Bauteil 65: Programmierbares Bauteil

Vorgaben

Die Zahl der Anschlüsse wurde auf 10 Eingänge und 10 Ausgänge erweitert. Der Programmierer der DLL entscheidet, wie diese anzuwenden sind.

Allgemeines

Das Bauteil 65 kann verwendet werden, um ein selbst geschriebenes Programm zur Berechnung eines Bauteils in Ebsilon einzubinden. Die Einbindung erfolgt in Form einer DLL. Zur Erstellung einer solchen DLL müssen geeignete Entwicklungswerkzeuge verfügbar sein.

Beim Aufruf der DLL werden die das entsprechende Bauteil betreffenden Daten aus der Ebsilon-Schaltung an diese DLL übergeben, die dann bestimmte Berechnungen damit durchführen kann. Die Ergebniswerte werden dann von Ebsilon übernommen.

Bei diesem Bauteil gibt es wie beim Bauteil 93 (KernelScripting) auch die Möglichkeit, Gleichungen abzusetzen. Dazu ist die Verwendung des „Extended Interface“ und eine Programmierung in C++ erforderlich.

Der Pfad zur DLL kann  beim Bauteil direkt  angegeben werden. Bisher war dies nur in den allgemeinen Einstellungen global für alle Schaltungen und Bauteile möglich. Damit ist auch Verwendung unterschiedlicher DLLs in einer Schaltung möglich.

Das ”Anschlüsse” -Blatt zeigt die Fluidtypen, wie sie den Komponentenverbindungspunkten zugeteilt sind.

Es gibt einen Eintritt für jeden Verbindungspunkt. Er enthält die Nummer des Verbindungspunktes und eine Kombobox, die den ständig angepassten Fluidtyp anzeigt.

Indem Sie in die Fluidtypen-Kombobox klicken und einen der Typen aus der angezeigten Liste auswählen, können Sie den Fluidtyp von Verbindungspunkten ändern.

Es besteht auch die Möglichkeit, durch eine Auswahl "keine" einen Anschluss komplett auszublenden.

Hinweis:

Bei diesen Bauteilen gibt es auch Kennlinien, Ergebnisarrays, Vorgabematrizen und Ergebnismatrizen. Es besteht die Möglichkeit, Ergebniswerte in jedem Iterationsschritt berechnen zu lassen. Siehe dazu Blatt "Rechnung" -->"Berechnungsoptionen" --> "Ergebnisberechnung" --> (1) "Ergebniswerte in jedem Iterationsschritt berechnen"

Für das Bauteil 65 gibt es zusätzliche Interfaces. Siehe dazu Blatt "Experten" und Hinweise im Kapitel "Komponenten bearbeiten" --> Blatt "Experten".

Vorgabewerte  

Generell sind alle sichtbaren Eingaben erforderlich. Häufig werden jedoch Standardwerte zur Verfügung gestellt.

Für weitere Informationen über die Farbe der Eingabefelder und ihre Beschreibungen siehe Komponenten bearbeiten\Vorgabewerte

Für weitere Informationen über Auslegung vs. Teillast und Nominalwerte siehe Allgemeines\Nominalwerte übernehmen

Überblick 

Für die Erstellung eines Programms in C/C++ wird ein eigener C/C++-Compiler benötigt, der eine dynamic link library (DLL) erzeugt, die die DLL Programmable.dll bzw. xui_dll.dll ersetzt. Diese DLL wird zusammen mit EBSILON®Professional benötigt, um eine Berechnung mit diesem Bauteil durchzuführen. 

• =0: die Berechnung wird als erfolgreich angesehen
• <0: es wird eine Fehlermeldung erzeugt
• >0: es wird eine Warnmeldung erzeugt

Das einzige Argument der Funktion EbsUser_Comp65 ist ein Zeiger auf eine EBSPROG_CALC_DATA -Struktur. Diese Struktur ist definiert als

