C# automatisch Strukturen einer Klasse erzeugen

[Kai A. (kaiculon)]

Hallo zusammen,

erstmal ich bin ein total Noob in C#.

Ich möchte folgendes Realisieren:

Eine Klasse "Pufferspeicher" hat eine Struktur "Ebenen" in der 3 
verschiedene Temperaturen hinterlegt sind. Die Anzahl der "Ebenen" in 
dem Pufferspeicher kann man eingeben.

In abhängigkeit der "Ebenen" sollen nun automatisch beim Aufruf der 
Klasse die Anzahl der Strukturen "Ebenen" erzeugt werden.

Ebene Ebene1 = new Ebene();
Ebene Ebenex = new Ebene();
usw...

        public struct Ebene
        {
            double Tupper;
            double Tlevel;
            double Tunder;
            double Tconv;

        }

Die Temperaturen in den Ebenen werden im Laufe einer Simmulation ständig 
neu berechnet und hier abgelegt.

Hat jemand eine Lösung oder wäre es einfacher für die 3 verschiedenen 
Temperaturen Arrays zu nutzen.

Danke und Gruß

Kaiculon

[Stephan L (Gast)]

Wie wäre es mit einem List<Ebene>-Objekt? Das ginge dann so:

List<Ebene> ebenen = new List<Ebene>();

int anzahl_ebenen = 5;

for (int i = 0; i < anzahl_ebenen; i++)
{
     ebenen.Add(new Ebene());
}

[Peter II (Gast)]

warum machst du die struct nicht in ein Array?

Oder besser eine Dictionary List verwenden.

[Udo S. (urschmitt)]

Kai A. schrieb:
> In abhängigkeit der "Ebenen" sollen nun automatisch beim Aufruf der
> Klasse die Anzahl der Strukturen "Ebenen" erzeugt werden.

Was meinst du mit "Aufruf der Klasse"
Eine Klasse ist in der OOP sowas wie ein Schema, eine Beschreibung 
zusammengehöriger Dinge. Im Prinzip das was in C ein struct ist, nur daß 
eine Klasse zusätzlich zu den Daten auch Methoden hat (haben kann) um 
die Daten zu ändern.

Um jetzt wirklich damit arbeiten zu können, musst du mit new() eine 
Instanz dieser Klasse erzeugen. Das ist wie wenn du eine variable vom 
Typ einer struct definierst.
Mit dieser Instanz/Variable kannst du jetzt arbeiten, Methoden aufrufen 
oder auch öffentlich zugängliche (member)variablen direkt ändern.

Ausnahme sind Klassen die statische Methoden oder variablen definiert 
haben. Nur da kann man direkt über den Klassennamen auf die 
entsprechende Variable/Methode zugreifen.

[Kai A. (kaiculon)]

Ja, das mit der Liste funktioniert. Danke!
Wie würde die Struct dann in einem Array aussehen?

Mit Aufruf der Klasse meine ich natürlich eine Instanz erzeugen ;)

Danke und Gruß

[Kai A. (kaiculon)]

Ich habe die Liste nun wie folgt erzeugt.

public struct LEVEL
{
public double Tupper;
public double Tlevel;
public double Tunder;
public double Tconv;
}
List<LEVEL> Level = new List<LEVEL>();
for (int i =0; i < AnzahlLEVEL;i++)
}
Level.Add(new LEVEL());
}

Die Klasse "Pufferspeicher" wird in einer Form instanziert wenn ich 
einen Button klicke. Gleichzig werden nun auch verschiedene Temperaturen 
berechnet welche ich nun direkt in die variablen der Liste Struct 
schreiben will. Ich kann aus der Form aber nicht auf die Liste 
zugreifen.

Wie kann dass funktionieren?

[Borislav B. (boris_b)]

Kai A. schrieb:
> Ich kann aus der Form aber nicht auf die Liste zugreifen.

Warum nicht?

[Kai A. (kaiculon)]

weil ich nicht weiß wie ;)

[Borislav B. (boris_b)]

Kai A. schrieb:
> weil ich nicht weiß wie ;)

Ich dachte dein Datenspeicher ist ein Member der Form, aus der du auch 
darauf zugreifen willst? Dann gibt es da doch keinerlei Hürden ;-)

