Line data Source code
1 : // EnergyPlus, Copyright (c) 1996-2024, The Board of Trustees of the University of Illinois,
2 : // The Regents of the University of California, through Lawrence Berkeley National Laboratory
3 : // (subject to receipt of any required approvals from the U.S. Dept. of Energy), Oak Ridge
4 : // National Laboratory, managed by UT-Battelle, Alliance for Sustainable Energy, LLC, and other
5 : // contributors. All rights reserved.
6 : //
7 : // NOTICE: This Software was developed under funding from the U.S. Department of Energy and the
8 : // U.S. Government consequently retains certain rights. As such, the U.S. Government has been
9 : // granted for itself and others acting on its behalf a paid-up, nonexclusive, irrevocable,
10 : // worldwide license in the Software to reproduce, distribute copies to the public, prepare
11 : // derivative works, and perform publicly and display publicly, and to permit others to do so.
12 : //
13 : // Redistribution and use in source and binary forms, with or without modification, are permitted
14 : // provided that the following conditions are met:
15 : //
16 : // (1) Redistributions of source code must retain the above copyright notice, this list of
17 : // conditions and the following disclaimer.
18 : //
19 : // (2) Redistributions in binary form must reproduce the above copyright notice, this list of
20 : // conditions and the following disclaimer in the documentation and/or other materials
21 : // provided with the distribution.
22 : //
23 : // (3) Neither the name of the University of California, Lawrence Berkeley National Laboratory,
24 : // the University of Illinois, U.S. Dept. of Energy nor the names of its contributors may be
25 : // used to endorse or promote products derived from this software without specific prior
26 : // written permission.
27 : //
28 : // (4) Use of EnergyPlus(TM) Name. If Licensee (i) distributes the software in stand-alone form
29 : // without changes from the version obtained under this License, or (ii) Licensee makes a
30 : // reference solely to the software portion of its product, Licensee must refer to the
31 : // software as "EnergyPlus version X" software, where "X" is the version number Licensee
32 : // obtained under this License and may not use a different name for the software. Except as
33 : // specifically required in this Section (4), Licensee shall not use in a company name, a
34 : // product name, in advertising, publicity, or other promotional activities any name, trade
35 : // name, trademark, logo, or other designation of "EnergyPlus", "E+", "e+" or confusingly
36 : // similar designation, without the U.S. Department of Energy's prior written consent.
37 : //
38 : // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
39 : // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
40 : // AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
41 : // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
42 : // CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
43 : // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
44 : // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
45 : // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
46 : // POSSIBILITY OF SUCH DAMAGE.
47 :
48 : #ifndef SQLiteProcedures_hh_INCLUDED
49 : #define SQLiteProcedures_hh_INCLUDED
50 :
51 : // C++ Headers
52 : #include <fstream>
53 : #include <iosfwd>
54 : #include <map>
55 : #include <memory>
56 : #include <sqlite3.h>
57 :
58 : // ObjexxFCL Headers
59 : #include <ObjexxFCL/Array1D.hh>
60 : #include <ObjexxFCL/Array2D.hh>
61 :
62 : // EnergyPlus Headers
63 : #include <EnergyPlus/Construction.hh>
64 : #include <EnergyPlus/Data/BaseData.hh>
65 : #include <EnergyPlus/DataHeatBalance.hh>
66 : #include <EnergyPlus/DataRoomAirModel.hh>
67 : #include <EnergyPlus/EnergyPlus.hh>
68 : #include <EnergyPlus/FileSystem.hh>
69 : #include <EnergyPlus/Material.hh>
70 : #include <EnergyPlus/OutputProcessor.hh>
71 :
72 : namespace EnergyPlus {
73 :
74 : // Forward
75 : struct EnergyPlusData;
76 :
77 : class SQLiteProcedures
78 : {
79 : protected:
80 : SQLiteProcedures(std::shared_ptr<std::ostream> const &errorStream, std::shared_ptr<sqlite3> const &db);
81 : SQLiteProcedures(std::shared_ptr<std::ostream> const &errorStream,
82 : bool writeOutputToSQLite,
83 : fs::path const &dbName,
84 : fs::path const &errorFilePath);
85 :
86 : int sqliteExecuteCommand(std::string_view commandBuffer);
87 : int sqlitePrepareStatement(sqlite3_stmt *&stmt, std::string_view stmtBuffer);
88 :
89 : int sqliteBindText(sqlite3_stmt *stmt, const int stmtInsertLocationIndex, std::string_view textBuffer);
90 : int sqliteBindInteger(sqlite3_stmt *stmt, const int stmtInsertLocationIndex, const int intToInsert);
91 : int sqliteBindDouble(sqlite3_stmt *stmt, const int stmtInsertLocationIndex, const double doubleToInsert);
92 : int sqliteBindNULL(sqlite3_stmt *stmt, const int stmtInsertLocationIndex);
93 : int sqliteBindLogical(sqlite3_stmt *stmt, const int stmtInsertLocationIndex, const bool valueToInsert);
94 :
95 : // This assumes a Foreign Key must be greater than 0 to be a valid Foreign Key, otherwise it sets the field to NULL.
96 : int sqliteBindForeignKey(sqlite3_stmt *stmt, const int stmtInsertLocationIndex, const int intToInsert);
97 :
98 : bool sqliteStepValidity(int const rc);
99 : int sqliteStepCommand(sqlite3_stmt *stmt);
100 : int sqliteResetCommand(sqlite3_stmt *stmt);
101 : bool sqliteWithinTransaction();
102 : // int sqliteClearBindings(sqlite3_stmt * stmt);
103 : // int sqliteFinalizeCommand(sqlite3_stmt * stmt);
104 :
105 : bool m_writeOutputToSQLite;
106 : std::shared_ptr<std::ostream> m_errorStream;
107 : std::shared_ptr<sqlite3> m_db;
108 : };
109 :
110 : class SQLite : SQLiteProcedures
111 : {
112 : public:
113 : // Friend SQLiteFixture which is the gtest fixture class for testing SQLite
114 : // This allows for testing of private methods in SQLite
115 : friend class SQLiteFixture;
116 :
117 : void addScheduleData(int const number, std::string_view name, std::string_view type, double const minValue, double const maxValue);
118 : void addZoneData(int const number, DataHeatBalance::ZoneData const &zoneData);
119 : void addZoneListData(int const number, DataHeatBalance::ZoneListData const &zoneListData);
120 : void addSurfaceData(int const number, DataSurfaces::SurfaceData const &surfaceData, std::string_view surfaceClass);
121 : void addZoneGroupData(int const number, DataHeatBalance::ZoneGroupData const &zoneGroupData);
122 : void addMaterialData(int const number, Material::MaterialBase const *materialData);
123 : void addConstructionData(int const number, Construction::ConstructionProps const &constructionData, double const &constructionUValue);
124 : void addNominalLightingData(int const number, DataHeatBalance::LightsData const &nominalLightingData);
125 : void addNominalPeopleData(int const number, DataHeatBalance::PeopleData const &nominalPeopleData);
126 : void addNominalElectricEquipmentData(int const number, DataHeatBalance::ZoneEquipData const &nominalElectricEquipmentData);
127 : void addNominalGasEquipmentData(int const number, DataHeatBalance::ZoneEquipData const &nominalGasEquipmentData);
128 : void addNominalSteamEquipmentData(int const number, DataHeatBalance::ZoneEquipData const &nominalSteamEquipmentData);
129 : void addNominalHotWaterEquipmentData(int const number, DataHeatBalance::ZoneEquipData const &nominalHotWaterEquipmentData);
130 : void addNominalOtherEquipmentData(int const number, DataHeatBalance::ZoneEquipData const &nominalOtherEquipmentData);
131 : void addNominalBaseboardData(int const number, DataHeatBalance::BBHeatData const &nominalBaseboardData);
132 : void addInfiltrationData(int const number, DataHeatBalance::InfiltrationData const &infiltrationData);
133 : void addVentilationData(int const number, DataHeatBalance::VentilationData const &ventilationData);
134 : void addRoomAirModelData(int const number, RoomAir::AirModelData const &roomAirModelData);
135 :
136 : // Open the DB and prepare for writing data
137 : // Create all of the tables on construction
138 : SQLite(std::shared_ptr<std::ostream> errorStream,
139 : fs::path const &dbName,
140 : fs::path const &errorFilePath,
141 : bool writeOutputToSQLite = false,
142 : bool writeTabularDataToSQLite = false);
143 :
144 : // Close database and free prepared statements
145 : virtual ~SQLite();
146 :
147 : bool writeOutputToSQLite() const;
148 : bool writeTabularDataToSQLite() const;
149 :
150 : // Begin a transaction
151 : void sqliteBegin();
152 :
153 : // Commit a transaction
154 : void sqliteCommit();
155 :
156 : // Rollback a transaction (cancel)
157 : void sqliteRollback();
158 :
159 : // Rollback to a named savepoint (nested transaction)
160 : void sqliteRollbackToSavepoint(std::string_view savepoint_name);
161 :
162 : // Release a named savepoint (nested transaction)
163 : void sqliteReleaseSavepoint(std::string_view savepoint_name);
164 :
165 : // create a named savepoint (nested transaction)
166 : void sqliteCreateSavepoint(std::string_view savepoint_name);
167 :
168 : // Within a current transaction
169 : bool sqliteWithinTransaction();
170 :
171 : void createSQLiteReportDictionaryRecord(int const reportVariableReportID,
172 : OutputProcessor::StoreType const storeType,
173 : std::string_view indexGroup,
174 : std::string_view keyedValueString,
175 : std::string_view const variableName,
176 : OutputProcessor::TimeStepType const timeStepType,
177 : std::string_view units,
178 : OutputProcessor::ReportFreq const reportFreq,
179 : bool isMeter,
180 : std::string_view const ScheduleName = {});
181 :
182 : void createSQLiteReportDataRecord(int const recordIndex,
183 : Real64 const value,
184 : OutputProcessor::ReportFreq const reportFreq = OutputProcessor::ReportFreq::Invalid,
185 : Real64 const minValue = 0.0,
186 : int const minValueDate = -1,
187 : Real64 const maxValue = 0.0,
188 : int const maxValueDate = -1,
189 : int const minutesPerTimeStep = -1);
190 :
191 : void createSQLiteTimeIndexRecord(OutputProcessor::ReportFreq const reportFreq,
192 : int const recordIndex,
193 : int const CumlativeSimulationDays,
194 : int const curEnvirNum,
195 : int const simulationYear,
196 : bool const curYearIsLeapYear,
197 : int const Month = -1,
198 : int const DayOfMonth = -1,
199 : int const Hour = -1,
200 : Real64 const EndMinute = -1.0,
201 : Real64 const StartMinute = -1.0,
202 : int const DST = -1,
203 : std::string_view const DayType = "",
204 : bool const warmupFlag = false);
205 :
206 : void createYearlyTimeIndexRecord(int const simulationYear, int const curEnvirNum);
207 :
208 : void addSQLiteZoneSizingRecord(std::string_view ZoneName, // the name of the zone
209 : std::string_view LoadType, // the description of the input variable
210 : Real64 const CalcDesLoad, // the value from the sizing calculation [W]
211 : Real64 const UserDesLoad, // the value from the sizing calculation modified by user input [W]
212 : Real64 const CalcDesFlow, // calculated design air flow rate [m3/s]
213 : Real64 const UserDesFlow, // user input or modified design air flow rate [m3/s]
214 : std::string_view DesDayName, // the name of the design day that produced the peak
215 : std::string_view PeakHrMin, // time stamp of the peak
216 : Real64 const PeakTemp, // temperature at peak [C]
217 : Real64 const PeakHumRat, // humidity ratio at peak [kg water/kg dry air]
218 : Real64 const MinOAVolFlow, // zone design minimum outside air flow rate [m3/s]
219 : Real64 const DOASHeatAddRate // zone design heat addition rate from the DOAS [W]
220 : );
221 :
222 : void addSQLiteSystemSizingRecord(std::string_view SysName, // the name of the system
223 : std::string_view LoadType, // either "Cooling" or "Heating"
224 : std::string_view PeakLoadType, // either "Sensible" or "Total"
225 : Real64 const UserDesCap, // User Design Capacity
226 : Real64 const CalcDesVolFlow, // Calculated Cooling Design Air Flow Rate
227 : Real64 const UserDesVolFlow, // User Cooling Design Air Flow Rate
228 : std::string_view DesDayName, // the name of the design day that produced the peak
229 : std::string_view PeakHrMin // time stamp of the peak
230 : );
231 :
232 : void addSQLiteComponentSizingRecord(std::string_view CompType, // the type of the component
233 : std::string_view CompName, // the name of the component
234 : std::string_view VarDesc, // the description of the input variable
235 : Real64 const VarValue // the value from the sizing calculation
236 : );
237 :
238 : void createSQLiteDaylightMapTitle(
239 : int const mapNum, std::string_view mapName, std::string_view environmentName, int const zone, std::string_view refPts, Real64 const zCoord);
240 :
241 : void createSQLiteDaylightMap(int const mapNum,
242 : int const year,
243 : int const month,
244 : int const dayOfMonth,
245 : int const hourOfDay,
246 : int const nX,
247 : Array1D<Real64> const &x,
248 : int const nY,
249 : Array1D<Real64> const &y,
250 : Array2<Real64> const &illuminance);
251 :
252 : void createSQLiteTabularDataRecords(Array2D_string const &body, // row,column
253 : Array1D_string const &rowLabels,
254 : Array1D_string const &columnLabels,
255 : std::string_view ReportName,
256 : std::string_view ReportForString,
257 : std::string_view TableName);
258 :
259 : void createSQLiteSimulationsRecord(int const ID, std::string_view verString, std::string_view currentDateTime);
260 :
261 : void createSQLiteErrorRecord(int const simulationIndex, int const errorType, std::string_view errorMessage, int const cnt);
262 :
263 : void updateSQLiteErrorRecord(std::string const &errorMessage);
264 :
265 : void updateSQLiteSimulationRecord(bool const completed, bool const completedSuccessfully, int const id = 1);
266 :
267 : void updateSQLiteSimulationRecord(int const id, int const numOfTimeStepInHour);
268 :
269 : void createSQLiteEnvironmentPeriodRecord(const int curEnvirNum,
270 : std::string_view environmentName,
271 : const Constant::KindOfSim kindOfSim,
272 : const int simulationIndex = 1);
273 :
274 : void sqliteWriteMessage(std::string_view message);
275 :
276 : void createZoneExtendedOutput();
277 :
278 : void initializeIndexes();
279 :
280 : private:
281 : int createSQLiteStringTableRecord(std::string_view stringValue, int const stringType);
282 :
283 : static void adjustReportingHourAndMinutes(int &hour, int &minutes);
284 : // Given combinedString, parse out units and description.
285 : // Example: Given combinedString "Total Energy [GJ]", return "Total Energy"
286 : // in description and "GJ" in units.
287 : static void parseUnitsAndDescription(std::string_view combinedString, std::string &units, std::string &description);
288 :
289 : static int logicalToInteger(const bool value);
290 :
291 : void initializeReportDataDictionaryTable();
292 : void initializeReportDataTables();
293 : void initializeTimeIndicesTable();
294 : void initializeZoneInfoTable();
295 : void initializeZoneInfoZoneListTable();
296 : void initializeNominalPeopleTable();
297 : void initializeNominalLightingTable();
298 : void initializeNominalElectricEquipmentTable();
299 : void initializeNominalGasEquipmentTable();
300 : void initializeNominalSteamEquipmentTable();
301 : void initializeNominalHotWaterEquipmentTable();
302 : void initializeNominalOtherEquipmentTable();
303 : void initializeNominalBaseboardHeatTable();
304 : void initializeSurfacesTable();
305 : void initializeConstructionsTables();
306 : void initializeMaterialsTable();
307 : void initializeZoneListTable();
308 : void initializeZoneGroupTable();
309 : void initializeNominalInfiltrationTable();
310 : void initializeNominalVentilationTable();
311 : void initializeZoneSizingTable();
312 : void initializeSystemSizingTable();
313 : void initializeComponentSizingTable();
314 : void initializeRoomAirModelTable();
315 : void initializeSchedulesTable();
316 : void initializeDaylightMapTables();
317 : void initializeViews();
318 : void initializeSimulationsTable();
319 : void initializeEnvironmentPeriodsTable();
320 : void initializeErrorsTable();
321 : void initializeTabularDataTable();
322 : void initializeTabularDataView();
323 :
324 : bool m_writeTabularDataToSQLite;
325 : int m_sqlDBTimeIndex;
326 :
327 : int m_hourlyReportIndex = 0;
328 : int m_hourlyDataIndex = 0;
329 : int m_tabularDataIndex = 0;
330 : int m_stringIndex = 1;
331 : std::map<std::pair<std::string, int>, int> m_tabularStrings;
332 : int m_errorIndex = 0;
333 : int m_dataIndex = 0;
334 : int m_extendedDataIndex = 0;
335 : int m_zoneSizingIndex = 0;
336 : int m_systemSizingIndex = 0;
337 : int m_componentSizingIndex = 0;
338 :
339 : sqlite3_stmt *m_reportDataInsertStmt;
340 : sqlite3_stmt *m_reportExtendedDataInsertStmt;
341 : sqlite3_stmt *m_reportDictionaryInsertStmt;
342 : sqlite3_stmt *m_timeIndexInsertStmt;
343 : sqlite3_stmt *m_zoneInfoInsertStmt;
344 : sqlite3_stmt *m_zoneInfoZoneListInsertStmt;
345 : sqlite3_stmt *m_nominalLightingInsertStmt;
346 : sqlite3_stmt *m_nominalElectricEquipmentInsertStmt;
347 : sqlite3_stmt *m_nominalGasEquipmentInsertStmt;
348 : sqlite3_stmt *m_nominalSteamEquipmentInsertStmt;
349 : sqlite3_stmt *m_nominalHotWaterEquipmentInsertStmt;
350 : sqlite3_stmt *m_nominalOtherEquipmentInsertStmt;
351 : sqlite3_stmt *m_nominalBaseboardHeatInsertStmt;
352 : sqlite3_stmt *m_surfaceInsertStmt;
353 : sqlite3_stmt *m_constructionInsertStmt;
354 : sqlite3_stmt *m_constructionLayerInsertStmt;
355 : sqlite3_stmt *m_materialInsertStmt;
356 : sqlite3_stmt *m_zoneListInsertStmt;
357 : sqlite3_stmt *m_zoneGroupInsertStmt;
358 : sqlite3_stmt *m_infiltrationInsertStmt;
359 : sqlite3_stmt *m_ventilationInsertStmt;
360 : sqlite3_stmt *m_nominalPeopleInsertStmt;
361 : sqlite3_stmt *m_zoneSizingInsertStmt;
362 : sqlite3_stmt *m_systemSizingInsertStmt;
363 : sqlite3_stmt *m_componentSizingInsertStmt;
364 : sqlite3_stmt *m_roomAirModelInsertStmt;
365 : sqlite3_stmt *m_groundTemperatureInsertStmt;
366 : sqlite3_stmt *m_weatherFileInsertStmt;
367 : sqlite3_stmt *m_scheduleInsertStmt;
368 : sqlite3_stmt *m_daylightMapTitleInsertStmt;
369 : sqlite3_stmt *m_daylightMapHourlyTitleInsertStmt;
370 : sqlite3_stmt *m_daylightMapHourlyDataInsertStmt;
371 : sqlite3_stmt *m_environmentPeriodInsertStmt;
372 : sqlite3_stmt *m_simulationsInsertStmt;
373 : sqlite3_stmt *m_tabularDataInsertStmt;
374 : sqlite3_stmt *m_stringsInsertStmt;
375 : sqlite3_stmt *m_stringsLookUpStmt;
376 : sqlite3_stmt *m_errorInsertStmt;
377 : sqlite3_stmt *m_errorUpdateStmt;
378 : sqlite3_stmt *m_simulationUpdateStmt;
379 : sqlite3_stmt *m_simulationDataUpdateStmt;
380 : sqlite3_stmt *m_rollbackToSavepointStmt;
381 : sqlite3_stmt *m_createSavepointStmt;
382 : sqlite3_stmt *m_releaseSavepointStmt;
383 :
384 : static const int LocalReportEach; // Write out each time UpdatedataandLocalReport is called
385 : static const int LocalReportTimeStep; // Write out at 'EndTimeStepFlag'
386 : static const int LocalReportHourly; // Write out at 'EndHourFlag'
387 : static const int LocalReportDaily; // Write out at 'EndDayFlag'
388 : static const int LocalReportMonthly; // Write out at end of month (must be determined)
389 : static const int LocalReportSim; // Write out once per environment 'EndEnvrnFlag'
390 : static const int LocalReportYearly; // Write out once per year
391 : static const int ReportNameId;
392 : static const int ReportForStringId;
393 : static const int TableNameId;
394 : static const int RowNameId;
395 : static const int ColumnNameId;
396 : static const int UnitsId;
397 :
398 : class SQLiteData : public SQLiteProcedures
399 : {
400 : protected:
401 : SQLiteData(std::shared_ptr<std::ostream> const &errorStream, std::shared_ptr<sqlite3> const &db);
402 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt) = 0;
403 : };
404 :
405 : class Schedule : SQLiteData
406 : {
407 : public:
408 3336 : Schedule(std::shared_ptr<std::ostream> const &errorStream,
409 : std::shared_ptr<sqlite3> const &db,
410 : int const scheduleNumber,
411 : std::string_view scheduleName,
412 : std::string_view scheduleType,
413 : double const scheduleMinValue,
414 : double const scheduleMaxValue)
415 3336 : : SQLiteData(errorStream, db), number(scheduleNumber), name(scheduleName), type(scheduleType), minValue(scheduleMinValue),
416 3336 : maxValue(scheduleMaxValue)
417 : {
418 3336 : }
419 :
420 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt) override;
421 :
422 : private:
423 : int const number;
424 : std::string const name;
425 : std::string const type;
426 : double const minValue;
427 : double const maxValue;
428 : };
429 :
430 : class Surface : SQLiteData
431 : {
432 : public:
433 13621 : Surface(std::shared_ptr<std::ostream> const &errorStream,
434 : std::shared_ptr<sqlite3> const &db,
435 : int const surfaceNumber,
436 : DataSurfaces::SurfaceData const &surfaceData,
437 : std::string_view surfaceClass)
438 27242 : : SQLiteData(errorStream, db), number(surfaceNumber), name(surfaceData.Name), construction(surfaceData.Construction),
439 13621 : surfaceClass(surfaceClass), area(surfaceData.Area), grossArea(surfaceData.GrossArea), perimeter(surfaceData.Perimeter),
440 13621 : azimuth(surfaceData.Azimuth), height(surfaceData.Height), reveal(surfaceData.Reveal), shape(surfaceData.Shape),
441 13621 : sides(surfaceData.Sides), tilt(surfaceData.Tilt), width(surfaceData.Width), heatTransSurf(surfaceData.HeatTransSurf),
442 13621 : baseSurf(surfaceData.BaseSurf), zone(surfaceData.Zone), extBoundCond(surfaceData.ExtBoundCond), extSolar(surfaceData.ExtSolar),
443 13621 : extWind(surfaceData.ExtWind)
444 : {
445 13621 : }
446 :
447 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt) override;
448 :
449 : private:
450 : int const number;
451 : std::string const &name;
452 : int const &construction;
453 : std::string const surfaceClass;
454 : double const &area;
455 : double const &grossArea;
456 : double const &perimeter;
457 : double const &azimuth;
458 : double const &height;
459 : double const &reveal;
460 : DataSurfaces::SurfaceShape const &shape;
461 : int const &sides;
462 : double const &tilt;
463 : double const &width;
464 : bool const &heatTransSurf;
465 : int const &baseSurf;
466 : int const &zone;
467 : int const &extBoundCond;
468 : bool const &extSolar;
469 : bool const &extWind;
470 : };
471 :
472 : class Zone : SQLiteData
473 : {
474 : public:
475 1506 : Zone(std::shared_ptr<std::ostream> const &errorStream,
476 : std::shared_ptr<sqlite3> const &db,
477 : int const zoneNumber,
478 : DataHeatBalance::ZoneData const &zoneData)
479 3012 : : SQLiteData(errorStream, db), number(zoneNumber), name(zoneData.Name), relNorth(zoneData.RelNorth), originX(zoneData.OriginX),
480 1506 : originY(zoneData.OriginY), originZ(zoneData.OriginZ), centroidX(zoneData.Centroid.x), centroidY(zoneData.Centroid.y),
481 1506 : centroidZ(zoneData.Centroid.z), ofType(zoneData.OfType), multiplier(zoneData.Multiplier), listMultiplier(zoneData.ListMultiplier),
482 1506 : minimumX(zoneData.MinimumX), maximumX(zoneData.MaximumX), minimumY(zoneData.MinimumY), maximumY(zoneData.MaximumY),
483 1506 : minimumZ(zoneData.MinimumZ), maximumZ(zoneData.MaximumZ), ceilingHeight(zoneData.CeilingHeight), volume(zoneData.Volume),
484 1506 : insideConvectionAlgo(zoneData.IntConvAlgo), outsideConvectionAlgo(zoneData.ExtConvAlgo), floorArea(zoneData.FloorArea),
485 1506 : extGrossWallArea(zoneData.ExtGrossWallArea), extNetWallArea(zoneData.ExtNetWallArea), extWindowArea(zoneData.ExtWindowArea),
486 1506 : isPartOfTotalArea(zoneData.isPartOfTotalArea)
487 : {
488 1506 : }
489 :
490 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt) override;
491 :
492 : private:
493 : int const number;
494 : std::string const &name;
495 : double const &relNorth;
496 : double const &originX;
497 : double const &originY;
498 : double const &originZ;
499 : double const ¢roidX;
500 : double const ¢roidY;
501 : double const ¢roidZ;
502 : int const &ofType;
503 : int const &multiplier;
504 : int const &listMultiplier;
505 : double const &minimumX;
506 : double const &maximumX;
507 : double const &minimumY;
508 : double const &maximumY;
509 : double const &minimumZ;
510 : double const &maximumZ;
511 : double const &ceilingHeight;
512 : double const &volume;
513 : Convect::HcInt const &insideConvectionAlgo;
514 : Convect::HcExt const &outsideConvectionAlgo;
515 : double const &floorArea;
516 : double const &extGrossWallArea;
517 : double const &extNetWallArea;
518 : double const &extWindowArea;
519 : bool const &isPartOfTotalArea;
520 : };
521 :
522 : class ZoneList : SQLiteData
523 : {
524 : public:
525 12 : ZoneList(std::shared_ptr<std::ostream> const &errorStream,
526 : std::shared_ptr<sqlite3> const &db,
527 : int const zoneListNumber,
528 : DataHeatBalance::ZoneListData const &zoneListData)
529 12 : : SQLiteData(errorStream, db), number(zoneListNumber), name(zoneListData.Name), zones(zoneListData.Zone)
530 : {
531 12 : }
532 :
533 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt) override;
534 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt, sqlite3_stmt *subInsertStmt);
535 :
536 : private:
537 : int const number;
538 : std::string const &name;
539 : Array1D_int const &zones;
540 : };
541 :
542 : class ZoneGroup : SQLiteData
543 : {
544 : public:
545 3 : ZoneGroup(std::shared_ptr<std::ostream> const &errorStream,
546 : std::shared_ptr<sqlite3> const &db,
547 : int const zoneGroupNumber,
548 : DataHeatBalance::ZoneGroupData const &zoneGroupData)
549 6 : : SQLiteData(errorStream, db), number(zoneGroupNumber), name(zoneGroupData.Name), zoneList(zoneGroupData.ZoneList),
550 3 : multiplier(zoneGroupData.Multiplier)
551 : {
552 3 : }
553 :
554 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt) override;
555 :
556 : private:
557 : int const number;
558 : std::string const &name;
559 : int const &zoneList;
560 : int const &multiplier;
561 : };
562 :
563 : class Material : SQLiteData
564 : {
565 : public:
566 1892 : Material(std::shared_ptr<std::ostream> const &errorStream,
567 : std::shared_ptr<sqlite3> const &db,
568 : int const materialNumber,
569 : EnergyPlus::Material::MaterialBase const *materialData)
570 3784 : : SQLiteData(errorStream, db), number(materialNumber), name(materialData->Name), group(materialData->group),
571 1892 : roughness(materialData->Roughness), conductivity(materialData->Conductivity), density(materialData->Density),
572 1892 : isoMoistCap(materialData->IsoMoistCap), porosity(materialData->Porosity), resistance(materialData->Resistance),
573 1892 : rOnly(materialData->ROnly), specHeat(materialData->SpecHeat), thermGradCoef(materialData->ThermGradCoef),
574 1892 : thickness(materialData->Thickness), vaporDiffus(materialData->VaporDiffus)
575 : {
576 1892 : }
577 :
578 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt) override;
579 :
580 : private:
581 : int const number;
582 : std::string const &name;
583 : EnergyPlus::Material::Group const &group;
584 : EnergyPlus::Material::SurfaceRoughness const &roughness;
585 : double const &conductivity;
586 : double const &density;
587 : double const &isoMoistCap;
588 : double const &porosity;
589 : double const &resistance;
590 : bool const &rOnly;
591 : double const &specHeat;
592 : double const &thermGradCoef;
593 : double const &thickness;
594 : double const &vaporDiffus;
595 : };
596 :
597 : class Construction : SQLiteData
598 : {
599 : public:
600 898 : Construction(std::shared_ptr<std::ostream> const &errorStream,
601 : std::shared_ptr<sqlite3> const &db,
602 : int const constructionNumber,
603 : EnergyPlus::Construction::ConstructionProps const &constructionData,
604 : double const &constructionUValue)
605 1796 : : SQLiteData(errorStream, db), number(constructionNumber), name(constructionData.Name), totLayers(constructionData.TotLayers),
606 898 : totSolidLayers(constructionData.TotSolidLayers), totGlassLayers(constructionData.TotGlassLayers),
607 898 : insideAbsorpVis(constructionData.InsideAbsorpVis), outsideAbsorpVis(constructionData.OutsideAbsorpVis),
608 898 : insideAbsorpSolar(constructionData.InsideAbsorpSolar), outsideAbsorpSolar(constructionData.OutsideAbsorpSolar),
609 898 : insideAbsorpThermal(constructionData.InsideAbsorpThermal), outsideAbsorpThermal(constructionData.OutsideAbsorpThermal),
610 898 : outsideRoughness(constructionData.OutsideRoughness), typeIsWindow(constructionData.TypeIsWindow), uValue(constructionUValue)
611 : {
612 2833 : for (int layerNum = 1; layerNum <= constructionData.TotLayers; ++layerNum) {
613 1935 : constructionLayers.push_back(std::unique_ptr<Construction::ConstructionLayer>(
614 1935 : new ConstructionLayer(m_errorStream, m_db, number, layerNum, constructionData.LayerPoint(layerNum))));
615 : }
616 898 : }
617 :
618 : // only inserts construction
619 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt) override;
620 : // inserts construction and construction layers
621 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt, sqlite3_stmt *subInsertStmt);
622 :
623 : private:
624 : int const number;
625 : std::string const &name;
626 : int const &totLayers;
627 : int const &totSolidLayers;
628 : int const &totGlassLayers;
629 : double const &insideAbsorpVis;
630 : double const &outsideAbsorpVis;
631 : double const &insideAbsorpSolar;
632 : double const &outsideAbsorpSolar;
633 : double const &insideAbsorpThermal;
634 : double const &outsideAbsorpThermal;
635 : EnergyPlus::Material::SurfaceRoughness const &outsideRoughness;
636 : bool const &typeIsWindow;
637 : double const &uValue;
638 :
639 : class ConstructionLayer : SQLiteData
640 : {
641 : public:
642 1935 : ConstructionLayer(std::shared_ptr<std::ostream> const &errorStream,
643 : std::shared_ptr<sqlite3> const &db,
644 : int const &constructNumber,
645 : int const layerNumber,
646 : int const &layerPoint)
647 1935 : : SQLiteData(errorStream, db), constructNumber(constructNumber), layerNumber(layerNumber), layerPoint(layerPoint)
648 : {
649 1935 : }
650 :
651 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt) override;
652 :
653 : private:
654 : int const &constructNumber;
655 : int const layerNumber;
656 : int const &layerPoint;
657 : };
658 :
659 : std::vector<std::unique_ptr<Construction::ConstructionLayer>> constructionLayers;
660 : };
661 :
662 : class NominalLighting : SQLiteData
663 : {
664 : public:
665 1398 : NominalLighting(std::shared_ptr<std::ostream> const &errorStream,
666 : std::shared_ptr<sqlite3> const &db,
667 : int const nominalLightingNumber,
668 : DataHeatBalance::LightsData const &nominalLightingData)
669 2796 : : SQLiteData(errorStream, db), number(nominalLightingNumber), name(nominalLightingData.Name), zonePtr(nominalLightingData.ZonePtr),
670 1398 : schedulePtr(nominalLightingData.SchedPtr), designLevel(nominalLightingData.DesignLevel),
671 1398 : fractionReturnAir(nominalLightingData.FractionReturnAir), fractionRadiant(nominalLightingData.FractionRadiant),
672 1398 : fractionShortWave(nominalLightingData.FractionShortWave), fractionReplaceable(nominalLightingData.FractionReplaceable),
673 1398 : fractionConvected(nominalLightingData.FractionConvected), endUseSubcategory(nominalLightingData.EndUseSubcategory)
674 : {
675 1398 : }
676 :
677 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt) override;
678 :
679 : private:
680 : int const number;
681 : std::string const &name;
682 : int const &zonePtr;
683 : int const &schedulePtr;
684 : double const &designLevel;
685 : double const &fractionReturnAir;
686 : double const &fractionRadiant;
687 : double const &fractionShortWave;
688 : double const &fractionReplaceable;
689 : double const &fractionConvected;
690 : std::string const &endUseSubcategory;
691 : };
692 :
693 : class NominalPeople : SQLiteData
694 : {
695 : public:
696 1226 : NominalPeople(std::shared_ptr<std::ostream> const &errorStream,
697 : std::shared_ptr<sqlite3> const &db,
698 : int const nominalPeopleNumber,
699 : DataHeatBalance::PeopleData const &nominalPeopleData)
700 2452 : : SQLiteData(errorStream, db), number(nominalPeopleNumber), name(nominalPeopleData.Name), zonePtr(nominalPeopleData.ZonePtr),
701 1226 : numberOfPeople(nominalPeopleData.NumberOfPeople), numberOfPeoplePtr(nominalPeopleData.NumberOfPeoplePtr),
702 1226 : activityLevelPtr(nominalPeopleData.ActivityLevelPtr), fractionRadiant(nominalPeopleData.FractionRadiant),
703 1226 : fractionConvected(nominalPeopleData.FractionConvected), workEffPtr(nominalPeopleData.WorkEffPtr),
704 1226 : clothingPtr(nominalPeopleData.ClothingPtr), airVelocityPtr(nominalPeopleData.AirVelocityPtr), fanger(nominalPeopleData.Fanger),
705 1226 : pierce(nominalPeopleData.Pierce), ksu(nominalPeopleData.KSU), mrtCalcType(nominalPeopleData.MRTCalcType),
706 1226 : surfacePtr(nominalPeopleData.SurfacePtr), angleFactorListName(nominalPeopleData.AngleFactorListName),
707 1226 : angleFactorListPtr(nominalPeopleData.AngleFactorListPtr), userSpecSensFrac(nominalPeopleData.UserSpecSensFrac),
708 1226 : show55Warning(nominalPeopleData.Show55Warning)
709 : {
710 1226 : }
711 :
712 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt) override;
713 :
714 : private:
715 : int const number;
716 : std::string const &name;
717 : int const &zonePtr;
718 : double const &numberOfPeople;
719 : int const &numberOfPeoplePtr;
720 : int const &activityLevelPtr;
721 : double const &fractionRadiant;
722 : double const &fractionConvected;
723 : int const &workEffPtr;
724 : int const &clothingPtr;
725 : int const &airVelocityPtr;
726 : bool const &fanger;
727 : bool const &pierce;
728 : bool const &ksu;
729 : DataHeatBalance::CalcMRT const &mrtCalcType;
730 : int const &surfacePtr;
731 : std::string const &angleFactorListName;
732 : int const &angleFactorListPtr;
733 : double const &userSpecSensFrac;
734 : bool const &show55Warning;
735 : };
736 :
737 : class NominalElectricEquipment : SQLiteData
738 : {
739 : public:
740 1344 : NominalElectricEquipment(std::shared_ptr<std::ostream> const &errorStream,
741 : std::shared_ptr<sqlite3> const &db,
742 : int const nominalElectricEquipmentNumber,
743 : DataHeatBalance::ZoneEquipData const &nominalElectricEquipmentData)
744 2688 : : SQLiteData(errorStream, db), number(nominalElectricEquipmentNumber), name(nominalElectricEquipmentData.Name),
745 1344 : zonePtr(nominalElectricEquipmentData.ZonePtr), schedulePtr(nominalElectricEquipmentData.SchedPtr),
746 1344 : designLevel(nominalElectricEquipmentData.DesignLevel), fractionLatent(nominalElectricEquipmentData.FractionLatent),
747 1344 : fractionRadiant(nominalElectricEquipmentData.FractionRadiant), fractionLost(nominalElectricEquipmentData.FractionLost),
748 1344 : fractionConvected(nominalElectricEquipmentData.FractionConvected), endUseSubcategory(nominalElectricEquipmentData.EndUseSubcategory)
749 : {
750 1344 : }
751 :
752 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt) override;
753 :
754 : private:
755 : int const number;
756 : std::string const &name;
757 : int const &zonePtr;
758 : int const &schedulePtr;
759 : double const &designLevel;
760 : double const &fractionLatent;
761 : double const &fractionRadiant;
762 : double const &fractionLost;
763 : double const &fractionConvected;
764 : std::string const &endUseSubcategory;
765 : };
766 :
767 : class NominalGasEquipment : SQLiteData
768 : {
769 : public:
770 31 : NominalGasEquipment(std::shared_ptr<std::ostream> const &errorStream,
771 : std::shared_ptr<sqlite3> const &db,
772 : int const nominalGasEquipmentNumber,
773 : DataHeatBalance::ZoneEquipData const &nominalGasEquipmentData)
774 62 : : SQLiteData(errorStream, db), number(nominalGasEquipmentNumber), name(nominalGasEquipmentData.Name),
775 31 : zonePtr(nominalGasEquipmentData.ZonePtr), schedulePtr(nominalGasEquipmentData.SchedPtr),
776 31 : designLevel(nominalGasEquipmentData.DesignLevel), fractionLatent(nominalGasEquipmentData.FractionLatent),
777 31 : fractionRadiant(nominalGasEquipmentData.FractionRadiant), fractionLost(nominalGasEquipmentData.FractionLost),
778 31 : fractionConvected(nominalGasEquipmentData.FractionConvected), endUseSubcategory(nominalGasEquipmentData.EndUseSubcategory)
779 : {
780 31 : }
781 :
782 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt) override;
783 :
784 : private:
785 : int const number;
786 : std::string const &name;
787 : int const &zonePtr;
788 : int const &schedulePtr;
789 : double const &designLevel;
790 : double const &fractionLatent;
791 : double const &fractionRadiant;
792 : double const &fractionLost;
793 : double const &fractionConvected;
794 : std::string const &endUseSubcategory;
795 : };
796 :
797 : class NominalSteamEquipment : SQLiteData
798 : {
799 : public:
800 0 : NominalSteamEquipment(std::shared_ptr<std::ostream> const &errorStream,
801 : std::shared_ptr<sqlite3> const &db,
802 : int const nominalSteamEquipmentNumber,
803 : DataHeatBalance::ZoneEquipData const &nominalSteamEquipmentData)
804 0 : : SQLiteData(errorStream, db), number(nominalSteamEquipmentNumber), name(nominalSteamEquipmentData.Name),
805 0 : zonePtr(nominalSteamEquipmentData.ZonePtr), schedulePtr(nominalSteamEquipmentData.SchedPtr),
806 0 : designLevel(nominalSteamEquipmentData.DesignLevel), fractionLatent(nominalSteamEquipmentData.FractionLatent),
807 0 : fractionRadiant(nominalSteamEquipmentData.FractionRadiant), fractionLost(nominalSteamEquipmentData.FractionLost),
808 0 : fractionConvected(nominalSteamEquipmentData.FractionConvected), endUseSubcategory(nominalSteamEquipmentData.EndUseSubcategory)
809 : {
810 0 : }
811 :
812 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt) override;
813 :
814 : private:
815 : int const number;
816 : std::string const &name;
817 : int const &zonePtr;
818 : int const &schedulePtr;
819 : double const &designLevel;
820 : double const &fractionLatent;
821 : double const &fractionRadiant;
822 : double const &fractionLost;
823 : double const &fractionConvected;
824 : std::string const &endUseSubcategory;
825 : };
826 :
827 : class NominalHotWaterEquipment : SQLiteData
828 : {
829 : public:
830 9 : NominalHotWaterEquipment(std::shared_ptr<std::ostream> const &errorStream,
831 : std::shared_ptr<sqlite3> const &db,
832 : int const nominalHotWaterEquipmentNumber,
833 : DataHeatBalance::ZoneEquipData const &nominalHotWaterEquipmentData)
834 18 : : SQLiteData(errorStream, db), number(nominalHotWaterEquipmentNumber), name(nominalHotWaterEquipmentData.Name),
835 9 : zonePtr(nominalHotWaterEquipmentData.ZonePtr), schedulePtr(nominalHotWaterEquipmentData.SchedPtr),
836 9 : designLevel(nominalHotWaterEquipmentData.DesignLevel), fractionLatent(nominalHotWaterEquipmentData.FractionLatent),
837 9 : fractionRadiant(nominalHotWaterEquipmentData.FractionRadiant), fractionLost(nominalHotWaterEquipmentData.FractionLost),
838 9 : fractionConvected(nominalHotWaterEquipmentData.FractionConvected), endUseSubcategory(nominalHotWaterEquipmentData.EndUseSubcategory)
839 : {
840 9 : }
841 :
842 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt) override;
843 :
844 : private:
845 : int const number;
846 : std::string const &name;
847 : int const &zonePtr;
848 : int const &schedulePtr;
849 : double const &designLevel;
850 : double const &fractionLatent;
851 : double const &fractionRadiant;
852 : double const &fractionLost;
853 : double const &fractionConvected;
854 : std::string const &endUseSubcategory;
855 : };
856 :
857 : class NominalOtherEquipment : SQLiteData
858 : {
859 : public:
860 19 : NominalOtherEquipment(std::shared_ptr<std::ostream> const &errorStream,
861 : std::shared_ptr<sqlite3> const &db,
862 : int const nominalOtherEquipmentNumber,
863 : DataHeatBalance::ZoneEquipData const &nominalOtherEquipmentData)
864 38 : : SQLiteData(errorStream, db), number(nominalOtherEquipmentNumber), name(nominalOtherEquipmentData.Name),
865 19 : zonePtr(nominalOtherEquipmentData.ZonePtr), schedulePtr(nominalOtherEquipmentData.SchedPtr),
866 19 : designLevel(nominalOtherEquipmentData.DesignLevel), fractionLatent(nominalOtherEquipmentData.FractionLatent),
867 19 : fractionRadiant(nominalOtherEquipmentData.FractionRadiant), fractionLost(nominalOtherEquipmentData.FractionLost),
868 19 : fractionConvected(nominalOtherEquipmentData.FractionConvected), endUseSubcategory(nominalOtherEquipmentData.EndUseSubcategory)
869 : {
870 19 : }
871 :
872 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt) override;
873 :
874 : private:
875 : int const number;
876 : std::string const &name;
877 : int const &zonePtr;
878 : int const &schedulePtr;
879 : double const &designLevel;
880 : double const &fractionLatent;
881 : double const &fractionRadiant;
882 : double const &fractionLost;
883 : double const &fractionConvected;
884 : std::string const &endUseSubcategory;
885 : };
886 :
887 : class NominalBaseboardHeat : SQLiteData
888 : {
889 : public:
890 0 : NominalBaseboardHeat(std::shared_ptr<std::ostream> const &errorStream,
891 : std::shared_ptr<sqlite3> const &db,
892 : int const nominalBaseboardHeatNumber,
893 : DataHeatBalance::BBHeatData const &nominalBaseboardHeatData)
894 0 : : SQLiteData(errorStream, db), number(nominalBaseboardHeatNumber), name(nominalBaseboardHeatData.Name),
895 0 : zonePtr(nominalBaseboardHeatData.ZonePtr), schedPtr(nominalBaseboardHeatData.SchedPtr),
896 0 : capatLowTemperature(nominalBaseboardHeatData.CapatLowTemperature), lowTemperature(nominalBaseboardHeatData.LowTemperature),
897 0 : capatHighTemperature(nominalBaseboardHeatData.CapatHighTemperature), highTemperature(nominalBaseboardHeatData.HighTemperature),
898 0 : fractionRadiant(nominalBaseboardHeatData.FractionRadiant), fractionConvected(nominalBaseboardHeatData.FractionConvected),
899 0 : endUseSubcategory(nominalBaseboardHeatData.EndUseSubcategory)
900 : {
901 0 : }
902 :
903 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt) override;
904 :
905 : private:
906 : int const number;
907 : std::string const &name;
908 : int const &zonePtr;
909 : int const &schedPtr;
910 : double const &capatLowTemperature;
911 : double const &lowTemperature;
912 : double const &capatHighTemperature;
913 : double const &highTemperature;
914 : double const &fractionRadiant;
915 : double const &fractionConvected;
916 : std::string const &endUseSubcategory;
917 : };
918 :
919 : class Infiltration : SQLiteData
920 : {
921 : public:
922 1175 : Infiltration(std::shared_ptr<std::ostream> const &errorStream,
923 : std::shared_ptr<sqlite3> const &db,
924 : int const infiltrationNumber,
925 : DataHeatBalance::InfiltrationData const &infiltrationData)
926 2350 : : SQLiteData(errorStream, db), number(infiltrationNumber), name(infiltrationData.Name), zonePtr(infiltrationData.ZonePtr),
927 1175 : schedPtr(infiltrationData.SchedPtr), designLevel(infiltrationData.DesignLevel)
928 : {
929 1175 : }
930 :
931 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt) override;
932 :
933 : private:
934 : int const number;
935 : std::string const &name;
936 : int const &zonePtr;
937 : int const &schedPtr;
938 : double const &designLevel;
939 : };
940 :
941 : class Ventilation : SQLiteData
942 : {
943 : public:
944 8 : Ventilation(std::shared_ptr<std::ostream> const &errorStream,
945 : std::shared_ptr<sqlite3> const &db,
946 : int const ventilationNumber,
947 : DataHeatBalance::VentilationData const &ventilationData)
948 16 : : SQLiteData(errorStream, db), number(ventilationNumber), name(ventilationData.Name), zonePtr(ventilationData.ZonePtr),
949 8 : schedPtr(ventilationData.SchedPtr), designLevel(ventilationData.DesignLevel)
950 : {
951 8 : }
952 :
953 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt) override;
954 :
955 : private:
956 : int const number;
957 : std::string const &name;
958 : int const &zonePtr;
959 : int const &schedPtr;
960 : double const &designLevel;
961 : };
962 :
963 : class RoomAirModel : SQLiteData
964 : {
965 : public:
966 1506 : RoomAirModel(std::shared_ptr<std::ostream> const &errorStream,
967 : std::shared_ptr<sqlite3> const &db,
968 : int const roomAirModelNumber,
969 : RoomAir::AirModelData const &roomAirModelData)
970 3012 : : SQLiteData(errorStream, db), number(roomAirModelNumber), airModelName(roomAirModelData.Name), airModel(roomAirModelData.AirModel),
971 1506 : tempCoupleScheme(roomAirModelData.TempCoupleScheme), simAirModel(roomAirModelData.SimAirModel)
972 : {
973 1506 : }
974 :
975 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt) override;
976 :
977 : private:
978 : int const number;
979 : std::string const &airModelName;
980 : RoomAir::RoomAirModel const &airModel;
981 : RoomAir::CouplingScheme const &tempCoupleScheme;
982 : bool const &simAirModel;
983 : };
984 :
985 : std::vector<std::unique_ptr<SQLite::Zone>> zones;
986 : std::vector<std::unique_ptr<SQLite::ZoneList>> zoneLists;
987 : std::vector<std::unique_ptr<SQLite::ZoneGroup>> zoneGroups;
988 : std::vector<std::unique_ptr<SQLite::Schedule>> schedules;
989 : std::vector<std::unique_ptr<SQLite::Surface>> surfaces;
990 : std::vector<std::unique_ptr<SQLite::Material>> materials;
991 : std::vector<std::unique_ptr<SQLite::Construction>> constructions;
992 : std::vector<std::unique_ptr<SQLite::NominalLighting>> nominalLightings;
993 : std::vector<std::unique_ptr<SQLite::NominalPeople>> nominalPeoples;
994 : std::vector<std::unique_ptr<SQLite::NominalElectricEquipment>> nominalElectricEquipments;
995 : std::vector<std::unique_ptr<SQLite::NominalGasEquipment>> nominalGasEquipments;
996 : std::vector<std::unique_ptr<SQLite::NominalSteamEquipment>> nominalSteamEquipments;
997 : std::vector<std::unique_ptr<SQLite::NominalHotWaterEquipment>> nominalHotWaterEquipments;
998 : std::vector<std::unique_ptr<SQLite::NominalOtherEquipment>> nominalOtherEquipments;
999 : std::vector<std::unique_ptr<SQLite::NominalBaseboardHeat>> nominalBaseboardHeats;
1000 : std::vector<std::unique_ptr<SQLite::Infiltration>> infiltrations;
1001 : std::vector<std::unique_ptr<SQLite::Ventilation>> ventilations;
1002 : std::vector<std::unique_ptr<SQLite::RoomAirModel>> roomAirModels;
1003 : };
1004 :
1005 : bool ParseSQLiteInput(EnergyPlusData &state, bool &writeOutputToSQLite, bool &writeTabularDataToSQLite);
1006 :
1007 : std::unique_ptr<SQLite> CreateSQLiteDatabase(EnergyPlusData &state);
1008 :
1009 : void CreateSQLiteZoneExtendedOutput(EnergyPlusData &state);
1010 :
1011 : struct SQLiteProceduresData : BaseGlobalStruct
1012 : {
1013 : std::unique_ptr<SQLite> sqlite;
1014 796 : void init_state([[maybe_unused]] EnergyPlusData &state) override
1015 : {
1016 796 : }
1017 :
1018 0 : void clear_state() override
1019 : {
1020 0 : sqlite.reset(); // probably not necessary, as it is recreated in ManageSimulation, but it should be fine to delete it here
1021 0 : }
1022 : };
1023 :
1024 : } // namespace EnergyPlus
1025 :
1026 : #endif
|
