/*
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;
}