typedef struct {
      int             compno;      // lfd. Nr. (1 = 1. Bauteil 65 in der Schaltung, 2 = 2. Bauteil 65...)
      int             nrule;        // Nr. der Berechnungsvorschrift (= 1. Spezifikationswert)
      int             nspecs;       // Zahl der Spezifikationswerte
      int             nresults;     // Zahl der Ergebniswerte
      int             n_inlines;   // Zahl der Eingangsleitungen
      int             n_outlines;   // Zahl der Austrittsleitungen
      int             n_materials;  // Maximalzahl der Bestandteile in der chemischen Zusammensetzung einer Leitung
      EBSPROG_PARAMS  calcparams; // Berechnungsparameter
      double          *specs;       // Feld aus 'nspecs' Komponenten-Spezifikationswerten
                                   // Leere Vorgaben werden als '-999' dargestellt
      double          *results;     // Feld aus 'nresults' Komponenten-Ergebniswerten
      EBSPROG_LINEVAL *in;         // Feld aus 'n_inlines' Werten der Eingangsleitungen
      EBSPROG_LINEVAL *out;        // Feld aus 'n_outlines' Werten der Austrittsleitungen
} EBSPROG_CALC_DATA;

Bevor der Ebsilon-Rechenkern Ihre DLL aufruft, legt er diese Struktur an und kopiert die Daten aus dem aktuellen Iterationsschritt in diese Struktur. Somit haben Sie in Ihrer DLL Zugriff auf alle diese Daten in der Struktur.

Die Datei EbsUser.c enthält Beispiele, die den Zugriff auf Ebsilon-Spezifikationswerte und Leitungsergebnisse und die Vorgabe Ihrer Ergebnisse verdeutlichen.

Der Parameter compno gibt an, welches der Bauteile 65 (in der Schaltung können mehrere sein) gerade berechnet wird.

Der Parameter nrule ist derselbe Werte, der als Spezifikationswert FPROG im Eigenschaftsfenster definiert wurde. Damit kann man verschiedene Typen von benutzerdefinierten Bausteinen unterscheiden, falls Sie unterschiedliche implementieren wollen.

Die Parameter nspecs, nresults, n_inlines, n_outlines und n_materials geben die Größe der entsprechenden Felder an. In Ihrem Code sollten Sie stets diese Größen an Stelle von absoluten Zahlen (wie 39, 40, 6) verwenden, da sich diese Werte in zukünftigen Ebsilon-Versionen ändern könnten. 

EBSPROG_PARAMS ist eine Struktur, die die Umstände und die Einstellungen der Berechnung angibt.

typedef struct {
    int     mode;       // Aufruf-Modus: Initialisierung (1), Berechnung (2), Beendigung (3)
                        // Modus 1: Empfang der Spezifikationswerte und Durchführung der Initialisierung
                        //         Kein Datentransfer zurück zu Ebsilon
                        // Modus 2: Empfang der Leitungswerte von Ebsilon und Durchführung der Berechnung
                        //         Leitungsergebnisse werden an Ebsilon zurückgegeben
                        // Modus 3: Spezifikationswerte und Komponentenergebnisse werden an Ebsilon zurückgegeben
    int     itno;       // Nummer des aktuellen Iterationsschritts (von 1 bis 998)
    int     design;     // Auslegung (0) / Teillast (1) Rechnung
    int     wst;        // Zu verwendende Wasserdampftafel: 0=IFC-67, 1=IAPWS-IF97
} EBSPROG_PARAMS;

Den Parameter mode können Sie in Ihrem Programm verwenden, um Initialisierungs- oder Beendigungsarbeiten zu erledigen, wie z.B. das Zuweisen und Freigeben von Speicherplatz oder das Öffnen und Schließen von Dateien.

Der Parameter itno dient zur Ihrer Information über den gerade durchgeführten Iterationsschritt.

EBSPROG_PARAMS ist eine Struktur, die die Umstände und die Einstellungen der Berechnung angibt.

typedef struct {
    int     mode;       // Aufruf-Modus: Initialisierung (1), Berechnung (2), Beendigung (3)
                        // Modus 1: Empfang der Spezifikationswerte und Durchführung der Initialisierung
                        //         Kein Datentransfer zurück zu Ebsilon
                        // Modus 2: Empfang der Leitungswerte von Ebsilon und Durchführung der Berechnung
                        //         Leitungsergebnisse werden an Ebsilon zurückgegeben
                        // Modus 3: Spezifikationswerte und Komponentenergebnisse werden an Ebsilon zurückgegeben
    int     itno;       // Nummer des aktuellen Iterationsschritts (von 1 bis 998)
    int     design;     // Auslegung (0) / Teillast (1) Rechnung
    int     wst;        // Zu verwendende Wasserdampftafel: 0=IFC-67, 1=IAPWS-IF97
} EBSPROG_PARAMS;