[Kai A. (kaiculon)]

Nein, ich instanziere in der Form die Klasse Pufferspeicher. Der 
Datenspeicher ist ein Member der Klasse Pufferspeicher. In der Form 
instanziere ich die Klasse Pufferspeicher.

[Peter II (Gast)]

Kai A. schrieb:
> Nein, ich instanziere in der Form die Klasse Pufferspeicher. Der
> Datenspeicher ist ein Member der Klasse Pufferspeicher. In der Form
> instanziere ich die Klasse Pufferspeicher.

gut und wo ist nun das Problem?

Du kannst uns auch code zeigen.

[Borislav B. (boris_b)]

Kai A. schrieb:
> Nein, ich instanziere in der Form die Klasse Pufferspeicher. Der
> Datenspeicher ist ein Member der Klasse Pufferspeicher. In der Form
> instanziere ich die Klasse Pufferspeicher.

Nimms nicht persönlich, aber ich glaube dir fehlen ganz elementare 
Grundlagen. An deiner Stelle würde ich einen Tag opfern, und mich durch 
ein schönes C#-Tutorial arbeiten. Wenn du dann über Klassen, Member, 
Properties, Methoden und ein paar Grundlegende Entwurfsmuster Bescheid 
weißt, wird auch dein aktuelles Projekt deutlich leichter fallen.

[Kai A. (kaiculon)]

Jaja, das letzte mal das ich programmiert hab war Turbo Pascal im 
studium. Ich hab nächsten Monat einen Kurs, das dauert mir aber zu 
lange. Ich posten den Code mal trotzdem und schreibe dazu was ich 
"eigentlich" machen will. Wenn ihr keinen Bockt habt kann ich das auch 
verstehen, nehm das nicht persönlich.

Also, bin für alle sinnvollen Vorschläge bzgl. Struktur und zum 
grundsätzlichen Vorgehen dankbar.

Hier erstmal der Code der Klasse Pufferspeicher:

public class Puffersimulation
    {
        //inputs
        int TINS;                            // input temp. secondary side [°C]
        double VDOTS;                        // secodary volumeflow [m³/h]
        double DIA;                          // storage diameter [m]
        double VOLUME;                       // storage Volume [m³]
        double QP;                           // heating power primary side [kW]
        int AnzahlLEVEL;                     // Number of levels buffer storage
        int t;                               // simulation time
        int Tx = 20;                         // Starttemp.
        
        // berechnung
        double[] VLEVEL;                     // volume of level



        //outputs
        int T1;
        int T2;


        // Konstruktor Grundzustand (Übergabewerte)
        public Puffersimulation();
        
        public Puffersimulation(double diaBS, double volumeBS, int levelBS)
        {
            DIA = diaBS;
            VOLUME = volumeBS;
            AnzahlLEVEL = levelBS;
        }
                      
        public Puffersimulation(int ToutCHP, double VCHP, double diaBS, double volumeBS, double QoutHEAT, int levelBS)
        {
            TINS = ToutCHP;
            VDOTS = VCHP;
            DIA = diaBS;
            VOLUME = volumeBS;
            QP = QoutHEAT;
            AnzahlLEVEL = levelBS;
        }

        // Methode Main
        public void Main()
        {
            List<LEVEL> Level = new List<LEVEL>();
            for (int i =0; i < AnzahlLEVEL;i++)
            {
                Level.Add(new LEVEL());
                LEVEL To = Level[0];
                To.Tupper = Tx;
                Level[0] = To;
                LEVEL Tl = Level[1];
                Tl.Tlevel = Tx;
                Level[1] = Tl;
                LEVEL Tu = Level[2];
                Tu.Tunder = Tx;
                Level[2] = Tu;
                LEVEL Tc = Level[4];
                Tc.Tconv = 0;
                Level[3] = Tc;
             }
        }


        // Methode - Berechnung der Schichthöhe
        public double GetHLEVEL(double volumen, double dia, int level)
        {
            double dh;
            double GHigh = volumen / ((dia / 2) * Math.PI);
            return dh = GHigh / level; 
        }

        //Methode - Berechnung des Schichtvolumens (alle Schichten gleich)
        public double[] GetVLEVEL(double volume, int level)
        {
            VLEVEL = new double[level];
            for (int i = 0; i <= VLEVEL.Length-1; i++)
            {
                VLEVEL[i] = volume / level;
            }
            return VLEVEL;
        }

        // Methode - Berechnung der Ladegeschwindigkeit
        public double GetULOAD (double vdots, double dia)
        {
            double uload;
            return uload = vdots/3600 / (Math.Pow((dia / 2), 2) * Math.PI);
        }

        // Methode - Berechung der Heizgeschwindigkeit
        public double GetUHEAT(double vdoth, double dia)
        {
            double uheat;
            return uheat = vdoth/3600 / (Math.Pow((dia / 2), 2) * Math.PI); 
        }
              

        // Methode - Berechnung des Konvektionswärmestroms der Ladung
        public double GetTCONVS(double uload, double tupper, double tlevel, double hlevel, int level)
        {

            double TCONVLL = (uload * ((tupper - tlevel) / hlevel));

            return TCONVLL;
        }

        // Methode zur Berechnung des Konvektionswärmestroms der Entladung
        public double GetTCONVH(double uheat, double tlevel, double tunder, double hlevel)
        {
            double TCONVHL = (uheat * ((tunder - tlevel) / hlevel));
            return TCONVHL;
        }
        // Methode zur Berechung des Konvektionswämrestromes
        public double GetTCONV(double tconvhl, double tconvll)
        {

            double TCONV = tconvhl + tconvll;
            return TCONV;
        }


        // Methode zur Berechnung der Schichttemperaturen
        public double GetTLEVEL(int t, double T0, double tconv)
        {
            double TLEVEL=0;
            if (tconv <= 0 && tconv <=0)
            {
                TLEVEL = T0;

            }
            else
            {
                TLEVEL = T0 + (tconv * t);
            }

            return TLEVEL;

        }


        // Struktur für Level
        public struct LEVEL
        {
            public double Tupper;
            public double Tlevel;
            public double Tunder;
            public double Tconv;
 
        }


    }

