Variablen Vektor zur Berechnung verwenden

[sgwosdek]

Hallo,

ich mache gerade meine Masterarbeit und soll chemische Reaktionen durch Differentialgleichungen (DGL) beschreiben und die Temperaturabhängigkeit dabei betrachten.
Da die Ergebnisse relativ sensibel sind, darf ich hier auch nicht alles posten, deswegen versuche ich es halbwegs verständlich zu verfassen. Der Code ist, so wie er da steht, nicht kompilierbar, und ich halte mich absichtlich nicht an diese Forenregel.

In einer anderen Klasse wird ein Temperaturprofil erstellt. Die Klasse, die die DGL löst, soll nun dieses Temperaturprofil übernehmen, und für jeden Schritt der Berechnung eine neue Temperatur verwenden.

Das ist ein Auszug der Klasse die das Temperaturprofil erstellt und soweit auch funktioniert.

public class Temperatur {
     public static double[] temp;
                 Ausführug
        }
        return temp;
}

Mein Problem ist nun folgendes:
Eine Funktion von hier wird in der anderen Klasse aufgerufen, sodass ein Temperaturprofil erstellt wird.

Fall 1:
Wenn ich mir das in einer for-Schleife ausdrucken lasse, bekomme ich alle Werte richtig angezeigt.

Fall 2:
Wenn ich den Vektor in T_neu speicher, wird nur die letzte Temperatur angezeigt.

for (double i = 0; i<Bedingung;i++){
System.out.println(temp.getTemp(i));
}


T_neu = temp.getTemp(zeit)
System.out.println(T_neu);

Die Krönung ist nun, dass ich an ganz anderer Stelle etwas berechnen muss, dass wiederrum von der Temperatur abhängt. Sagen wir x =a* (T_neu)^2.
Das ganze in einer For Schleife zu berechnen funktioniert zwar, aber dieses x brauche ich für meine DGL. Auch hier wird nur der letzte Wert verwendet.
Mit einer Methode getX kam das gleiche Ergebnis raus.

Bisher steht folgendes da(mit benötigten anderen Methoden etc.), wobei die for Schleife keinen Unterschied bringt. Das Ergebnis ist links dargestellt, es sollte aber das rechte rauskommen (leider per Hand eingefügt)

