diff --git a/Zero_engine.alpx b/Zero_engine.alpx index 7e6a20b9..fd1f76e8 100644 --- a/Zero_engine.alpx +++ b/Zero_engine.alpx @@ -1351,12 +1351,6 @@ 1752677832758 - - 1666189454453 - - true - 1752677832758 - 1666879973864 @@ -1412,12 +1406,6 @@ 1752680962144 - - 1678469210821 - - true - 1752677832758 - 1692861398767 diff --git a/Zero_engine.original.alp b/Zero_engine.original.alp index b94f0f0d..349fb79a 100644 --- a/Zero_engine.original.alp +++ b/Zero_engine.original.alp @@ -1,8 +1,8 @@ + AnyLogicVersion="8.9.7.202512010504" + AlpVersion="8.9.7"> 1658477103134 Zero_engine @@ -1063,6 +1063,14 @@ 1764776053512 hotWaterConsumption_kW + + 1762354709855 @@ -3493,7 +3501,7 @@ energyModel.c_connectionOwners.add(this); NONE false - false + true 1745927932566 @@ -3504,6 +3512,34 @@ energyModel.c_connectionOwners.add(this); + + 1763647266429 + b_dataIsAccessible + 60 + 550 + + false + true + true + + boolean + NONE + false + + true + + + 1763647266427 + CHECK_BOX + 0 + 100 + NO_DELIMETER + + + 1679502158516 c_actorContracts @@ -19830,6 +19866,9 @@ c_assetManagement.remove(assetManagement); b_dataSharingAgreed + + b_dataIsAccessible + true @@ -33102,7 +33141,7 @@ public void f_operateFlexAssets(){ true true - double + int NONE false @@ -33667,7 +33706,7 @@ else{ 0 0.0 -16777216 - Charging Centre Functions + Charging Station Parameters SansSerif 14 @@ -48273,7 +48312,8 @@ public class J_EAConversion extends zero_engine.J_EA implements Serializable {&# @Override public void f_updateAllFlows(double powerFraction_fr) { - if ( powerFraction_fr < 0 ) { + powerFraction_fr = roundToDecimal(powerFraction_fr, J_GlobalParameters.floatingPointPrecision); + if(powerFraction_fr < 0) { throw new RuntimeException("Impossible to operate conversion asset with negative powerfraction."); } else if ( powerFraction_fr == 0 ) { @@ -48390,15 +48430,24 @@ public class J_EAConsumption extends zero_engine.J_EA implements Serializable {& profilePointer = profile; } this.activeConsumptionEnergyCarriers.add(this.energyCarrier); - if (this.energyAssetType == OL_EnergyAssetType.ELECTRIC_HOB) { - this.assetFlowCategory = OL_AssetFlowCategories.electricHobConsumption_kW; // - } - else if (this.energyCarrier == OL_EnergyCarriers.ELECTRICITY) { - this.assetFlowCategory = OL_AssetFlowCategories.fixedConsumptionElectric_kW; // + + if (this.energyCarrier == OL_EnergyCarriers.ELECTRICITY) { + if (this.energyAssetType == OL_EnergyAssetType.ELECTRIC_HOB) { + this.assetFlowCategory = OL_AssetFlowCategories.electricHobConsumption_kW; // + } + else { + this.assetFlowCategory = OL_AssetFlowCategories.fixedConsumptionElectric_kW; // + } } - else if (this.energyAssetType == OL_EnergyAssetType.HOT_WATER_CONSUMPTION) { - this.assetFlowCategory = OL_AssetFlowCategories.hotWaterConsumption_kW; + else if (this.energyCarrier == OL_EnergyCarriers.HEAT) { + if (this.energyAssetType == OL_EnergyAssetType.HOT_WATER_CONSUMPTION) { + this.assetFlowCategory = OL_AssetFlowCategories.hotWaterConsumption_kW; + } + else { + this.assetFlowCategory = OL_AssetFlowCategories.spaceHeating_kW; + } } + registerEnergyAsset(); } @@ -49577,6 +49626,7 @@ public class J_EABuilding extends zero_engine.J_EAStorageHeat implements Seriali this.activeProductionEnergyCarriers.add(OL_EnergyCarriers.HEAT); this.activeConsumptionEnergyCarriers.add(OL_EnergyCarriers.HEAT); + this.assetFlowCategory = OL_AssetFlowCategories.buildingHeating_kW; registerEnergyAsset(); } @@ -49682,7 +49732,9 @@ public class J_EABuilding extends zero_engine.J_EAStorageHeat implements Seriali /*if (Double.isNaN(this.energyUse_kW)) { throw new RuntimeException("Building thermal model energyUse_kW is NaN!"); }*/ - + if (this.assetFlowCategory != null) { + assetFlowsMap.put(this.assetFlowCategory, inputPower_kW); + } } @@ -56101,6 +56153,7 @@ public class J_EAAirco extends zero_engine.J_EA implements Serializable { 1749649002419 J_ChargingSession + 1752680962144 /** * J_ChargingSession */ @@ -56456,20 +56509,9 @@ import java.util.EnumSet; public class J_ChargingManagementSimple implements I_ChargingManagement { private GridConnection gc; - private OL_ChargingAttitude activeChargingType; - private double electricityPriceLowPassed_eurpkWh = 0.1; - private double priceFilterTimeScale_h = 5*24; - private double priceFilterDiffGain_r; - private EnumSet<OL_ChargingAttitude> supportedChargingTypes = EnumSet.noneOf(OL_ChargingAttitude.class); - + private OL_ChargingAttitude activeChargingType = OL_ChargingAttitude.SIMPLE; private boolean V2GActive = false; - - //Stored - private double storedElectricityPriceLowPassed_eurpkWh; - - - //private double GCdemandLowPassed_kW = 0.5; - //private double GCdemandFilterTimeScale_h = 5*24; + /** * Default constructor */ @@ -56479,73 +56521,30 @@ public class J_ChargingManagementSimple implements I_ChargingManagement { public J_ChargingManagementSimple( GridConnection gc ) { this.gc = gc; - this.priceFilterDiffGain_r = 1/(priceFilterTimeScale_h/gc.energyModel.p_timeStep_h); - this.supportedChargingTypes.add(OL_ChargingAttitude.SIMPLE); - this.supportedChargingTypes.add(OL_ChargingAttitude.PRICE); - this.activeChargingType = OL_ChargingAttitude.SIMPLE; } public OL_ChargingAttitude getCurrentChargingType() { return activeChargingType; } - public void setCurrentChargingType(OL_ChargingAttitude chargeTypeRequest) { - if (supportedChargingTypes.contains(chargeTypeRequest)) { - this.activeChargingType = chargeTypeRequest; - } else { - throw new RuntimeException("Unsupported charging type for J_ChargingManagementSimple"); - } - } /** * One of the simplest charging algorithms. * */ public void manageCharging() { double t_h = gc.energyModel.t_h; - //double currentElectricityPriceConsumption_eurpkWh = gc.p_owner.f_getElectricityPrice(gc.v_liveConnectionMetaData.contractedDeliveryCapacity_kW); - double currentElectricityPriceConsumption_eurpkWh = gc.energyModel.pp_dayAheadElectricityPricing_eurpMWh.getCurrentValue() * 0.001; - electricityPriceLowPassed_eurpkWh += (currentElectricityPriceConsumption_eurpkWh-electricityPriceLowPassed_eurpkWh) * priceFilterDiffGain_r ; - /*// Little experiment, use current GC-load (so without EV charging!) as an equivalent price signal, and apply the same price-based smart charging and V2G algorithm. - GCdemandLowPassed_kW += (gc.fm_currentBalanceFlows_kW.get(OL_EnergyCarriers.ELECTRICITY) - GCdemandLowPassed_kW) * priceFilterDiffGain_r; - electricityPriceLowPassed_eurpkWh = gc.fm_currentBalanceFlows_kW.get(OL_EnergyCarriers.ELECTRICITY); - currentElectricityPriceConsumption_eurpkWh = gc.v_previousPowerElectricity_kW; - */ - //traceln("Current price: %s eurpkWh, filtered price: %s eurpkWh", currentElectricityPriceConsumption_eurpkWh, electricityPriceLowPassed_eurpkWh); for (J_EAEV ev : gc.c_electricVehicles) { - if (ev.available) { - if (this.activeChargingType != OL_ChargingAttitude.SIMPLE) { - double chargeNeedForNextTrip_kWh = ev.energyNeedForNextTrip_kWh - ev.getCurrentStateOfCharge_kWh(); // Can be negative if recharging is not needed for next trip! - double remainingFlexTime_h = ev.getChargeDeadline_h() - t_h; // measure of flexiblity left in current charging session. - double WTPoffset_eurpkW = 0.01; // Drops willingness to pay price for charging, combined with remainingFlexTime_h. - double chargeSetpoint_kW = 0; - if ( t_h >= (ev.getChargeDeadline_h()) && chargeNeedForNextTrip_kWh > 0) { // Must-charge time at max charging power - //traceln("Urgency charging in GC: %s! May exceed connection capacity!", gc.p_gridConnectionID)); - chargeSetpoint_kW = ev.getCapacityElectric_kW(); - } else { - double WTPCharging_eurpkWh = electricityPriceLowPassed_eurpkWh - WTPoffset_eurpkW * remainingFlexTime_h; //+ urgencyGain_eurpkWh * ( max(0,maxSpreadChargingPower_kW) / ev.getCapacityElectric_kW() ); // Scale WTP based on flexibility expressed in terms of power-fraction - //WTPprice_eurpkWh = WTPoffset_eurpkWh + (main.v_epexNext24hours_eurpkWh+v_electricityPriceLowPassed_eurpkWh)/2 + flexibilityGain_eurpkWh * sqrt(maxSpreadChargingPower_kW/maxChargingPower_kW); - double priceGain_r = 0.5; // When WTP is higher than current electricity price, ramp up charging power with this gain based on the price-delta. - chargeSetpoint_kW = max(0, ev.getCapacityElectric_kW() * (WTPCharging_eurpkWh / currentElectricityPriceConsumption_eurpkWh - 1) * priceGain_r); - //if ( chargeNeedForNextTrip_kWh < -ev.getCapacityElectric_kW()*gc.energyModel.p_timeStep_h && chargeSetpoint_kW == 0 ) { // Surpluss SOC and high energy price - if ( this.V2GActive && ev.getV2GCapable() && remainingFlexTime_h > 1 && chargeSetpoint_kW == 0 ) { // Surpluss SOC and high energy price - double V2G_WTS_offset_eurpkWh = 0.02; // Price must be at least this amount above the moving average to decide to discharge EV battery. - double WTSV2G_eurpkWh = V2G_WTS_offset_eurpkWh + electricityPriceLowPassed_eurpkWh; // Scale WillingnessToSell based on flexibility expressed in terms of power-fraction - chargeSetpoint_kW = min(0, -ev.getCapacityElectric_kW() * (currentElectricityPriceConsumption_eurpkWh / WTSV2G_eurpkWh - 1) * priceGain_r); - //if (chargeSetpoint_kW < 0) {traceln(" V2G Active! Power: " + chargeSetpoint_kW );} - } - } - ev.f_updateAllFlows( chargeSetpoint_kW / ev.getCapacityElectric_kW() ); - } else { // just charge 'dumb', full power until full - ev.f_updateAllFlows(1.0); - } + if (ev.available) { + // just charge 'dumb', full power until full + ev.f_updateAllFlows(1.0); } } } public void setV2GActive(boolean activateV2G) { - // throw an exception if the management does not support V2G? - this.V2GActive = activateV2G; - this.gc.c_electricVehicles.forEach(ev -> ev.setV2GActive(activateV2G)); // not really wanted but NEEDED TO HAVE EV ASSET IN CORRECT assetFlowCatagory + if(activateV2G) { + throw new RuntimeException("Trying to Activate V2G for chargingManagement Simple -> Not supported"); + } } public boolean getV2GActive() { @@ -56553,7 +56552,6 @@ public class J_ChargingManagementSimple implements I_ChargingManagement { } - //Get parentagent public Agent getParentAgent() { return this.gc; @@ -56561,11 +56559,10 @@ public class J_ChargingManagementSimple implements I_ChargingManagement { //Store and reset states public void storeStatesAndReset() { - this.storedElectricityPriceLowPassed_eurpkWh = electricityPriceLowPassed_eurpkWh; - this.electricityPriceLowPassed_eurpkWh = 0; + //Noting to reset and store } public void restoreStates() { - this.electricityPriceLowPassed_eurpkWh = this.storedElectricityPriceLowPassed_eurpkWh; + //Nothing to restore } @@ -59842,6 +59839,9 @@ public class J_HeatingManagementSimple implements I_HeatingManagement { private J_EABuilding building; private J_EAConversion heatingAsset; private J_HeatingPreferences heatingPreferences; + private J_EAStorageHeat hotWaterBuffer; + private List<J_EAProduction> ptAssets; + private boolean hasPT = false; /** * Default constructor @@ -59854,52 +59854,7 @@ public class J_HeatingManagementSimple implements I_HeatingManagement { this.gc = gc; this.currentHeatingType = heatingType; } - - public double managePTAndHotWaterHeatBuffer(double hotWaterDemand_kW){ - - //Calculate the pt production - double ptProduction_kW = 0; - List<J_EAProduction> ptAssets = findAll(gc.c_productionAssets, ea -> ea.energyAssetType == OL_EnergyAssetType.PHOTOTHERMAL); - for (J_EA j_ea : ptAssets) { - ptProduction_kW -= j_ea.getLastFlows().get(OL_EnergyCarriers.HEAT); - } - - //Calculate the remaining hot water energy need after pt production, also calculate the remaining unused pt production - double remainingHotWater_kW = max(0, hotWaterDemand_kW - ptProduction_kW); // Need to do this, because pt has already compensated the hot water demand in the gc flows, so just need to update this value - double remainingPTProduction_kW = max(0, ptProduction_kW - hotWaterDemand_kW); - - if(gc.p_heatBuffer != null){ - double chargeSetpoint_kW = 0; - if(remainingHotWater_kW > 0) { - chargeSetpoint_kW = -remainingHotWater_kW; - } - else if(remainingPTProduction_kW > 0) { - chargeSetpoint_kW = remainingPTProduction_kW; - } - gc.p_heatBuffer.v_powerFraction_fr = chargeSetpoint_kW / gc.p_heatBuffer.getCapacityHeat_kW(); - gc.p_heatBuffer.f_updateAllFlows(gc.p_heatBuffer.v_powerFraction_fr); - - double heatBufferCharge_kW = gc.p_heatBuffer.getLastFlows().get(OL_EnergyCarriers.HEAT); - - if(remainingHotWater_kW > 0){//Only if the current pt production, wasnt enough, adjust the hotwater demand with the buffer, cause then the buffer will have tried to discharge - remainingHotWater_kW = max(0, remainingHotWater_kW + heatBufferCharge_kW); - } - else {//Curtail the remaining pt that is not used for hot water - remainingPTProduction_kW = max(0, remainingPTProduction_kW - heatBufferCharge_kW); - if (remainingPTProduction_kW > 0) {//Heat (for now always curtail over produced heat!) - for (J_EAProduction j_ea : ptAssets) { - remainingPTProduction_kW -= j_ea.curtailEnergyCarrierProduction( OL_EnergyCarriers.HEAT, remainingPTProduction_kW); - - if (remainingPTProduction_kW <= 0) { - break; - } - } - } - } - } - return remainingHotWater_kW; - } - + public void manageHeating() { if ( !isInitialized ) { @@ -59908,8 +59863,9 @@ public class J_HeatingManagementSimple implements I_HeatingManagement { double hotWaterDemand_kW = gc.p_DHWAsset != null ? gc.p_DHWAsset.getLastFlows().get(OL_EnergyCarriers.HEAT) : 0; - //Adjust the hot water and overall heat demand with the buffer and pt - double remainingHotWaterDemand_kW = managePTAndHotWaterHeatBuffer(hotWaterDemand_kW); // also updates fm_currentBalanceFlows_kW(heat)! + if(hasPT) {//Adjust the hot water and overall heat demand with the buffer and pt + double remainingHotWaterDemand_kW = J_HeatingFunctionLibrary.managePTAndHotWaterHeatBuffer(hotWaterBuffer, ptAssets, hotWaterDemand_kW); // also updates fm_currentBalanceFlows_kW(heat)! + } double heatDemand_kW = gc.fm_currentBalanceFlows_kW.get(OL_EnergyCarriers.HEAT); @@ -59952,16 +59908,19 @@ public class J_HeatingManagementSimple implements I_HeatingManagement { if (!validHeatingTypes.contains(this.currentHeatingType)) { throw new RuntimeException(this.getClass() + " does not support heating type: " + this.currentHeatingType); } - J_EAProduction ptAsset = findFirst(gc.c_productionAssets, ea -> ea.energyAssetType == OL_EnergyAssetType.PHOTOTHERMAL); - if (ptAsset != null) { + List<J_EAProduction> ptAssets = findAll(gc.c_productionAssets, ea -> ea.energyAssetType == OL_EnergyAssetType.PHOTOTHERMAL); + if (ptAssets.size() > 0) { if(gc.p_DHWAsset == null) { throw new RuntimeException(this.getClass() + " requires a hot water demand to make sense to use this heating management with PT."); } + this.ptAssets = ptAssets; + this.hasPT = true; } if (gc.p_heatBuffer != null) { - if(gc.p_DHWAsset == null && ptAsset == null) { - throw new RuntimeException(this.getClass() + " requires a hot water demand and PT to make sense to use this heating management with a heatbuffer."); + if(gc.p_DHWAsset == null || ptAssets.size() == 0) { + throw new RuntimeException(this.getClass() + " requires a hot water demand and PT to make sense to use this heating management with heatbuffer."); } + this.hotWaterBuffer = gc.p_heatBuffer; } if(gc.p_BuildingThermalAsset != null) { this.building = gc.p_BuildingThermalAsset; @@ -60719,20 +60678,13 @@ public class J_ChargingManagementPrice implements I_ChargingManagement { //double currentElectricityPriceConsumption_eurpkWh = gc.p_owner.f_getElectricityPrice(gc.v_liveConnectionMetaData.contractedDeliveryCapacity_kW); double currentElectricityPriceConsumption_eurpkWh = gc.energyModel.pp_dayAheadElectricityPricing_eurpMWh.getCurrentValue() * 0.001; electricityPriceLowPassed_eurpkWh += (currentElectricityPriceConsumption_eurpkWh-electricityPriceLowPassed_eurpkWh) * priceFilterDiffGain_r ; - /*// Little experiment, use current GC-load (so without EV charging!) as an equivalent price signal, and apply the same price-based smart charging and V2G algorithm. - GCdemandLowPassed_kW += (gc.fm_currentBalanceFlows_kW.get(OL_EnergyCarriers.ELECTRICITY) - GCdemandLowPassed_kW) * priceFilterDiffGain_r; - electricityPriceLowPassed_eurpkWh = gc.fm_currentBalanceFlows_kW.get(OL_EnergyCarriers.ELECTRICITY); - currentElectricityPriceConsumption_eurpkWh = gc.v_previousPowerElectricity_kW; - */ - //traceln("Current price: %s eurpkWh, filtered price: %s eurpkWh", currentElectricityPriceConsumption_eurpkWh, electricityPriceLowPassed_eurpkWh); - for (J_EAEV ev : gc.c_electricVehicles) { + for (J_EAEV ev : gc.c_electricVehicles) { if (ev.available) { double chargeNeedForNextTrip_kWh = ev.energyNeedForNextTrip_kWh - ev.getCurrentStateOfCharge_kWh(); // Can be negative if recharging is not needed for next trip! double remainingFlexTime_h = ev.getChargeDeadline_h() - t_h; // measure of flexiblity left in current charging session. double WTPoffset_eurpkW = 0.01; // Drops willingness to pay price for charging, combined with remainingFlexTime_h. double chargeSetpoint_kW = 0; if ( t_h >= (ev.getChargeDeadline_h()) && chargeNeedForNextTrip_kWh > 0) { // Must-charge time at max charging power - //traceln("Urgency charging in GC: %s! May exceed connection capacity!", gc.p_gridConnectionID)); chargeSetpoint_kW = ev.getCapacityElectric_kW(); } else { double WTPCharging_eurpkWh = electricityPriceLowPassed_eurpkWh - WTPoffset_eurpkW * remainingFlexTime_h; //+ urgencyGain_eurpkWh * ( max(0,maxSpreadChargingPower_kW) / ev.getCapacityElectric_kW() ); // Scale WTP based on flexibility expressed in terms of power-fraction @@ -60740,11 +60692,10 @@ public class J_ChargingManagementPrice implements I_ChargingManagement { double priceGain_r = 0.5; // When WTP is higher than current electricity price, ramp up charging power with this gain based on the price-delta. chargeSetpoint_kW = max(0, ev.getCapacityElectric_kW() * (WTPCharging_eurpkWh / currentElectricityPriceConsumption_eurpkWh - 1) * priceGain_r); //if ( chargeNeedForNextTrip_kWh < -ev.getCapacityElectric_kW()*gc.energyModel.p_timeStep_h && chargeSetpoint_kW == 0 ) { // Surpluss SOC and high energy price - if ( ev.getV2GActive() && remainingFlexTime_h > 1 && chargeSetpoint_kW == 0 ) { // Surpluss SOC and high energy price + if ( this.V2GActive && ev.getV2GCapable() && remainingFlexTime_h > 1 && chargeSetpoint_kW == 0 ) { // Surpluss SOC and high energy price double V2G_WTS_offset_eurpkWh = 0.02; // Price must be at least this amount above the moving average to decide to discharge EV battery. double WTSV2G_eurpkWh = V2G_WTS_offset_eurpkWh + electricityPriceLowPassed_eurpkWh; // Scale WillingnessToSell based on flexibility expressed in terms of power-fraction chargeSetpoint_kW = min(0, -ev.getCapacityElectric_kW() * (currentElectricityPriceConsumption_eurpkWh / WTSV2G_eurpkWh - 1) * priceGain_r); - //if (chargeSetpoint_kW < 0) {traceln(" V2G Active! Power: " + chargeSetpoint_kW );} } } ev.f_updateAllFlows( chargeSetpoint_kW / ev.getCapacityElectric_kW() ); @@ -61617,7 +61568,11 @@ public class J_HeatingManagementPIcontrol implements I_HeatingManagement { private J_EABuilding building; private J_EAConversion heatingAsset; private J_HeatingPreferences heatingPreferences; - + private J_EAStorageHeat hotWaterBuffer; + private List<J_EAProduction> ptAssets; + private boolean hasPT = false; + private boolean hasHotWaterBuffer = false; + // PI control gains private double P_gain_kWpDegC = 1*1; private double I_gain_kWphDegC = 0.1*2; @@ -61649,11 +61604,26 @@ public class J_HeatingManagementPIcontrol implements I_HeatingManagement { } double hotWaterDemand_kW = gc.p_DHWAsset != null ? gc.p_DHWAsset.getLastFlows().get(OL_EnergyCarriers.HEAT) : 0; + double ptAssetPower_kW = ptAssets != null ? sum(ptAssets, pt -> pt.getLastFlows().get(OL_EnergyCarriers.HEAT)) : 0; + double additionalHeatDemand_kW = (gc.fm_currentBalanceFlows_kW.get(OL_EnergyCarriers.HEAT) - hotWaterDemand_kW + (-ptAssetPower_kW)); - //Adjust the hot water and overall heat demand with the buffer and pt - double remainingHotWaterDemand_kW = managePTAndHotWaterHeatBuffer(hotWaterDemand_kW); + double currentHeatDemand_kW = additionalHeatDemand_kW; + double availableAssetPowerForHotWater_kWth = heatingAsset.getOutputCapacity_kW() - additionalHeatDemand_kW; + + //Manage hot water if additional systems are present + if(this.hasPT) { + //Adjust the hot water and overall heat demand with the buffer and pt + double remainingHotWaterDemand_kW = J_HeatingFunctionLibrary.managePTAndHotWaterHeatBuffer(hotWaterBuffer, ptAssets, hotWaterDemand_kW); // This function updates the buffer and curtails PT if needed -> current balanceflow is updated accordingly. + currentHeatDemand_kW += remainingHotWaterDemand_kW; + } + else if(this.hasHotWaterBuffer) { + double heatDemandFromHeatingAssetForHotWater_kW = J_HeatingFunctionLibrary.manageHotWaterHeatBuffer(this.hotWaterBuffer, hotWaterDemand_kW, availableAssetPowerForHotWater_kWth, this.timeStep_h); + currentHeatDemand_kW += heatDemandFromHeatingAssetForHotWater_kW; + } + else { + currentHeatDemand_kW += hotWaterDemand_kW; + } - double otherHeatDemand_kW = gc.fm_currentBalanceFlows_kW.get(OL_EnergyCarriers.HEAT); double buildingTemp_degC = building.getCurrentTemperature(); double timeOfDay_h = gc.energyModel.t_hourOfDay; @@ -61674,73 +61644,33 @@ public class J_HeatingManagementPIcontrol implements I_HeatingManagement { buildingHeatingDemand_kW = max(0,deltaT_degC * P_gain_kWpDegC + I_state_hDegC * I_gain_kWphDegC); - double assetPower_kW = min(heatingAsset.getOutputCapacity_kW(),buildingHeatingDemand_kW + otherHeatDemand_kW); // minimum not strictly needed as asset will limit power by itself. Could be used later if we notice demand is higher than capacity of heating asset. + double assetPower_kW = min(heatingAsset.getOutputCapacity_kW(),buildingHeatingDemand_kW + currentHeatDemand_kW); // minimum not strictly needed as asset will limit power by itself. Could be used later if we notice demand is higher than capacity of heating asset. heatingAsset.f_updateAllFlows( assetPower_kW / heatingAsset.getOutputCapacity_kW() ); - double heatIntoBuilding_kW = max(0, assetPower_kW - otherHeatDemand_kW); + double heatIntoBuilding_kW = max(0, assetPower_kW - currentHeatDemand_kW); building.f_updateAllFlows( heatIntoBuilding_kW / building.getCapacityHeat_kW() ); } - private double managePTAndHotWaterHeatBuffer(double hotWaterDemand_kW){ - - //Calculate the pt production - double ptProduction_kW = 0; - List<J_EAProduction> ptAssets = findAll(gc.c_productionAssets, ea -> ea.energyAssetType == OL_EnergyAssetType.PHOTOTHERMAL); - for (J_EA j_ea : ptAssets) { - ptProduction_kW -= j_ea.getLastFlows().get(OL_EnergyCarriers.HEAT); - } - - //Calculate the remaining hot water energy need after pt production, also calculate the remaining unused pt production - double remainingHotWater_kW = max(0, hotWaterDemand_kW - ptProduction_kW); // Need to do this, because pt has already compensated the hot water demand in the gc flows, so just need to update this value - double remainingPTProduction_kW = max(0, ptProduction_kW - hotWaterDemand_kW); - - if(gc.p_heatBuffer != null){ - double chargeSetpoint_kW = 0; - if(remainingHotWater_kW > 0) { - chargeSetpoint_kW = -remainingHotWater_kW; - } - else if(remainingPTProduction_kW > 0) { - chargeSetpoint_kW = remainingPTProduction_kW; - } - gc.p_heatBuffer.v_powerFraction_fr = chargeSetpoint_kW / gc.p_heatBuffer.getCapacityHeat_kW(); - gc.p_heatBuffer.f_updateAllFlows(gc.p_heatBuffer.v_powerFraction_fr); - - double heatBufferCharge_kW = gc.p_heatBuffer.getLastFlows().get(OL_EnergyCarriers.HEAT); - - if(remainingHotWater_kW > 0){//Only if the current pt production, wasnt enough, adjust the hotwater demand with the buffer, cause then the buffer will have tried to discharge - remainingHotWater_kW = max(0, remainingHotWater_kW + heatBufferCharge_kW); - } - else {//Curtail the remaining pt that is not used for hot water - remainingPTProduction_kW = max(0, remainingPTProduction_kW - heatBufferCharge_kW); - if (remainingPTProduction_kW > 0) {//Heat (for now always curtail over produced heat!) - for (J_EAProduction j_ea : ptAssets) { - remainingPTProduction_kW -= j_ea.curtailEnergyCarrierProduction( OL_EnergyCarriers.HEAT, remainingPTProduction_kW); - - if (remainingPTProduction_kW <= 0) { - break; - } - } - } - } - } - return remainingHotWater_kW; - } public void initializeAssets() { if (!validHeatingTypes.contains(this.currentHeatingType)) { throw new RuntimeException(this.getClass() + " does not support heating type: " + this.currentHeatingType); } - J_EAProduction ptAsset = findFirst(gc.c_productionAssets, ea -> ea.energyAssetType == OL_EnergyAssetType.PHOTOTHERMAL); - if (ptAsset != null) { + List<J_EAProduction> ptAssets = findAll(gc.c_productionAssets, ea -> ea.energyAssetType == OL_EnergyAssetType.PHOTOTHERMAL); + if (ptAssets.size() > 0) { if(gc.p_DHWAsset == null) { throw new RuntimeException(this.getClass() + " requires a hot water demand to make sense to use this heating management with PT."); } + this.ptAssets = ptAssets; + this.hasPT = true; } if (gc.p_heatBuffer != null) { - if(gc.p_DHWAsset == null && ptAsset == null) { - throw new RuntimeException(this.getClass() + " requires a hot water demand and PT to make sense to use this heating management with a heatbuffer."); + if(gc.p_DHWAsset == null) { + throw new RuntimeException(this.getClass() + " requires a hot water demand to make sense to use this heating management with heatbuffer."); } + this.hotWaterBuffer = gc.p_heatBuffer; + this.hasHotWaterBuffer = true; } if(gc.p_BuildingThermalAsset != null) { this.building = gc.p_BuildingThermalAsset; @@ -61853,7 +61783,11 @@ public class J_HeatingManagementHeatpumpOffPeak implements I_HeatingManagement { private J_EABuilding building; private J_EAConversion heatingAsset; private J_HeatingPreferences heatingPreferences; - + private J_EAStorageHeat hotWaterBuffer; + private List<J_EAProduction> ptAssets; + private boolean hasPT = false; + private boolean hasHotWaterBuffer = false; + // PI control gains private double P_gain_kWpDegC = 1*1; private double I_gain_kWphDegC = 0.1*2; @@ -61903,13 +61837,27 @@ public class J_HeatingManagementHeatpumpOffPeak implements I_HeatingManagement { calculatePreHeatParameters(); } - //Adjust the hot water and overall heat demand with the buffer and pt double hotWaterDemand_kW = gc.p_DHWAsset != null ? gc.p_DHWAsset.getLastFlows().get(OL_EnergyCarriers.HEAT) : 0; - double remainingHotWaterDemand_kW = managePTAndHotWaterHeatBuffer(hotWaterDemand_kW); + double ptAssetPower_kW = ptAssets != null ? sum(ptAssets, pt -> pt.getLastFlows().get(OL_EnergyCarriers.HEAT)) : 0; + double additionalHeatDemand_kW = (gc.fm_currentBalanceFlows_kW.get(OL_EnergyCarriers.HEAT) - hotWaterDemand_kW + (-ptAssetPower_kW)); + + double currentHeatDemand_kW = additionalHeatDemand_kW; + double availableAssetPowerForHotWater_kWth = heatingAsset.getOutputCapacity_kW() - additionalHeatDemand_kW; + + //Manage hot water if additional systems are present + if(this.hasPT) { + //Adjust the hot water and overall heat demand with the buffer and pt + double remainingHotWaterDemand_kW = J_HeatingFunctionLibrary.managePTAndHotWaterHeatBuffer(hotWaterBuffer, ptAssets, hotWaterDemand_kW); // This function updates the buffer and curtails PT if needed -> current balanceflow is updated accordingly. + currentHeatDemand_kW += remainingHotWaterDemand_kW; + } + else if(this.hasHotWaterBuffer) { + double heatDemandFromHeatingAssetForHotWater_kW = J_HeatingFunctionLibrary.manageHotWaterHeatBuffer(this.hotWaterBuffer, hotWaterDemand_kW, availableAssetPowerForHotWater_kWth, this.timeStep_h); + currentHeatDemand_kW += heatDemandFromHeatingAssetForHotWater_kW; + } + else { + currentHeatDemand_kW += hotWaterDemand_kW; + } - //Get the remaining heat demand (hot water, and potential other profiles) - double otherHeatDemand_kW = gc.fm_currentBalanceFlows_kW.get(OL_EnergyCarriers.HEAT); - //Determine if time is in reduced Heating interval boolean timeIsInReducedHeatingInterval = ((timeOfDay_h - startTimeOfReducedHeatingInterval_hr + 24) % 24) < reducedHeatingIntervalLength_hr; boolean timeIsInPreheatInterval = ((timeOfDay_h - (startTimeOfReducedHeatingInterval_hr - preHeatDuration_hr) + 24) % 24) < preHeatDuration_hr; @@ -61944,11 +61892,11 @@ public class J_HeatingManagementHeatpumpOffPeak implements I_HeatingManagement { double buildingHeatingDemand_kW = max(0,deltaT_degC * P_gain_kWpDegC + I_state_hDegC * I_gain_kWphDegC); //Set asset power - double assetPower_kW = min(heatingAsset.getOutputCapacity_kW(), buildingHeatingDemand_kW + otherHeatDemand_kW); // minimum not strictly needed as asset will limit power by itself. Could be used later if we notice demand is higher than capacity of heating asset. + double assetPower_kW = min(heatingAsset.getOutputCapacity_kW(), buildingHeatingDemand_kW + currentHeatDemand_kW); // minimum not strictly needed as asset will limit power by itself. Could be used later if we notice demand is higher than capacity of heating asset. heatingAsset.f_updateAllFlows( assetPower_kW / heatingAsset.getOutputCapacity_kW() ); //Set building power (other heat demand gets bias if asset does not have enough capacity) - double heatIntoBuilding_kW = max(0, assetPower_kW - otherHeatDemand_kW); + double heatIntoBuilding_kW = max(0, assetPower_kW - currentHeatDemand_kW); building.f_updateAllFlows( heatIntoBuilding_kW / building.getCapacityHeat_kW() ); } @@ -62017,53 +61965,6 @@ public class J_HeatingManagementHeatpumpOffPeak implements I_HeatingManagement { //For now, preheat duration of 2 hours is assumed. } } - - private double managePTAndHotWaterHeatBuffer(double hotWaterDemand_kW){ - - //Calculate the pt production - double ptProduction_kW = 0; - List<J_EAProduction> ptAssets = findAll(gc.c_productionAssets, ea -> ea.energyAssetType == OL_EnergyAssetType.PHOTOTHERMAL); - for (J_EA j_ea : ptAssets) { - ptProduction_kW -= j_ea.getLastFlows().get(OL_EnergyCarriers.HEAT); - } - - //Calculate the remaining hot water energy need after pt production, also calculate the remaining unused pt production - double remainingHotWater_kW = max(0, hotWaterDemand_kW - ptProduction_kW); // Need to do this, because pt has already compensated the hot water demand in the gc flows, so just need to update this value - double remainingPTProduction_kW = max(0, ptProduction_kW - hotWaterDemand_kW); - - if(gc.p_heatBuffer != null){ - double chargeSetpoint_kW = 0; - if(remainingHotWater_kW > 0) { - chargeSetpoint_kW = -remainingHotWater_kW; - } - else if(remainingPTProduction_kW > 0) { - chargeSetpoint_kW = remainingPTProduction_kW; - } - gc.p_heatBuffer.v_powerFraction_fr = chargeSetpoint_kW / gc.p_heatBuffer.getCapacityHeat_kW(); - gc.p_heatBuffer.f_updateAllFlows(gc.p_heatBuffer.v_powerFraction_fr); - - double heatBufferCharge_kW = gc.p_heatBuffer.getLastFlows().get(OL_EnergyCarriers.HEAT); - - if(remainingHotWater_kW > 0){//Only if the current pt production, wasnt enough, adjust the hotwater demand with the buffer, cause then the buffer will have tried to discharge - remainingHotWater_kW = max(0, remainingHotWater_kW + heatBufferCharge_kW); - } - else {//Curtail the remaining pt that is not used for hot water - remainingPTProduction_kW = max(0, remainingPTProduction_kW - heatBufferCharge_kW); - if (remainingPTProduction_kW > 0) {//Heat (for now always curtail over produced heat!) - for (J_EAProduction j_ea : ptAssets) { - remainingPTProduction_kW -= j_ea.curtailEnergyCarrierProduction( OL_EnergyCarriers.HEAT, remainingPTProduction_kW); - - if (remainingPTProduction_kW <= 0) { - break; - } - } - } - } - } - return remainingHotWater_kW; - } - - public void setStartTimeOfReducedHeatingInterval_hr(double startTimeOfReducedHeatingInterval_hr) { @@ -62097,16 +61998,20 @@ public class J_HeatingManagementHeatpumpOffPeak implements I_HeatingManagement { if (!validHeatingTypes.contains(this.currentHeatingType)) { throw new RuntimeException(this.getClass() + " does not support heating type: " + this.currentHeatingType); } - J_EAProduction ptAsset = findFirst(gc.c_productionAssets, ea -> ea.energyAssetType == OL_EnergyAssetType.PHOTOTHERMAL); - if (ptAsset != null) { + List<J_EAProduction> ptAssets = findAll(gc.c_productionAssets, ea -> ea.energyAssetType == OL_EnergyAssetType.PHOTOTHERMAL); + if (ptAssets.size() > 0) { if(gc.p_DHWAsset == null) { throw new RuntimeException(this.getClass() + " requires a hot water demand to make sense to use this heating management with PT."); } + this.ptAssets = ptAssets; + this.hasPT = true; } if (gc.p_heatBuffer != null) { - if(gc.p_DHWAsset == null && ptAsset == null) { - throw new RuntimeException(this.getClass() + " requires a hot water demand and PT to make sense to use this heating management with a heatbuffer."); + if(gc.p_DHWAsset == null) { + throw new RuntimeException(this.getClass() + " requires a hot water demand to make sense to use this heating management with a heatbuffer."); } + this.hotWaterBuffer = gc.p_heatBuffer; + this.hasHotWaterBuffer = true; } if(gc.p_BuildingThermalAsset != null) { this.building = gc.p_BuildingThermalAsset; @@ -62331,6 +62236,9 @@ public class J_HeatingManagementPIcontrolHybridHeatpump implements I_HeatingMana private J_EAConversionHeatPump heatPumpAsset; private J_EAConversionGasBurner gasBurnerAsset; private J_HeatingPreferences heatingPreferences; + private J_EAStorageHeat hotWaterBuffer; + private List<J_EAProduction> ptAssets; + private boolean hasPT = false; // PI control gains private double P_gain_kWpDegC = 1*1; @@ -62365,8 +62273,10 @@ public class J_HeatingManagementPIcontrolHybridHeatpump implements I_HeatingMana double hotWaterDemand_kW = gc.p_DHWAsset != null ? gc.p_DHWAsset.getLastFlows().get(OL_EnergyCarriers.HEAT) : 0; - //Adjust the hot water and overall heat demand with the buffer and pt - double remainingHotWaterDemand_kW = managePTAndHotWaterHeatBuffer(hotWaterDemand_kW); // This function updates the buffer and curtails PT if needed -> current balanceflow is updated accordingly. + if(hasPT) { + //Adjust the hot water and overall heat demand with the buffer and pt + double remainingHotWaterDemand_kW = J_HeatingFunctionLibrary.managePTAndHotWaterHeatBuffer(hotWaterBuffer, ptAssets, hotWaterDemand_kW); // This function updates the buffer and curtails PT if needed -> current balanceflow is updated accordingly. + } double otherHeatDemand_kW = gc.fm_currentBalanceFlows_kW.get(OL_EnergyCarriers.HEAT); @@ -62413,66 +62323,23 @@ public class J_HeatingManagementPIcontrolHybridHeatpump implements I_HeatingMana } - private double managePTAndHotWaterHeatBuffer(double hotWaterDemand_kW){ - - //Calculate the pt production - double ptProduction_kW = 0; - List<J_EAProduction> ptAssets = findAll(gc.c_productionAssets, ea -> ea.energyAssetType == OL_EnergyAssetType.PHOTOTHERMAL); - for (J_EA j_ea : ptAssets) { - ptProduction_kW -= j_ea.getLastFlows().get(OL_EnergyCarriers.HEAT); - } - - //Calculate the remaining hot water energy need after pt production, also calculate the remaining unused pt production - double remainingHotWater_kW = max(0, hotWaterDemand_kW - ptProduction_kW); // Need to do this, because pt has already compensated the hot water demand in the gc flows, so just need to update this value - double remainingPTProduction_kW = max(0, ptProduction_kW - hotWaterDemand_kW); - - if(gc.p_heatBuffer != null){ - double chargeSetpoint_kW = 0; - if(remainingHotWater_kW > 0) { - chargeSetpoint_kW = -remainingHotWater_kW; - } - else if(remainingPTProduction_kW > 0) { - chargeSetpoint_kW = remainingPTProduction_kW; - } - gc.p_heatBuffer.v_powerFraction_fr = chargeSetpoint_kW / gc.p_heatBuffer.getCapacityHeat_kW(); - gc.p_heatBuffer.f_updateAllFlows(gc.p_heatBuffer.v_powerFraction_fr); - - double heatBufferCharge_kW = gc.p_heatBuffer.getLastFlows().get(OL_EnergyCarriers.HEAT); - - if(remainingHotWater_kW > 0){//Only if the current pt production, wasnt enough, adjust the hotwater demand with the buffer, cause then the buffer will have tried to discharge - remainingHotWater_kW = max(0, remainingHotWater_kW + heatBufferCharge_kW); - } - else {//Curtail the remaining pt that is not used for hot water - remainingPTProduction_kW = max(0, remainingPTProduction_kW - heatBufferCharge_kW); - if (remainingPTProduction_kW > 0) {//Heat (for now always curtail over produced heat!) - for (J_EAProduction j_ea : ptAssets) { - remainingPTProduction_kW -= j_ea.curtailEnergyCarrierProduction( OL_EnergyCarriers.HEAT, remainingPTProduction_kW); - - if (remainingPTProduction_kW <= 0) { - break; - } - } - } - } - } - return remainingHotWater_kW; - } - - public void initializeAssets() { if (!validHeatingTypes.contains(this.currentHeatingType)) { throw new RuntimeException(this.getClass() + " does not support heating type: " + this.currentHeatingType); } - J_EAProduction ptAsset = findFirst(gc.c_productionAssets, ea -> ea.energyAssetType == OL_EnergyAssetType.PHOTOTHERMAL); - if (ptAsset != null) { + List<J_EAProduction> ptAssets = findAll(gc.c_productionAssets, ea -> ea.energyAssetType == OL_EnergyAssetType.PHOTOTHERMAL); + if (ptAssets.size() > 0) { if(gc.p_DHWAsset == null) { throw new RuntimeException(this.getClass() + " requires a hot water demand to make sense to use this heating management with PT."); } + this.hasPT = true; + this.ptAssets = ptAssets; } if (gc.p_heatBuffer != null) { - if(gc.p_DHWAsset == null && ptAsset == null) { - throw new RuntimeException(this.getClass() + " requires a hot water demand and PT to make sense to use this heating management with a heatbuffer."); + if(gc.p_DHWAsset == null || ptAssets.size() == 0) { + throw new RuntimeException(this.getClass() + " requires a hot water demand and pt to make sense to use this heating management."); } + this.hotWaterBuffer = gc.p_heatBuffer; } if(gc.p_BuildingThermalAsset != null) { this.building = gc.p_BuildingThermalAsset; @@ -62549,6 +62416,99 @@ public class J_HeatingManagementPIcontrolHybridHeatpump implements I_HeatingMana public String toString() { return super.toString(); } +} + + + 1763557451043 + J_HeatingFunctionLibrary + 1762850578079 + /** + * J_HeatingFunctionLibrary + */ +public abstract class J_HeatingFunctionLibrary { + + public static double managePTAndHotWaterHeatBuffer(J_EAStorageHeat hotWaterBuffer, List<J_EAProduction> ptAssets, double hotWaterDemand_kW){ + //Calculate the pt production + double ptProduction_kW = 0; + for (J_EA j_ea : ptAssets) { + ptProduction_kW -= j_ea.getLastFlows().get(OL_EnergyCarriers.HEAT); + } + + //Calculate the remaining hot water energy need after pt production, also calculate the remaining unused pt production + double remainingHotWater_kW = max(0, hotWaterDemand_kW - ptProduction_kW); // Need to do this, because pt has already compensated the hot water demand in the gc flows, so just need to update this value + double remainingPTProduction_kW = max(0, ptProduction_kW - hotWaterDemand_kW); + + if(hotWaterBuffer != null){ + double chargeSetpoint_kW = 0; + if(remainingHotWater_kW > 0) { + chargeSetpoint_kW = -remainingHotWater_kW; + } + else if(remainingPTProduction_kW > 0) { + chargeSetpoint_kW = remainingPTProduction_kW; + } + hotWaterBuffer.v_powerFraction_fr = chargeSetpoint_kW / hotWaterBuffer.getCapacityHeat_kW(); + hotWaterBuffer.f_updateAllFlows(hotWaterBuffer.v_powerFraction_fr); + + double heatBufferCharge_kW = hotWaterBuffer.getLastFlows().get(OL_EnergyCarriers.HEAT); + + if(remainingHotWater_kW > 0){//Only if the current pt production, wasnt enough, adjust the hotwater demand with the buffer, cause then the buffer will have tried to discharge + remainingHotWater_kW = max(0, remainingHotWater_kW + heatBufferCharge_kW); + } + else {//Curtail the remaining pt that is not used for hot water + remainingPTProduction_kW = max(0, remainingPTProduction_kW - heatBufferCharge_kW); + } + } + + if (remainingPTProduction_kW > 0) {//Heat (for now always curtail over produced heat!) + for (J_EAProduction j_ea : ptAssets) { + remainingPTProduction_kW -= j_ea.curtailEnergyCarrierProduction( OL_EnergyCarriers.HEAT, remainingPTProduction_kW); + + if (remainingPTProduction_kW <= 0) { + break; + } + } + } + return remainingHotWater_kW; + } + + public static double manageHotWaterHeatBuffer(J_EAStorageHeat hotWaterBuffer, double hotWaterDemand_kW, double availableHeatingPower_kWth, double timeStep_h){ + if(hotWaterDemand_kW > availableHeatingPower_kWth + hotWaterBuffer.getCurrentStateOfCharge_kWh() / timeStep_h) { + throw new RuntimeException("Hot water demand is higher than available power."); + } + + //Heating asset should always try to fill the heat buffer as fast as possible. + double hotWaterDemandFromHeatingAsset_kW = min(availableHeatingPower_kWth, hotWaterDemand_kW + (hotWaterBuffer.getStorageCapacity_kWh() - hotWaterBuffer.getCurrentStateOfCharge_kWh())); + double heatIntoBuffer_kW = hotWaterDemandFromHeatingAsset_kW - hotWaterDemand_kW; + + + hotWaterBuffer.v_powerFraction_fr = heatIntoBuffer_kW / hotWaterBuffer.getCapacityHeat_kW(); + hotWaterBuffer.f_updateAllFlows(hotWaterBuffer.v_powerFraction_fr); + + + return hotWaterDemandFromHeatingAsset_kW; + } +} + + + + + + + + + + + + + 1763570262548 + J_GlobalParameters + 1752680962144 + /** + * J_GlobalParameters + */ +public abstract class J_GlobalParameters { + //public final static double floatingPointErrorMargin = 1e-15; + public final static int floatingPointPrecision = 15; } @@ -62641,5 +62601,6 @@ public class J_HeatingManagementPIcontrolHybridHeatpump implements I_HeatingMana 2216cdd0-177c-5678-9e88-dd8b95312234 1737c8c6-b526-4dd8-589e-ee4e205b06f4 6a43bef6-8b70-4253-a828-82c3ab399655 + 0a27038a-0f3a-48bb-b235-4a44066a1402 diff --git a/_alp/Agents/EnergyModel/Code/Functions.java b/_alp/Agents/EnergyModel/Code/Functions.java index 24b325f3..483375d4 100644 --- a/_alp/Agents/EnergyModel/Code/Functions.java +++ b/_alp/Agents/EnergyModel/Code/Functions.java @@ -984,9 +984,9 @@ EnergyCoop f_addProductionEnergyCarrier(OL_EnergyCarriers EC) } } if (e instanceof J_EAStorageHeat) { // includes J_EABuilding - totalAmbientHeating_MWh += ((J_EAStorageHeat)e).energyAbsorbed_kWh/1000; - totalHeatProduced_MWh += ((J_EAStorageHeat)e).energyAbsorbed_kWh/1000; - totalEnergyProduced_MWh += ((J_EAStorageHeat)e).energyAbsorbed_kWh/1000; + totalAmbientHeating_MWh += ((J_EAStorageHeat)e).ambientEnergyAbsorbed_kWh/1000; + totalHeatProduced_MWh += ((J_EAStorageHeat)e).ambientEnergyAbsorbed_kWh/1000; + totalEnergyProduced_MWh += ((J_EAStorageHeat)e).ambientEnergyAbsorbed_kWh/1000; deltaThermalEnergySinceStart_MWh += (((J_EAStorageHeat)e).getRemainingHeatStorageHeat_kWh() - ((J_EAStorageHeat)e).getStartingHeatStorageHeat_kWh())/1000; } if (e instanceof J_EAEV) { diff --git a/_alp/Agents/EnergyModel/EmbeddedObjects.xml b/_alp/Agents/EnergyModel/EmbeddedObjects.xml index cd638a2c..589a0797 100644 --- a/_alp/Agents/EnergyModel/EmbeddedObjects.xml +++ b/_alp/Agents/EnergyModel/EmbeddedObjects.xml @@ -1014,6 +1014,24 @@ + + + + + + + + + + + + + + + + + + true diff --git a/_alp/Agents/GCEnergyConversion/Code/Functions.xml b/_alp/Agents/GCEnergyConversion/Code/Functions.xml index 49cd46c2..2ea50340 100644 --- a/_alp/Agents/GCEnergyConversion/Code/Functions.xml +++ b/_alp/Agents/GCEnergyConversion/Code/Functions.xml @@ -47,6 +47,7 @@ @author: Gillis Hommen @since: 28-12-2022]]> + true 1230 180 LEFT + + 1765379026595 + + 1940 + 790 + + false + true + false + SHAPE_DRAW_2D3D + true + + 1765379026593 + true + 1674979200000 + + + HOUR + + + + MINUTE + + + false + 490 + 260 + + + + 50 + 30 + 410 + 170 + -1 + -16777216 + -12566464 + + + SOUTH + -16777216 + 30 + + + DEFAULT + DEFAULT + -12566464 + + true + MOVEMENT_WITH_TIME + DAY + 0 + 1 + AUTO + true + LINEAR + + Min + 1765380741625 + my_dataset + -2448096 + p_BuildingThermalAsset.getCurrentTemperature() + true + NONE + 1.0 + + 288 + 3 + false + dd_MM_HH + diff --git a/_alp/Agents/GCHouse/Variables.xml b/_alp/Agents/GCHouse/Variables.xml index 91864ea2..83d57c30 100644 --- a/_alp/Agents/GCHouse/Variables.xml +++ b/_alp/Agents/GCHouse/Variables.xml @@ -386,4 +386,154 @@ + + 1765292486713 + + -300 + 50 + + false + true + true + + + NONE + false + + 1765292486711 + TEXT_BOX + 0 + 100 + NO_DELIMETER + + + + + 1765292501616 + + -300 + 70 + + false + true + true + + + NONE + false + + 1765292501614 + TEXT_BOX + 0 + 100 + NO_DELIMETER + + + + + 1765292517522 + + -300 + 90 + + false + true + true + + + NONE + false + + 1765292517520 + TEXT_BOX + 0 + 100 + NO_DELIMETER + + + + + 1765292532994 + + -300 + 130 + + false + true + true + + + NONE + false + + 1765292532992 + TEXT_BOX + 0 + 100 + NO_DELIMETER + + + + + 1765292546817 + + -300 + 150 + + false + true + true + + + NONE + false + + 1765292546815 + TEXT_BOX + 0 + 100 + NO_DELIMETER + + + + + 1765357455086 + + -300 + 110 + + false + true + true + + + NONE + false + + 1765357455084 + TEXT_BOX + 0 + 100 + NO_DELIMETER + + + diff --git a/_alp/Agents/GCNeighborhood/Code/Functions.xml b/_alp/Agents/GCNeighborhood/Code/Functions.xml index 3ace1e2d..5d97eb67 100644 --- a/_alp/Agents/GCNeighborhood/Code/Functions.xml +++ b/_alp/Agents/GCNeighborhood/Code/Functions.xml @@ -218,6 +218,7 @@ double 1736869275213 + true 1680 570