/** * Mit dieser Methode kann ein Massenelement eines Gases mit der Temperatur T_m der Zone mit der * Temperatur T_Zone zugemischt werden. Die sich ergebende Mischungstemperatur wird für * VERÄNDERLICHE CVs und ein adiabates System nach dem ersten HS berechnet. Das Volumen der Zone * bleibt Konstant --> das zugemischte Massenelement leistet Verschiebearbeit! * * @param m_Zu --> zugemischtes Massenelement [kg] * @param T_Zu --> Temperatur des zugemischten Massenelements [K] * @param s_Zu --> Zusammensetzung des Massenelements */ public void massenElementZumischenKonstVol(double m_Zu, double T_Zu, Spezies s_Zu) { // adiabate Mischungstemperatur nach dem ersten Hauptsatz double Tm = 278.15, U1, U_zu, U1m, U_zum, Cvm1, Cv_zum, F, dF, Tm_buffer; U1 = gg_Zone.get_u_mass(T_Zone) * m_Zone; U_zu = s_Zu.get_u_mass(T_Zu) * m_Zu; int idx = 0; // Newtonverfahren für F(Tm)= U1(T1)+U2(T2)-U1(Tm)-U2(Tm)=0 // mit dF/dT=-m1*Cv1(Tm)-m2*Cv2(Tm) do { Tm_buffer = Tm; U1m = gg_Zone.get_u_mass(Tm) * m_Zone; U_zum = s_Zu.get_u_mass(Tm) * m_Zu; Cvm1 = gg_Zone.get_cv_mass(Tm) * m_Zone; Cv_zum = s_Zu.get_cv_mass(Tm) * m_Zu; F = U1 + U_zu - U1m - U_zum; dF = -Cvm1 - Cv_zum; Tm = Tm - F / dF; idx++; } while (idx < 1000 && Math.abs(Tm - Tm_buffer) > 0.1); if (idx >= 1000) { try { throw new MiscException("t"); } catch (MiscException me) { me.log_Warning("Mangelnde Konvergenz bei der Berechnung der Mischungstemperatur"); } } T_Zone = Tm; // dieser Aufruf muss nach der Temperaturberechnung erfolgen da sich hier die Masse der Zone // ändert massenElementZumischen(m_Zu, s_Zu); }
/** * Erzeugt eine Zonen mit den angegebenen Startparametern * * @param p_init * @param V_init * @param T_init * @param m_init * @param gg GasGemsich oder Spezies * @param burns * @param id */ public Zone( CasePara cp, double p_init, double V_init, double T_init, double m_init, Spezies gg, boolean burns, int id) { CP = cp; // if(Bremo.get_casePara().get_zonenVerwaltung().existsID(id)) // throw new IllegalArgumentException("Zone: " + // "Es wurde versucht eine Zone mit einer bereits bestehenden ID zu erzeugen"); this.GG_SOLVER = cp.OHC_SOLVER; this.ID = id; // TODO ZonenID automatisch Verwalten? this.gg_Zone = new GasGemisch("ggZone" + id); this.burns = burns; Hashtable<Spezies, Double> einzelMassen = new Hashtable<Spezies, Double>(); if (gg.isGasGemisch() && !CP.SPEZIES_FABRIK.isToIntegrate(gg)) { einzelMassen = this.get_einzelMassenHash( ((GasGemisch) gg).get_speziesMassenBruecheDetailToIntegrate(), m_init); } else { einzelMassen.put(gg, m_init); } this.set_p_V_T_mi(p_init, V_init, T_init, einzelMassen); }
/** * Mit dieser Methode kann eine Zone mit einer anderen gemischt werden. Das Volumen der beiden * Zonen wird addiert entsprechent wird keine Verschiebearbeit geleistet. Temperaur, Masse und * Zusammensetzung werden entsprechend {@link massenElementZumischen} berechnet * * @param Zone zone2 --> die Zone die zugemischt werden soll */ public void zoneZumischen(Zone zone2) { double m_Zu = zone2.get_m(); double T_Zu = zone2.get_T(); double V_Zu = zone2.get_V(); Spezies s_Zu = zone2.get_ggZone(); // Nach dem 1HS gilt: -pdV+dm*h=dU --> -p*deltaV+deltaH=deltaU=U2-U1 --> U2=U1+deltaH-p*deltaV double H_zu = m_Zu * s_Zu.get_h_mass(T_Zu); // deltaV=V_zu außerdem ist der Druck in beiden Zonen identisch double U2_Zone_mass = m_Zone * gg_Zone.get_u_mass(T_Zone) + H_zu - p_Zone * V_Zu; // dieser Aufruf muss vor der Temperaturberechnung erfolgen da sich hier die Masse und die // Zusammensetzung // der Zone ändert massenElementZumischen(m_Zu, s_Zu); // Berechnen der Mischungstemperatur T_Zone = gg_Zone.get_T4u_mass(U2_Zone_mass / m_Zone); }
/** * Mit dieser Methode kann ein Massenelement eines Gases mit der Temperatur T_m der Zone mit der * Temperatur T_Zone zugemischt werden. Die sich ergebende Mischungstemperatur wird für * VERÄNDERLICHE CVs und ein adiabates System nach dem ersten HS berechnet. Das Volumen der Zone * bleibt Konstant --> das zugemischte Massenelement leistet Verschiebearbeit! * * @param m_Zu --> zugemischtes Massenelement [kg] * @param T_Zu --> Temperatur des zugemischten Massenelements [K] * @param s_Zu --> Zusammensetzung des Massenelements */ public void massenElementZumischenKonstVolEinfacher(double m_Zu, double T_Zu, Spezies s_Zu) { // Nach dem 1HS gilt: dm*h=dU double dH = m_Zu * s_Zu.get_h_mass(T_Zu); double U_Zone_mass_temp = m_Zone * gg_Zone.get_u_mass(T_Zone) + dH; // dieser Aufruf muss vor der Temperaturberechnung erfolgen da sich hier die Masse und die // Zusammensetzung // der Zone ändert massenElementZumischen(m_Zu, s_Zu); // Berechnen der Mischungstemperatur U_Zone_mass_temp = U_Zone_mass_temp / m_Zone; T_Zone = gg_Zone.get_T4u_mass(U_Zone_mass_temp); }
public double get_bY() { Enumeration<Spezies> e; Spezies spez; double sum_dmj_Rj = 0D; e = dmj_ein.keys(); while (e.hasMoreElements()) { spez = e.nextElement(); sum_dmj_Rj = sum_dmj_Rj + dmj_ein.get(spez) * spez.get_R(); } e = null; e = dm_aus.keys(); while (e.hasMoreElements()) { spez = e.nextElement(); sum_dmj_Rj = sum_dmj_Rj - dm_aus.get(spez) * spez.get_R(); } double bY = T_Zone * sum_dmj_Rj; return bY; }
public static Zone zonenMischen(CasePara cp, Zone z1, Zone z2, boolean burns, int ID) { double p = z1.get_p(); // fuer beide Zonen gleich double m1 = z1.get_m(); double T1 = z1.get_T(); double V1 = z1.get_V(); Spezies s1 = z1.get_ggZone(); double m2 = z2.get_m(); double T2 = z2.get_T(); double V2 = z2.get_V(); Spezies s2 = z2.get_ggZone(); // Erzeugen einer Spezies die durch die Mischung der beiden ZonenSpezies entsteht GasGemisch s0 = new GasGemisch("zonenGemisch"); Hashtable<Spezies, Double> ht0 = new Hashtable<Spezies, Double>(3); double mGes = m1 + m2; ht0.put(s1, m1 / mGes); ht0.put(s2, m2 / mGes); s0.set_Gasmischung_massenBruch(ht0); // Berechnung der Mischungstemperatur // 1.HS --> Kontrollraumgrenze wird um beide Zonen gelegt // Dann gilt: Umisch=U1+U2; double Umisch = m1 * s1.get_u_mass(T1) + m2 * s2.get_u_mass(T2); // Berechnung der Temperatur bei der die innere Energie von Spezies s0=Umisch ist. // Dies entspricht der Mischungstemperatur double T0 = s0.get_T4u_mass(Umisch / mGes); // Das Volumen beider Zonen wird addiert double V0 = V1 + V2; // Test ob alles stimmt double pV = z1.get_p() * V0; double mRT = mGes * T0 * s0.get_R(); double T = (m1 * s1.get_cv_mass(T1) * T1 + m2 * s2.get_cv_mass(T2) * T2) / (m1 * s1.get_cv_mass(T1) + m2 * s2.get_cv_mass(T2)); double deltaT = (T - T0) / T0 * 100; double T3 = pV / mGes / s0.get_R(); double mRT2 = mGes * T * s0.get_R(); double mRT3 = mGes * T3 * s0.get_R(); // Fazit ueber die Gasgleichung geht es auch und zwar viel einfacher und genauer! Zone z0 = new Zone(cp, p, V0, T0, mGes, s0, burns, ID); return z0; }
/** * Mit dieser Methode kann ein Massenelement eines Gases der Zone zugemischt werden. --> es wird * nur die Zusammensetzung und die Gesamtmasse der Zone geändert nicht aber die Temperatur * * @param idx --> Rechenindex * @param mZu --> zugemischtes Massenelement [kg] * @param sZu --> SpeziesObjekt des Massenelements */ public void massenElementZumischen(double mZu, Spezies sZu) { Hashtable<Spezies, Double> massenBruchHash_Zone = gg_Zone.get_speziesMassenBruecheDetail(); Hashtable<Spezies, Double> massenBruchHashNeu = new Hashtable<Spezies, Double>(4); double m_Zone_neu = mZu + m_Zone; if (m_Zone_neu < 0) { try { throw new MiscException( "ERROR: Aus Zone " + ID + " wird mehr Masse entnommen als vorhanden ist"); } catch (MiscException miscE) { miscE.stopBremo(); } } Hashtable<Spezies, Double> einzelMassenHashIn = new Hashtable<Spezies, Double>(); // einzelmassen der zugefuehrten Spezies bestimmen if (mZu < 0) { if (sZu.isGasGemisch()) { einzelMassenHashIn = // enthaelt negative Werte!! this.get_einzelMassenHash(((GasGemisch) sZu).get_speziesMassenBruecheDetail(), mZu); } else { einzelMassenHashIn.put(sZu, mZu); } // einzelmassen der Zone bestimmen Hashtable<Spezies, Double> einzelMassenHashZone = this.get_einzelMassenHash(massenBruchHash_Zone, m_Zone); // Addieren der einzelnen Massen von Zone und sZu Enumeration<Spezies> e = einzelMassenHashZone.keys(); Spezies spez; double mTemp; while (e.hasMoreElements()) { spez = e.nextElement(); mTemp = einzelMassenHashZone.get(spez); if (einzelMassenHashIn.containsKey(spez)) mTemp = mTemp + einzelMassenHashIn.get(spez); // Wert in Hashtable ist negativ double massenBruch = mTemp / m_Zone_neu; massenBruchHashNeu.put(spez, massenBruch); if (massenBruch < 0) { // kommt vor wenn eine Masse entnommen werden soll die gar nicht in der Zone ist! try { throw new MiscException( "ERROR: In einer Zone tritt ein negativer Massenbruch auf \n" + spez.get_name() + ": " + massenBruch); } catch (MiscException miscE) { massenBruchHashNeu.put(spez, 0d); // miscE.stopBremo(); //TODO check mich } } } } else { massenBruchHashNeu.put(gg_Zone, m_Zone / m_Zone_neu); if (massenBruchHashNeu.containsKey( sZu)) { // ==True wenn der Zone eine Masse von sich selbst zugefuehrt wird massenBruchHashNeu.put(gg_Zone, 1D); } else massenBruchHashNeu.put(sZu, mZu / m_Zone_neu); } Hashtable<Spezies, Double> molenBruchHash = new Hashtable<Spezies, Double>(4); molenBruchHash = GasGemisch.Gasmischer.massenBruch2molenBruch(massenBruchHashNeu); GasGemisch gasGemisch = new GasGemisch(molenBruchHash, ""); // würde man hier die gg_Zone.set_Gasmischung_molenBruch(gasGemisch.get_speziesMolenBruecheDetail()); m_Zone = m_Zone_neu; }
public void set_dm_ein(double dm_zu, double T_zu, Spezies spez_zu) { if (dm_zu < 0) { throw new IllegalArgumentException( "Es wurde versucht die Methode \"set_massenstrom_ein()\" " + "mit einen negativen Massenstrom aufzurufen"); } if (dm_zu != 0) { // wenn die Masse null ist mach garnichts // Berechnen des Energiestroms double dU = spez_zu.get_u_mass(T_Zone) * dm_zu; sumdU = sumdU + dU; double dH = spez_zu.get_h_mass(T_zu) * dm_zu; sumdH = sumdH + dH; // Hinzufügen der Einzelmassen der zugefügten Spezies zur Hashtable dmj Hashtable<Spezies, Double> einzelMassenHash_zu = new Hashtable<Spezies, Double>(); if (spez_zu.isGasGemisch() && CP.SPEZIES_FABRIK.isToIntegrate(spez_zu) == false) { Hashtable<Spezies, Double> massenBruchHash_zu = ((GasGemisch) spez_zu).get_speziesMassenBruecheDetailToIntegrate(); // Erstellen der Hashtable mit den Einzelmassen der Grundspezies (CO2, O2, usw.... einzelMassenHash_zu = this.get_einzelMassenHash(massenBruchHash_zu, dm_zu); } else { einzelMassenHash_zu.put(spez_zu, dm_zu); } // Hinzufügen der Änderung der Grundspeziesmassen Enumeration<Spezies> e = einzelMassenHash_zu.keys(); Spezies spez; while (e.hasMoreElements()) { spez = e.nextElement(); if (!CP.SPEZIES_FABRIK.isToIntegrate(spez)) { try { throw new BirdBrainedProgrammerException( "In Zone " + this.ID + " wurde eine Spezies " + "(" + spez.get_name() + ") eingebracht die nicht integriert werden soll" + " (isToIntegrate() liefert false)"); } catch (BirdBrainedProgrammerException bbpe) { bbpe.stopBremo(); } } if (dmj_ein.containsKey(spez)) { dmj_ein.put(spez, einzelMassenHash_zu.get(spez) + dmj_ein.get(spez)); } else { dmj_ein.put(spez, einzelMassenHash_zu.get(spez)); } } // e=null; // e=einzelMassenHash_zu.keys(); // spez=null; // double dmCheck=0; // while(e.hasMoreElements()){ // spez=e.nextElement(); // dmCheck+=einzelMassenHash_zu.get(spez); // } // if(dmCheck!=dm_zu) // System.out.println("Zone.set_dm_ein: dm_zu !=dmCheck " +((dmCheck-dm_zu))); } }
/** * Berechnet den Massenverlust bei entnahme einer BESTIMMTEN Spezies Dieser Aufruf sollte nur vom * einzonigen Modell benoetigt werden * * @param dm_a [kg] muss groeser Null sein * @throws NegativeMassException */ public void set_dm_aus(double dm_a, Spezies spez) throws NegativeMassException { if (dm_a < 0) throw new IllegalArgumentException( "\"set_dm_aus()\" wurde fuer Zone " + ID + " mit einem negativen Massenstrom aufgerufen"); if (dm_a > 0) { // Hinzufügen der Einzelmassen der entnommenen Spezies zur Hashtable dmj Hashtable<Spezies, Double> einzelMassenHash_aus = new Hashtable<Spezies, Double>(); if (spez.isGasGemisch() && CP.SPEZIES_FABRIK.isToIntegrate(spez) == false) { Hashtable<Spezies, Double> massenBruchHash_aus = ((GasGemisch) spez).get_speziesMassenBruecheDetailToIntegrate(); // Erstellen der Hashtable mit den Einzelmassen der Grundspezies (CO2, O2, usw.... einzelMassenHash_aus = this.get_einzelMassenHash(massenBruchHash_aus, dm_a); } else { einzelMassenHash_aus.put(spez, dm_a); } // Hinzufügen der Änderung der Grundspeziesmassen Enumeration<Spezies> e = einzelMassenHash_aus.keys(); Spezies spez1; while (e.hasMoreElements()) { spez1 = e.nextElement(); if (!CP.SPEZIES_FABRIK.isToIntegrate(spez1)) { try { throw new BirdBrainedProgrammerException( "Aus Zone " + this.ID + " wurde eine Spezies " + "(" + spez1.get_name() + ") entnommen die nicht integriert werden soll" + " (\"isToIntegrate()\" liefert false)"); } catch (BirdBrainedProgrammerException bbpe) { bbpe.stopBremo(); } } if (!gg_Zone.get_speziesMassenBruecheDetailToIntegrate().containsKey(spez1) && einzelMassenHash_aus.get(spez1) > 0) // Es kann sein, dass Spezies mit einem Massenbruch von 0 in der Hashtable // stehen throw new NegativeMassException( "Aus Zone " + this.ID + " soll eine Spezies" + "(" + spez1.get_name() + ") entnommen werden " + "die in der Zone nicht vorhanden ist"); } e = null; e = einzelMassenHash_aus.keys(); spez1 = null; while (e.hasMoreElements()) { spez1 = e.nextElement(); if (this.dm_aus.containsKey(spez1)) { this.dm_aus.put(spez1, einzelMassenHash_aus.get(spez1) + dm_aus.get(spez1)); } else { this.dm_aus.put(spez1, einzelMassenHash_aus.get(spez1)); } } // e=null; // e=einzelMassenHash_aus.keys(); // spez1=null; // double dmCheck=0; // while(e.hasMoreElements()){ // spez1=e.nextElement(); // dmCheck+=einzelMassenHash_aus.get(spez1); // } // if(dmCheck!=dm_a) // System.out.println("Zone.set_dm_aus: dm_a !=dmCheck " + ((dmCheck-dm_a)) ); // das hier muss nach der NegativeMassException stehen!! Wenn die Exception geworfen // wird und dieser Code ist schon ausgefuehrt wuerde die Energie aber nicht dei Masse // beruecksichtigt double dU = spez.get_u_mass(T_Zone) * dm_a; sumdU = sumdU - dU; double dH = spez.get_h_mass(T_Zone) * dm_a; sumdH = sumdH - dH; } }
public void set_p_V_T_mi( double p_init, double V_init, double T_init, Hashtable<Spezies, Double> mi) { this.p_Zone = p_init; this.V_Zone = V_init; this.T_Zone = T_init; if (p_Zone <= 0 || V_Zone <= 0 || T_Zone <= 0 || (((Double) p_Zone).isNaN()) || (((Double) T_Zone).isNaN()) || (((Double) V_Zone).isNaN())) { try { throw new NegativeMassException( "Falsche Werte in Zone " + this.ID + "\n V= " + V_Zone + "\n p= " + p_Zone + "\n T= " + T_Zone); } catch (NegativeMassException nmE) { nmE.log_Warning(); } } if (CP.get_aktuelle_Rechenzeit() > CP.SYS.WRITE_INTERVAL_SEC) { // System.out.println("xsi: "+this.get_xsi()); // System.out.println("eta: " +this.get_eta()); } if (T_Zone > T_max_Zone) T_max_Zone = T_Zone; // Überprüfen ob die Berechnung der Dissoziation Sinn macht if (T_max_Zone >= GG_SOLVER.get_T_Freeze() && burns) loeseChemGleichgwicht = true; // Berechnen der Gesamtmasse double mGes = 0.0D; double mi_; Enumeration<Spezies> e = mi.keys(); Spezies spez; while (e.hasMoreElements()) { spez = e.nextElement(); mi_ = mi.get(spez); if (mi_ < 0) { if (Math.abs(mi_) >= 0.00001 * CP.SYS.MINIMALE_ZONENMASSE) { try { throw new NegativeMassException( spez.get_name() + " in Zone " + this.ID + " hatte eine negative Masse (" + mi_ + "kg). Die Masse wurde auf null gesetzt!"); } catch (NegativeMassException nmE) { nmE.log_Warning(); } } mi_ = 0; mi.put(spez, mi_); } mGes = mGes + mi_; } spez = null; e = null; this.m_Zone = mGes; if (this.m_Zone > 0) { // Berechnen der Massenbrueche Hashtable<Spezies, Double> massenBrueche = new Hashtable<Spezies, Double>(); e = mi.keys(); double xi; while (e.hasMoreElements()) { spez = e.nextElement(); xi = mi.get(spez) / mGes; massenBrueche.put(spez, xi); } gg_Zone.set_Gasmischung_massenBruch(massenBrueche); // Berechnen der Dissoziation if (loeseChemGleichgwicht == true) gg_Zone.set_Gasmischung_molenBruch(GG_SOLVER.get_GG_molenBrueche(p_Zone, T_Zone, gg_Zone)); } else { Hashtable<Spezies, Double> massenBrueche = new Hashtable<Spezies, Double>(); Spezies co2 = CP.SPEZIES_FABRIK.get_spezCO2(); massenBrueche.put(co2, 1D); // TODO irgendwie uncool gg_Zone.set_Gasmischung_massenBruch(massenBrueche); } double pV = p_Zone * V_Zone; double mRT = m_Zone * gg_Zone.get_R() * T_Zone; // This accounts for inaccuracy during the integration process. // The differences in temperature should be very very small!! // if(CP.get_time()>CP.convert_KW2SEC(5.2)) // System.out.println(); if (pV != mRT && m_Zone > 0 && V_Zone > 0) { // System.out.println("(pV-mRT)/pV: "+(pV-mRT)/pV*100); double T_temp = pV / m_Zone / gg_Zone.get_R(); this.T_Zone = T_temp; double chkPv = pV - m_Zone * gg_Zone.get_R() * T_temp; double chkT = Math.abs((T_Zone - T_temp) / T_temp); if (chkT > 7.555e-3 && m_Zone > CP.SYS.MINIMALE_ZONENMASSE) { try { throw new MiscException( "The temperature of zone " + this.ID + " had to be adjusted too much! " + "chkT= " + chkT); } catch (MiscException me) { me.log_Warning(); } } } dmj_ein = new Hashtable<Spezies, Double>(); dm_aus = new Hashtable<Spezies, Double>(); sumdQ = 0; sumdH = 0; sumdU = 0; dudp = this.calc_dudp_dRdp()[0]; dRdp = this.calc_dudp_dRdp()[1]; dudT = this.calc_dudT_dRdT()[0]; dRdT = this.calc_dudT_dRdT()[1]; }