for (double i = 0; i<=Bedingung; i++){
           
                T_neu = temp.getTemp(time);
               
                x = a*T_neu*T_neu

                // ODEs
               
                ydot[0] = x * y[0];                     // Reaktion 1
                ydot[1] =-x * y[0];                     // Reaktion 2
                ydot[2] = b * ydot[1];                // Reaktion 3
                ydot[3] = c * ydot[1];                // Reaktion 4



T_neu   x       T_neu  x
 2      25         2   4
 3      25         3   9   
 4      25         4   16
 5      25         5   25

Ich habe nun alle Möglichkeiten ausprobiert die ich nach einem Monat Java kenne (Arrays, selbst als neue DGL, mit getter, noch mehr Methoden und ein paar andere) aber ohne richtiges Ergebnis.
Ich habe im Internet auch schon gesucht, aber wahrscheinlich falsch. Bisher habe ich nichts gefunden bzw die Lösung dann übersehen.

Hat noch jemand Ideen, bzw Vorschläge, nach was ich suchen kann, um den Vektor so hinbekommen, dass in den Berechnungen der DGL auch das ensprechende x verwendet wird und nicht das letzte?

Vielen Dank
sgwosdek

 

[knilch]

Hi,
Ist gar nicht so einfach, den Fehler zu finden, wenn nur snippets zu sehen sind... Mir sieht das hier irgendwie strange aus:

for (double i = 0; i<=Bedingung; i++) {
   T_neu = temp.getTemp(time);
   ...
}

Die variable: time wird innerhalb von diesem for-loop nie irgenwie inkrementiert, dekrementiert oder sonst irgendwie verändert. Egal wie oft der for-loop durchlaufen wird ist T_neu immer gleich...
Wenn T_neu sich innerhalb vom for-loop ändern muss, dann musst du schauen, dass auch time innerhalb vom for-loop verändert wird.
Vielleicht so?

for (double i = 0; i<=Bedingung; i++) {
   T_neu = temp.getTemp(i);
   ...
}

 

[sgwosdek]

Hi,
danke für die schnelle Antwort.
Ja es stimmt, das sieht auf den ersten Blick komisch aus.
Die Schleife funktioniert sogar mit beiden Ausdrücken, nur wird trotzdem leider nur der Letzte Eintrag für die Berechnung verwendet.

public void computeDerivatives(double time, double[] y, double[] ydot)
                throws MaxCountExceededException, DimensionMismatchException {
                      
    for (double i = 0; i<=endtime; i=i+delta_time_h){
          
        T_neu = temperatures.getTemp(time);
//         T_neu = temperatures.getTemp(i);
              
                x = a*T_neu*T_neu

                // ODEs
             
                ydot[0] = x * y[0];                     // Reaktion 1
                ydot[1] =-x * y[0];                     // Reaktion 2
                ydot[2] = b * ydot[1];                // Reaktion 3
                ydot[3] = c * ydot[1];                // Reaktion 4

        }
}

Aber ich versuche gerade mit der Klammer der for-Schleife zu spielen und an verschiedenen Stellen zu positionieren, vielleicht kommt dann was bei raus.

 

[sgwosdek]

        public void computeDerivatives(double time, double[] y, double[] ydot)
                throws MaxCountExceededException, DimensionMismatchException {
            
            for (int i=0 ; i<=Bedingung; i++){
        
            double [] T_neu = new double [Bedingung];
            double [] x = new double[Bedingung];
            T_neu[i] = getTemp(i);
                
                x[i] = a* T_neu[i] * T_neu[i]
        
                System.out.println(i + ";"+T_neu[i] + ";"+x[i]
                 + ";"+getState(i,0) +);  //getState gibt das Ergebnis der Ableitung aus

                // ODEs
            
                        ydot[0] = x[i] * y[0];                     // Reaktion 1
                        ydot[1] =-x[i] * y[0];                     // Reaktion 2
                        ydot[2] = b * ydot[1];                // Reaktion 3
                        ydot[3] = c * ydot[1];                // Reaktion 4
}
}

So, ich habe nun mit Arrays rumprobiert. Die T_neu und x Abhängigkeit funktioniert auf diese Weise, nur klappt die Berechnng der Ableitungen noch nicht. Da vermute ich aber dass die Dimensionen nicht so richtig passen, das werde ich heute Abend weiter verfolgen

 

[sgwosdek]

So, ich habe was rausbekommen, aber fragt jetzt bitte nicht wie

for (int i=0 ; i<=Bedingung; i++){
           
            double [] T_neu = new double [Bedingung];     //vectors of length Bedingungen
            double [] x = new double[Bedingung];
            T_new[i] = temperatures.getTemp(i);
  
     x[i] = a * T_neu[i] *   T_neu[i]         
               
                // ODEs               
                ydot[0] = x * y[0];                     // Reaktion 1
                ydot[1] =-x * y[0];                     // Reaktion 2
                ydot[2] = b * ydot[1];                // Reaktion 3
                ydot[3] = c * ydot[1];                // Reaktion 4
              
               
                System.out.println(i + "    "+T_neu[i] + "    "+x[i] + "    "
                        +ydot[0] +"    "+ydot[1] +"    "+ydot[2] +"    "+ydot[3]);

Das ganze löst zwar noch nicht die DGL, gibt aber erstmal die Änderungen durch die Temperatur wieder.
Wenn jemand noch auf eine bessere/schnellere/einfachere Idee kommt, stehe ich den Vorschlägen offen gegenüber, immerhin ist meine Lösung nun wirklich nicht das Gelbe vom Ei.