-----------------------------------------------

Hier der Code der Form die ich zum Testen benutze:

public partial class Form1 : Form
    {
        // inputs
        int ToutCHP = 70;                        // input temp. secondary side [°C]
        double VDOTS = 2;                        // secodary volumeflow [m³/h]
        double DIA = 0.8;                        // storage diameter [m]
        double VOLUME = 2;                       // storage Volume [m³]
        double QP = 0;                           // heating power primary side [kW]
        int LEVEL = 3;                           // Number of levels buffer storage
        int t = 10;                              // Simmulationszeit in [s]
        double T0 = 20;                          // Starttemperatur in [°C]

        // Berechnung
        double tconv = 0;




        Puffersimulation PS = new Puffersimulation();


        

        public Form1()
        {
            InitializeComponent();
        }


        private void textBox3_TextChanged(object sender, EventArgs e)
        {
            //VDOTS = Convert.ToDouble(textBox3.Text);
        }      

        private void textBox4_TextChanged(object sender, EventArgs e)
        {
            //DIA = Convert.ToDouble(textBox4.Text);
        }

        private void textBox5_TextChanged(object sender, EventArgs e)
        {
            //VOLUME = Convert.ToDouble(textBox5.Text);
        }

        private void textBox6_TextChanged(object sender, EventArgs e)
        {
            //LEVEL = Convert.ToInt32(textBox6.Text);
        }

        private void textBox9_TextChanged(object sender, EventArgs e)
        {
            //ToutCHP = Convert.ToInt32(textBox9.Text);
        }

        private void textBox10_TextChanged(object sender, EventArgs e)
        {
            //QP = Convert.ToDouble(textBox10.Text);
        }

        private void button1_Click(object sender, EventArgs e)
        {
            double hlevel = PS.GetHLEVEL(VDOTS, DIA, LEVEL);                // Berechnung der Schichthöhe
            label1.Text = hlevel.ToString();
            double []vlevel = new double[LEVEL];
            vlevel = PS.GetVLEVEL(VOLUME, LEVEL);                           // Berechnung des Volumens der verschiedenen Schichten
            label4.Text = vlevel[2].ToString();
            double uload = PS.GetULOAD(VDOTS, DIA);                         // Berechnung der Ladegeschwindigkeit
            double uheat = PS.GetUHEAT(VDOTS, DIA);                         // Berechnung der Heizgeschwindigkeit
            label15.Text = uload.ToString();
            double test1 = PS.GetTLEVEL(t, T0, tconv);
            label8.Text = test1.ToString();
 





        }

Der Pufferspeicher hat je nach eingabe eine Anzahl an Level. Ich will 
für jedes level die 3 zugehörigen Temperaturen ausrechnen. Anschließend 
bekommt der Speicher einen Input an Wärmeenergie und einen Output an 
Wärmeeinergie. Das verändert die die innere Konvektion des Speichers und 
der verschiedenen Schichten. Diese errechne ich in °C/s. in Abhängigkeit 
der Simmulationsdauer ändert sich also die Temperatur der Schichten (T 
Eingang in die Schicht, T Schicht und T Ausgang aus der Schicht).
Diese Werte sollen in das Struct LEVEL geschrieben werden und ständig 
aktualisiert werden.

Danke und Gruß

[Peter II (Gast)]

das sieht sehr merkwürdig aus

> Level.Add(new LEVEL());

ok, ein neues objekt in Level

> LEVEL To = Level[0];
hier wird ein neues objekt als KOPIE von Level[0] angelegt

> To.Tupper = Tx;
ok

> Level[0] = To;
und wieder zurückkopiert, ok

> LEVEL Tl = Level[1];
woher soll jetzt auf einmal Level[1] kommen?

[Karl H. (kbuchegg)]

Ich denke da liegt ein grundsätzliches strukturelles Problem vor.

Du musst dir darüber im klaren sein, dass du in deinem Programm so etwas 
wie eine Hierarchie brauchst.

d.h. da gibt es eine Klasse, welche als deine Applikation an sich 
auftritt
In dieser Klasse sind alle 'globalen' Dinge versammelt, die eben deine 
Appliktion ausmachen

Dann gibt es noch Forms, die zu dieser Applikation gehören und die zb 
Zugang zu diesen applikationsweiten Daten haben und sie manipulieren.

Die Aussage "Hier erstmal der Code der Klasse Pufferspeicher:" und der 
Klassenname "Puffersimulation" beissen sich schon mal für meine 
Begriffe. Denn der Pufferspeicher ist Teil der Simulation. Aber er IST 
nicht die Simulation.

Genauso wie hier:
        Puffersimulation PS = new Puffersimulation();

Deine Form1 kann nicht die Puffersimulation erzeugen. Denn die Form ist 
Teil der Simulation. Wenn schon, dann könnte höchstens das 
Simulationsobjekt die Form erzeugt haben.


Wie Peter II schon sagte: das alles sieht sehr merkwürdig aus. Es sieht 
nicht richtig aus, auch wenn es nicht nur eine einzige Stelle gibt, auf 
die man zeigen könnte und sagen könnte: da steckt der Fehler. Es ist 
irgendwie alles ein wenig falsch bzw. merkwürdig.

Jetzt ist es aber so, dass in diesen C# Forms Anwendungen eine Form 
(deine Form1) als das Applikationsobjekt fungiert. D.h. die oberste Form 
verwaltet alle applikationsweit verfügbaren Objekte. In diesem Sinne 
kann diese Form dann sehr wohl das Puffersimulationsobjekt erzeugen 
(auch wenn ich persönlich das für etwas seltsam halte, aber so ist das 
nun mal in der Forms-Programmierung).

Aber: dann kann Puffersimulation keine Methode

        // Methode Main
        public void Main()
        {
            List<LEVEL> Level = new List<LEVEL>();
            for (int i =0; i < AnzahlLEVEL;i++)
            {
                Level.Add(new LEVEL());
                LEVEL To = Level[0];
                To.Tupper = Tx;
                Level[0] = To;
                LEVEL Tl = Level[1];
                Tl.Tlevel = Tx;
                Level[1] = Tl;
                LEVEL Tu = Level[2];
                Tu.Tunder = Tx;
                Level[2] = Tu;
                LEVEL Tc = Level[4];
                Tc.Tconv = 0;
                Level[3] = Tc;
             }
        }

haben, denn die wird nie aufgerufen. Das Programm startet nicht hier, 
sondern es startet mit der Erzeugung der ersten Form.

Und diese Form wiederrum erzeugt dann das Puffersimulation Objekt. Aber 
es ruft nicht Main auf.

Und vor allen Dingen hält momentan das Puffersimulations Objekt nicht 
die Liste der LEVEL Objekte, denn die ist ja hier

        public void Main()
        {
            List<LEVEL> Level = new List<LEVEL>();

lokal zu dieser Methode.

Alles in allem:
Da sind einige strukturelle Probleme. Du solltest dir erst mal klar 
machen, welches Objekt welche anderen Objekte enthält. Enthalten muss.
Einfach drauf los coden, geht auch in einer objektorientierten Welt 
schief.

[Kai A. (kaiculon)]

Da war Turbo Pascal aber einfacher ;)

OK, das ist ein Ansatz mit dem ich arbeiten kann. Ich habe 
beispielsweise die Klasse Pufferspeicher mit ihren Konstruktoren, 
Eigenschaften und Methoden.

Dann habe ich eine Ausführende Klasse in der ich die Klasse 
Pufferspeicher instanziere und alle globalen größen anordne und die 
Methoden einer Klasse Pufferspeicher und z.B. einer Klasse Berechnungen 
nutze und ausführe.

Ich versuche das mal so umzusetzen.

DAnke und Gruß

[Kai A. (kaiculon)]

Hallo zusammen,

hier nun das funktionierende Programm, falls es jemand ausprobieren 
möchte!

namespace Simulation
{
    // Klasse Pufferspeicher
    public class Pufferspeicher
    {
        double DIA;                          // storage diameter [m]
        double VOLUME;                       // storage Volume [m³]
        int NumberOfLevel;                   // Number of levels buffer 
storage
        public LEVEL[] NLEVEL;               // Array of struct Level 
with unknown lenght
        LEVEL[] NLEVELS;                     // Array of Struct Level 
with unknown lenght for backup
        // Bis Hier = Ausgangszustand
        double VDOTS;                        // secodary volumeflow 
[m³/h]
        double VDOTP;                        // primary volumeflow 
[m³/h]
        public double ULOAD;                 // loading speed
        public double UHEAT;                 // heating speed



        // Konstanten
        public const double cw = 4.18;       // [kJ/kg*K]

        // Output
        double T1;
        double T2;


        // Konstruktor 1(Beschreibung für den Grundzustand)
        public Pufferspeicher(double diameter, double volume, double 
tstart, int numberoflevel)
        {
            DIA = diameter;
            VOLUME = volume;
            NumberOfLevel = numberoflevel;
            // initialisierung von NLEVEL mit der Länge von der 
Levelanzahl
            NLEVEL = new LEVEL[numberoflevel];

            for (int index = 0; index < NLEVEL.Length; index++)
            {
                NLEVEL[index].Hight = GetHLEVEL(volume, diameter, 
numberoflevel);
                NLEVEL[index].Volume = GetVLEVEL(volume, numberoflevel);
                NLEVEL[index].Tlevel = tstart;
                NLEVEL[index].Tconv = 0.0;
            }


        }
        // Konstruktor 2(Beschreibung für den Simmulationszustand)
        public Pufferspeicher(double diameter, double volume, double 
tstart, int numberoflevel, double vdots,double vdotp, double qheat)
        {
            DIA = diameter;
            VOLUME = volume;
            NumberOfLevel = numberoflevel;
            VDOTS = vdots;
            VDOTP = vdotp;
            // initialisierung von NLEVEL mit der Länge von der 
Levelanzahl
            NLEVEL = new LEVEL[numberoflevel];

            // Generelle Berechnung
            UHEAT = GetUHEAT(vdotp, diameter);
            ULOAD = GetULOAD(vdots, diameter);

            for (int index = 0; index < NLEVEL.Length; index++)
            {
                NLEVEL[index].Hight = GetHLEVEL(volume, diameter, 
numberoflevel);
                NLEVEL[index].Volume = GetVLEVEL(volume, numberoflevel);
                NLEVEL[index].Tlevel = tstart;
                NLEVEL[index].Tconv = 0.0;
            }

        }


        // Struktur für Level
        public struct LEVEL
        {

            public double Tlevel;
            public double Tconv;
            public double Hight;
            public double Volume;

        }


        // Methode - Berechnung der Schichthöhe
        public double GetHLEVEL(double volumen, double dia, int 
numberoflevel)
        {
            double hight;
            double Ghight = volumen / ((dia / 2) * Math.PI);
            return hight = Ghight / numberoflevel;
        }

        //Methode - Berechnung des Schichtvolumens (alle Schichten 
gleich)
        public double GetVLEVEL(double volume, int numberoflevel)
        {
            double vlevel = volume / numberoflevel;
            return vlevel;
        }

        // Methode - Berechnung der Ladegeschwindigkeit
        public double GetULOAD(double vdots, double diameter)
        {
            double uload;
            return uload = vdots  3600  (Math.Pow((diameter / 2), 2) * 
Math.PI);
        }

        // Methode - Berechung der Heizgeschwindigkeit
        public double GetUHEAT(double vdoth, double diameter)
        {
            double uheat;
            return uheat = vdoth  3600  (Math.Pow((diameter / 2), 2) * 
Math.PI);
        }

        // Methode - Berechnung des Konvektionswärmestroms der 
Sekundärseite
        public double GetTCONVS(double uload, double tupper, double 
tlevel, double hlevel)
        {
            double TCONVS = (uload * ((tupper - tlevel) / hlevel));
            return TCONVS;
        }

        // Methode - Berechnung des Konvektionswärmestroms der 
Primärseite
        public double GetTCONVP(double uheat, double tlevel, double 
tunder, double hlevel)
        {
            double TCONVP = (uheat * ((tunder - tlevel) / hlevel));
            return TCONVP;
        }
        // Methode zur Berechung des Konvektionswämrestromes
        public double GetTCONV(double tconvhl, double tconvll)
        {

            double TCONV = tconvhl + tconvll;
            return TCONV;
        }

        // Methode zur Berechnung der Eintrittstemperatur auf der 
Heizseite
        public double GetTInP(double qheat, double vdoth, double toutp)
        {
            double value1 = vdoth / 3.6;
            double value2 = toutp - (qheat / (value1 * cw));
            return value2;
        }



        // Methode zur berechnung des Zustandes nach X Sekunden
        public void GetNewState(double TInputS, double TInputP, int 
simutime)
        {
            NLEVELS = new LEVEL[NumberOfLevel];
            // Kopieren der aktuellen Werte für Nutzung in Berechnungen 
in ein zweites Array
            NLEVELS = NLEVEL;

            for (int time = 0; time < simutime; time++ )
            {
                for (int index = 0; index < NLEVEL.Length; index++)
                {
                    // Kopieren der aktuellen Werte für Nutzung in 
Berechnungen in ein zweites Array
                    NLEVELS = NLEVEL;
                    // Bei Schicht 1 wird die Eintrittstemperatur der 
Sekundärseite als Obere Temperatur genutzt
                    if (index == 0)
                    {
                        double tconvs = GetTCONVS(ULOAD, TInputS, 
NLEVELS[index].Tlevel, NLEVELS[index].Hight);
                        double tconvp = GetTCONVP(UHEAT, 
NLEVELS[index].Tlevel, NLEVELS[index + 1].Tlevel, NLEVELS[index].Hight);
                        NLEVEL[index].Tconv = GetTCONV(tconvs, tconvp);
                        T1 = NLEVEL[index].Tlevel = 
NLEVELS[index].Tlevel + NLEVEL[index].Tconv;
                    }
                    // Bei der letzten Schicht wird die 
Eintrittstemperatur der Primärseite als Untere Temperatur genutzt
                    else if (index == NLEVEL.Length - 1)
                    {
                        double tconvs = GetTCONVS(ULOAD, NLEVELS[index - 
1].Tlevel, NLEVELS[index].Tlevel, NLEVELS[index].Hight);
                        double tconvp = GetTCONVP(UHEAT, 
NLEVELS[index].Tlevel, TInputP, NLEVELS[index].Hight);
                        NLEVEL[index].Tconv = GetTCONV(tconvs, tconvp);
                        T2 = NLEVEL[index].Tlevel = 
NLEVELS[index].Tlevel + NLEVEL[index].Tconv;
                    }

                    // Bei allen anderen Schichten wird jeweils 
Temperatur der oberen und unteren Schicht genutzt
                    else
                    {
                        double tconvs = GetTCONVS(ULOAD, NLEVELS[index - 
1].Tlevel, NLEVELS[index].Tlevel, NLEVELS[index].Hight);
                        double tconvp = GetTCONVP(UHEAT, 
NLEVELS[index].Tlevel, NLEVELS[index + 1].Tlevel, NLEVELS[index].Hight);
                        NLEVEL[index].Tconv = GetTCONV(tconvs, tconvp);
                        NLEVEL[index].Tlevel = NLEVELS[index].Tlevel + 
NLEVEL[index].Tconv;
                    }
                }

            }

        }



    }
}