Den Parameter mode können Sie in Ihrem Programm auswerten, um Initialisierungs- oder Beendigungsarbeiten zu erledigen, wie z.B. das Zuweisen und Freigeben von Speicherplatz oder das Öffnen und Schließen von Dateien.

Der Parameter itno dient zur Ihrer Information über den gerade durchgeführten Iterationsschritt.

 Der Parameter design ist aus zwei Gründen wichtig:

• Sie können zwischen unterschiedlichen Berechnungsalgorithmen im Fall von Auslegungs- oder Teillastberechnungen wählen
• Nur im Auslegungsmodus ist es möglich, die Vorgabewerte innerhalb Ihrer Berechnung zu ändern, die an Ebsilon zurückgegeben werden (Referenzwerte für Teillast).

Der Parameter wst wird zum Aufruf von Stoffwerttabellen benötigt. Aus Gründen der Einheitlichkeit muss in Ihrer DLL dieselbe Formulierung der Wasser/Dampf-Tafeln wie in Ebsilon benutzt werden.

EBSPROG_LINEVAL ist eine Struktur, die die Leitungswerte enthält. Für die Eingabezeilen liefert Ebsilon diese Werte für Ihre Berechnung. Für die Ausgabezeilen erwartet Ebsilon, dass Ihr Programm diese Werte errechnet.

typedef struct {

      double      p;          //  Druck [bar]

      double      h;          //  Enthalpie [kJ/kg]

      double      m;          //  Massenstrom [kg/s]

      double      ncv;        //  unterer Heizwert [kJ/kg]

      MT_ANALYSE ana;        //  Zusammensetzung

      double      fugit;      //  Flüchtige Anteile (nur Kohle)

      double      rho;        //  Dichte (nur Kohle)

      double      zfac;       //  Z-Faktor (nur Öl)

      int         fcoal;      //  Kohleart (nur Kohle)

} EBSPROG_LINEVAL;

Mit  der Struktur MT_ANALYSE wird die Stoffzusammensetzung vorgegeben, sie wird in material_table.h definiert. Siehe die Beschreibung der Stoffwerttabellen-Funktionen für Einzelheiten.

Es ist Aufgabe des Anwenders, festzulegen, wie die Werte der 10 Austrittsanschlüsse von den Eintrittswerten der 10 Eintrittsanschlüsse abhängen.

Sind mehr als 6 Eintritts- oder 6 Austrittsanschlüsse erforderlich, können mehrere dieser Bauteile kombiniert werden (unterschieden durch den Parameter FPROG).

Es können alle Stofftabellen-Funktionen (Wasser und Verbrennung) durch das C-Programm aufgerufen werden.

Jedes andere Programm oder jede API kann einfach durch Modifikation des Make-files einschließlich zusätzlicher Header-files integriert werden.

Beachten Sie, dass die implementierten Berechnungen in jedem Iterationsschritt der Simulation ausgeführt werden, und einen Einfluss auf das Konvergenzverhalten haben.

Die Ebsilon-Schaltung kann mehrere Bauteile des Typs 65 enthalten. Jedes muss eine gültige Unterbauteilnummer FPROG bekommen. Jede vergebene Unterbauteilnummer (FPROG) muss im C-Code bzw. in der DLL bekannt sein.

In "Data\Examples\Programmable\ebsuser.c " sind 3 Beispiele für Unterbauteile gegeben. Diese Beispiele wurden mit Microsoft Developer Studio 6.0 (Visual C++) getestet. Die entsprechenden Schaltungen sind im Verzeichnis data\Examples\components\ des EBSILON^®Professional Installationsverzeichnis unter den Namen Component_65.ebs, Component_65_2.ebs und Component_65_3. abgelegt.

Vorbereitungen zur Implementierung eines neuen Bauteils

Es wird die mit EBSILON^®Professional ausgelieferte Datei ebsuser.c verwendet. Vor einer Modifikation der Datei, erzeugen Sie eine eigene DLL  programmable.dll durch Kompilation und Linken des Originalfiles.

