Deklaration von Variablen
Alle in einem Modell vorkommenden Variablen werden im Formular Deklaration mit begin declaration eingeleitet und mit end declaration beendet.
Die Deklaration des Gleichungssystems, das im Artikel zur Modellbeschreibungssprache PML gezeigt wird, sieht zum Beispiel wie folgt aus:
begin declaration
State area;
Linear PinNumber lP_max_solar [kW];
Linear PinNumber lP_nom [kW];
PinNumber Irradiance_global_inclined ~ 10000[W/m^2];
PinNumber P_max_solar ~ 20 [kW];
PinNumber T_amb ~ 293 [K];
PinNumber P_nom [kW];
//USEFUL Abbreviations:
//*** NOCT: Nominal Operation Cell Temperature
//*** STC: Standard Test Conditions
//**********************//
//*** Technical Data ***//
//**********************//
//Collector Area
Number Area_collector („/Local/eProc/bndl:PhotovoltaicData/nb:Area“)~ 10[m^2];
Option opt_PeakPower („/Local/eProc/bndl:PhotovoltaicData/opt:TotalPeak_or_perModule“) ;
Number AreaPerModule(„/Local/eProc/bndl:PhotovoltaicData/nb:AreaPerModule“) ~ 2[m^2] ;
Number NumberOfModules(„/Local/eProc/bndl:PhotovoltaicData/nb:NumberOfModules“) ~ 2[] ;
Number PerformanceRatio („/Local/eProc/bndl:PhotovoltaicData/nb:PerformanceRatio“) ~ 0.75;
Number T_cell („/Local/eProc/bndl:PhotovoltaicData/nb:CellTemperature“) ~ 293[K];
Number FinalYield („/Local/eProc/bndl:PhotovoltaicData/nb:FinalYield“) ~ 1[];
//Current on Maximume Power Point MPP
Number peak_Facility(„/Local/eProc/bndl:PhotovoltaicData/nb:PeakFacility“) ~ 20[W];
Number peak_Facility_perModule(„/Local/eProc/bndl:PhotovoltaicData/nb:PeakFacility_perModule“) ~ 20[W];
//Current on Power Operating Conditions
Number El_Facility_nom („/Local/eProc/bndl:PhotovoltaicData/nb:PowerFacility“) ~ 20[W];
//Performance Ratio
//Standard test condition efficiency
//Number eta_stc („/Local/eProc/bndl:SolarCollectorData/misc:EffStd“) ~ 10[%];
//Power temp coeff
Number Temp_Coefficient („/Local/eProc/bndl:PhotovoltaicData/nb:TemperatureCoefficient“) ~ 1[%/K];
//Option Reference Values
Option opt_NOCT („/Local/eProc/bndl:PhotovoltaicData/opt:NOCT“);
//Temperatur korrektur because of array mount type
Number Delta_T_cell_installed_NOCT_correction ~ 2[K];
//*******************************************//
//**** Photovoltaic specific parameters *****//
//*******************************************//
//Power on Maximume Power Point MPP
Number PMPP ~ 50[W];
//PV_cell_Temperatur NOCT normal test conditions
Number T_cell_NOCT („/Local/eProc/bndl:PhotovoltaicData/nb:NominalCellTemperature_NOCT“) ~ 293[K];
//Temperature of cell by normal test conditions at installed conditions
Number T_cell_installed_NOCT ~ 293[K];
//PV_cell_Temperatur standard test conditions
Number T_cell_STC ~ 293[K];
// air test conditions temperature
Number T_amb_NOCT ~ 293.15[K];
//Standard Test Conditions (1000 W/m² irradiance)
Number Irradiance_STC ~ 1367[W/m^2];
Number Irradiance_NOCT ~ 800[W/m^2];
end declaration
In der Deklaration werden alle Variablen, die in dem Komponentenmodell Verwendung finden, beschrieben.
Dabei wird jeder zu deklarierenden Variablen nach folgender Syntax mindestens der Variablentyp (Number, Bool, Option, Zeitreihe oder andere) zugeordnet.
Variablentyp Variablenname [Variableneinheit];
Beispiel: einfache Variablendeklaration
begin declaration
Number x_O2;
Number P_demand [kW];
end declaration
Um Variablen mit der Benutzeroberfläche zu verbinden, müssen diese mit einem Primitiv verknüpft werden. Dies ist notwendig, damit die Variablen in der Formularansicht angezeigt und editiert werden können.
Primitive
Primitive sind Datenelemente in TOP-Energy, die in Formularen unter Bezeichnern sichtbar und editierbar sind und in Projekten gespeichert werden.
Die Syntax für die Verknüpfung der Variablen mit dem Primitiv lautet:
Variablentyp Variablenname (Primitivenpfad) [Variableneinheit];
Startwert für algebraische Variablen
Für numerische Verfahren sollten algebraische Variablen mit einem physikalisch sinnvollen Startwert versehen werden, der in der Größenordnung einer möglichen Lösung liegt, zum Beispiel 293,15 [K] für eine Kühlwassertemperatur. Der Startwert einer algebraischen Variable wird mit einer Tilde (~) und der Zahl mit Einheit abgebildet:
Variablentyp Variablenname (Primitivenpfad) ~ Startwert [Variableneinheit];
Geben Sie keinen Startwert vor, wird standardmäßig 0.5 [Variableneinheit] verwendet.
Ungünstige Startwerte können, insbesondere bei Verwendung der Variablen zur Berechnung von Stoffwerten, zu der Fehlermeldung 8327 führen.
Die Angabe des Startwertes ist nicht mit der Initialisierung von Anfangswerten zu verwechseln.
Beispiele
Number Area_collector („/Local/eProc/bndl:PhotovoltaicData/nb:Area“)~ 10[m^2];
In dem step-Abschnitt der Energiesicht sehen die Gleichungen wie folgt aus:
begin step
Q_dot_prod = Q_dot_radiation + Q_dot_nutz;
Q_dot_radiation = q_radiation_rel * Q_dot_nenn;
end step
Eine Deklaration der oben aufgestellten Gleichungen sieht wie folgt aus:
begin declaration
Number Q_dot_prod ~ 1000 [kW];
Number Q_dot_Radiation („/Local/eSim/Pfad zum Primitiv“) ~ 20 [kW];
Number Q_dot_usable („/Local/eSim/Pfad zum Primitiv“) ~ 1000 [kW];
Number q_Radiation_rel („/Local/eSim/Pfad zum Primitiv“) ~ 1 [%];
end step
Variablentypen
Der Variablentyp wird in der PML als Deklaration vergeben. Meistens entspricht der Variablentyp dem Datentyp (dem Datenmodell/Primitiv). In der PML wird z. B. für eine Number-Variable ein Number-Datenprimitiv verwendet, aber ein Number-Datenprimitiv kann mit den Variablentypen Number, Linear Number und Steady Number verknüpft werden.
Kontinuierliche Variable mit Einheit (Number)
Number entspricht einer Zahl oder Zeitreihe mit Einheit. Diese Einheit wird entweder bei der Deklaration explizit angegeben oder sie ergibt sich aus dem Primitiv, mit dem die Variable verknüpft ist. Ein Numberprimitiv kann als Number, Linear Number und als Steady Number angegeben werden.
Einfache Number-Primitive werden als algebraische Variablen verwendet und können als Koeffizienten in die Optimierung eingehen oder weitere Ergebnisvariablen darstellen. Linear Number Variablen sind Designvariablen (Optimierungsvariablen), welche in der Optimierung so verändert werden, dass die Kostenfunktion minimiert wird.
Entsprechend den Gleichungstypen algebraisch und linear gibt es zwei Variablentypen.
| Algebraisch (gewöhnlich) | Linear (Entscheidungsvariablen des MILP) |
|---|---|
| Number P_pos[kW]; Binary bP_neg; | Linear Number lP_pos[kW]; Linear Binary lbP_neg;4 |
| p * v = n * R * (T - 0['K]); 0[kW]=Q_dot + H_dot_in + H_dot_out; | target.Operation P_el * price_el; 0[kW]==lQ_dot + lH_dot_in + lH_dot_out; |
Variablen vom Typ Steady Number sind Designvariablen, welche in jedem Zeitschritt der Simulation denselben Wert annehmen, wie z. B. die Nennleistung einer Anlage. Sie werden für die Strukturoptimierung genutzt. Sobald eine Steady Number in der Deklaration gelesen wird, wird automatisch eine Strukturoptimierung durchgeführt.
begin declaration
Steady Number lQ_dot_heat_nom [kW];
Linear Number lQ_dot_heat_nom [kW];
Number m_dot ~2[kg/s]; // Zahl mit Einheit und Startwert
Number m_dot („/Global/Allgemein/…“); // Verknüpfung zu Primitiv
Number m_dot („/Global/Allgemein/…“) ~ 2 [kg/s]; /* Verknüpfung zu Primitiv mit Startwert und Einheit (empfohlen) */
Number m_dot; // Zahl ohne Einheit
end declaration
Binär-Variablen (Binary)
Binärvariablen können den Wert 1 oder 0 annehmen. Sie können als algebraische Variablen (Binary) oder als Optimierungsvariablen (Linear Binary) verwendet werden. Ein algebraisches Binary wird typischerweise in Checkboxen verwendet, z. B. für die Funktion Modulieren unter Minimaler Teillast. Eine Typische Verwendung von linear optimierbaren Binärvariablen ist bIsOn, eine Variable, die über den An- oder Aus-Zustand einer Anlage entscheidet.
Kennlinie Char1D
Der Typ Char1D wird in den Klassenfunktionen getYFromX und getXFromY verwendet. Dort ist der Variablentyp erklärt.
Beispiel Kompressionskältemaschine
Char1D CharDiagram_Refrig_Electricity(„/Local/eProc/stdDesignChill:Characteristic_El_Q_dot_cool“);
Abfrage von Werten über Kennlinienfunktionen
P_el / P_el_max = – CharDiagram_Refrig_Electricity.getYFromX(OP);
Verknüpfung von zwei linearen Variablen des MILP
CharDiagram_Refrig_Electricity.generatePiecewiseAbs(lQ_dot_cool_rel, lP_el_rel);
Integralvariablen (Integral)
Integralvariablen können ebenfalls algebraisch (Integral) oder linear optimierbar (Linear Integral) verwendet werden. Sie werden z. B. zur Modellierung von Energiespeichern verwendet. In der init-Section wird der Anfangswert angegeben.
Ganze Zahlen (Integer)
Ganze Zahlen, die die Werte 0, 1, 2, 3… annehmen können, können in TOP-Energy im algebraischen Gleichungssystem (Integer) oder als linear optimierbare Variable (Linear Integer) verwendet werden.
Option (Auswahlfeld)
Ein Option-Primitiv kann verwendet werden, um aus einer vorher festgelegten Menge von Alternativen auszuwählen. Dem Primitiv werden die Auswahlmöglichkeiten in der Primitivendatenbank eingegeben. Über eine Verzweigung werden die alternativen Möglichkeiten als Zuweisungen aufgestellt.
Die Komponente Brennstoffversorger-gasförmig enthält z. B. die Option Variablenname.
Option FuelSelection(„/Local/eProc/stdResourceFuelGas:TypeOfNaturalGas“);
if (FuelSelection < 0.5)
x_CO2 := 0.008;
else if(FuelSelection > 0.5 && FuelSelection < 1.5)
x_CO2 := 0.01;
else
x_CO2 := x_CO2_Form;
end if
Die Option-Variable enthält als Wert den nullbasierten Index der Auswahl:
Wenn in der Option der zweite Eintrag gewählt ist, kann in der PML stehen:
begin case (Option == 1)
…
end case
oder:
if(Option==1)
…
end if
Auch das folgende Beispiel der Photovoltaik bezieht sich auf den 2. Eintrag der Option.
Die Bedingung (opt_PeakPower >= 0.5) zwischen begin und end case und bezieht sich auf den 2. Eintrag der Option, denn der erste Eintrag hat den Wert 0 und wäre damit <= 0.5 und der zweite Eintrag ist 1 und daher >=0.5.
State
Der Variablentyp State macht ein technisches Komponentenmodell (oder einen Prozessschritt) für die ein- und ausgehenden Pins zugänglich. Dazu wird eine Variable mit dem Typ State deklariert. Sie erhält den Namen des Pins, der zuvor im Pin-Editor erzeugt wurde, z. B. water_in oder water_out. Die Variable ist mit dem PropertyComponentReference-Primitivenpfad verknüpft, der beim Erstellen des Pins automatisch erzeugt wurde.
Beispiel: Verlinkung der Pins eines Heißwasserkessels mit den zugehörigen Primitiven
begin declaration
//**********************************//
//*** Property functions on Pins**//
//**********************************//
State water_in („/Local/eSim/eSim/eSimIf:PinProperties_water_in/eSim:PropertyComponentReference“);
State water_out („/Local/eSim/eSim/eSimIf:PinProperties_water_out/eSim:PropertyComponentReference“);
State air_in („/Local/eSim/eSim/eSimIf:PinProperties_air_in/eSim:PropertyComponentReference“);
State fuel_in („/Local/eSim/eSim/eSimIf:PinProperties_fuel_in/eSim:PropertyComponentReference“);
State fluegas_out („/Local/eSim/eSim/eSimIf:PinProperties_fluegas_out/eSim:PropertyComponentReference“);
end declaration
Im Beispiel oben stehen der Komponentenmodellierung durch den State-Variablentyp die energetischen Werte der zugeführten Stoffströme als Daten zur Verfügung. Danach kann beispielsweise in der Stoffsicht bestimmt werden, dass der eintretende Massenstrom an Wasser (water_in) genauso hoch wie der austretende Massenstrom (water_out) ist, wie im folgenden Beispiel zu sehen ist.
begin declaration
//**********************************//
//*** Property functions on Pins**//
//**********************************//
State water_in („/Local/eSim/eSim/eSimIf:PinProperties_water_in/eSim:PropertyComponentReference“);
State water_out („/Local/eSim/eSim/eSimIf:PinProperties_water_out/eSim:PropertyComponentReference“);
Number m_dot_in ~ 1[kg/s];
Number m_dot_out ~ -1[kg/s]; //Negativer Wert, da die Komponente verlassen wird
end declaration
begin step
m_dot_in = water_in.m_dot;
m_dot_out = water_out.m_dot;
water_in.m_dot + water_out.m_dot = 0[kg/s];
end step
So wie hier am Massenstrom gezeigt, werden alle energetischen Werte, die in den Stoffwertekomponenten berechnet werden, an technische Komponenten übermittelt.
DateTime
Variablen vom Typ DateTime werden zum Speichern von Zeitpunkten verwendet. Es wird empfohlen, nur die intern angelegten
Systemvariablen von diesem Typ zu benutzen. Diese lassen sich über die verfügbaren Kalenderfunktionen in die Modellgleichungen einbinden.
Container
Der Variablentyp Container wird im eSim-Modul verwendet, um globale Namensräume zu deklarieren. Zu den wichtigsten Namensräumen gehören die folgenden.
begin declaration
// Konstanten
Container .constants;
// Process control variables
Container .control;
// Ambient and Reference State
Container .amb;
Container .ref;
end declaration
Unterscheidung von Ein- und Ausgabedaten
Um in der Plausibilitätsprüfung und in der Fehlerdiagnose Eingabedaten prüfen zu können, lassen sich Variablen in der Deklaration in Ein- und Ausgabedaten unterscheiden.
Dazu werden die Abschnitte der Eingabevariablen mit begin input eröffnet und mit end input beendet, die Abschnitte der Ausgabevariablen mit begin output eröffnet und mit end output beendet.
