def init_sequence(self):
self.t = 0
self.x = {}
self.h = {}
self.c = {}
self.ct = {}
self.input_gate = {}
self.forget_gate = {}
self.output_gate = {}
self.cell_update = {}
if hasattr(self, 'previous'):
self.h[0] = self.previous.h[self.previous.t]
self.c[0] = self.previous.c[self.previous.t]
else:
self.h[0] = zeros(self.hidden_size)
self.c[0] = zeros(self.hidden_size)
if hasattr(self, 'next'):
self.dh_prev = self.next.dh_prev
self.dc_prev = self.next.dc_prev
else:
self.dh_prev = zeros(self.hidden_size)
self.dc_prev = zeros(self.hidden_size)
for name, params, grad in self.params:
grad[:] = 0
def read_epw(self):
"""Section 2 - Read EPW file
properties:
self.climateDataPath
self.newPathName
self._header # header data
self.epwinput # timestep data for weather
self.lat # latitude
self.lon # longitude
self.GMT # GMT
self.nSoil # Number of soil depths
self.Tsoil # nSoil x 12 matrix for soil temperture (K)
self.depth_soil # nSoil x 1 matrix for soil depth (m)
"""
# Make dir path to epw file
self.climateDataPath = os.path.join(self.epwDir, self.epwFileName)
# Open epw file and feed csv data to climate_data
try:
climate_data = utilities.read_csv(self.climateDataPath)
except Exception as e:
raise Exception("Failed to read epw file! {}".format(e.message))
# Read header lines (1 to 8) from EPW and ensure TMY2 format.
self._header = climate_data[0:8]
# Read weather data from EPW for each time step in weather file. (lines 8 - end)
self.epwinput = climate_data[8:]
# Read Lat, Long (line 1 of EPW)
self.lat = float(self._header[0][6])
self.lon = float(self._header[0][7])
self.GMT = float(self._header[0][8])
# Read in soil temperature data (assumes this is always there)
# ref: http://bigladdersoftware.com/epx/docs/8-2/auxiliary-programs/epw-csv-format-inout.html
soilData = self._header[3]
self.nSoil = int(soilData[1]) # Number of ground temperature depths
self.Tsoil = utilities.zeros(
self.nSoil, 12) # nSoil x 12 matrix for soil temperture (K)
self.depth_soil = utilities.zeros(
self.nSoil, 1) # nSoil x 1 matrix for soil depth (m)
# Read monthly data for each layer of soil from EPW file
for i in xrange(self.nSoil):
self.depth_soil[i][0] = float(
soilData[2 + (i * 16)]) # get soil depth for each nSoil
# Monthly data
for j in xrange(12):
self.Tsoil[i][j] = float(soilData[
6 + (i * 16) +
j]) + 273.15 # 12 months of soil T for specific depth
# Set new directory path for the moprhed EPW file
self.newPathName = os.path.join(self.destinationDir,
self.destinationFileName)
def init_input_obj(self):
"""Section 4 - Create UWG objects from input parameters
self.simTime # simulation time parameter obj
self.weather # weather obj for simulation time period
self.forcIP # Forcing obj
self.forc # Empty forcing obj
self.geoParam # geographic parameters obj
self.RSM # Rural site & vertical diffusion model obj
self.USM # Urban site & vertical diffusion model obj
self.UCM # Urban canopy model obj
self.UBL # Urban boundary layer model
self.road # urban road element
self.rural # rural road element
self.soilindex1 # soil index for urban rsoad depth
self.soilindex2 # soil index for rural road depth
self.BEM # list of BEMDef objects
self.Sch # list of Schedule objects
"""
climate_file_path = os.path.join(self.epwDir, self.epwFileName)
self.simTime = SimParam(self.dtSim, self.dtWeather, self.Month,
self.Day,
self.nDay) # simulation time parametrs
self.weather = Weather(
climate_file_path, self.simTime.timeInitial, self.simTime.timeFinal
) # weather file data for simulation time period
self.forcIP = Forcing(self.weather.staTemp,
self.weather) # initialized Forcing class
self.forc = Forcing() # empty forcing class
# Initialize geographic Param and Urban Boundary Layer Objects
nightStart = 18. # arbitrary values for begin/end hour for night setpoint
nightEnd = 8.
maxdx = 250.
# max dx (m)
self.geoParam = Param(self.h_ubl1,self.h_ubl2,self.h_ref,self.h_temp,self.h_wind,self.c_circ,\
self.maxDay,self.maxNight,self.latTree,self.latGrss,self.albVeg,self.vegStart,self.vegEnd,\
nightStart,nightEnd,self.windMin,self.WGMAX,self.c_exch,maxdx,self.G,self.CP,self.VK,self.R,\
self.RV,self.LV,math.pi,self.SIGMA,self.WATERDENS,self.LVTT,self.TT,self.ESTT,self.CL,\
self.CPV,self.B, self.CM, self.COLBURN)
self.UBL = UBLDef('C', self.charLength, self.weather.staTemp[0], maxdx,
self.geoParam.dayBLHeight,
self.geoParam.nightBLHeight)
# Defining road
emis = 0.93
asphalt = Material(self.kRoad, self.cRoad, 'asphalt')
road_T_init = 293.
road_horizontal = 1
road_veg_coverage = min(self.vegCover / (1 - self.bldDensity),
1.) # fraction of surface vegetation coverage
# define road layers
road_layer_num = int(math.ceil(self.d_road / 0.05))
thickness_vector = map(lambda r: 0.05, range(
road_layer_num)) # 0.5/0.05 ~ 10 x 1 matrix of 0.05 thickness
material_vector = map(lambda n: asphalt, range(road_layer_num))
self.road = Element(self.alb_road,emis,thickness_vector,material_vector,road_veg_coverage,\
road_T_init,road_horizontal,name="urban_road")
self.rural = copy.deepcopy(self.road)
self.rural.vegCoverage = self.rurVegCover
self.rural._name = "rural_road"
# Define BEM for each DOE type (read the fraction)
if not os.path.exists(self.readDOE_file_path):
raise Exception("readDOE.pkl file: '{}' does not exist.".format(
readDOE_file_path))
readDOE_file = open(self.readDOE_file_path,
'rb') # open pickle file in binary form
refDOE = cPickle.load(readDOE_file)
refBEM = cPickle.load(readDOE_file)
refSchedule = cPickle.load(readDOE_file)
readDOE_file.close()
# Define building energy models
k = 0
r_glaze = 0 # Glazing ratio for total building stock
SHGC = 0 # SHGC addition for total building stock
alb_wall = 0 # albedo wall addition for total building stock
h_floor = self.flr_h or 3.05 # average floor height
total_urban_bld_area = math.pow(
self.charLength, 2
) * self.bldDensity * self.bldHeight / h_floor # total building floor area
area_matrix = utilities.zeros(16, 3)
self.BEM = [] # list of BEMDef objects
self.Sch = [] # list of Schedule objects
for i in xrange(16): # 16 building types
for j in xrange(3): # 3 built eras
if self.bld[i][j] > 0.:
# Add to BEM list
self.BEM.append(refBEM[i][j][self.zone])
self.BEM[k].frac = self.bld[i][j]
self.BEM[k].fl_area = self.bld[i][j] * total_urban_bld_area
# Overwrite with optional parameters if provided
if self.glzR:
self.BEM[k].building.glazingRatio = self.glzR
if self.albRoof:
self.BEM[k].roof.albedo = self.albRoof
if self.vegRoof:
self.BEM[k].roof.vegCoverage = self.vegRoof
if self.SHGC:
self.BEM[k].building.shgc = self.SHGC
if self.albWall:
self.BEM[k].wall.albedo = self.albWall
# Keep track of total urban r_glaze, SHGC, and alb_wall for UCM model
r_glaze = r_glaze + self.BEM[k].frac * self.BEM[
k].building.glazingRatio ##
SHGC = SHGC + self.BEM[k].frac * self.BEM[k].building.shgc
alb_wall = alb_wall + self.BEM[k].frac * self.BEM[
k].wall.albedo
# Add to schedule list
self.Sch.append(refSchedule[i][j][self.zone])
k += 1
# Reference site class (also include VDM)
self.RSM = RSMDef(self.lat, self.lon, self.GMT, self.h_obs,
self.weather.staTemp[0], self.weather.staPres[0],
self.geoParam, self.z_meso_dir_path)
self.USM = RSMDef(self.lat, self.lon, self.GMT, self.bldHeight / 10.,
self.weather.staTemp[0], self.weather.staPres[0],
self.geoParam, self.z_meso_dir_path)
T_init = self.weather.staTemp[0]
H_init = self.weather.staHum[0]
self.UCM = UCMDef(self.bldHeight,self.bldDensity,self.verToHor,self.treeCoverage,self.sensAnth,self.latAnth,T_init,H_init,\
self.weather.staUmod[0],self.geoParam,r_glaze,SHGC,alb_wall,self.road)
self.UCM.h_mix = self.h_mix
# Define Road Element & buffer to match ground temperature depth
roadMat, newthickness = procMat(self.road, self.MAXTHICKNESS,
self.MINTHICKNESS)
for i in xrange(self.nSoil):
# if soil depth is greater then the thickness of the road
# we add new slices of soil at max thickness until road is greater or equal
is_soildepth_equal = self.is_near_zero(
self.depth_soil[i][0] - sum(newthickness), 1e-15)
if is_soildepth_equal or (self.depth_soil[i][0] >
sum(newthickness)):
while self.depth_soil[i][0] > sum(newthickness):
newthickness.append(self.MAXTHICKNESS)
roadMat.append(self.SOIL)
self.soilindex1 = i
break
self.road = Element(self.road.albedo, self.road.emissivity, newthickness, roadMat,\
self.road.vegCoverage, self.road.layerTemp[0], self.road.horizontal, self.road._name)
# Define Rural Element
ruralMat, newthickness = procMat(self.rural, self.MAXTHICKNESS,
self.MINTHICKNESS)
for i in xrange(self.nSoil):
# if soil depth is greater then the thickness of the road
# we add new slices of soil at max thickness until road is greater or equal
is_soildepth_equal = self.is_near_zero(
self.depth_soil[i][0] - sum(newthickness), 1e-15)
if is_soildepth_equal or (self.depth_soil[i][0] >
sum(newthickness)):
while self.depth_soil[i][0] > sum(newthickness):
newthickness.append(self.MAXTHICKNESS)
ruralMat.append(self.SOIL)
self.soilindex2 = i
break
self.rural = Element(self.rural.albedo, self.rural.emissivity, newthickness,\
ruralMat,self.rural.vegCoverage,self.rural.layerTemp[0],self.rural.horizontal, self.rural._name)
def init_BEM_obj(self):
"""
Define BEM for each DOE type (read the fraction)
self.BEM # list of BEMDef objects
self.r_glaze # Glazing ratio for total building stock
self.SHGC # SHGC addition for total building stock
self.alb_wall # albedo wall addition for total building stock
"""
if not os.path.exists(self.readDOE_file_path):
raise Exception("readDOE.pkl file: '{}' does not exist.".format(readDOE_file_path))
readDOE_file = open(self.readDOE_file_path, 'rb') # open pickle file in binary form
refDOE = cPickle.load(readDOE_file)
refBEM = cPickle.load(readDOE_file)
refSchedule = cPickle.load(readDOE_file)
readDOE_file.close()
# Define building energy models
k = 0
self.r_glaze_total = 0. # Glazing ratio for total building stock
self.SHGC_total = 0. # SHGC addition for total building stock
self.alb_wall_total = 0. # albedo wall addition for total building stock
h_floor = self.flr_h or 3.05 # average floor height
total_urban_bld_area = math.pow(self.charLength, 2)*self.bldDensity * \
self.bldHeight/h_floor # total building floor area
area_matrix = utilities.zeros(16, 3)
self.BEM = [] # list of BEMDef objects
self.Sch = [] # list of Schedule objects
for i in xrange(16): # 16 building types
for j in xrange(3): # 3 built eras
if self.bld[i][j] > 0.:
# Add to BEM list
self.BEM.append(refBEM[i][j][self.zone])
self.BEM[k].frac = self.bld[i][j]
self.BEM[k].fl_area = self.bld[i][j] * total_urban_bld_area
# Overwrite with optional parameters if provided
if self.glzR:
self.BEM[k].building.glazingRatio = self.glzR
if self.albRoof:
self.BEM[k].roof.albedo = self.albRoof
if self.vegRoof:
self.BEM[k].roof.vegCoverage = self.vegRoof
if self.SHGC:
self.BEM[k].building.shgc = self.SHGC
if self.albWall:
self.BEM[k].wall.albedo = self.albWall
if self.flr_h:
self.BEM[k].building.floorHeight = self.flr_h
# Keep track of total urban r_glaze, SHGC, and alb_wall for UCM model
self.r_glaze_total += self.BEM[k].frac * self.BEM[k].building.glazingRatio
self.SHGC_total += self.BEM[k].frac * self.BEM[k].building.shgc
self.alb_wall_total += self.BEM[k].frac * self.BEM[k].wall.albedo
# Add to schedule list
self.Sch.append(refSchedule[i][j][self.zone])
k += 1
def __init__(self, input_size: int,
hidden_size: int,
init_range: float = 1.0,
previous=None):
self.input_size = input_size
self.hidden_size = hidden_size
if previous:
self.previous = previous
previous.next = self
def init(x: int, y: int):
return initalize((x, y), init_range)
h, n = hidden_size, input_size
self.W_hi, self.W_hf = init(h, h), init(h, h)
self.W_ho, self.W_hj = init(h, h), init(h, h)
self.W_xi, self.W_xf = init(h, n), init(h, n)
self.W_xo, self.W_xj = init(h, n), init(h, n)
self.b_i, self.b_f = zeros(h), ones(h) * 3
self.b_o, self.b_j = zeros(h), zeros(h)
self.dW_hi, self.dW_hf = zeros(h, h), zeros(h, h)
self.dW_ho, self.dW_hj = zeros(h, h), zeros(h, h)
self.dW_xi, self.dW_xf = zeros(h, n), zeros(h, n)
self.dW_xo, self.dW_xj = zeros(h, n), zeros(h, n)
self.db_i, self.db_f = zeros(h), zeros(h)
self.db_o, self.db_j = zeros(h), zeros(h)
self.params = [
('W_hi', self.W_hi, self.dW_hi),
('W_hf', self.W_hf, self.dW_hf),
('W_ho', self.W_ho, self.dW_ho),
('W_hj', self.W_hj, self.dW_hj),
('W_xi', self.W_xi, self.dW_xi),
('W_xf', self.W_xf, self.dW_xf),
('W_xo', self.W_xo, self.dW_xo),
('W_xj', self.W_xj, self.dW_xj),
('b_i', self.b_i, self.db_i),
('b_f', self.b_f, self.db_f),
('b_o', self.b_o, self.db_o),
('b_j', self.b_j, self.db_j),
]
self.init_sequence()