C# automatisch Strukturen einer Klasse erzeugen

Kai A. OP #3598719
Lesenswert?
• ▲
▼ 
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
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Stephan L Gast #3598729
Lesenswert?
• ▲
▼ 
Wie wäre es mit einem List<Ebene>-Objekt? Das ginge dann so:

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

2


3
int anzahl_ebenen = 5;

4


5
for (int i = 0; i < anzahl_ebenen; i++)

6
{

7
     ebenen.Add(new Ebene());

8
}
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Udo S. #3598735
Lesenswert?
• ▲
▼ 
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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Kai A. OP #3599081
Lesenswert?
• ▲
▼ 
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?
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Borislav B. #3599177
Lesenswert?
• ▲
▼ 
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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Kai A. OP #3599228
Lesenswert?
• ▲
▼ 
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:
1
public class Puffersimulation

2
    {

3
        //inputs

4
        int TINS;                            // input temp. secondary side [°C]

5
        double VDOTS;                        // secodary volumeflow [m³/h]

6
        double DIA;                          // storage diameter [m]

7
        double VOLUME;                       // storage Volume [m³]

8
        double QP;                           // heating power primary side [kW]

9
        int AnzahlLEVEL;                     // Number of levels buffer storage

10
        int t;                               // simulation time

11
        int Tx = 20;                         // Starttemp.

12
        

13
        // berechnung

14
        double[] VLEVEL;                     // volume of level

15


16


17


18
        //outputs

19
        int T1;

20
        int T2;

21


22


23
        // Konstruktor Grundzustand (Übergabewerte)

24
        public Puffersimulation();

25
        

26
        public Puffersimulation(double diaBS, double volumeBS, int levelBS)

27
        {

28
            DIA = diaBS;

29
            VOLUME = volumeBS;

30
            AnzahlLEVEL = levelBS;

31
        }

32
                      

33
        public Puffersimulation(int ToutCHP, double VCHP, double diaBS, double volumeBS, double QoutHEAT, int levelBS)

34
        {

35
            TINS = ToutCHP;

36
            VDOTS = VCHP;

37
            DIA = diaBS;

38
            VOLUME = volumeBS;

39
            QP = QoutHEAT;

40
            AnzahlLEVEL = levelBS;

41
        }

42


43
        // Methode Main

44
        public void Main()

45
        {

46
            List<LEVEL> Level = new List<LEVEL>();

47
            for (int i =0; i < AnzahlLEVEL;i++)

48
            {

49
                Level.Add(new LEVEL());

50
                LEVEL To = Level[0];

51
                To.Tupper = Tx;

52
                Level[0] = To;

53
                LEVEL Tl = Level[1];

54
                Tl.Tlevel = Tx;

55
                Level[1] = Tl;

56
                LEVEL Tu = Level[2];

57
                Tu.Tunder = Tx;

58
                Level[2] = Tu;

59
                LEVEL Tc = Level[4];

60
                Tc.Tconv = 0;

61
                Level[3] = Tc;

62
             }

63
        }

64


65


66
        // Methode - Berechnung der Schichthöhe

67
        public double GetHLEVEL(double volumen, double dia, int level)

68
        {

69
            double dh;

70
            double GHigh = volumen / ((dia / 2) * Math.PI);

71
            return dh = GHigh / level; 

72
        }

73


74
        //Methode - Berechnung des Schichtvolumens (alle Schichten gleich)

75
        public double[] GetVLEVEL(double volume, int level)

76
        {

77
            VLEVEL = new double[level];

78
            for (int i = 0; i <= VLEVEL.Length-1; i++)

79
            {

80
                VLEVEL[i] = volume / level;

81
            }

82
            return VLEVEL;

83
        }

84


85
        // Methode - Berechnung der Ladegeschwindigkeit

86
        public double GetULOAD (double vdots, double dia)

87
        {

88
            double uload;

89
            return uload = vdots/3600 / (Math.Pow((dia / 2), 2) * Math.PI);

90
        }

91


92
        // Methode - Berechung der Heizgeschwindigkeit

93
        public double GetUHEAT(double vdoth, double dia)

94
        {

95
            double uheat;

96
            return uheat = vdoth/3600 / (Math.Pow((dia / 2), 2) * Math.PI); 

97
        }

98
              

99


100
        // Methode - Berechnung des Konvektionswärmestroms der Ladung

101
        public double GetTCONVS(double uload, double tupper, double tlevel, double hlevel, int level)

102
        {

103


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

105


106
            return TCONVLL;

107
        }

108


109
        // Methode zur Berechnung des Konvektionswärmestroms der Entladung

110
        public double GetTCONVH(double uheat, double tlevel, double tunder, double hlevel)

111
        {

112
            double TCONVHL = (uheat * ((tunder - tlevel) / hlevel));

113
            return TCONVHL;

114
        }

115
        // Methode zur Berechung des Konvektionswämrestromes

116
        public double GetTCONV(double tconvhl, double tconvll)

117
        {

118


119
            double TCONV = tconvhl + tconvll;

120
            return TCONV;

121
        }

122


123


124
        // Methode zur Berechnung der Schichttemperaturen

125
        public double GetTLEVEL(int t, double T0, double tconv)

126
        {

127
            double TLEVEL=0;

128
            if (tconv <= 0 && tconv <=0)

129
            {

130
                TLEVEL = T0;

131


132
            }

133
            else

134
            {

135
                TLEVEL = T0 + (tconv * t);

136
            }

137


138
            return TLEVEL;

139


140
        }

141


142


143
        // Struktur für Level

144
        public struct LEVEL

145
        {

146
            public double Tupper;

147
            public double Tlevel;

148
            public double Tunder;

149
            public double Tconv;

150
 

151
        }

152


153


154
    }

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

