def readDOE(serialize_output=True):
"""
Read csv files of DOE buildings
Sheet 1 = BuildingSummary
Sheet 2 = ZoneSummary
Sheet 3 = LocationSummary
Sheet 4 = Schedules
Note BLD8 & 10 = school
Then make matrix of ref data as nested nested lists [16, 3, 16]:
matrix refDOE = Building objs
matrix Schedule = SchDef objs
matrix refBEM (16,3,16) = BEMDef
where:
[16,3,16] is Type = 1-16, Era = 1-3, climate zone = 1-16
i.e.
Type: FullServiceRestaurant, Era: Pre80, Zone: 6A Minneapolis
Nested tree:
[TYPE_1:
ERA_1:
CLIMATE_ZONE_1
...
CLIMATE_ZONE_16
ERA_2:
CLIMATE_ZONE_1
...
CLIMATE_ZONE_16
...
ERA_3:
CLIMATE_ZONE_1
...
CLIMATE_ZONE_16]
"""
#Nested, nested lists of Building, SchDef, BEMDef objects
refDOE = map(lambda j_: map(lambda k_: [None] * 16, [None] * 3),
[None] * 16) #refDOE(16,3,16) = Building;
Schedule = map(lambda j_: map(lambda k_: [None] * 16, [None] * 3),
[None] * 16) #Schedule (16,3,16) = SchDef;
refBEM = map(lambda j_: map(lambda k_: [None] * 16, [None] * 3),
[None] * 16) #refBEM (16,3,16) = BEMDef;
#Purpose: Loop through every DOE reference csv and extract building data
#Nested loop = 16 types, 3 era, 16 zones = time complexity O(n*m*k) = 768
for i in xrange(16):
#i = 16 types of buildings
#print "\tType: {} @i={}".format(BLDTYPE[i], i)
# Read building summary (Sheet 1)
file_doe_name_bld = os.path.join(
"{}".format(DIR_DOE_PATH), "BLD{}".format(i + 1),
"BLD{}_BuildingSummary.csv".format(i + 1))
list_doe1 = read_csv(file_doe_name_bld)
#listof(listof 3 era values)
nFloor = str2fl(
list_doe1[3][3:6]
) # Number of Floors, this will be list of floats and str if "basement"
glazing = str2fl(list_doe1[4][3:6]) # [?] Total
hCeiling = str2fl(list_doe1[5][3:6]) # [m] Ceiling height
ver2hor = str2fl(list_doe1[7][3:6]) # Wall to Skin Ratio
AreaRoof = str2fl(
list_doe1[8][3:6]) # [m2] Gross Dimensions - Total area
# Read zone summary (Sheet 2)
file_doe_name_zone = os.path.join(
"{}".format(DIR_DOE_PATH), "BLD{}".format(i + 1),
"BLD{}_ZoneSummary.csv".format(i + 1))
list_doe2 = read_csv(file_doe_name_zone)
#listof(listof 3 eras)
AreaFloor = str2fl([list_doe2[2][5], list_doe2[3][5],
list_doe2[4][5]]) # [m2]
Volume = str2fl([list_doe2[2][6], list_doe2[3][6],
list_doe2[4][6]]) # [m3]
AreaWall = str2fl([list_doe2[2][8], list_doe2[3][8],
list_doe2[4][8]]) # [m2]
AreaWindow = str2fl(
[list_doe2[2][9], list_doe2[3][9], list_doe2[4][9]]) # [m2]
Occupant = str2fl(
[list_doe2[2][11], list_doe2[3][11],
list_doe2[4][11]]) # Number of People
Light = str2fl([list_doe2[2][12], list_doe2[3][12],
list_doe2[4][12]]) # [W/m2]
Elec = str2fl([list_doe2[2][13], list_doe2[3][13],
list_doe2[4][13]]) # [W/m2] Electric Plug and Process
Gas = str2fl([list_doe2[2][14], list_doe2[3][14],
list_doe2[4][14]]) # [W/m2] Gas Plug and Process
SHW = str2fl([list_doe2[2][15], list_doe2[3][15],
list_doe2[4][15]]) # [Litres/hr] Peak Service Hot Water
Vent = str2fl([list_doe2[2][17], list_doe2[3][17],
list_doe2[4][17]]) # [L/s/m2] Ventilation
Infil = str2fl([list_doe2[2][20], list_doe2[3][20], list_doe2[4][20]
]) # Air Changes Per Hour (ACH) Infiltration
# Read location summary (Sheet 3)
file_doe_name_location = os.path.join(
"{}".format(DIR_DOE_PATH), "BLD{}".format(i + 1),
"BLD{}_LocationSummary.csv".format(i + 1))
list_doe3 = read_csv(file_doe_name_location)
#(listof (listof 3 eras (listof 16 climate types)))
TypeWall = [
list_doe3[3][4:20], list_doe3[14][4:20], list_doe3[25][4:20]
] # Construction type
RvalWall = str2fl(
[list_doe3[4][4:20], list_doe3[15][4:20],
list_doe3[26][4:20]]) # [m2*K/W] R-value
TypeRoof = [
list_doe3[5][4:20], list_doe3[16][4:20], list_doe3[27][4:20]
] # Construction type
RvalRoof = str2fl(
[list_doe3[6][4:20], list_doe3[17][4:20],
list_doe3[28][4:20]]) # [m2*K/W] R-value
Uwindow = str2fl(
[list_doe3[7][4:20], list_doe3[18][4:20],
list_doe3[29][4:20]]) # [W/m2*K] U-factor
SHGC = str2fl(
[list_doe3[8][4:20], list_doe3[19][4:20],
list_doe3[30][4:20]]) # [-] coefficient
HVAC = str2fl(
[list_doe3[9][4:20], list_doe3[20][4:20],
list_doe3[31][4:20]]) # [kW] Air Conditioning
HEAT = str2fl(
[list_doe3[10][4:20], list_doe3[21][4:20],
list_doe3[32][4:20]]) # [kW] Heating
COP = str2fl(
[list_doe3[11][4:20], list_doe3[22][4:20],
list_doe3[33][4:20]]) # [-] Air Conditioning COP
EffHeat = str2fl(
[list_doe3[12][4:20], list_doe3[23][4:20],
list_doe3[34][4:20]]) # [%] Heating Efficiency
FanFlow = str2fl(
[list_doe3[13][4:20], list_doe3[24][4:20],
list_doe3[35][4:20]]) # [m3/s] Fan Max Flow Rate
# Read Schedules (Sheet 4)
file_doe_name_schedules = os.path.join(
"{}".format(DIR_DOE_PATH), "BLD{}".format(i + 1),
"BLD{}_Schedules.csv".format(i + 1))
list_doe4 = read_csv(file_doe_name_schedules)
#listof(listof weekday, sat, sun (list of 24 fractions)))
SchEquip = str2fl(
[list_doe4[1][6:30], list_doe4[2][6:30],
list_doe4[3][6:30]]) # Equipment Schedule 24 hrs
SchLight = str2fl(
[list_doe4[4][6:30], list_doe4[5][6:30],
list_doe4[6][6:30]]) # Light Schedule 24 hrs; Wkday=Sat=Sun=Hol
SchOcc = str2fl(
[list_doe4[7][6:30], list_doe4[8][6:30],
list_doe4[9][6:30]]) # Occupancy Schedule 24 hrs
SetCool = str2fl(
[list_doe4[10][6:30], list_doe4[11][6:30],
list_doe4[12][6:30]]) # Cooling Setpoint Schedule 24 hrs
SetHeat = str2fl([
list_doe4[13][6:30], list_doe4[14][6:30], list_doe4[15][6:30]
]) # Heating Setpoint Schedule 24 hrs; summer design
SchGas = str2fl(
[list_doe4[16][6:30], list_doe4[17][6:30],
list_doe4[18][6:30]]) # Gas Equipment Schedule 24 hrs; wkday=sat
SchSWH = str2fl(
[list_doe4[19][6:30], list_doe4[20][6:30], list_doe4[21][6:30]]
) # Solar Water Heating Schedule 24 hrs; wkday=summerdesign, sat=winterdesgin
for j in xrange(3):
# j = 3 built eras
#print"\tEra: {} @j={}".format(BUILTERA[j], j)
for k in xrange(16):
# k = 16 climate zones
#print "\tClimate zone: {} @k={}".format(ZONETYPE[k], k)
B = Building(
hCeiling[j], # floorHeight by era
1, # intHeatNight
1, # intHeatDay
0.1, # intHeatFRad
0.1, # intHeatFLat
Infil[j], # infil (ACH) by era
Vent[j] /
1000., # vent (m^3/s/m^2) by era, converted from liters
glazing[j], # glazing ratio by era
Uwindow[j][k], # uValue by era, by climate type
SHGC[j][k], # SHGC, by era, by climate type
'AIR', # cooling condensation system type: AIR, WATER
COP[j][k], # cop by era, climate type
297, # coolSetpointDay = 24 C
297, # coolSetpointNight
293, # heatSetpointDay = 20 C
293, # heatSetpointNight
(HVAC[j][k] * 1000.0) / AreaFloor[
j], # coolCap converted to W/m2 by era, climate type
EffHeat[j][k], # heatEff by era, climate type
293) # initialTemp at 20 C
#Not defined in the constructor
B.heatCap = (HEAT[j][k] * 1000.0) / AreaFloor[
j] # heating Capacity converted to W/m2 by era, climate type
B.Type = BLDTYPE[i]
B.Era = BUILTERA[j]
B.Zone = ZONETYPE[k]
refDOE[i][j][k] = B
# Define wall, mass(floor), roof
# Reference from E+ for conductivity, thickness (reference below)
# Material: (thermalCond, volHeat = specific heat * density)
Concrete = Material(1.311, 836.8 * 2240, "Concrete")
Insulation = Material(0.049, 836.8 * 265.0, "Insulation")
Gypsum = Material(0.16, 830.0 * 784.9, "Gypsum")
Wood = Material(0.11, 1210.0 * 544.62, "Wood")
Stucco = Material(0.6918, 837.0 * 1858.0, "Stucco")
# Wall (1 in stucco, concrete, insulation, gypsum)
# Check TypWall by era, by climate
if TypeWall[j][k] == "MassWall":
#Construct wall based on R value of Wall from refDOE and properties defined above
# 1" stucco, 8" concrete, tbd insulation, 1/2" gypsum
Rbase = 0.271087 # R val based on stucco, concrete, gypsum
Rins = RvalWall[j][k] - Rbase #find insulation value
D_ins = Rins * Insulation.thermalCond # depth of ins from m2*K/W * W/m*K = m
if D_ins > 0.01:
thickness = [
0.0254, 0.0508, 0.0508, 0.0508, 0.0508, D_ins,
0.0127
]
layers = [
Stucco, Concrete, Concrete, Concrete, Concrete,
Insulation, Gypsum
]
else:
#if it's less then 1 cm don't include in layers
thickness = [
0.0254, 0.0508, 0.0508, 0.0508, 0.0508, 0.0127
]
layers = [
Stucco, Concrete, Concrete, Concrete, Concrete,
Gypsum
]
wall = Element(0.08, 0.92, thickness, layers, 0., 293., 0.,
"MassWall")
# If mass wall, assume mass floor (4" concrete)
# Mass (assume 4" concrete);
alb = 0.2
emis = 0.9
thickness = [0.054, 0.054]
concrete = Material(1.31, 2240.0 * 836.8)
mass = Element(alb, emis, thickness, [concrete, concrete],
0, 293, 1, "MassFloor")
elif TypeWall[j][k] == "WoodFrame":
# 0.01m wood siding, tbd insulation, 1/2" gypsum
Rbase = 0.170284091 # based on wood siding, gypsum
Rins = RvalWall[j][k] - Rbase
D_ins = Rins * Insulation.thermalCond #depth of insulatino
if D_ins > 0.01:
thickness = [0.01, D_ins, 0.0127]
layers = [Wood, Insulation, Gypsum]
else:
thickness = [0.01, 0.0127]
layers = [Wood, Gypsum]
wall = Element(0.22, 0.92, thickness, layers, 0., 293., 0.,
"WoodFrameWall")
# If wood frame wall, assume wooden floor
alb = 0.2
emis = 0.9
thickness = [0.05, 0.05]
wood = Material(1.31, 2240.0 * 836.8)
mass = Element(alb, emis, thickness, [wood, wood], 0.,
293., 1., "WoodFloor")
elif TypeWall[j][k] == "SteelFrame":
# 1" stucco, 8" concrete, tbd insulation, 1/2" gypsum
Rbase = 0.271087 # based on stucco, concrete, gypsum
Rins = RvalWall[j][k] - Rbase
D_ins = Rins * Insulation.thermalCond
if D_ins > 0.01:
thickness = [
0.0254, 0.0508, 0.0508, 0.0508, 0.0508, D_ins,
0.0127
]
layers = [
Stucco, Concrete, Concrete, Concrete, Concrete,
Insulation, Gypsum
]
else: # If insulation is too thin, assume no insulation
thickness = [
0.0254, 0.0508, 0.0508, 0.0508, 0.0508, 0.0127
]
layers = [
Stucco, Concrete, Concrete, Concrete, Concrete,
Gypsum
]
wall = Element(0.15, 0.92, thickness, layers, 0., 293., 0.,
"SteelFrame")
# If mass wall, assume mass foor
# Mass (assume 4" concrete),
alb = 0.2
emis = 0.93
thickness = [0.05, 0.05]
mass = Element(alb, emis, thickness, [Concrete, Concrete],
0., 293., 1., "MassFloor")
elif TypeWall[j][k] == "MetalWall":
# metal siding, insulation, 1/2" gypsum
alb = 0.2
emis = 0.9
D_ins = max(
(RvalWall[j][k] * Insulation.thermalCond) / 2, 0.01
) #use derived insul thickness or 0.01 based on max
thickness = [D_ins, D_ins, 0.0127]
materials = [Insulation, Insulation, Gypsum]
wall = Element(alb, emis, thickness, materials, 0, 293, 0,
"MetalWall")
# Mass (assume 4" concrete);
alb = 0.2
emis = 0.9
thickness = [0.05, 0.05]
concrete = Material(1.31, 2240.0 * 836.8)
mass = Element(alb, emis, thickness, [concrete, concrete],
0., 293., 1., "MassFloor")
# Roof
if TypeRoof[j][k] == "IEAD": #Insulation Entirely Above Deck
# IEAD-> membrane, insulation, decking
alb = 0.2
emis = 0.93
D_ins = max(RvalRoof[j][k] * Insulation.thermalCond / 2.,
0.01)
roof = Element(alb, emis, [D_ins, D_ins],
[Insulation, Insulation], 0., 293., 0.,
"IEAD")
elif TypeRoof[j][k] == "Attic":
# IEAD-> membrane, insulation, decking
alb = 0.2
emis = 0.9
D_ins = max(RvalRoof[j][k] * Insulation.thermalCond / 2.,
0.01)
roof = Element(alb, emis, [D_ins, D_ins],
[Insulation, Insulation], 0., 293., 0.,
"Attic")
elif TypeRoof[j][k] == "MetalRoof":
# IEAD-> membrane, insulation, decking
alb = 0.2
emis = 0.9
D_ins = max(RvalRoof[j][k] * Insulation.thermalCond / 2.,
0.01)
roof = Element(alb, emis, [D_ins, D_ins],
[Insulation, Insulation], 0., 293., 0.,
"MetalRoof")
# Define bulding energy model, set fraction of the urban floor space of this typology to zero
refBEM[i][j][k] = BEMDef(B, mass, wall, roof, 0.0)
refBEM[i][j][k].building.FanMax = FanFlow[j][
k] # max fan flow rate (m^3/s) per DOE
Schedule[i][j][k] = SchDef()
Schedule[i][j][
k].Elec = SchEquip # 3x24 matrix of schedule for fraction electricity (WD,Sat,Sun)
Schedule[i][j][
k].Light = SchLight # 3x24 matrix of schedule for fraction light (WD,Sat,Sun)
Schedule[i][j][
k].Gas = SchGas # 3x24 matrix of schedule for fraction gas (WD,Sat,Sun)
Schedule[i][j][
k].Occ = SchOcc # 3x24 matrix of schedule for fraction occupancy (WD,Sat,Sun)
Schedule[i][j][
k].Cool = SetCool # 3x24 matrix of schedule for fraction cooling temp (WD,Sat,Sun)
Schedule[i][j][
k].Heat = SetHeat # 3x24 matrix of schedule for fraction heating temp (WD,Sat,Sun)
Schedule[i][j][
k].SWH = SchSWH # 3x24 matrix of schedule for fraction SWH (WD,Sat,Sun
Schedule[i][j][k].Qelec = Elec[
j] # W/m^2 (max) for electrical plug process
Schedule[i][j][k].Qlight = Light[j] # W/m^2 (max) for light
Schedule[i][j][k].Nocc = Occupant[j] / AreaFloor[
j] # Person/m^2
Schedule[i][j][k].Qgas = Gas[j] # W/m^2 (max) for gas
Schedule[i][j][k].Vent = Vent[j] / 1000.0 # m^3/m^2 per person
Schedule[i][j][k].Vswh = SHW[j] / AreaFloor[
j] # litres per hour per m^2 of floor
# if not test serialize refDOE,refBEM,Schedule and store in resources
if serialize_output:
# create a binary file for serialized obj
pkl_file_path = os.path.join(DIR_CURR, '..', 'resources',
'readDOE.pkl')
pickle_readDOE = open(pkl_file_path, 'wb')
# dump in ../resources
# Pickle objects, protocol 1 b/c binary file
cPickle.dump(refDOE, pickle_readDOE, 1)
cPickle.dump(refBEM, pickle_readDOE, 1)
cPickle.dump(Schedule, pickle_readDOE, 1)
pickle_readDOE.close()
return refDOE, refBEM, Schedule
def __init__(self, climate_file, HI, HF):
#HI: Julian start date
#HF: Julian final date
#H1 and HF define the row we want
# Open .epw file and feed csv data to self.climate_data
try:
self.climate_data = read_csv(climate_file)
except Exception as e:
raise Exception("Failed to read .epw file! {}".format(e.message))
self.location = self.climate_data[0][1]
cd = self.climate_data[HI:HF + 1]
self.staTemp = str2fl([cd[i][6]
for i in xrange(len(cd))]) # drybulb [C]
self.staTdp = str2fl([cd[i][7]
for i in xrange(len(cd))]) # dewpoint [C]
self.staRhum = str2fl([cd[i][8] for i in xrange(len(cd))
]) # air relative humidity (%)
self.staPres = str2fl([cd[i][9]
for i in xrange(len(cd))]) # air pressure (Pa)
self.staInfra = str2fl([
cd[i][12] for i in xrange(len(cd))
]) # horizontal Infrared Radiation Intensity (W m-2)
self.staHor = str2fl([cd[i][13] for i in xrange(len(cd))
]) # horizontal radiation [W m-2]
self.staDir = str2fl([cd[i][14] for i in xrange(len(cd))
]) # normal solar direct radiation (W m-2)
self.staDif = str2fl([cd[i][15] for i in xrange(len(cd))
]) # horizontal solar diffuse radiation (W m-2)
self.staUdir = str2fl([cd[i][20]
for i in xrange(len(cd))]) # wind direction ()
self.staUmod = str2fl([cd[i][21]
for i in xrange(len(cd))]) # wind speed (m s-1)
self.staRobs = str2fl([cd[i][33] for i in xrange(len(cd))
]) # Precipitation (mm h-1)
self.staHum = [0.0] * len(
self.staTemp) # specific humidty (kgH20 kgN202-1)
for i in xrange(len(self.staTemp)):
self.staHum[i] = HumFromRHumTemp(self.staRhum[i], self.staTemp[i],
self.staPres[i])
self.staTemp = [s + 273.15
for s in self.staTemp] # air temperature (K)
def read_input(self):
"""Section 3 - Read Input File (.m, file)
Note: UWG_Matlab input files are xlsm, XML, .m, file.
properties:
self._init_param_dict # dictionary of simulation initialization parameters
self.sensAnth # non-building sensible heat (W/m^2)
self.SchTraffic # Traffice schedule
self.BEM # list of BEMDef objects extracted from readDOE
self.Sch # list of Schedule objects extracted from readDOE
"""
uwg_param_file_path = os.path.join(self.uwgParamDir,
self.uwgParamFileName)
if not os.path.exists(uwg_param_file_path):
raise Exception(
"Param file: '{}' does not exist.".format(uwg_param_file_path))
# Open .uwg file and feed csv data to initializeDataFile
try:
uwg_param_data = utilities.read_csv(uwg_param_file_path)
except Exception as e:
raise Exception("Failed to read .uwg file! {}".format(e.message))
# The initialize.uwg is read with a dictionary so that users changing
# line endings or line numbers doesn't make reading input incorrect
self._init_param_dict = {}
count = 0
while count < len(uwg_param_data):
row = uwg_param_data[count]
row = [row[i].replace(" ", "")
for i in xrange(len(row))] # strip white spaces
# Optional parameters might be empty so handle separately
is_optional_parameter = (
row != [] and \
(
row[0] == "albRoof" or \
row[0] == "vegRoof" or \
row[0] == "glzR" or \
row[0] == "hvac" or \
row[0] == "albWall" or \
row[0] == "SHGC"
)
)
if row == [] or "#" in row[0]:
count += 1
continue
elif row[0] == "SchTraffic":
# SchTraffic: 3 x 24 matrix
trafficrows = uwg_param_data[count + 1:count + 4]
self._init_param_dict[row[0]] = map(
lambda r: utilities.str2fl(r[:24]), trafficrows)
count += 4
elif row[0] == "bld":
#bld: 17 x 3 matrix
bldrows = uwg_param_data[count + 1:count + 17]
self._init_param_dict[row[0]] = map(
lambda r: utilities.str2fl(r[:3]), bldrows)
count += 17
elif is_optional_parameter:
self._init_param_dict[row[0]] = float(
row[1]) if row[1] != "" else None
count += 1
else:
self._init_param_dict[row[0]] = float(row[1])
count += 1
ipd = self._init_param_dict
# Define Simulation and Weather parameters
if self.Month is None: self.Month = ipd['Month']
if self.Day is None: self.Day = ipd['Day']
if self.nDay is None: self.nDay = ipd['nDay']
if self.dtSim is None: self.dtSim = ipd['dtSim']
if self.dtWeather is None: self.dtWeather = ipd['dtWeather']
# HVAC system and internal laod
if self.autosize is None: self.autosize = ipd['autosize']
if self.sensOcc is None: self.sensOcc = ipd['sensOcc']
if self.LatFOcc is None: self.LatFOcc = ipd['LatFOcc']
if self.RadFOcc is None: self.RadFOcc = ipd['RadFOcc']
if self.RadFEquip is None: self.RadFEquip = ipd['RadFEquip']
if self.RadFLight is None: self.RadFLight = ipd['RadFLight']
# Define Urban microclimate parameters
if self.h_ubl1 is None: self.h_ubl1 = ipd['h_ubl1']
if self.h_ubl2 is None: self.h_ubl2 = ipd['h_ubl2']
if self.h_ref is None: self.h_ref = ipd['h_ref']
if self.h_temp is None: self.h_temp = ipd['h_temp']
if self.h_wind is None: self.h_wind = ipd['h_wind']
if self.c_circ is None: self.c_circ = ipd['c_circ']
if self.c_exch is None: self.c_exch = ipd['c_exch']
if self.maxDay is None: self.maxDay = ipd['maxDay']
if self.maxNight is None: self.maxNight = ipd['maxNight']
if self.windMin is None: self.windMin = ipd['windMin']
if self.h_obs is None: self.h_obs = ipd['h_obs']
# Urban characteristics
if self.bldHeight is None: self.bldHeight = ipd['bldHeight']
if self.h_mix is None: self.h_mix = ipd['h_mix']
if self.bldDensity is None: self.bldDensity = ipd['bldDensity']
if self.verToHor is None: self.verToHor = ipd['verToHor']
if self.charLength is None: self.charLength = ipd['charLength']
if self.alb_road is None: self.alb_road = ipd['albRoad']
if self.d_road is None: self.d_road = ipd['dRoad']
if self.sensAnth is None: self.sensAnth = ipd['sensAnth']
if self.latAnth is None: self.latAnth = ipd['latAnth']
# climate Zone
if self.zone is None: self.zone = ipd['zone']
# Vegetation parameters
if self.vegCover is None: self.vegCover = ipd['vegCover']
if self.treeCoverage is None: self.treeCoverage = ipd['treeCoverage']
if self.vegStart is None: self.vegStart = ipd['vegStart']
if self.vegEnd is None: self.vegEnd = ipd['vegEnd']
if self.albVeg is None: self.albVeg = ipd['albVeg']
if self.rurVegCover is None: self.rurVegCover = ipd['rurVegCover']
if self.latGrss is None: self.latGrss = ipd['latGrss']
if self.latTree is None: self.latTree = ipd['latTree']
# Define Traffic schedule
if self.SchTraffic is None: self.SchTraffic = ipd['SchTraffic']
# Define Road (Assume 0.5m of asphalt)
if self.kRoad is None: self.kRoad = ipd['kRoad']
if self.cRoad is None: self.cRoad = ipd['cRoad']
# Building stock fraction
if self.bld is None: self.bld = ipd['bld']
# Optional parameters
if self.albRoof is None: self.albRoof = ipd['albRoof']
if self.vegRoof is None: self.vegRoof = ipd['vegRoof']
if self.glzR is None: self.glzR = ipd['glzR']
if self.albWall is None: self.albWall = ipd['albWall']
if self.SHGC is None: self.SHGC = ipd['SHGC']