Sie müssen folgendes tun: Die Dateien

• ebsuser.c,
• ebsuser.h,
• materials_table.h,
• materials_wdt.h,
• wdt.lib and
• Programmable.mak.

sind zusammen in dem Verzeichnis Data\Examples\Programmable\ abgelegt, das als EBSILON^®Professional Installations-Verzeichnis ausgewählt wurde.

Wenn Sie Visual C++ installiert haben, müssen Sie folgendermaßen vorgehen

• Öffnen einer Kommandozeile,
• Aufruf des Arbeitsverzeichnisses, in dem alle Dateien (oder Kopien davon) vorhanden sind und
• Eingabe des Befehls nmake Programmable.mak.

Es wird dann ebsuser.obj und die DLL ProgrammableUser.dll erzeugt.

Ersetzen der Programmable.dll, die mit EBSILON^®Professional ausgeliefert wird, durch die von Ihnen erzeugte und umbenannte Kopie. Vergessen Sie nicht, vorher ein Backup der Original-DLL zu machen, falls Ihre DLL nicht ordnungsgemäß funktioniert. 

Implementierung der ebsuser_Comp65-Routine

Zur Implementierung Ihres eigenen Unterbauteils ändern Sie die Funktion ebsuser_Comp65, die Bestandteil von ebsuser.c ist. Diese Funktion sieht folgendermaßen aus:

LINKDLL     int   EbsUser_Comp65    (EBSPROG_CALC_DATA  *data)

{

    int     rc;

    switch (data->nrule) {

        case 1:

                  .....  code for sub type 1

            break;

        case 2:

                  .....  code for sub type 2

            break;

        case 3:

                  .....  code for sub type 3

            break;

        default:

            rc = -999;

            break;

    }

    return rc;

} 

Hinzufügen eines Unterbauteils bedeutet innerhalb eines Blocks einen neuen Fall mit einem Schalter (FPROG) hinzufügen.

Die verfügbare Eingabe sind Felder für

• Drücke p,
• spezifischen Enthalpien h,
• Massenströme m,
• untere Heizwerte ncv und
• Zusammensetzungen ana,

Jede Größe enthält die Werte aller 6 Eingabe-Leitungen.

Als Beispiele enthält das mit EBSILON^®Professional ausgelieferte ebsuser.c drei Unterbauteile (FPROG 1, 2 und 3).

Das erste Beispiel (FPROG = 1) verwendet alle Eingaben und Ausgaben für Leitungen. Es wird in EBSILON^®Professional Beispiel Component_65.ebs, das im Verzeichnis examples\components\ des Installationsverzeichnisses abgelegt ist, verwendet.

Das zweite Beispiel (FPROG = 2) (detaillierte Beschreibung) verwendet die Eingabeleitungen 5 und 6 und die Ausgabeleitungen 2 und 3. Es wird in EBSILON^®Professional Beispiel Component_65_2.ebs , das im Verzeichnis Examples\components\ des Installationsverzeichnisses abgelegt ist, verwendet. In diesem Beispiel wird die Schnittstelle zu den Stoffwertetabellen (allerdings nur Wasser-Dampftafel) verwendet.

Das dritte Beispiel (FPROG = 3) (Component_65_3.ebs, abgelegt im Verzeichnis Examples\components\ des Installationsverzeichnisses), spaltet einen Rohgasmassenstrom in drei Massenströme auf:

• einen Gasmassenstrom, der die Methan- und Wasserstoffanteile enthält,
• einen Rauchgasmassenstrom, der Anteile von Stickstoff, Sauerstoff, Argon, Wasser (gasförmig und flüssig) und Kohlenstoffdioxid enthält und
• ein Rohgasmassenstrom, der die verbleibenden Anteile enthält.

In diesem Beispiel wird die Schnittstelle zu den Verbrennungstabellen verwendet, der untere Heizwert des resultierenden Massenstroms wird berechnet.

Kompilieren und Verlinken

Das Make-file (Data\Examples\Programmable\Programmable.mak ), das mit EBSILON^®Professional ausgeliefert wird, kann verwendet und geändert werden. Sie können einen eigenen Compiler, Linker, Makefile etc. oder jedes andere Werkzeug verwenden.

