Line data Source code
1 : // EnergyPlus, Copyright (c) 1996-2023, 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 : #include <ObjexxFCL/Optional.hh>
62 :
63 : // EnergyPlus Headers
64 : #include <EnergyPlus/Construction.hh>
65 : #include <EnergyPlus/Data/BaseData.hh>
66 : #include <EnergyPlus/DataHeatBalance.hh>
67 : #include <EnergyPlus/DataRoomAirModel.hh>
68 : #include <EnergyPlus/EnergyPlus.hh>
69 : #include <EnergyPlus/FileSystem.hh>
70 : #include <EnergyPlus/Material.hh>
71 :
72 : namespace EnergyPlus {
73 :
74 : // Forward
75 : struct EnergyPlusData;
76 :
77 27034 : 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(const std::string &commandBuffer);
87 : int sqlitePrepareStatement(sqlite3_stmt *&stmt, const std::string &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 : sqlite3 *m_connection;
108 : std::shared_ptr<sqlite3> m_db;
109 : };
110 :
111 : class SQLite : SQLiteProcedures
112 : {
113 : public:
114 : // Friend SQLiteFixture which is the gtest fixture class for testing SQLite
115 : // This allows for testing of private methods in SQLite
116 : friend class SQLiteFixture;
117 :
118 : void addScheduleData(int const number, std::string const &name, std::string const &type, double const minValue, double const maxValue);
119 : void addZoneData(int const number, DataHeatBalance::ZoneData const &zoneData);
120 : void addZoneListData(int const number, DataHeatBalance::ZoneListData const &zoneListData);
121 : void addSurfaceData(int const number, DataSurfaces::SurfaceData const &surfaceData, std::string const &surfaceClass);
122 : void addZoneGroupData(int const number, DataHeatBalance::ZoneGroupData const &zoneGroupData);
123 : void addMaterialData(int const number, Material::MaterialProperties const &materialData);
124 : void addConstructionData(int const number, Construction::ConstructionProps const &constructionData, double const &constructionUValue);
125 : void addNominalLightingData(int const number, DataHeatBalance::LightsData const &nominalLightingData);
126 : void addNominalPeopleData(int const number, DataHeatBalance::PeopleData const &nominalPeopleData);
127 : void addNominalElectricEquipmentData(int const number, DataHeatBalance::ZoneEquipData const &nominalElectricEquipmentData);
128 : void addNominalGasEquipmentData(int const number, DataHeatBalance::ZoneEquipData const &nominalGasEquipmentData);
129 : void addNominalSteamEquipmentData(int const number, DataHeatBalance::ZoneEquipData const &nominalSteamEquipmentData);
130 : void addNominalHotWaterEquipmentData(int const number, DataHeatBalance::ZoneEquipData const &nominalHotWaterEquipmentData);
131 : void addNominalOtherEquipmentData(int const number, DataHeatBalance::ZoneEquipData const &nominalOtherEquipmentData);
132 : void addNominalBaseboardData(int const number, DataHeatBalance::BBHeatData const &nominalBaseboardData);
133 : void addInfiltrationData(int const number, DataHeatBalance::InfiltrationData const &infiltrationData);
134 : void addVentilationData(int const number, DataHeatBalance::VentilationData const &ventilationData);
135 : void addRoomAirModelData(int const number, DataRoomAirModel::AirModelData const &roomAirModelData);
136 :
137 : // Open the DB and prepare for writing data
138 : // Create all of the tables on construction
139 : SQLite(std::shared_ptr<std::ostream> errorStream,
140 : fs::path const &dbName,
141 : fs::path const &errorFilePath,
142 : bool writeOutputToSQLite = false,
143 : bool writeTabularDataToSQLite = false);
144 :
145 : // Close database and free prepared statements
146 : virtual ~SQLite();
147 :
148 : bool writeOutputToSQLite() const;
149 : bool writeTabularDataToSQLite() const;
150 :
151 : // Begin a transaction
152 : void sqliteBegin();
153 :
154 : // Commit a transaction
155 : void sqliteCommit();
156 :
157 : // Rollback a transaction (cancel)
158 : void sqliteRollback();
159 :
160 : // Within a current transaction
161 : bool sqliteWithinTransaction();
162 :
163 : void createSQLiteReportDictionaryRecord(int const reportVariableReportID,
164 : int const storeTypeIndex,
165 : std::string const &indexGroup,
166 : std::string_view keyedValueString,
167 : std::string_view const variableName,
168 : int const indexType,
169 : std::string const &units,
170 : int const reportingFreq,
171 : bool isMeter,
172 : std::string_view const ScheduleName = {});
173 :
174 : void createSQLiteReportDataRecord(int const recordIndex,
175 : Real64 const value,
176 : Optional_int_const reportingInterval = _,
177 : Optional<Real64 const> minValue = _,
178 : Optional_int_const minValueDate = _,
179 : Optional<Real64 const> maxValue = _,
180 : Optional_int_const maxValueDate = _,
181 : Optional_int_const minutesPerTimeStep = _);
182 :
183 : void createSQLiteTimeIndexRecord(int const reportingInterval,
184 : int const recordIndex,
185 : int const CumlativeSimulationDays,
186 : int const curEnvirNum,
187 : int const simulationYear,
188 : Optional_int_const Month = _,
189 : Optional_int_const DayOfMonth = _,
190 : Optional_int_const Hour = _,
191 : Optional<Real64 const> EndMinute = _,
192 : Optional<Real64 const> StartMinute = _,
193 : Optional_int_const DST = _,
194 : Optional_string_const DayType = _,
195 : bool const warmupFlag = false);
196 :
197 : void createYearlyTimeIndexRecord(int const simulationYear, int const curEnvirNum);
198 :
199 : void addSQLiteZoneSizingRecord(std::string const &ZoneName, // the name of the zone
200 : std::string const &LoadType, // the description of the input variable
201 : Real64 const CalcDesLoad, // the value from the sizing calculation [W]
202 : Real64 const UserDesLoad, // the value from the sizing calculation modified by user input [W]
203 : Real64 const CalcDesFlow, // calculated design air flow rate [m3/s]
204 : Real64 const UserDesFlow, // user input or modified design air flow rate [m3/s]
205 : std::string const &DesDayName, // the name of the design day that produced the peak
206 : std::string const &PeakHrMin, // time stamp of the peak
207 : Real64 const PeakTemp, // temperature at peak [C]
208 : Real64 const PeakHumRat, // humidity ratio at peak [kg water/kg dry air]
209 : Real64 const MinOAVolFlow, // zone design minimum outside air flow rate [m3/s]
210 : Real64 const DOASHeatAddRate // zone design heat addition rate from the DOAS [W]
211 : );
212 :
213 : void addSQLiteSystemSizingRecord(std::string const &SysName, // the name of the system
214 : std::string const &LoadType, // either "Cooling" or "Heating"
215 : std::string const &PeakLoadType, // either "Sensible" or "Total"
216 : Real64 const &UserDesCap, // User Design Capacity
217 : Real64 const &CalcDesVolFlow, // Calculated Cooling Design Air Flow Rate
218 : Real64 const &UserDesVolFlow, // User Cooling Design Air Flow Rate
219 : std::string const &DesDayName, // the name of the design day that produced the peak
220 : std::string const &PeakHrMin // time stamp of the peak
221 : );
222 :
223 : void addSQLiteComponentSizingRecord(std::string_view CompType, // the type of the component
224 : std::string_view CompName, // the name of the component
225 : std::string_view VarDesc, // the description of the input variable
226 : Real64 const VarValue // the value from the sizing calculation
227 : );
228 :
229 : void createSQLiteDaylightMapTitle(int const mapNum,
230 : std::string const &mapName,
231 : std::string const &environmentName,
232 : int const zone,
233 : std::string const &refPts,
234 : Real64 const zCoord);
235 :
236 : void createSQLiteDaylightMap(int const mapNum,
237 : int const year,
238 : int const month,
239 : int const dayOfMonth,
240 : int const hourOfDay,
241 : int const nX,
242 : Array1D<Real64> const &x,
243 : int const nY,
244 : Array1D<Real64> const &y,
245 : Array2<Real64> const &illuminance);
246 :
247 : void createSQLiteTabularDataRecords(Array2D_string const &body, // row,column
248 : Array1D_string const &rowLabels,
249 : Array1D_string const &columnLabels,
250 : std::string const &ReportName,
251 : std::string const &ReportForString,
252 : std::string const &TableName);
253 :
254 : void createSQLiteSimulationsRecord(int const ID, const std::string &verString, const std::string ¤tDateTime);
255 :
256 : void createSQLiteErrorRecord(int const simulationIndex, int const errorType, std::string const &errorMessage, int const cnt);
257 :
258 : void updateSQLiteErrorRecord(std::string const &errorMessage);
259 :
260 : void updateSQLiteSimulationRecord(bool const completed, bool const completedSuccessfully, int const id = 1);
261 :
262 : void updateSQLiteSimulationRecord(int const id, int const numOfTimeStepInHour);
263 :
264 : void createSQLiteEnvironmentPeriodRecord(const int curEnvirNum,
265 : const std::string &environmentName,
266 : const DataGlobalConstants::KindOfSim kindOfSim,
267 : const int simulationIndex = 1);
268 :
269 : void sqliteWriteMessage(const std::string &message);
270 :
271 : void createZoneExtendedOutput();
272 :
273 : void initializeIndexes();
274 :
275 : private:
276 : int createSQLiteStringTableRecord(std::string const &stringValue, int const stringType);
277 :
278 : static std::string storageType(const int storageTypeIndex);
279 : static std::string timestepTypeName(const int timestepType);
280 : static std::string reportingFreqName(const int reportingFreqIndex);
281 :
282 : static void adjustReportingHourAndMinutes(int &hour, int &minutes);
283 : // Given combinedString, parse out units and description.
284 : // Example: Given combinedString "Total Energy [GJ]", return "Total Energy"
285 : // in description and "GJ" in units.
286 : static void parseUnitsAndDescription(std::string_view combinedString, std::string &units, std::string &description);
287 :
288 : static int logicalToInteger(const bool value);
289 :
290 : void initializeReportDataDictionaryTable();
291 : void initializeReportDataTables();
292 : void initializeTimeIndicesTable();
293 : void initializeZoneInfoTable();
294 : void initializeZoneInfoZoneListTable();
295 : void initializeNominalPeopleTable();
296 : void initializeNominalLightingTable();
297 : void initializeNominalElectricEquipmentTable();
298 : void initializeNominalGasEquipmentTable();
299 : void initializeNominalSteamEquipmentTable();
300 : void initializeNominalHotWaterEquipmentTable();
301 : void initializeNominalOtherEquipmentTable();
302 : void initializeNominalBaseboardHeatTable();
303 : void initializeSurfacesTable();
304 : void initializeConstructionsTables();
305 : void initializeMaterialsTable();
306 : void initializeZoneListTable();
307 : void initializeZoneGroupTable();
308 : void initializeNominalInfiltrationTable();
309 : void initializeNominalVentilationTable();
310 : void initializeZoneSizingTable();
311 : void initializeSystemSizingTable();
312 : void initializeComponentSizingTable();
313 : void initializeRoomAirModelTable();
314 : void initializeSchedulesTable();
315 : void initializeDaylightMapTables();
316 : void initializeViews();
317 : void initializeSimulationsTable();
318 : void initializeEnvironmentPeriodsTable();
319 : void initializeErrorsTable();
320 : void initializeTabularDataTable();
321 : void initializeTabularDataView();
322 :
323 : bool m_writeTabularDataToSQLite;
324 : int m_sqlDBTimeIndex;
325 :
326 : int m_hourlyReportIndex = 0;
327 : int m_hourlyDataIndex = 0;
328 : int m_tabularDataIndex = 0;
329 : int m_stringIndex = 1;
330 : std::map<std::pair<std::string, int>, int> m_tabularStrings;
331 : int m_errorIndex = 0;
332 : int m_dataIndex = 0;
333 : int m_extendedDataIndex = 0;
334 : int m_zoneSizingIndex = 0;
335 : int m_systemSizingIndex = 0;
336 : int m_componentSizingIndex = 0;
337 :
338 : sqlite3_stmt *m_reportDataInsertStmt;
339 : sqlite3_stmt *m_reportExtendedDataInsertStmt;
340 : sqlite3_stmt *m_reportDictionaryInsertStmt;
341 : sqlite3_stmt *m_timeIndexInsertStmt;
342 : sqlite3_stmt *m_zoneInfoInsertStmt;
343 : sqlite3_stmt *m_zoneInfoZoneListInsertStmt;
344 : sqlite3_stmt *m_nominalLightingInsertStmt;
345 : sqlite3_stmt *m_nominalElectricEquipmentInsertStmt;
346 : sqlite3_stmt *m_nominalGasEquipmentInsertStmt;
347 : sqlite3_stmt *m_nominalSteamEquipmentInsertStmt;
348 : sqlite3_stmt *m_nominalHotWaterEquipmentInsertStmt;
349 : sqlite3_stmt *m_nominalOtherEquipmentInsertStmt;
350 : sqlite3_stmt *m_nominalBaseboardHeatInsertStmt;
351 : sqlite3_stmt *m_surfaceInsertStmt;
352 : sqlite3_stmt *m_constructionInsertStmt;
353 : sqlite3_stmt *m_constructionLayerInsertStmt;
354 : sqlite3_stmt *m_materialInsertStmt;
355 : sqlite3_stmt *m_zoneListInsertStmt;
356 : sqlite3_stmt *m_zoneGroupInsertStmt;
357 : sqlite3_stmt *m_infiltrationInsertStmt;
358 : sqlite3_stmt *m_ventilationInsertStmt;
359 : sqlite3_stmt *m_nominalPeopleInsertStmt;
360 : sqlite3_stmt *m_zoneSizingInsertStmt;
361 : sqlite3_stmt *m_systemSizingInsertStmt;
362 : sqlite3_stmt *m_componentSizingInsertStmt;
363 : sqlite3_stmt *m_roomAirModelInsertStmt;
364 : sqlite3_stmt *m_groundTemperatureInsertStmt;
365 : sqlite3_stmt *m_weatherFileInsertStmt;
366 : sqlite3_stmt *m_scheduleInsertStmt;
367 : sqlite3_stmt *m_daylightMapTitleInsertStmt;
368 : sqlite3_stmt *m_daylightMapHourlyTitleInsertStmt;
369 : sqlite3_stmt *m_daylightMapHourlyDataInsertStmt;
370 : sqlite3_stmt *m_environmentPeriodInsertStmt;
371 : sqlite3_stmt *m_simulationsInsertStmt;
372 : sqlite3_stmt *m_tabularDataInsertStmt;
373 : sqlite3_stmt *m_stringsInsertStmt;
374 : sqlite3_stmt *m_stringsLookUpStmt;
375 : sqlite3_stmt *m_errorInsertStmt;
376 : sqlite3_stmt *m_errorUpdateStmt;
377 : sqlite3_stmt *m_simulationUpdateStmt;
378 : sqlite3_stmt *m_simulationDataUpdateStmt;
379 :
380 : static const int LocalReportEach; // Write out each time UpdatedataandLocalReport is called
381 : static const int LocalReportTimeStep; // Write out at 'EndTimeStepFlag'
382 : static const int LocalReportHourly; // Write out at 'EndHourFlag'
383 : static const int LocalReportDaily; // Write out at 'EndDayFlag'
384 : static const int LocalReportMonthly; // Write out at end of month (must be determined)
385 : static const int LocalReportSim; // Write out once per environment 'EndEnvrnFlag'
386 : static const int LocalReportYearly; // Write out once per year
387 : static const int ReportNameId;
388 : static const int ReportForStringId;
389 : static const int TableNameId;
390 : static const int RowNameId;
391 : static const int ColumnNameId;
392 : static const int UnitsId;
393 :
394 26918 : class SQLiteData : public SQLiteProcedures
395 : {
396 : protected:
397 : SQLiteData(std::shared_ptr<std::ostream> const &errorStream, std::shared_ptr<sqlite3> const &db);
398 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt) = 0;
399 : };
400 :
401 3138 : class Schedule : SQLiteData
402 : {
403 : public:
404 3138 : Schedule(std::shared_ptr<std::ostream> const &errorStream,
405 : std::shared_ptr<sqlite3> const &db,
406 : int const scheduleNumber,
407 : std::string const &scheduleName,
408 : std::string const &scheduleType,
409 : double const scheduleMinValue,
410 : double const scheduleMaxValue)
411 3138 : : SQLiteData(errorStream, db), number(scheduleNumber), name(scheduleName), type(scheduleType), minValue(scheduleMinValue),
412 3138 : maxValue(scheduleMaxValue)
413 : {
414 3138 : }
415 :
416 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt);
417 :
418 : private:
419 : int const number;
420 : std::string const name;
421 : std::string const type;
422 : double const minValue;
423 : double const maxValue;
424 : };
425 :
426 12098 : class Surface : SQLiteData
427 : {
428 : public:
429 12098 : Surface(std::shared_ptr<std::ostream> const &errorStream,
430 : std::shared_ptr<sqlite3> const &db,
431 : int const surfaceNumber,
432 : DataSurfaces::SurfaceData const &surfaceData,
433 : std::string const &surfaceClass)
434 12098 : : SQLiteData(errorStream, db), number(surfaceNumber), name(surfaceData.Name), construction(surfaceData.Construction),
435 : surfaceClass(surfaceClass), area(surfaceData.Area), grossArea(surfaceData.GrossArea), perimeter(surfaceData.Perimeter),
436 : azimuth(surfaceData.Azimuth), height(surfaceData.Height), reveal(surfaceData.Reveal), shape(surfaceData.Shape),
437 : sides(surfaceData.Sides), tilt(surfaceData.Tilt), width(surfaceData.Width), heatTransSurf(surfaceData.HeatTransSurf),
438 : baseSurf(surfaceData.BaseSurf), zone(surfaceData.Zone), extBoundCond(surfaceData.ExtBoundCond), extSolar(surfaceData.ExtSolar),
439 12098 : extWind(surfaceData.ExtWind)
440 : {
441 12098 : }
442 :
443 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt);
444 :
445 : private:
446 : int const number;
447 : std::string const &name;
448 : int const &construction;
449 : std::string const surfaceClass;
450 : double const &area;
451 : double const &grossArea;
452 : double const &perimeter;
453 : double const &azimuth;
454 : double const &height;
455 : double const &reveal;
456 : DataSurfaces::SurfaceShape const &shape;
457 : int const &sides;
458 : double const &tilt;
459 : double const &width;
460 : bool const &heatTransSurf;
461 : int const &baseSurf;
462 : int const &zone;
463 : int const &extBoundCond;
464 : bool const &extSolar;
465 : bool const &extWind;
466 : };
467 :
468 1337 : class Zone : SQLiteData
469 : {
470 : public:
471 1337 : Zone(std::shared_ptr<std::ostream> const &errorStream,
472 : std::shared_ptr<sqlite3> const &db,
473 : int const zoneNumber,
474 : DataHeatBalance::ZoneData const &zoneData)
475 1337 : : SQLiteData(errorStream, db), number(zoneNumber), name(zoneData.Name), relNorth(zoneData.RelNorth), originX(zoneData.OriginX),
476 : originY(zoneData.OriginY), originZ(zoneData.OriginZ), centroidX(zoneData.Centroid.x), centroidY(zoneData.Centroid.y),
477 : centroidZ(zoneData.Centroid.z), ofType(zoneData.OfType), multiplier(zoneData.Multiplier), listMultiplier(zoneData.ListMultiplier),
478 : minimumX(zoneData.MinimumX), maximumX(zoneData.MaximumX), minimumY(zoneData.MinimumY), maximumY(zoneData.MaximumY),
479 : minimumZ(zoneData.MinimumZ), maximumZ(zoneData.MaximumZ), ceilingHeight(zoneData.CeilingHeight), volume(zoneData.Volume),
480 : insideConvectionAlgo(zoneData.InsideConvectionAlgo), outsideConvectionAlgo(zoneData.OutsideConvectionAlgo),
481 : floorArea(zoneData.FloorArea), extGrossWallArea(zoneData.ExtGrossWallArea), extNetWallArea(zoneData.ExtNetWallArea),
482 1337 : extWindowArea(zoneData.ExtWindowArea), isPartOfTotalArea(zoneData.isPartOfTotalArea)
483 : {
484 1337 : }
485 :
486 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt);
487 :
488 : private:
489 : int const number;
490 : std::string const &name;
491 : double const &relNorth;
492 : double const &originX;
493 : double const &originY;
494 : double const &originZ;
495 : double const ¢roidX;
496 : double const ¢roidY;
497 : double const ¢roidZ;
498 : int const &ofType;
499 : int const &multiplier;
500 : int const &listMultiplier;
501 : double const &minimumX;
502 : double const &maximumX;
503 : double const &minimumY;
504 : double const &maximumY;
505 : double const &minimumZ;
506 : double const &maximumZ;
507 : double const &ceilingHeight;
508 : double const &volume;
509 : int const &insideConvectionAlgo;
510 : int const &outsideConvectionAlgo;
511 : double const &floorArea;
512 : double const &extGrossWallArea;
513 : double const &extNetWallArea;
514 : double const &extWindowArea;
515 : bool const &isPartOfTotalArea;
516 : };
517 :
518 4 : class ZoneList : SQLiteData
519 : {
520 : public:
521 4 : ZoneList(std::shared_ptr<std::ostream> const &errorStream,
522 : std::shared_ptr<sqlite3> const &db,
523 : int const zoneListNumber,
524 : DataHeatBalance::ZoneListData const &zoneListData)
525 4 : : SQLiteData(errorStream, db), number(zoneListNumber), name(zoneListData.Name), zones(zoneListData.Zone)
526 : {
527 4 : }
528 :
529 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt);
530 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt, sqlite3_stmt *subInsertStmt);
531 :
532 : private:
533 : int const number;
534 : std::string const &name;
535 : Array1D_int const &zones;
536 : };
537 :
538 3 : class ZoneGroup : SQLiteData
539 : {
540 : public:
541 3 : ZoneGroup(std::shared_ptr<std::ostream> const &errorStream,
542 : std::shared_ptr<sqlite3> const &db,
543 : int const zoneGroupNumber,
544 : DataHeatBalance::ZoneGroupData const &zoneGroupData)
545 3 : : SQLiteData(errorStream, db), number(zoneGroupNumber), name(zoneGroupData.Name), zoneList(zoneGroupData.ZoneList),
546 3 : multiplier(zoneGroupData.Multiplier)
547 : {
548 3 : }
549 :
550 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt);
551 :
552 : private:
553 : int const number;
554 : std::string const &name;
555 : int const &zoneList;
556 : int const &multiplier;
557 : };
558 :
559 1786 : class Material : SQLiteData
560 : {
561 : public:
562 1786 : Material(std::shared_ptr<std::ostream> const &errorStream,
563 : std::shared_ptr<sqlite3> const &db,
564 : int const materialNumber,
565 : EnergyPlus::Material::MaterialProperties const &materialData)
566 1786 : : SQLiteData(errorStream, db), number(materialNumber), name(materialData.Name), group(materialData.Group),
567 : roughness(materialData.Roughness), conductivity(materialData.Conductivity), density(materialData.Density),
568 : isoMoistCap(materialData.IsoMoistCap), porosity(materialData.Porosity), resistance(materialData.Resistance), rOnly(materialData.ROnly),
569 : specHeat(materialData.SpecHeat), thermGradCoef(materialData.ThermGradCoef), thickness(materialData.Thickness),
570 1786 : vaporDiffus(materialData.VaporDiffus)
571 : {
572 1786 : }
573 :
574 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt);
575 :
576 : private:
577 : int const number;
578 : std::string const &name;
579 : DataHeatBalance::MaterialGroup const &group;
580 : DataSurfaces::SurfaceRoughness const &roughness;
581 : double const &conductivity;
582 : double const &density;
583 : double const &isoMoistCap;
584 : double const &porosity;
585 : double const &resistance;
586 : bool const &rOnly;
587 : double const &specHeat;
588 : double const &thermGradCoef;
589 : double const &thickness;
590 : double const &vaporDiffus;
591 : };
592 :
593 844 : class Construction : SQLiteData
594 : {
595 : public:
596 844 : Construction(std::shared_ptr<std::ostream> const &errorStream,
597 : std::shared_ptr<sqlite3> const &db,
598 : int const constructionNumber,
599 : EnergyPlus::Construction::ConstructionProps const &constructionData,
600 : double const &constructionUValue)
601 844 : : SQLiteData(errorStream, db), number(constructionNumber), name(constructionData.Name), totLayers(constructionData.TotLayers),
602 : totSolidLayers(constructionData.TotSolidLayers), totGlassLayers(constructionData.TotGlassLayers),
603 : insideAbsorpVis(constructionData.InsideAbsorpVis), outsideAbsorpVis(constructionData.OutsideAbsorpVis),
604 : insideAbsorpSolar(constructionData.InsideAbsorpSolar), outsideAbsorpSolar(constructionData.OutsideAbsorpSolar),
605 : insideAbsorpThermal(constructionData.InsideAbsorpThermal), outsideAbsorpThermal(constructionData.OutsideAbsorpThermal),
606 844 : outsideRoughness(constructionData.OutsideRoughness), typeIsWindow(constructionData.TypeIsWindow), uValue(constructionUValue)
607 : {
608 2672 : for (int layerNum = 1; layerNum <= constructionData.TotLayers; ++layerNum) {
609 5484 : constructionLayers.push_back(std::unique_ptr<Construction::ConstructionLayer>(
610 3656 : new ConstructionLayer(m_errorStream, m_db, number, layerNum, constructionData.LayerPoint(layerNum))));
611 : }
612 844 : }
613 :
614 : // only inserts construction
615 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt);
616 : // inserts construction and construction layers
617 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt, sqlite3_stmt *subInsertStmt);
618 :
619 : private:
620 : int const number;
621 : std::string const &name;
622 : int const &totLayers;
623 : int const &totSolidLayers;
624 : int const &totGlassLayers;
625 : double const &insideAbsorpVis;
626 : double const &outsideAbsorpVis;
627 : double const &insideAbsorpSolar;
628 : double const &outsideAbsorpSolar;
629 : double const &insideAbsorpThermal;
630 : double const &outsideAbsorpThermal;
631 : DataSurfaces::SurfaceRoughness const &outsideRoughness;
632 : bool const &typeIsWindow;
633 : double const &uValue;
634 :
635 1828 : class ConstructionLayer : SQLiteData
636 : {
637 : public:
638 1828 : ConstructionLayer(std::shared_ptr<std::ostream> const &errorStream,
639 : std::shared_ptr<sqlite3> const &db,
640 : int const &constructNumber,
641 : int const layerNumber,
642 : int const &layerPoint)
643 1828 : : SQLiteData(errorStream, db), constructNumber(constructNumber), layerNumber(layerNumber), layerPoint(layerPoint)
644 : {
645 1828 : }
646 :
647 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt);
648 :
649 : private:
650 : int const &constructNumber;
651 : int const layerNumber;
652 : int const &layerPoint;
653 : };
654 :
655 : std::vector<std::unique_ptr<Construction::ConstructionLayer>> constructionLayers;
656 : };
657 :
658 1186 : class NominalLighting : SQLiteData
659 : {
660 : public:
661 1186 : NominalLighting(std::shared_ptr<std::ostream> const &errorStream,
662 : std::shared_ptr<sqlite3> const &db,
663 : int const nominalLightingNumber,
664 : DataHeatBalance::LightsData const &nominalLightingData)
665 1186 : : SQLiteData(errorStream, db), number(nominalLightingNumber), name(nominalLightingData.Name), zonePtr(nominalLightingData.ZonePtr),
666 : schedulePtr(nominalLightingData.SchedPtr), designLevel(nominalLightingData.DesignLevel),
667 : fractionReturnAir(nominalLightingData.FractionReturnAir), fractionRadiant(nominalLightingData.FractionRadiant),
668 : fractionShortWave(nominalLightingData.FractionShortWave), fractionReplaceable(nominalLightingData.FractionReplaceable),
669 1186 : fractionConvected(nominalLightingData.FractionConvected), endUseSubcategory(nominalLightingData.EndUseSubcategory)
670 : {
671 1186 : }
672 :
673 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt);
674 :
675 : private:
676 : int const number;
677 : std::string const &name;
678 : int const &zonePtr;
679 : int const &schedulePtr;
680 : double const &designLevel;
681 : double const &fractionReturnAir;
682 : double const &fractionRadiant;
683 : double const &fractionShortWave;
684 : double const &fractionReplaceable;
685 : double const &fractionConvected;
686 : std::string const &endUseSubcategory;
687 : };
688 :
689 1069 : class NominalPeople : SQLiteData
690 : {
691 : public:
692 1069 : NominalPeople(std::shared_ptr<std::ostream> const &errorStream,
693 : std::shared_ptr<sqlite3> const &db,
694 : int const nominalPeopleNumber,
695 : DataHeatBalance::PeopleData const &nominalPeopleData)
696 1069 : : SQLiteData(errorStream, db), number(nominalPeopleNumber), name(nominalPeopleData.Name), zonePtr(nominalPeopleData.ZonePtr),
697 : numberOfPeople(nominalPeopleData.NumberOfPeople), numberOfPeoplePtr(nominalPeopleData.NumberOfPeoplePtr),
698 : activityLevelPtr(nominalPeopleData.ActivityLevelPtr), fractionRadiant(nominalPeopleData.FractionRadiant),
699 : fractionConvected(nominalPeopleData.FractionConvected), workEffPtr(nominalPeopleData.WorkEffPtr),
700 : clothingPtr(nominalPeopleData.ClothingPtr), airVelocityPtr(nominalPeopleData.AirVelocityPtr), fanger(nominalPeopleData.Fanger),
701 : pierce(nominalPeopleData.Pierce), ksu(nominalPeopleData.KSU), mrtCalcType(nominalPeopleData.MRTCalcType),
702 : surfacePtr(nominalPeopleData.SurfacePtr), angleFactorListName(nominalPeopleData.AngleFactorListName),
703 : angleFactorListPtr(nominalPeopleData.AngleFactorListPtr), userSpecSensFrac(nominalPeopleData.UserSpecSensFrac),
704 1069 : show55Warning(nominalPeopleData.Show55Warning)
705 : {
706 1069 : }
707 :
708 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt);
709 :
710 : private:
711 : int const number;
712 : std::string const &name;
713 : int const &zonePtr;
714 : double const &numberOfPeople;
715 : int const &numberOfPeoplePtr;
716 : int const &activityLevelPtr;
717 : double const &fractionRadiant;
718 : double const &fractionConvected;
719 : int const &workEffPtr;
720 : int const &clothingPtr;
721 : int const &airVelocityPtr;
722 : bool const &fanger;
723 : bool const &pierce;
724 : bool const &ksu;
725 : DataHeatBalance::CalcMRT const &mrtCalcType;
726 : int const &surfacePtr;
727 : std::string const &angleFactorListName;
728 : int const &angleFactorListPtr;
729 : double const &userSpecSensFrac;
730 : bool const &show55Warning;
731 : };
732 :
733 1193 : class NominalElectricEquipment : SQLiteData
734 : {
735 : public:
736 1193 : NominalElectricEquipment(std::shared_ptr<std::ostream> const &errorStream,
737 : std::shared_ptr<sqlite3> const &db,
738 : int const nominalElectricEquipmentNumber,
739 : DataHeatBalance::ZoneEquipData const &nominalElectricEquipmentData)
740 1193 : : SQLiteData(errorStream, db), number(nominalElectricEquipmentNumber), name(nominalElectricEquipmentData.Name),
741 : zonePtr(nominalElectricEquipmentData.ZonePtr), schedulePtr(nominalElectricEquipmentData.SchedPtr),
742 : designLevel(nominalElectricEquipmentData.DesignLevel), fractionLatent(nominalElectricEquipmentData.FractionLatent),
743 : fractionRadiant(nominalElectricEquipmentData.FractionRadiant), fractionLost(nominalElectricEquipmentData.FractionLost),
744 1193 : fractionConvected(nominalElectricEquipmentData.FractionConvected), endUseSubcategory(nominalElectricEquipmentData.EndUseSubcategory)
745 : {
746 1193 : }
747 :
748 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt);
749 :
750 : private:
751 : int const number;
752 : std::string const &name;
753 : int const &zonePtr;
754 : int const &schedulePtr;
755 : double const &designLevel;
756 : double const &fractionLatent;
757 : double const &fractionRadiant;
758 : double const &fractionLost;
759 : double const &fractionConvected;
760 : std::string const &endUseSubcategory;
761 : };
762 :
763 35 : class NominalGasEquipment : SQLiteData
764 : {
765 : public:
766 35 : NominalGasEquipment(std::shared_ptr<std::ostream> const &errorStream,
767 : std::shared_ptr<sqlite3> const &db,
768 : int const nominalGasEquipmentNumber,
769 : DataHeatBalance::ZoneEquipData const &nominalGasEquipmentData)
770 35 : : SQLiteData(errorStream, db), number(nominalGasEquipmentNumber), name(nominalGasEquipmentData.Name),
771 : zonePtr(nominalGasEquipmentData.ZonePtr), schedulePtr(nominalGasEquipmentData.SchedPtr),
772 : designLevel(nominalGasEquipmentData.DesignLevel), fractionLatent(nominalGasEquipmentData.FractionLatent),
773 : fractionRadiant(nominalGasEquipmentData.FractionRadiant), fractionLost(nominalGasEquipmentData.FractionLost),
774 35 : fractionConvected(nominalGasEquipmentData.FractionConvected), endUseSubcategory(nominalGasEquipmentData.EndUseSubcategory)
775 : {
776 35 : }
777 :
778 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt);
779 :
780 : private:
781 : int const number;
782 : std::string const &name;
783 : int const &zonePtr;
784 : int const &schedulePtr;
785 : double const &designLevel;
786 : double const &fractionLatent;
787 : double const &fractionRadiant;
788 : double const &fractionLost;
789 : double const &fractionConvected;
790 : std::string const &endUseSubcategory;
791 : };
792 :
793 0 : class NominalSteamEquipment : SQLiteData
794 : {
795 : public:
796 0 : NominalSteamEquipment(std::shared_ptr<std::ostream> const &errorStream,
797 : std::shared_ptr<sqlite3> const &db,
798 : int const nominalSteamEquipmentNumber,
799 : DataHeatBalance::ZoneEquipData const &nominalSteamEquipmentData)
800 0 : : SQLiteData(errorStream, db), number(nominalSteamEquipmentNumber), name(nominalSteamEquipmentData.Name),
801 : zonePtr(nominalSteamEquipmentData.ZonePtr), schedulePtr(nominalSteamEquipmentData.SchedPtr),
802 : designLevel(nominalSteamEquipmentData.DesignLevel), fractionLatent(nominalSteamEquipmentData.FractionLatent),
803 : fractionRadiant(nominalSteamEquipmentData.FractionRadiant), fractionLost(nominalSteamEquipmentData.FractionLost),
804 0 : fractionConvected(nominalSteamEquipmentData.FractionConvected), endUseSubcategory(nominalSteamEquipmentData.EndUseSubcategory)
805 : {
806 0 : }
807 :
808 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt);
809 :
810 : private:
811 : int const number;
812 : std::string const &name;
813 : int const &zonePtr;
814 : int const &schedulePtr;
815 : double const &designLevel;
816 : double const &fractionLatent;
817 : double const &fractionRadiant;
818 : double const &fractionLost;
819 : double const &fractionConvected;
820 : std::string const &endUseSubcategory;
821 : };
822 :
823 9 : class NominalHotWaterEquipment : SQLiteData
824 : {
825 : public:
826 9 : NominalHotWaterEquipment(std::shared_ptr<std::ostream> const &errorStream,
827 : std::shared_ptr<sqlite3> const &db,
828 : int const nominalHotWaterEquipmentNumber,
829 : DataHeatBalance::ZoneEquipData const &nominalHotWaterEquipmentData)
830 9 : : SQLiteData(errorStream, db), number(nominalHotWaterEquipmentNumber), name(nominalHotWaterEquipmentData.Name),
831 : zonePtr(nominalHotWaterEquipmentData.ZonePtr), schedulePtr(nominalHotWaterEquipmentData.SchedPtr),
832 : designLevel(nominalHotWaterEquipmentData.DesignLevel), fractionLatent(nominalHotWaterEquipmentData.FractionLatent),
833 : fractionRadiant(nominalHotWaterEquipmentData.FractionRadiant), fractionLost(nominalHotWaterEquipmentData.FractionLost),
834 9 : fractionConvected(nominalHotWaterEquipmentData.FractionConvected), endUseSubcategory(nominalHotWaterEquipmentData.EndUseSubcategory)
835 : {
836 9 : }
837 :
838 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt);
839 :
840 : private:
841 : int const number;
842 : std::string const &name;
843 : int const &zonePtr;
844 : int const &schedulePtr;
845 : double const &designLevel;
846 : double const &fractionLatent;
847 : double const &fractionRadiant;
848 : double const &fractionLost;
849 : double const &fractionConvected;
850 : std::string const &endUseSubcategory;
851 : };
852 :
853 18 : class NominalOtherEquipment : SQLiteData
854 : {
855 : public:
856 18 : NominalOtherEquipment(std::shared_ptr<std::ostream> const &errorStream,
857 : std::shared_ptr<sqlite3> const &db,
858 : int const nominalOtherEquipmentNumber,
859 : DataHeatBalance::ZoneEquipData const &nominalOtherEquipmentData)
860 18 : : SQLiteData(errorStream, db), number(nominalOtherEquipmentNumber), name(nominalOtherEquipmentData.Name),
861 : zonePtr(nominalOtherEquipmentData.ZonePtr), schedulePtr(nominalOtherEquipmentData.SchedPtr),
862 : designLevel(nominalOtherEquipmentData.DesignLevel), fractionLatent(nominalOtherEquipmentData.FractionLatent),
863 : fractionRadiant(nominalOtherEquipmentData.FractionRadiant), fractionLost(nominalOtherEquipmentData.FractionLost),
864 18 : fractionConvected(nominalOtherEquipmentData.FractionConvected), endUseSubcategory(nominalOtherEquipmentData.EndUseSubcategory)
865 : {
866 18 : }
867 :
868 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt);
869 :
870 : private:
871 : int const number;
872 : std::string const &name;
873 : int const &zonePtr;
874 : int const &schedulePtr;
875 : double const &designLevel;
876 : double const &fractionLatent;
877 : double const &fractionRadiant;
878 : double const &fractionLost;
879 : double const &fractionConvected;
880 : std::string const &endUseSubcategory;
881 : };
882 :
883 0 : class NominalBaseboardHeat : SQLiteData
884 : {
885 : public:
886 0 : NominalBaseboardHeat(std::shared_ptr<std::ostream> const &errorStream,
887 : std::shared_ptr<sqlite3> const &db,
888 : int const nominalBaseboardHeatNumber,
889 : DataHeatBalance::BBHeatData const &nominalBaseboardHeatData)
890 0 : : SQLiteData(errorStream, db), number(nominalBaseboardHeatNumber), name(nominalBaseboardHeatData.Name),
891 : zonePtr(nominalBaseboardHeatData.ZonePtr), schedPtr(nominalBaseboardHeatData.SchedPtr),
892 : capatLowTemperature(nominalBaseboardHeatData.CapatLowTemperature), lowTemperature(nominalBaseboardHeatData.LowTemperature),
893 : capatHighTemperature(nominalBaseboardHeatData.CapatHighTemperature), highTemperature(nominalBaseboardHeatData.HighTemperature),
894 : fractionRadiant(nominalBaseboardHeatData.FractionRadiant), fractionConvected(nominalBaseboardHeatData.FractionConvected),
895 0 : endUseSubcategory(nominalBaseboardHeatData.EndUseSubcategory)
896 : {
897 0 : }
898 :
899 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt);
900 :
901 : private:
902 : int const number;
903 : std::string const &name;
904 : int const &zonePtr;
905 : int const &schedPtr;
906 : double const &capatLowTemperature;
907 : double const &lowTemperature;
908 : double const &capatHighTemperature;
909 : double const &highTemperature;
910 : double const &fractionRadiant;
911 : double const &fractionConvected;
912 : std::string const &endUseSubcategory;
913 : };
914 :
915 1025 : class Infiltration : SQLiteData
916 : {
917 : public:
918 1025 : Infiltration(std::shared_ptr<std::ostream> const &errorStream,
919 : std::shared_ptr<sqlite3> const &db,
920 : int const infiltrationNumber,
921 : DataHeatBalance::InfiltrationData const &infiltrationData)
922 1025 : : SQLiteData(errorStream, db), number(infiltrationNumber), name(infiltrationData.Name), zonePtr(infiltrationData.ZonePtr),
923 1025 : schedPtr(infiltrationData.SchedPtr), designLevel(infiltrationData.DesignLevel)
924 : {
925 1025 : }
926 :
927 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt);
928 :
929 : private:
930 : int const number;
931 : std::string const &name;
932 : int const &zonePtr;
933 : int const &schedPtr;
934 : double const &designLevel;
935 : };
936 :
937 8 : class Ventilation : SQLiteData
938 : {
939 : public:
940 8 : Ventilation(std::shared_ptr<std::ostream> const &errorStream,
941 : std::shared_ptr<sqlite3> const &db,
942 : int const ventilationNumber,
943 : DataHeatBalance::VentilationData const &ventilationData)
944 8 : : SQLiteData(errorStream, db), number(ventilationNumber), name(ventilationData.Name), zonePtr(ventilationData.ZonePtr),
945 8 : schedPtr(ventilationData.SchedPtr), designLevel(ventilationData.DesignLevel)
946 : {
947 8 : }
948 :
949 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt);
950 :
951 : private:
952 : int const number;
953 : std::string const &name;
954 : int const &zonePtr;
955 : int const &schedPtr;
956 : double const &designLevel;
957 : };
958 :
959 1337 : class RoomAirModel : SQLiteData
960 : {
961 : public:
962 1337 : RoomAirModel(std::shared_ptr<std::ostream> const &errorStream,
963 : std::shared_ptr<sqlite3> const &db,
964 : int const roomAirModelNumber,
965 : DataRoomAirModel::AirModelData const &roomAirModelData)
966 1337 : : SQLiteData(errorStream, db), number(roomAirModelNumber), airModelName(roomAirModelData.AirModelName),
967 : airModelType(roomAirModelData.AirModelType), tempCoupleScheme(roomAirModelData.TempCoupleScheme),
968 1337 : simAirModel(roomAirModelData.SimAirModel)
969 : {
970 1337 : }
971 :
972 : virtual bool insertIntoSQLite(sqlite3_stmt *insertStmt);
973 :
974 : private:
975 : int const number;
976 : std::string const &airModelName;
977 : DataRoomAirModel::RoomAirModel const &airModelType;
978 : DataRoomAirModel::CouplingScheme const &tempCoupleScheme;
979 : bool const &simAirModel;
980 : };
981 :
982 : std::vector<std::unique_ptr<SQLite::Zone>> zones;
983 : std::vector<std::unique_ptr<SQLite::ZoneList>> zoneLists;
984 : std::vector<std::unique_ptr<SQLite::ZoneGroup>> zoneGroups;
985 : std::vector<std::unique_ptr<SQLite::Schedule>> schedules;
986 : std::vector<std::unique_ptr<SQLite::Surface>> surfaces;
987 : std::vector<std::unique_ptr<SQLite::Material>> materials;
988 : std::vector<std::unique_ptr<SQLite::Construction>> constructions;
989 : std::vector<std::unique_ptr<SQLite::NominalLighting>> nominalLightings;
990 : std::vector<std::unique_ptr<SQLite::NominalPeople>> nominalPeoples;
991 : std::vector<std::unique_ptr<SQLite::NominalElectricEquipment>> nominalElectricEquipments;
992 : std::vector<std::unique_ptr<SQLite::NominalGasEquipment>> nominalGasEquipments;
993 : std::vector<std::unique_ptr<SQLite::NominalSteamEquipment>> nominalSteamEquipments;
994 : std::vector<std::unique_ptr<SQLite::NominalHotWaterEquipment>> nominalHotWaterEquipments;
995 : std::vector<std::unique_ptr<SQLite::NominalOtherEquipment>> nominalOtherEquipments;
996 : std::vector<std::unique_ptr<SQLite::NominalBaseboardHeat>> nominalBaseboardHeats;
997 : std::vector<std::unique_ptr<SQLite::Infiltration>> infiltrations;
998 : std::vector<std::unique_ptr<SQLite::Ventilation>> ventilations;
999 : std::vector<std::unique_ptr<SQLite::RoomAirModel>> roomAirModels;
1000 : };
1001 :
1002 : std::unique_ptr<SQLite> CreateSQLiteDatabase(EnergyPlusData &state);
1003 :
1004 : void CreateSQLiteZoneExtendedOutput(EnergyPlusData &state);
1005 :
1006 1542 : struct SQLiteProceduresData : BaseGlobalStruct
1007 : {
1008 : std::unique_ptr<SQLite> sqlite;
1009 0 : void clear_state() override
1010 : {
1011 0 : sqlite.reset(); // probably not necessary, as it is recreated in ManageSimulation, but it should be fine to delete it here
1012 0 : }
1013 : };
1014 :
1015 : } // namespace EnergyPlus
1016 :
1017 : #endif
|
