def test_skew(self):
""" Test the skew of an image """
test_dir = os.path.dirname(os.path.abspath(__file__))
# read in the dem from the gold file as we're
# comparing the arrays at the end and it will
# ensure that the bit resolution is kept
infile = os.path.join(
test_dir, 'Lakes/gold_ipw/gold_dem.ipw')
d = ipw.IPW(infile)
gold_dem = d.bands[0].data
for angle in range(-45, 45, 5):
# Get the IPW gold skew values
gold = ipw.IPW(
os.path.join(
test_dir,
'Lakes/gold_ipw/skew/skew_{}.ipw'.format(angle)
)
)
gold_data = gold.bands[0].data
# skew the initial array
sarr = skew(gold_dem, angle=angle, fill_min=True)
self.assertTrue(np.array_equal(sarr, gold_data))
# skew it back to original
sbarr = skew(sarr, angle=angle, fwd=False)
self.assertTrue(np.array_equal(sbarr, gold_dem))
def get_timestep_ipw(tstep, input_list, ppt_list, myawsm):
"""
Pull out a time step from the forcing files (IPW) and
place that time step into a dict
Args:
tstep: datetime of time step
input_list: numpy array (1D) of integer time steps given
ppt_list: numpy array(1D) of integer time steps for ppt_list
myawsm: AWSM instance for current run
Returns:
inpt: dictionary of forcing variable images
"""
inpt = {}
# map function from these values to the ones required by snobal
map_val = {1: 'T_a', 5: 'S_n', 0: 'I_lw', 2: 'e_a', 3: 'u'}
map_val_prec = {0: 'm_pp', 1: 'percent_snow', 2: 'rho_snow', 3: 'T_pp'}
# get wy hour
wyhr = int(utils.water_day(tstep)[0] * 24)
# if we have inputs matching this water year hour
if np.any(input_list == wyhr):
i_in = ipw.IPW(os.path.join(myawsm.pathi, 'in.%04i' % (wyhr)))
# assign soil temp
inpt['T_g'] = myawsm.soil_temp * np.ones(
(myawsm.topo.ny, myawsm.topo.nx))
# myawsm._logger.info('T_g: {}'.format(myawsm.soil_temp))
# inpt['T_g'] = -2.5*np.ones((myawsm.topo.ny, myawsm.topo.nx))
for f, v in map_val.items():
# if no solar data, give it zero
if f == 5 and len(i_in.bands) < 6:
# myawsm._logger.info('No solar data for {}'.format(tstep))
inpt[v] = np.zeros((myawsm.topo.ny, myawsm.topo.nx))
else:
inpt[v] = i_in.bands[f].data
# assign ppt data if there
else:
raise ValueError('No input time steps for {}'.format(tstep))
if np.any(ppt_list == wyhr):
i_ppt = ipw.IPW(os.path.join(myawsm.path_ppt, 'ppt.4b_%04i' % (wyhr)))
for f, v in map_val_prec.items():
inpt[v] = i_ppt.bands[f].data
else:
for f, v in map_val_prec.items():
inpt[v] = np.zeros((myawsm.topo.ny, myawsm.topo.nx))
# convert from C to K
inpt['T_a'] += FREEZE
inpt['T_pp'] += FREEZE
inpt['T_g'] += FREEZE
return inpt
def get_ipw(self):
"""
Set init fields for iSnobal out as init file
"""
i_in = ipw.IPW(self.init_file)
self.init['z_0'] = i_in.bands[1].data * self.topo.mask # snow depth
self.logger.warning(
'Using roughness from iSnobal ipw init file for initializing of model!'
)
self.init['z_s'] = i_in.bands[2].data * self.topo.mask # snow depth
self.init['rho'] = i_in.bands[3].data * self.topo.mask # snow density
self.init[
'T_s_0'] = i_in.bands[4].data * self.topo.mask # active layer temp
# get bands depending on if there is a lower layer or not
if len(i_in.bands) == 8:
self.init['T_s_l'] = i_in.bands[
5].data * self.topo.mask # lower layer temp
self.init['T_s'] = i_in.bands[
6].data * self.topo.mask # avgerage snow temp
self.init['h2o_sat'] = i_in.bands[
7].data * self.topo.mask # percent saturation
elif len(i_in.bands) == 7:
self.init['T_s'] = i_in.bands[
5].data * self.topo.mask # avgerage snow temp
self.init['h2o_sat'] = i_in.bands[
6].data * self.topo.mask # percent saturation
def write_init(self):
"""
Write the iSnobal init file
"""
# get mask
mask = self.topo.mask
# make ipw init file
i_out = ipw.IPW()
i_out.new_band(self.init['elevation'])
i_out.new_band(self.init['z_0'])
i_out.new_band(self.init['z_s'] * mask) # snow depth
i_out.new_band(self.init['rho'] * mask) # snow density
i_out.new_band(self.init['T_s_0'] * mask) # active layer temp
if self.start_wyhr > 0 or self.restart_crash:
i_out.new_band(self.init['T_s_l'] * mask) # lower layer temp
i_out.new_band(self.init['T_s'] * mask) # avgerage snow temp
i_out.new_band(self.init['h2o_sat'] * mask) # percent saturatio
i_out.add_geo_hdr([self.topo.u, self.topo.v],
[self.topo.du, self.topo.dv], self.topo.units,
self.csys)
i_out.write(self.fp_init, 16)
def setUpClass(cls):
test_dir = os.path.dirname(os.path.abspath(__file__))
# input DEM
infile = os.path.join(test_dir, 'Lakes/gold_ipw/gold_dem.ipw')
d = ipw.IPW(infile)
# C code for hor1d is expecting double
# the LQ headers have added some small values in the
# linearization of the image
cls.gold_dem = np.double(d.bands[0].data)
cls.spacing = d.bands[0].dline
# Horizon gold files
cls.gold_file = os.path.join(test_dir,
'Lakes/gold_ipw/horizon/horizon_{}.ipw')
# to make a fair comparison, first convert the hcos to
# integers then back using the 16 bit LQ
# with horizon the float min/max are constant from 0-1
cls.float_min = 1.0
cls.float_max = 0.0
cls.int_min = 0
cls.int_max = 2**16 - 1
def calc_vis(self, min_storm_day, wy_day, tz_min_west, wyear, cosz,
azimuth):
"""
Run ``stoporad`` for the visible bands
Args:
min_storm_day: decimal day of last storm for the entire basin, from
:mod:`smrf.distribute.precip.ppt.last_storm_day_basin`
wy_day: day of water year, from
:mod:`~smrf.distirbute.solar.solar.radiation_dates`
tz_min_west: time zone in minutes west from UTC, from
:mod:`~smrf.distirbute.solar.solar.radiation_dates`
wyear: water year, from
:mod:`~smrf.distirbute.solar.solar.radiation_dates`
cosz: cosine of the zenith angle for the basin, from
:mod:`smrf.envphys.radiation.sunang`
azimuth: azimuth to the sun for the basin, from
:mod:`smrf.envphys.radiation.sunang`
"""
self._logger.debug('Calculating clear sky radiation, visible')
vis_cmd = 'stoporad -z %i -t %s -w %s -g %s -x 0.28,0.7 -s %s'\
' -d %s -f %i -y %i -A %f,%f -a %i -m %i -c %i -D %s > %s' \
% (self.config['clear_opt_depth'],
str(self.config['clear_tau']),
str(self.config['clear_omega']),
str(self.config['clear_gamma']),
str(min_storm_day),
str(wy_day),
tz_min_west,
wyear,
cosz,
azimuth,
self.albedoConfig['grain_size'],
self.albedoConfig['max_grain'],
self.albedoConfig['dirt'],
self.stoporad_in,
self.vis_file)
# self._logger.debug(vis_cmd)
visp = sp.Popen(vis_cmd,
shell=True,
env={
"PATH": os.environ['PATH'],
"WORKDIR": os.environ['WORKDIR']
})
stdoutdata, stderrdata = visp.communicate()
if visp.returncode != 0:
raise Exception('Clear sky for visible failed')
# load clear sky files back in
vis = ipw.IPW(self.vis_file)
clear_vis_beam = vis.bands[0].data
clear_vis_diffuse = vis.bands[1].data
return clear_vis_beam, clear_vis_diffuse
def get_ipw_out(self):
"""
Set init fields for iSnobal out as init file
"""
i_in = ipw.IPW(self.init_file)
self.init['z_s'] = i_in.bands[0].data * self.topo.mask # snow depth
self.init['rho'] = i_in.bands[1].data * self.topo.mask # snow density
self.init[
'T_s_0'] = i_in.bands[4].data * self.topo.mask # active layer temp
self.init[
'T_s_l'] = i_in.bands[5].data * self.topo.mask # lower layer temp
self.init[
'T_s'] = i_in.bands[6].data * self.topo.mask # avgerage snow temp
self.init['h2o_sat'] = i_in.bands[
8].data * self.topo.mask # percent saturation
def run_horizon(self, azimuth):
"""Run the horizon function for a given azimuth and
compare with the gold file
Arguments:
azimuth {float} -- azimuth to test
"""
hcos = horizon(azimuth, self.gold_dem, self.spacing)
# convert the numpy array from a float, to int and back
h_int = ipw.map_fn(hcos, self.float_min, self.float_max, self.int_min,
self.int_max)
h_float = self.int_to_float(h_int)
gold = ipw.IPW(self.gold_file.format(azimuth))
gold_data = gold.bands[0].data
return gold_data, h_float
def stoporadInput(self):
"""
Calculate the necessary input file for stoporad
The IPW and WORKDIR environment variables must be set
"""
# if self.topoConfig['type'] != 'ipw':
#
f = os.path.abspath(
os.path.expanduser(os.path.join(self.tempDir, 'dem.ipw')))
i = ipw.IPW()
i.new_band(self.dem)
i.add_geo_hdr([self.x[0], self.y[0]],
[np.mean(np.diff(self.x)),
np.mean(np.diff(self.y))], 'm', 'UTM')
i.write(f, 16)
self.topoConfig['dem'] = f
# calculate the skyview
svfile = os.path.abspath(
os.path.expanduser(os.path.join(self.tempDir, 'sky_view.ipw')))
self._logger.debug('sky view file - %s' % svfile)
# calculate the gradient
gfile = os.path.abspath(
os.path.expanduser(os.path.join(self.tempDir, 'gradient.ipw')))
self._logger.debug('gradient file - %s' % gfile)
if self.threaded:
ts = Process(target=self._viewf,
args=(self.topoConfig['dem'], svfile))
ts.start()
tg = Process(target=self._gradient,
args=(self.topoConfig['dem'], gfile))
tg.start()
# wait for the processes to stop
tg.join()
ts.join()
else:
self._viewf(self.topoConfig['dem'], svfile)
self._gradient(self.topoConfig['dem'], gfile)
# combine into a value
sfile = os.path.abspath(
os.path.expanduser(os.path.join(self.tempDir, 'stoporad_in.ipw')))
self._logger.debug('stoporad in file - %s' % sfile)
cmd = 'mux %s %s %s > %s' % (self.topoConfig['dem'], gfile, svfile,
sfile)
proc = sp.Popen(cmd, shell=True).wait()
if proc != 0:
raise OSError('mux for stoporad_in.ipw failed')
# read in the stoporad file to store in memory
self.stoporad_in = ipw.IPW(sfile)
self.stoporad_in_file = sfile
self.slope = self.stoporad_in.bands[1].data.astype(np.float64)
self.aspect = self.stoporad_in.bands[2].data.astype(np.float64)
self.sky_view = self.stoporad_in.bands[3].data.astype(np.float64)
# clean up the WORKDIR
os.remove(gfile)
os.remove(svfile)
os.remove(self.topoConfig['dem'])
self.topoConfig.pop('dem', None)
def do_update_isnobal(self, myawsm, update_info, update_snow, x, y):
"""
Function to read in an output file and update it with the lidar depth field
Argument:
myawsm: instantiated awsm class
update_info: update info pandas at correct index
update_snow: file pointer to snow update image
x: x vector
y: y vector
Returns:
init_file: file pointer to init image
"""
# get some info
update_number = update_info['number']
date = update_info['date_time']
wyhr = update_info['wyhr']
last_snow_image = ipw.IPW(update_snow)
z_s = last_snow_image.bands[0].data # Get modeled depth image.
# z_s(mask==0) = NaN;
## Continue as before:
density = last_snow_image.bands[1].data.copy() # Get density image.
## ## ## ## ## ## ## ## ## %
# SPECIAL CASE... insert adjusted densities here:
# density = arcgridread_v2(['/Volumes/data/blizzard/Tuolumne/lidar/snowon/2017' ...
# '/adjusted_rho/TB2017' date_mmdd '_operational_rho_ARSgrid_50m.asc']);
## ## ## ## ## ## ## ## ## %
m_s = last_snow_image.bands[2].data.copy() # Get SWE image.
T_s_0 = last_snow_image.bands[4].data.copy(
) # Get active snow layer temperature image
T_s_l = last_snow_image.bands[5].data.copy(
) # Get lower snow layer temperature image
T_s = last_snow_image.bands[6].data.copy(
) # Get average snowpack temperature image
h2o_sat = last_snow_image.bands[8].data.copy(
) # Get liquid water saturation image
updated_fields = self.hedrick_updating_procedure(
m_s, T_s_0, T_s_l, T_s, h2o_sat, density, z_s, x, y, update_info)
# write init file
out_file = 'init_update_{}_wyhr{:04d}.ipw'.format(update_number, wyhr)
init_file = os.path.join(self.pathinit, out_file)
i_out = ipw.IPW()
i_out.new_band(updated_fields['dem'])
i_out.new_band(updated_fields['z0'])
i_out.new_band(updated_fields['D'])
i_out.new_band(updated_fields['rho'])
i_out.new_band(updated_fields['T_s_0'])
i_out.new_band(updated_fields['T_s_l'])
i_out.new_band(updated_fields['T_s'])
i_out.new_band(updated_fields['h2o_sat'])
#i_out.add_geo_hdr([u, v], [du, dv], units, csys)
i_out.add_geo_hdr([self.topo.u, self.topo.v],
[self.topo.du, self.topo.dv], self.topo.units,
self.csys)
i_out.write(init_file, self.nbits)
## Import newly-created init file and look at images to make sure they line up:
self._logger.info('Wrote ipw image for update {}'.format(wyhr))
return init_file
def ipw2nc_mea(myawsm, runtype):
'''
Function to create netcdf files from iSnobal output. Reads the snow and em
ouptuts in the 'output' folder and stores them in snow.nc and em.nc one
directory up.
Args:
myawsm: AWSM instance
runtype: either 'smrf' for standard run or 'forecast' for gridded data run
'''
myawsm._logger.info("making the NetCDF files from ipw"
" files for {}".format(runtype))
if runtype != 'smrf' and runtype != 'forecast':
myawsm._logger.error('Wrong run type given to ipw2nc. '
'not smrf or forecast')
sys.exit()
myawsm._logger.info("convert all .ipw output files to netcdf files")
#######################################################################
# Convert all .ipw output files to netcdf files #####################
#######################################################################
time_zone = myawsm.tmz
# create the x,y vectors
x = myawsm.topo.x
y = myawsm.topo.y
# ========================================================================
# NetCDF EM image
# ========================================================================
m = {}
m['name'] = [
'net_rad', 'sensible_heat', 'latent_heat', 'snow_soil',
'precip_advected', 'sum_EB', 'evaporation', 'snowmelt', 'SWI',
'cold_content'
]
m['units'] = [
'W m-2', 'W m-2', 'W m-2', 'W m-2', 'W m-2', 'W m-2', 'kg m-2',
'kg m-2', 'kg or mm m-2', 'J m-2'
]
m['description'] = [
'Average net all-wave radiation', 'Average sensible heat transfer',
'Average latent heat exchange', 'Average snow/soil heat exchange',
'Average advected heat from precipitation',
'Average sum of EB terms for snowcover', 'Total evaporation',
'Total snowmelt', 'Total runoff', 'Snowcover cold content'
]
if runtype == 'smrf':
netcdfFile = os.path.join(myawsm.pathrr, 'em.nc')
elif runtype == 'forecast':
netcdfFile = os.path.join(myawsm.pathrr, 'em_forecast.nc')
dimensions = ('time', 'y', 'x')
em = nc.Dataset(netcdfFile, 'w')
# create the dimensions
em.createDimension('time', None)
em.createDimension('y', myawsm.topo.ny)
em.createDimension('x', myawsm.topo.nx)
# create some variables
em.createVariable('time', 'f', dimensions[0])
em.createVariable('y', 'f', dimensions[1])
em.createVariable('x', 'f', dimensions[2])
setattr(em.variables['time'], 'units', 'hours since %s' % myawsm.wy_start)
setattr(em.variables['time'], 'calendar', 'standard')
setattr(em.variables['time'], 'time_zone', time_zone)
em.variables['x'][:] = x
em.variables['y'][:] = y
# em image
for i, v in enumerate(m['name']):
em.createVariable(v, 'f', dimensions[:3], chunksizes=(24, 10, 10))
setattr(em.variables[v], 'units', m['units'][i])
setattr(em.variables[v], 'description', m['description'][i])
em.setncattr_string('source', 'AWSM {}'.format(myawsm.gitVersion))
# ========================================================================
# NetCDF SNOW image
# ========================================================================
s = {}
s['name'] = [
'thickness', 'snow_density', 'specific_mass', 'liquid_water',
'temp_surf', 'temp_lower', 'temp_snowcover', 'thickness_lower',
'water_saturation'
]
s['units'] = [
'm', 'kg m-3', 'kg m-2', 'kg m-2', 'C', 'C', 'C', 'm', 'percent'
]
s['description'] = [
'Predicted thickness of the snowcover',
'Predicted average snow density',
'Predicted specific mass of the snowcover',
'Predicted mass of liquid water in the snowcover',
'Predicted temperature of the surface layer',
'Predicted temperature of the lower layer',
'Predicted temperature of the snowcover',
'Predicted thickness of the lower layer',
'Predicted percentage of liquid water'
' saturation of the snowcover'
]
if runtype == 'smrf':
netcdfFile = os.path.join(myawsm.pathrr, 'snow.nc')
elif runtype == 'forecast':
netcdfFile = os.path.join(myawsm.pathrr, 'snow_forescast.nc')
dimensions = ('time', 'y', 'x')
snow = nc.Dataset(netcdfFile, 'w')
# create the dimensions
snow.createDimension('time', None)
snow.createDimension('y', myawsm.topo.ny)
snow.createDimension('x', myawsm.topo.nx)
# create some variables
snow.createVariable('time', 'f', dimensions[0])
snow.createVariable('y', 'f', dimensions[1])
snow.createVariable('x', 'f', dimensions[2])
setattr(snow.variables['time'], 'units',
'hours since %s' % myawsm.wy_start)
setattr(snow.variables['time'], 'calendar', 'standard')
setattr(snow.variables['time'], 'time_zone', time_zone)
snow.variables['x'][:] = x
snow.variables['y'][:] = y
# snow image
for i, v in enumerate(s['name']):
snow.createVariable(v, 'f', dimensions[:3], chunksizes=(6, 10, 10))
setattr(snow.variables[v], 'units', s['units'][i])
setattr(snow.variables[v], 'description', s['description'][i])
h = '[{}] Data added or updated'.format(datetime.now().strftime("%Y%m%d"))
snow.setncattr_string('last modified', h)
snow.setncattr_string('AWSM version', myawsm.gitVersion)
if myawsm.do_smrf:
snow.setncattr_string('SMRF version', myawsm.smrf_version)
# =======================================================================
# Get all files in the directory, open ipw file, and add to netCDF
# =======================================================================
# get all the files in the directory
d = sorted(glob.glob("%s/snow*" % myawsm.pathro), key=os.path.getmtime)
d.sort(key=lambda f: os.path.splitext(f))
# find a drop any netcdfs in directory
d = [ddp for ddp in d if '.nc' not in ddp]
# pbar = progressbar.ProgressBar(max_value=len(d)).start()
j = 0
for idf, f in enumerate(d):
# print out counter at certain percentages. pbar doesn't play nice
# with logging
if j == int(len(d) / 4):
myawsm._logger.info("25 percent finished with "
"making NetCDF files!")
if j == int(len(d) / 2):
myawsm._logger.info("50 percent finished with "
"making NetCDF files!")
if j == int(3 * len(d) / 4):
myawsm._logger.info("75 percent finished with "
"making NetCDF files!")
# get the hr
nm = os.path.basename(f)
head = os.path.dirname(f)
hr = int(nm.split('.')[1])
# hr = int(hr)
snow.variables['time'][j] = hr # +1
em.variables['time'][j] = hr # +1
# Read the IPW file
i = ipw.IPW(f)
# output to the snow netcdf file
for b, var in enumerate(s['name']):
snow.variables[var][j, :] = i.bands[b].data
# output to the em netcdf file
# emFile = "%s/%s.%04i" % (head, 'em', hr)
emFile = os.path.join(head, 'em.%04i' % (hr))
i_em = ipw.IPW(emFile)
for b, var in enumerate(m['name']):
em.variables[var][j, :] = i_em.bands[b].data
snow.setncattr_string('last modified', h)
snow.setncattr_string('AWSM version', myawsm.gitVersion)
if myawsm.do_smrf:
snow.setncattr_string('SMRF version', myawsm.smrf_version)
em.sync()
snow.sync()
j += 1
# pbar.update(j)
# pbar.finish()
snow.close()
em.close()
myawsm._logger.info("Finished making the NetCDF "
"files from iSnobal output!")
def nc2ipw_mea(myawsm, runtype):
'''
Function to create iSnobal forcing and precip images from smrf ouputs. Reads
in all of the SMRF forcing outputs and converts them into input and ppt
images in the 'input' and 'ppt_4b' directories. Also writes the ppt_desc
file.
Args:
myawsm: AWSM instance
runtype: either 'smrf' for standard run or 'forecast' for gridded data run
'''
################################################################
# Make .ipw input files from netCDF files ####################
################################################################
myawsm._logger.info("making the ipw files"
" from NetCDF files for {}".format(runtype))
if runtype != 'smrf' and runtype != 'forecast':
myawsm._logger.error('Wrong run type given to nc2ipw. '
'not smrf or forecast')
sys.exit()
tt = myawsm.start_date - myawsm.wy_start
smrfpath = myawsm.paths
datapath = myawsm.pathdd
f = open(myawsm.ppt_desc, 'w')
offset = tt.days * 24 + tt.seconds // 3600 # start index for the input file
# File paths
th = os.path.join(smrfpath, 'thermal.nc')
th_var = 'thermal'
ta = os.path.join(smrfpath, 'air_temp.nc')
ta_var = 'air_temp'
ea = os.path.join(smrfpath, 'vapor_pressure.nc')
ea_var = 'vapor_pressure'
wind = os.path.join(smrfpath, 'wind_speed.nc')
wind_var = 'wind_speed'
sn = os.path.join(smrfpath, 'net_solar.nc')
sn_var = 'net_solar'
in_path = os.path.join(datapath, 'input/')
mp = os.path.join(smrfpath, 'precip.nc')
mp_var = 'precip'
ps = os.path.join(smrfpath, 'percent_snow.nc')
ps_var = 'percent_snow'
rho = os.path.join(smrfpath, 'snow_density.nc')
rho_var = 'snow_density'
tp = os.path.join(smrfpath, 'precip_temp.nc')
tp_var = 'precip_temp'
in_pathp = os.path.join(datapath, 'ppt_4b')
th_file = nc.Dataset(th, 'r')
ta_file = nc.Dataset(ta, 'r')
ea_file = nc.Dataset(ea, 'r')
wind_file = nc.Dataset(wind, 'r')
sn_file = nc.Dataset(sn, 'r')
mp_file = nc.Dataset(mp, 'r')
ps_file = nc.Dataset(ps, 'r')
rho_file = nc.Dataset(rho, 'r')
tp_file = nc.Dataset(tp, 'r')
N = th_file.variables[th_var].shape[0]
# timeStep = np.arange(0,N) # timesteps loop through
timeStep = np.arange(offset, N + offset) # timesteps loop through
# pbar = progressbar.ProgressBar(max_value=len(timeStep)).start()
j = 0
for idxt, t in enumerate(timeStep):
if j == int(len(timeStep) / 4):
myawsm._logger.info("25 percent finished with "
"making IPW input files!")
if j == int(len(timeStep) / 2):
myawsm._logger.info("50 percent finished with "
"making IPW input files!")
if j == int(3 * len(timeStep) / 4):
myawsm._logger.info("75 percent finished with "
"making IPW input files!")
# print('idxt: {} t: {}'.format(idxt, t))
trad_step = th_file.variables[th_var][idxt, :]
ta_step = ta_file.variables[ta_var][idxt, :]
ea_step = ea_file.variables[ea_var][idxt, :]
wind_step = wind_file.variables[wind_var][idxt, :]
sn_step = sn_file.variables[sn_var][idxt, :]
mp_step = mp_file.variables[mp_var][idxt, :]
tg_step = np.ones_like(mp_step) * (myawsm.soil_temp) # ground temp
in_step = os.path.join(in_path, 'in.%04i' % (t))
i = ipw.IPW()
i.new_band(trad_step)
i.new_band(ta_step)
i.new_band(ea_step)
i.new_band(wind_step)
i.new_band(tg_step)
# add solar if the sun is up
if np.sum(sn_step) > 0:
i.new_band(sn_step)
i.add_geo_hdr([myawsm.topo.u, myawsm.topo.v],
[myawsm.topo.du, myawsm.topo.dv], myawsm.topo.units,
myawsm.csys)
i.write(in_step, myawsm.nbits)
# only output if precip
if np.sum(mp_step) > 0:
ps_step = ps_file.variables[ps_var][idxt, :]
rho_step = rho_file.variables[rho_var][idxt, :]
tp_step = tp_file.variables[tp_var][idxt, :]
in_stepp = os.path.join(os.path.abspath(in_pathp),
'ppt.4b_%04i' % (t))
i = ipw.IPW()
i.new_band(mp_step)
i.new_band(ps_step)
i.new_band(rho_step)
i.new_band(tp_step)
i.add_geo_hdr([myawsm.topo.u, myawsm.topo.v],
[myawsm.topo.du, myawsm.topo.dv], myawsm.topo.units,
myawsm.csys)
i.write(in_stepp, myawsm.nbits)
f.write('%i %s\n' % (t, in_stepp))
j += 1
# pbar.update(j)
th_file.close()
ta_file.close()
ea_file.close()
wind_file.close()
sn_file.close()
mp_file.close()
ps_file.close()
rho_file.close()
tp_file.close()
f.close()
# pbar.finish()
myawsm._logger.info("finished making the ipw "
"input and ppt files from NetCDF files")
# double percision error for the input
# Load the netcdf dem and get all the geo coords for IPW
topo_path = './tests/Lakes/topo.nc'
d = nc.Dataset(topo_path)
dem = np.round(d.variables['dem'][:])
d.close()
ts = get_topo_stats(topo_path)
csys = 'UTM'
nbits = 16
# Create the IPW image
i = ipw.IPW()
i.new_band(dem)
i.add_geo_hdr(coordinates=[ts['u'], ts['v']],
d=[ts['dv'], ts['du']],
units=ts['units'],
csys=csys)
i.write('./tests/Lakes/gold_ipw/gold_dem.ipw', nbits=nbits)
# Create a gradient ipw image (slope and aspect)
# in both 8 and 16 bit resolution
cmd = "gradient -i {0} ./tests/Lakes/gold_ipw/gold_dem.ipw >" \
"./tests/Lakes/gold_ipw/gold_gradient{0}.ipw"
for nbit in [8, 16]:
with subprocess.Popen(cmd.format(nbit),
maxus_file = 'maxus690_%i.asc'
var = 'maxus'
nFile = 'maxus.nc'
# maxus_file = 'tbreak90_%i.asc'
# var = 'tbreak'
# nFile = 'tbreak.nc'
maxusInd = range(0, 360, 5)
#------------------------------------------------------------------------------
# include the geohdr
# execfile('/media/Drobo1/BRB/BRB-wy09/grid_info.py')
dem = '/media/Drobo1/BRB/BRB-wy09/spatial_WRF_OG/data/topo/dem30m.ipw'
dem = ipw.IPW(dem)
nx = dem.nsamps
ny = dem.nlines
v = dem.bands[0].bsamp
dv = dem.bands[0].dsamp
u = dem.bands[0].bline
du = dem.bands[0].dline
# files = glob.glob(maxus_dir)
nfiles = len(maxusInd)
#===============================================================================
# Create netCDF file
#===============================================================================