src/model/AirLoopHVACUnitarySystem.cpp
| Line | Branch | Exec | Source |
|---|---|---|---|
| 1 | /*********************************************************************************************************************** | ||
| 2 | * OpenStudio(R), Copyright (c) Alliance for Energy Innovation, LLC. | ||
| 3 | * See also https://openstudio.net/license | ||
| 4 | ***********************************************************************************************************************/ | ||
| 5 | |||
| 6 | #include "AirLoopHVACUnitarySystem.hpp" | ||
| 7 | #include "AirLoopHVACUnitarySystem_Impl.hpp" | ||
| 8 | |||
| 9 | #include "ThermalZone.hpp" | ||
| 10 | #include "ThermalZone_Impl.hpp" | ||
| 11 | #include "Schedule.hpp" | ||
| 12 | #include "Schedule_Impl.hpp" | ||
| 13 | #include "Model.hpp" | ||
| 14 | #include "Model_Impl.hpp" | ||
| 15 | #include "HVACComponent.hpp" | ||
| 16 | #include "HVACComponent_Impl.hpp" | ||
| 17 | #include "Node.hpp" | ||
| 18 | #include "Node_Impl.hpp" | ||
| 19 | #include "PlantLoop.hpp" | ||
| 20 | #include "ScheduleTypeLimits.hpp" | ||
| 21 | #include "ScheduleTypeRegistry.hpp" | ||
| 22 | #include "UnitarySystemPerformanceMultispeed.hpp" | ||
| 23 | #include "UnitarySystemPerformanceMultispeed_Impl.hpp" | ||
| 24 | |||
| 25 | #include "../utilities/core/Assert.hpp" | ||
| 26 | #include "../utilities/data/DataEnums.hpp" | ||
| 27 | #include "../utilities/core/Compare.hpp" | ||
| 28 | #include "../utilities/core/Exception.hpp" | ||
| 29 | |||
| 30 | #include <utilities/idd/IddFactory.hxx> | ||
| 31 | #include <utilities/idd/OS_AirLoopHVAC_UnitarySystem_FieldEnums.hxx> | ||
| 32 | #include <utilities/idd/IddEnums.hxx> | ||
| 33 | |||
| 34 | // Remove when deprecated methods (maximumCyclingRate and co) are removed | ||
| 35 | #include "../utilities/core/DeprecatedHelpers.hpp" | ||
| 36 | #include "CoilCoolingDXVariableSpeed.hpp" | ||
| 37 | #include "CoilCoolingDXVariableSpeed_Impl.hpp" | ||
| 38 | #include "CoilCoolingWaterToAirHeatPumpEquationFit.hpp" | ||
| 39 | #include "CoilCoolingWaterToAirHeatPumpEquationFit_Impl.hpp" | ||
| 40 | #include "CoilCoolingWaterToAirHeatPumpVariableSpeedEquationFit.hpp" | ||
| 41 | #include "CoilCoolingWaterToAirHeatPumpVariableSpeedEquationFit_Impl.hpp" | ||
| 42 | |||
| 43 | namespace openstudio { | ||
| 44 | namespace model { | ||
| 45 | |||
| 46 | namespace detail { | ||
| 47 | |||
| 48 | 114 | AirLoopHVACUnitarySystem_Impl::AirLoopHVACUnitarySystem_Impl(const IdfObject& idfObject, Model_Impl* model, bool keepHandle) | |
| 49 | 114 | : ZoneHVACComponent_Impl(idfObject, model, keepHandle) { | |
| 50 |
4/6✓ Branch 1 taken 114 times.
✓ Branch 4 taken 114 times.
✓ Branch 7 taken 114 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 114 times.
✗ Branch 13 not taken.
|
114 | OS_ASSERT(idfObject.iddObject().type() == AirLoopHVACUnitarySystem::iddObjectType()); |
| 51 | 114 | } | |
| 52 | |||
| 53 | 17 | AirLoopHVACUnitarySystem_Impl::AirLoopHVACUnitarySystem_Impl(const openstudio::detail::WorkspaceObject_Impl& other, Model_Impl* model, | |
| 54 | 17 | bool keepHandle) | |
| 55 | 17 | : ZoneHVACComponent_Impl(other, model, keepHandle) { | |
| 56 |
4/6✓ Branch 1 taken 17 times.
✓ Branch 4 taken 17 times.
✓ Branch 7 taken 17 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 17 times.
✗ Branch 13 not taken.
|
17 | OS_ASSERT(other.iddObject().type() == AirLoopHVACUnitarySystem::iddObjectType()); |
| 57 | 17 | } | |
| 58 | |||
| 59 | 89 | AirLoopHVACUnitarySystem_Impl::AirLoopHVACUnitarySystem_Impl(const AirLoopHVACUnitarySystem_Impl& other, Model_Impl* model, bool keepHandle) | |
| 60 | 89 | : ZoneHVACComponent_Impl(other, model, keepHandle) {} | |
| 61 | |||
| 62 | ✗ | const std::vector<std::string>& AirLoopHVACUnitarySystem_Impl::outputVariableNames() const { | |
| 63 | // TODO: make this non static, and do implement the test cases below | ||
| 64 | static const std::vector<std::string> result{ | ||
| 65 | "Unitary System Fan Part Load Ratio", "Unitary System Compressor Part Load Ratio", "Unitary System Total Cooling Rate", | ||
| 66 | "Unitary System Total Heating Rate", "Unitary System Sensible Cooling Rate", "Unitary System Sensible Heating Rate", | ||
| 67 | "Unitary System Latent Cooling Rate", "Unitary System Latent Heating Rate", "Unitary System Ancillary Electricity Rate", | ||
| 68 | |||
| 69 | // Load based and SingleZoneVAV control outputs | ||
| 70 | "Unitary System Predicted Sensible Load to Setpoint Heat Transfer Rate", | ||
| 71 | "Unitary System Predicted Moisture Load to Setpoint Heat Transfer Rate", | ||
| 72 | |||
| 73 | // Two speed coil outputs | ||
| 74 | "Unitary System Cycling Ratio", "Unitary System Compressor Speed Ratio", | ||
| 75 | |||
| 76 | // Multi speed coil outputs | ||
| 77 | "Unitary System DX Coil Cycling Ratio", "Unitary System DX Coil Speed Ratio", "Unitary System DX Coil Speed Level", | ||
| 78 | "Unitary System Electricity Rate", "Unitary System Electricity Energy", "Unitary System Cooling Ancillary Electricity Energy", | ||
| 79 | "Unitary System Heating Ancillary Electricity Energy", | ||
| 80 | |||
| 81 | // Multi speed coil outputs(If heat recovery is specified) | ||
| 82 | "Unitary System Heat Recovery Rate", "Unitary System Heat Recovery Inlet Temperature", "Unitary System Heat Recovery Outlet Temperature", | ||
| 83 | "Unitary System Heat Recovery Fluid Mass Flow Rate", "Unitary System Heat Recovery Energy", | ||
| 84 | |||
| 85 | // Variable speed coils | ||
| 86 | "Unitary System Requested Sensible Cooling Rate", "Unitary System Requested Latent Cooling Rate", | ||
| 87 | |||
| 88 | // Water to air heat pump outputs | ||
| 89 | "Unitary System Requested Sensible Cooling Rate", "Unitary System Requested Latent Cooling Rate", "Unitary System Requested Heating Rate", | ||
| 90 | ✗ | "Unitary System Water Coil Cycling Ratio", "Unitary System Water Coil Speed Ratio", "Unitary System Water Coil Speed Level"}; | |
| 91 | ✗ | return result; | |
| 92 | ✗ | } | |
| 93 | |||
| 94 | 32 | IddObjectType AirLoopHVACUnitarySystem_Impl::iddObjectType() const { | |
| 95 | 32 | return AirLoopHVACUnitarySystem::iddObjectType(); | |
| 96 | } | ||
| 97 | |||
| 98 | ✗ | std::vector<ScheduleTypeKey> AirLoopHVACUnitarySystem_Impl::getScheduleTypeKeys(const Schedule& schedule) const { | |
| 99 | ✗ | std::vector<ScheduleTypeKey> result; | |
| 100 | ✗ | const UnsignedVector fieldIndices = getSourceIndices(schedule.handle()); | |
| 101 | ✗ | const auto b = fieldIndices.cbegin(); | |
| 102 | ✗ | const auto e = fieldIndices.cend(); | |
| 103 | ✗ | if (std::find(b, e, OS_AirLoopHVAC_UnitarySystemFields::AvailabilityScheduleName) != e) { | |
| 104 | ✗ | result.emplace_back("AirLoopHVACUnitarySystem", "Availability"); | |
| 105 | } | ||
| 106 | ✗ | if (std::find(b, e, OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFanOperatingModeScheduleName) != e) { | |
| 107 | ✗ | result.emplace_back("AirLoopHVACUnitarySystem", "Supply Air Fan Operating Mode"); | |
| 108 | } | ||
| 109 | ✗ | return result; | |
| 110 | ✗ | } | |
| 111 | |||
| 112 | 8 | ModelObject AirLoopHVACUnitarySystem_Impl::clone(Model model) const { | |
| 113 | // Mimic what StraightComponent_Impl::clone would do (we inherit ZoneHVACComponent here...) | ||
| 114 |
3/3✓ Branch 1 taken 8 times.
✓ Branch 4 taken 8 times.
✓ Branch 7 taken 8 times.
|
8 | auto modelObjectClone = ModelObject_Impl::clone(model).cast<AirLoopHVACUnitarySystem>(); // NOLINT(bugprone-parent-virtual-call) |
| 115 |
3/3✓ Branch 1 taken 8 times.
✓ Branch 4 taken 8 times.
✓ Branch 7 taken 8 times.
|
16 | modelObjectClone.setString(modelObjectClone.inletPort(), ""); |
| 116 |
3/3✓ Branch 1 taken 8 times.
✓ Branch 4 taken 8 times.
✓ Branch 7 taken 8 times.
|
8 | modelObjectClone.setString(modelObjectClone.outletPort(), ""); |
| 117 | |||
| 118 |
3/3✓ Branch 1 taken 8 times.
✓ Branch 3 taken 4 times.
✓ Branch 4 taken 4 times.
|
16 | if (boost::optional<HVACComponent> supplyFan = this->supplyFan()) { |
| 119 |
5/5✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
✓ Branch 7 taken 4 times.
✓ Branch 10 taken 4 times.
✓ Branch 13 taken 4 times.
|
4 | modelObjectClone.setSupplyFan(supplyFan->clone(model).cast<HVACComponent>()); |
| 120 | 8 | } | |
| 121 |
3/3✓ Branch 1 taken 8 times.
✓ Branch 3 taken 6 times.
✓ Branch 4 taken 2 times.
|
16 | if (boost::optional<HVACComponent> coolingCoil = this->coolingCoil()) { |
| 122 |
5/5✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
✓ Branch 7 taken 6 times.
✓ Branch 10 taken 6 times.
✓ Branch 13 taken 6 times.
|
6 | modelObjectClone.setCoolingCoil(coolingCoil->clone(model).cast<HVACComponent>()); |
| 123 | 8 | } | |
| 124 |
3/3✓ Branch 1 taken 8 times.
✓ Branch 3 taken 4 times.
✓ Branch 4 taken 4 times.
|
16 | if (boost::optional<HVACComponent> heatingCoil = this->heatingCoil()) { |
| 125 |
5/5✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
✓ Branch 7 taken 4 times.
✓ Branch 10 taken 4 times.
✓ Branch 13 taken 4 times.
|
4 | modelObjectClone.setHeatingCoil(heatingCoil->clone(model).cast<HVACComponent>()); |
| 126 | 8 | } | |
| 127 |
3/3✓ Branch 1 taken 8 times.
✓ Branch 3 taken 4 times.
✓ Branch 4 taken 4 times.
|
16 | if (boost::optional<HVACComponent> supplementalHeatingCoil = this->supplementalHeatingCoil()) { |
| 128 |
5/5✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
✓ Branch 7 taken 4 times.
✓ Branch 10 taken 4 times.
✓ Branch 13 taken 4 times.
|
4 | modelObjectClone.setSupplementalHeatingCoil(supplementalHeatingCoil->clone(model).cast<HVACComponent>()); |
| 129 | 8 | } | |
| 130 |
2/3✓ Branch 1 taken 8 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 8 times.
|
16 | if (auto designSpec = designSpecificationMultispeedObject()) { |
| 131 | ✗ | modelObjectClone.setDesignSpecificationMultispeedObject(designSpec->clone(model).cast<UnitarySystemPerformanceMultispeed>()); | |
| 132 | 8 | } | |
| 133 | |||
| 134 | 16 | return std::move(modelObjectClone); | |
| 135 | 8 | } | |
| 136 | |||
| 137 | 76 | std::vector<ModelObject> AirLoopHVACUnitarySystem_Impl::children() const { | |
| 138 | 76 | std::vector<ModelObject> result; | |
| 139 | |||
| 140 |
3/3✓ Branch 1 taken 76 times.
✓ Branch 3 taken 26 times.
✓ Branch 4 taken 50 times.
|
152 | if (boost::optional<HVACComponent> supplyFan = this->supplyFan()) { |
| 141 |
2/2✓ Branch 1 taken 26 times.
✓ Branch 4 taken 26 times.
|
26 | result.push_back(*supplyFan); |
| 142 | 76 | } | |
| 143 |
3/3✓ Branch 1 taken 76 times.
✓ Branch 3 taken 53 times.
✓ Branch 4 taken 23 times.
|
152 | if (boost::optional<HVACComponent> coolingCoil = this->coolingCoil()) { |
| 144 |
2/2✓ Branch 1 taken 53 times.
✓ Branch 4 taken 53 times.
|
53 | result.push_back(*coolingCoil); |
| 145 | 76 | } | |
| 146 |
3/3✓ Branch 1 taken 76 times.
✓ Branch 3 taken 38 times.
✓ Branch 4 taken 38 times.
|
152 | if (boost::optional<HVACComponent> heatingCoil = this->heatingCoil()) { |
| 147 |
2/2✓ Branch 1 taken 38 times.
✓ Branch 4 taken 38 times.
|
38 | result.push_back(*heatingCoil); |
| 148 | 76 | } | |
| 149 |
3/3✓ Branch 1 taken 76 times.
✓ Branch 3 taken 22 times.
✓ Branch 4 taken 54 times.
|
152 | if (boost::optional<HVACComponent> supplementalHeatingCoil = this->supplementalHeatingCoil()) { |
| 150 |
2/2✓ Branch 1 taken 22 times.
✓ Branch 4 taken 22 times.
|
22 | result.push_back(*supplementalHeatingCoil); |
| 151 | 76 | } | |
| 152 |
3/3✓ Branch 1 taken 76 times.
✓ Branch 3 taken 11 times.
✓ Branch 4 taken 65 times.
|
152 | if (auto designSpec = designSpecificationMultispeedObject()) { |
| 153 |
2/2✓ Branch 1 taken 11 times.
✓ Branch 4 taken 11 times.
|
11 | result.push_back(*designSpec); |
| 154 | 76 | } | |
| 155 | |||
| 156 | 76 | return result; | |
| 157 | ✗ | } | |
| 158 | |||
| 159 | 3 | std::vector<IdfObject> AirLoopHVACUnitarySystem_Impl::remove() { | |
| 160 | 3 | std::vector<IdfObject> result; | |
| 161 | |||
| 162 |
3/3✓ Branch 1 taken 3 times.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 1 time.
|
6 | if (boost::optional<HVACComponent> _supplyFan = this->supplyFan()) { |
| 163 |
2/2✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
|
2 | std::vector<IdfObject> removedFans = _supplyFan->remove(); |
| 164 |
1/1✓ Branch 5 taken 2 times.
|
2 | result.insert(result.end(), removedFans.begin(), removedFans.end()); |
| 165 | 5 | } | |
| 166 | |||
| 167 |
3/3✓ Branch 1 taken 3 times.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 1 time.
|
6 | if (boost::optional<HVACComponent> _coolingCoil = this->coolingCoil()) { |
| 168 |
3/4✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 2 times.
|
4 | if (boost::optional<PlantLoop> loop = _coolingCoil->plantLoop()) { |
| 169 | ✗ | loop->removeDemandBranchWithComponent(*_coolingCoil); | |
| 170 | 2 | } | |
| 171 |
2/2✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
|
2 | std::vector<IdfObject> removedCoolingCoils = _coolingCoil->remove(); |
| 172 |
1/1✓ Branch 5 taken 2 times.
|
2 | result.insert(result.end(), removedCoolingCoils.begin(), removedCoolingCoils.end()); |
| 173 | 5 | } | |
| 174 | |||
| 175 |
3/3✓ Branch 1 taken 3 times.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 1 time.
|
6 | if (boost::optional<HVACComponent> _heatingCoil = this->heatingCoil()) { |
| 176 |
4/4✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
✓ Branch 6 taken 1 time.
✓ Branch 7 taken 1 time.
|
4 | if (boost::optional<PlantLoop> loop = _heatingCoil->plantLoop()) { |
| 177 |
4/4✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
|
1 | loop->removeDemandBranchWithComponent(*_heatingCoil); |
| 178 | 2 | } | |
| 179 |
2/2✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
|
2 | std::vector<IdfObject> removedHeatingCoils = _heatingCoil->remove(); |
| 180 |
1/1✓ Branch 5 taken 2 times.
|
2 | result.insert(result.end(), removedHeatingCoils.begin(), removedHeatingCoils.end()); |
| 181 | 5 | } | |
| 182 | |||
| 183 |
3/3✓ Branch 1 taken 3 times.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 1 time.
|
6 | if (boost::optional<HVACComponent> _supplementalHeatingCoil = this->supplementalHeatingCoil()) { |
| 184 |
4/4✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
✓ Branch 6 taken 1 time.
✓ Branch 7 taken 1 time.
|
4 | if (boost::optional<PlantLoop> loop = _supplementalHeatingCoil->plantLoop()) { |
| 185 |
4/4✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
|
1 | loop->removeDemandBranchWithComponent(*_supplementalHeatingCoil); |
| 186 | 2 | } | |
| 187 |
2/2✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
|
2 | std::vector<IdfObject> removedSuppHeatingCoils = _supplementalHeatingCoil->remove(); |
| 188 |
1/1✓ Branch 5 taken 2 times.
|
2 | result.insert(result.end(), removedSuppHeatingCoils.begin(), removedSuppHeatingCoils.end()); |
| 189 | 5 | } | |
| 190 | |||
| 191 |
2/3✓ Branch 1 taken 3 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.
|
6 | if (auto designSpec = designSpecificationMultispeedObject()) { |
| 192 | ✗ | auto removed = designSpec->remove(); | |
| 193 | ✗ | result.insert(result.end(), removed.begin(), removed.end()); | |
| 194 | 3 | } | |
| 195 | |||
| 196 |
1/1✓ Branch 1 taken 3 times.
|
3 | std::vector<IdfObject> removedUnitarySystem = ZoneHVACComponent_Impl::remove(); |
| 197 |
1/1✓ Branch 5 taken 3 times.
|
3 | result.insert(result.end(), removedUnitarySystem.begin(), removedUnitarySystem.end()); |
| 198 | |||
| 199 | 6 | return result; | |
| 200 | 3 | } | |
| 201 | |||
| 202 | 76 | bool AirLoopHVACUnitarySystem_Impl::addToNode(Node& node) { | |
| 203 | 76 | bool result = ZoneHVACComponent_Impl::addToNode(node); | |
| 204 | |||
| 205 |
1/2✓ Branch 0 taken 76 times.
✗ Branch 1 not taken.
|
76 | if (!result) { |
| 206 |
1/1✓ Branch 1 taken 76 times.
|
76 | auto _model = node.model(); |
| 207 |
1/1✓ Branch 1 taken 76 times.
|
76 | auto thisModelObject = getObject<ModelObject>(); |
| 208 |
1/1✓ Branch 1 taken 76 times.
|
76 | auto t_airLoop = node.airLoopHVAC(); |
| 209 |
1/1✓ Branch 1 taken 76 times.
|
76 | auto t_oaSystem = node.airLoopHVACOutdoorAirSystem(); |
| 210 | |||
| 211 | 76 | boost::optional<unsigned> componentInletPort; | |
| 212 | 76 | boost::optional<unsigned> componentOutletPort; | |
| 213 | |||
| 214 | 76 | boost::optional<HVACComponent> systemStartComponent; | |
| 215 | 76 | boost::optional<HVACComponent> systemEndComponent; | |
| 216 | |||
| 217 |
3/3✓ Branch 3 taken 76 times.
✓ Branch 6 taken 1 time.
✓ Branch 7 taken 75 times.
|
76 | if (node.getImpl<Node_Impl>()->isConnected(thisModelObject)) { |
| 218 | 1 | return false; | |
| 219 | } | ||
| 220 | |||
| 221 |
5/6✓ Branch 0 taken 71 times.
✓ Branch 1 taken 4 times.
✓ Branch 3 taken 71 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 71 times.
✓ Branch 6 taken 4 times.
|
75 | if (t_airLoop && !t_oaSystem) { |
| 222 |
5/5✓ Branch 1 taken 71 times.
✓ Branch 4 taken 71 times.
✓ Branch 7 taken 71 times.
✓ Branch 10 taken 1 time.
✓ Branch 11 taken 70 times.
|
142 | if (t_airLoop->demandComponent(node.handle())) { |
| 223 | 1 | return false; | |
| 224 | } | ||
| 225 | |||
| 226 |
3/3✓ Branch 1 taken 70 times.
✓ Branch 4 taken 70 times.
✓ Branch 7 taken 70 times.
|
70 | systemStartComponent = t_airLoop->supplyInletNode(); |
| 227 |
2/2✓ Branch 1 taken 70 times.
✓ Branch 4 taken 70 times.
|
70 | auto nodes = t_airLoop->supplyOutletNodes(); |
| 228 |
1/3✗ Branch 1 not taken.
✓ Branch 2 taken 70 times.
✗ Branch 4 not taken.
|
70 | OS_ASSERT(!nodes.empty()); |
| 229 |
5/22✗ Branch 1 not taken.
✓ Branch 2 taken 70 times.
✗ Branch 4 not taken.
✗ Branch 7 not taken.
✗ Branch 10 not taken.
✗ Branch 14 not taken.
✗ Branch 17 not taken.
✗ Branch 18 not taken.
✗ Branch 19 not taken.
✓ Branch 20 taken 70 times.
✗ Branch 22 not taken.
✓ Branch 23 taken 70 times.
✗ Branch 25 not taken.
✓ Branch 26 taken 70 times.
✗ Branch 27 not taken.
✓ Branch 28 taken 70 times.
✗ Branch 29 not taken.
✗ Branch 30 not taken.
✗ Branch 32 not taken.
✗ Branch 33 not taken.
✗ Branch 35 not taken.
✗ Branch 36 not taken.
|
70 | if ((nodes.size() == 2u) && (!t_airLoop->supplyComponents(node, nodes[1]).empty())) { |
| 230 | ✗ | systemEndComponent = nodes[1]; | |
| 231 | } else { | ||
| 232 |
1/1✓ Branch 2 taken 70 times.
|
70 | systemEndComponent = nodes[0]; |
| 233 | } | ||
| 234 |
1/3✗ Branch 1 not taken.
✓ Branch 2 taken 70 times.
✗ Branch 4 not taken.
|
70 | OS_ASSERT(systemEndComponent); |
| 235 |
2/2✓ Branch 1 taken 70 times.
✓ Branch 4 taken 70 times.
|
70 | componentInletPort = inletPort(); |
| 236 |
2/2✓ Branch 1 taken 70 times.
✓ Branch 4 taken 70 times.
|
70 | componentOutletPort = outletPort(); |
| 237 | |||
| 238 |
1/1✓ Branch 1 taken 70 times.
|
70 | removeFromAirLoopHVAC(); |
| 239 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
|
74 | } else if (t_oaSystem) { |
| 240 | ✗ | if (t_oaSystem->oaComponent(node.handle())) { | |
| 241 | ✗ | systemStartComponent = t_oaSystem->outboardOANode(); | |
| 242 | ✗ | systemEndComponent = t_oaSystem.get(); | |
| 243 | ✗ | componentInletPort = inletPort(); | |
| 244 | ✗ | componentOutletPort = outletPort(); | |
| 245 | ✗ | } else if (t_oaSystem->reliefComponent(node.handle())) { | |
| 246 | ✗ | systemStartComponent = t_oaSystem.get(); | |
| 247 | ✗ | systemEndComponent = t_oaSystem->outboardReliefNode(); | |
| 248 | ✗ | componentInletPort = inletPort(); | |
| 249 | ✗ | componentOutletPort = outletPort(); | |
| 250 | } | ||
| 251 | ✗ | removeFromAirLoopHVAC(); | |
| 252 | } | ||
| 253 | |||
| 254 |
7/10✓ Branch 0 taken 70 times.
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 70 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 70 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 70 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 70 times.
✓ Branch 9 taken 4 times.
|
284 | if (systemStartComponent && systemEndComponent && componentOutletPort && componentInletPort) { |
| 255 |
3/3✓ Branch 1 taken 70 times.
✓ Branch 4 taken 70 times.
✓ Branch 7 taken 70 times.
|
70 | result = HVACComponent_Impl::addToNode(node, systemStartComponent.get(), systemEndComponent.get(), componentInletPort.get(), |
| 256 |
2/2✓ Branch 1 taken 70 times.
✓ Branch 4 taken 70 times.
|
70 | componentOutletPort.get()); |
| 257 | } | ||
| 258 | 86 | } | |
| 259 | |||
| 260 | 74 | return result; | |
| 261 | } | ||
| 262 | |||
| 263 | 358 | unsigned AirLoopHVACUnitarySystem_Impl::inletPort() const { | |
| 264 | 358 | return OS_AirLoopHVAC_UnitarySystemFields::AirInletNodeName; | |
| 265 | } | ||
| 266 | |||
| 267 | 636 | unsigned AirLoopHVACUnitarySystem_Impl::outletPort() const { | |
| 268 | 636 | return OS_AirLoopHVAC_UnitarySystemFields::AirOutletNodeName; | |
| 269 | } | ||
| 270 | |||
| 271 | 75 | std::string AirLoopHVACUnitarySystem_Impl::controlType() const { | |
| 272 |
1/1✓ Branch 1 taken 75 times.
|
75 | boost::optional<std::string> value = getString(OS_AirLoopHVAC_UnitarySystemFields::ControlType, true); |
| 273 |
1/3✗ Branch 1 not taken.
✓ Branch 2 taken 75 times.
✗ Branch 4 not taken.
|
75 | OS_ASSERT(value); |
| 274 |
2/2✓ Branch 1 taken 75 times.
✓ Branch 4 taken 75 times.
|
150 | return value.get(); |
| 275 | 75 | } | |
| 276 | |||
| 277 | 3 | bool AirLoopHVACUnitarySystem_Impl::isControlTypeDefaulted() const { | |
| 278 | 3 | return isEmpty(OS_AirLoopHVAC_UnitarySystemFields::ControlType); | |
| 279 | } | ||
| 280 | |||
| 281 | 73 | boost::optional<ThermalZone> AirLoopHVACUnitarySystem_Impl::controllingZoneorThermostatLocation() const { | |
| 282 |
2/2✓ Branch 1 taken 73 times.
✓ Branch 4 taken 73 times.
|
73 | return getObject<ModelObject>().getModelObjectTarget<ThermalZone>(OS_AirLoopHVAC_UnitarySystemFields::ControllingZoneorThermostatLocation); |
| 283 | } | ||
| 284 | |||
| 285 | 75 | std::string AirLoopHVACUnitarySystem_Impl::dehumidificationControlType() const { | |
| 286 |
1/1✓ Branch 1 taken 75 times.
|
75 | boost::optional<std::string> value = getString(OS_AirLoopHVAC_UnitarySystemFields::DehumidificationControlType, true); |
| 287 |
1/3✗ Branch 1 not taken.
✓ Branch 2 taken 75 times.
✗ Branch 4 not taken.
|
75 | OS_ASSERT(value); |
| 288 |
2/2✓ Branch 1 taken 75 times.
✓ Branch 4 taken 75 times.
|
150 | return value.get(); |
| 289 | 75 | } | |
| 290 | |||
| 291 | ✗ | bool AirLoopHVACUnitarySystem_Impl::isDehumidificationControlTypeDefaulted() const { | |
| 292 | ✗ | return isEmpty(OS_AirLoopHVAC_UnitarySystemFields::DehumidificationControlType); | |
| 293 | } | ||
| 294 | |||
| 295 | 73 | boost::optional<Schedule> AirLoopHVACUnitarySystem_Impl::availabilitySchedule() const { | |
| 296 |
2/2✓ Branch 1 taken 73 times.
✓ Branch 4 taken 73 times.
|
73 | return getObject<ModelObject>().getModelObjectTarget<Schedule>(OS_AirLoopHVAC_UnitarySystemFields::AvailabilityScheduleName); |
| 297 | } | ||
| 298 | |||
| 299 | 173 | boost::optional<HVACComponent> AirLoopHVACUnitarySystem_Impl::supplyFan() const { | |
| 300 |
2/2✓ Branch 1 taken 173 times.
✓ Branch 4 taken 173 times.
|
173 | return getObject<ModelObject>().getModelObjectTarget<HVACComponent>(OS_AirLoopHVAC_UnitarySystemFields::SupplyFanName); |
| 301 | } | ||
| 302 | |||
| 303 | 74 | boost::optional<std::string> AirLoopHVACUnitarySystem_Impl::fanPlacement() const { | |
| 304 | // No default, and return uninitialized if empty | ||
| 305 | 74 | return getString(OS_AirLoopHVAC_UnitarySystemFields::FanPlacement, false, true); | |
| 306 | } | ||
| 307 | |||
| 308 | 73 | boost::optional<Schedule> AirLoopHVACUnitarySystem_Impl::supplyAirFanOperatingModeSchedule() const { | |
| 309 |
2/2✓ Branch 1 taken 73 times.
✓ Branch 4 taken 73 times.
|
73 | return getObject<ModelObject>().getModelObjectTarget<Schedule>(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFanOperatingModeScheduleName); |
| 310 | } | ||
| 311 | |||
| 312 | 2 | bool AirLoopHVACUnitarySystem_Impl::hasHeatingCoil() const { | |
| 313 | 2 | return !isEmpty(OS_AirLoopHVAC_UnitarySystemFields::HeatingCoilName); | |
| 314 | } | ||
| 315 | |||
| 316 | 225 | boost::optional<HVACComponent> AirLoopHVACUnitarySystem_Impl::heatingCoil() const { | |
| 317 |
2/2✓ Branch 1 taken 225 times.
✓ Branch 4 taken 225 times.
|
225 | return getObject<ModelObject>().getModelObjectTarget<HVACComponent>(OS_AirLoopHVAC_UnitarySystemFields::HeatingCoilName); |
| 318 | } | ||
| 319 | |||
| 320 | 75 | double AirLoopHVACUnitarySystem_Impl::dXHeatingCoilSizingRatio() const { | |
| 321 |
1/1✓ Branch 1 taken 75 times.
|
75 | boost::optional<double> value = getDouble(OS_AirLoopHVAC_UnitarySystemFields::DXHeatingCoilSizingRatio, true); |
| 322 |
1/3✗ Branch 1 not taken.
✓ Branch 2 taken 75 times.
✗ Branch 4 not taken.
|
75 | OS_ASSERT(value); |
| 323 |
1/1✓ Branch 1 taken 75 times.
|
150 | return value.get(); |
| 324 | } | ||
| 325 | |||
| 326 | ✗ | bool AirLoopHVACUnitarySystem_Impl::isDXHeatingCoilSizingRatioDefaulted() const { | |
| 327 | ✗ | return isEmpty(OS_AirLoopHVAC_UnitarySystemFields::DXHeatingCoilSizingRatio); | |
| 328 | } | ||
| 329 | |||
| 330 | 2 | bool AirLoopHVACUnitarySystem_Impl::hasCoolingCoil() const { | |
| 331 | 2 | return !isEmpty(OS_AirLoopHVAC_UnitarySystemFields::CoolingCoilName); | |
| 332 | } | ||
| 333 | |||
| 334 | 268 | boost::optional<HVACComponent> AirLoopHVACUnitarySystem_Impl::coolingCoil() const { | |
| 335 |
2/2✓ Branch 1 taken 268 times.
✓ Branch 4 taken 268 times.
|
268 | return getObject<ModelObject>().getModelObjectTarget<HVACComponent>(OS_AirLoopHVAC_UnitarySystemFields::CoolingCoilName); |
| 336 | } | ||
| 337 | |||
| 338 | 75 | bool AirLoopHVACUnitarySystem_Impl::useDOASDXCoolingCoil() const { | |
| 339 |
1/1✓ Branch 1 taken 75 times.
|
75 | boost::optional<std::string> value = getString(OS_AirLoopHVAC_UnitarySystemFields::UseDOASDXCoolingCoil, true); |
| 340 |
1/3✗ Branch 1 not taken.
✓ Branch 2 taken 75 times.
✗ Branch 4 not taken.
|
75 | OS_ASSERT(value); |
| 341 |
3/3✓ Branch 1 taken 75 times.
✓ Branch 4 taken 75 times.
✓ Branch 7 taken 75 times.
|
150 | return openstudio::istringEqual(value.get(), "Yes"); |
| 342 | 75 | } | |
| 343 | |||
| 344 | ✗ | bool AirLoopHVACUnitarySystem_Impl::isUseDOASDXCoolingCoilDefaulted() const { | |
| 345 | ✗ | return isEmpty(OS_AirLoopHVAC_UnitarySystemFields::UseDOASDXCoolingCoil); | |
| 346 | } | ||
| 347 | |||
| 348 | 75 | double AirLoopHVACUnitarySystem_Impl::dOASDXCoolingCoilLeavingMinimumAirTemperature() const { | |
| 349 |
1/1✓ Branch 1 taken 75 times.
|
75 | boost::optional<double> value = getDouble(OS_AirLoopHVAC_UnitarySystemFields::DOASDXCoolingCoilLeavingMinimumAirTemperature, true); |
| 350 |
1/3✗ Branch 1 not taken.
✓ Branch 2 taken 75 times.
✗ Branch 4 not taken.
|
75 | OS_ASSERT(value); |
| 351 |
1/1✓ Branch 1 taken 75 times.
|
150 | return value.get(); |
| 352 | } | ||
| 353 | |||
| 354 | 3 | bool AirLoopHVACUnitarySystem_Impl::isDOASDXCoolingCoilLeavingMinimumAirTemperatureDefaulted() const { | |
| 355 | 3 | return isEmpty(OS_AirLoopHVAC_UnitarySystemFields::DOASDXCoolingCoilLeavingMinimumAirTemperature); | |
| 356 | } | ||
| 357 | |||
| 358 | 76 | bool AirLoopHVACUnitarySystem_Impl::isDOASDXCoolingCoilLeavingMinimumAirTemperatureAutosized() const { | |
| 359 | 76 | bool result = false; | |
| 360 |
1/1✓ Branch 1 taken 76 times.
|
76 | boost::optional<std::string> value = getString(OS_AirLoopHVAC_UnitarySystemFields::DOASDXCoolingCoilLeavingMinimumAirTemperature, true); |
| 361 |
1/2✓ Branch 0 taken 76 times.
✗ Branch 1 not taken.
|
76 | if (value) { |
| 362 |
3/3✓ Branch 1 taken 76 times.
✓ Branch 4 taken 76 times.
✓ Branch 7 taken 76 times.
|
152 | result = openstudio::istringEqual(value.get(), "Autosize"); |
| 363 | } | ||
| 364 | 76 | return result; | |
| 365 | 76 | } | |
| 366 | |||
| 367 | 75 | std::string AirLoopHVACUnitarySystem_Impl::latentLoadControl() const { | |
| 368 |
1/1✓ Branch 1 taken 75 times.
|
75 | boost::optional<std::string> value = getString(OS_AirLoopHVAC_UnitarySystemFields::LatentLoadControl, true); |
| 369 |
1/3✗ Branch 1 not taken.
✓ Branch 2 taken 75 times.
✗ Branch 4 not taken.
|
75 | OS_ASSERT(value); |
| 370 |
2/2✓ Branch 1 taken 75 times.
✓ Branch 4 taken 75 times.
|
150 | return value.get(); |
| 371 | 75 | } | |
| 372 | |||
| 373 | ✗ | bool AirLoopHVACUnitarySystem_Impl::isLatentLoadControlDefaulted() const { | |
| 374 | ✗ | return isEmpty(OS_AirLoopHVAC_UnitarySystemFields::LatentLoadControl); | |
| 375 | } | ||
| 376 | |||
| 377 | 178 | boost::optional<HVACComponent> AirLoopHVACUnitarySystem_Impl::supplementalHeatingCoil() const { | |
| 378 |
2/2✓ Branch 1 taken 178 times.
✓ Branch 4 taken 178 times.
|
178 | return getObject<ModelObject>().getModelObjectTarget<HVACComponent>(OS_AirLoopHVAC_UnitarySystemFields::SupplementalHeatingCoilName); |
| 379 | } | ||
| 380 | |||
| 381 | 131 | std::string AirLoopHVACUnitarySystem_Impl::supplyAirFlowRateMethodDuringCoolingOperation() const { | |
| 382 |
1/1✓ Branch 1 taken 131 times.
|
131 | boost::optional<std::string> value = getString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringCoolingOperation, true); |
| 383 |
1/3✗ Branch 1 not taken.
✓ Branch 2 taken 131 times.
✗ Branch 4 not taken.
|
131 | OS_ASSERT(value); |
| 384 |
2/2✓ Branch 1 taken 131 times.
✓ Branch 4 taken 131 times.
|
262 | return value.get(); |
| 385 | 131 | } | |
| 386 | |||
| 387 | 21 | boost::optional<double> AirLoopHVACUnitarySystem_Impl::supplyAirFlowRateDuringCoolingOperation() const { | |
| 388 | 21 | return getDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringCoolingOperation, true); | |
| 389 | } | ||
| 390 | |||
| 391 | 60 | bool AirLoopHVACUnitarySystem_Impl::isSupplyAirFlowRateDuringCoolingOperationAutosized() const { | |
| 392 | 60 | bool result = false; | |
| 393 |
1/1✓ Branch 1 taken 60 times.
|
60 | boost::optional<std::string> value = getString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringCoolingOperation, true); |
| 394 |
1/2✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
|
60 | if (value) { |
| 395 |
3/3✓ Branch 1 taken 60 times.
✓ Branch 4 taken 60 times.
✓ Branch 7 taken 60 times.
|
120 | result = openstudio::istringEqual(value.get(), "Autosize"); |
| 396 | } | ||
| 397 | 60 | return result; | |
| 398 | 60 | } | |
| 399 | |||
| 400 | 59 | boost::optional<double> AirLoopHVACUnitarySystem_Impl::supplyAirFlowRatePerFloorAreaDuringCoolingOperation() const { | |
| 401 | 59 | return getDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaDuringCoolingOperation, true); | |
| 402 | } | ||
| 403 | |||
| 404 | 59 | boost::optional<double> AirLoopHVACUnitarySystem_Impl::fractionofAutosizedDesignCoolingSupplyAirFlowRate() const { | |
| 405 | 59 | return getDouble(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignCoolingSupplyAirFlowRate, true); | |
| 406 | } | ||
| 407 | |||
| 408 | 59 | boost::optional<double> AirLoopHVACUnitarySystem_Impl::designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation() const { | |
| 409 | 59 | return getDouble(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation, true); | |
| 410 | } | ||
| 411 | |||
| 412 | 102 | std::string AirLoopHVACUnitarySystem_Impl::supplyAirFlowRateMethodDuringHeatingOperation() const { | |
| 413 |
1/1✓ Branch 1 taken 102 times.
|
102 | boost::optional<std::string> value = getString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringHeatingOperation, true); |
| 414 |
1/3✗ Branch 1 not taken.
✓ Branch 2 taken 102 times.
✗ Branch 4 not taken.
|
102 | OS_ASSERT(value); |
| 415 |
2/2✓ Branch 1 taken 102 times.
✓ Branch 4 taken 102 times.
|
204 | return value.get(); |
| 416 | 102 | } | |
| 417 | |||
| 418 | 21 | boost::optional<double> AirLoopHVACUnitarySystem_Impl::supplyAirFlowRateDuringHeatingOperation() const { | |
| 419 | 21 | return getDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringHeatingOperation, true); | |
| 420 | } | ||
| 421 | |||
| 422 | 45 | bool AirLoopHVACUnitarySystem_Impl::isSupplyAirFlowRateDuringHeatingOperationAutosized() const { | |
| 423 | 45 | bool result = false; | |
| 424 |
1/1✓ Branch 1 taken 45 times.
|
45 | boost::optional<std::string> value = getString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringHeatingOperation, true); |
| 425 |
1/2✓ Branch 0 taken 45 times.
✗ Branch 1 not taken.
|
45 | if (value) { |
| 426 |
3/3✓ Branch 1 taken 45 times.
✓ Branch 4 taken 45 times.
✓ Branch 7 taken 45 times.
|
90 | result = openstudio::istringEqual(value.get(), "Autosize"); |
| 427 | } | ||
| 428 | 45 | return result; | |
| 429 | 45 | } | |
| 430 | |||
| 431 | 44 | boost::optional<double> AirLoopHVACUnitarySystem_Impl::supplyAirFlowRatePerFloorAreaduringHeatingOperation() const { | |
| 432 | 44 | return getDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaduringHeatingOperation, true); | |
| 433 | } | ||
| 434 | |||
| 435 | 44 | boost::optional<double> AirLoopHVACUnitarySystem_Impl::fractionofAutosizedDesignHeatingSupplyAirFlowRate() const { | |
| 436 | 44 | return getDouble(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignHeatingSupplyAirFlowRate, true); | |
| 437 | } | ||
| 438 | |||
| 439 | 44 | boost::optional<double> AirLoopHVACUnitarySystem_Impl::designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation() const { | |
| 440 | 44 | return getDouble(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation, true); | |
| 441 | } | ||
| 442 | |||
| 443 | 85 | std::string AirLoopHVACUnitarySystem_Impl::supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired() const { | |
| 444 | boost::optional<std::string> value = | ||
| 445 |
1/1✓ Branch 1 taken 85 times.
|
85 | getString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired, true); |
| 446 |
1/3✗ Branch 1 not taken.
✓ Branch 2 taken 85 times.
✗ Branch 4 not taken.
|
85 | OS_ASSERT(value); |
| 447 |
2/2✓ Branch 1 taken 85 times.
✓ Branch 4 taken 85 times.
|
170 | return value.get(); |
| 448 | 85 | } | |
| 449 | |||
| 450 | 84 | boost::optional<double> AirLoopHVACUnitarySystem_Impl::supplyAirFlowRateWhenNoCoolingorHeatingisRequired() const { | |
| 451 | 84 | return getDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateWhenNoCoolingorHeatingisRequired, true); | |
| 452 | } | ||
| 453 | |||
| 454 | 85 | bool AirLoopHVACUnitarySystem_Impl::isSupplyAirFlowRateWhenNoCoolingorHeatingisRequiredAutosized() const { | |
| 455 | 85 | bool result = false; | |
| 456 |
1/1✓ Branch 1 taken 85 times.
|
85 | boost::optional<std::string> value = getString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateWhenNoCoolingorHeatingisRequired, true); |
| 457 |
1/2✓ Branch 0 taken 85 times.
✗ Branch 1 not taken.
|
85 | if (value) { |
| 458 |
3/3✓ Branch 1 taken 85 times.
✓ Branch 4 taken 85 times.
✓ Branch 7 taken 85 times.
|
170 | result = openstudio::istringEqual(value.get(), "Autosize"); |
| 459 | } | ||
| 460 | 85 | return result; | |
| 461 | 85 | } | |
| 462 | |||
| 463 | 84 | boost::optional<double> AirLoopHVACUnitarySystem_Impl::supplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired() const { | |
| 464 | 84 | return getDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired, true); | |
| 465 | } | ||
| 466 | |||
| 467 | 84 | boost::optional<double> AirLoopHVACUnitarySystem_Impl::fractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired() const { | |
| 468 | 84 | return getDouble(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired, true); | |
| 469 | } | ||
| 470 | |||
| 471 | 84 | boost::optional<double> AirLoopHVACUnitarySystem_Impl::fractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired() const { | |
| 472 | 84 | return getDouble(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired, true); | |
| 473 | } | ||
| 474 | |||
| 475 | boost::optional<double> | ||
| 476 | 84 | AirLoopHVACUnitarySystem_Impl::designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired() const { | |
| 477 | 84 | return getDouble( | |
| 478 | 84 | OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired, true); | |
| 479 | } | ||
| 480 | |||
| 481 | boost::optional<double> | ||
| 482 | 84 | AirLoopHVACUnitarySystem_Impl::designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired() const { | |
| 483 | 84 | return getDouble( | |
| 484 | 84 | OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired, true); | |
| 485 | } | ||
| 486 | |||
| 487 | 75 | bool AirLoopHVACUnitarySystem_Impl::noLoadSupplyAirFlowRateControlSetToLowSpeed() const { | |
| 488 | 75 | return getBooleanFieldValue(OS_AirLoopHVAC_UnitarySystemFields::NoLoadSupplyAirFlowRateControlSetToLowSpeed); | |
| 489 | } | ||
| 490 | |||
| 491 | 74 | boost::optional<double> AirLoopHVACUnitarySystem_Impl::maximumSupplyAirTemperature() const { | |
| 492 | 74 | return getDouble(OS_AirLoopHVAC_UnitarySystemFields::MaximumSupplyAirTemperature, true); | |
| 493 | } | ||
| 494 | |||
| 495 | ✗ | bool AirLoopHVACUnitarySystem_Impl::isMaximumSupplyAirTemperatureDefaulted() const { | |
| 496 | ✗ | return isEmpty(OS_AirLoopHVAC_UnitarySystemFields::MaximumSupplyAirTemperature); | |
| 497 | } | ||
| 498 | |||
| 499 | 74 | bool AirLoopHVACUnitarySystem_Impl::isMaximumSupplyAirTemperatureAutosized() const { | |
| 500 | 74 | bool result = false; | |
| 501 |
1/1✓ Branch 1 taken 74 times.
|
74 | boost::optional<std::string> value = getString(OS_AirLoopHVAC_UnitarySystemFields::MaximumSupplyAirTemperature, true); |
| 502 |
1/2✓ Branch 0 taken 74 times.
✗ Branch 1 not taken.
|
74 | if (value) { |
| 503 |
3/3✓ Branch 1 taken 74 times.
✓ Branch 4 taken 74 times.
✓ Branch 7 taken 74 times.
|
148 | result = openstudio::istringEqual(value.get(), "Autosize"); |
| 504 | } | ||
| 505 | 74 | return result; | |
| 506 | 74 | } | |
| 507 | |||
| 508 | 75 | double AirLoopHVACUnitarySystem_Impl::maximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation() const { | |
| 509 | boost::optional<double> value = | ||
| 510 |
1/1✓ Branch 1 taken 75 times.
|
75 | getDouble(OS_AirLoopHVAC_UnitarySystemFields::MaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation, true); |
| 511 |
1/3✗ Branch 1 not taken.
✓ Branch 2 taken 75 times.
✗ Branch 4 not taken.
|
75 | OS_ASSERT(value); |
| 512 |
1/1✓ Branch 1 taken 75 times.
|
150 | return value.get(); |
| 513 | } | ||
| 514 | |||
| 515 | ✗ | bool AirLoopHVACUnitarySystem_Impl::isMaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperationDefaulted() const { | |
| 516 | ✗ | return isEmpty(OS_AirLoopHVAC_UnitarySystemFields::MaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation); | |
| 517 | } | ||
| 518 | |||
| 519 | 73 | boost::optional<std::string> AirLoopHVACUnitarySystem_Impl::outdoorDryBulbTemperatureSensorNodeName() const { | |
| 520 | 73 | return getString(OS_AirLoopHVAC_UnitarySystemFields::OutdoorDryBulbTemperatureSensorNodeName, true); | |
| 521 | } | ||
| 522 | |||
| 523 | 75 | double AirLoopHVACUnitarySystem_Impl::ancilliaryOnCycleElectricPower() const { | |
| 524 |
1/1✓ Branch 1 taken 75 times.
|
75 | boost::optional<double> value = getDouble(OS_AirLoopHVAC_UnitarySystemFields::AncilliaryOnCycleElectricPower, true); |
| 525 |
1/3✗ Branch 1 not taken.
✓ Branch 2 taken 75 times.
✗ Branch 4 not taken.
|
75 | OS_ASSERT(value); |
| 526 |
1/1✓ Branch 1 taken 75 times.
|
150 | return value.get(); |
| 527 | } | ||
| 528 | |||
| 529 | ✗ | bool AirLoopHVACUnitarySystem_Impl::isAncilliaryOnCycleElectricPowerDefaulted() const { | |
| 530 | ✗ | return isEmpty(OS_AirLoopHVAC_UnitarySystemFields::AncilliaryOnCycleElectricPower); | |
| 531 | } | ||
| 532 | |||
| 533 | 75 | double AirLoopHVACUnitarySystem_Impl::ancilliaryOffCycleElectricPower() const { | |
| 534 |
1/1✓ Branch 1 taken 75 times.
|
75 | boost::optional<double> value = getDouble(OS_AirLoopHVAC_UnitarySystemFields::AncilliaryOffCycleElectricPower, true); |
| 535 |
1/3✗ Branch 1 not taken.
✓ Branch 2 taken 75 times.
✗ Branch 4 not taken.
|
75 | OS_ASSERT(value); |
| 536 |
1/1✓ Branch 1 taken 75 times.
|
150 | return value.get(); |
| 537 | } | ||
| 538 | |||
| 539 | ✗ | bool AirLoopHVACUnitarySystem_Impl::isAncilliaryOffCycleElectricPowerDefaulted() const { | |
| 540 | ✗ | return isEmpty(OS_AirLoopHVAC_UnitarySystemFields::AncilliaryOffCycleElectricPower); | |
| 541 | } | ||
| 542 | |||
| 543 | // double AirLoopHVACUnitarySystem_Impl::designHeatRecoveryWaterFlowRate() const { | ||
| 544 | // boost::optional<double> value = getDouble(OS_AirLoopHVAC_UnitarySystemFields::DesignHeatRecoveryWaterFlowRate,true); | ||
| 545 | // OS_ASSERT(value); | ||
| 546 | // return value.get(); | ||
| 547 | // } | ||
| 548 | |||
| 549 | // bool AirLoopHVACUnitarySystem_Impl::isDesignHeatRecoveryWaterFlowRateDefaulted() const { | ||
| 550 | // return isEmpty(OS_AirLoopHVAC_UnitarySystemFields::DesignHeatRecoveryWaterFlowRate); | ||
| 551 | // } | ||
| 552 | |||
| 553 | // double AirLoopHVACUnitarySystem_Impl::maximumTemperatureforHeatRecovery() const { | ||
| 554 | // boost::optional<double> value = getDouble(OS_AirLoopHVAC_UnitarySystemFields::MaximumTemperatureforHeatRecovery,true); | ||
| 555 | // OS_ASSERT(value); | ||
| 556 | // return value.get(); | ||
| 557 | // } | ||
| 558 | |||
| 559 | // bool AirLoopHVACUnitarySystem_Impl::isMaximumTemperatureforHeatRecoveryDefaulted() const { | ||
| 560 | // return isEmpty(OS_AirLoopHVAC_UnitarySystemFields::MaximumTemperatureforHeatRecovery); | ||
| 561 | // } | ||
| 562 | |||
| 563 | 163 | boost::optional<UnitarySystemPerformanceMultispeed> AirLoopHVACUnitarySystem_Impl::designSpecificationMultispeedObject() const { | |
| 564 |
1/1✓ Branch 1 taken 163 times.
|
326 | return getObject<ModelObject>().getModelObjectTarget<UnitarySystemPerformanceMultispeed>( |
| 565 |
1/1✓ Branch 1 taken 163 times.
|
326 | OS_AirLoopHVAC_UnitarySystemFields::DesignSpecificationMultispeedObjectName); |
| 566 | } | ||
| 567 | |||
| 568 | 100 | bool AirLoopHVACUnitarySystem_Impl::setControlType(const std::string& controlType) { | |
| 569 | 100 | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::ControlType, controlType); | |
| 570 | 100 | return result; | |
| 571 | } | ||
| 572 | |||
| 573 | 1 | void AirLoopHVACUnitarySystem_Impl::resetControlType() { | |
| 574 |
2/2✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
|
2 | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::ControlType, ""); |
| 575 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
|
1 | OS_ASSERT(result); |
| 576 | 1 | } | |
| 577 | |||
| 578 | ✗ | bool AirLoopHVACUnitarySystem_Impl::setControllingZoneorThermostatLocation(const ThermalZone& thermalZone) { | |
| 579 | ✗ | const bool result = setPointer(OS_AirLoopHVAC_UnitarySystemFields::ControllingZoneorThermostatLocation, thermalZone.handle()); | |
| 580 | ✗ | return result; | |
| 581 | } | ||
| 582 | |||
| 583 | ✗ | void AirLoopHVACUnitarySystem_Impl::resetControllingZoneorThermostatLocation() { | |
| 584 | ✗ | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::ControllingZoneorThermostatLocation, ""); | |
| 585 | ✗ | OS_ASSERT(result); | |
| 586 | ✗ | } | |
| 587 | |||
| 588 | 98 | bool AirLoopHVACUnitarySystem_Impl::setDehumidificationControlType(const std::string& dehumidificationControlType) { | |
| 589 | 98 | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::DehumidificationControlType, dehumidificationControlType); | |
| 590 | 98 | return result; | |
| 591 | } | ||
| 592 | |||
| 593 | ✗ | void AirLoopHVACUnitarySystem_Impl::resetDehumidificationControlType() { | |
| 594 | ✗ | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::DehumidificationControlType, ""); | |
| 595 | ✗ | OS_ASSERT(result); | |
| 596 | ✗ | } | |
| 597 | |||
| 598 | ✗ | bool AirLoopHVACUnitarySystem_Impl::setAvailabilitySchedule(Schedule& schedule) { | |
| 599 | const bool result = | ||
| 600 | ✗ | setSchedule(OS_AirLoopHVAC_UnitarySystemFields::AvailabilityScheduleName, "AirLoopHVACUnitarySystem", "Availability", schedule); | |
| 601 | ✗ | return result; | |
| 602 | } | ||
| 603 | |||
| 604 | ✗ | void AirLoopHVACUnitarySystem_Impl::resetAvailabilitySchedule() { | |
| 605 | ✗ | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::AvailabilityScheduleName, ""); | |
| 606 | ✗ | OS_ASSERT(result); | |
| 607 | ✗ | } | |
| 608 | |||
| 609 | 44 | bool AirLoopHVACUnitarySystem_Impl::setSupplyFan(const HVACComponent& supplyFan) { | |
| 610 |
2/2✓ Branch 1 taken 44 times.
✓ Branch 4 taken 44 times.
|
44 | const bool result = setPointer(OS_AirLoopHVAC_UnitarySystemFields::SupplyFanName, supplyFan.handle()); |
| 611 | 44 | return result; | |
| 612 | } | ||
| 613 | |||
| 614 | ✗ | void AirLoopHVACUnitarySystem_Impl::resetSupplyFan() { | |
| 615 | ✗ | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyFanName, ""); | |
| 616 | ✗ | OS_ASSERT(result); | |
| 617 | ✗ | } | |
| 618 | |||
| 619 | 31 | bool AirLoopHVACUnitarySystem_Impl::setFanPlacement(const std::string& fanPlacement) { | |
| 620 | 31 | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::FanPlacement, fanPlacement); | |
| 621 | 31 | return result; | |
| 622 | } | ||
| 623 | |||
| 624 | ✗ | void AirLoopHVACUnitarySystem_Impl::resetFanPlacement() { | |
| 625 | ✗ | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::FanPlacement, ""); | |
| 626 | ✗ | OS_ASSERT(result); | |
| 627 | ✗ | } | |
| 628 | |||
| 629 | ✗ | bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFanOperatingModeSchedule(Schedule& schedule) { | |
| 630 | ✗ | const bool result = setSchedule(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFanOperatingModeScheduleName, "AirLoopHVACUnitarySystem", | |
| 631 | "Supply Air Fan Operating Mode", schedule); | ||
| 632 | ✗ | return result; | |
| 633 | } | ||
| 634 | |||
| 635 | ✗ | void AirLoopHVACUnitarySystem_Impl::resetSupplyAirFanOperatingModeSchedule() { | |
| 636 | ✗ | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFanOperatingModeScheduleName, ""); | |
| 637 | ✗ | OS_ASSERT(result); | |
| 638 | ✗ | } | |
| 639 | |||
| 640 | 59 | bool AirLoopHVACUnitarySystem_Impl::setHeatingCoil(const HVACComponent& heatingCoil) { | |
| 641 |
2/2✓ Branch 1 taken 59 times.
✓ Branch 4 taken 59 times.
|
59 | const bool result = setPointer(OS_AirLoopHVAC_UnitarySystemFields::HeatingCoilName, heatingCoil.handle()); |
| 642 |
5/5✓ Branch 1 taken 59 times.
✓ Branch 4 taken 59 times.
✓ Branch 7 taken 59 times.
✓ Branch 11 taken 47 times.
✓ Branch 12 taken 12 times.
|
177 | if (openstudio::istringEqual("None", supplyAirFlowRateMethodDuringHeatingOperation())) { |
| 643 | 47 | autosizeSupplyAirFlowRateDuringHeatingOperation(); | |
| 644 |
3/5✓ Branch 1 taken 47 times.
✓ Branch 4 taken 47 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 47 times.
✗ Branch 9 not taken.
|
94 | OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("SupplyAirFlowRate")); |
| 645 | } | ||
| 646 | 59 | return result; | |
| 647 | } | ||
| 648 | |||
| 649 | 2 | void AirLoopHVACUnitarySystem_Impl::resetHeatingCoil() { | |
| 650 |
2/2✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
|
4 | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::HeatingCoilName, ""); |
| 651 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | OS_ASSERT(result); |
| 652 |
3/5✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 2 times.
✗ Branch 9 not taken.
|
2 | OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("None")); |
| 653 | 2 | resetSupplyAirFlowRateDuringHeatingOperation(); | |
| 654 | 2 | resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation(); | |
| 655 | 2 | resetFractionofAutosizedDesignHeatingSupplyAirFlowRate(); | |
| 656 | 2 | resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(); | |
| 657 |
2/2✓ Branch 1 taken 1 time.
✓ Branch 2 taken 1 time.
|
2 | if (!hasCoolingCoil()) { |
| 658 |
2/2✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
|
1 | setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired("None"); |
| 659 | 1 | resetSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | |
| 660 | 1 | resetSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired(); | |
| 661 | 1 | resetFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | |
| 662 | 1 | resetFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | |
| 663 | 1 | resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired(); | |
| 664 | 1 | resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired(); | |
| 665 | } | ||
| 666 | 2 | } | |
| 667 | |||
| 668 | 98 | bool AirLoopHVACUnitarySystem_Impl::setDXHeatingCoilSizingRatio(double dXHeatingCoilSizingRatio) { | |
| 669 | 98 | const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::DXHeatingCoilSizingRatio, dXHeatingCoilSizingRatio); | |
| 670 | 98 | return result; | |
| 671 | } | ||
| 672 | |||
| 673 | ✗ | void AirLoopHVACUnitarySystem_Impl::resetDXHeatingCoilSizingRatio() { | |
| 674 | ✗ | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::DXHeatingCoilSizingRatio, ""); | |
| 675 | ✗ | OS_ASSERT(result); | |
| 676 | ✗ | } | |
| 677 | |||
| 678 | 73 | bool AirLoopHVACUnitarySystem_Impl::setCoolingCoil(const HVACComponent& coolingCoil) { | |
| 679 |
2/2✓ Branch 1 taken 73 times.
✓ Branch 4 taken 73 times.
|
73 | const bool result = setPointer(OS_AirLoopHVAC_UnitarySystemFields::CoolingCoilName, coolingCoil.handle()); |
| 680 |
5/5✓ Branch 1 taken 73 times.
✓ Branch 4 taken 73 times.
✓ Branch 7 taken 73 times.
✓ Branch 11 taken 59 times.
✓ Branch 12 taken 14 times.
|
219 | if (openstudio::istringEqual("None", supplyAirFlowRateMethodDuringCoolingOperation())) { |
| 681 | 59 | autosizeSupplyAirFlowRateDuringCoolingOperation(); | |
| 682 |
3/5✓ Branch 1 taken 59 times.
✓ Branch 4 taken 59 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 59 times.
✗ Branch 9 not taken.
|
118 | OS_ASSERT(setSupplyAirFlowRateMethodDuringCoolingOperation("SupplyAirFlowRate")); |
| 683 | } | ||
| 684 | 73 | return result; | |
| 685 | } | ||
| 686 | |||
| 687 | 2 | void AirLoopHVACUnitarySystem_Impl::resetCoolingCoil() { | |
| 688 |
2/2✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
|
4 | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::CoolingCoilName, ""); |
| 689 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | OS_ASSERT(result); |
| 690 |
3/5✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 2 times.
✗ Branch 9 not taken.
|
2 | OS_ASSERT(setSupplyAirFlowRateMethodDuringCoolingOperation("None")); |
| 691 | 2 | resetSupplyAirFlowRateDuringCoolingOperation(); | |
| 692 | 2 | resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(); | |
| 693 | 2 | resetFractionofAutosizedDesignCoolingSupplyAirFlowRate(); | |
| 694 | 2 | resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(); | |
| 695 |
1/2✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
|
2 | if (!hasHeatingCoil()) { |
| 696 |
2/2✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
|
2 | setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired("None"); |
| 697 | 2 | resetSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | |
| 698 | 2 | resetSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired(); | |
| 699 | 2 | resetFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | |
| 700 | 2 | resetFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | |
| 701 | 2 | resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired(); | |
| 702 | 2 | resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired(); | |
| 703 | } | ||
| 704 | 2 | } | |
| 705 | |||
| 706 | 98 | bool AirLoopHVACUnitarySystem_Impl::setUseDOASDXCoolingCoil(bool useDOASDXCoolingCoil) { | |
| 707 | 98 | return setBooleanFieldValue(OS_AirLoopHVAC_UnitarySystemFields::UseDOASDXCoolingCoil, useDOASDXCoolingCoil); | |
| 708 | } | ||
| 709 | |||
| 710 | ✗ | void AirLoopHVACUnitarySystem_Impl::resetUseDOASDXCoolingCoil() { | |
| 711 | ✗ | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::UseDOASDXCoolingCoil, ""); | |
| 712 | ✗ | OS_ASSERT(result); | |
| 713 | ✗ | } | |
| 714 | |||
| 715 | 98 | bool AirLoopHVACUnitarySystem_Impl::setDOASDXCoolingCoilLeavingMinimumAirTemperature(double dOASDXCoolingCoilLeavingMinimumAirTemperature) { | |
| 716 | const bool result = | ||
| 717 | 98 | setDouble(OS_AirLoopHVAC_UnitarySystemFields::DOASDXCoolingCoilLeavingMinimumAirTemperature, dOASDXCoolingCoilLeavingMinimumAirTemperature); | |
| 718 | 98 | return result; | |
| 719 | } | ||
| 720 | |||
| 721 | 1 | void AirLoopHVACUnitarySystem_Impl::resetDOASDXCoolingCoilLeavingMinimumAirTemperature() { | |
| 722 |
2/2✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
|
2 | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::DOASDXCoolingCoilLeavingMinimumAirTemperature, ""); |
| 723 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
|
1 | OS_ASSERT(result); |
| 724 | 1 | } | |
| 725 | |||
| 726 | 1 | void AirLoopHVACUnitarySystem_Impl::autosizeDOASDXCoolingCoilLeavingMinimumAirTemperature() { | |
| 727 |
2/2✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
|
2 | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::DOASDXCoolingCoilLeavingMinimumAirTemperature, "Autosize"); |
| 728 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
|
1 | OS_ASSERT(result); |
| 729 | 1 | } | |
| 730 | |||
| 731 | 98 | bool AirLoopHVACUnitarySystem_Impl::setLatentLoadControl(const std::string& latentLoadControl) { | |
| 732 | 98 | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::LatentLoadControl, latentLoadControl); | |
| 733 | 98 | return result; | |
| 734 | } | ||
| 735 | |||
| 736 | ✗ | void AirLoopHVACUnitarySystem_Impl::resetLatentLoadControl() { | |
| 737 | ✗ | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::LatentLoadControl, ""); | |
| 738 | ✗ | OS_ASSERT(result); | |
| 739 | ✗ | } | |
| 740 | |||
| 741 | 39 | bool AirLoopHVACUnitarySystem_Impl::setSupplementalHeatingCoil(const HVACComponent& supplementalHeatingCoil) { | |
| 742 |
2/2✓ Branch 1 taken 39 times.
✓ Branch 4 taken 39 times.
|
39 | const bool result = setPointer(OS_AirLoopHVAC_UnitarySystemFields::SupplementalHeatingCoilName, supplementalHeatingCoil.handle()); |
| 743 | 39 | return result; | |
| 744 | } | ||
| 745 | |||
| 746 | ✗ | void AirLoopHVACUnitarySystem_Impl::resetSupplementalHeatingCoil() { | |
| 747 | ✗ | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplementalHeatingCoilName, ""); | |
| 748 | ✗ | OS_ASSERT(result); | |
| 749 | ✗ | } | |
| 750 | |||
| 751 | 226 | bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRateMethodDuringCoolingOperation( | |
| 752 | const std::string& supplyAirFlowRateMethodDuringCoolingOperation) { | ||
| 753 | const bool result = | ||
| 754 | 226 | setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringCoolingOperation, supplyAirFlowRateMethodDuringCoolingOperation); | |
| 755 | 226 | return result; | |
| 756 | } | ||
| 757 | |||
| 758 | 5 | bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRateDuringCoolingOperation(double supplyAirFlowRateDuringCoolingOperation) { | |
| 759 | const bool result = | ||
| 760 | 5 | setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringCoolingOperation, supplyAirFlowRateDuringCoolingOperation); | |
| 761 |
3/5✓ Branch 1 taken 5 times.
✓ Branch 4 taken 5 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 5 times.
✗ Branch 9 not taken.
|
5 | OS_ASSERT(setSupplyAirFlowRateMethodDuringCoolingOperation("SupplyAirFlowRate")); |
| 762 | // resetSupplyAirFlowRateDuringCoolingOperation(); | ||
| 763 | 5 | resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(); | |
| 764 | 5 | resetFractionofAutosizedDesignCoolingSupplyAirFlowRate(); | |
| 765 | 5 | resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(); | |
| 766 | 5 | return result; | |
| 767 | } | ||
| 768 | |||
| 769 | 5 | void AirLoopHVACUnitarySystem_Impl::resetSupplyAirFlowRateDuringCoolingOperation() { | |
| 770 |
2/2✓ Branch 1 taken 5 times.
✓ Branch 4 taken 5 times.
|
10 | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringCoolingOperation, ""); |
| 771 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
|
5 | OS_ASSERT(result); |
| 772 | 5 | } | |
| 773 | |||
| 774 | 60 | void AirLoopHVACUnitarySystem_Impl::autosizeSupplyAirFlowRateDuringCoolingOperation() { | |
| 775 |
2/2✓ Branch 1 taken 60 times.
✓ Branch 4 taken 60 times.
|
120 | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringCoolingOperation, "Autosize"); |
| 776 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 60 times.
|
60 | OS_ASSERT(result); |
| 777 |
3/5✓ Branch 1 taken 60 times.
✓ Branch 4 taken 60 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 60 times.
✗ Branch 9 not taken.
|
60 | OS_ASSERT(setSupplyAirFlowRateMethodDuringCoolingOperation("SupplyAirFlowRate")); |
| 778 | // resetSupplyAirFlowRateDuringCoolingOperation(); | ||
| 779 | 60 | resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(); | |
| 780 | 60 | resetFractionofAutosizedDesignCoolingSupplyAirFlowRate(); | |
| 781 | 60 | resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(); | |
| 782 | 60 | } | |
| 783 | |||
| 784 | 1 | bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation( | |
| 785 | double supplyAirFlowRatePerFloorAreaDuringCoolingOperation) { | ||
| 786 | 1 | const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaDuringCoolingOperation, | |
| 787 | supplyAirFlowRatePerFloorAreaDuringCoolingOperation); | ||
| 788 |
3/5✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✗ Branch 6 not taken.
✓ Branch 7 taken 1 time.
✗ Branch 9 not taken.
|
1 | OS_ASSERT(setSupplyAirFlowRateMethodDuringCoolingOperation("FlowPerFloorArea")); |
| 789 | 1 | resetSupplyAirFlowRateDuringCoolingOperation(); | |
| 790 | // resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(); | ||
| 791 | 1 | resetFractionofAutosizedDesignCoolingSupplyAirFlowRate(); | |
| 792 | 1 | resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(); | |
| 793 | 1 | return result; | |
| 794 | } | ||
| 795 | |||
| 796 | 69 | void AirLoopHVACUnitarySystem_Impl::resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation() { | |
| 797 |
2/2✓ Branch 1 taken 69 times.
✓ Branch 4 taken 69 times.
|
138 | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaDuringCoolingOperation, ""); |
| 798 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 69 times.
|
69 | OS_ASSERT(result); |
| 799 | 69 | } | |
| 800 | |||
| 801 | bool | ||
| 802 | 1 | AirLoopHVACUnitarySystem_Impl::setFractionofAutosizedDesignCoolingSupplyAirFlowRate(double fractionofAutosizedDesignCoolingSupplyAirFlowRate) { | |
| 803 | 1 | const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignCoolingSupplyAirFlowRate, | |
| 804 | fractionofAutosizedDesignCoolingSupplyAirFlowRate); | ||
| 805 |
3/5✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✗ Branch 6 not taken.
✓ Branch 7 taken 1 time.
✗ Branch 9 not taken.
|
1 | OS_ASSERT(setSupplyAirFlowRateMethodDuringCoolingOperation("FractionOfAutosizedCoolingValue")); |
| 806 | 1 | resetSupplyAirFlowRateDuringCoolingOperation(); | |
| 807 | 1 | resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(); | |
| 808 | // resetFractionofAutosizedDesignCoolingSupplyAirFlowRate(); | ||
| 809 | 1 | resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(); | |
| 810 | 1 | return result; | |
| 811 | } | ||
| 812 | |||
| 813 | 69 | void AirLoopHVACUnitarySystem_Impl::resetFractionofAutosizedDesignCoolingSupplyAirFlowRate() { | |
| 814 |
2/2✓ Branch 1 taken 69 times.
✓ Branch 4 taken 69 times.
|
138 | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignCoolingSupplyAirFlowRate, ""); |
| 815 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 69 times.
|
69 | OS_ASSERT(result); |
| 816 | 69 | } | |
| 817 | |||
| 818 | 1 | bool AirLoopHVACUnitarySystem_Impl::setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation( | |
| 819 | double designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation) { | ||
| 820 | 1 | const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation, | |
| 821 | designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation); | ||
| 822 |
3/5✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✗ Branch 6 not taken.
✓ Branch 7 taken 1 time.
✗ Branch 9 not taken.
|
1 | OS_ASSERT(setSupplyAirFlowRateMethodDuringCoolingOperation("FlowPerCoolingCapacity")); |
| 823 | 1 | resetSupplyAirFlowRateDuringCoolingOperation(); | |
| 824 | 1 | resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(); | |
| 825 | 1 | resetFractionofAutosizedDesignCoolingSupplyAirFlowRate(); | |
| 826 | // resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(); | ||
| 827 | 1 | return result; | |
| 828 | } | ||
| 829 | |||
| 830 | 69 | void AirLoopHVACUnitarySystem_Impl::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation() { | |
| 831 |
2/2✓ Branch 1 taken 69 times.
✓ Branch 4 taken 69 times.
|
138 | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation, ""); |
| 832 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 69 times.
|
69 | OS_ASSERT(result); |
| 833 | 69 | } | |
| 834 | |||
| 835 | 202 | bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRateMethodDuringHeatingOperation( | |
| 836 | const std::string& supplyAirFlowRateMethodDuringHeatingOperation) { | ||
| 837 | const bool result = | ||
| 838 | 202 | setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringHeatingOperation, supplyAirFlowRateMethodDuringHeatingOperation); | |
| 839 | 202 | return result; | |
| 840 | } | ||
| 841 | |||
| 842 | 5 | bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRateDuringHeatingOperation(double supplyAirFlowRateDuringHeatingOperation) { | |
| 843 | const bool result = | ||
| 844 | 5 | setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringHeatingOperation, supplyAirFlowRateDuringHeatingOperation); | |
| 845 |
3/5✓ Branch 1 taken 5 times.
✓ Branch 4 taken 5 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 5 times.
✗ Branch 9 not taken.
|
5 | OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("SupplyAirFlowRate")); |
| 846 | // resetSupplyAirFlowRateDuringHeatingOperation(); | ||
| 847 | 5 | resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation(); | |
| 848 | 5 | resetFractionofAutosizedDesignHeatingSupplyAirFlowRate(); | |
| 849 | 5 | resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(); | |
| 850 | 5 | return result; | |
| 851 | } | ||
| 852 | |||
| 853 | 5 | void AirLoopHVACUnitarySystem_Impl::resetSupplyAirFlowRateDuringHeatingOperation() { | |
| 854 |
2/2✓ Branch 1 taken 5 times.
✓ Branch 4 taken 5 times.
|
10 | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringHeatingOperation, ""); |
| 855 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
|
5 | OS_ASSERT(result); |
| 856 | 5 | } | |
| 857 | |||
| 858 | 48 | void AirLoopHVACUnitarySystem_Impl::autosizeSupplyAirFlowRateDuringHeatingOperation() { | |
| 859 |
2/2✓ Branch 1 taken 48 times.
✓ Branch 4 taken 48 times.
|
96 | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringHeatingOperation, "Autosize"); |
| 860 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 48 times.
|
48 | OS_ASSERT(result); |
| 861 |
3/5✓ Branch 1 taken 48 times.
✓ Branch 4 taken 48 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 48 times.
✗ Branch 9 not taken.
|
48 | OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("SupplyAirFlowRate")); |
| 862 | // resetSupplyAirFlowRateDuringHeatingOperation(); | ||
| 863 | 48 | resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation(); | |
| 864 | 48 | resetFractionofAutosizedDesignHeatingSupplyAirFlowRate(); | |
| 865 | 48 | resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(); | |
| 866 | 48 | } | |
| 867 | |||
| 868 | 1 | bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRatePerFloorAreaduringHeatingOperation( | |
| 869 | double supplyAirFlowRatePerFloorAreaDuringHeatingOperation) { | ||
| 870 | 1 | const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaduringHeatingOperation, | |
| 871 | supplyAirFlowRatePerFloorAreaDuringHeatingOperation); | ||
| 872 |
3/5✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✗ Branch 6 not taken.
✓ Branch 7 taken 1 time.
✗ Branch 9 not taken.
|
1 | OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("FlowPerFloorArea")); |
| 873 | 1 | resetSupplyAirFlowRateDuringHeatingOperation(); | |
| 874 | // resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation(); | ||
| 875 | 1 | resetFractionofAutosizedDesignHeatingSupplyAirFlowRate(); | |
| 876 | 1 | resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(); | |
| 877 | 1 | return result; | |
| 878 | } | ||
| 879 | |||
| 880 | 57 | void AirLoopHVACUnitarySystem_Impl::resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation() { | |
| 881 |
2/2✓ Branch 1 taken 57 times.
✓ Branch 4 taken 57 times.
|
114 | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaduringHeatingOperation, ""); |
| 882 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 57 times.
|
57 | OS_ASSERT(result); |
| 883 | 57 | } | |
| 884 | |||
| 885 | bool | ||
| 886 | 1 | AirLoopHVACUnitarySystem_Impl::setFractionofAutosizedDesignHeatingSupplyAirFlowRate(double fractionofAutosizedDesignHeatingSupplyAirFlowRate) { | |
| 887 | 1 | const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignHeatingSupplyAirFlowRate, | |
| 888 | fractionofAutosizedDesignHeatingSupplyAirFlowRate); | ||
| 889 |
3/5✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✗ Branch 6 not taken.
✓ Branch 7 taken 1 time.
✗ Branch 9 not taken.
|
1 | OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("FractionOfAutosizedHeatingValue")); |
| 890 | 1 | resetSupplyAirFlowRateDuringHeatingOperation(); | |
| 891 | 1 | resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation(); | |
| 892 | // resetFractionofAutosizedDesignHeatingSupplyAirFlowRate(); | ||
| 893 | 1 | resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(); | |
| 894 | 1 | return result; | |
| 895 | } | ||
| 896 | |||
| 897 | 57 | void AirLoopHVACUnitarySystem_Impl::resetFractionofAutosizedDesignHeatingSupplyAirFlowRate() { | |
| 898 |
2/2✓ Branch 1 taken 57 times.
✓ Branch 4 taken 57 times.
|
114 | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignHeatingSupplyAirFlowRate, ""); |
| 899 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 57 times.
|
57 | OS_ASSERT(result); |
| 900 | 57 | } | |
| 901 | |||
| 902 | 1 | bool AirLoopHVACUnitarySystem_Impl::setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation( | |
| 903 | double designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation) { | ||
| 904 | 1 | const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation, | |
| 905 | designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation); | ||
| 906 |
3/5✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✗ Branch 6 not taken.
✓ Branch 7 taken 1 time.
✗ Branch 9 not taken.
|
1 | OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("FlowPerHeatingCapacity")); |
| 907 | 1 | resetSupplyAirFlowRateDuringHeatingOperation(); | |
| 908 | 1 | resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation(); | |
| 909 | 1 | resetFractionofAutosizedDesignHeatingSupplyAirFlowRate(); | |
| 910 | // resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(); | ||
| 911 | 1 | return result; | |
| 912 | } | ||
| 913 | |||
| 914 | 57 | void AirLoopHVACUnitarySystem_Impl::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation() { | |
| 915 |
2/2✓ Branch 1 taken 57 times.
✓ Branch 4 taken 57 times.
|
114 | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation, ""); |
| 916 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 57 times.
|
57 | OS_ASSERT(result); |
| 917 | 57 | } | |
| 918 | |||
| 919 | 110 | bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired( | |
| 920 | const std::string& supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired) { | ||
| 921 | 110 | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired, | |
| 922 | supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired); | ||
| 923 | 110 | return result; | |
| 924 | } | ||
| 925 | |||
| 926 | 1 | void AirLoopHVACUnitarySystem_Impl::resetSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired() { | |
| 927 |
2/2✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
|
2 | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired, "None"); |
| 928 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
|
1 | OS_ASSERT(result); |
| 929 | 1 | resetSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | |
| 930 | 1 | resetSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired(); | |
| 931 | 1 | resetFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | |
| 932 | 1 | resetFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | |
| 933 | 1 | resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired(); | |
| 934 | 1 | resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired(); | |
| 935 | 1 | } | |
| 936 | |||
| 937 | bool | ||
| 938 | 1 | AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(double supplyAirFlowRateWhenNoCoolingorHeatingisRequired) { | |
| 939 | 1 | const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateWhenNoCoolingorHeatingisRequired, | |
| 940 | supplyAirFlowRateWhenNoCoolingorHeatingisRequired); | ||
| 941 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
|
1 | if (!result) { |
| 942 | ✗ | return false; | |
| 943 | } | ||
| 944 | |||
| 945 |
3/5✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✗ Branch 6 not taken.
✓ Branch 7 taken 1 time.
✗ Branch 9 not taken.
|
1 | OS_ASSERT(setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired("SupplyAirFlowRate")); |
| 946 | // resetSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | ||
| 947 | 1 | resetSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired(); | |
| 948 | 1 | resetFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | |
| 949 | 1 | resetFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | |
| 950 | 1 | resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired(); | |
| 951 | 1 | resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired(); | |
| 952 | |||
| 953 | 1 | return true; | |
| 954 | } | ||
| 955 | |||
| 956 | 10 | void AirLoopHVACUnitarySystem_Impl::resetSupplyAirFlowRateWhenNoCoolingorHeatingisRequired() { | |
| 957 |
2/2✓ Branch 1 taken 10 times.
✓ Branch 4 taken 10 times.
|
20 | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateWhenNoCoolingorHeatingisRequired, ""); |
| 958 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
|
10 | OS_ASSERT(result); |
| 959 | 10 | } | |
| 960 | |||
| 961 | 3 | void AirLoopHVACUnitarySystem_Impl::autosizeSupplyAirFlowRateWhenNoCoolingorHeatingisRequired() { | |
| 962 |
2/2✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
|
6 | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateWhenNoCoolingorHeatingisRequired, "Autosize"); |
| 963 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
|
3 | OS_ASSERT(result); |
| 964 |
3/5✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 3 times.
✗ Branch 9 not taken.
|
3 | OS_ASSERT(setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired("SupplyAirFlowRate")); |
| 965 | // resetSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | ||
| 966 | 3 | resetSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired(); | |
| 967 | 3 | resetFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | |
| 968 | 3 | resetFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | |
| 969 | 3 | resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired(); | |
| 970 | 3 | resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired(); | |
| 971 | 3 | } | |
| 972 | |||
| 973 | 1 | bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired( | |
| 974 | double supplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired) { | ||
| 975 | 1 | const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired, | |
| 976 | supplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired); | ||
| 977 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
|
1 | if (!result) { |
| 978 | ✗ | return false; | |
| 979 | } | ||
| 980 | |||
| 981 |
3/5✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✗ Branch 6 not taken.
✓ Branch 7 taken 1 time.
✗ Branch 9 not taken.
|
1 | OS_ASSERT(setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired("FlowPerFloorArea")); |
| 982 | 1 | resetSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | |
| 983 | // resetSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired(); | ||
| 984 | 1 | resetFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | |
| 985 | 1 | resetFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | |
| 986 | 1 | resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired(); | |
| 987 | 1 | resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired(); | |
| 988 | |||
| 989 | 1 | return true; | |
| 990 | } | ||
| 991 | |||
| 992 | 13 | void AirLoopHVACUnitarySystem_Impl::resetSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired() { | |
| 993 |
2/2✓ Branch 1 taken 13 times.
✓ Branch 4 taken 13 times.
|
26 | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired, ""); |
| 994 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
|
13 | OS_ASSERT(result); |
| 995 | 13 | } | |
| 996 | |||
| 997 | 1 | bool AirLoopHVACUnitarySystem_Impl::setFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired( | |
| 998 | double fractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired) { | ||
| 999 | const bool result = | ||
| 1000 | 1 | setDouble(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired, | |
| 1001 | fractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired); | ||
| 1002 | |||
| 1003 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
|
1 | if (!result) { |
| 1004 | ✗ | return false; | |
| 1005 | } | ||
| 1006 | |||
| 1007 |
3/5✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✗ Branch 6 not taken.
✓ Branch 7 taken 1 time.
✗ Branch 9 not taken.
|
1 | OS_ASSERT(setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired("FractionOfAutosizedCoolingValue")); |
| 1008 | 1 | resetSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | |
| 1009 | 1 | resetSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired(); | |
| 1010 | // resetFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | ||
| 1011 | 1 | resetFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | |
| 1012 | 1 | resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired(); | |
| 1013 | 1 | resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired(); | |
| 1014 | |||
| 1015 | 1 | return true; | |
| 1016 | } | ||
| 1017 | |||
| 1018 | 13 | void AirLoopHVACUnitarySystem_Impl::resetFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired() { | |
| 1019 | const bool result = | ||
| 1020 |
2/2✓ Branch 1 taken 13 times.
✓ Branch 4 taken 13 times.
|
26 | setString(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired, ""); |
| 1021 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
|
13 | OS_ASSERT(result); |
| 1022 | 13 | } | |
| 1023 | |||
| 1024 | 1 | bool AirLoopHVACUnitarySystem_Impl::setFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired( | |
| 1025 | double fractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired) { | ||
| 1026 | const bool result = | ||
| 1027 | 1 | setDouble(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired, | |
| 1028 | fractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired); | ||
| 1029 | |||
| 1030 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
|
1 | if (!result) { |
| 1031 | ✗ | return false; | |
| 1032 | } | ||
| 1033 | |||
| 1034 |
3/5✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✗ Branch 6 not taken.
✓ Branch 7 taken 1 time.
✗ Branch 9 not taken.
|
1 | OS_ASSERT(setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired("FractionOfAutosizedHeatingValue")); |
| 1035 | 1 | resetSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | |
| 1036 | 1 | resetSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired(); | |
| 1037 | 1 | resetFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | |
| 1038 | // resetFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | ||
| 1039 | 1 | resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired(); | |
| 1040 | 1 | resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired(); | |
| 1041 | |||
| 1042 | 1 | return true; | |
| 1043 | } | ||
| 1044 | |||
| 1045 | 13 | void AirLoopHVACUnitarySystem_Impl::resetFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired() { | |
| 1046 | const bool result = | ||
| 1047 |
2/2✓ Branch 1 taken 13 times.
✓ Branch 4 taken 13 times.
|
26 | setString(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired, ""); |
| 1048 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
|
13 | OS_ASSERT(result); |
| 1049 | 13 | } | |
| 1050 | |||
| 1051 | 1 | bool AirLoopHVACUnitarySystem_Impl::setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired( | |
| 1052 | double designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired) { | ||
| 1053 | const bool result = | ||
| 1054 | 1 | setDouble(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired, | |
| 1055 | designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired); | ||
| 1056 | |||
| 1057 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
|
1 | if (!result) { |
| 1058 | ✗ | return false; | |
| 1059 | } | ||
| 1060 | |||
| 1061 |
3/5✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✗ Branch 6 not taken.
✓ Branch 7 taken 1 time.
✗ Branch 9 not taken.
|
1 | OS_ASSERT(setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired("FlowPerCoolingCapacity")); |
| 1062 | 1 | resetSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | |
| 1063 | 1 | resetSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired(); | |
| 1064 | 1 | resetFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | |
| 1065 | 1 | resetFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | |
| 1066 | // resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired(); | ||
| 1067 | 1 | resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired(); | |
| 1068 | |||
| 1069 | 1 | return true; | |
| 1070 | } | ||
| 1071 | |||
| 1072 | 13 | void AirLoopHVACUnitarySystem_Impl::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired() { | |
| 1073 |
2/2✓ Branch 1 taken 13 times.
✓ Branch 4 taken 13 times.
|
26 | const bool result = setString( |
| 1074 | |||
| 1075 | OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired, ""); | ||
| 1076 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
|
13 | OS_ASSERT(result); |
| 1077 | 13 | } | |
| 1078 | |||
| 1079 | 2 | bool AirLoopHVACUnitarySystem_Impl::setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired( | |
| 1080 | double designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired) { | ||
| 1081 | const bool result = | ||
| 1082 | 2 | setDouble(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired, | |
| 1083 | designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired); | ||
| 1084 | |||
| 1085 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (!result) { |
| 1086 | ✗ | return false; | |
| 1087 | } | ||
| 1088 | |||
| 1089 |
3/5✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 2 times.
✗ Branch 9 not taken.
|
2 | OS_ASSERT(setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired("FlowPerHeatingCapacity")); |
| 1090 | 2 | resetSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | |
| 1091 | 2 | resetSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired(); | |
| 1092 | 2 | resetFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | |
| 1093 | 2 | resetFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | |
| 1094 | 2 | resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired(); | |
| 1095 | // resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired(); | ||
| 1096 | |||
| 1097 | 2 | return true; | |
| 1098 | } | ||
| 1099 | |||
| 1100 | 12 | void AirLoopHVACUnitarySystem_Impl::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired() { | |
| 1101 |
2/2✓ Branch 1 taken 12 times.
✓ Branch 4 taken 12 times.
|
24 | const bool result = setString( |
| 1102 | OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired, ""); | ||
| 1103 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | OS_ASSERT(result); |
| 1104 | 12 | } | |
| 1105 | |||
| 1106 | 98 | bool AirLoopHVACUnitarySystem_Impl::setNoLoadSupplyAirFlowRateControlSetToLowSpeed(bool noLoadSupplyAirFlowRateControlSetToLowSpeed) { | |
| 1107 | 98 | return setBooleanFieldValue(OS_AirLoopHVAC_UnitarySystemFields::NoLoadSupplyAirFlowRateControlSetToLowSpeed, | |
| 1108 | 98 | noLoadSupplyAirFlowRateControlSetToLowSpeed); | |
| 1109 | } | ||
| 1110 | |||
| 1111 | 97 | bool AirLoopHVACUnitarySystem_Impl::setMaximumSupplyAirTemperature(double maximumSupplyAirTemperature) { | |
| 1112 | 97 | const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::MaximumSupplyAirTemperature, maximumSupplyAirTemperature); | |
| 1113 | 97 | return result; | |
| 1114 | } | ||
| 1115 | |||
| 1116 | ✗ | void AirLoopHVACUnitarySystem_Impl::resetMaximumSupplyAirTemperature() { | |
| 1117 | ✗ | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::MaximumSupplyAirTemperature, ""); | |
| 1118 | ✗ | OS_ASSERT(result); | |
| 1119 | ✗ | } | |
| 1120 | |||
| 1121 | 1 | void AirLoopHVACUnitarySystem_Impl::autosizeMaximumSupplyAirTemperature() { | |
| 1122 |
2/2✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
|
2 | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::MaximumSupplyAirTemperature, "Autosize"); |
| 1123 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
|
1 | OS_ASSERT(result); |
| 1124 | 1 | } | |
| 1125 | |||
| 1126 | 98 | bool AirLoopHVACUnitarySystem_Impl::setMaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation( | |
| 1127 | double maximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation) { | ||
| 1128 | 98 | const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::MaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation, | |
| 1129 | maximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation); | ||
| 1130 | 98 | return result; | |
| 1131 | } | ||
| 1132 | |||
| 1133 | ✗ | void AirLoopHVACUnitarySystem_Impl::resetMaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation() { | |
| 1134 | ✗ | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::MaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation, ""); | |
| 1135 | ✗ | OS_ASSERT(result); | |
| 1136 | ✗ | } | |
| 1137 | |||
| 1138 | ✗ | bool AirLoopHVACUnitarySystem_Impl::setOutdoorDryBulbTemperatureSensorNodeName(const std::string& outdoorDryBulbTemperatureSensorNodeName) { | |
| 1139 | const bool result = | ||
| 1140 | ✗ | setString(OS_AirLoopHVAC_UnitarySystemFields::OutdoorDryBulbTemperatureSensorNodeName, outdoorDryBulbTemperatureSensorNodeName); | |
| 1141 | ✗ | OS_ASSERT(result); | |
| 1142 | ✗ | return result; | |
| 1143 | } | ||
| 1144 | |||
| 1145 | ✗ | void AirLoopHVACUnitarySystem_Impl::resetOutdoorDryBulbTemperatureSensorNodeName() { | |
| 1146 | ✗ | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::OutdoorDryBulbTemperatureSensorNodeName, ""); | |
| 1147 | ✗ | OS_ASSERT(result); | |
| 1148 | ✗ | } | |
| 1149 | |||
| 1150 | 98 | bool AirLoopHVACUnitarySystem_Impl::setAncilliaryOnCycleElectricPower(double ancilliaryOnCycleElectricPower) { | |
| 1151 | 98 | const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::AncilliaryOnCycleElectricPower, ancilliaryOnCycleElectricPower); | |
| 1152 | 98 | return result; | |
| 1153 | } | ||
| 1154 | |||
| 1155 | ✗ | void AirLoopHVACUnitarySystem_Impl::resetAncilliaryOnCycleElectricPower() { | |
| 1156 | ✗ | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::AncilliaryOnCycleElectricPower, ""); | |
| 1157 | ✗ | OS_ASSERT(result); | |
| 1158 | ✗ | } | |
| 1159 | |||
| 1160 | 98 | bool AirLoopHVACUnitarySystem_Impl::setAncilliaryOffCycleElectricPower(double ancilliaryOffCycleElectricPower) { | |
| 1161 | 98 | const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::AncilliaryOffCycleElectricPower, ancilliaryOffCycleElectricPower); | |
| 1162 | 98 | return result; | |
| 1163 | } | ||
| 1164 | |||
| 1165 | ✗ | void AirLoopHVACUnitarySystem_Impl::resetAncilliaryOffCycleElectricPower() { | |
| 1166 | ✗ | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::AncilliaryOffCycleElectricPower, ""); | |
| 1167 | ✗ | OS_ASSERT(result); | |
| 1168 | ✗ | } | |
| 1169 | |||
| 1170 | // bool AirLoopHVACUnitarySystem_Impl::setDesignHeatRecoveryWaterFlowRate(double designHeatRecoveryWaterFlowRate) { | ||
| 1171 | // const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::DesignHeatRecoveryWaterFlowRate, designHeatRecoveryWaterFlowRate); | ||
| 1172 | // return result; | ||
| 1173 | // } | ||
| 1174 | |||
| 1175 | // void AirLoopHVACUnitarySystem_Impl::resetDesignHeatRecoveryWaterFlowRate() { | ||
| 1176 | // const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::DesignHeatRecoveryWaterFlowRate, ""); | ||
| 1177 | // OS_ASSERT(result); | ||
| 1178 | // } | ||
| 1179 | |||
| 1180 | // bool AirLoopHVACUnitarySystem_Impl::setMaximumTemperatureforHeatRecovery(double maximumTemperatureforHeatRecovery) { | ||
| 1181 | // const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::MaximumTemperatureforHeatRecovery, maximumTemperatureforHeatRecovery); | ||
| 1182 | // return result; | ||
| 1183 | // } | ||
| 1184 | |||
| 1185 | // void AirLoopHVACUnitarySystem_Impl::resetMaximumTemperatureforHeatRecovery() { | ||
| 1186 | // const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::MaximumTemperatureforHeatRecovery, ""); | ||
| 1187 | // OS_ASSERT(result); | ||
| 1188 | // } | ||
| 1189 | |||
| 1190 | 12 | bool AirLoopHVACUnitarySystem_Impl::setDesignSpecificationMultispeedObject(const UnitarySystemPerformanceMultispeed& unitarySystemPerformace) { | |
| 1191 |
2/2✓ Branch 1 taken 12 times.
✓ Branch 4 taken 12 times.
|
12 | const bool result = setPointer(OS_AirLoopHVAC_UnitarySystemFields::DesignSpecificationMultispeedObjectName, unitarySystemPerformace.handle()); |
| 1192 | 12 | return result; | |
| 1193 | } | ||
| 1194 | |||
| 1195 | 1 | void AirLoopHVACUnitarySystem_Impl::resetDesignSpecificationMultispeedObject() { | |
| 1196 |
2/2✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
|
2 | const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::DesignSpecificationMultispeedObjectName, ""); |
| 1197 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
|
1 | OS_ASSERT(result); |
| 1198 | 1 | } | |
| 1199 | |||
| 1200 | ✗ | boost::optional<double> AirLoopHVACUnitarySystem_Impl::autosizedSupplyAirFlowRateDuringCoolingOperation() const { | |
| 1201 | ✗ | return getAutosizedValue("Design Size Cooling Supply Air Flow Rate", "m3/s"); | |
| 1202 | } | ||
| 1203 | |||
| 1204 | ✗ | boost::optional<double> AirLoopHVACUnitarySystem_Impl::autosizedSupplyAirFlowRateDuringHeatingOperation() const { | |
| 1205 | ✗ | return getAutosizedValue("Design Size Heating Supply Air Flow Rate", "m3/s"); | |
| 1206 | } | ||
| 1207 | |||
| 1208 | ✗ | boost::optional<double> AirLoopHVACUnitarySystem_Impl::autosizedSupplyAirFlowRateWhenNoCoolingorHeatingisRequired() const { | |
| 1209 | ✗ | return getAutosizedValue("Design Size No Load Supply Air Flow Rate", "m3/s"); | |
| 1210 | } | ||
| 1211 | |||
| 1212 | ✗ | boost::optional<double> AirLoopHVACUnitarySystem_Impl::autosizedMaximumSupplyAirTemperature() const { | |
| 1213 | ✗ | return getAutosizedValue("Design Size Maximum Supply Air Temperature", "C"); | |
| 1214 | } | ||
| 1215 | |||
| 1216 | ✗ | boost::optional<double> AirLoopHVACUnitarySystem_Impl::autosizedDOASDXCoolingCoilLeavingMinimumAirTemperature() const { | |
| 1217 | ✗ | return getAutosizedValue("Design Size Minimum Supply Air Temperature", "C"); | |
| 1218 | } | ||
| 1219 | |||
| 1220 | ✗ | void AirLoopHVACUnitarySystem_Impl::autosize() { | |
| 1221 | ✗ | autosizeSupplyAirFlowRateDuringCoolingOperation(); | |
| 1222 | ✗ | autosizeSupplyAirFlowRateDuringHeatingOperation(); | |
| 1223 | ✗ | autosizeSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | |
| 1224 | ✗ | autosizeMaximumSupplyAirTemperature(); | |
| 1225 | ✗ | } | |
| 1226 | |||
| 1227 | ✗ | void AirLoopHVACUnitarySystem_Impl::applySizingValues() { | |
| 1228 | ✗ | boost::optional<double> val; | |
| 1229 | ✗ | val = autosizedSupplyAirFlowRateDuringCoolingOperation(); | |
| 1230 | ✗ | if (val) { | |
| 1231 | ✗ | setSupplyAirFlowRateDuringCoolingOperation(val.get()); | |
| 1232 | } | ||
| 1233 | |||
| 1234 | ✗ | val = autosizedSupplyAirFlowRateDuringHeatingOperation(); | |
| 1235 | ✗ | if (val) { | |
| 1236 | ✗ | setSupplyAirFlowRateDuringHeatingOperation(val.get()); | |
| 1237 | } | ||
| 1238 | |||
| 1239 | ✗ | val = autosizedSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | |
| 1240 | ✗ | if (val) { | |
| 1241 | ✗ | setSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(val.get()); | |
| 1242 | } | ||
| 1243 | |||
| 1244 | ✗ | val = autosizedMaximumSupplyAirTemperature(); | |
| 1245 | ✗ | if (val) { | |
| 1246 | ✗ | setMaximumSupplyAirTemperature(val.get()); | |
| 1247 | } | ||
| 1248 | ✗ | } | |
| 1249 | |||
| 1250 | ✗ | std::vector<EMSActuatorNames> AirLoopHVACUnitarySystem_Impl::emsActuatorNames() const { | |
| 1251 | std::vector<EMSActuatorNames> actuators{{"AirLoopHVAC:UnitarySystem", "Autosized Supply Air Flow Rate"}, | ||
| 1252 | {"AirLoopHVAC:UnitarySystem", "Autosized Supply Air Flow Rate During Cooling Operation"}, | ||
| 1253 | {"AirLoopHVAC:UnitarySystem", "Autosized Supply Air Flow Rate During Heating Operation"}, | ||
| 1254 | {"AirLoopHVAC:UnitarySystem", "Autosized Supply Air Flow Rate During No Heating or Cooling Operation"}, | ||
| 1255 | {"Unitary HVAC", "Sensible Load Request"}, | ||
| 1256 | ✗ | {"Unitary HVAC", "Moisture Load Request"}}; | |
| 1257 | ✗ | return actuators; | |
| 1258 | ✗ | } | |
| 1259 | |||
| 1260 | ✗ | std::vector<std::string> AirLoopHVACUnitarySystem_Impl::emsInternalVariableNames() const { | |
| 1261 | std::vector<std::string> types{"Unitary System Control Zone Mass Flow Fraction", "Unitary HVAC Design Heating Capacity", | ||
| 1262 | ✗ | "Unitary HVAC Design Cooling Capacity"}; | |
| 1263 | ✗ | return types; | |
| 1264 | ✗ | } | |
| 1265 | |||
| 1266 | ✗ | ComponentType AirLoopHVACUnitarySystem_Impl::componentType() const { | |
| 1267 | ✗ | const bool has_cooling = coolingCoil().is_initialized(); | |
| 1268 | ✗ | const bool has_heating = heatingCoil().is_initialized(); | |
| 1269 | |||
| 1270 | ✗ | if (has_cooling && has_heating) { | |
| 1271 | ✗ | return ComponentType::Both; | |
| 1272 | ✗ | } else if (has_cooling) { | |
| 1273 | ✗ | return ComponentType::Cooling; | |
| 1274 | ✗ | } else if (has_heating) { | |
| 1275 | ✗ | return ComponentType::Heating; | |
| 1276 | } | ||
| 1277 | ✗ | return ComponentType::None; | |
| 1278 | } | ||
| 1279 | |||
| 1280 | ✗ | std::vector<FuelType> AirLoopHVACUnitarySystem_Impl::coolingFuelTypes() const { | |
| 1281 | ✗ | std::set<FuelType> result; | |
| 1282 | ✗ | if (auto cc_ = coolingCoil()) { | |
| 1283 | ✗ | for (auto ft : cc_->coolingFuelTypes()) { | |
| 1284 | ✗ | result.insert(ft); | |
| 1285 | ✗ | } | |
| 1286 | ✗ | } | |
| 1287 | |||
| 1288 | ✗ | return {result.begin(), result.end()}; | |
| 1289 | ✗ | } | |
| 1290 | |||
| 1291 | ✗ | std::vector<FuelType> AirLoopHVACUnitarySystem_Impl::heatingFuelTypes() const { | |
| 1292 | ✗ | std::set<FuelType> result; | |
| 1293 | ✗ | if (auto hc_ = heatingCoil()) { | |
| 1294 | ✗ | for (auto ft : hc_->heatingFuelTypes()) { | |
| 1295 | ✗ | result.insert(ft); | |
| 1296 | ✗ | } | |
| 1297 | ✗ | } | |
| 1298 | ✗ | if (auto supHC_ = supplementalHeatingCoil()) { | |
| 1299 | ✗ | for (auto ft : supHC_->heatingFuelTypes()) { | |
| 1300 | ✗ | result.insert(ft); | |
| 1301 | ✗ | } | |
| 1302 | ✗ | } | |
| 1303 | |||
| 1304 | ✗ | return {result.begin(), result.end()}; | |
| 1305 | ✗ | } | |
| 1306 | |||
| 1307 | ✗ | std::vector<AppGFuelType> AirLoopHVACUnitarySystem_Impl::appGHeatingFuelTypes() const { | |
| 1308 | ✗ | std::set<AppGFuelType> result; | |
| 1309 | ✗ | if (auto hc_ = heatingCoil()) { | |
| 1310 | ✗ | for (auto ft : hc_->appGHeatingFuelTypes()) { | |
| 1311 | ✗ | result.insert(ft); | |
| 1312 | ✗ | } | |
| 1313 | ✗ | } | |
| 1314 | ✗ | if (auto supHC_ = supplementalHeatingCoil()) { | |
| 1315 | ✗ | for (auto ft : supHC_->appGHeatingFuelTypes()) { | |
| 1316 | ✗ | result.insert(ft); | |
| 1317 | ✗ | } | |
| 1318 | ✗ | } | |
| 1319 | ✗ | return {result.begin(), result.end()}; | |
| 1320 | ✗ | } | |
| 1321 | |||
| 1322 | } // namespace detail | ||
| 1323 | |||
| 1324 | 97 | AirLoopHVACUnitarySystem::AirLoopHVACUnitarySystem(const Model& model) : ZoneHVACComponent(AirLoopHVACUnitarySystem::iddObjectType(), model) { | |
| 1325 |
1/3✗ Branch 2 not taken.
✓ Branch 3 taken 97 times.
✗ Branch 5 not taken.
|
97 | OS_ASSERT(getImpl<detail::AirLoopHVACUnitarySystem_Impl>()); |
| 1326 | |||
| 1327 | 97 | bool ok = true; | |
| 1328 |
2/2✓ Branch 3 taken 97 times.
✓ Branch 6 taken 97 times.
|
291 | ok = getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setControlType("Load"); |
| 1329 |
1/3✗ Branch 0 not taken.
✓ Branch 1 taken 97 times.
✗ Branch 3 not taken.
|
97 | OS_ASSERT(ok); |
| 1330 |
2/2✓ Branch 1 taken 97 times.
✓ Branch 4 taken 97 times.
|
97 | ok = setDehumidificationControlType("None"); |
| 1331 |
1/3✗ Branch 0 not taken.
✓ Branch 1 taken 97 times.
✗ Branch 3 not taken.
|
97 | OS_ASSERT(ok); |
| 1332 |
1/1✓ Branch 1 taken 97 times.
|
97 | ok = setDXHeatingCoilSizingRatio(1.0); |
| 1333 |
1/3✗ Branch 0 not taken.
✓ Branch 1 taken 97 times.
✗ Branch 3 not taken.
|
97 | OS_ASSERT(ok); |
| 1334 |
1/1✓ Branch 1 taken 97 times.
|
97 | setUseDOASDXCoolingCoil(false); |
| 1335 |
1/1✓ Branch 1 taken 97 times.
|
97 | ok = setDOASDXCoolingCoilLeavingMinimumAirTemperature(2.0); |
| 1336 |
1/3✗ Branch 0 not taken.
✓ Branch 1 taken 97 times.
✗ Branch 3 not taken.
|
97 | OS_ASSERT(ok); |
| 1337 |
2/2✓ Branch 1 taken 97 times.
✓ Branch 4 taken 97 times.
|
97 | ok = setLatentLoadControl("SensibleOnlyLoadControl"); |
| 1338 |
1/3✗ Branch 0 not taken.
✓ Branch 1 taken 97 times.
✗ Branch 3 not taken.
|
97 | OS_ASSERT(ok); |
| 1339 |
2/2✓ Branch 3 taken 97 times.
✓ Branch 6 taken 97 times.
|
291 | getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplyAirFlowRateMethodDuringCoolingOperation("None"); |
| 1340 |
2/2✓ Branch 3 taken 97 times.
✓ Branch 6 taken 97 times.
|
291 | getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplyAirFlowRateMethodDuringHeatingOperation("None"); |
| 1341 |
2/2✓ Branch 3 taken 97 times.
✓ Branch 6 taken 97 times.
|
291 | getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired("None"); |
| 1342 |
1/1✓ Branch 1 taken 97 times.
|
97 | setNoLoadSupplyAirFlowRateControlSetToLowSpeed(true); |
| 1343 |
1/1✓ Branch 1 taken 97 times.
|
97 | setMaximumSupplyAirTemperature(80.0); |
| 1344 |
1/1✓ Branch 1 taken 97 times.
|
97 | setMaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation(21.0); |
| 1345 |
1/1✓ Branch 1 taken 97 times.
|
97 | ok = setAncilliaryOnCycleElectricPower(0.0); |
| 1346 |
1/3✗ Branch 0 not taken.
✓ Branch 1 taken 97 times.
✗ Branch 3 not taken.
|
97 | OS_ASSERT(ok); |
| 1347 |
1/1✓ Branch 1 taken 97 times.
|
97 | ok = setAncilliaryOffCycleElectricPower(0.0); |
| 1348 |
1/3✗ Branch 0 not taken.
✓ Branch 1 taken 97 times.
✗ Branch 3 not taken.
|
97 | OS_ASSERT(ok); |
| 1349 | // ok = setMaximumTemperatureforHeatRecovery(80.0); | ||
| 1350 | // OS_ASSERT(ok); | ||
| 1351 | 97 | } | |
| 1352 | |||
| 1353 | 8785 | IddObjectType AirLoopHVACUnitarySystem::iddObjectType() { | |
| 1354 |
1/1✓ Branch 1 taken 8785 times.
|
8785 | return {IddObjectType::OS_AirLoopHVAC_UnitarySystem}; |
| 1355 | } | ||
| 1356 | |||
| 1357 | ✗ | std::vector<std::string> AirLoopHVACUnitarySystem::controlTypeValues() { | |
| 1358 | ✗ | return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_AirLoopHVAC_UnitarySystemFields::ControlType); | |
| 1359 | } | ||
| 1360 | |||
| 1361 | ✗ | std::vector<std::string> AirLoopHVACUnitarySystem::dehumidificationControlTypeValues() { | |
| 1362 | ✗ | return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_AirLoopHVAC_UnitarySystemFields::DehumidificationControlType); | |
| 1363 | } | ||
| 1364 | |||
| 1365 | ✗ | std::vector<std::string> AirLoopHVACUnitarySystem::fanPlacementValues() { | |
| 1366 | ✗ | return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_AirLoopHVAC_UnitarySystemFields::FanPlacement); | |
| 1367 | } | ||
| 1368 | |||
| 1369 | ✗ | std::vector<std::string> AirLoopHVACUnitarySystem::latentLoadControlValues() { | |
| 1370 | ✗ | return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_AirLoopHVAC_UnitarySystemFields::LatentLoadControl); | |
| 1371 | } | ||
| 1372 | |||
| 1373 | ✗ | std::vector<std::string> AirLoopHVACUnitarySystem::supplyAirFlowRateMethodDuringCoolingOperationValues() { | |
| 1374 | ✗ | return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), | |
| 1375 | ✗ | OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringCoolingOperation); | |
| 1376 | } | ||
| 1377 | |||
| 1378 | ✗ | std::vector<std::string> AirLoopHVACUnitarySystem::supplyAirFlowRateMethodDuringHeatingOperationValues() { | |
| 1379 | ✗ | return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), | |
| 1380 | ✗ | OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringHeatingOperation); | |
| 1381 | } | ||
| 1382 | |||
| 1383 | ✗ | std::vector<std::string> AirLoopHVACUnitarySystem::supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequiredValues() { | |
| 1384 | ✗ | return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), | |
| 1385 | ✗ | OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired); | |
| 1386 | } | ||
| 1387 | |||
| 1388 | 75 | std::string AirLoopHVACUnitarySystem::controlType() const { | |
| 1389 |
1/1✓ Branch 3 taken 75 times.
|
75 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->controlType(); |
| 1390 | } | ||
| 1391 | |||
| 1392 | 3 | bool AirLoopHVACUnitarySystem::isControlTypeDefaulted() const { | |
| 1393 |
1/1✓ Branch 3 taken 3 times.
|
3 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isControlTypeDefaulted(); |
| 1394 | } | ||
| 1395 | |||
| 1396 | 73 | boost::optional<ThermalZone> AirLoopHVACUnitarySystem::controllingZoneorThermostatLocation() const { | |
| 1397 |
1/1✓ Branch 3 taken 73 times.
|
73 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->controllingZoneorThermostatLocation(); |
| 1398 | } | ||
| 1399 | |||
| 1400 | 75 | std::string AirLoopHVACUnitarySystem::dehumidificationControlType() const { | |
| 1401 |
1/1✓ Branch 3 taken 75 times.
|
75 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->dehumidificationControlType(); |
| 1402 | } | ||
| 1403 | |||
| 1404 | ✗ | bool AirLoopHVACUnitarySystem::isDehumidificationControlTypeDefaulted() const { | |
| 1405 | ✗ | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isDehumidificationControlTypeDefaulted(); | |
| 1406 | } | ||
| 1407 | |||
| 1408 | 73 | boost::optional<Schedule> AirLoopHVACUnitarySystem::availabilitySchedule() const { | |
| 1409 |
1/1✓ Branch 3 taken 73 times.
|
73 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->availabilitySchedule(); |
| 1410 | } | ||
| 1411 | |||
| 1412 | 86 | boost::optional<HVACComponent> AirLoopHVACUnitarySystem::supplyFan() const { | |
| 1413 |
1/1✓ Branch 3 taken 86 times.
|
86 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->supplyFan(); |
| 1414 | } | ||
| 1415 | |||
| 1416 | 74 | boost::optional<std::string> AirLoopHVACUnitarySystem::fanPlacement() const { | |
| 1417 |
1/1✓ Branch 3 taken 74 times.
|
74 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->fanPlacement(); |
| 1418 | } | ||
| 1419 | |||
| 1420 | 73 | boost::optional<Schedule> AirLoopHVACUnitarySystem::supplyAirFanOperatingModeSchedule() const { | |
| 1421 |
1/1✓ Branch 3 taken 73 times.
|
73 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->supplyAirFanOperatingModeSchedule(); |
| 1422 | } | ||
| 1423 | |||
| 1424 | 138 | boost::optional<HVACComponent> AirLoopHVACUnitarySystem::heatingCoil() const { | |
| 1425 |
1/1✓ Branch 3 taken 138 times.
|
138 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->heatingCoil(); |
| 1426 | } | ||
| 1427 | |||
| 1428 | 75 | double AirLoopHVACUnitarySystem::dXHeatingCoilSizingRatio() const { | |
| 1429 |
1/1✓ Branch 3 taken 75 times.
|
75 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->dXHeatingCoilSizingRatio(); |
| 1430 | } | ||
| 1431 | |||
| 1432 | ✗ | bool AirLoopHVACUnitarySystem::isDXHeatingCoilSizingRatioDefaulted() const { | |
| 1433 | ✗ | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isDXHeatingCoilSizingRatioDefaulted(); | |
| 1434 | } | ||
| 1435 | |||
| 1436 | 181 | boost::optional<HVACComponent> AirLoopHVACUnitarySystem::coolingCoil() const { | |
| 1437 |
1/1✓ Branch 3 taken 181 times.
|
181 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->coolingCoil(); |
| 1438 | } | ||
| 1439 | |||
| 1440 | 75 | bool AirLoopHVACUnitarySystem::useDOASDXCoolingCoil() const { | |
| 1441 |
1/1✓ Branch 3 taken 75 times.
|
75 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->useDOASDXCoolingCoil(); |
| 1442 | } | ||
| 1443 | |||
| 1444 | ✗ | bool AirLoopHVACUnitarySystem::isUseDOASDXCoolingCoilDefaulted() const { | |
| 1445 | ✗ | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isUseDOASDXCoolingCoilDefaulted(); | |
| 1446 | } | ||
| 1447 | |||
| 1448 | 75 | double AirLoopHVACUnitarySystem::dOASDXCoolingCoilLeavingMinimumAirTemperature() const { | |
| 1449 |
1/1✓ Branch 3 taken 75 times.
|
75 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->dOASDXCoolingCoilLeavingMinimumAirTemperature(); |
| 1450 | } | ||
| 1451 | |||
| 1452 | 3 | bool AirLoopHVACUnitarySystem::isDOASDXCoolingCoilLeavingMinimumAirTemperatureDefaulted() const { | |
| 1453 |
1/1✓ Branch 3 taken 3 times.
|
3 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isDOASDXCoolingCoilLeavingMinimumAirTemperatureDefaulted(); |
| 1454 | } | ||
| 1455 | |||
| 1456 | 76 | bool AirLoopHVACUnitarySystem::isDOASDXCoolingCoilLeavingMinimumAirTemperatureAutosized() const { | |
| 1457 |
1/1✓ Branch 3 taken 76 times.
|
76 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isDOASDXCoolingCoilLeavingMinimumAirTemperatureAutosized(); |
| 1458 | } | ||
| 1459 | |||
| 1460 | 75 | std::string AirLoopHVACUnitarySystem::latentLoadControl() const { | |
| 1461 |
1/1✓ Branch 3 taken 75 times.
|
75 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->latentLoadControl(); |
| 1462 | } | ||
| 1463 | |||
| 1464 | ✗ | bool AirLoopHVACUnitarySystem::isLatentLoadControlDefaulted() const { | |
| 1465 | ✗ | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isLatentLoadControlDefaulted(); | |
| 1466 | } | ||
| 1467 | |||
| 1468 | 91 | boost::optional<HVACComponent> AirLoopHVACUnitarySystem::supplementalHeatingCoil() const { | |
| 1469 |
1/1✓ Branch 3 taken 91 times.
|
91 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->supplementalHeatingCoil(); |
| 1470 | } | ||
| 1471 | |||
| 1472 | 58 | std::string AirLoopHVACUnitarySystem::supplyAirFlowRateMethodDuringCoolingOperation() const { | |
| 1473 |
1/1✓ Branch 3 taken 58 times.
|
58 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->supplyAirFlowRateMethodDuringCoolingOperation(); |
| 1474 | } | ||
| 1475 | |||
| 1476 | 21 | boost::optional<double> AirLoopHVACUnitarySystem::supplyAirFlowRateDuringCoolingOperation() const { | |
| 1477 |
1/1✓ Branch 3 taken 21 times.
|
21 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->supplyAirFlowRateDuringCoolingOperation(); |
| 1478 | } | ||
| 1479 | |||
| 1480 | 60 | bool AirLoopHVACUnitarySystem::isSupplyAirFlowRateDuringCoolingOperationAutosized() const { | |
| 1481 |
1/1✓ Branch 3 taken 60 times.
|
60 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isSupplyAirFlowRateDuringCoolingOperationAutosized(); |
| 1482 | } | ||
| 1483 | |||
| 1484 | 59 | boost::optional<double> AirLoopHVACUnitarySystem::supplyAirFlowRatePerFloorAreaDuringCoolingOperation() const { | |
| 1485 |
1/1✓ Branch 3 taken 59 times.
|
59 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->supplyAirFlowRatePerFloorAreaDuringCoolingOperation(); |
| 1486 | } | ||
| 1487 | |||
| 1488 | 59 | boost::optional<double> AirLoopHVACUnitarySystem::fractionofAutosizedDesignCoolingSupplyAirFlowRate() const { | |
| 1489 |
1/1✓ Branch 3 taken 59 times.
|
59 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->fractionofAutosizedDesignCoolingSupplyAirFlowRate(); |
| 1490 | } | ||
| 1491 | |||
| 1492 | 59 | boost::optional<double> AirLoopHVACUnitarySystem::designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation() const { | |
| 1493 |
1/1✓ Branch 3 taken 59 times.
|
59 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(); |
| 1494 | } | ||
| 1495 | |||
| 1496 | 43 | std::string AirLoopHVACUnitarySystem::supplyAirFlowRateMethodDuringHeatingOperation() const { | |
| 1497 |
1/1✓ Branch 3 taken 43 times.
|
43 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->supplyAirFlowRateMethodDuringHeatingOperation(); |
| 1498 | } | ||
| 1499 | |||
| 1500 | 21 | boost::optional<double> AirLoopHVACUnitarySystem::supplyAirFlowRateDuringHeatingOperation() const { | |
| 1501 |
1/1✓ Branch 3 taken 21 times.
|
21 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->supplyAirFlowRateDuringHeatingOperation(); |
| 1502 | } | ||
| 1503 | |||
| 1504 | 45 | bool AirLoopHVACUnitarySystem::isSupplyAirFlowRateDuringHeatingOperationAutosized() const { | |
| 1505 |
1/1✓ Branch 3 taken 45 times.
|
45 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isSupplyAirFlowRateDuringHeatingOperationAutosized(); |
| 1506 | } | ||
| 1507 | |||
| 1508 | 44 | boost::optional<double> AirLoopHVACUnitarySystem::supplyAirFlowRatePerFloorAreaduringHeatingOperation() const { | |
| 1509 |
1/1✓ Branch 3 taken 44 times.
|
44 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->supplyAirFlowRatePerFloorAreaduringHeatingOperation(); |
| 1510 | } | ||
| 1511 | |||
| 1512 | 44 | boost::optional<double> AirLoopHVACUnitarySystem::fractionofAutosizedDesignHeatingSupplyAirFlowRate() const { | |
| 1513 |
1/1✓ Branch 3 taken 44 times.
|
44 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->fractionofAutosizedDesignHeatingSupplyAirFlowRate(); |
| 1514 | } | ||
| 1515 | |||
| 1516 | 44 | boost::optional<double> AirLoopHVACUnitarySystem::designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation() const { | |
| 1517 |
1/1✓ Branch 3 taken 44 times.
|
44 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(); |
| 1518 | } | ||
| 1519 | |||
| 1520 | 85 | std::string AirLoopHVACUnitarySystem::supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired() const { | |
| 1521 |
1/1✓ Branch 3 taken 85 times.
|
85 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired(); |
| 1522 | } | ||
| 1523 | |||
| 1524 | 84 | boost::optional<double> AirLoopHVACUnitarySystem::supplyAirFlowRateWhenNoCoolingorHeatingisRequired() const { | |
| 1525 |
1/1✓ Branch 3 taken 84 times.
|
84 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->supplyAirFlowRateWhenNoCoolingorHeatingisRequired(); |
| 1526 | } | ||
| 1527 | |||
| 1528 | 85 | bool AirLoopHVACUnitarySystem::isSupplyAirFlowRateWhenNoCoolingorHeatingisRequiredAutosized() const { | |
| 1529 |
1/1✓ Branch 3 taken 85 times.
|
85 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isSupplyAirFlowRateWhenNoCoolingorHeatingisRequiredAutosized(); |
| 1530 | } | ||
| 1531 | |||
| 1532 | 84 | boost::optional<double> AirLoopHVACUnitarySystem::supplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired() const { | |
| 1533 |
1/1✓ Branch 3 taken 84 times.
|
84 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->supplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired(); |
| 1534 | } | ||
| 1535 | |||
| 1536 | 84 | boost::optional<double> AirLoopHVACUnitarySystem::fractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired() const { | |
| 1537 |
1/1✓ Branch 3 taken 84 times.
|
84 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->fractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); |
| 1538 | } | ||
| 1539 | |||
| 1540 | 84 | boost::optional<double> AirLoopHVACUnitarySystem::fractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired() const { | |
| 1541 |
1/1✓ Branch 3 taken 84 times.
|
84 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->fractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); |
| 1542 | } | ||
| 1543 | |||
| 1544 | boost::optional<double> | ||
| 1545 | 84 | AirLoopHVACUnitarySystem::designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired() const { | |
| 1546 | 168 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>() | |
| 1547 |
1/1✓ Branch 2 taken 84 times.
|
168 | ->designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired(); |
| 1548 | } | ||
| 1549 | |||
| 1550 | boost::optional<double> | ||
| 1551 | 84 | AirLoopHVACUnitarySystem::designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired() const { | |
| 1552 | 168 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>() | |
| 1553 |
1/1✓ Branch 2 taken 84 times.
|
168 | ->designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired(); |
| 1554 | } | ||
| 1555 | |||
| 1556 | 75 | bool AirLoopHVACUnitarySystem::noLoadSupplyAirFlowRateControlSetToLowSpeed() const { | |
| 1557 |
1/1✓ Branch 3 taken 75 times.
|
75 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->noLoadSupplyAirFlowRateControlSetToLowSpeed(); |
| 1558 | } | ||
| 1559 | |||
| 1560 | 74 | boost::optional<double> AirLoopHVACUnitarySystem::maximumSupplyAirTemperature() const { | |
| 1561 |
1/1✓ Branch 3 taken 74 times.
|
74 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->maximumSupplyAirTemperature(); |
| 1562 | } | ||
| 1563 | |||
| 1564 | ✗ | bool AirLoopHVACUnitarySystem::isMaximumSupplyAirTemperatureDefaulted() const { | |
| 1565 | ✗ | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isMaximumSupplyAirTemperatureDefaulted(); | |
| 1566 | } | ||
| 1567 | |||
| 1568 | 74 | bool AirLoopHVACUnitarySystem::isMaximumSupplyAirTemperatureAutosized() const { | |
| 1569 |
1/1✓ Branch 3 taken 74 times.
|
74 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isMaximumSupplyAirTemperatureAutosized(); |
| 1570 | } | ||
| 1571 | |||
| 1572 | 75 | double AirLoopHVACUnitarySystem::maximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation() const { | |
| 1573 |
1/1✓ Branch 3 taken 75 times.
|
75 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->maximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation(); |
| 1574 | } | ||
| 1575 | |||
| 1576 | ✗ | bool AirLoopHVACUnitarySystem::isMaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperationDefaulted() const { | |
| 1577 | ✗ | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isMaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperationDefaulted(); | |
| 1578 | } | ||
| 1579 | |||
| 1580 | 73 | boost::optional<std::string> AirLoopHVACUnitarySystem::outdoorDryBulbTemperatureSensorNodeName() const { | |
| 1581 |
1/1✓ Branch 3 taken 73 times.
|
73 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->outdoorDryBulbTemperatureSensorNodeName(); |
| 1582 | } | ||
| 1583 | |||
| 1584 | 75 | double AirLoopHVACUnitarySystem::ancilliaryOnCycleElectricPower() const { | |
| 1585 |
1/1✓ Branch 3 taken 75 times.
|
75 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->ancilliaryOnCycleElectricPower(); |
| 1586 | } | ||
| 1587 | |||
| 1588 | ✗ | bool AirLoopHVACUnitarySystem::isAncilliaryOnCycleElectricPowerDefaulted() const { | |
| 1589 | ✗ | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isAncilliaryOnCycleElectricPowerDefaulted(); | |
| 1590 | } | ||
| 1591 | |||
| 1592 | 75 | double AirLoopHVACUnitarySystem::ancilliaryOffCycleElectricPower() const { | |
| 1593 |
1/1✓ Branch 3 taken 75 times.
|
75 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->ancilliaryOffCycleElectricPower(); |
| 1594 | } | ||
| 1595 | |||
| 1596 | ✗ | bool AirLoopHVACUnitarySystem::isAncilliaryOffCycleElectricPowerDefaulted() const { | |
| 1597 | ✗ | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isAncilliaryOffCycleElectricPowerDefaulted(); | |
| 1598 | } | ||
| 1599 | |||
| 1600 | // TODO: @kbenne, why is this not exposed? | ||
| 1601 | // double AirLoopHVACUnitarySystem::designHeatRecoveryWaterFlowRate() const { | ||
| 1602 | // return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->designHeatRecoveryWaterFlowRate(); | ||
| 1603 | // } | ||
| 1604 | |||
| 1605 | // bool AirLoopHVACUnitarySystem::isDesignHeatRecoveryWaterFlowRateDefaulted() const { | ||
| 1606 | // return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isDesignHeatRecoveryWaterFlowRateDefaulted(); | ||
| 1607 | // } | ||
| 1608 | |||
| 1609 | // double AirLoopHVACUnitarySystem::maximumTemperatureforHeatRecovery() const { | ||
| 1610 | // return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->maximumTemperatureforHeatRecovery(); | ||
| 1611 | // } | ||
| 1612 | |||
| 1613 | // bool AirLoopHVACUnitarySystem::isMaximumTemperatureforHeatRecoveryDefaulted() const { | ||
| 1614 | // return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isMaximumTemperatureforHeatRecoveryDefaulted(); | ||
| 1615 | // } | ||
| 1616 | |||
| 1617 | 76 | boost::optional<UnitarySystemPerformanceMultispeed> AirLoopHVACUnitarySystem::designSpecificationMultispeedObject() const { | |
| 1618 |
1/1✓ Branch 3 taken 76 times.
|
76 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->designSpecificationMultispeedObject(); |
| 1619 | } | ||
| 1620 | |||
| 1621 | 3 | bool AirLoopHVACUnitarySystem::setControlType(const std::string& controlType) { | |
| 1622 |
1/1✓ Branch 3 taken 3 times.
|
3 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setControlType(controlType); |
| 1623 | } | ||
| 1624 | |||
| 1625 | 1 | void AirLoopHVACUnitarySystem::resetControlType() { | |
| 1626 |
1/1✓ Branch 3 taken 1 time.
|
1 | getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetControlType(); |
| 1627 | 1 | } | |
| 1628 | |||
| 1629 | ✗ | bool AirLoopHVACUnitarySystem::setControllingZoneorThermostatLocation(const ThermalZone& thermalZone) { | |
| 1630 | ✗ | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setControllingZoneorThermostatLocation(thermalZone); | |
| 1631 | } | ||
| 1632 | |||
| 1633 | ✗ | void AirLoopHVACUnitarySystem::resetControllingZoneorThermostatLocation() { | |
| 1634 | ✗ | getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetControllingZoneorThermostatLocation(); | |
| 1635 | ✗ | } | |
| 1636 | |||
| 1637 | 98 | bool AirLoopHVACUnitarySystem::setDehumidificationControlType(const std::string& dehumidificationControlType) { | |
| 1638 |
1/1✓ Branch 3 taken 98 times.
|
98 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setDehumidificationControlType(dehumidificationControlType); |
| 1639 | } | ||
| 1640 | |||
| 1641 | ✗ | void AirLoopHVACUnitarySystem::resetDehumidificationControlType() { | |
| 1642 | ✗ | getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetDehumidificationControlType(); | |
| 1643 | ✗ | } | |
| 1644 | |||
| 1645 | ✗ | bool AirLoopHVACUnitarySystem::setAvailabilitySchedule(Schedule& schedule) { | |
| 1646 | ✗ | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setAvailabilitySchedule(schedule); | |
| 1647 | } | ||
| 1648 | |||
| 1649 | ✗ | void AirLoopHVACUnitarySystem::resetAvailabilitySchedule() { | |
| 1650 | ✗ | getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetAvailabilitySchedule(); | |
| 1651 | ✗ | } | |
| 1652 | |||
| 1653 | 44 | bool AirLoopHVACUnitarySystem::setSupplyFan(const HVACComponent& supplyFan) { | |
| 1654 |
1/1✓ Branch 3 taken 44 times.
|
44 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplyFan(supplyFan); |
| 1655 | } | ||
| 1656 | |||
| 1657 | ✗ | void AirLoopHVACUnitarySystem::resetSupplyFan() { | |
| 1658 | ✗ | getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetSupplyFan(); | |
| 1659 | ✗ | } | |
| 1660 | |||
| 1661 | 31 | bool AirLoopHVACUnitarySystem::setFanPlacement(const std::string& fanPlacement) { | |
| 1662 |
1/1✓ Branch 3 taken 31 times.
|
31 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setFanPlacement(fanPlacement); |
| 1663 | } | ||
| 1664 | |||
| 1665 | ✗ | void AirLoopHVACUnitarySystem::resetFanPlacement() { | |
| 1666 | ✗ | getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetFanPlacement(); | |
| 1667 | ✗ | } | |
| 1668 | |||
| 1669 | ✗ | bool AirLoopHVACUnitarySystem::setSupplyAirFanOperatingModeSchedule(Schedule& schedule) { | |
| 1670 | ✗ | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplyAirFanOperatingModeSchedule(schedule); | |
| 1671 | } | ||
| 1672 | |||
| 1673 | ✗ | void AirLoopHVACUnitarySystem::resetSupplyAirFanOperatingModeSchedule() { | |
| 1674 | ✗ | getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetSupplyAirFanOperatingModeSchedule(); | |
| 1675 | ✗ | } | |
| 1676 | |||
| 1677 | 59 | bool AirLoopHVACUnitarySystem::setHeatingCoil(const HVACComponent& heatingCoil) { | |
| 1678 |
1/1✓ Branch 3 taken 59 times.
|
59 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setHeatingCoil(heatingCoil); |
| 1679 | } | ||
| 1680 | |||
| 1681 | 2 | void AirLoopHVACUnitarySystem::resetHeatingCoil() { | |
| 1682 |
1/1✓ Branch 3 taken 2 times.
|
2 | getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetHeatingCoil(); |
| 1683 | 2 | } | |
| 1684 | |||
| 1685 | 98 | bool AirLoopHVACUnitarySystem::setDXHeatingCoilSizingRatio(double dXHeatingCoilSizingRatio) { | |
| 1686 |
1/1✓ Branch 3 taken 98 times.
|
98 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setDXHeatingCoilSizingRatio(dXHeatingCoilSizingRatio); |
| 1687 | } | ||
| 1688 | |||
| 1689 | ✗ | void AirLoopHVACUnitarySystem::resetDXHeatingCoilSizingRatio() { | |
| 1690 | ✗ | getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetDXHeatingCoilSizingRatio(); | |
| 1691 | ✗ | } | |
| 1692 | |||
| 1693 | 73 | bool AirLoopHVACUnitarySystem::setCoolingCoil(const HVACComponent& coolingCoil) { | |
| 1694 |
1/1✓ Branch 3 taken 73 times.
|
73 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setCoolingCoil(coolingCoil); |
| 1695 | } | ||
| 1696 | |||
| 1697 | 2 | void AirLoopHVACUnitarySystem::resetCoolingCoil() { | |
| 1698 |
1/1✓ Branch 3 taken 2 times.
|
2 | getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetCoolingCoil(); |
| 1699 | 2 | } | |
| 1700 | |||
| 1701 | 98 | bool AirLoopHVACUnitarySystem::setUseDOASDXCoolingCoil(bool useDOASDXCoolingCoil) { | |
| 1702 |
1/1✓ Branch 3 taken 98 times.
|
98 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setUseDOASDXCoolingCoil(useDOASDXCoolingCoil); |
| 1703 | } | ||
| 1704 | |||
| 1705 | ✗ | void AirLoopHVACUnitarySystem::resetUseDOASDXCoolingCoil() { | |
| 1706 | ✗ | getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetUseDOASDXCoolingCoil(); | |
| 1707 | ✗ | } | |
| 1708 | |||
| 1709 | 98 | bool AirLoopHVACUnitarySystem::setDOASDXCoolingCoilLeavingMinimumAirTemperature(double dOASDXCoolingCoilLeavingMinimumAirTemperature) { | |
| 1710 |
1/1✓ Branch 3 taken 98 times.
|
196 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setDOASDXCoolingCoilLeavingMinimumAirTemperature( |
| 1711 | 196 | dOASDXCoolingCoilLeavingMinimumAirTemperature); | |
| 1712 | } | ||
| 1713 | |||
| 1714 | 1 | void AirLoopHVACUnitarySystem::resetDOASDXCoolingCoilLeavingMinimumAirTemperature() { | |
| 1715 |
1/1✓ Branch 3 taken 1 time.
|
1 | getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetDOASDXCoolingCoilLeavingMinimumAirTemperature(); |
| 1716 | 1 | } | |
| 1717 | |||
| 1718 | 1 | void AirLoopHVACUnitarySystem::autosizeDOASDXCoolingCoilLeavingMinimumAirTemperature() { | |
| 1719 |
1/1✓ Branch 3 taken 1 time.
|
1 | getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->autosizeDOASDXCoolingCoilLeavingMinimumAirTemperature(); |
| 1720 | 1 | } | |
| 1721 | |||
| 1722 | 98 | bool AirLoopHVACUnitarySystem::setLatentLoadControl(const std::string& latentLoadControl) { | |
| 1723 |
1/1✓ Branch 3 taken 98 times.
|
98 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setLatentLoadControl(latentLoadControl); |
| 1724 | } | ||
| 1725 | |||
| 1726 | ✗ | void AirLoopHVACUnitarySystem::resetLatentLoadControl() { | |
| 1727 | ✗ | getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetLatentLoadControl(); | |
| 1728 | ✗ | } | |
| 1729 | |||
| 1730 | 39 | bool AirLoopHVACUnitarySystem::setSupplementalHeatingCoil(const HVACComponent& supplementalHeatingCoil) { | |
| 1731 |
1/1✓ Branch 3 taken 39 times.
|
39 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplementalHeatingCoil(supplementalHeatingCoil); |
| 1732 | } | ||
| 1733 | |||
| 1734 | ✗ | void AirLoopHVACUnitarySystem::resetSupplementalHeatingCoil() { | |
| 1735 | ✗ | getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetSupplementalHeatingCoil(); | |
| 1736 | ✗ | } | |
| 1737 | |||
| 1738 | 5 | bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateDuringCoolingOperation(double supplyAirFlowRateDuringCoolingOperation) { | |
| 1739 |
1/1✓ Branch 3 taken 5 times.
|
5 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplyAirFlowRateDuringCoolingOperation(supplyAirFlowRateDuringCoolingOperation); |
| 1740 | } | ||
| 1741 | |||
| 1742 | 1 | void AirLoopHVACUnitarySystem::autosizeSupplyAirFlowRateDuringCoolingOperation() { | |
| 1743 |
1/1✓ Branch 3 taken 1 time.
|
1 | getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->autosizeSupplyAirFlowRateDuringCoolingOperation(); |
| 1744 | 1 | } | |
| 1745 | |||
| 1746 | 1 | bool AirLoopHVACUnitarySystem::setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(double supplyAirFlowRatePerFloorAreaDuringCoolingOperation) { | |
| 1747 |
1/1✓ Branch 3 taken 1 time.
|
2 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation( |
| 1748 | 2 | supplyAirFlowRatePerFloorAreaDuringCoolingOperation); | |
| 1749 | } | ||
| 1750 | |||
| 1751 | 1 | bool AirLoopHVACUnitarySystem::setFractionofAutosizedDesignCoolingSupplyAirFlowRate(double fractionofAutosizedDesignCoolingSupplyAirFlowRate) { | |
| 1752 |
1/1✓ Branch 3 taken 1 time.
|
2 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setFractionofAutosizedDesignCoolingSupplyAirFlowRate( |
| 1753 | 2 | fractionofAutosizedDesignCoolingSupplyAirFlowRate); | |
| 1754 | } | ||
| 1755 | |||
| 1756 | 1 | bool AirLoopHVACUnitarySystem::setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation( | |
| 1757 | double designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation) { | ||
| 1758 |
1/1✓ Branch 3 taken 1 time.
|
2 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation( |
| 1759 | 2 | designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation); | |
| 1760 | } | ||
| 1761 | |||
| 1762 | 5 | bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateDuringHeatingOperation(double supplyAirFlowRateDuringHeatingOperation) { | |
| 1763 |
1/1✓ Branch 3 taken 5 times.
|
5 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplyAirFlowRateDuringHeatingOperation(supplyAirFlowRateDuringHeatingOperation); |
| 1764 | } | ||
| 1765 | |||
| 1766 | 1 | void AirLoopHVACUnitarySystem::autosizeSupplyAirFlowRateDuringHeatingOperation() { | |
| 1767 |
1/1✓ Branch 3 taken 1 time.
|
1 | getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->autosizeSupplyAirFlowRateDuringHeatingOperation(); |
| 1768 | 1 | } | |
| 1769 | |||
| 1770 | 1 | bool AirLoopHVACUnitarySystem::setSupplyAirFlowRatePerFloorAreaduringHeatingOperation(double supplyAirFlowRatePerFloorAreaduringHeatingOperation) { | |
| 1771 |
1/1✓ Branch 3 taken 1 time.
|
2 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplyAirFlowRatePerFloorAreaduringHeatingOperation( |
| 1772 | 2 | supplyAirFlowRatePerFloorAreaduringHeatingOperation); | |
| 1773 | } | ||
| 1774 | |||
| 1775 | 1 | bool AirLoopHVACUnitarySystem::setFractionofAutosizedDesignHeatingSupplyAirFlowRate(double fractionofAutosizedDesignHeatingSupplyAirFlowRate) { | |
| 1776 |
1/1✓ Branch 3 taken 1 time.
|
2 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setFractionofAutosizedDesignHeatingSupplyAirFlowRate( |
| 1777 | 2 | fractionofAutosizedDesignHeatingSupplyAirFlowRate); | |
| 1778 | } | ||
| 1779 | |||
| 1780 | 1 | bool AirLoopHVACUnitarySystem::setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation( | |
| 1781 | double designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation) { | ||
| 1782 |
1/1✓ Branch 3 taken 1 time.
|
2 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation( |
| 1783 | 2 | designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation); | |
| 1784 | } | ||
| 1785 | |||
| 1786 | 1 | void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired() { | |
| 1787 |
1/1✓ Branch 3 taken 1 time.
|
1 | getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired(); |
| 1788 | 1 | } | |
| 1789 | |||
| 1790 | 1 | bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(double supplyAirFlowRateWhenNoCoolingorHeatingisRequired) { | |
| 1791 |
1/1✓ Branch 3 taken 1 time.
|
2 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplyAirFlowRateWhenNoCoolingorHeatingisRequired( |
| 1792 | 2 | supplyAirFlowRateWhenNoCoolingorHeatingisRequired); | |
| 1793 | } | ||
| 1794 | |||
| 1795 | 3 | void AirLoopHVACUnitarySystem::autosizeSupplyAirFlowRateWhenNoCoolingorHeatingisRequired() { | |
| 1796 |
1/1✓ Branch 3 taken 3 times.
|
3 | getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->autosizeSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); |
| 1797 | 3 | } | |
| 1798 | |||
| 1799 | 1 | bool AirLoopHVACUnitarySystem::setSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired( | |
| 1800 | double supplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired) { | ||
| 1801 |
1/1✓ Branch 3 taken 1 time.
|
2 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired( |
| 1802 | 2 | supplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired); | |
| 1803 | } | ||
| 1804 | |||
| 1805 | 1 | bool AirLoopHVACUnitarySystem::setFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired( | |
| 1806 | double fractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired) { | ||
| 1807 |
1/1✓ Branch 3 taken 1 time.
|
2 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired( |
| 1808 | 2 | fractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired); | |
| 1809 | } | ||
| 1810 | |||
| 1811 | 1 | bool AirLoopHVACUnitarySystem::setFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired( | |
| 1812 | double fractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired) { | ||
| 1813 |
1/1✓ Branch 3 taken 1 time.
|
2 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired( |
| 1814 | 2 | fractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired); | |
| 1815 | } | ||
| 1816 | |||
| 1817 | 1 | bool AirLoopHVACUnitarySystem::setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired( | |
| 1818 | double designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired) { | ||
| 1819 | 2 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>() | |
| 1820 |
1/1✓ Branch 2 taken 1 time.
|
1 | ->setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired( |
| 1821 | 2 | designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired); | |
| 1822 | } | ||
| 1823 | |||
| 1824 | 2 | bool AirLoopHVACUnitarySystem::setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired( | |
| 1825 | double designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired) { | ||
| 1826 | 4 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>() | |
| 1827 |
1/1✓ Branch 2 taken 2 times.
|
2 | ->setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired( |
| 1828 | 4 | designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired); | |
| 1829 | } | ||
| 1830 | |||
| 1831 | 98 | bool AirLoopHVACUnitarySystem::setNoLoadSupplyAirFlowRateControlSetToLowSpeed(bool noLoadSupplyAirFlowRateControlSetToLowSpeed) { | |
| 1832 |
1/1✓ Branch 3 taken 98 times.
|
196 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setNoLoadSupplyAirFlowRateControlSetToLowSpeed( |
| 1833 | 196 | noLoadSupplyAirFlowRateControlSetToLowSpeed); | |
| 1834 | } | ||
| 1835 | |||
| 1836 | 97 | bool AirLoopHVACUnitarySystem::setMaximumSupplyAirTemperature(double maximumSupplyAirTemperature) { | |
| 1837 |
1/1✓ Branch 3 taken 97 times.
|
97 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setMaximumSupplyAirTemperature(maximumSupplyAirTemperature); |
| 1838 | } | ||
| 1839 | |||
| 1840 | ✗ | void AirLoopHVACUnitarySystem::resetMaximumSupplyAirTemperature() { | |
| 1841 | ✗ | getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetMaximumSupplyAirTemperature(); | |
| 1842 | ✗ | } | |
| 1843 | |||
| 1844 | 1 | void AirLoopHVACUnitarySystem::autosizeMaximumSupplyAirTemperature() { | |
| 1845 |
1/1✓ Branch 3 taken 1 time.
|
1 | getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->autosizeMaximumSupplyAirTemperature(); |
| 1846 | 1 | } | |
| 1847 | |||
| 1848 | 98 | bool AirLoopHVACUnitarySystem::setMaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation( | |
| 1849 | double maximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation) { | ||
| 1850 |
1/1✓ Branch 3 taken 98 times.
|
196 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setMaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation( |
| 1851 | 196 | maximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation); | |
| 1852 | } | ||
| 1853 | |||
| 1854 | ✗ | void AirLoopHVACUnitarySystem::resetMaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation() { | |
| 1855 | ✗ | getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetMaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation(); | |
| 1856 | ✗ | } | |
| 1857 | |||
| 1858 | ✗ | bool AirLoopHVACUnitarySystem::setOutdoorDryBulbTemperatureSensorNodeName(const std::string& outdoorDryBulbTemperatureSensorNodeName) { | |
| 1859 | ✗ | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setOutdoorDryBulbTemperatureSensorNodeName(outdoorDryBulbTemperatureSensorNodeName); | |
| 1860 | } | ||
| 1861 | |||
| 1862 | ✗ | void AirLoopHVACUnitarySystem::resetOutdoorDryBulbTemperatureSensorNodeName() { | |
| 1863 | ✗ | getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetOutdoorDryBulbTemperatureSensorNodeName(); | |
| 1864 | ✗ | } | |
| 1865 | |||
| 1866 | 98 | bool AirLoopHVACUnitarySystem::setAncilliaryOnCycleElectricPower(double ancilliaryOnCycleElectricPower) { | |
| 1867 |
1/1✓ Branch 3 taken 98 times.
|
98 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setAncilliaryOnCycleElectricPower(ancilliaryOnCycleElectricPower); |
| 1868 | } | ||
| 1869 | |||
| 1870 | ✗ | void AirLoopHVACUnitarySystem::resetAncilliaryOnCycleElectricPower() { | |
| 1871 | ✗ | getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetAncilliaryOnCycleElectricPower(); | |
| 1872 | ✗ | } | |
| 1873 | |||
| 1874 | 98 | bool AirLoopHVACUnitarySystem::setAncilliaryOffCycleElectricPower(double ancilliaryOffCycleElectricPower) { | |
| 1875 |
1/1✓ Branch 3 taken 98 times.
|
98 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setAncilliaryOffCycleElectricPower(ancilliaryOffCycleElectricPower); |
| 1876 | } | ||
| 1877 | |||
| 1878 | ✗ | void AirLoopHVACUnitarySystem::resetAncilliaryOffCycleElectricPower() { | |
| 1879 | ✗ | getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetAncilliaryOffCycleElectricPower(); | |
| 1880 | ✗ | } | |
| 1881 | |||
| 1882 | // bool AirLoopHVACUnitarySystem::setDesignHeatRecoveryWaterFlowRate(double designHeatRecoveryWaterFlowRate) { | ||
| 1883 | // return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setDesignHeatRecoveryWaterFlowRate(designHeatRecoveryWaterFlowRate); | ||
| 1884 | // } | ||
| 1885 | |||
| 1886 | // void AirLoopHVACUnitarySystem::resetDesignHeatRecoveryWaterFlowRate() { | ||
| 1887 | // getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetDesignHeatRecoveryWaterFlowRate(); | ||
| 1888 | // } | ||
| 1889 | |||
| 1890 | // bool AirLoopHVACUnitarySystem::setMaximumTemperatureforHeatRecovery(double maximumTemperatureforHeatRecovery) { | ||
| 1891 | // return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setMaximumTemperatureforHeatRecovery(maximumTemperatureforHeatRecovery); | ||
| 1892 | // } | ||
| 1893 | |||
| 1894 | // void AirLoopHVACUnitarySystem::resetMaximumTemperatureforHeatRecovery() { | ||
| 1895 | // getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetMaximumTemperatureforHeatRecovery(); | ||
| 1896 | // } | ||
| 1897 | |||
| 1898 | 12 | bool AirLoopHVACUnitarySystem::setDesignSpecificationMultispeedObject(const UnitarySystemPerformanceMultispeed& unitarySystemPerformace) { | |
| 1899 |
1/1✓ Branch 3 taken 12 times.
|
12 | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setDesignSpecificationMultispeedObject(unitarySystemPerformace); |
| 1900 | } | ||
| 1901 | |||
| 1902 | 1 | void AirLoopHVACUnitarySystem::resetDesignSpecificationMultispeedObject() { | |
| 1903 |
1/1✓ Branch 3 taken 1 time.
|
1 | getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetDesignSpecificationMultispeedObject(); |
| 1904 | 1 | } | |
| 1905 | |||
| 1906 | ✗ | boost::optional<double> AirLoopHVACUnitarySystem::autosizedSupplyAirFlowRateDuringCoolingOperation() const { | |
| 1907 | ✗ | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->autosizedSupplyAirFlowRateDuringCoolingOperation(); | |
| 1908 | } | ||
| 1909 | |||
| 1910 | ✗ | boost::optional<double> AirLoopHVACUnitarySystem::autosizedSupplyAirFlowRateDuringHeatingOperation() const { | |
| 1911 | ✗ | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->autosizedSupplyAirFlowRateDuringHeatingOperation(); | |
| 1912 | } | ||
| 1913 | |||
| 1914 | ✗ | boost::optional<double> AirLoopHVACUnitarySystem::autosizedSupplyAirFlowRateWhenNoCoolingorHeatingisRequired() const { | |
| 1915 | ✗ | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->autosizedSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); | |
| 1916 | } | ||
| 1917 | |||
| 1918 | ✗ | boost::optional<double> AirLoopHVACUnitarySystem::autosizedMaximumSupplyAirTemperature() const { | |
| 1919 | ✗ | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->autosizedMaximumSupplyAirTemperature(); | |
| 1920 | } | ||
| 1921 | |||
| 1922 | ✗ | boost::optional<double> AirLoopHVACUnitarySystem::autosizedDOASDXCoolingCoilLeavingMinimumAirTemperature() const { | |
| 1923 | ✗ | return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->autosizedDOASDXCoolingCoilLeavingMinimumAirTemperature(); | |
| 1924 | } | ||
| 1925 | |||
| 1926 | /// @cond | ||
| 1927 | 246 | AirLoopHVACUnitarySystem::AirLoopHVACUnitarySystem(std::shared_ptr<detail::AirLoopHVACUnitarySystem_Impl> impl) | |
| 1928 |
1/1✓ Branch 3 taken 246 times.
|
246 | : ZoneHVACComponent(std::move(impl)) {} |
| 1929 | |||
| 1930 | // DEPRECATED | ||
| 1931 | 1 | bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateMethodDuringCoolingOperation(const std::string& supplyAirFlowRateMethodDuringCoolingOperation) { | |
| 1932 |
5/5✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
✓ Branch 13 taken 1 time.
|
4 | DEPRECATED_AT_MSG(3, 7, 0, |
| 1933 | "Use setSupplyAirFlowRateDuringCoolingOperation, autosizeSupplyAirFlowRateDuringCoolingOperation, " | ||
| 1934 | "setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation, setFractionofAutosizedDesignCoolingSupplyAirFlowRate, or " | ||
| 1935 | "setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation instead."); | ||
| 1936 | 1 | return false; | |
| 1937 | } | ||
| 1938 | |||
| 1939 | 1 | void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateMethodDuringCoolingOperation() { | |
| 1940 |
5/5✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
✓ Branch 13 taken 1 time.
|
4 | DEPRECATED_AT_MSG(3, 7, 0, |
| 1941 | "Use setSupplyAirFlowRateDuringCoolingOperation, autosizeSupplyAirFlowRateDuringCoolingOperation, " | ||
| 1942 | "setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation, setFractionofAutosizedDesignCoolingSupplyAirFlowRate, or " | ||
| 1943 | "setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation instead."); | ||
| 1944 | 1 | } | |
| 1945 | |||
| 1946 | 1 | void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateDuringCoolingOperation() { | |
| 1947 |
5/5✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
✓ Branch 13 taken 1 time.
|
4 | DEPRECATED_AT_MSG(3, 7, 0, |
| 1948 | "Use setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation, setFractionofAutosizedDesignCoolingSupplyAirFlowRate, or " | ||
| 1949 | "setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation instead."); | ||
| 1950 | 1 | } | |
| 1951 | |||
| 1952 | 1 | void AirLoopHVACUnitarySystem::resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation() { | |
| 1953 |
5/5✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
✓ Branch 13 taken 1 time.
|
4 | DEPRECATED_AT_MSG( |
| 1954 | 3, 7, 0, | ||
| 1955 | "Use setSupplyAirFlowRateDuringCoolingOperation, autosizeSupplyAirFlowRateDuringCoolingOperation, " | ||
| 1956 | "setFractionofAutosizedDesignCoolingSupplyAirFlowRate, or setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation instead."); | ||
| 1957 | 1 | } | |
| 1958 | |||
| 1959 | 1 | void AirLoopHVACUnitarySystem::resetFractionofAutosizedDesignCoolingSupplyAirFlowRate() { | |
| 1960 |
5/5✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
✓ Branch 13 taken 1 time.
|
4 | DEPRECATED_AT_MSG( |
| 1961 | 3, 7, 0, | ||
| 1962 | "Use setSupplyAirFlowRateDuringCoolingOperation, autosizeSupplyAirFlowRateDuringCoolingOperation, " | ||
| 1963 | "setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation, or setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation instead."); | ||
| 1964 | 1 | } | |
| 1965 | |||
| 1966 | 1 | void AirLoopHVACUnitarySystem::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation() { | |
| 1967 |
5/5✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
✓ Branch 13 taken 1 time.
|
4 | DEPRECATED_AT_MSG(3, 7, 0, |
| 1968 | "Use setSupplyAirFlowRateDuringCoolingOperation, autosizeSupplyAirFlowRateDuringCoolingOperation, " | ||
| 1969 | "setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation, or setFractionofAutosizedDesignCoolingSupplyAirFlowRate instead."); | ||
| 1970 | 1 | } | |
| 1971 | |||
| 1972 | 1 | bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateMethodDuringHeatingOperation(const std::string& supplyAirFlowRateMethodDuringHeatingOperation) { | |
| 1973 |
5/5✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
✓ Branch 13 taken 1 time.
|
4 | DEPRECATED_AT_MSG(3, 7, 0, |
| 1974 | "Use setSupplyAirFlowRateDuringHeatingOperation, autosizeSupplyAirFlowRateDuringHeatingOperation, " | ||
| 1975 | "setSupplyAirFlowRatePerFloorAreaduringHeatingOperation, setFractionofAutosizedDesignHeatingSupplyAirFlowRate, or " | ||
| 1976 | "setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation instead."); | ||
| 1977 | 1 | return false; | |
| 1978 | } | ||
| 1979 | |||
| 1980 | 1 | void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateMethodDuringHeatingOperation() { | |
| 1981 |
5/5✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
✓ Branch 13 taken 1 time.
|
4 | DEPRECATED_AT_MSG(3, 7, 0, |
| 1982 | "Use setSupplyAirFlowRateDuringHeatingOperation, autosizeSupplyAirFlowRateDuringHeatingOperation, " | ||
| 1983 | "setSupplyAirFlowRatePerFloorAreaduringHeatingOperation, setFractionofAutosizedDesignHeatingSupplyAirFlowRate, or " | ||
| 1984 | "setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation instead."); | ||
| 1985 | 1 | } | |
| 1986 | |||
| 1987 | 1 | void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateDuringHeatingOperation() { | |
| 1988 |
5/5✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
✓ Branch 13 taken 1 time.
|
4 | DEPRECATED_AT_MSG(3, 7, 0, |
| 1989 | "Use setSupplyAirFlowRatePerFloorAreaduringHeatingOperation, setFractionofAutosizedDesignHeatingSupplyAirFlowRate, or " | ||
| 1990 | "setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation instead."); | ||
| 1991 | 1 | } | |
| 1992 | |||
| 1993 | 1 | void AirLoopHVACUnitarySystem::resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation() { | |
| 1994 |
5/5✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
✓ Branch 13 taken 1 time.
|
4 | DEPRECATED_AT_MSG( |
| 1995 | 3, 7, 0, | ||
| 1996 | "Use setSupplyAirFlowRateDuringHeatingOperation, autosizeSupplyAirFlowRateDuringHeatingOperation, " | ||
| 1997 | "setFractionofAutosizedDesignHeatingSupplyAirFlowRate, or setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation instead."); | ||
| 1998 | 1 | } | |
| 1999 | |||
| 2000 | 1 | void AirLoopHVACUnitarySystem::resetFractionofAutosizedDesignHeatingSupplyAirFlowRate() { | |
| 2001 |
5/5✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
✓ Branch 13 taken 1 time.
|
4 | DEPRECATED_AT_MSG( |
| 2002 | 3, 7, 0, | ||
| 2003 | "Use setSupplyAirFlowRateDuringHeatingOperation, autosizeSupplyAirFlowRateDuringHeatingOperation, " | ||
| 2004 | "setSupplyAirFlowRatePerFloorAreaduringHeatingOperation, or setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation instead."); | ||
| 2005 | 1 | } | |
| 2006 | |||
| 2007 | 1 | void AirLoopHVACUnitarySystem::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation() { | |
| 2008 |
5/5✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
✓ Branch 13 taken 1 time.
|
4 | DEPRECATED_AT_MSG(3, 7, 0, |
| 2009 | "Use setSupplyAirFlowRateDuringHeatingOperation, autosizeSupplyAirFlowRateDuringHeatingOperation, " | ||
| 2010 | "setSupplyAirFlowRatePerFloorAreaduringHeatingOperation, or setFractionofAutosizedDesignHeatingSupplyAirFlowRate instead."); | ||
| 2011 | 1 | } | |
| 2012 | |||
| 2013 | ✗ | bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired(const std::string& noCoolHeatMethod) { | |
| 2014 | // setSupplyAirFlowRateWhenNoCoolingorHeatingisRequired, setSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired, setFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired, setFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired, setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired, setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired | ||
| 2015 | ✗ | DEPRECATED_AT_MSG(3, 7, 0, | |
| 2016 | "Use resetSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired For 'None', one of the flow rate setters otherwise."); | ||
| 2017 | |||
| 2018 | ✗ | if (openstudio::istringEqual("None", noCoolHeatMethod)) { | |
| 2019 | ✗ | resetSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired(); | |
| 2020 | ✗ | return true; | |
| 2021 | } | ||
| 2022 | ✗ | return false; | |
| 2023 | } | ||
| 2024 | |||
| 2025 | ✗ | void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateWhenNoCoolingorHeatingisRequired() { | |
| 2026 | ✗ | DEPRECATED_AT_MSG( | |
| 2027 | 3, 7, 0, "Use resetSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired to clear all fields, one of the flow rate setters otherwise."); | ||
| 2028 | ✗ | } | |
| 2029 | |||
| 2030 | ✗ | void AirLoopHVACUnitarySystem::resetSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired() { | |
| 2031 | ✗ | DEPRECATED_AT_MSG( | |
| 2032 | 3, 7, 0, "Use resetSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired to clear all fields, one of the flow rate setters otherwise."); | ||
| 2033 | ✗ | } | |
| 2034 | |||
| 2035 | ✗ | void AirLoopHVACUnitarySystem::resetFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired() { | |
| 2036 | ✗ | DEPRECATED_AT_MSG( | |
| 2037 | 3, 7, 0, "Use resetSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired to clear all fields, one of the flow rate setters otherwise."); | ||
| 2038 | ✗ | } | |
| 2039 | |||
| 2040 | ✗ | void AirLoopHVACUnitarySystem::resetFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired() { | |
| 2041 | ✗ | DEPRECATED_AT_MSG( | |
| 2042 | 3, 7, 0, "Use resetSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired to clear all fields, one of the flow rate setters otherwise."); | ||
| 2043 | ✗ | } | |
| 2044 | |||
| 2045 | ✗ | void AirLoopHVACUnitarySystem::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired() { | |
| 2046 | ✗ | DEPRECATED_AT_MSG( | |
| 2047 | 3, 7, 0, "Use resetSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired to clear all fields, one of the flow rate setters otherwise."); | ||
| 2048 | ✗ | } | |
| 2049 | |||
| 2050 | ✗ | void AirLoopHVACUnitarySystem::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired() { | |
| 2051 | ✗ | DEPRECATED_AT_MSG( | |
| 2052 | 3, 7, 0, "Use resetSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired to clear all fields, one of the flow rate setters otherwise."); | ||
| 2053 | ✗ | } | |
| 2054 | |||
| 2055 | ✗ | double AirLoopHVACUnitarySystem::maximumCyclingRate() const { | |
| 2056 | ✗ | DEPRECATED_AT_MSG(3, 7, 0, | |
| 2057 | "As of EnergyPlus 23.2.0, this property is on the child cooling coil. Use coolingCoil()->maximumCyclingRate() instead."); | ||
| 2058 | ✗ | double result = 2.5; // former default | |
| 2059 | ✗ | if (auto c_ = coolingCoil()) { | |
| 2060 | ✗ | if (auto c_eq_ = c_->optionalCast<CoilCoolingWaterToAirHeatPumpEquationFit>()) { | |
| 2061 | ✗ | result = c_eq_->maximumCyclingRate(); | |
| 2062 | ✗ | } else if (auto c_vs_ = c_->optionalCast<CoilCoolingWaterToAirHeatPumpVariableSpeedEquationFit>()) { | |
| 2063 | ✗ | result = c_vs_->maximumCyclingRate(); | |
| 2064 | ✗ | } else if (auto c_dx_ = c_->optionalCast<CoilCoolingDXVariableSpeed>()) { | |
| 2065 | ✗ | result = c_dx_->maximumCyclingRate(); | |
| 2066 | ✗ | } | |
| 2067 | ✗ | } | |
| 2068 | ✗ | return result; | |
| 2069 | } | ||
| 2070 | |||
| 2071 | ✗ | bool AirLoopHVACUnitarySystem::isMaximumCyclingRateDefaulted() const { | |
| 2072 | ✗ | DEPRECATED_AT_MSG(3, 7, 0, "As of EnergyPlus 23.2.0, this property is on the child cooling coil and it's a required-field"); | |
| 2073 | ✗ | return false; | |
| 2074 | } | ||
| 2075 | |||
| 2076 | ✗ | bool AirLoopHVACUnitarySystem::setMaximumCyclingRate(double maximumCyclingRate) { | |
| 2077 | ✗ | DEPRECATED_AT_MSG(3, 7, 0, | |
| 2078 | "As of EnergyPlus 23.2.0, this property is on the child cooling coil. Use coolingCoil()->setMaximumCyclingRate() instead."); | ||
| 2079 | ✗ | bool result = false; | |
| 2080 | ✗ | if (auto c_ = coolingCoil()) { | |
| 2081 | ✗ | if (auto c_eq_ = c_->optionalCast<CoilCoolingWaterToAirHeatPumpEquationFit>()) { | |
| 2082 | ✗ | result = c_eq_->setMaximumCyclingRate(maximumCyclingRate); | |
| 2083 | ✗ | } else if (auto c_vs_ = c_->optionalCast<CoilCoolingWaterToAirHeatPumpVariableSpeedEquationFit>()) { | |
| 2084 | ✗ | result = c_vs_->setMaximumCyclingRate(maximumCyclingRate); | |
| 2085 | ✗ | } else if (auto c_dx_ = c_->optionalCast<CoilCoolingDXVariableSpeed>()) { | |
| 2086 | ✗ | result = c_dx_->setMaximumCyclingRate(maximumCyclingRate); | |
| 2087 | ✗ | } | |
| 2088 | ✗ | } | |
| 2089 | ✗ | return result; | |
| 2090 | } | ||
| 2091 | |||
| 2092 | ✗ | void AirLoopHVACUnitarySystem::resetMaximumCyclingRate() { | |
| 2093 | ✗ | DEPRECATED_AT_MSG(3, 7, 0, "As of EnergyPlus 23.2.0, this property is on the child cooling coil and it's a required-field"); | |
| 2094 | ✗ | } | |
| 2095 | |||
| 2096 | ✗ | double AirLoopHVACUnitarySystem::heatPumpTimeConstant() const { | |
| 2097 | ✗ | DEPRECATED_AT_MSG( | |
| 2098 | 3, 7, 0, "As of EnergyPlus 23.2.0, this property is on the child cooling coil. Use coolingCoil()->latentCapacityTimeConstant() instead."); | ||
| 2099 | ✗ | double result = 60; // former default | |
| 2100 | ✗ | if (auto c_ = coolingCoil()) { | |
| 2101 | ✗ | if (auto c_eq_ = c_->optionalCast<CoilCoolingWaterToAirHeatPumpEquationFit>()) { | |
| 2102 | ✗ | result = c_eq_->latentCapacityTimeConstant(); | |
| 2103 | ✗ | } else if (auto c_vs_ = c_->optionalCast<CoilCoolingWaterToAirHeatPumpVariableSpeedEquationFit>()) { | |
| 2104 | ✗ | result = c_vs_->latentCapacityTimeConstant(); | |
| 2105 | ✗ | } else if (auto c_dx_ = c_->optionalCast<CoilCoolingDXVariableSpeed>()) { | |
| 2106 | ✗ | result = c_dx_->latentCapacityTimeConstant(); | |
| 2107 | ✗ | } | |
| 2108 | ✗ | } | |
| 2109 | ✗ | return result; | |
| 2110 | } | ||
| 2111 | |||
| 2112 | ✗ | bool AirLoopHVACUnitarySystem::isHeatPumpTimeConstantDefaulted() const { | |
| 2113 | ✗ | DEPRECATED_AT_MSG(3, 7, 0, "As of EnergyPlus 23.2.0, this property is on the child cooling coil and it's a required-field"); | |
| 2114 | ✗ | return false; | |
| 2115 | } | ||
| 2116 | |||
| 2117 | ✗ | bool AirLoopHVACUnitarySystem::setHeatPumpTimeConstant(double heatPumpTimeConstant) { | |
| 2118 | ✗ | DEPRECATED_AT_MSG( | |
| 2119 | 3, 7, 0, "As of EnergyPlus 23.2.0, this property is on the child cooling coil. Use coolingCoil()->setLatentCapacityTimeConstant() instead."); | ||
| 2120 | ✗ | bool result = false; | |
| 2121 | ✗ | if (auto c_ = coolingCoil()) { | |
| 2122 | ✗ | if (auto c_eq_ = c_->optionalCast<CoilCoolingWaterToAirHeatPumpEquationFit>()) { | |
| 2123 | ✗ | result = c_eq_->setLatentCapacityTimeConstant(heatPumpTimeConstant); | |
| 2124 | ✗ | } else if (auto c_vs_ = c_->optionalCast<CoilCoolingWaterToAirHeatPumpVariableSpeedEquationFit>()) { | |
| 2125 | ✗ | result = c_vs_->setLatentCapacityTimeConstant(heatPumpTimeConstant); | |
| 2126 | ✗ | } else if (auto c_dx_ = c_->optionalCast<CoilCoolingDXVariableSpeed>()) { | |
| 2127 | ✗ | result = c_dx_->setLatentCapacityTimeConstant(heatPumpTimeConstant); | |
| 2128 | ✗ | } | |
| 2129 | ✗ | } | |
| 2130 | ✗ | return result; | |
| 2131 | } | ||
| 2132 | |||
| 2133 | ✗ | void AirLoopHVACUnitarySystem::resetHeatPumpTimeConstant() { | |
| 2134 | ✗ | DEPRECATED_AT_MSG(3, 7, 0, "As of EnergyPlus 23.2.0, this property is on the child cooling coil and it's a required-field"); | |
| 2135 | ✗ | } | |
| 2136 | |||
| 2137 | ✗ | double AirLoopHVACUnitarySystem::fractionofOnCyclePowerUse() const { | |
| 2138 | ✗ | DEPRECATED_AT_MSG(3, 7, 0, "As of EnergyPlus 23.2.0, this property is no longer used."); | |
| 2139 | ✗ | const double result = 0.01; // former default | |
| 2140 | ✗ | return result; | |
| 2141 | } | ||
| 2142 | |||
| 2143 | ✗ | bool AirLoopHVACUnitarySystem::isFractionofOnCyclePowerUseDefaulted() const { | |
| 2144 | ✗ | DEPRECATED_AT_MSG(3, 7, 0, "As of EnergyPlus 23.2.0, this property is no longer used."); | |
| 2145 | ✗ | return false; | |
| 2146 | } | ||
| 2147 | |||
| 2148 | ✗ | bool AirLoopHVACUnitarySystem::setFractionofOnCyclePowerUse(double fractionofOnCyclePowerUse) { | |
| 2149 | ✗ | DEPRECATED_AT_MSG(3, 7, 0, "As of EnergyPlus 23.2.0, this property is no longer used."); | |
| 2150 | ✗ | return false; | |
| 2151 | } | ||
| 2152 | |||
| 2153 | ✗ | void AirLoopHVACUnitarySystem::resetFractionofOnCyclePowerUse() { | |
| 2154 | ✗ | DEPRECATED_AT_MSG(3, 7, 0, "As of EnergyPlus 23.2.0, this property is no longer used."); | |
| 2155 | ✗ | } | |
| 2156 | |||
| 2157 | ✗ | double AirLoopHVACUnitarySystem::heatPumpFanDelayTime() const { | |
| 2158 | ✗ | DEPRECATED_AT_MSG(3, 7, 0, "As of EnergyPlus 23.2.0, this property is on the child cooling coil. Use coolingCoil()->fanDelayTime() instead."); | |
| 2159 | ✗ | double result = 60; // former default | |
| 2160 | ✗ | if (auto c_ = coolingCoil()) { | |
| 2161 | ✗ | if (auto c_eq_ = c_->optionalCast<CoilCoolingWaterToAirHeatPumpEquationFit>()) { | |
| 2162 | ✗ | result = c_eq_->fanDelayTime(); | |
| 2163 | ✗ | } else if (auto c_vs_ = c_->optionalCast<CoilCoolingWaterToAirHeatPumpVariableSpeedEquationFit>()) { | |
| 2164 | ✗ | result = c_vs_->fanDelayTime(); | |
| 2165 | ✗ | } else if (auto c_dx_ = c_->optionalCast<CoilCoolingDXVariableSpeed>()) { | |
| 2166 | ✗ | result = c_dx_->fanDelayTime(); | |
| 2167 | ✗ | } | |
| 2168 | ✗ | } | |
| 2169 | ✗ | return result; | |
| 2170 | } | ||
| 2171 | |||
| 2172 | ✗ | bool AirLoopHVACUnitarySystem::isHeatPumpFanDelayTimeDefaulted() const { | |
| 2173 | ✗ | DEPRECATED_AT_MSG(3, 7, 0, "As of EnergyPlus 23.2.0, this property is on the child cooling coil and it's a required-field"); | |
| 2174 | ✗ | return false; | |
| 2175 | } | ||
| 2176 | |||
| 2177 | ✗ | bool AirLoopHVACUnitarySystem::setHeatPumpFanDelayTime(double heatPumpFanDelayTime) { | |
| 2178 | ✗ | DEPRECATED_AT_MSG(3, 7, 0, "As of EnergyPlus 23.2.0, this property is on the child cooling coil. Use coolingCoil()->setFanDelayTime() instead."); | |
| 2179 | ✗ | bool result = false; | |
| 2180 | ✗ | if (auto c_ = coolingCoil()) { | |
| 2181 | ✗ | if (auto c_eq_ = c_->optionalCast<CoilCoolingWaterToAirHeatPumpEquationFit>()) { | |
| 2182 | ✗ | result = c_eq_->setFanDelayTime(heatPumpFanDelayTime); | |
| 2183 | ✗ | } else if (auto c_vs_ = c_->optionalCast<CoilCoolingWaterToAirHeatPumpVariableSpeedEquationFit>()) { | |
| 2184 | ✗ | result = c_vs_->setFanDelayTime(heatPumpFanDelayTime); | |
| 2185 | ✗ | } else if (auto c_dx_ = c_->optionalCast<CoilCoolingDXVariableSpeed>()) { | |
| 2186 | ✗ | result = c_dx_->setFanDelayTime(heatPumpFanDelayTime); | |
| 2187 | ✗ | } | |
| 2188 | ✗ | } | |
| 2189 | ✗ | return result; | |
| 2190 | } | ||
| 2191 | |||
| 2192 | ✗ | void AirLoopHVACUnitarySystem::resetHeatPumpFanDelayTime() { | |
| 2193 | ✗ | DEPRECATED_AT_MSG(3, 7, 0, "As of EnergyPlus 23.2.0, this property is on the child cooling coil and it's a required-field"); | |
| 2194 | ✗ | } | |
| 2195 | |||
| 2196 | /// @endcond | ||
| 2197 | |||
| 2198 | } // namespace model | ||
| 2199 | } // namespace openstudio | ||
| 2200 |