Ich habe es in der Form so aufgerufen:

namespace Simulation
{

    public partial class Form1 : Form
    {
        // inputs

        double DIA = 0.8;                        // storage diameter [m]
        double VOLUME = 2.0;                     // storage Volume [m³]
        int LEVEL = 3;                           // Number of levels 
buffer storage
        double VDOTCHP = 2.0;                    // Volumeflow from CHP 
unit [m³/h]
        double TOUTCHP = 85.0;                   // Outlet temp. from 
CHP unit [°C]
        double QHEAT = 55;                       // Heat load heating 
circuit [kW]
        double VDOTHEAT = 4.0;                   // Volumeflow in 
heating circuit [m³/h]
        double Tstart = 20.0;                    // Start Temp. of 
simulation [°C]
        int tsim = 10;                           // Simulationtime [s]

        Pufferspeicher Puffer1;
        Pufferspeicher Puffer2;

        // Berechnung
        double TInP;

        public Form1()
        {
            InitializeComponent();
            // initialisierung von Puffer1 in Form 1
            Puffer1 = new Pufferspeicher(DIA, VOLUME, Tstart, LEVEL);
            Puffer2 = new Pufferspeicher(DIA, VOLUME, Tstart, LEVEL, 
VDOTCHP, VDOTHEAT, QHEAT);

        }