Die von Ihnen erzeugte DLL muss eine multithreaded DLL sein. Verwenden Sie keine MFC.

Verfügbare Stoffwerttabellen-Funktionen

Die verfügbaren Funktionen sind unten aufgelistet. Bei Aufruf der Funktion müssen die Eingabewerte wie dargestellt spezifiziert sein.

Verwendete Abkürzungen sind

Verfügbare Funktionen für Wasser und Dampf

Verfügbare Funktionen für andere Fluide

Fluide können aus mehreren Substanzen bestehen. Die Massenanteile der einzelnen Substanzen müssen vorgegeben werden.

Zusätzlich zu den Eingabewerten, die in den Tabellen spezifiziert sind, benötigen nahezu alle Berechnungen auch diese Massenanteile. Nur die Berechnung der Massenanteile selbst benötigt die Volumenanteile.

Funktionen für Gase (Luft, Rauchgas, Brenngas, Rohgas)

Funktionen für Kohle und Öl

Vorgabe und Analyse der Stoffwertzusammensetzung

Brennstoffe und Rauchgase können aus mehreren Stoffbestandteilen bestehen. Die Massenanteile dieser Stoffe müssen vorgegeben werden.

Zusätzlich zu den Eingabewerten, die in den Tabellen oben spezifiziert sind, benötigen nahezu alle Berechnungen diese Massenverhältnisse. Nur die Berechnung der Massenanteile selbst benötigt die Volumenverhältnisse.

Um eine Zusammensetzung vorzugeben, werden nur die Funktionen mt_init_analyse () und mt_set_analyse () verwendet:

void mt_init_analyse (MT_ANALYSE         *analyse,
                      MT_ANALYSE_TYPE     analyse_id);
 

BOOL mt_set_analyse  (MT_ANALYSE         *analyse, 
                      MT_ANALYSE_PART     Bauteil_id, 
                      doppelt             Anteil);

Um eine Zusammensetzung abzufragen, muss nur mt_inq_analyse () aufgerufen werden :

BOOL mt_inq_analyse  (MT_ANALYSE         *analyse,
                      MT_ANALYSE_PART     Bauteil_ID, 
                      doppelt                  *Anteil);

(die Deklaration der Strukturen ist in der Header-Datei materials_table.h enthalten).

Aufruf einer Stoffwerttabellen-Funktion

Zur Verwendung der Stoffwerttabellen steht die Funktion mt_calc () zur Verfügung. Diese Funktion ist folgendermaßen definiert:

BOOL mt_calc  (MT_ANALYSE_TYPE     table_id,         // Materialtyp (= Fluid-Typ) (Eingabe)
               MT_FUNC_ID           func_id,          // Gewünschte Funktion (Eingabe)
               double               para_1,           // 1. Parameter der Funktion (Eingabe)
               double               para_2,           // 2. Parameter der Funktion (Eingabe, falls noch erforderlich)

               MT_ANALYSE           *analyse,         // Materialzusammensetzung (Eingabe, bei MT_VRAT_OF_MRAT
                                                      // oder MT_MRAT_OF_VRAT Eingabe und Ausgabe)
               double               *result,          // Berechnetes Ergebnis der gewünschten Funktion (Ausgabe) 
               MT_PHASE_ID          *phase_id,        // Phase für Wasser (Ausgabe, wenn vorhanden)
               MT_FORMULATION       formulation,      // zu verwendende Wasser/Dampf-Tafel Formulierung(Eingabe)
               long                 *error_id);       // Fehlercode (0 = erfolgreich)

Es müssen alle Parameter spezifiziert werden. Die verfügbaren Datentypen und Werte sind im Header-file materials_table.h definiert.

Wenn z.B. die spezifische Enthalpie von Dampf berechnet werden soll und p und T gegeben sind, kann spezifiziert werden:

Oder es soll die spezifische Enthalpie von Rohgas berechnet werden und p und s sind gegeben. Dann muss spezifiziert werden:

• MT_AT_CRUDEGAS als func_id,
• MT_H_OF_PS als func_id,
• der Druck als para_1,
• die spezifische Enthalpie als para_2 und
• die Analyse des Rohgases MT_AT_CRUDEGAS als MT_ANALYSE_Typ

