EBSILON®Professional Online Dokumentation
EbsScript ist eine eingebettete Skriptsprache innerhalb von EBSILON Professional, die Ihnen Zugang zu EBSILON Eingabe-, Ausgabe- und Berechnungsfunktionen gibt, und diese mit Ihrem Code zu kombinieren:
Es gibt 6 Situationen, in denen EbsScript verwendet werden kann:
Dieses Kapitel soll für jene einen kurzen Überblick über EbsScript vermitteln, die bereits mit anderen Programmiersprachen, und Programmierung im Allgemeinen, vertraut sind. Es gibt einen Überblick über die EbsScript Syntax, einzelne Code-Stücke gängiger Aufgaben, und Tipps zur Fehlerbehebung. Mehr Details über die Nutzung von EbsScript stehen in der EBSILON Hilfedatei im Kapitel EbsScript zu Verfügung. In diesem Kapitel werden auch die drei wichtigsten Teile der EbsScript-Instrumente (Editor, Explorer und Executor) beschrieben.
EbsScript Syntax EbsScript Operatoren EbsScript Decision Making Statements EbsScript Schleifen Statements
Gültigkeitsbereich von Variablen in EbsScript EbsScript Arrays EbsScript Debuggen EbsScript Interface Units EbsScript Beispiele
Die EbsScript Syntax basiert auf der Programmiersprache PASCAL, und einigen Erweiterungen. Auf einem höheren Level bedeutet dies:
myrealvar := 1.2 ;
const PI = 3.14159;
{* Dies ist ein mehrzeiliger Kommentar in EbsScript. *}
{Dies ist ein einzeiliger Kommentar in EbsScript}
// Dies ist ein einzeiliger Kommentar in EbsScript
Kommentare werden im EbsScript-Editor mit grauer Schrift gekennzeichnet.
var
val1, val2 :real;
offset : integer;
name : string;
flag : boolean;
pipe : ebsPipe ;
cmp : ebsComp ;
xsqrd := pow(x,2) ;
Neben den oben genannten Regeln, sind auch noch folgende Punkte wichtig:
Die Statements in EbsScript verwenden spezielle "PASCAL"-Ausdrücke (bzw. Eigenschaften von "Delphi"), die Reserved oder Keywords genannt werden. Zum Beispiel sind die Wörter while, do, var, real, begin und end Reserved bzw. Keywords. Sie können diese Wörter nicht als Namen für Ihre Variablen, Funktionen oder Prozeduren verwenden. Die nachstehende Tabelle zeigt die Reserved und Keywords in EbsScript:
|
A |
||||
|
abstract |
add |
addr |
and |
append |
|
array |
autodispatch |
autosafearray |
autounknown |
|
|
B |
||||
|
begin |
bitand |
bitnot |
bitor |
bitwiseand |
|
bitwiseor |
bitwisexor |
bitxor |
boolean |
break |
|
C |
||||
|
callback |
capacity |
case |
char |
class |
|
comnullptr |
const |
constructor |
continue |
copy |
|
copymem |
||||
|
D |
||||
|
dec |
default |
destructor |
dispatchcall |
dispose |
|
div |
divide |
do |
downto |
|
|
E |
||||
|
else |
end |
enumstrings |
enumtostring |
equal |
|
except |
explicit |
|||
|
F |
||||
|
false |
finalization |
finally |
for |
forward |
|
freemem |
function |
|||
|
G |
||||
|
getmem |
greaterthan |
greaterthan |
||
|
H |
||||
|
high |
||||
|
I |
||||
|
if |
implementation |
implicit |
in |
inc |
|
index |
inherited |
initialization |
insert |
internal |
|
intdivide |
integer |
interface |
||
|
L |
||||
|
leftshift |
length |
lessthan |
lessthanorequal |
logicaland |
|
logicalnot |
logicalor |
logicalxor |
low |
|
|
M |
||||
|
mod |
modulus |
multiply |
||
|
N |
||||
|
negative |
new |
nil |
not |
notequal |
|
O |
||||
|
of |
on |
operator |
or |
otherwise |
|
overload |
override |
|||
|
P |
||||
|
pointer |
positive |
|
println |
private |
|
procedure |
program |
property |
protected |
public |
|
R |
||||
|
raise |
read |
real |
record |
reintroduce |
|
remove |
repeat |
reserve |
return |
rightshift |
|
round |
||||
|
S |
||||
|
self |
setlength |
setlow |
shl |
shr |
|
sizeof |
sliceleft |
slicemid |
sliceright |
smartptr |
|
static |
step |
string |
subtract |
|
|
T |
||||
|
then |
to |
true |
trunc |
try |
|
type |
typeof |
|||
|
U |
||||
|
unit |
unittest |
until |
uses |
|
|
V |
||||
|
var |
virtual |
|||
|
W |
||||
|
while |
write |
|||
Diese Wörter werden im EbsScript-Editor in blauer Schrift angezeigt.
Ein "Identifikator" bezeichnet in einem Programm ein Objekt (z.B. einen Datentyp, eine Variable oder eine Funktion), welches er eindeutig benennt.
Daher muss der Bezeichner innerhalb eines Namensraumes eindeutig sein. In der Regel wird für Bezeichner die Kombination einer Zeichenfolge aus Buchstaben und Ziffern verwendet.
|
Operator |
Description |
|
+ |
Addiert zwei Operatoren |
|
- |
Subtrahiert den zweiten Operator vom ersten |
|
* |
Multipliziert beide Operatoren |
|
div |
Integer Division |
|
mod |
Modulus Operator UND Rest nach einer ganzzahligen Division |
|
/ |
Floating Point (Real) Division |
|
Potenzierung |
pow(base, exponent) |
|
Operator |
Description |
|
= |
Überprüft ob die Werte von zwei Operatoren gleich sind oder nicht, wenn ja, dann wird die Bedingung wahr. |
|
<> |
Überprüft ob die Werte von zwei Operatoren gleich sind oder nicht, wenn die Werte nicht gleich sind, dann wird die Bedingung wahr. |
|
> |
Überprüft ob der Werte des linken Operators größer ist als der des rechten Operators, wenn ja, wird die Bedingung wahr. |
|
< |
Überprüft ob der Werte des linken Operators kleiner ist als der des rechten Operators, wenn ja, wird die Bedingung wahr. |
|
>= |
Überprüft ob der Werte des linken Operators größer oder gleich ist als der des rechten Operators, wenn ja, wird die Bedingung wahr. |
|
<= |
Überprüft ob der Werte des linken Operators kleiner oder gleich ist als der des rechten Operators, wenn ja, wird die Bedingung wahr. |
|
Operator |
Description |
|
and |
Boolean AND Operator. Wenn beide Operatoren wahr sind, dann wird die Bedingung wahr. |
|
and then |
Ähnlich wie der AND Operator, jedoch garantiert er die Reihenfolge, in der der Compiler den logischen Ausdrucke auswertet. Von links nach rechts, und die rechten Operatoren werden nur dann ausgewertet, wenn notwendig. |
|
or |
Boolean OR Operator. Wenn einer der Operatoren wahr ist, dann wird die Bedingung wahr. |
|
or else |
Ähnlich wie der OR Operator, jedoch garantiert er die Reihenfolge, in der der Compiler den logischen Ausdruck auswertet. Von links nach rechts, und die rechten Operatoren werden nur dann ausgewertet, wenn notwendig. |
|
not |
Boolean NOT Operator wird verwendet, um den logischen Status des Operators umzukehren. Wenn eine Bedingung wahr ist, dann ändert der NOT Operator die Bedingung auf falsch. |
Wenn die Bedingung wahr ist, dann wird der Code innerhalb der if-Anweisung ausgeführt. Wenn die Bedingung falsch ist, dann wird der Code nach dem schließenden „end“ ausgeführt.
if str <> "" then begin
str := StringTrimLeft(str);
str := stringLower(str) ;
end;
EbsScript betrachtet alle Nicht-Null oder vorhandenen Werte als wahr. Werte von Null oder leere Wertezellen werden als falsch behandelt.
Wenn die Bedingung wahr ist, dann wird der if ... then Block des Codes ausgeführt, sonst der else-Block. Zum Beispiel:
if str <> "" then begin
str := StringTrimLeft(str);
str := stringLower(str) ;
end
else begin
UserInput := "" ;
end;
Die Syntax des case-statements lautet wie folgt:
case (expression) of
L1 : S1;
L2: S2;
...
Ln: Sn;
otherwise: Sotherwise; or else: Selse
end;
L1, L2, ….. Ln sind case-lables oder Eingabewerte und können vom Typ Integer, Boolean oder Aufzählungsvariable sein. S1, S2, …. Sn sind EbsScript-Statements, die jeweils mit einem oder mehreren case-lables verbunden sein können. Der Ausdruck wird case-selector oder case-index genannt. Der case-index kann Werte annehmen, die dem case-statement entsprechen. Das case-statement ist immer mit einem end-statement verbunden. Die folgenden Regeln gelten für ein case-statement:
Zum Beispiel:
case MacroInterface.LoadMethod of
0 : Programmable.SPEC3 := 0 ;
1 : Programmable.SPEC3 := 2 ;
2 : Programmable.SPEC3 := 1 ;
otherwise Programmable.SPEC3 := MacroInterface.LoadMethod ;
end;
Der Typ bei case of kann auch ein String sein. Dann müssen die einzelnen Ansprungstellen Stringkonstanten sein:
procedure foo(s:string);
begin
case s of "Hallo" : begin
// ...
end;
"Welt" : begin
// ...
end
otherwise begin
// ...
end
end;
end;
Der Vergleich findet IMMER Case-Sensitiv statt (Groß/Kleinschreibung wird unterschieden).
Weiterhin können als Ansprungstellen ganze Bereiche angegeben werden.
5 .. 10 : // alle Werte größer gleich 5 und kleiner gleich 10
.. 2 : // alle Werte kleiner gleich 2
15 .. : // alle Werte größer gleich 15
procedure bar(value:integer); begin
case value of ..-10 : begin
println("<= -10");
end;
20.. : begin
println("=> 20");
end;
5..8 : begin
println("5 <= .. <= 8");
end;
4 : begin
println("== 4");
end;
0 : begin
println("== 0");
end
otherwise begin
println("something else");
end
end;
end;
Bei Strings wird hierbei die lexikographische Ordnung verwendet.
Eine while-do Schleife erlaubt es, sich wiederholende Berechnungen durchzuführen, bis die gewünschte Bedingung erfüllt ist. Die Syntax einer while-do Schleife sieht wie folgt aus:
while (condition) do S;
Dabei ist die Bedingung ein Boolean oder ein relationaler Ausdruck, dessen Wert richtig oder falsch ist, und S ist ein Ausdruck oder eine Gruppe von Ausdrücken, innerhalb des "begin …… end" Blocks.
while number > 0 do
begin
sum := sum + number;
number := number - 1;
end;
Wenn der Ausdruck falsch wird, steuert der Code sofort den nächsten Ausdruck nach dem end-Statement an.
Eine for ... do Schleife ist eine effiziente Art, um eine Schleife zu programmieren, die eine bestimmte Anzahl von Wiederholungen durchlaufen soll.
for < loop-variable-name > := < initial_value > to [downto] < final_value > do S;
Der "loop-variable-name" spezifiziert eine Variable von Ordinaltyp, und wird Regelgröße oder Index-Variable genannt. „initial_value“ und „final_value“ sind Werte, die die Regelgröße verwenden kann. S ist eine Anweisung, oder eine Gruppe von Anweisungen, in der for ... do Schleife. Zum Beispiel:
for i:=1 to n do
begin
MacroInterface.ERRARRAY.x[i] := Programmable.RA_2.x[i];
MacroInterface.ERRARRAY.y[i] := Programmable.RA_2.y[i];
end;
Dies ist ein Beispiel, wie der Ablauf in einer for ... do Schleife funktioniert:
Die repeat ... until Schleife ist ähnlich einer While-Schleife, mit der Ausnahme, dass sie mindestens einmal ausgeführt wird. Die Syntax für eine repeat ... until Schleife sieht wie folgt aus:
repeat
S1;
S2;
...
Sn;
until condition;
For example:
repeat
sum := sum + number;
number := number - 1;
until number = 0;
Beachten Sie, dass die Bedingung erst am Ende der Schleife gesetzt wird, und der Ausdruck der Schleife somit einmal ausgeführt wird, bevor die Bedingung geprüft wird. Ist die Bedingung erfüllt, beginnt der Ablauf von vorne. Dieser Vorgang wiederholt sich, bis die vorgegebene Bedingung falsch ist.
Das break-statement findet in EbsScript folgende Anwendung:
Das continue-statement in EbsScript arbeitet umgekehrt. Anstatt die Ausführung zu beenden, wird die nächste Iteration gestartet und der verbleibende Code übersprungen. Wenn Continue in einer for ... do Schleife angewandt wird, dann wird die Bedingungsüberprüfung und die Erhöhung oder Verringerung der Schleifenvariable durchgeführt.
Eine Funktion in EbsScript besteht aus einem Kopfteil, lokalen Deklarationen und dem Funktionshauptteil. Der Funktionskopf besteht aus der Schlüsselwortfunktion und einem Funktionsnamen. Folgend werden die Teile einer Funktionsdeklaration dargestellt:
Argumente: Die Argumente stellen die Verbindung zwischen den rufenden Programmen und den Funktionskennungen her, und werden auch formale Parameter genannt.
Rückgabetypen: Alle Funktionen müssen einen Wert zurückgeben und alle Funktionen müssen einem Typ zugeordnet sein. Der Funktionstyp ist der Datentyp des Werts, den die Funktion zurückgibt. Dies kann ein Standard-Typ sein, benutzerdefiniert Skalar oder Subrange-Typ, aber es kann kein strukturierter Typ sein.
Lokale Deklarationen: Lokale Deklarationen beziehen sich auf Deklarationen für Lables, Konstanten, Variablen, Funktionen und Prozeduren, die nur für den Körper der Funktion anwendbar sind.
Funktionskörper: Der Funktionskörper enthält eine Sammlung von Anweisungen, die definieren, was die Funktion tut. Diese sollen immer zwischen den reservierten Ausdrücken "begin ….. end" stehen. Der Funktionskörper ist der Teil einer Funktion, in dem alle Berechnungen durchgeführt werden. Im Funktionskörper muss eine Zuweisung des Typs "function_name := expression;" erfolgen, die der Funktion einen Wert zuordnet. Dieser Wert wird zurückgegeben, wenn die Funktion ausgeführt wird. Die letzte Anweisung im Körper lautet „end“. Um eine Funktion aufzurufen, müssen Sie einfach die gewünschten Parameter zusammen mit dem Funktionsnamen übergeben. Wenn die Funktion einen Wert zurückgibt, dann können Sie diesen einer Variable zuweisen und speichern. Zum Beispiel:
function test (a, b: Integer ; c: real) : real;
begin
test:= (a+b)*c;
end;
begin
println ( test(2, 5, 7.1));
end;
Beachten Sie auch den Strichpunkt nach dem letzten end-statement.
Der Gültigkeitsbereich in jeder Programmierung ist der Bereich oder Teil des Programms, in dem eine definierte Variable existiert. Außerhalb dieses Bereichs kann auf die Variablen nicht zugegriffen werden. Es gibt drei Bereiche, an denen Variablen in EbsScript deklariert werden können.
Lokale Variablen
Variablen, die innerhalb einer Funktion / Prozedur oder einem Codeblock deklariert werden, werden lokale Variablen genannt. Diese Variablen werden nicht von Funktionen / Prozeduren oder Codestücken außerhalb der eigenen Funktion erkannt.
Globale Variablen
Globale Variablen werden außerhalb von Funktionen definiert, meist am Beginn des Skripts. Die globalen Variablen halten ihren Wert während der gesamten Laufzeit des Skripts, und können von jeder Funktion im Skript aufgerufen werden.
Mehr Informationen zum Umfang von Variablen finden Sie unter den Free Pascal language reference.
EbsScript stellt eine Datenstruktur zu Verfügung, die Array genannt wird. Dieses kann eine sequentielle Auflistung von Elementen des gleichen Typs und fester Größe, speichern. Ein Array wird verwendet, um eine Sammlung von Variablen des gleichen Typs zu speichern. An Stelle der Deklaration einzelner Variablen, wie number1, number2, … und number100, wird eine Array Variable „number“ deklariert und verwendet, um individuelle Variablen mit numbers[1], numbers[2], … und numbers[100] abzubilden. Einzelne Elemente in einem Array werden durch einen Index abgerufen. Alle Arrays bestehen aus zusammenhängenden Speicherplätzen. Die niedrigste Adresse entspricht dem ersten Element, und die höchste Adresse dem letzten Element. Wenn Sie ein C-Style Array vom Index 0 starten möchten beachten Sie, dass Sie den Index anstelle von 1 nur von 0 beginnen lassen müssen.
Die allgemeine Form der Typendeklaration von eindimensionalen Arrays ist:
type array-identifier = array[index-type] of element-type;
Wobei:
array-identifier, gibt den Namen des Array-Typs an.
index-Typ, gibt den Index des Arrays an, es kann ein beliebiger skalarer Datentyp außer Real sein
element-Typ, gibt die Art von Werten die gespeichert werden, an
Zum Beispiel:
type
vector = array [ 1..25] of real;
var
velocity: vector;
Die Geschwindigkeit ein Variablen Array des Typs Vektor, und ist in der Lage bis zu 25 reelle Zahlen zu speichern. Um das Array von Index 0 zu starten, muss die Deklaration wie folgt lauten:
type
vector = array [ 0..24] of real;
var
velocity: vector;
Typen von Array-Indizes
In EbsScript kann ein Array-Index von skalarem Typ ein Integer, Boolean, Char oder Subrange-Typ sein. Real ist nicht zulässig. Array-Indizes können auch negative Werte haben, wie zum Beispiel:
type
temperature = array [-10 .. 50] of real;
var
day_temp, night_temp: temperature;
Zum Schluss ein Beispiel in dem der Index vom Typ Char ist:
type
ch_array = array[char] of 1..26;
var
alphabet: ch_array;
c: char;
begin
...
for c:= 'A' to 'Z' do
alphabet[c] :=
Ein Element wird durch die Indizierung des Array-Namens abgerufen. Dies geschieht durch die Anordnung des Index innerhalb der eckigen Klammern, nach dem Array Namen. Zum Beispiel:
a: integer;
a: = alphabet['A'];
a:= numbers[10];
uses @KernelScripting
Da das Kernel Scripting in den Solver für das Gesamtgleichungssystem eingebettet ist, können Sie es nicht im Editor debuggen. Alle Debugging-Funktionen im EbsScript-Editor werden deaktiviert, wenn Sie ein Kernel Script bearbeiten. Um diese Einschränkung zu umgehen, können Zwischenergebnisse mit dem Befehl print(ln) ausgegeben werden.
println("FCTRLMODE =", ::Control.FCTRLMODE);
Zeigen Sie die Ergebnisse in der the EbsKern-Output tool bar. Um diese anzuzeigen, folgen Sie den nächsten Punkten:
1. Wählen Sie die Symbolleiste > aus dem View Pulldown-Menü.
2. Wählen Sie EbsKern-Output aus dem Untermenü, um das EbsKern-Output Fenster zu öffnen (siehe nächste Abbildung):
In der EbsKernel-Ausgabezeile wird für jede, im Modell befindliche Komponente 93, ein Blatt (tab) erstellt, und das Modell, gemeinsam mit einem kompletten Blatt (tab) für alle Ausgaben, ausgeführt.
Wenn Ihr Skript-Code kein Kernel-Scripting verwendet, dann können Sie Ihren Code debuggen, während ein EbsScript läuft. Debugging macht es möglich, die Ausführung des Skripts zu unterbrechen, und die Werte von Variablen anzuzeigen und zu ändern. Der EbsScript-Debugger ist unter dem Menüpunkt Debug zu finden.
Um zu debuggen, müssen Breakpoints im EbsScript-Fenster gesetzt werden. Bewegen Sie hierzu den Cursor auf die gewünschte Zeile im Skript und drücken Sie F9 („Switch breakpoint“). Ein weiterer Klick auf F9 entfernt den Breakpoint.
Das Skript kann dann mit der Taste "F5" gestartet werden (Start / Continue) und wird bis zum ersten gesetzten Breakpoint ausgeführt. Es ist möglich, die Werte der Variablen in der Monitor-Leiste (im EbsScript-Editor unter View > Toolbars > Console) anzusehen und zu ändern.
Sie können das Skript, durch Drücken der Taste "F10" (über nächste Prozedur hinweg) und "F11" (in Prozeduren), weiter Schritt für Schritt, oder durch "F5" bis zum nächsten Breakpoint, ausführen. Das Debugging Fenster wird in der nächsten Abbildung dargestellt.
Beachten Sie, dass Sie den Debugger auch in einigen Kernel-Skripts verwenden können, indem Sie den Inhalt des Kernel-Skripts in ein externes Skript kopieren. Dabei ist aber vorausgesetzt, dass dieses nicht auf Strom- oder Komponentendaten mittels Funktionen wie "ksGetPipeValue" zugreift. Um die Variablennamen des Modells richtig zu interpretieren, muss das externe Skript im gleichen Kontext ausgeführt werden (z. B.: auf Modellebene, standard gemäß mit Global bezeichnet, oder innerhalb des jeweiligen Makroobjekts, welche das Kernel Skript enthält, im obigen Beispiel mit „Control“ bezeichnet). Sie können den entsprechenden Kontext aus dem Dropdown-Menü im EbsScript-Menü (in der Abbildung oben rot eingekreist) auswählen.
Wenn Ihr Kernel Skript auf Strom- oder Komponentendaten zugreift, dann ist die Verwendung der println-Anweisung und des EbsKern-Output Fensters die einzige derzeit verfügbare Debugging Möglichkeit.
uses @KernelScripting;
Das „@“ vor dem Einheitennamen dient als Identifikation für eine Interface Unit. EBSILON Professional bietet die folgenden Interface Units:
KernalScripting
Fluid
Variant
Units
Covariance
System
Epos
KernelExpression
MacroHelpers
TimeSeries
NNTool
Standard
Debug
Durch öffnen des EbsScript-Editor können Sie sehen, welche Funktionen diese Interface Units zu Verfügung stellen. Wählen Sie hierbei den Punkt „Interface-Unit öffnen“ im EbsScript Pulldown Menü der Menüleiste aus. Beachten Sie, dass einige Interface Units wie NNTool zusätzliche Lizenzierungen benötigen können.
In Pascal ist es auch möglich, individuelle Custom-Units zu definieren, die von jedem Skript verwendet werden können.
Unten ist ein Beispiel für eine solche Custom-Unit dargestellt:
unit EngineCalcs;
interface
procedure EnginePreProcessing;
procedure EnginePostProcessing;
procedure DoMyCalculations( par1:real; var retval1:real, var retval2:real);
implementation
uses @kernelscripting,@fluid;
procedure AddMessage( MessageNumber:integer; MessageMessage: string);
var len:integer;
begin
//::StatusText.text:=printToString( ::StatusText.text, "\n",MessageMessage );
len:=MacroInterface.Messages.getSize+1;
MacroInterface.Messages.size:=len;
MacroInterface.Messages.x[ len ]:= MessageNumber;
end;
procedure EnginePreProcessing;
var i,j:integer;
x,y:real;
begin
…
…
…
end;
procedure EnginePostProcessing;
var i,j:integer;
x,y:real;
begin
…
…
…
end;
procedure DoMyCalculations( par1:real; var retval1:real, var retval2:real);
var i,j:integer;
x,y:real;
begin
…
…
…
retval1 := …;
retval2 := …;
end;
end.
Anwendungsbeispiele:
Aus einem Makro im „Skript vor der Berechnung“
uses EngineCalcs;
begin
EnginePreProcessing;
end;
Von jeder Komponente 93 oder „Kernel Expression“ (= spezielle Eingabefelder in Komponenten):
uses EngineCalcs;
var p1, r1,r2;
begin
p1:= sqrt(23);
DoMyCalculations(p1,t1,r2);
…
…
end;
Die folgenden Beispiele zeigen einige gängige Anwendungen, die mit EbsScript umgesetzt werden können.
Simulationen unter verschiedenen Profilen in einem Modell laufen lassen:
var
i: integer;
begin
for i:=1 to 10 do
begin
setCalcProfileByName(“first_profile_name”);
simulate ;
setCalcProfileByName(“second_profile_name”);
simulate ;
end;
end;
Einheitenumrechnung – Druck in psia
Sie können gegebenenfalls direkt mittels EbsScript auf die Modellgrößen zugreifen. Beachten Sie, dass die Modellgrößen intern mit SI-Einheiten abgespeichert werden. Die verwendeten UOM´s (Unit of Measure) lauten wie folgt:
Daher bedeutet eine direkte Zuordnung wie
Turbine.M1N := 100;
immer 100kg/s. EbsScript bietet die Interface-Unit „Units“ die es erlaubt Einheitenumrechnungen in Ihrem Skript-Code durchzuführen. Das folgende Beispiel wandelt den Druck von bar in psia um:
uses @Units
unitsConvert(comp122.P1, “BAR”, myPinPsia, “PSIA”) ;
Der folgende Link öffnet eine Liste aller verfügbaren Maßeinheiten in EBSILON:
Einstellen von Spezifikationswerten mit EbsScript
Um einen Spezifikationswert mit EbsScript zu setzten, fügen Sie eine Funktion, die den gewünschten Spezifikationswert berechnet, im Spezifikationseingabefeld ein. Zum Beispiel:
function evalexpr:REAL;
var
begin
// TODO: calculate specification value
evalexpr:= calc_result
end;
Durchführung einer Eigenschaftsberechnung
Sie können in EbsScript jede Eigenschaftsberechnung für alle EBSILON Eigenschaften durchführen. Als Beispiel berechnen Sie die Enthalpie aus Druck P und Temperatur T:
uses @fluid;
var
Pres,Temp,rResult:real;
iphase:PhaseEnum;
begin
Pres:=1.013;
Temp:=20.0;
fluidTableWST( rResult, iPhase, Pres, Temp, FuncH_OF_PT);
println (rResult);
end;
Der folgende Abschnitt des Codes kann angenehmer sein, wenn der Benutzer einen Strom-Typ zu Verfügung hat, auf den er sich beziehen kann:
begin
fluidTableObject( {var rResult:Real}, {var phase:PhaseEnum}, {arg1:Real}, {arg2:Real}, {func:FuncEnum}, {obj:ebsData} );
end;
Der letzte Parameter (obj:ebsData) repräsentiert einen Strom, entweder durch den Namen aus dem Flowsheet, oder durch Bezugnahme auf einen Port (Zum Beispiel: ‚componentname._2‘ für den an Port 2 angeschlossenen Strom).
Nachstehend ist ein Screenshot der verfügbaren Funktionen der Interface-Unit für Fluid dargestellt:
Unter dem folgenden Link ist eine Auflistung der verfügbaren Eigenschaftsfunktionen dargestellt, auf die von EbsScript aus zugegriffen werden kann: EbsScript Berechnungsfunktionen
Auf P, H und M eines Ports einer Komponente zugreifen
uses @kernelscripting;
var
m14,h14,p14:real;
begin
m14:=ksGetPipeValue(14,PhysValueM);
h14:=ksGetPipeValue(14,PhysValueH);
p14:=ksGetPipeValue(14,PhysValueP);
end;
Überprüfen Sie, ob ein bestimmter Port (Port 7) an einem Makro Objekt verbunden ist, und die Upstream-Komponente übergeben wird:
uses @MacroHelpers
var
txt : string;
ThisMacro : ebsMacro ;
pipe : ebsPipe ;
cmp : ebsComp ;
ThisMacro := getContainerMacro(MacroInterface); // Check if logic line is connected
if isNull(getPipeAtLink(ThisMacro,7)) then
begin
txt := ThisMacro.name + " fuel logic line at Pin 7 not connected." ;
MessageBox(txt)
exit(-1, txt); // terminate the run and set error message to txt
end;
// There's a logic line at Pin 7. Get it.
pipe := getPipeAtLink(ThisMacro,7) ; // Check if it's connected to a pipe
if isNull(GetPipeAtLogpipe(pipe, 1)) then
begin
txt := ThisMacro.name + " logic line at Pin 7 not connected to a pipe." ;
MessageBox(txt);
exit(-1, txt); // terminate the run
end;
// It's connected to a pipe. Get it.
pipe := GetPipeAtLogpipe(pipe, 1) ;
// Get component at upstream end of that pipe
cmp := GetCompAtPipe(pipe, 1) ;
Code Aufruf in einem COM Objekt
callEbsScriptServer( {class:string}, {var var1:(array of) primitive type}, {var var2:(array of) primitive type}{, callBackProc:callback procedure = nil} );
Beispiel dazu unter Block 750.ebs