/* Wenn Aktiv, dann werden an die Verbrucher am Output die von ihnen benötigten Energien gesendet. Die Energie die zum aufladen am Input benötigt wird, wird nur teilweise in elektrische Energie umgesetzt, der rest wird als Wärme an die Radiatoren abgegeben. */ void Battery::calculateStep() { std::vector<Port*> inputEnergy = collectAllActiveSubSystemsWithClassifier(inputStreams_,"Energy[J]"); std::vector<Port*> outputEnergy = collectAllActiveSubSystemsWithClassifier(outputStreams_,"Energy[J]"); std::vector<Port*> inputHeat = collectAllActiveSubSystemsWithClassifier(inputStreams_,"Heat[J]"); std::vector<Port*> outputHeat = collectAllActiveSubSystemsWithClassifier(outputStreams_,"Heat[J]"); double inE = getPortValuesSum(inputEnergy); double outE = getPortValuesSum(outputEnergy); double inH = getPortValuesSum(inputHeat); double outH = getPortValuesSum(outputHeat); if(isActive()) { //Neue Ladung der Batterie. Auf- und Entladung sind verlustbehaftet. double elecE = inE * eff_ - outE * (1/eff_); c_ = c_ + elecE; //Energie die als Wärme beim Auf- und Entladen entsteht. double heat = elecE * (1 - eff_); //Temperaturdiffernz durch Wärme, Heater und Radiatoren double deltaT = (heat - (outH) + inH) / (m_ * heatCap_); //Daraus ergibt sich die Temperatur t_ = t_ + deltaT; //Wenn diese Temperatur größer oder kleiner ist als die Maximalwerte, //dann soll die Batterie keine Energie mehr liefern und auch nicht mehr //aufladen können, was im else Teil der Abfrage geregelt wird. if( (t_<maxT_) && (t_>minT_) ){ //Energie Anforderung an die Input-Energieströme senden. if(c_<mc_){ writePortValuesEqual(inputEnergy,cr_*(*simTime_)); }else{ writePortValuesEqual(inputEnergy,0.0); } //Energie entsprechend der entladerate an die Verbraucher senden, wenn noch if(c_>outE){ std::vector<Port*>::iterator it; for (it = outputEnergy.begin(); it!=outputEnergy.end(); ++it){ double v = (*it)->getValue(); (*it)->setValue(v*dcr_*(*simTime_)); } }else{ writePortValuesEqual(outputEnergy,0.0); } }else{ //Die Batterie soll nicht aufgeladen werden, wenn sie nicht nominell funktioniert writePortValuesEqual(inputEnergy,0.0); //Es soll keine Energie an die Verbruacher gesendet werden, wenn der //Betrieb nicht nominell ist. writePortValuesEqual(outputEnergy,0.0); } //Wärme Anforderung an die Heater senden sobald Abweichung -3 Kelvin beträgt if(t_<tOperating_-3){ double heatDemand = (tOperating_-t_) * m_ * heatCap_; writePortValuesEqual(inputHeat,heatDemand); //Radiation auf Null sezten writePortValuesEqual(outputHeat,0.0); } //Wärme-Abgabe Anforderung an die Radiatoren senden sobald Abweichung von +3 Kelvin if(t_>tOperating_+3){ double radDemand = (t_-tOperating_) * m_ * heatCap_; writePortValuesEqual(outputHeat,radDemand); //Heat auf Null setzen writePortValuesEqual(inputHeat,0.0); } if((t_<tOperating_+3) && (t_>tOperating_-3)){ //Heat und Radiation auf Null setzen writePortValuesEqual(inputHeat,0.0); writePortValuesEqual(outputHeat,0.0); } } if(!isActive()) { writePortValuesEqual(inputEnergy,0.0); writePortValuesEqual(outputEnergy,0.0); writePortValuesEqual(inputHeat,0.0); writePortValuesEqual(outputHeat,0.0); } //Nominal if(((c_/mc_) > 0.15 ) && (t_<maxT_) && (t_>minT_)) setNominal(); //Anzeige von Warnungen if( ((c_/mc_) < 0.15 ) || (t_>(tOperating_+3)) || (t_<(tOperating_-3))) setWarning(); //Anzeige von Fehlern if(((c_/mc_) < 0.00001 ) || (t_>maxT_) || (t_<minT_)) setError(); }
int AbstractMeter::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { _id = WidgetWithBackground::qt_metacall(_c, _id, _a); if (_id < 0) return _id; if (_c == QMetaObject::InvokeMetaMethod) { switch (_id) { case 0: valueChanged((*reinterpret_cast< int(*)>(_a[1]))); break; case 1: valueChanged((*reinterpret_cast< double(*)>(_a[1]))); break; case 2: setValue((*reinterpret_cast< int(*)>(_a[1]))); break; case 3: setValue((*reinterpret_cast< double(*)>(_a[1]))); break; default: ; } _id -= 4; } #ifndef QT_NO_PROPERTIES else if (_c == QMetaObject::ReadProperty) { void *_v = _a[0]; switch (_id) { case 0: *reinterpret_cast< double*>(_v) = minimum(); break; case 1: *reinterpret_cast< double*>(_v) = maximum(); break; case 2: *reinterpret_cast< double*>(_v) = value(); break; case 3: *reinterpret_cast< double*>(_v) = nominal(); break; case 4: *reinterpret_cast< double*>(_v) = critical(); break; case 5: *reinterpret_cast< QString*>(_v) = prefix(); break; case 6: *reinterpret_cast< QString*>(_v) = suffix(); break; case 7: *reinterpret_cast< QFont*>(_v) = valueFont(); break; case 8: *reinterpret_cast< double*>(_v) = valueOffset(); break; case 9: *reinterpret_cast< QFont*>(_v) = digitFont(); break; case 10: *reinterpret_cast< double*>(_v) = digitOffset(); break; } _id -= 11; } else if (_c == QMetaObject::WriteProperty) { void *_v = _a[0]; switch (_id) { case 0: setMinimum(*reinterpret_cast< double*>(_v)); break; case 1: setMaximum(*reinterpret_cast< double*>(_v)); break; case 2: setValue(*reinterpret_cast< double*>(_v)); break; case 3: setNominal(*reinterpret_cast< double*>(_v)); break; case 4: setCritical(*reinterpret_cast< double*>(_v)); break; case 5: setPrefix(*reinterpret_cast< QString*>(_v)); break; case 6: setSuffix(*reinterpret_cast< QString*>(_v)); break; case 7: setValueFont(*reinterpret_cast< QFont*>(_v)); break; case 8: setValueOffset(*reinterpret_cast< double*>(_v)); break; case 9: setDigitFont(*reinterpret_cast< QFont*>(_v)); break; case 10: setDigitOffset(*reinterpret_cast< double*>(_v)); break; } _id -= 11; } else if (_c == QMetaObject::ResetProperty) { _id -= 11; } else if (_c == QMetaObject::QueryPropertyDesignable) { _id -= 11; } else if (_c == QMetaObject::QueryPropertyScriptable) { _id -= 11; } else if (_c == QMetaObject::QueryPropertyStored) { _id -= 11; } else if (_c == QMetaObject::QueryPropertyEditable) { _id -= 11; } else if (_c == QMetaObject::QueryPropertyUser) { _id -= 11; } #endif // QT_NO_PROPERTIES return _id; }