Beispiel: Modellierung Bauteil 8 (Pumpe)

Dieses Beispiel zeigt die Modellierung von Bauteil 8 (siehe weiter unten) durch Verwendung des Bauteils 65.

Bauteilnummer 8 (beispielhaft genutzt mit drei Anschlüssen) :

• Auf der rechten Seite ist ein Wasserrohr angeschlossen, das den Wassereintritt repräsentiert. Druck, Temperatur und Massenstrom des Rohrs sind festgelegt durch Bauteil 1, das mit der rechten Seite der Rohrleitung verbunden ist.
• Auf der linken Seite ist ein Wasserrohr angeschlossen, das den Wasseraustritt repräsentiert. Der Druck in der Rohrleitung wird durch Bauteil 33 spezifiziert, das an diesem Anschluss angeschlossen ist. Der Austrittsdruck wird als Berechnungseingabe für die Pumpe verwendet. Es spezifiziert den Druck, den die Pumpe erzeugen muss.
• Der Wellenanschluss ist als Eintritt (der Leistung) vorgegeben.
  

Das folgende Bild zeigt den oben modellierten Kreislauf mit Verwendung des Bauteils 65. Die Eintritte sind an der unteren und rechten Seite angeordnet, die Austritte an der oberen und linken Seite. Der Spezifikationswert FPROG ist zu 2 gesetzt.

Gegenüber dem vorherigen Modell, werden nun vier Anschlüsse verwendet:

• An der rechten Seite (Anschluss 6, Eintritt 6, Leitungstyp Wasser) ist eine Wasserleitung angeschlossen, die den Wassereintritt repräsentiert. Wie oben sind Druck, Temperatur und Massenstrom dieser Leitung durch ein Bauteil 1 festgelegt, das mit der rechten Seite der Leitung verbunden ist.
• An der oberen Seite (Anschluss 8, Austritt 2, Leitungstyp Wasser) ist eine Wasserleitung angeschlossen, die den Wasseraustritt repräsentiert.
• Der Druck in der Leitung ist spezifiziert durch ein Bauteil 33 , das auf eine andere Eingangsleitung des Bauteils 65 (Anschluss 5, Eintritt 5, Leitungstyp Logik) gesetzt ist, weil dieser Druck als Berechnungseingabe verwendet wird. Falls es auf der Wasseraustrittsleitung (wie oben) platziert wäre, könnte es nicht als Eingabe für Bauteil 65 verwendet werden, da nur die Werte der an die 6 Eingabeanschlüsse angeschlossenen Leitungen als Berechnungseingabe verwendet werden können.
• Eine Welle ist oben (Anschluss 7, Austritt 1, Leitungstyp mechanische Welle) angebunden. Im Unterschied zum vorherigen Modell ist sie als Austritt vorgegeben, weil die erforderliche Leistung, um die Pumpe zu betreiben, ein Ergebnis der Berechnung ist.

Im Folgenden sind die Spezifikationswerte für die Pumpe im Originalmodell und der zugehörigen Code im File ebsuser.c dargestellt. Die Namen der Variablen entsprechen den in der Online Hilfe für Bauteil 8 verwendeten Namen und Gleichungen. Die erforderlichen Spezifikationswerte für die Pumpe sind als Konstanten vorgegeben. Die Kennlinien sind nicht implementiert. Dies ist ohne Belang, da im Originalmodell

• die Kennlinie ETAI/ETAIN = f (M1/M1N) mit M1 = M1N = 100 den konstanten Wert 1 besitzt und
• die Kennlinie HEAD = f (VM1) für FCHR = P2: Ergebnis des Systemdrucks nicht verwendet wird.

