GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 0.0% 0 / 0 / 88
Functions: 0.0% 0 / 0 / 1
Branches: 0.0% 0 / 0 / 152

src/energyplus/ForwardTranslator/ForwardTranslateChillerAbsorption.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 "../ForwardTranslator.hpp"
7 #include "../../model/Model.hpp"
8 #include "../../model/Schedule.hpp"
9 #include "../../model/Schedule_Impl.hpp"
10 #include "../../model/Node.hpp"
11 #include "../../model/Node_Impl.hpp"
12 #include "../../model/ChillerAbsorption.hpp"
13 #include "../../model/ChillerAbsorption_Impl.hpp"
14 #include "../../model/Curve.hpp"
15 #include "../../model/Curve_Impl.hpp"
16 #include "../../utilities/core/Logger.hpp"
17 #include "../../utilities/core/Assert.hpp"
18 #include <utilities/idd/Chiller_Absorption_FieldEnums.hxx>
19 #include "../../utilities/idd/IddEnums.hpp"
20 #include <utilities/idd/IddEnums.hxx>
21 #include <utilities/idd/IddFactory.hxx>
22
23 using namespace openstudio::model;
24
25 using namespace std;
26
27 namespace openstudio {
28
29 namespace energyplus {
30
31 ✗ boost::optional<IdfObject> ForwardTranslator::translateChillerAbsorption(ChillerAbsorption& modelObject) {
32 ✗ IdfObject idfObject(IddObjectType::Chiller_Absorption);
33
34 ✗ m_idfObjects.push_back(idfObject);
35
36 // Name
37 ✗ if (auto s = modelObject.name()) {
38 ✗ idfObject.setName(*s);
39 ✗ }
40
41 // ChilledWaterInletNodeName
42 ✗ if (auto mo = modelObject.supplyInletModelObject()) {
43 ✗ if (auto node = mo->optionalCast<Node>()) {
44 ✗ idfObject.setString(Chiller_AbsorptionFields::ChilledWaterInletNodeName, node->name().get());
45 ✗ }
46 ✗ }
47
48 // ChilledWaterOutletNodeName
49 ✗ if (auto mo = modelObject.supplyOutletModelObject()) {
50 ✗ if (auto node = mo->optionalCast<Node>()) {
51 ✗ idfObject.setString(Chiller_AbsorptionFields::ChilledWaterOutletNodeName, node->name().get());
52 ✗ }
53 ✗ }
54
55 // CondenserInletNodeName
56 ✗ if (auto mo = modelObject.demandInletModelObject()) {
57 ✗ if (auto node = mo->optionalCast<Node>()) {
58 ✗ idfObject.setString(Chiller_AbsorptionFields::CondenserInletNodeName, node->name().get());
59 ✗ }
60 ✗ }
61
62 // CondenserOutletNodeName
63 ✗ if (auto mo = modelObject.demandOutletModelObject()) {
64 ✗ if (auto node = mo->optionalCast<Node>()) {
65 ✗ idfObject.setString(Chiller_AbsorptionFields::CondenserOutletNodeName, node->name().get());
66 ✗ }
67 ✗ }
68
69 ✗ if (auto mo = modelObject.tertiaryInletModelObject()) {
70 ✗ idfObject.setString(Chiller_AbsorptionFields::GeneratorInletNodeName, mo->name().get());
71 ✗ }
72
73 ✗ if (auto mo = modelObject.tertiaryOutletModelObject()) {
74 ✗ idfObject.setString(Chiller_AbsorptionFields::GeneratorOutletNodeName, mo->name().get());
75 ✗ }
76
77 ✗ if (modelObject.isNominalCapacityAutosized()) {
78 ✗ idfObject.setString(Chiller_AbsorptionFields::NominalCapacity, "Autosize");
79 ✗ } else if (auto value = modelObject.nominalCapacity()) {
80 ✗ idfObject.setDouble(Chiller_AbsorptionFields::NominalCapacity, value.get());
81 }
82
83 ✗ if (modelObject.isNominalPumpingPowerAutosized()) {
84 ✗ idfObject.setString(Chiller_AbsorptionFields::NominalPumpingPower, "Autosize");
85 ✗ } else if (auto value = modelObject.nominalPumpingPower()) {
86 ✗ idfObject.setDouble(Chiller_AbsorptionFields::NominalPumpingPower, value.get());
87 }
88
89 {
90 ✗ auto value = modelObject.minimumPartLoadRatio();
91 ✗ idfObject.setDouble(Chiller_AbsorptionFields::MinimumPartLoadRatio, value);
92 }
93
94 {
95 ✗ auto value = modelObject.maximumPartLoadRatio();
96 ✗ idfObject.setDouble(Chiller_AbsorptionFields::MaximumPartLoadRatio, value);
97 }
98
99 {
100 ✗ auto value = modelObject.optimumPartLoadRatio();
101 ✗ idfObject.setDouble(Chiller_AbsorptionFields::OptimumPartLoadRatio, value);
102 }
103
104 {
105 ✗ auto value = modelObject.designCondenserInletTemperature();
106 ✗ idfObject.setDouble(Chiller_AbsorptionFields::DesignCondenserInletTemperature, value);
107 }
108
109 ✗ if (modelObject.isDesignChilledWaterFlowRateAutosized()) {
110 ✗ idfObject.setString(Chiller_AbsorptionFields::DesignChilledWaterFlowRate, "Autosize");
111 ✗ } else if (auto value = modelObject.designChilledWaterFlowRate()) {
112 ✗ idfObject.setDouble(Chiller_AbsorptionFields::DesignChilledWaterFlowRate, value.get());
113 }
114
115 ✗ if (modelObject.isDesignCondenserWaterFlowRateAutosized()) {
116 ✗ idfObject.setString(Chiller_AbsorptionFields::DesignCondenserWaterFlowRate, "Autosize");
117 ✗ } else if (auto value = modelObject.designCondenserWaterFlowRate()) {
118 ✗ idfObject.setDouble(Chiller_AbsorptionFields::DesignCondenserWaterFlowRate, value.get());
119 }
120
121 {
122 ✗ auto value = modelObject.coefficient1oftheHotWaterorSteamUsePartLoadRatioCurve();
123 ✗ idfObject.setDouble(Chiller_AbsorptionFields::Coefficient1oftheHotWaterorSteamUsePartLoadRatioCurve, value);
124 }
125
126 {
127 ✗ auto value = modelObject.coefficient2oftheHotWaterorSteamUsePartLoadRatioCurve();
128 ✗ idfObject.setDouble(Chiller_AbsorptionFields::Coefficient2oftheHotWaterorSteamUsePartLoadRatioCurve, value);
129 }
130
131 {
132 ✗ auto value = modelObject.coefficient3oftheHotWaterorSteamUsePartLoadRatioCurve();
133 ✗ idfObject.setDouble(Chiller_AbsorptionFields::Coefficient3oftheHotWaterorSteamUsePartLoadRatioCurve, value);
134 }
135
136 {
137 ✗ auto value = modelObject.coefficient1ofthePumpElectricUsePartLoadRatioCurve();
138 ✗ idfObject.setDouble(Chiller_AbsorptionFields::Coefficient1ofthePumpElectricUsePartLoadRatioCurve, value);
139 }
140
141 {
142 ✗ auto value = modelObject.coefficient2ofthePumpElectricUsePartLoadRatioCurve();
143 ✗ idfObject.setDouble(Chiller_AbsorptionFields::Coefficient2ofthePumpElectricUsePartLoadRatioCurve, value);
144 }
145
146 {
147 ✗ auto value = modelObject.coefficient3ofthePumpElectricUsePartLoadRatioCurve();
148 ✗ idfObject.setDouble(Chiller_AbsorptionFields::Coefficient3ofthePumpElectricUsePartLoadRatioCurve, value);
149 }
150
151 {
152 ✗ auto value = modelObject.chilledWaterOutletTemperatureLowerLimit();
153 ✗ idfObject.setDouble(Chiller_AbsorptionFields::ChilledWaterOutletTemperatureLowerLimit, value);
154 }
155
156 {
157 ✗ auto value = modelObject.chillerFlowMode();
158 ✗ idfObject.setString(Chiller_AbsorptionFields::ChillerFlowMode, value);
159 ✗ }
160
161 {
162 ✗ auto value = modelObject.generatorHeatSourceType();
163 ✗ idfObject.setString(Chiller_AbsorptionFields::GeneratorHeatSourceType, value);
164 ✗ }
165
166 ✗ if (modelObject.generatorLoop()) {
167 ✗ if (modelObject.isDesignGeneratorFluidFlowRateAutosized()) {
168 ✗ idfObject.setString(Chiller_AbsorptionFields::DesignGeneratorFluidFlowRate, "Autosize");
169 ✗ } else if (auto value = modelObject.designGeneratorFluidFlowRate()) {
170 ✗ idfObject.setDouble(Chiller_AbsorptionFields::DesignGeneratorFluidFlowRate, value.get());
171 }
172 } else {
173 ✗ idfObject.setString(Chiller_AbsorptionFields::DesignGeneratorFluidFlowRate, "");
174 }
175
176 {
177 ✗ auto value = modelObject.degreeofSubcoolinginSteamGenerator();
178 ✗ idfObject.setDouble(Chiller_AbsorptionFields::DegreeofSubcoolinginSteamGenerator, value);
179 }
180
181 {
182 ✗ auto value = modelObject.sizingFactor();
183 ✗ idfObject.setDouble(Chiller_AbsorptionFields::SizingFactor, value);
184 }
185
186 ✗ return idfObject;
187 ✗ }
188
189 } // namespace energyplus
190
191 } // namespace openstudio
192