        private void textBox3_TextChanged(object sender, EventArgs e)
        {
            //VDOTS = Convert.ToDouble(textBox3.Text);
        }

        private void textBox4_TextChanged(object sender, EventArgs e)
        {
            //DIA = Convert.ToDouble(textBox4.Text);
        }

        private void textBox5_TextChanged(object sender, EventArgs e)
        {
            //VOLUME = Convert.ToDouble(textBox5.Text);
        }

        private void textBox6_TextChanged(object sender, EventArgs e)
        {
            //LEVEL = Convert.ToInt32(textBox6.Text);
        }

        private void textBox9_TextChanged(object sender, EventArgs e)
        {
            //ToutCHP = Convert.ToInt32(textBox9.Text);
        }

        private void textBox10_TextChanged(object sender, EventArgs e)
        {
            //QP = Convert.ToDouble(textBox10.Text);
        }

        private void button1_Click(object sender, EventArgs e)
        {
            timer1.Interval = 100;
            timer1.Start();
        }

        private void timer1_Tick(object sender, EventArgs e)
        {
            label1.Text = Puffer2.NLEVEL[0].Hight.ToString("F4");
            label4.Text = Puffer2.NLEVEL[0].Volume.ToString("F4");
            label8.Text = Puffer2.ULOAD.ToString("F6");
            label11.Text = Puffer2.UHEAT.ToString("F6");
            TInP = Puffer2.GetTInP(QHEAT, VDOTHEAT, 
Puffer2.NLEVEL[0].Tlevel);
            label32.Text = TInP.ToString("F4");
            Puffer2.GetNewState(TOUTCHP, TInP, tsim);
            label17.Text = Puffer2.NLEVEL[0].Tconv.ToString("F4");
            label19.Text = Puffer2.NLEVEL[0].Tlevel.ToString("F4");
            label21.Text = Puffer2.NLEVEL[LEVEL - 
1].Tconv.ToString("F4");
            label23.Text = Puffer2.NLEVEL[LEVEL - 
1].Tlevel.ToString("F4");
            label27.Text = Puffer2.NLEVEL[1].Tconv.ToString("F4");
            label29.Text = Puffer2.NLEVEL[1].Tlevel.ToString("F4");
        }

Danke für die Hilfe und Gruß