case 2:
//
//    Fall 2 (FPROG = 2): 
//
//    Modellierung einer Pumpe als Ersatz für Bauteil Nr. 8 
//
//    Zu den Gleichungen siehe Online Hilfe von Bauteil 8
//
//    Der Wassereintritt ist verbunden mit Anschluss 6 von Bauteil 65.
//    Der zu erzeugende Druck ist verbunden mit Eingabeanschluss 5 von Bauteil 65.
//    Der Wasseraustritt ist verbunden mit Anschluss 2 von Bauteil 65.
//    Die Welle ist verbunden mit Anschluss 3 von Bauteil 65.
//
//    Die Spezifikationswerte sind:
//    ETAIN = SPEC1
//    ETAM  = SPEC2
//    M1N   = SPEC3
//
//    Die Ergebniswerte sind:
//    ETAI  = RES1
//    
//    Indizes in C beginnen bei 0 (d.h. SPEC1 = specs[0],...)
      
    int     rc = 0;
    double  etain, etai;    // Isentroper Wirkungsgrad (Nennwert und aktueller Wert) 
    double  etam;           // Mechanischer Wirkungsgrad
    double  m1n;            // Nenndurchsatz
    double  p1,h1,m1;
    double  p2,h2,m2;
    int     rcmt;           // Rückkehrcode von mt_calc
    double  s1,t2s,h2s,dhs,dh,t2,q2,q3;
    int     ii;
    int     phase = 0, error = 0; 
    MT_FORMULATION form;
 
//    Einlesen der Spezifikationswerte
    etain = data->specs[0];
    etam = data->specs[1];
    m1n = data->specs[2];
 
//    Einlesen der Werte für den Wassereintritt (6) in die lokalen Variablen
    p1 = data->in[5].p;
    h1 = data->in[5].h;
    m1 = data->in[5].m;
 
//    Einlesen der Druckvorgabe (Leitung 5) in die lokale Variable
    p2 = data->in[4].p;
 
//    Berechnung des aktuellen Wirkungsgrads
    if (data->calcparams.design == 0) {
        etai = etain;
    }
    else {
          etai = etain *  (m1 / m1n);
    }
 
//    Einlesen der Wasserdampftafel
    form = data->calcparams.wst;
    
//    Gleichungen der Komponente 8
    rcmt = mt_calc (MT_AT_WATER, MT_S_OF_PH, p1, h1, NULL, &s1 , &phase, form, &error);       
    assert (rcmt);
    rcmt = mt_calc (MT_AT_WATER, MT_T_OF_PS, p2, s1, NULL, &t2s, &phase, form, &error);
    assert (rcmt);
    rcmt = mt_calc (MT_AT_WATER, MT_H_OF_PS, p2, s1, NULL, &h2s, &phase, form, &error);
    assert (rcmt);
 
    dhs = h2s - h1;
    dh = dhs / etai;
    h2 = h1 + dh;
    rcmt = mt_calc (MT_AT_WATER, MT_T_OF_PH, p2, h2, NULL, &t2 , &phase, form, &error);       
    assert (rcmt);
    m2 = m1;
    q2 = m2 * h2;
    q3 = (m2 * h2 - m1 * h1) / etam;
 
//    Initialisierung der Ausgabewerte
    for (ii = 0; ii < 6; ii++) 
    {
        data->out[ii].p = 0.0;
        data->out[ii].h = 0.0;
        data->out[ii].m = 0.0;
    }
 
//    Setzen der Werte für den Wasseraustritt 
    data->out[1].p = p2;
    data->out[1].h = h2;
    data->out[1].m = m2;
 
//    Setzen der Werte Ausgabe für die Welle (p und m sind notwendige Dummy-Werte)
    data->out[2].p = 0.01;
    data->out[2].h = q3;
    data->out[2].m = 1.0;
 
//    Berechnung der Ergebniswerte (nur im letzten Iterationsschritt)
    if (data->calcparams.mode == 3) {
        data->results[0] = etai;
        
//      im Design-Fall: M1N definieren
        if (data->calcparams.design == 0) {
            data->specs[2] = m1;
        }
    }
 
// Festlegen von M1N im Auslegungsfall im letzten Itarationsschritt
    return rc;
}
break; 
 
Wenn der Kreislauf und der Code erzeugt sind, kann kompiliert und gelinkt werden, um die DLL zu erzeugen.

Weitere Beispiele

Klicken Sie hier >> Bauteil 65 Demo 1 << um ein Beispiel 1 (einfach) zu laden.

Klicken Sie hier >> Bauteil 65 Demo 2 << um ein Beispiel 2 (Simulation einer Pumpe wie dargestellt) zu laden.

Klicken Sie hier >> Bauteil 65 Demo 3 << um ein Beispiel 3 (Verwendung Analyse) zu laden.