.Buildings.Fluid.HeatPumps.ModularReversible.RefrigerantCycle.BaseClasses.TableData2DLoadDepSHC .Buildings.Fluid.HeatPumps.ModularReversible.RefrigerantCycle.BaseClasses.TableData2DLoadDepSHCThis block provides the core implementation to model
simultaneous heating and cooling (SHC) systems, also referred to as
multipipe polyvalent units or "Type A" in Eurovent (2025). Since
the most recent versions of these systems are composed of multiple
modules, the implementation includes the staging logic for an
arbitrary number of modules nUni. Nevertheless,
single-module systems can also be appropriately represented by
setting nUni = 1.
All kinds of capacity-modulation processes are supported, such as VFD-driven compressors, multiple on-off compressors, and single compressor cycling. The method used to interpolate capacity and power based on user-provided data is taken from Buildings.Fluid.HeatPumps.ModularReversible.RefrigerantCycle.BaseClasses.TableData2DLoadDep. Users should be familiar with this latter block before continuing with this documentation.
The block implements the following functionalities:
The block inputs onHea and onCoo allow
switching between three system operating modes.
For each module operating mode, the block implements ideal controls by solving for the part load ratio required to meet the load (more precisely the minimum between the load and the actual capacity for the current source and sink temperatures). This is done by interpolating the PLR values along the heat flow rate values for a given load. As described in Section "Load balancing between the HW and CHW side", the part load ratio for modules in SHC mode is the maximum between the PLR values for the heating load and the cooling load.
The load is calculated based on the HW and CHW-side side
variables and the temperature setpoint provided as inputs. The
setpoint either represents a leaving (supply) temperature setpoint
if use_TLoaLvgForCtl is true (default
setting) or the entering (return) temperature if
use_TLoaLvgForCtl is false.
In contrast to the implementation in Buildings.Fluid.HeatPumps.ModularReversible.RefrigerantCycle.BaseClasses.TableData2DLoadDep the current block does not expose the PLR value, and therefore does not support external modeling of equipment safeties.
The capacity and power calculation follows the same logic as the
one described in
Buildings.Fluid.HeatPumps.ModularReversible.RefrigerantCycle.BaseClasses.TableData2DLoadDep
except that the current block does not include compressor false
loading, i.e., both the capacity and power are linearly
interpolated along PLR between 0 and
min(PLR<Shc|Hea|Coo>Sup).
The performance data are read from external ASCII files that must meet the requirements specified in the documentation of Buildings.Fluid.HeatPumps.ModularReversible.RefrigerantCycle.BaseClasses.TableData2DLoadDep.
A performance data file must be provided for each module
operating mode: heating-only, cooling-only and simultaneous heating
and cooling. It is expected that performance data be provided for a
single module. This is however a loose requirement as the scaling
logic anyway ensures that the nominal heat flow rates
Q*_flow_nominal provided as parameters match the
values interpolated from the performance data, times the number of
modules.
Note that for single-mode performance data, the ambient-side
fluid temperature must correspond to the entering
temperature, while the model supports choosing between entering or
leaving temperature for the CHW and HW via the parameters
use_TEvaOutForTab and use_TConOutForTab,
respectively.
First, the heating and cooling loads QHeaSet_flow
and QCooSet_flow are calculated from the block inputs
(see Section "Ideal controls"). The staging logic uses
time-averaged heating and cooling loads
QHeaSetMea_flow and QCooSetMea_flow. An
exponential moving average (dtMea *
der(Q<Hea|Coo>SetMea_flow) = Q<Hea|Coo>Set_flow -
Q<Hea|Coo>SetMea_flow) is used for computational
efficiency.
Then the model evaluates the capacity of a single module in each mode, based on the current source and sink fluid temperature (see Section "Capacity and power calculation"). The number of modules required to run to meet the load is then calculated for each mode as follows.
nUniHeaShcRaw = ceil(QHeaSetMea_flow / max(QHeaShcInt_flow) /
SPLR),max(QHeaShcInt_flow) is the heating capacity of
one module in SHC mode and SPLR is a parameter
representing the staging part load ratio. Note that this parameter
should be strictly lower than 1 because the number of
staged modules ultimately conditions the opening of isolation
valves and the staging of primary pumps. If SPLR = 1
it is likely that the mass flow rate will limit the load below the
capacity of a single module, practically preventing the system from
staging up until the return temperature exceeds the design
value.nUniCooShcRaw = ceil(QCooSetMea_flow / min(QCooSHcInt_flow) /
SPLR),min(QCooSHcInt_flow) is the cooling capacity of
one module in SHC mode.nUniShcRaw = min(nUniCooShcRaw, nUniHeaShcRaw).nUniHeaRaw = ceil(QHeaSetResMea_flow / max(QHeaInt_flow) /
SPLR),QHeaSetResMea_flow is the residual heating load,
calculated as the time-averaged heating load minus the heating
output of modules in SHC mode, and max(QHeaInt_flow)
is the capacity of one module in heating-only mode.nUniCooRaw = ceil(QCooSetResMea_flow / min(QCooInt_flow) /
SPLR),QCooSetResMea_flow is the residual cooling load,
calculated as the time-averaged cooling load minus the cooling
output of modules in SHC mode, and min(QCooInt_flow)
is the capacity of one module in cooling-only mode.Discrete-event logic is then used to calculate the actual number
of modules in each mode (nUniShc, nUniHea
and nUniCoo) considering the following
requirements.
dtRun.nUniShcRaw + nUniHeaRaw +
nUniCooRaw) exceeds the number of modules in the bank, the
following priority applies where modules required in SHC mode are
staged first and modules required in cooling mode are staged
last.A fundamental assumption for load balancing is that the system is composed of equally sized modules that are hydronically balanced, connected in parallel arrangement and controlled at the same setpoint. This implies that each module connected to the HW (resp. CHW) loop handles an equal fraction of the total heating (resp. cooling) load, irrespective of whether the module operates in SHC or single mode. This assumption is strictly true on the dominant side. However, as explained below, it is only partially true on the non-dominant side where setpoint deviations occur in the modules with excess thermal output and in the compensating module.
Based on this assumption, on the dominant side, the heating or cooling load of each module in SHC mode can be calculated as
Q<Hea|Coo>SetUniShc_flow = Q<Hea|Coo>Set_flow /
(nUniShc + nUni<Hea|Coo>).
In order to achieve load balancing between the CHW and HW sides for the subset of modules in SHC mode, the model assumes that these modules are loaded for the most demanding side, and that a single module can cycle between SHC and the corresponding single-mode operation. For example, in case of 90 % cooling load and 60 % heating load, the module will cycle between SHC at 90 % PLR during 2/3 of the time and cooling-only at 90 % PLR during 1/3 of the time. This logic is inspired from the sequence of operation of a multipipe heat pump system (Johnson Controls, 2024) where the last enabled circuit cycles between SHC and single-mode operation to balance the heating and cooling loads.
The part load ratio of each module in SHC mode to satisfy the most demanding side is
PLRShcLoa = min(PLRShcSup,
max(fHeaShc-1(QHeaSetUniShc_flow),
fCooShc-1(QCooSetUniShc_flow))),
where f<Hea|Coo>Shc-1 is the
linear interpolation of the part load ratio along the module
heating or cooling capacity at the actual source and sink
temperature, based on the performance data provided for SHC
operation.
A demand limiting logic is implemented to prevent overcooling or
overheating due to the stage minimum runtime requirement and the
possible flow variations resulting from modulating the primary pump
speed and/or the minimum flow bypass valve. This logic uses a
temperature deviation from setpoint dTSaf, which is
converted to limiting heat flow rates
Q<Hea|Coo>Saf_flow. The limiting part load ratio
is calculated as
PLRShcSaf = min(fHeaShc-1(QHeaSaf_flow / (nUniShc
+ nUniHea)), fCooShc-1(QCooSaf_flow / (nUniShc +
nUniCoo))).
The effective part load ratio of each module in SHC mode is then the minimum of the load-based and safety-limited values
PLRShc = min(PLRShcLoa, PLRShcSaf).
The excess heating or cooling heat flow rate (non-dominant side) of the modules in SHC mode is then calculated as
Q<Hea|Coo>ShcExc_flow = nUniShc *
(f<Hea|Coo>Shc(PLRShc) -
Q<Hea|Coo>SetUniShc_flow),
where f<Hea|Coo>Shc is the linear
interpolation of the module heating or cooling capacity along the
part load ratio at the actual source and sink temperature, based on
the performance data provided for SHC operation.
This excess heat flow rate is compensated by cycling a single module, which gives theg expression of the cycling ratio for this module as
ratCycShc = 1 - min(1, max(QHeaShcExc_flow / fHeaShc(PLRShc),
QCooShcExc_flow / fCooShc(PLRShc))),
where ratCycShc = 1 means perfect balance, i.e.,
the module does not cycle and continuously runs in SHC mode, and
ratCycShc = 0 means that the module continuously runs
in single mode.
The actual heating or cooling heat flow rate of the modules in SHC mode is
Q<Hea|Coo>Shc_flow = (nUniShc - 1 + ratCycShc) *
f<Hea|Coo>Shc(PLRShc).
The residual load that the module which cycles between SHC and single-mode must handle is
Q<Hea|Coo>SetUniShc_flow * nUniShc -
Q<Hea|Coo>Shc_flow,
which gives the part load ratio
PLR<Hea|Coo>ShcCyc of this module while it runs
in single mode. The corresponding heating or cooling heat flow rate
is then
Q<Hea|Coo>ShcCyc_flow = (1 - ratCycShc) *
f<Hea|Coo>(PLR<Hea|Coo>ShcCyc),
where f<Hea|Coo> is the linear interpolation
of the module capacity along the part load ratio at the actual
source and sink temperature, based on the performance data provided
for single-mode operation.
The residual heating or cooling loads that the modules running in single mode must meet can now be calculated as
Q<Hea|Coo>SetRes_flow = Q<Hea|Coo>Set_flow -
(Q<Hea|Coo>Shc_flow + Q<Hea|Coo>ShcCyc_flow),
which ultimately allows calculating the PLR value of these modules and their contribution to the total heating and cooling output of the bank.
The load balancing logic relies on a subset of modules producing
excess heat flow rate while another module compensates for it. The
fundamental assumption of even load between modules therefore
breaks down on the non-dominant side. In a real system where the
modules are hydronically balanced, this load imbalance yields
varying leaving temperatures across modules. In the worst case, the
deviation from setpoint is ΔT⋅SPLR / 2, where
ΔT is the design temperature difference.
These temperature discrepancies are neglected in the model which "numerically absorbs" them by simply adjusting the load that each module must handle. This creates a modeling uncertainty that is deemed acceptable given the error magnitude and partial cancellation of opposing errors from modules that exhibit setpoint overshoot and modules that exhibit setpoint undershoot.