def initialize_initial_conditions_dict(pairs=None): """ :return: """ # read in initial soil moisture conditions from spin up, put in dict if pairs is None: print 'Using default initial inputs path: {}'.format(paths.initial_inputs) pairs = make_pairs(paths.initial_inputs, INITIAL_KEYS) d = {} print '-------------------------------------------------------' print ' Key Name' for k, p in pairs: print 'initial {:<20s} {}'.format(k, p) raster = Raster(p, root=paths.initial_inputs) data = raster.masked() d[k] = data nans = count_nonzero(isnan(data)) if nans: print '{} has {} nan values'.format(k, nans) nons = count_nonzero(data < 0.0) if nons: print '{} has {} negative values'.format(k, nons) print '-------------------------------------------------------\n' return d
def get_penman(date_object, variable='etrs'): """ Find PENMAN image. :param variable: type of PENMAN variable sought :type variable: str :param date_object: Datetime object of date. :return: numpy array object """ names = ('etrs', 'rlin', 'rg') if variable not in names: raise NotImplementedError('Invalid PENMAN variable name {}. must be in {}'.format(variable, names)) is_walnut_gulch = False # Changed for Walnut gulch NDVI naming convention year = date_object.year tail = '{}_{:03n}.tif'.format(year, date_object.timetuple().tm_yday) if variable == 'etrs': name = os.path.join('PM{}'.format(year), 'PM_NM_{}'.format(tail)) # default is this one elif variable == 'rlin': name = os.path.join('PM{}'.format(year), 'RLIN_NM_{}'.format(tail)) # Makes no sense. Not in directory. elif variable == 'rg': if is_walnut_gulch: name = os.path.join('rad{}'.format(year), 'RTOT_NM_{}'.format(tail)) else: name = os.path.join('rad{}'.format(year), 'RTOT_{}'.format(tail)) raster = Raster(name, root=paths.penman) return raster.masked()
def extract_mask(out, geo, bounds): raster = Raster(paths.mask) p = make_reduced_path(out, 'Mask', 'mask') arr = raster.masked() slice_and_save(p, arr, geo, *bounds) print 'mask reduced'
def initialize_initial_conditions_dict(pairs=None): """ :return: """ # read in initial soil moisture conditions from spin up, put in dict if pairs is None: print 'Using default initial inputs path: {}'.format( paths.initial_inputs) pairs = make_pairs(paths.initial_inputs, INITIAL_KEYS) d = {} print '-------------------------------------------------------' print ' Key Name' for k, p in pairs: print 'initial {:<20s} {}'.format(k, p) raster = Raster(p, root=paths.initial_inputs) data = raster.masked() d[k] = data nans = count_nonzero(isnan(data)) if nans: print '{} has {} nan values'.format(k, nans) nons = count_nonzero(data < 0.0) if nons: print '{} has {} negative values'.format(k, nons) print '-------------------------------------------------------\n' return d
def _extract(tag, pairs, root, out, geo, bounds): for k, pair in pairs: raster = Raster(pair, root=root) p = make_reduced_path(out, tag, k) arr = raster.masked() slice_and_save(p, arr, geo, *bounds) print '{} {} reduced'.format(tag, k)
def get_individ_ndvi(date_object): year = str(date_object.year) tail = 'NDVI{}_{:02n}_{:02n}.tif'.format(year, date_object.timetuple().tm_mon, date_object.timetuple().tm_mday) name = os.path.join(year, tail) raster = Raster(name, root=paths.ndvi_individ) return raster.masked()
def generate_rew_tiff(sand_tif, clay_tif, output): sand = Raster(sand_tif) clay = Raster(clay_tif) # From ASCE pg 195, equations from Ritchie et al., 1989 rew = 8 + 0.08 * clay rew = where(sand > 80.0, 20.0 - 0.15 * sand, rew) rew = where(clay > 50, 11 - 0.06 * clay, rew) out = Raster.fromarray(rew, sand.geo) out.save(output)
def update_raster_obj(self, master, date_object): """ Checks if the date is specified for writing output and calls the write and tabulation methods. :param master: master dict object from etrm.Processes :param date_object: datetime date object :return: None """ mo_date = monthrange(date_object.year, date_object.month) # save daily data (this will take a long time) # don't use 'tot_parameter' or you will sum totals # just use the normal daily fluxes from master, aka _daily_outputs if self._write_freq == 'daily': # dailys = [(element, Raster.fromarray(master[element] - master['p{}'.format(element)]).unmasked()) for element in self._cfg.daily_outputs] print "self tiff ", self._cfg.tiff_shape tiff_shp = self._cfg.tiff_shape dailys = [(element, Raster.fromarray( master[element]).unmasked(tiff_shape=tiff_shp)) for element in self._cfg.daily_outputs] # print 'new dailys -> {}'.format(dailys) for element, arr in dailys: self._sum_raster_by_shape(element, date_object, arr) print "Heres the save dates", self._save_dates if self._save_dates: print 'Date object {}. {}'.format( date_object, date_object in self._save_dates) if date_object in self._save_dates: self._set_outputs(dailys, date_object, 'daily') outputs = [(element, Raster.fromarray( master[element]).unmasked(tiff_shape=self._cfg.tiff_shape)) for element in self._cfg.daily_outputs] # print 'outputs rm {}'.format(outputs) # save monthly data # etrm_processes.run._save_tabulated_results_to_csv will re-sample to annual if date_object.day == mo_date[1]: print 'saving monthly data for {}'.format(date_object) self._set_outputs(outputs, date_object, 'monthly') # save annual data if date_object.month == 12 and date_object.day == 31: self._set_outputs(outputs, date_object, 'annual')
def get_spline_kcb(date_object, previous_kcb=None): """ Find NDVI image and convert to Kcb. :param date_object: Datetime object of date. :param previous_kcb: Previous day's kcb value. :return: numpy array object """ year = str(date_object.year) tail = 'ndvi{}_{:03n}.tif'.format(year, date_object.timetuple().tm_yday) path = os.path.join(year, tail) raster = Raster(path, root=paths.ndvi_spline) ndvi = raster.masked() return post_process_ndvi(ndvi, previous_kcb=previous_kcb)
def slice_and_save(p, arr, geo, startc, endc, startr, endr): if not os.path.isdir(os.path.dirname(p)): os.makedirs(os.path.dirname(p)) raster = Raster.fromarray(arr) marr = raster.unmasked() marr = marr[slice(startr, endr), slice(startc, endc)] # print 'saving {}'.format(p) raster.save(p, marr, geo)
def update_raster_obj(self, master, date_object): """ Checks if the date is specified for writing output and calls the write and tabulation methods. :param master: master dict object from etrm.Processes :param date_object: datetime date object :return: None """ mo_date = monthrange(date_object.year, date_object.month) # save daily data (this will take a long time) # don't use 'tot_parameter' or you will sum totals # just use the normal daily fluxes from master, aka _daily_outputs if self._write_freq == 'daily': # dailys = [(element, Raster.fromarray(master[element] - master['p{}'.format(element)]).unmasked()) for element in self._cfg.daily_outputs] print "self tiff ", self._cfg.tiff_shape tiff_shp = self._cfg.tiff_shape dailys = [(element, Raster.fromarray(master[element]).unmasked(tiff_shape=tiff_shp)) for element in self._cfg.daily_outputs] # print 'new dailys -> {}'.format(dailys) for element, arr in dailys: self._sum_raster_by_shape(element, date_object, arr) print "Heres the save dates", self._save_dates if self._save_dates: print 'Date object {}. {}'.format(date_object, date_object in self._save_dates) if date_object in self._save_dates: self._set_outputs(dailys, date_object, 'daily') outputs = [(element, Raster.fromarray(master[element]).unmasked(tiff_shape=self._cfg.tiff_shape)) for element in self._cfg.daily_outputs] # print 'outputs rm {}'.format(outputs) # save monthly data # etrm_processes.run._save_tabulated_results_to_csv will re-sample to annual if date_object.day == mo_date[1]: print 'saving monthly data for {}'.format(date_object) self._set_outputs(outputs, date_object, 'monthly') # save annual data if date_object.month == 12 and date_object.day == 31: self._set_outputs(outputs, date_object, 'annual')
def post_process_ndvi(name, in_path, previous_kcb, band=1, scalar=1.25): """ convert to ndvi to Kcb. :param date_object: Datetime object of date. :param previous_kcb: Previous day's kcb value. :return: numpy array object """ raster = Raster(name, root=in_path, band=band) ndvi = raster.masked() # ndvi *= 0.0001 kcb = ndvi * scalar if previous_kcb is not None: kcb = np.where(np.isnan(kcb) is True, previous_kcb, kcb) kcb = np.where(abs(kcb) > 100.0, previous_kcb, kcb) return kcb
def setup_geo(): raster = Raster(paths.mask) mask_arr = raster.as_bool_array # get raster to provide geo data (need one that is not "Byte") root = paths.initial_inputs name = tiff_list(root)[0] raster = Raster(name, root=root) geo = raster.geo startc, endc, startr, endr = bounding_box(mask_arr) geo['rows'] = endr - startr geo['cols'] = endc - startc transform = get_tiff_transform(paths.mask) transform *= Affine.translation(startc, startr) geo['geotransform'] = transform.to_gdal() return geo, (startc, endc, startr, endr)
def get_geo(date_object): # TODO: tiff vs. tif extension on file names breaks mac or PC tail = '{}{:02n}{:02n}.tif'.format(date_object.year, date_object.month, date_object.day) root = os.path.join('precip', '800m_std_all') # this will need to be fixed name = 'PRISMD2_NMHW2mi_{}'.format(tail) raster = Raster(name, root=os.path.join(paths.prism, root)) return raster.geo
def get_penman(date_object, variable='etrs'): """ Find PENMAN image. :param variable: type of PENMAN variable sought :type variable: str :param date_object: Datetime object of date. :return: numpy array object """ names = ('etrs', 'rlin', 'rg') if variable not in names: raise NotImplementedError( 'Invalid PENMAN variable name {}. must be in {}'.format( variable, names)) is_walnut_gulch = False # Changed for Walnut gulch NDVI naming convention year = date_object.year tail = '{}_{:03n}.tif'.format(year, date_object.timetuple().tm_yday) if variable == 'etrs': name = os.path.join('PM{}'.format(year), 'PM_NM_{}'.format(tail)) # default is this one elif variable == 'rlin': name = os.path.join( 'PM{}'.format(year), 'RLIN_NM_{}'.format(tail)) # Makes no sense. Not in directory. elif variable == 'rg': if is_walnut_gulch: name = os.path.join('rad{}'.format(year), 'RTOT_NM_{}'.format(tail)) else: name = os.path.join('rad{}'.format(year), 'RTOT_{}'.format(tail)) raster = Raster(name, root=paths.penman) return raster.masked()
def initialize_static_dict(pairs=None): """ :return: """ def initial_plant_height(r): # I think plant height is recorded in ft, when it should be m. Not sure if *= works on rasters. return r * 0.3048 def initial_root_z(r): return minimum(r, 100) def initial_soil_ksat(r): return maximum( r, 0.01 ) * 86.4 / 10 # KSat raster is in um/s; convert using 1 um/s = 86.4 mm/day # This / 10 is temporary, to reduce k-sat until better estimate can be obtained def initial_tew(r): return maximum(minimum(r, 10), 0.001) def initial_rew(r): return maximum(r, 0.001) d = {} if pairs is None: print 'Using default static inputs path: {}'.format( paths.static_inputs) pairs = make_pairs(paths.static_inputs, STATIC_KEYS) print '-------------------------------------------------------' print ' Key Name' for k, p in pairs: print 'static {:<20s} {}'.format(k, p) raster = Raster(p, root=paths.static_inputs) # print 'raster jjj', raster arr = raster.masked() if k == 'plant_height': arr = initial_plant_height(arr) # print arr elif k == 'rew': arr = initial_rew(arr) elif k == 'root_z': arr = initial_root_z(arr) elif k == 'soil_ksat': arr = initial_soil_ksat(arr) # print arr elif k == 'tew': arr = initial_tew(arr) d[k] = arr print '-------------------------------------------------------' q = d['quat_deposits'] taw = d['taw'] tew = d['tew'] land_cover = d['land_cover'] print 'original Ksat = {}, REW = {}, TAW = {}, land cover = {}'.format( d['soil_ksat'], d['rew'], d['taw'], d['land_cover']) # apply high TAW to unconsolidated Quaternary deposits min_val = 250 taw = where(q > 0.0, maximum(min_val, taw), taw) # apply bounds to TAW # min_val = 50.0 # max_val = 320.0 #data = d['taw'] #taw = where(data < min_val, min_val, taw) #taw = where(data > max_val, max_val, taw) # v = tew + d['rew'] taw = where(taw < tew, tew, taw) # non_zero = count_nonzero(data < min_val) # print 'taw has {} cells below the minimum'.format(non_zero, min_val) print 'taw median: {}, mean {}, max {}, min {}\n'.format( median(taw), taw.mean(), taw.max(), taw.min()) d['taw'] = taw # apply tew adjustment # tew = where(land_cover == 41, tew * 0.25, tew) # tew = where(land_cover == 42, tew * 0.25, tew) # tew = where(land_cover == 43, tew * 0.25, tew) # d['tew'] = where(land_cover == 52, tew * 0.75, tew) return d
def initialize_static_dict(pairs=None): """ :return: """ def initial_plant_height(r): # I think plant height is recorded in ft, when it should be m. Not sure if *= works on rasters. return r * 0.3048 def initial_root_z(r): return minimum(r, 100) def initial_soil_ksat(r): return maximum(r, 0.01) * 86.4 / 10 # KSat raster is in um/s; convert using 1 um/s = 86.4 mm/day # This / 10 is temporary, to reduce k-sat until better estimate can be obtained def initial_tew(r): return maximum(minimum(r, 10), 0.001) def initial_rew(r): return maximum(r, 0.001) d = {} if pairs is None: print 'Using default static inputs path: {}'.format(paths.static_inputs) pairs = make_pairs(paths.static_inputs, STATIC_KEYS) print '-------------------------------------------------------' print ' Key Name' for k, p in pairs: print 'static {:<20s} {}'.format(k, p) raster = Raster(p, root=paths.static_inputs) # print 'raster jjj', raster arr = raster.masked() if k == 'plant_height': arr = initial_plant_height(arr) # print arr elif k == 'rew': arr = initial_rew(arr) elif k == 'root_z': arr = initial_root_z(arr) elif k == 'soil_ksat': arr = initial_soil_ksat(arr) # print arr elif k == 'tew': arr = initial_tew(arr) d[k] = arr print '-------------------------------------------------------' q = d['quat_deposits'] taw = d['taw'] tew = d['tew'] land_cover = d['land_cover'] print 'original Ksat = {}, REW = {}, TAW = {}, land cover = {}'.format(d['soil_ksat'],d['rew'],d['taw'],d['land_cover']) # apply high TAW to unconsolidated Quaternary deposits min_val = 250 taw = where(q > 0.0, maximum(min_val, taw), taw) # apply bounds to TAW # min_val = 50.0 # max_val = 320.0 #data = d['taw'] #taw = where(data < min_val, min_val, taw) #taw = where(data > max_val, max_val, taw) # v = tew + d['rew'] taw = where(taw < tew, tew, taw) # non_zero = count_nonzero(data < min_val) # print 'taw has {} cells below the minimum'.format(non_zero, min_val) print 'taw median: {}, mean {}, max {}, min {}\n'.format(median(taw), taw.mean(), taw.max(), taw.min()) d['taw'] = taw # apply tew adjustment # tew = where(land_cover == 41, tew * 0.25, tew) # tew = where(land_cover == 42, tew * 0.25, tew) # tew = where(land_cover == 43, tew * 0.25, tew) # d['tew'] = where(land_cover == 52, tew * 0.75, tew) return d
def get_prism(date_object, variable='precip', is_reduced = False): """ Find PRISM image. :param variable: type of PRISM variable sought :type variable: str :param date_object: Datetime object of date. :return: numpy array object """ is_walnut_gulch = False # Changed for Walnut gulch NDVI naming convention names = ('precip', 'min_temp', 'max_temp') if variable not in names: raise NotImplementedError('Invalid PRISM variable name {}. must be in {}'.format(variable, names)) year = date_object.year year_str = str(year) # TODO: tiff vs. tif extension on file names breaks mac or PC if variable == 'precip': if is_reduced: root = os.path.join('precip', '800m_std_all') tail = '{}{:02n}{:02n}.tif'.format(year, date_object.month, date_object.day) name = 'precip_{}'.format(tail) else: if is_walnut_gulch: root = os.path.join('precip', '800m_std_all', year_str) tail = '{}{:02n}{:02n}.tiff'.format(year, date_object.month, date_object.day) name = 'Walnut_precip_{}'.format(tail) else: root = os.path.join('precip', '800m_std_all') tail = '{}{:02n}{:02n}.tif'.format(year, date_object.month, date_object.day) name = 'PRISMD2_NMHW2mi_{}'.format(tail) elif variable == 'min_temp': if is_reduced: root = os.path.join('Temp', 'Minimum_standard') tail = '{}{:02n}{:02n}.tif'.format(year, date_object.month, date_object.day) name = 'min_temp_{}'.format(tail) else: if is_walnut_gulch: root = os.path.join('Temp', 'Minimum_standard', year_str) tail = '{}{:02n}{:02n}.tiff'.format(year, date_object.month, date_object.day) name = 'Walnut_MinTemp_{}'.format(tail) else: root = os.path.join('Temp', 'Minimum_standard') tail = '{}{:02n}{:02n}.tif'.format(year, date_object.month, date_object.day) if year in PRISM_YEARS: name = 'cai_tmin_us_us_30s_{}'.format(tail) else: name = 'TempMin_NMHW2Buff_{}'.format(tail) elif variable == 'max_temp': if is_reduced: root = os.path.join('Temp', 'Maximum_standard') tail = '{}{:02n}' \ ' {:02n}.tif'.format(year, date_object.month, date_object.day) name = 'max_temp_{}'.format(tail) else: if is_walnut_gulch: root = os.path.join('Temp', 'Maximum_standard', year_str) tail = '{}{:02n}{:02n}.tiff'.format(year, date_object.month, date_object.day) name = 'Walnut_MaxTemp_{}'.format(tail) else: root = os.path.join('Temp', 'Maximum_standard') tail = '{}{:02n}{:02n}.tif'.format(year, date_object.month, date_object.day) name = 'TempMax_NMHW2Buff_{}'.format(tail) raster = Raster(name, root=os.path.join(paths.prism, root)) return raster.masked()
def run(): cfg = Config() outdir = os.path.dirname(cfg.output_path) if not os.path.isdir(outdir): print('output directory does not exist. making it now: {}'.format( outdir)) os.makedirs(outdir) # startday = datetime(2000, 1, 1) # endday = datetime(2013, 12, 31) startday, endday = cfg.date_range # mask_path = os.path.join(root, 'Mask') # statics_to_save = os.path.join(root, 'NDVI_statics') # ndvi = os.path.join(root, 'NDVI_spline',) # prism = os.path.join(root, 'PRISM') # penman = os.path.join(root, 'PM_RAD') # nlcd_name = 'nlcd_nm_utm13.tif' # dem_name = 'NMbuffer_DEM_UTM13_250m.tif' # aspect_name = 'NMbuffer_DEMAspect_UTM13_250m.tif' # slope_name = 'NMbuffer_DEMSlope_UTM13_250m.tif' # x_cord_name = 'NDVI_1300ptsX.tif' # y_cord_name = 'NDVI_1300ptsY.tif' # Gets the arrays using function convert_raster_to_array() in raster_tools.py # apply_mask is done on the same array. # nlcd = apply_mask(mask_path, convert_raster_to_array(statics_to_save, nlcd_name, 1)) # dem = apply_mask(mask_path, convert_raster_to_array(statics_to_save, dem_name, 1)) # slope = apply_mask(mask_path, convert_raster_to_array(statics_to_save, slope_name, 1)) # aspect = apply_mask(mask_path, convert_raster_to_array(statics_to_save, aspect_name, 1)) # x_cord = apply_mask(mask_path, convert_raster_to_array(statics_to_save, x_name, 1)) # y_cord = apply_mask(mask_path, convert_raster_to_array(statics_to_save, y_name, 1)) root = paths.ndvi_statics nlcd = Raster(cfg.nlcd_name, root).masked() dem = Raster(cfg.dem_name, root).masked() x_cord = Raster(cfg.x_cord_name, root).masked() y_cord = Raster(cfg.y_cord_name, root).masked() rslope = Raster(cfg.slope_name, root) raspect = Raster(cfg.aspect_name, root) rslope.apply_mask() rslope.filter_less(0, 0) slope = rslope.array raspect.apply_mask() raspect.filter_less(0, 0) raspect.filter_greater(360, 0) aspect = raspect.array keys = ('Year', 'Month', 'Day', 'X', 'Y', 'NDVI', 'Tavg', 'Precip', 'ETr', 'PminusEtr', 'NLCD_class', 'Elev', 'Slope', 'Aspect') st_begin = time.time() # do you really want to be appending to the output file every time you run this script? # is so then 'a' is appropriate otherwise 'w' is the correct choice. # notice also in my write the file is only opened *once* as apposed to every iteration. with open(cfg.output_path, 'w') as wfile: wfile.write('{}\n'.format(','.join(keys))) for day in rrule.rrule(rrule.DAILY, dtstart=startday, until=endday): st = time.time() ndvi_data = get_kcb(paths.ndvi_spline, day) precip_data = get_prism(paths.prism, day, variable="precip") tmin_data = get_prism(paths.prism, day, variable="min_temp") tmax_data = get_prism(paths.prism, day, variable="max_temp") tavg = tmin_data + tmax_data / 2 # Finds the penman image. etrs_data = get_penman(paths.penman, day, variable="etrs") p_minus_etr = precip_data - etrs_data data = array([ x_cord, y_cord, ndvi_data, tavg, precip_data, etrs_data, p_minus_etr, nlcd, dem, slope, aspect ]).T save_daily_pts(wfile, day, data) runtime = time.time() - st print(('Time for day = {}'.format(runtime))) runtime_full = time.time() - st_begin print(('Time to save entire period = {}'.format(runtime_full)))
def get_prism(date_object, variable='precip', is_reduced=False): """ Find PRISM image. :param variable: type of PRISM variable sought :type variable: str :param date_object: Datetime object of date. :return: numpy array object """ is_walnut_gulch = False # Changed for Walnut gulch NDVI naming convention names = ('precip', 'min_temp', 'max_temp') if variable not in names: raise NotImplementedError( 'Invalid PRISM variable name {}. must be in {}'.format( variable, names)) year = date_object.year year_str = str(year) # TODO: tiff vs. tif extension on file names breaks mac or PC if variable == 'precip': if is_reduced: root = os.path.join('precip', '800m_std_all') tail = '{}{:02n}{:02n}.tif'.format(year, date_object.month, date_object.day) name = 'precip_{}'.format(tail) else: if is_walnut_gulch: root = os.path.join('precip', '800m_std_all', year_str) tail = '{}{:02n}{:02n}.tiff'.format(year, date_object.month, date_object.day) name = 'Walnut_precip_{}'.format(tail) else: root = os.path.join('precip', '800m_std_all') tail = '{}{:02n}{:02n}.tif'.format(year, date_object.month, date_object.day) name = 'PRISMD2_NMHW2mi_{}'.format(tail) elif variable == 'min_temp': if is_reduced: root = os.path.join('Temp', 'Minimum_standard') tail = '{}{:02n}{:02n}.tif'.format(year, date_object.month, date_object.day) name = 'min_temp_{}'.format(tail) else: if is_walnut_gulch: root = os.path.join('Temp', 'Minimum_standard', year_str) tail = '{}{:02n}{:02n}.tiff'.format(year, date_object.month, date_object.day) name = 'Walnut_MinTemp_{}'.format(tail) else: root = os.path.join('Temp', 'Minimum_standard') tail = '{}{:02n}{:02n}.tif'.format(year, date_object.month, date_object.day) if year in PRISM_YEARS: name = 'cai_tmin_us_us_30s_{}'.format(tail) else: name = 'TempMin_NMHW2Buff_{}'.format(tail) elif variable == 'max_temp': if is_reduced: root = os.path.join('Temp', 'Maximum_standard') tail = '{}{:02n}' \ ' {:02n}.tif'.format(year, date_object.month, date_object.day) name = 'max_temp_{}'.format(tail) else: if is_walnut_gulch: root = os.path.join('Temp', 'Maximum_standard', year_str) tail = '{}{:02n}{:02n}.tiff'.format(year, date_object.month, date_object.day) name = 'Walnut_MaxTemp_{}'.format(tail) else: root = os.path.join('Temp', 'Maximum_standard') tail = '{}{:02n}{:02n}.tif'.format(year, date_object.month, date_object.day) name = 'TempMax_NMHW2Buff_{}'.format(tail) raster = Raster(name, root=os.path.join(paths.prism, root)) return raster.masked()
def run(): cfg = Config() outdir = os.path.dirname(cfg.output_path) if not os.path.isdir(outdir): print 'output directory does not exist. making it now: {}'.format(outdir) os.makedirs(outdir) # startday = datetime(2000, 1, 1) # endday = datetime(2013, 12, 31) startday, endday = cfg.date_range # mask_path = os.path.join(root, 'Mask') # statics_to_save = os.path.join(root, 'NDVI_statics') # ndvi = os.path.join(root, 'NDVI_spline',) # prism = os.path.join(root, 'PRISM') # penman = os.path.join(root, 'PM_RAD') # nlcd_name = 'nlcd_nm_utm13.tif' # dem_name = 'NMbuffer_DEM_UTM13_250m.tif' # aspect_name = 'NMbuffer_DEMAspect_UTM13_250m.tif' # slope_name = 'NMbuffer_DEMSlope_UTM13_250m.tif' # x_cord_name = 'NDVI_1300ptsX.tif' # y_cord_name = 'NDVI_1300ptsY.tif' # Gets the arrays using function convert_raster_to_array() in raster_tools.py # apply_mask is done on the same array. # nlcd = apply_mask(mask_path, convert_raster_to_array(statics_to_save, nlcd_name, 1)) # dem = apply_mask(mask_path, convert_raster_to_array(statics_to_save, dem_name, 1)) # slope = apply_mask(mask_path, convert_raster_to_array(statics_to_save, slope_name, 1)) # aspect = apply_mask(mask_path, convert_raster_to_array(statics_to_save, aspect_name, 1)) # x_cord = apply_mask(mask_path, convert_raster_to_array(statics_to_save, x_name, 1)) # y_cord = apply_mask(mask_path, convert_raster_to_array(statics_to_save, y_name, 1)) root = paths.ndvi_statics nlcd = Raster(cfg.nlcd_name, root).masked() dem = Raster(cfg.dem_name, root).masked() x_cord = Raster(cfg.x_cord_name, root).masked() y_cord = Raster(cfg.y_cord_name, root).masked() rslope = Raster(cfg.slope_name, root) raspect = Raster(cfg.aspect_name, root) rslope.apply_mask() rslope.filter_less(0,0) slope = rslope.array raspect.apply_mask() raspect.filter_less(0, 0) raspect.filter_greater(360, 0) aspect = raspect.array keys = ('Year', 'Month', 'Day', 'X', 'Y', 'NDVI', 'Tavg', 'Precip', 'ETr', 'PminusEtr', 'NLCD_class', 'Elev', 'Slope', 'Aspect') st_begin = time.time() # do you really want to be appending to the output file every time you run this script? # is so then 'a' is appropriate otherwise 'w' is the correct choice. # notice also in my write the file is only opened *once* as apposed to every iteration. with open(cfg.output_path, 'w') as wfile: wfile.write('{}\n'.format(','.join(keys))) for day in rrule.rrule(rrule.DAILY, dtstart=startday, until=endday): st = time.time() ndvi_data = get_kcb(paths.ndvi_spline, day) precip_data = get_prism(paths.prism, day, variable="precip") tmin_data = get_prism(paths.prism, day, variable="min_temp") tmax_data = get_prism(paths.prism, day, variable="max_temp") tavg = tmin_data + tmax_data / 2 # Finds the penman image. etrs_data = get_penman(paths.penman, day, variable="etrs") p_minus_etr = precip_data - etrs_data data = array([x_cord, y_cord, ndvi_data, tavg, precip_data, etrs_data, p_minus_etr, nlcd, dem, slope, aspect]).T save_daily_pts(wfile, day, data) runtime = time.time() - st print('Time for day = {}'.format(runtime)) runtime_full = time.time() - st_begin print('Time to save entire period = {}'.format(runtime_full))