?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Initial Commit
[HECS.git] / Gains.cpp
blob0a51301a79d5abb101c5ce0345152ffbcbe1e1f3
1 /***************************************************************************
2 * *
3 * Gains.cpp Copyright (C) 2008 by Jon Rumble *
4 * j.w.rumble@reading.ac.uk *
5 * *
6 * This file is part of HECS, *
7 * *
8 * HECS is free software: you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation, either version 2 of the License, or *
11 * (at your option) any later version. *
12 * *
13 * HECS is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
17 * *
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
19 * You should have received a copy of the GNU General Public License *
20 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
21 ***************************************************************************/
22
23 #include "Gains.h"
24 #include <iostream>
25 // Constructors/Destructors
26 //
27
28 Gains::Gains (const ConfigParser& config, WaterHeating *waterheat,
29 HeatLosses *heatingLosses,DwellingDimensions *dims)
30 {
31 cf = config;
32 ptrWaterHeat = waterheat;
33 ptrHeatLosses = heatingLosses;
34 ptrDims = dims;
35 initVars();
36 }
37
38 Gains::~Gains ( )
39 {
40 //TODO
41 }
42
43 //
44 // Methods
45 //
46
47
48 // Accessor methods
49 //
50
51 void Gains::setLightAppCookMetabolicGains ( double val_in ) {
52 m_lightAppCookMetabolicGains = val_in;
53 }
54
55 double Gains::getLightAppCookMetabolicGains ( ) {
56 return m_lightAppCookMetabolicGains;
57 }
58
59 void Gains::setLowEnergyLightRed ( double val_in ) {
60 m_lowEnergyLightRed = val_in;
61 }
62
63 double Gains::getLowEnergyLightRed ( ) {
64 return m_lowEnergyLightRed;
65 }
66
67 void Gains::setAddtnGains ( double val_in ) {
68 m_addtnGains = val_in;
69 }
70
71 double Gains::getAddtnGains ( ) {
72 return m_addtnGains;
73 }
74
75 void Gains::setWaterHeating ( double val_in ) {
76 m_waterHeating = val_in;
77 }
78
79 double Gains::getWaterHeating ( ) {
80 return m_waterHeating;
81 }
82
83 void Gains::setTotalIntGains ( double val_in ) {
84 m_totalIntGains = val_in;
85 }
86
87 double Gains::getTotalIntGains ( ) {
88 return m_totalIntGains;
89 }
90
91 void Gains::setTotalGains ( double val_in ) {
92 m_totalGains = val_in;
93 }
94
95 double Gains::getTotalGains ( ) {
96 return m_totalGains;
97 }
98
99 void Gains::setSolarGLR ( double val_in ) {
100 m_solarGLR = val_in;
101 }
102
103 double Gains::getSolarGLR ( ) {
104 return m_solarGLR;
105 }
106
107 void Gains::setSolarUtilFactor ( double val_in ) {
108 m_solarUtilFactor = val_in;
109 }
110
111 double Gains::getSolarUtilFactor ( ) {
112 return m_solarUtilFactor;
113 }
114
115 void Gains::setTotalSolarGains ( double val_in ) {
116 m_totalSolarGains = val_in;
117 }
118
119 double Gains::getTotalSolarGains ( ) {
120 return m_totalSolarGains;
121 }
122
123 void Gains::setMeanTempLivingArea ( double val_in ) {
124 m_meanTempLivingArea = val_in;
125 }
126
127 double Gains::getMeanTempLivingArea ( ) {
128 return m_meanTempLivingArea;
129 }
130
131 void Gains::setTempAdjustment ( double val_in ) {
132 m_tempAdjustment = val_in;
133 }
134
135 double Gains::getTempAdjustment ( ) {
136 return m_tempAdjustment;
137 }
138
139 void Gains::setAdjustForGains ( double val_in ) {
140 m_adjustForGains = val_in;
141 }
142
143 double Gains::getAdjustForGains ( ) {
144 return m_adjustForGains;
145 }
146
147 void Gains::setAdjustLivingTemp ( double val_in ) {
148 m_adjustLivingTemp = val_in;
149 }
150
151 double Gains::getAdjustLivingTemp ( ) {
152 return m_adjustLivingTemp;
153 }
154
155 void Gains::setTempDiffZones ( double val_in ) {
156 m_tempDiffZones = val_in;
157 }
158
159 double Gains::getTempDiffZones ( ) {
160 return m_tempDiffZones;
161 }
162
163 void Gains::setLivingAreaFrac ( double val_in ) {
164 m_livingAreaFrac = val_in;
165 }
166
167 double Gains::getLivingAreaFrac ( ) {
168 return m_livingAreaFrac;
169 }
170
171 void Gains::setRestOfHouseFrac ( double val_in ) {
172 m_restOfHouseFrac = val_in;
173 }
174
175 double Gains::getRestOfHouseFrac ( ) {
176 return m_restOfHouseFrac;
177 }
178
179 void Gains::setMeanIntTemp ( double val_in ) {
180 m_meanIntTemp = val_in;
181 }
182
183 double Gains::getMeanIntTemp ( ) {
184 return m_meanIntTemp;
185 }
186
187 void Gains::setTempRiseFromGains ( double val_in ) {
188 m_tempRiseFromGains = val_in;
189 }
190
191 double Gains::getTempRiseFromGains ( ) {
192 return m_tempRiseFromGains;
193 }
194
195 void Gains::setBaseTemp ( double val_in ) {
196 m_baseTemp = val_in;
197 }
198
199 double Gains::getBaseTemp ( ) {
200 return m_baseTemp;
201 }
202
203 void Gains::setDegreeDays ( double val_in ) {
204 m_degreeDays = val_in;
205 }
206
207 double Gains::getDegreeDays ( ) {
208 return m_degreeDays;
209 }
210
211 void Gains::setSpaceHeatingReq ( double val_in ) {
212 m_spaceHeatingReq = val_in;
213 }
214
215 double Gains::getSpaceHeatingReq ( ) {
216 return m_spaceHeatingReq;
217 }
218
219 double Gains::getGainLossRatio ( ) {
220 return m_gainLossRatio;
221 }
222
223 void Gains::setGainLossRatio (double val_in ) {
224 m_gainLossRatio = val_in;
225 }
226
227 double Gains::getUtilisationFactor ( ) {
228 return m_utilisationFactor;
229 }
230
231 void Gains::setUtilisationFactor (double val_in ) {
232 m_utilisationFactor = val_in;
233 }
234
235 double Gains::getUsefulGains ( ) {
236 return m_usefulGains;
237 }
238
239 void Gains::setUsefulGains (double val_in ) {
240 m_usefulGains = val_in;
241 }
242
243 double Gains::getAnnualLightEnergy(){
244 return m_annualLightEnergy;
245 }
246
247 void Gains::setAnnualLightEnergy(double val_in){
248 m_annualLightEnergy = val_in;
249 }
250
251 // Other methods
252 //
253
254 void Gains::calcLightingEnergy()
255 {
256 //Fixed Low Energy Lightbulbs
257 //
258
259 //Ratio of Enegry saving to standard lights
260 double C_1 = 0.00, C_2 = 0.00, GL = 0.00;
261 C_1 = 1 - 0.50 * m_lightRatio;
262
263
264
265 //Daylighting Calc
266 GL = m_totalSolarGains / ptrDims->get_totalFloorArea();
267
268 if (GL <= 0.095)
269 C_2 = (52.2 * (GL * GL)) - 9.94 * GL + 1.433;
270 else //GL > 0.095
271 C_2 = 0.96;
272
273 m_annualLightEnergy = 9.3 *
274 ptrDims->get_totalFloorArea() *
275 C_1 *
276 C_2;
277
278
279 //Gains From Lighting
280 m_lowEnergyLightRed = m_annualLightEnergy * 0.15;
281 }
282
283 void Gains::calcMeanIntTempLiving ()
284 {
285 double HLP = ptrHeatLosses->getHeatLossParam();
286 double x1 = 0.00;
287 double x3 = 0.00;
288 double y1 = 0.00;
289 double y3 = 0.00;
290 QList <double> tmpList;
291
292 QMap<double,QList <double> >::const_iterator i;
293
294 if (HLP <= 1.00)
295 {
296 m_meanTempLivingArea= table8.value(1.00).at(m_heatingTypeControl);
297 }
298 else if (HLP >= 6.00)
299 {
300
301 m_meanTempLivingArea = table8.value(6.00).at(m_heatingTypeControl);
302 }
303
304 //Find Upper Bound
305 else
306 {
307 i = table8.upperBound(HLP);
308 x3 = i.key();
309 tmpList = i.value();
310 y3 = tmpList.at(m_heatingTypeControl);
311 //Decrement by 1 for lower bound
312 --i;
313 x1 = i.key();
314 tmpList = i.value();
315 y1 = tmpList.at(m_heatingTypeControl);
316
317 m_meanTempLivingArea = lerp(x1,HLP,x3,y1,y3);
318 }
319
320 }
321
322
323 void Gains::calctempDiffBetweenZones()
324 {
325 double HLP = ptrHeatLosses->getHeatLossParam();
326 double x1 = 0.00;
327 double x3 = 0.00;
328 double y1 = 0.00;
329 double y3 = 0.00;
330 QList <double> tmpList;
331
332 QMap<double,QList <double> >::const_iterator i;
333
334 if (HLP <= 1.00)
335 {
336 m_tempDiffZones = table9.value(1.00).at(m_controlType);
337 }
338 else if (HLP >= 6.00)
339 {
340
341 m_tempDiffZones = table9.value(6.00).at(m_controlType);
342 }
343
344 //Find Upper Bound
345 else
346 {
347 i = table9.upperBound(HLP);
348 x3 = i.key();
349 tmpList = i.value();
350 y3 = tmpList.at(m_controlType);
351 //Decrement by 1 for lower bound
352 --i;
353 x1 = i.key();
354 tmpList = i.value();
355 y1 = tmpList.at(m_controlType);
356
357 m_tempDiffZones = lerp(x1,HLP,x3,y1,y3);
358 }
359
360 }
361 void Gains::calcDegreeDays()
362 {
363 double x1 = 0.00;
364 double x3 = 0.00;
365 double y1 = 0.00;
366 double y3 = 0.00;
367 QList <double> tmpList;
368 m_tempRiseFromGains = m_usefulGains /
369 ptrHeatLosses->getHeatLossCoeff();
370
371 m_baseTemp = m_meanIntTemp - m_tempRiseFromGains;
372
373 if (m_baseTemp < 1.00)
374 m_degreeDays = 0.00;
375 else if(m_baseTemp > 20.50)
376 m_degreeDays = 3330.00;
377
378 else
379 {
380
381 QMap<double,QList <double> >::const_iterator i;
382
383
384 i = table10.upperBound(m_baseTemp);
385 x3 = i.key();
386 tmpList = i.value();
387 y3 = tmpList.at(0);
388 //Decrement by 1 for lower bound
389 --i;
390 x1 = i.key();
391 tmpList = i.value();
392 y1 = tmpList.at(0);
393
394 m_degreeDays = lerp(x1,m_baseTemp,x3,y1,y3);
395 }
396 }
397
398 void Gains::calcTotalInternalGains()
399 {
400
401 double N = 0.00, W = 0.00, SFP=0.00;
402 double TFA = ptrDims->get_totalFloorArea();
403
404 //Calculate N
405 //
406 if (TFA <= 420.00)
407 N = 0.035 * TFA - 0.000038 * (TFA * TFA);
408 else
409 N = 8.00;
410
411 //Calculate Gains W
412 //
413 if (TFA <= 282.00)
414 W = 74.00 + 2.66 * TFA + 75.5 * N;
415 else
416 W = 824.00 + 75.5 * N;
417
418 m_lightAppCookMetabolicGains = W;
419
420 if(m_specificFanPower == 1)
421 SFP = 2.0;
422 else
423 SFP = 0.8;
424
425
426 switch (m_addtnGainsTableVal)
427 {
428 case 1: //Central Heating Pump
429 m_addtnGains = 10.00;
430 break;
431 case 2: //Oil Boiler Pump, inside dwelling
432 m_addtnGains = 10.00;
433 break;
434
435 case 3://Warm air heating system fans
436 m_addtnGains = 0.06 * ptrDims->get_dwellingVolume();
437 break;
438 case 4:
439 m_addtnGains = SFP * 0.06 * ptrDims->get_dwellingVolume();
440 break;
441 default:
442 break;
443 } /* ----- end switch ----- */
444
445
446 m_waterHeating = ptrWaterHeat->getHotWaterHeatGains() / 8.76 ;
447 m_totalIntGains = m_lightAppCookMetabolicGains +
448 m_addtnGains +
449 m_waterHeating -
450 m_lowEnergyLightRed;
451 }
452
453 void Gains::calcUsefulSolarGains()
454 {
455 QMapIterator <QString, SolarGains> i(gainsList);
456
457 while (i.hasNext())
458 {
459 i.next();
460 SolarGains temp = i.value();
461 m_totalSolarGains += temp.getSolarGains();
462
463 }
464
465 m_totalGains = m_totalIntGains + m_totalSolarGains;
466
467 m_gainLossRatio = m_totalGains / ptrHeatLosses->getHeatLossCoeff();
468
469 //Calculate Utilisation Factor
470 m_utilisationFactor = 1 - exp(-18/m_gainLossRatio);
471
472 m_usefulGains = m_totalSolarGains * m_utilisationFactor;
473
474 }
475
476 void Gains::calcSpaceHeatReq()
477 {
478 m_spaceHeatingReq = 0.024 *
479 m_degreeDays *
480 ptrHeatLosses->getHeatLossCoeff();
481 }
482
483 void Gains::calcMeanInternalTemp()
484 {
485 //Needs work to Fix !!!!
486 //
487 double R = 1.00;
488
489 //Calc Mean Internal Living Room Temperature
490 calcMeanIntTempLiving();
491
492 //TODO - adjust from table 4e
493
494 //TODO - responsiveness, defaulting to 1.00 for now !!
495
496 m_adjustForGains = (m_usefulGains /
497 ptrHeatLosses->getHeatLossCoeff() - 4.0) *
498 0.2 *
499 R;
500
501 m_adjustLivingTemp = m_meanTempLivingArea +
502 m_tempAdjustment +
503 m_adjustForGains;
504
505 calctempDiffBetweenZones();
506
507 m_livingAreaFrac = ptrDims->get_livingRoomArea() /
508 ptrDims->get_totalFloorArea();
509
510 m_restOfHouseFrac = 1.00 - m_livingAreaFrac;
511 m_meanIntTemp = m_adjustLivingTemp -
512 (m_tempDiffZones * m_restOfHouseFrac);
513
514 }
515
516 void Gains::initVars()
517 {
518
519 buildLT();
520
521 m_lightAppCookMetabolicGains = cf.getValueDouble("Gains:lightAppCookMetabolicGains");
522 m_lowEnergyLightRed = cf.getValueDouble("Gains:lowEnergyLightRed");
523 m_addtnGains = cf.getValueDouble("Gains:addtnGains");
524 m_waterHeating = cf.getValueDouble("Gains:waterHeating");
525 m_totalIntGains = cf.getValueDouble("Gains:totalIntGains");
526 m_totalGains = cf.getValueDouble("Gains:totalGains");
527 m_solarGLR = cf.getValueDouble("Gains:solarGLR");
528 m_solarUtilFactor = cf.getValueDouble("Gains:solarUtilFactor");
529 m_totalSolarGains = cf.getValueDouble("Gains:totalSolarGains");
530 m_meanTempLivingArea = cf.getValueDouble("Gains:meanTempLivingArea");
531 m_tempAdjustment = cf.getValueDouble("Gains:tempAdjustment");
532 m_adjustForGains = cf.getValueDouble("Gains:adjustForGains");
533 m_adjustLivingTemp = cf.getValueDouble("Gains:adjustLivingTemp");
534 m_tempDiffZones = cf.getValueDouble("Gains:tempDiffZones");
535 m_livingAreaFrac = cf.getValueDouble("Gains:livingAreaFrac");
536 m_restOfHouseFrac = cf.getValueDouble("Gains:restOfHouseFrac");
537 m_meanIntTemp = cf.getValueDouble("Gains:meantIntTemp");
538 m_tempRiseFromGains = cf.getValueDouble("Gains:tempRiseFromGains");
539 m_baseTemp = cf.getValueDouble("Gains:baseTemp");
540 m_degreeDays = cf.getValueDouble("Gains:degreeDays");
541 m_spaceHeatingReq = cf.getValueDouble("Gains:spaceHeatingReq");
542 m_usefulGains = cf.getValueDouble("Gains:usefulGains");
543 m_gainLossRatio = cf.getValueDouble("Gains:gainLossRatio");
544 m_utilisationFactor = cf.getValueDouble("Gains:utilisationFactor");
545 m_lightRatio = cf.getValueDouble("Gains:lightRatio");
546 m_addtnGainsTableVal = cf.getValueInt("Gains:addtnGainsTableVal");
547 m_specificFanPower = cf.getValueInt("Gains:specificFanPower");
548 m_heatingTypeControl = cf.getValueInt("Gains:heatingTypeControl");
549 m_controlType = cf.getValueInt("Gains:controlType");
550 m_annualLightEnergy= cf.getValueInt("Gains:annualLightEnergy");
551
552 loadSolarGain("North");
553 loadSolarGain("South");
554 loadSolarGain("East");
555 loadSolarGain("West");
556 loadSolarGain("NorthEast");
557 loadSolarGain("SouthEast");
558 loadSolarGain("NorthWest");
559 loadSolarGain("SouthWest");
560 loadSolarGain("Rooflights");
561 }
562
563
564 void Gains::loadSolarGain(const QString& gainName)
565 {
566 int overshadow = 0,orientation =0;
567 int frameType, glazingType = 0;
568 double area = 0.00;
569
570 QString searchStr = "SG" + gainName + ":";
571 overshadow = cf.getValueInt(searchStr+"overshadow");
572 orientation = cf.getValueInt(searchStr+"orientation");
573 area = cf.getValueDouble(searchStr+"area");
574 frameType = cf.getValueInt(searchStr+"frameType");
575 glazingType = cf.getValueInt(searchStr+"glazingType");
576
577 createSolarGain(gainName,
578 overshadow,
579 orientation,
580 area,
581 frameType,
582 glazingType,'w');
583 }
584
585
586 void Gains::buildLT()
587 {
588 //TEST BEFORE REMOVAL
589 DoubleReader t1 ("table9");
590 table9 = t1.getDoubleMap();
591 DoubleReader t2 ("table8");
592 table8 = t2.getDoubleMap();
593 DoubleReader t3 ("table10");
594 table10 = t3.getDoubleMap();
595
596 /* //dr.readFile("table8");
597 DoubleReader table8r ("table8");
598 table8 = table8r.getDoubleMap();
599
600 DoubleReader table9r ("table9");
601 table9 = table9r.getDoubleMap();
602
603
604 //dr.readFile("table10");
605 DoubleReader table10r ("table10");
606 table10 = table10r.getDoubleMap();*/
607
608 }
609 void Gains::createSolarGain(QString gainName,
610 int overshadow,
611 int orientation,
612 double area,
613 int frameType,
614 int glazingType,
615 char season)
616 {
617 SolarGains gain(overshadow,orientation,area,
618 frameType,glazingType,season);
619 gainsList[gainName] = gain;
620 }
621
622 void Gains::calcAll()
623 {
624 calcTotalInternalGains();
625 calcUsefulSolarGains();
626 calcLightingEnergy();
627 calcMeanInternalTemp();
628 calcDegreeDays();
629 calcSpaceHeatReq();
630 }
HECS