Hier der Code der Form die ich zum Testen benutze:
1
public partial class Form1 : Form

2
    {

3
        // inputs

4
        int ToutCHP = 70;                        // input temp. secondary side [°C]

5
        double VDOTS = 2;                        // secodary volumeflow [m³/h]

6
        double DIA = 0.8;                        // storage diameter [m]

7
        double VOLUME = 2;                       // storage Volume [m³]

8
        double QP = 0;                           // heating power primary side [kW]

9
        int LEVEL = 3;                           // Number of levels buffer storage

10
        int t = 10;                              // Simmulationszeit in [s]

11
        double T0 = 20;                          // Starttemperatur in [°C]

12


13
        // Berechnung

14
        double tconv = 0;

15


16


17


18


19
        Puffersimulation PS = new Puffersimulation();

20


21


22
        

23


24
        public Form1()

25
        {

26
            InitializeComponent();

27
        }

28


29


30
        private void textBox3_TextChanged(object sender, EventArgs e)

31
        {

32
            //VDOTS = Convert.ToDouble(textBox3.Text);

33
        }      

34


35
        private void textBox4_TextChanged(object sender, EventArgs e)

36
        {

37
            //DIA = Convert.ToDouble(textBox4.Text);

38
        }

39


40
        private void textBox5_TextChanged(object sender, EventArgs e)

41
        {

42
            //VOLUME = Convert.ToDouble(textBox5.Text);

43
        }

44


45
        private void textBox6_TextChanged(object sender, EventArgs e)

46
        {

47
            //LEVEL = Convert.ToInt32(textBox6.Text);

48
        }

49


50
        private void textBox9_TextChanged(object sender, EventArgs e)

51
        {

52
            //ToutCHP = Convert.ToInt32(textBox9.Text);

53
        }

54


55
        private void textBox10_TextChanged(object sender, EventArgs e)

56
        {

57
            //QP = Convert.ToDouble(textBox10.Text);

58
        }

59


60
        private void button1_Click(object sender, EventArgs e)

61
        {

62
            double hlevel = PS.GetHLEVEL(VDOTS, DIA, LEVEL);                // Berechnung der Schichthöhe

63
            label1.Text = hlevel.ToString();

64
            double []vlevel = new double[LEVEL];

65
            vlevel = PS.GetVLEVEL(VOLUME, LEVEL);                           // Berechnung des Volumens der verschiedenen Schichten

66
            label4.Text = vlevel[2].ToString();

67
            double uload = PS.GetULOAD(VDOTS, DIA);                         // Berechnung der Ladegeschwindigkeit

68
            double uheat = PS.GetUHEAT(VDOTS, DIA);                         // Berechnung der Heizgeschwindigkeit

69
            label15.Text = uload.ToString();

70
            double test1 = PS.GetTLEVEL(t, T0, tconv);

71
            label8.Text = test1.ToString();

72
 

73


74


75


76


77


78
        }

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ß
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Peter II Gast #3599246
Lesenswert?
• ▲
▼ 
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?
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #3599266
Lesenswert?
• ▲
▼ 
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
1
        // Methode Main

2
        public void Main()

3
        {

4
            List<LEVEL> Level = new List<LEVEL>();

5
            for (int i =0; i < AnzahlLEVEL;i++)

6
            {

7
                Level.Add(new LEVEL());

8
                LEVEL To = Level[0];

9
                To.Tupper = Tx;

10
                Level[0] = To;

11
                LEVEL Tl = Level[1];

12
                Tl.Tlevel = Tx;

13
                Level[1] = Tl;

14
                LEVEL Tu = Level[2];

15
                Tu.Tunder = Tx;

16
                Level[2] = Tu;

17
                LEVEL Tc = Level[4];

18
                Tc.Tconv = 0;

19
                Level[3] = Tc;

20
             }

21
        }

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
1
        public void Main()

2
        {

3
            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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Kai A. OP #3599356
Lesenswert?
• ▲
▼ 
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ß
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Kai A. OP #3635958
Lesenswert?
• ▲
▼ 
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ß
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren