def run_gfail(args):
"""Runs ground failure.
Args:
args: dictionary or argument parser Namespace output by bin/gfail
program.
Returns:
list: Names of created files.
"""
# TODO: ADD CONFIG VALIDATION STEP THAT MAKES SURE ALL THE FILES EXIST
filenames = []
# If args is a dictionary, convert to a Namespace
if isinstance(args, dict):
args = Namespace(**args)
if args.set_default_paths:
set_default_paths(args)
print('default paths set, continuing...\n')
if args.list_default_paths:
list_default_paths()
return
if args.reset_default_paths:
reset_default_paths()
return
if args.make_webpage:
# Turn on GIS and HDF5 flags
gis = True
hdf5 = True
kmz = True
else:
gis = args.gis
hdf5 = args.hdf5
kmz = args.kmz
# Figure out what models will be run
if args.shakefile is not None: # user intends to actually run some models
shakefile = args.shakefile
# make output location for things
if args.output_filepath is None:
outdir = os.getcwd()
else:
outdir = args.output_filepath
if hdf5 or gis or kmz:
if not os.path.exists(outdir):
os.makedirs(outdir)
# download if is url
# cleanup = False
if not os.path.isfile(shakefile):
if isURL(shakefile):
# getGridURL returns a named temporary file object
shakefile = getGridURL(shakefile)
# cleanup = True # Be sure to delete it after
else:
raise NameError('Could not find "%s" as a file or a valid url'
% shakefile)
eventid = getHeaderData(shakefile)[0]['event_id']
# Get entire path so won't break if running gfail with relative path
shakefile = os.path.abspath(shakefile)
if args.extract_contents:
outfolder = outdir
else: # Nest in a folder named by eventid
outfolder = os.path.join(outdir, eventid)
if not os.path.exists(outfolder):
os.makedirs(outfolder)
# Copy shake grid into output directory
# --- this is base on advice from Mike that when running in production
# the shake grids are not archived and so if we need/want to have
# the exact grid used for the calculation later if there's every a
# question about how the calculation was done, the safest thing is
# to store a copy of it here.
shake_copy = os.path.join(outfolder, "grid.xml")
shutil.copyfile(shakefile, shake_copy)
if args.uncertfile is not None:
uncertfile = os.path.abspath(args.uncertfile)
unc_copy = os.path.join(outfolder, "uncertainty.xml")
shutil.copyfile(uncertfile, unc_copy)
else:
uncertfile = None
# Write shakefile to a file for use later
shakename = os.path.join(outfolder, "shakefile.txt")
shake_file = open(shakename, "wt")
shake_file.write(shake_copy)
shake_file.close()
filenames.append(shakename)
# Check that shakemap bounds do not cross 180/-180 line
if args.set_bounds is None:
sd = ShakeGrid.getFileGeoDict(shakefile)
if sd.xmin > sd.xmax:
print('\nShakeMap crosses 180/-180 line, setting bounds so '
'only side with more land area is run')
if sd.xmax + 180. > 180 - sd.xmin:
set_bounds = '%s, %s, %s, %s' % (
sd.ymin, sd.ymax, -180., sd.xmax)
else:
set_bounds = '%s, %s, %s, %s' % (sd.ymin, sd.ymax, sd.xmin,
180.)
print('Bounds applied: %s' % set_bounds)
else:
set_bounds = args.set_bounds
else:
set_bounds = args.set_bounds
config = args.config
if args.config_filepath is not None:
# only add config_filepath if full filepath not given and file
# ext is .ini
if (not os.path.isabs(config) and
os.path.splitext(config)[-1] == '.ini'):
config = os.path.join(args.config_filepath, config)
if os.path.splitext(config)[-1] == '.ini':
temp = ConfigObj(config)
if len(temp) == 0:
raise Exception(
'Could not find specified .ini file: %s' % config)
if args.data_path is not None:
temp = correct_config_filepaths(args.data_path, temp)
configs = [temp]
conffail = []
else:
# input is a list of config files
f = open(config, 'r')
configlist = f.readlines()
configs = []
conffail = []
for conf in configlist:
conf = conf.strip()
if not os.path.isabs(conf):
# only add config_filepath if full filepath not given
conf = os.path.join(args.config_filepath, conf)
try:
temp = ConfigObj(conf)
if temp:
if args.data_path is not None:
temp = correct_config_filepaths(
args.data_path, temp)
configs.append(temp)
else:
conffail.append(conf)
except BaseException:
conffail.append(conf)
print('\nRunning the following models:')
for conf in configs:
print('\t%s' % conf.keys()[0])
if len(conffail) > 0:
print('Could not find or read in the following config files:\n')
for conf in conffail:
print('\t%s' % conf)
print('\nContinuing...\n')
if set_bounds is not None:
if 'zoom' in set_bounds:
temp = set_bounds.split(',')
print('Using %s threshold of %1.1f to cut model bounds'
% (temp[1].strip(), float(temp[2].strip())))
bounds = get_bounds(shakefile, temp[1].strip(),
float(temp[2].strip()))
else:
temp = eval(set_bounds)
latmin = temp[0]
latmax = temp[1]
lonmin = temp[2]
lonmax = temp[3]
bounds = {'xmin': lonmin, 'xmax': lonmax,
'ymin': latmin, 'ymax': latmax}
print('Applying bounds of lonmin %1.2f, lonmax %1.2f, '
'latmin %1.2f, latmax %1.2f'
% (bounds['xmin'], bounds['xmax'],
bounds['ymin'], bounds['ymax']))
else:
bounds = None
if args.make_webpage:
results = []
# pre-read in ocean trimming file polygons so only do this step once
if args.trimfile is not None:
if not os.path.exists(args.trimfile):
print('trimfile defined does not exist: %s\n'
'Ocean will not be trimmed.' % args.trimfile)
trimfile = None
elif os.path.splitext(args.trimfile)[1] != '.shp':
print('trimfile must be a shapefile, '
'ocean will not be trimmed')
trimfile = None
else:
trimfile = args.trimfile
else:
trimfile = None
# Get finite fault ready, if exists
ffault = None
point = True
if args.finite_fault is not None:
point = False
try:
if os.path.splitext(args.finite_fault)[-1] == '.txt':
ffault = text_to_json(args.finite_fault)
elif os.path.splitext(args.finite_fault)[-1] == '.json':
ffault = args.finite_fault
else:
print('Could not read in finite fault, will '
'try to download from comcat')
ffault = None
except BaseException:
print('Could not read in finite fault, will try to '
'download from comcat')
ffault = None
if ffault is None:
# Try to get finite fault file, if it exists
try:
returned_ev = get_event_comcat(shakefile)
if returned_ev is not None:
testjd, detail, temp = returned_ev
evinfo = testjd['input']['event_information']
if 'faultfiles' in evinfo:
ffilename = evinfo['faultfiles']
if len(ffilename) > 0:
# Download the file
with tempfile.NamedTemporaryFile(
delete=False, mode='w') as f:
temp.getContent(ffilename, filename=f.name)
ffault = text_to_json(f.name)
os.remove(f.name)
point = False
else:
point = True
else:
print('Unable to determine source type, unknown if finite'
' fault or point source')
ffault = None
point = False
except Exception as e:
print(e)
print('Unable to determine source type, unknown if finite'
' fault or point source')
ffault = None
point = False
# Loop over config files
for conf in configs:
modelname = conf.keys()[0]
print('\nNow running %s:' % modelname)
notcov, newbnds = check_input_extents(
conf, shakefile=shakefile,
bounds=bounds
)
if len(notcov) > 0:
print('\nThe following input layers do not cover'
' the area of interest:\n\t%s' % '\n\t'.join(notcov))
if newbnds is None:
print('\nCannnot make bounds that work. '
'Skipping to next model\n')
continue
else:
pnt = '%s, %s, %s, %s' % (
newbnds['xmin'], newbnds['xmax'],
newbnds['ymin'], newbnds['ymax'])
print('Running model for new bounds that are fully covered'
' by input layer: %s' % pnt)
bounds2 = newbnds
else:
bounds2 = bounds
modelfunc = conf[modelname]['funcname']
if modelfunc == 'LogisticModel':
lm = LM.LogisticModel(shakefile, conf,
uncertfile=uncertfile,
saveinputs=args.save_inputs,
bounds=bounds2,
trimfile=trimfile)
maplayers = lm.calculate()
elif modelfunc == 'godt2008':
maplayers = godt2008(shakefile, conf,
uncertfile=uncertfile,
saveinputs=args.save_inputs,
bounds=bounds2,
trimfile=trimfile)
else:
print('Unknown model function specified in config for %s '
'model, skipping to next config' % modelfunc)
continue
# time1 = datetime.datetime.utcnow().strftime('%d%b%Y_%H%M')
# filename = ('%s_%s_%s' % (eventid, modelname, time1))
if args.appendname is not None:
filename = ('%s_%s_%s' % (eventid, modelname, args.appendname))
else:
filename = ('%s_%s' % (eventid, modelname))
if hdf5:
filenameh = filename + '.hdf5'
if os.path.exists(filenameh):
os.remove(filenameh)
savelayers(maplayers, os.path.join(outfolder, filenameh))
filenames.append(filenameh)
if gis or kmz:
for key in maplayers:
# Rename 'std' key to 'beta_sigma'
if key == 'std':
key_label = 'beta_sigma'
else:
key_label = key
if gis:
filen = os.path.join(outfolder, '%s_%s.bil'
% (filename, key_label))
fileh = os.path.join(outfolder, '%s_%s.hdr'
% (filename, key_label))
fileg = os.path.join(outfolder, '%s_%s.tif'
% (filename, key_label))
GDALGrid.copyFromGrid(
maplayers[key]['grid']).save(filen)
cflags = '-co COMPRESS=DEFLATE -co predictor=2'
srs = '-a_srs EPSG:4326'
cmd = 'gdal_translate %s %s -of GTiff %s %s' % (
srs, cflags, filen, fileg)
rc, so, se = get_command_output(cmd)
# Delete bil file and its header
os.remove(filen)
os.remove(fileh)
filenames.append(fileg)
if kmz and (not key.startswith('quantile') and not key.startswith('std')) :
plotorder, logscale, lims, colormaps, maskthresh = \
parseConfigLayers(maplayers, conf, keys=['model'])
maxprob = np.nanmax(maplayers[key]['grid'].getData())
if key == 'model':
qdict = {
k: maplayers[k] for k in maplayers.keys()
if k.startswith('quantile')
}
else:
qdict = None
if maskthresh is None:
maskthresh = [0.]
if maxprob >= maskthresh[0]:
filen = os.path.join(outfolder, '%s_%s.kmz'
% (filename, key_label))
filek = create_kmz(maplayers[key], filen,
mask=maskthresh[0],
levels=lims[0],
qdict=qdict)
filenames.append(filek)
else:
print('No unmasked pixels present, skipping kmz '
'file creation')
if args.make_webpage:
# Compile into list of results for later
results.append(maplayers)
# # Make binary output for ShakeCast
# filef = os.path.join(outfolder, '%s_model.flt'
# % filename)
# # And get name of header
# filefh = os.path.join(outfolder, '%s_model.hdr'
# % filename)
# # Make file
# write_floats(filef, maplayers['model']['grid'])
# filenames.append(filef)
# filenames.append(filefh)
eventid = getHeaderData(shakefile)[0]['event_id']
if not hasattr(args, 'eventsource'):
args.eventsource = 'us'
if not hasattr(args, 'eventsourcecode'):
args.eventsourcecode = eventid
if args.make_webpage:
if len(results) == 0:
raise Exception('No models were run. Cannot make webpages.')
outputs = hazdev(
results, configs,
shakefile, outfolder=outfolder,
pop_file=args.popfile,
pager_alert=args.property_alertlevel,
eventsource=args.eventsource,
eventsourcecode=args.eventsourcecode,
point=point, gf_version=args.gf_version,
pdlcall=args.pdlcall)
filenames = filenames + outputs
# # create transparent png file
# outputs = create_png(outdir)
# filenames = filenames + outputs
#
# # create info file
# infofile = create_info(outdir)
# filenames = filenames + infofile
print('\nFiles created:\n')
for filen in filenames:
print('%s' % filen)
return filenames
def test_save():
tdir = tempfile.mkdtemp()
testfile = os.path.join(tdir, 'test.xml')
try:
print('Testing save/read functionality for shakemap grids...')
pga = np.arange(0, 16, dtype=np.float32).reshape(4, 4)
pgv = np.arange(1, 17, dtype=np.float32).reshape(4, 4)
mmi = np.arange(2, 18, dtype=np.float32).reshape(4, 4)
geodict = GeoDict({
'xmin': 0.5,
'xmax': 3.5,
'ymin': 0.5,
'ymax': 3.5,
'dx': 1.0,
'dy': 1.0,
'ny': 4,
'nx': 4
})
layers = OrderedDict()
layers['pga'] = pga
layers['pgv'] = pgv
layers['mmi'] = mmi
shakeDict = {
'event_id': 'usabcd1234',
'shakemap_id': 'usabcd1234',
'shakemap_version': 1,
'code_version': '4.0',
'process_timestamp': datetime.utcnow(),
'shakemap_originator': 'us',
'map_status': 'RELEASED',
'shakemap_event_type': 'ACTUAL'
}
eventDict = {
'event_id': 'usabcd1234',
'magnitude': 7.6,
'depth': 1.4,
'lat': 2.0,
'lon': 2.0,
'event_timestamp': datetime.utcnow(),
'event_network': 'us',
'event_description': 'sample event'
}
uncDict = {'pga': (0.0, 0), 'pgv': (0.0, 0), 'mmi': (0.0, 0)}
shake = ShakeGrid(layers, geodict, eventDict, shakeDict, uncDict)
print('Testing save/read functionality...')
shake.save(testfile, version=3)
shake2 = ShakeGrid.load(testfile)
for layer in ['pga', 'pgv', 'mmi']:
tdata = shake2.getLayer(layer).getData()
np.testing.assert_almost_equal(tdata, layers[layer])
print('Passed save/read functionality for shakemap grids.')
print('Testing getFileGeoDict method...')
fgeodict = ShakeGrid.getFileGeoDict(testfile)
print('Passed save/read functionality for shakemap grids.')
print('Testing loading with bounds (no resampling or padding)...')
sampledict = GeoDict({
'xmin': -0.5,
'xmax': 3.5,
'ymin': -0.5,
'ymax': 3.5,
'dx': 1.0,
'dy': 1.0,
'ny': 5,
'nx': 5
})
shake3 = ShakeGrid.load(testfile,
samplegeodict=sampledict,
resample=False,
doPadding=False,
padValue=np.nan)
tdata = shake3.getLayer('pga').getData()
np.testing.assert_almost_equal(tdata, layers['pga'])
print('Passed loading with bounds (no resampling or padding)...')
print('Testing loading shakemap with padding, no resampling...')
newdict = GeoDict({
'xmin': -0.5,
'xmax': 4.5,
'ymin': -0.5,
'ymax': 4.5,
'dx': 1.0,
'dy': 1.0,
'ny': 6,
'nx': 6
})
shake4 = ShakeGrid.load(testfile,
samplegeodict=newdict,
resample=False,
doPadding=True,
padValue=np.nan)
output = np.array([[np.nan, np.nan, np.nan, np.nan, np.nan, np.nan],
[np.nan, 0.0, 1.0, 2.0, 3.0, np.nan],
[np.nan, 4.0, 5.0, 6.0, 7.0, np.nan],
[np.nan, 8.0, 9.0, 10.0, 11.0, np.nan],
[np.nan, 12.0, 13.0, 14.0, 15.0, np.nan],
[np.nan, np.nan, np.nan, np.nan, np.nan, np.nan]])
tdata = shake4.getLayer('pga').getData()
np.testing.assert_almost_equal(tdata, output)
print('Passed loading shakemap with padding, no resampling...')
#make a bigger grid
pga = np.arange(0, 36, dtype=np.float32).reshape(6, 6)
pgv = np.arange(1, 37, dtype=np.float32).reshape(6, 6)
mmi = np.arange(2, 38, dtype=np.float32).reshape(6, 6)
layers = OrderedDict()
layers['pga'] = pga
layers['pgv'] = pgv
layers['mmi'] = mmi
geodict = GeoDict({
'xmin': 0.5,
'xmax': 5.5,
'ymin': 0.5,
'ymax': 5.5,
'dx': 1.0,
'dy': 1.0,
'ny': 6,
'nx': 6
})
shake = ShakeGrid(layers, geodict, eventDict, shakeDict, uncDict)
shake.save(testfile, version=3)
print('Testing resampling, no padding...')
littledict = GeoDict({
'xmin': 2.0,
'xmax': 4.0,
'ymin': 2.0,
'ymax': 4.0,
'dx': 1.0,
'dy': 1.0,
'ny': 3,
'nx': 3
})
shake5 = ShakeGrid.load(testfile,
samplegeodict=littledict,
resample=True,
doPadding=False,
padValue=np.nan)
output = np.array([[10.5, 11.5, 12.5], [16.5, 17.5, 18.5],
[22.5, 23.5, 24.5]])
tdata = shake5.getLayer('pga').getData()
np.testing.assert_almost_equal(tdata, output)
print('Passed resampling, no padding...')
print('Testing resampling and padding...')
pga = np.arange(0, 16, dtype=np.float32).reshape(4, 4)
pgv = np.arange(1, 17, dtype=np.float32).reshape(4, 4)
mmi = np.arange(2, 18, dtype=np.float32).reshape(4, 4)
geodict = GeoDict({
'xmin': 0.5,
'ymax': 3.5,
'ymin': 0.5,
'xmax': 3.5,
'dx': 1.0,
'dy': 1.0,
'ny': 4,
'nx': 4
})
layers = OrderedDict()
layers['pga'] = pga
layers['pgv'] = pgv
layers['mmi'] = mmi
shake = ShakeGrid(layers, geodict, eventDict, shakeDict, uncDict)
shake.save(testfile, version=3)
bigdict = GeoDict({
'xmin': 0.0,
'xmax': 4.0,
'ymin': 0.0,
'ymax': 4.0,
'dx': 1.0,
'dy': 1.0,
'ny': 5,
'nx': 5
})
shake6 = ShakeGrid.load(testfile,
samplegeodict=bigdict,
resample=True,
doPadding=True,
padValue=np.nan)
tdata = shake6.getLayer('pga').getData()
output = np.array([[np.nan, np.nan, np.nan, np.nan, np.nan],
[np.nan, 2.5, 3.5, 4.5, np.nan],
[np.nan, 6.5, 7.5, 8.5, np.nan],
[np.nan, 10.5, 11.5, 12.5, np.nan],
[np.nan, np.nan, np.nan, np.nan, np.nan]])
np.testing.assert_almost_equal(tdata, output)
print('Passed resampling and padding...')
except Exception as error:
print('Failed to read grid.xml format file "%s". Error "%s".' %
(xmlfile, str(error)))
assert 0 == 1
finally:
if os.path.isdir(tdir):
shutil.rmtree(tdir)
def calcExposure(self,shakefile):
"""Calculate population exposure to shaking, per country, plus total exposure across all countries.
:param shakefile:
Path to ShakeMap grid.xml file.
:returns:
Dictionary containing country code (ISO2) keys, and values of
10 element arrays representing population exposure to MMI 1-10.
Dictionary will contain an additional key 'TotalExposure', with value of exposure across all countries.
Dictionary will also contain a field "maximum_border_mmi" which indicates the maximum MMI value along
any edge of the ShakeMap.
"""
#get shakemap geodict
shakedict = ShakeGrid.getFileGeoDict(shakefile,adjust='res')
#get population geodict
popdict,t = self._pop_class.getFileGeoDict(self._popfile)
#get country code geodict
isodict,t = self._iso_class.getFileGeoDict(self._isofile)
#special case for very high latitude events that may be outside the bounds
#of our population data...
if not popdict.intersects(shakedict):
expdict = {'UK':np.zeros((10,)),'TotalExposure':np.zeros((10,))}
return expdict
if popdict == shakedict == isodict:
#special case, probably for testing...
self._shakegrid = ShakeGrid.load(shakefile,adjust='res')
self._popgrid = self._pop_class.load(self._popfile)
self._isogrid = self._iso_class.load(self._isofile)
else:
sampledict = popdict.getBoundsWithin(shakedict)
self._shakegrid = ShakeGrid.load(shakefile,samplegeodict=sampledict,resample=True,
method='linear',adjust='res')
self._popgrid = self._pop_class.load(self._popfile,samplegeodict=sampledict,
resample=False,doPadding=True,padValue=np.nan)
self._isogrid = self._iso_class.load(self._isofile,samplegeodict=sampledict,
resample=True,method='nearest',doPadding=True,padValue=0)
mmidata = self._shakegrid.getLayer('mmi').getData()
popdata = self._popgrid.getData()
isodata = self._isogrid.getData()
eventyear = self._shakegrid.getEventDict()['event_timestamp'].year
#in order to avoid crazy far-future scenarios where PAGER models are probably invalid,
#check to see if the time gap between the date of population data collection and event year
#reaches either of a couple of different thresholds.
if eventyear > self._popyear:
tdiff = (eventyear - self._popyear)
if tdiff > SCENARIO_WARNING and tdiff < SCENARIO_ERROR:
msg = '''The input ShakeMap event year is more than %i years from the population date.
PAGER results for events this far in the future may not be valid.''' % SCENARIO_WARNING
warnings.warn(msg)
if tdiff > SCENARIO_ERROR:
msg = '''The input ShakeMap event year is more than %i years from the population date.
PAGER results for events this far in the future are not valid. Stopping.''' % SCENARIO_ERROR
raise PagerException(msg)
ucodes = np.unique(isodata)
for ccode in ucodes:
cidx = (isodata == ccode)
popdata[cidx] = self._popgrowth.adjustPopulation(popdata[cidx],ccode,self._popyear,eventyear)
exposure_dict = calc_exposure(mmidata,popdata,isodata)
newdict = {}
#Get rolled up exposures
total = np.zeros((10,),dtype=np.uint32)
for isocode,value in exposure_dict.items():
cdict = self._country.getCountry(int(isocode))
if cdict is None:
ccode = 'UK'
else:
ccode = cdict['ISO2']
newdict[ccode] = value
total += value
newdict['TotalExposure'] = total
#get the maximum MMI value along any of the four map edges
nrows,ncols = mmidata.shape
top = mmidata[0,0:ncols].max()
bottom = mmidata[nrows-1,0:ncols].max()
left = mmidata[0:nrows,0].max()
right = mmidata[0:nrows,ncols-1].max()
newdict['maximum_border_mmi'] = np.array([top,bottom,left,right]).max()
return newdict
def __init__(self,config,shakefile,model):
if model not in getLogisticModelNames(config):
raise Exception('Could not find a model called "%s" in config %s.' % (model,config))
#do everything here short of calculations - parse config, assemble eqn strings, load data.
self.model = model
cmodel = config['logistic_models'][model]
self.coeffs = validateCoefficients(cmodel)
self.layers = validateLayers(cmodel)#key = layer name, value = file name
self.terms,timeField = validateTerms(cmodel,self.coeffs,self.layers)
self.interpolations = validateInterpolations(cmodel,self.layers)
self.units = validateUnits(cmodel,self.layers)
if 'baselayer' not in cmodel:
raise Exception('You must specify a base layer file in config.')
if cmodel['baselayer'] not in list(self.layers.keys()):
raise Exception('You must specify a base layer corresponding to one of the files in the layer section.')
#get the geodict for the shakemap
geodict = ShakeGrid.getFileGeoDict(shakefile,adjust='res')
griddict,eventdict,specdict,fields,uncertainties = getHeaderData(shakefile)
YEAR = eventdict['event_timestamp'].year
MONTH = MONTHS[(eventdict['event_timestamp'].month)-1]
DAY = eventdict['event_timestamp'].day
HOUR = eventdict['event_timestamp'].hour
#now find the layer that is our base layer and get the largest bounds we can guaranteed not to exceed shakemap bounds
basefile = self.layers[cmodel['baselayer']]
ftype = getFileType(basefile)
if ftype == 'esri':
basegeodict = GDALGrid.getFileGeoDict(basefile)
sampledict = basegeodict.getBoundsWithin(geodict)
elif ftype == 'gmt':
basegeodict = GMTGrid.getFileGeoDict(basefile)
sampledict = basegeodict.getBoundsWithin(geodict)
else:
raise Exception('All predictor variable grids must be a valid GMT or ESRI file type')
#now load the shakemap, resampling and padding if necessary
self.shakemap = ShakeGrid.load(shakefile,samplegeodict=sampledict,resample=True,doPadding=True,adjust='res')
#load the predictor layers into a dictionary
self.layerdict = {} #key = layer name, value = grid object
for layername,layerfile in self.layers.items():
if isinstance(layerfile,list):
for lfile in layerfile:
if timeField == 'MONTH':
if lfile.find(MONTH) > -1:
layerfile = lfile
ftype = getFileType(layerfile)
interp = self.interpolations[layername]
if ftype == 'gmt':
lyr = GMTGrid.load(layerfile,sampledict,resample=True,method=interp,doPadding=True)
elif ftype == 'esri':
lyr = GDALGrid.load(layerfile,sampledict,resample=True,method=interp,doPadding=True)
else:
msg = 'Layer %s (file %s) does not appear to be a valid GMT or ESRI file.' % (layername,layerfile)
raise Exception(msg)
self.layerdict[layername] = lyr
else:
#first, figure out what kind of file we have (or is it a directory?)
ftype = getFileType(layerfile)
interp = self.interpolations[layername]
if ftype == 'gmt':
lyr = GMTGrid.load(layerfile,sampledict,resample=True,method=interp,doPadding=True)
elif ftype == 'esri':
lyr = GDALGrid.load(layerfile,sampledict,resample=True,method=interp,doPadding=True)
else:
msg = 'Layer %s (file %s) does not appear to be a valid GMT or ESRI file.' % (layername,layerfile)
raise Exception(msg)
self.layerdict[layername] = lyr
shapes = {}
for layername,layer in self.layerdict.items():
shapes[layername] = layer.getData().shape
x = 1
self.nuggets = [str(self.coeffs['b0'])]
ckeys = list(self.terms.keys())
ckeys.sort()
for key in ckeys:
term = self.terms[key]
coeff = self.coeffs[key]
self.nuggets.append('(%g * %s)' % (coeff, term))
self.equation = ' + '.join(self.nuggets)
self.geodict = self.shakemap.getGeoDict()
def godt2008(shakefile,
config,
uncertfile=None,
saveinputs=False,
displmodel=None,
bounds=None,
slopediv=100.,
codiv=10.,
numstd=None,
trimfile=None):
"""
This function runs the Godt and others (2008) global method for a given
ShakeMap. The Factor of Safety is calculated using infinite slope analysis
assumuing dry conditions. The method uses threshold newmark displacement
and estimates areal coverage by doing the calculations for each slope
quantile.
Args:
shakefile (str): Path to shakemap xml file.
config (ConfigObj): ConfigObj of config file containing inputs required
for running the model
uncertfile (str): Path to shakemap uncertainty xml file (optional).
saveinputs (bool): Whether or not to return the model input layers,
False (default) returns only the model output (one layer).
displmodel (str): Newmark displacement regression model to use
* ``'J_PGA'`` (default) -- PGA-based model, equation 6 from
Jibson (2007).
* ``'J_PGA_M'`` -- PGA and M-based model, equation 7 from
Jibson (2007).
* ``'RS_PGA_M'`` -- PGA and M-based model from from Rathje and
Saygili (2009).
* ``'RS_PGA_PGV'`` -- PGA and PGV-based model, equation 6
from Saygili and Rathje (2008).
bounds (dict): Optional dictionary with keys 'xmin', 'xmax', 'ymin',
'ymax' that defines a subset of the shakemap area to compute.
slopediv (float): Divide slope by this number to get slope in degrees
(Verdin datasets need to be divided by 100).
codiv (float): Divide cohesion input layer by this number
(For Godt method, need to divide by 10 because that is how it was
calibrated).
numstd (float): Number of (+/-) standard deviations to use if
uncertainty is computed (uncertfile must be supplied).
trimfile (str): shapefile of earth's land masses to trim offshore areas
of model
Returns:
dict: Dictionary containing output and input layers (if
saveinputs=True):
.. code-block:: python
{
'grid': mapio grid2D object,
'label': 'label for colorbar and top line of subtitle',
'type': 'output or input to model',
'description': {'name': 'short reference of model',
'longref': 'full model reference',
'units': 'units of output',
'shakemap': 'information about shakemap used',
'event_id': 'shakemap event id',
'parameters': 'dictionary of model parameters
used'
}
}
Raises:
NameError: when unable to parse the config correctly (probably a
formatting issue in the configfile) or when unable to find the
shakefile (Shakemap filepath) -- these cause program to end.
"""
# TODO:
# - Add 'all' -- averages Dn from all four equations, add term to
# convert PGA and PGV to Ia and use other equations, add Ambraseys and
# Menu (1988) option.
# Empty refs
slopesref = 'unknown'
slopelref = 'unknown'
cohesionlref = 'unknown'
cohesionsref = 'unknown'
frictionsref = 'unknown'
frictionlref = 'unknown'
modellref = 'unknown'
modelsref = 'unknown'
# See if trimfile exists
if trimfile is not None:
if not os.path.exists(trimfile):
print('trimfile defined does not exist: %s\n'
'Ocean will not be trimmed' % trimfile)
trimfile = None
if os.path.splitext(trimfile)[1] != '.shp':
print('trimfile must be a shapefile, ocean will not be trimmed')
trimfile = None
# Parse config
try: # May want to add error handling so if refs aren't given, just
# includes unknown
slopefilepath = config['godt_2008']['layers']['slope']['filepath']
slopeunits = config['godt_2008']['layers']['slope']['units']
cohesionfile = config['godt_2008']['layers']['cohesion']['file']
cohesionunits = config['godt_2008']['layers']['cohesion']['units']
frictionfile = config['godt_2008']['layers']['friction']['file']
frictionunits = config['godt_2008']['layers']['friction']['units']
thick = float(config['godt_2008']['parameters']['thick'])
uwt = float(config['godt_2008']['parameters']['uwt'])
nodata_cohesion = \
float(config['godt_2008']['parameters']['nodata_cohesion'])
nodata_friction = \
float(config['godt_2008']['parameters']['nodata_friction'])
dnthresh = float(config['godt_2008']['parameters']['dnthresh'])
fsthresh = float(config['godt_2008']['parameters']['fsthresh'])
acthresh = float(config['godt_2008']['parameters']['acthresh'])
try:
slopemin = float(config['godt_2008']['parameters']['slopemin'])
except:
slopemin = 0.01
print('No slopemin found in config file, using 0.01 deg '
'for slope minimum')
except Exception as e:
raise NameError('Could not parse configfile, %s' % e)
if displmodel is None:
try:
displmodel = config['godt_2008']['parameters']['displmodel']
except:
print('No regression model specified, using default of J_PGA_M')
displmodel = 'J_PGA_M'
# TO DO: ADD ERROR CATCHING ON UNITS, MAKE SURE THEY ARE WHAT THEY SHOULD
# BE FOR THIS MODEL
try: # Try to fetch source information from config
modelsref = config['godt_2008']['shortref']
modellref = config['godt_2008']['longref']
slopesref = config['godt_2008']['layers']['slope']['shortref']
slopelref = config['godt_2008']['layers']['slope']['longref']
cohesionsref = config['godt_2008']['layers']['cohesion']['shortref']
cohesionlref = config['godt_2008']['layers']['cohesion']['longref']
frictionsref = config['godt_2008']['layers']['friction']['shortref']
frictionlref = config['godt_2008']['layers']['friction']['longref']
except:
print('Was not able to retrieve all references from config file. '
'Continuing')
# Figure out how/if need to cut anything
geodict = ShakeGrid.getFileGeoDict(shakefile) # , adjust='res')
if bounds is not None: # Make sure bounds are within ShakeMap Grid
if geodict.xmin < geodict.xmax: # only if signs are not opposite
if (geodict.xmin > bounds['xmin'] or geodict.xmax < bounds['xmax']
or geodict.ymin > bounds['ymin']
or geodict.ymax < bounds['ymax']):
print('Specified bounds are outside shakemap area, using '
'ShakeMap bounds instead.')
bounds = None
if bounds is not None:
tempgdict = GeoDict.createDictFromBox(bounds['xmin'],
bounds['xmax'],
bounds['ymin'],
bounds['ymax'],
geodict.dx,
geodict.dy,
inside=False)
# If Shakemap geodict crosses 180/-180 line, fix geodict so things don't break
if geodict.xmin > geodict.xmax:
if tempgdict.xmin < 0:
geodict._xmin -= 360.
else:
geodict._xmax += 360.
geodict = geodict.getBoundsWithin(tempgdict)
basegeodict, firstcol = GDALGrid.getFileGeoDict(
os.path.join(slopefilepath, 'slope_min.bil'))
if basegeodict == geodict:
sampledict = geodict
else:
sampledict = basegeodict.getBoundsWithin(geodict)
# Do we need to subdivide baselayer?
if 'divfactor' in config['godt_2008'].keys():
divfactor = float(config['godt_2008']['divfactor'])
if divfactor != 1.:
# adjust sampledict so everything will be resampled (cut one cell
# of each edge so will be inside bounds)
newxmin = sampledict.xmin - sampledict.dx/2. + \
sampledict.dx/(2.*divfactor) + sampledict.dx
newymin = sampledict.ymin - sampledict.dy/2. + \
sampledict.dy/(2.*divfactor) + sampledict.dy
newxmax = sampledict.xmax + sampledict.dx/2. - \
sampledict.dx/(2.*divfactor) - sampledict.dx
newymax = sampledict.ymax + sampledict.dy/2. - \
sampledict.dy/(2.*divfactor) - sampledict.dy
newdx = sampledict.dx / divfactor
newdy = sampledict.dy / divfactor
sampledict = GeoDict.createDictFromBox(newxmin,
newxmax,
newymin,
newymax,
newdx,
newdy,
inside=True)
tmpdir = tempfile.mkdtemp()
# Load in ShakeMap and get new geodictionary
temp = ShakeGrid.load(shakefile) # , adjust='res')
junkfile = os.path.join(tmpdir, 'temp.bil')
GDALGrid.copyFromGrid(temp.getLayer('pga')).save(junkfile)
pga = quickcut(junkfile, sampledict, precise=True, method='bilinear')
os.remove(junkfile)
GDALGrid.copyFromGrid(temp.getLayer('pgv')).save(junkfile)
pgv = quickcut(junkfile, sampledict, precise=True, method='bilinear')
os.remove(junkfile)
# Update geodictionary
sampledict = pga.getGeoDict()
t2 = temp.getEventDict()
M = t2['magnitude']
event_id = t2['event_id']
shakedict = temp.getShakeDict()
del (temp)
# read in uncertainty if present
if uncertfile is not None:
try:
temp = ShakeGrid.load(uncertfile) # , adjust='res')
GDALGrid.copyFromGrid(temp.getLayer('stdpga')).save(junkfile)
uncertpga = quickcut(junkfile,
sampledict,
precise=True,
method='bilinear',
override=True)
os.remove(junkfile)
GDALGrid.copyFromGrid(temp.getLayer('stdpgv')).save(junkfile)
uncertpgv = quickcut(junkfile,
sampledict,
precise=True,
method='bilinear',
override=True)
os.remove(junkfile)
except:
print('Could not read uncertainty file, ignoring uncertainties')
uncertfile = None
if numstd is None:
numstd = 1.
# Read in all the slope files, divide all by 100 to get to slope in
# degrees (because input files are multiplied by 100.)
slopes = []
quantiles = [
'slope_min.bil', 'slope10.bil', 'slope30.bil', 'slope50.bil',
'slope70.bil', 'slope90.bil', 'slope_max.bil'
]
for quant in quantiles:
tmpslp = quickcut(os.path.join(slopefilepath, quant), sampledict)
tgd = tmpslp.getGeoDict()
if tgd != sampledict:
raise Exception('Input layers are not aligned to same geodict')
else:
slopes.append(tmpslp.getData() / slopediv)
slopestack = np.dstack(slopes)
# Change any zero slopes to a very small number to avoid dividing by
# zero later
slopestack[slopestack == 0] = 1e-8
# Read in the cohesion and friction files and duplicate layers so they
# are same shape as slope structure
tempco = quickcut(cohesionfile, sampledict, method='near')
tempco = tempco.getData()[:, :, np.newaxis] / codiv
cohesion = np.repeat(tempco, 7, axis=2)
cohesion[cohesion == -999.9] = nodata_cohesion
cohesion = np.nan_to_num(cohesion)
cohesion[cohesion == 0] = nodata_cohesion
tempfric = quickcut(frictionfile, sampledict, method='near')
tempfric = tempfric.getData().astype(float)[:, :, np.newaxis]
friction = np.repeat(tempfric, 7, axis=2)
friction[friction == -9999] = nodata_friction
friction = np.nan_to_num(friction)
friction[friction == 0] = nodata_friction
# Do the calculations using Jibson (2007) PGA only model for Dn
FS = (cohesion / (uwt * thick * np.sin(slopestack * (np.pi / 180.))) +
np.tan(friction * (np.pi / 180.)) / np.tan(slopestack *
(np.pi / 180.)))
FS[FS < fsthresh] = fsthresh
# Compute critical acceleration, in g
# This gives ac in g, equations that multiply by g give ac in m/s2
Ac = (FS - 1) * np.sin(slopestack * (np.pi / 180.)).astype(float)
Ac[Ac < acthresh] = acthresh
# Get PGA in g (PGA is %g in ShakeMap, convert to g)
PGA = np.repeat(pga.getData()[:, :, np.newaxis] / 100., 7,
axis=2).astype(float)
if 'PGV' in displmodel: # Load in PGV also, in cm/sec
PGV = np.repeat(pgv.getData()[:, :, np.newaxis], 7,
axis=2).astype(float)
else:
PGV = None
if uncertfile is not None:
stdpga = np.repeat(uncertpga.getData()[:, :, np.newaxis], 7,
axis=2).astype(float)
stdpgv = np.repeat(uncertpgv.getData()[:, :, np.newaxis], 7,
axis=2).astype(float)
# estimate PGA +- 1std
PGAmin = np.exp(np.log(PGA * 100) - numstd * stdpga) / 100
PGAmax = np.exp(np.log(PGA * 100) + numstd * stdpga) / 100
if 'PGV' in displmodel:
PGVmin = np.exp(np.log(PGV) - numstd * stdpgv)
PGVmax = np.exp(np.log(PGV) + numstd * stdpgv)
else:
PGVmin = None
PGVmax = None
# Ignore errors so still runs when Ac > PGA, just leaves nan instead
# of crashing.
np.seterr(invalid='ignore')
Dn, logDnstd, logtype = NMdisp(Ac, PGA, model=displmodel, M=M, PGV=PGV)
if uncertfile is not None:
Dnmin, logDnstdmin, logtype = NMdisp(Ac,
PGAmin,
model=displmodel,
M=M,
PGV=PGVmin)
Dnmax, logDnstdmax, logtype = NMdisp(Ac,
PGAmax,
model=displmodel,
M=M,
PGV=PGVmax)
PROB = Dn.copy()
PROB[PROB < dnthresh] = 0.
PROB[PROB >= dnthresh] = 1.
PROB = np.sum(PROB, axis=2)
if uncertfile is not None:
PROBmin = Dnmin.copy()
PROBmin[PROBmin <= dnthresh] = 0.
PROBmin[PROBmin > dnthresh] = 1.
PROBmin = np.sum(PROBmin, axis=2)
PROBmax = Dnmax.copy()
PROBmax[PROBmax <= dnthresh] = 0.
PROBmax[PROBmax > dnthresh] = 1.
PROBmax = np.sum(PROBmax, axis=2)
PROB[PROB == 1.] = 0.01
PROB[PROB == 2.] = 0.10
PROB[PROB == 3.] = 0.30
PROB[PROB == 4.] = 0.50
PROB[PROB == 5.] = 0.70
PROB[PROB == 6.] = 0.90
PROB[PROB == 7.] = 0.99
if uncertfile is not None:
PROBmin[PROBmin == 1.] = 0.01
PROBmin[PROBmin == 2.] = 0.10
PROBmin[PROBmin == 3.] = 0.30
PROBmin[PROBmin == 4.] = 0.50
PROBmin[PROBmin == 5.] = 0.70
PROBmin[PROBmin == 6.] = 0.90
PROBmin[PROBmin == 7.] = 0.99
PROBmax[PROBmax == 1.] = 0.01
PROBmax[PROBmax == 2.] = 0.10
PROBmax[PROBmax == 3.] = 0.30
PROBmax[PROBmax == 4.] = 0.50
PROBmax[PROBmax == 5.] = 0.70
PROBmax[PROBmax == 6.] = 0.90
PROBmax[PROBmax == 7.] = 0.99
if slopemin is not None:
PROB[slopestack[:, :, 6] <= slopemin] = 0.
# uncert too
if uncertfile is not None:
PROBmin[slopestack[:, :, 6] <= slopemin] = 0.
PROBmax[slopestack[:, :, 6] <= slopemin] = 0.
# Turn output and inputs into into grids and put in mapLayers dictionary
maplayers = collections.OrderedDict()
shakedetail = '%s_ver%s' % (shakedict['shakemap_id'],
shakedict['shakemap_version'])
description = {
'name': modelsref,
'longref': modellref,
'units': 'Proportion of Area Affected',
'shakemap': shakedetail,
'event_id': event_id,
'parameters': {
'displmodel': displmodel,
'thickness_m': thick,
'unitwt_kNm3': uwt,
'dnthresh_cm': dnthresh,
'acthresh_g': acthresh,
'fsthresh': fsthresh,
'modeltype': 'Landslide'
}
}
PROBgrid = GDALGrid(PROB, sampledict)
if trimfile is not None:
PROBgrid = trim_ocean(PROBgrid, trimfile)
maplayers['model'] = {
'grid': PROBgrid,
'label': 'Landslide - Proportion of Area Affected',
'type': 'output',
'description': description
}
if uncertfile is not None:
PROBmingrid = GDALGrid(PROBmin, sampledict)
PROBmaxgrid = GDALGrid(PROBmax, sampledict)
if trimfile is not None:
PROBmingrid = trim_ocean(PROBmingrid, trimfile)
PROBmaxgrid = trim_ocean(PROBmaxgrid, trimfile)
maplayers['modelmin'] = {
'grid': PROBmingrid,
'label': 'Landslide Probability-%1.2fstd' % numstd,
'type': 'output',
'description': description
}
maplayers['modelmax'] = {
'grid': PROBmaxgrid,
'label': 'Landslide Probability+%1.2fstd' % numstd,
'type': 'output',
'description': description
}
if saveinputs is True:
maplayers['pga'] = {
'grid': GDALGrid(PGA[:, :, 0], sampledict),
'label': 'PGA (g)',
'type': 'input',
'description': {
'units': 'g',
'shakemap': shakedetail
}
}
if 'PGV' in displmodel:
maplayers['pgv'] = {
'grid': GDALGrid(PGV[:, :, 0], sampledict),
'label': 'PGV (cm/s)',
'type': 'input',
'description': {
'units': 'cm/s',
'shakemap': shakedetail
}
}
maplayers['minFS'] = {
'grid': GDALGrid(np.min(FS, axis=2), sampledict),
'label': 'Min Factor of Safety',
'type': 'input',
'description': {
'units': 'unitless'
}
}
maplayers['max slope'] = {
'grid': GDALGrid(slopestack[:, :, -1], sampledict),
'label': r'Maximum slope ($^\circ$)',
'type': 'input',
'description': {
'units': 'degrees',
'name': slopesref,
'longref': slopelref
}
}
maplayers['cohesion'] = {
'grid': GDALGrid(cohesion[:, :, 0], sampledict),
'label': 'Cohesion (kPa)',
'type': 'input',
'description': {
'units': 'kPa (adjusted)',
'name': cohesionsref,
'longref': cohesionlref
}
}
maplayers['friction angle'] = {
'grid': GDALGrid(friction[:, :, 0], sampledict),
'label': r'Friction angle ($^\circ$)',
'type': 'input',
'description': {
'units': 'degrees',
'name': frictionsref,
'longref': frictionlref
}
}
if uncertfile is not None:
maplayers['pgamin'] = {
'grid': GDALGrid(PGAmin[:, :, 0], sampledict),
'label': 'PGA - %1.2fstd (g)' % numstd,
'type': 'input',
'description': {
'units': 'g',
'shakemap': shakedetail
}
}
maplayers['pgamax'] = {
'grid': GDALGrid(PGAmax[:, :, 0], sampledict),
'label': 'PGA + %1.2fstd (g)' % numstd,
'type': 'input',
'description': {
'units': 'g',
'shakemap': shakedetail
}
}
if 'PGV' in displmodel:
if uncertfile is not None:
maplayers['pgvmin'] = {
'grid': GDALGrid(PGVmin[:, :, 0], sampledict),
'label': 'PGV - %1.2fstd (cm/s)' % numstd,
'type': 'input',
'description': {
'units': 'cm/s',
'shakemap': shakedetail
}
}
maplayers['pgvmax'] = {
'grid': GDALGrid(PGVmax[:, :, 0], sampledict),
'label': 'PGV + %1.2fstd (cm/s)' % numstd,
'type': 'input',
'description': {
'units': 'cm/s',
'shakemap': shakedetail
}
}
shutil.rmtree(tmpdir)
return maplayers
def kritikos_fuzzygamma(shakefile, config, bounds=None):
"""
Runs kritikos procedure with fuzzy gamma overlay method
"""
cmodel = config['statistical_models']['kritikos_2015']
gamma = cmodel['gamma_value']
############ This section reads in items from the config file
## Read in layer files and get data
layers = cmodel['layers']
try:
# Slope
slope_file = layers['slope']
# DFF
dff_file = layers['dff']
# DFS
dfs_file = layers['dfs']
# elev
elev_file = layers['elev']
except:
print('Unable to retrieve grid data.')
try:
div = cmodel['divisor']
# Load in divisors
MMI_div = div['MMI']
slope_div = div['slope']
dff_div = div['dff']
dfs_div = div['dfs']
slope_pos_div = div['slope_pos']
except:
print('Unable to retrieve divisors.')
try:
power = cmodel['power']
# Load in powers
MMI_power = power['MMI']
slope_power = power['slope']
dff_power = power['dff']
dfs_power = power['dfs']
slope_pos_power = power['slope_pos']
except:
print('Unable to retrieve powers.')
# Cut and resample, create geodict
try:
bounds = None
shkgdict = ShakeGrid.getFileGeoDict(shakefile, adjust='res')
slopedict, duplicated = GDALGrid.getFileGeoDict(slope_file)
if bounds is not None: # Make sure bounds are within ShakeMap Grid
if shkgdict.xmin > bounds['xmin'] or shkgdict.xmax < bounds[
'xmax'] or shkgdict.ymin > bounds[
'ymin'] or shkgdict.ymax < bounds['ymax']:
print(
'Specified bounds are outside shakemap area, using ShakeMap bounds instead'
)
bounds = None
if bounds is not None:
tempgdict = GeoDict(
{
'xmin': bounds['xmin'],
'ymin': bounds['ymin'],
'xmax': bounds['xmax'],
'ymax': bounds['ymax'],
'dx': 100.,
'dy': 100.,
'nx': 100.,
'ny': 100.
},
adjust='res')
gdict = slpdict.getBoundsWithin(tempgdict)
else: # Get boundaries from shakemap if not specified
gdict = slopedict.getBoundsWithin(shkgdict)
except:
raise NameError('Unable to create base geodict.')
# Load in data
############## Still need to make DFF and DFS layers
try:
# Load in slope data
slopegrid = GDALGrid.load(slope_file,
samplegeodict=gdict,
resample=False)
slope_data = slopegrid.getData().astype(float)
# Load in MMI
shakemap = ShakeGrid.load(shakefile,
samplegeodict=gdict,
resample=True,
method='linear',
adjust='res')
MMI_data = shakemap.getLayer('mmi').getData().astype(float)
# Load in Dff
############### STILL NEED THIS FILE
dffgrid = GDALGrid.load(dff_file, samplegeodict=gdict, resample=False)
dff_data = dffgrid.getData().astype(float)
# Load in DFS
############### STILL NEED THIS FILE
dfsgrid = GDALGrid.load(dfs_file, samplegeodict=gdict, resample=False)
dfs_data = dfsgrid.getData().astype(float)
# Load in elevation
elev_grid = GDALGrid.load(elev_file,
samplegeodict=gdict,
resample=False)
DEM = elev_grid.getData().astype(float)
except:
print('Data could not be retrieved.')
# Read in classifications
try:
mmi_class = cmodel['classification']['MMI']
slope_class = cmodel['classification']['slope']
dff_class = cmodel['classification']['dff']
dfs_class = cmodel['classification']['dfs']
slope_pos_class = cmodel['classification']['slope_pos']
except:
print('Could not recover classifications from config.')
try:
slope_pos_data = create_slopePos(slope_data, DEM, cmodel)
except:
print('Could not create slope position grid.')
####### Split classification strings into lists containing numbers and classify layers
# MMI classifications
try:
mmi_classes = mmi_class.split(',')
for i in mmi_classes:
if i.find('-') != -1:
j = i.split('-')
if MMI_data in range(int(j[0]), int(j[1])):
MMI_data = int(j[0])
else:
MMI_data = int(i)
except:
print('Could not categorize MMI values')
# Slope Classifications
try:
slope_classes = slope_class.split(',')
k = 1
for i in mmi_classes:
if i.find('-') != -1:
j = i.split('-')
if slope_data in range(int(j[0]), int(j[1])):
slope_data = k
k += 1
else:
slope_data = 11
except:
print('Could not recategorize Slope Values.')
# DFF classifications
try:
dff_classes = dff_class.split(',')
k = 1
for i in dff_classes:
if i.find('-') != -1:
j = i.split('-')
if dff_data in range(int(j[0]), int(j[1])):
dff_data = k
k += 1
else:
dff_data = 7
except:
print('Could not recategorize DFF values.')
# DFS classifications
try:
dfs_classes = dfs_class.split(',')
k = 1
for i in dfs_classes:
if i.find('-') != -1:
j = i.split('-')
if dfs_data in range(int(j[0]), int(j[1])):
dfs_data = k
k += 1
else:
dfs_data = 6
except:
print('Could not recategorize DFS values.')
# Slope position classification
try:
slope_pos_classes = slope_pos_class.split(',')
k = 1
for i in slope_poss_classes:
if slope_pos_data == i:
slope_pos_data = k
k += 1
except:
print('Could not recategorize slope position values.')
##############
# This section runs all the calculations
##############
# Run each layer through a membership function
try:
layers = []
# Calculate layers
slope = 1 / (1 + np.exp(slope_data / slope_div, slope_power))
MMI = 1 / (1 + np.exp(MMI_data / MMI_div, MMI_power))
dff = 1 / (1 + np.exp(dff_data / dff_div, dff_power))
dfs = 1 / (1 + np.exp(dfs_data / dfs_div, dfs_power))
slope_pos = 1 / (1 +
np.exp(slop_pos_data / slop_pos_div, slope_pos_power))
# Add to layers list (to be used in further calculations)
layers.append(slope)
layers.append(MMI)
layers.append(dff)
layers.append(dfs)
layers.append(slope_pos)
except:
print('Layer calculations failed.')
# Apply final calculations operator
# From Kritikos paper equation 4
############ Haven't run.
try:
a = np.prod(layers)
b = np.prod(1 - layers)
mu_x = np.power(a, 1 - gamma) * np.power(1 - b, gamma)
except:
print('Unable to calculate final product.')
def getLosses(self, shakefile):
"""Calculate number of fatalities using semi-empirical approach.
:param shakefile:
Path to a ShakeMap grid.xml file.
:returns:
Tuple of:
1) Total number of fatalities
2) Dictionary of residential fatalities per building type, per country.
3) Dictionary of non-residential fatalities per building type, per country.
"""
# get shakemap geodict
shakedict = ShakeGrid.getFileGeoDict(shakefile, adjust='res')
# get population geodict
popdict = get_file_geodict(self._popfile)
# get country code geodict
isodict = get_file_geodict(self._isofile)
# get urban grid geodict
urbdict = get_file_geodict(self._urbanfile)
# load all of the grids we need
if popdict == shakedict == isodict == urbdict:
# special case, probably for testing...
shakegrid = ShakeGrid.load(shakefile, adjust='res')
popgrid = read(self._popfile)
isogrid = read(self._isofile)
urbgrid = read(self._urbanfile)
else:
sampledict = popdict.getBoundsWithin(shakedict)
shakegrid = ShakeGrid.load(shakefile,
samplegeodict=sampledict,
resample=True,
method='linear',
adjust='res')
popgrid = read(self._popfile,
samplegeodict=sampledict,
resample=False)
isogrid = read(self._isofile,
samplegeodict=sampledict,
resample=True,
method='nearest',
doPadding=True,
padValue=0)
urbgrid = read(self._urbanfile,
samplegeodict=sampledict,
resample=True,
method='nearest',
doPadding=True,
padValue=RURAL)
# determine the local apparent time of day (based on longitude)
edict = shakegrid.getEventDict()
etime = edict['event_timestamp']
elon = edict['lon']
time_of_day, event_year, event_hour = get_time_of_day(etime, elon)
# round off our MMI data to nearest 0.5 (5.5 should stay 5.5, 5.4
# should become 5.5, 5.24 should become 5.0, etc.)
# TODO: Someday, make this more general to include perhaps grids of all IMT values, or
# at least the ones we have collapse data for.
mmidata = np.round(shakegrid.getLayer('mmi').getData() / 0.5) * 0.5
# get arrays from our other grids
popdata = popgrid.getData()
isodata = isogrid.getData()
urbdata = urbgrid.getData()
# modify the population values for growth rate by country
ucodes = np.unique(isodata[~np.isnan(isodata)])
for ccode in ucodes:
cidx = (isodata == ccode)
popdata[cidx] = self._popgrowth.adjustPopulation(
popdata[cidx], ccode, self._popyear, event_year)
# create a dictionary containing indoor populations by building type (in cells where MMI >= 6)
#popbystruct = get_indoor_pop(mmidata,popdata,urbdata,isodata,time_of_day)
# find all mmi values greater than 9, set them to 9
mmidata[mmidata > 9.0] = 9.0
# dictionary containers for sums of fatalities (res/nonres) by building type
res_fatal_by_ccode = {}
nonres_fatal_by_ccode = {}
# fatality sum
ntotal = 0
# loop over countries
ucodes = np.unique(isodata[~np.isnan(isodata)])
for ucode in ucodes:
if ucode == 0:
continue
res_fatal_by_btype = {}
nonres_fatal_by_btype = {}
cdict = self._country.getCountry(int(ucode))
ccode = cdict['ISO2']
# get the workforce Series data for the current country
wforce = self.getWorkforce(ccode)
if wforce is None:
logging.info('No workforce data for %s. Skipping.' %
(cdict['Name']))
continue
# loop over MMI values 6-9
for mmi in np.arange(6, 9.5, 0.5):
c1 = (mmidata == mmi)
c2 = (isodata == ucode)
if ucode > 900 and ucode != CALIFORNIA_US_CCODE:
ucode = US_CCODE
for dclass in [URBAN, RURAL]:
c3 = (urbdata == dclass)
# get the population data in those cells at MMI, in country, and density class
# I think I want an AND condition here
popcells = popdata[c1 & c2 & c3]
# get the population distribution across residential, non-residential, and outdoor.
res, nonres, outside = pop_dist(
popcells, wforce, time_of_day, dclass)
# get the inventory for urban residential
resrow, nresrow = self.getInventories(ccode, dclass)
# TODO - figure out why this is happening, make the following lines
# not necessary
if 'Unnamed: 0' in resrow:
resrow = resrow.drop('Unnamed: 0')
if 'Unnamed: 0' in nresrow:
nresrow = nresrow.drop('Unnamed: 0')
# now multiply the residential/non-residential population through the inventory data
numres = len(resrow)
numnonres = len(nresrow)
resmat = np.reshape(
resrow.values, (numres, 1)).astype(np.float32)
nresmat = np.reshape(
nresrow.values, (numnonres, 1)).astype(np.float32)
popres = np.tile(res, (numres, 1))
popnonres = np.tile(nonres, (numnonres, 1))
popresbuilding = (popres * resmat)
popnonresbuilding = (popnonres * nresmat)
# now we have the residential and non-residental population
# distributed through the building types for each cell that matches
# MMI,country, and density criteria.
# popresbuilding rows are building types, columns are population cells
# next, we get the collapse rates for these buildings
# and multiply them by the population by building.
collapse_res = self.getCollapse(ccode, mmi, resrow)
collapse_nonres = self.getCollapse(ccode, mmi, nresrow)
resrates = np.reshape(
collapse_res.values.astype(np.float32), (numres, 1))
nonresrates = np.reshape(
collapse_nonres.values.astype(np.float32), (numnonres, 1))
rescollapse = popresbuilding * resrates
nonrescollapse = popnonresbuilding * nonresrates
# get the fatality rates given collapse by building type and
# multiply through the result of collapse*population per building
resfatalcol = self.getFatalityRates(
ccode, time_of_day, resrow)
nonresfatalcol = self.getFatalityRates(
ccode, time_of_day, nresrow)
resfatal = np.reshape(
resfatalcol.values.astype(np.float32), (numres, 1))
nonresfatal = np.reshape(
nonresfatalcol.values.astype(np.float32), (numnonres, 1))
resfat = rescollapse * resfatal
nonresfat = nonrescollapse * nonresfatal
# zero out the cells where fatalities are less than 1 or nan
try:
if len(resfat) and len(resfat[0]):
resfat[np.ma.masked_less(resfat, 1).mask] = 0.0
except:
resfat[np.isnan(resfat)] = 0.0
try:
if len(nonresfat) and len(nonresfat[0]):
nonresfat[np.ma.masked_less(
nonresfat, 1).mask] = 0.0
except:
nonresfat[np.isnan(nonresfat)] = 0.0
# sum the fatalities per building through all cells
resfatbybuilding = np.nansum(resfat, axis=1)
nonresfatbybuilding = np.nansum(nonresfat, axis=1)
resfdict = dict(
zip(resrow.index, resfatbybuilding.tolist()))
nonresfdict = dict(
zip(nresrow.index, nonresfatbybuilding.tolist()))
res_fatal_by_btype = add_dicts(
res_fatal_by_btype, resfdict)
nonres_fatal_by_btype = add_dicts(
nonres_fatal_by_btype, nonresfdict)
# add the fatalities by building type to the dictionary containing fatalities by country
res_fatal_by_ccode[ccode] = res_fatal_by_btype.copy()
nonres_fatal_by_ccode[ccode] = nonres_fatal_by_btype.copy()
# increment the total number of fatalities
ntotal += int(sum(res_fatal_by_btype.values())
+ sum(nonres_fatal_by_btype.values()))
return (ntotal, res_fatal_by_ccode, nonres_fatal_by_ccode)
def __init__(self,
shakefile,
config,
uncertfile=None,
saveinputs=False,
slopefile=None,
slopediv=1.,
bounds=None,
numstd=1):
"""Set up the logistic model
# ADD BOUNDS TO THIS MODEL
:param config: configobj (config .ini file read in using configobj) defining the model and its inputs. Only one
model should be described in each config file.
:type config: dictionary
:param shakefile: Full file path to shakemap.xml file for the event of interest
:type shakefile: string
:param uncertfile: Full file path to xml file of shakemap uncertainties
:type uncertfile: string
:param saveinputs: if True, saves all the input layers as Grid2D objects in addition to the model
if false, it will just output the model
:type saveinputs: boolean
:param slopefile: optional file path to slopefile that will be resampled to the other input files for applying
thresholds OVERWRITES VALUE IN CONFIG
:type slopefile: string
:param slopediv: number to divide slope by to get to degrees (usually will be default
of 1.)
:type slopediv: float
:param numstd: number of +/- standard deviations to use if uncertainty is computed (uncertfile is not None)
"""
mnames = getLogisticModelNames(config)
if len(mnames) == 0:
raise Exception(
'No config file found or problem with config file format')
if len(mnames) > 1:
raise Exception(
'Config file contains more than one model which is no longer allowed,\
update your config file to the newer format')
self.model = mnames[0]
self.config = config
cmodel = config[self.model]
self.modeltype = cmodel['gfetype']
self.coeffs = validateCoefficients(cmodel)
self.layers = validateLayers(
cmodel) # key = layer name, value = file name
self.terms, timeField = validateTerms(cmodel, self.coeffs, self.layers)
self.interpolations = validateInterpolations(cmodel, self.layers)
self.units = validateUnits(cmodel, self.layers)
self.gmused = [
value for term, value in cmodel['terms'].items()
if 'pga' in value.lower() or 'pgv' in value.lower()
or 'mmi' in value.lower()
]
self.modelrefs, self.longrefs, self.shortrefs = validateRefs(cmodel)
self.numstd = numstd
if cmodel['baselayer'] not in list(self.layers.keys()):
raise Exception(
'You must specify a base layer corresponding to one of the files in the layer section.'
)
self.saveinputs = saveinputs
if slopefile is None:
try:
self.slopefile = cmodel['slopefile']
except:
print(
'Could not find slopefile term in config, no slope thresholds will be applied\n'
)
self.slopefile = None
else:
self.slopefile = slopefile
self.slopediv = slopediv
#get the geodict for the shakemap
geodict = ShakeGrid.getFileGeoDict(shakefile, adjust='res')
griddict, eventdict, specdict, fields, uncertainties = getHeaderData(
shakefile)
#YEAR = eventdict['event_timestamp'].year
MONTH = MONTHS[(eventdict['event_timestamp'].month) - 1]
#DAY = eventdict['event_timestamp'].day
#HOUR = eventdict['event_timestamp'].hour
#now find the layer that is our base layer and get the largest bounds we can guarantee not to exceed shakemap bounds
basefile = self.layers[cmodel['baselayer']]
ftype = getFileType(basefile)
if ftype == 'esri':
basegeodict, firstcol = GDALGrid.getFileGeoDict(basefile)
sampledict = basegeodict.getBoundsWithin(geodict)
elif ftype == 'gmt':
basegeodict, firstcol = GMTGrid.getFileGeoDict(basefile)
sampledict = basegeodict.getBoundsWithin(geodict)
else:
raise Exception(
'All predictor variable grids must be a valid GMT or ESRI file type'
)
#now load the shakemap, resampling and padding if necessary
if ShakeGrid.getFileGeoDict(shakefile, adjust='res') == sampledict:
self.shakemap = ShakeGrid.load(shakefile, adjust='res')
flag = 1
else:
self.shakemap = ShakeGrid.load(shakefile,
samplegeodict=sampledict,
resample=True,
doPadding=True,
adjust='res')
flag = 0
# take uncertainties into account
if uncertfile is not None:
try:
if flag == 1:
self.uncert = ShakeGrid.load(uncertfile, adjust='res')
else:
self.uncert = ShakeGrid.load(uncertfile,
samplegeodict=sampledict,
resample=True,
doPadding=True,
adjust='res')
except:
print(
'Could not read uncertainty file, ignoring uncertainties')
self.uncert = None
else:
self.uncert = None
#load the predictor layers into a dictionary
self.layerdict = {} # key = layer name, value = grid object
for layername, layerfile in self.layers.items():
if isinstance(layerfile, list):
for lfile in layerfile:
if timeField == 'MONTH':
if lfile.find(MONTH) > -1:
layerfile = lfile
ftype = getFileType(layerfile)
interp = self.interpolations[layername]
if ftype == 'gmt':
if GMTGrid.getFileGeoDict(
layerfile)[0] == sampledict:
lyr = GMTGrid.load(layerfile)
else:
lyr = GMTGrid.load(layerfile,
sampledict,
resample=True,
method=interp,
doPadding=True)
elif ftype == 'esri':
if GDALGrid.getFileGeoDict(
layerfile)[0] == sampledict:
lyr = GDALGrid.load(layerfile)
else:
lyr = GDALGrid.load(layerfile,
sampledict,
resample=True,
method=interp,
doPadding=True)
else:
msg = 'Layer %s (file %s) does not appear to be a valid GMT or ESRI file.' % (
layername, layerfile)
raise Exception(msg)
self.layerdict[layername] = lyr
else:
#first, figure out what kind of file we have (or is it a directory?)
ftype = getFileType(layerfile)
interp = self.interpolations[layername]
if ftype == 'gmt':
if GMTGrid.getFileGeoDict(layerfile)[0] == sampledict:
lyr = GMTGrid.load(layerfile)
else:
lyr = GMTGrid.load(layerfile,
sampledict,
resample=True,
method=interp,
doPadding=True)
elif ftype == 'esri':
if GDALGrid.getFileGeoDict(layerfile)[0] == sampledict:
lyr = GDALGrid.load(layerfile)
else:
lyr = GDALGrid.load(layerfile,
sampledict,
resample=True,
method=interp,
doPadding=True)
else:
msg = 'Layer %s (file %s) does not appear to be a valid GMT or ESRI file.' % (
layername, layerfile)
raise Exception(msg)
self.layerdict[layername] = lyr
shapes = {}
for layername, layer in self.layerdict.items():
shapes[layername] = layer.getData().shape
self.nuggets = [str(self.coeffs['b0'])]
ckeys = list(self.terms.keys())
ckeys.sort()
for key in ckeys:
term = self.terms[key]
coeff = self.coeffs[key]
self.nuggets.append('(%g * %s)' % (coeff, term))
self.equation = ' + '.join(self.nuggets)
if self.uncert is not None:
self.nugmin = copy.copy(self.nuggets)
self.nugmax = copy.copy(self.nuggets)
# Find the term with the shakemap input and replace for these nuggets
for k, nug in enumerate(self.nuggets):
if "self.shakemap.getLayer('pga').getData()" in nug:
self.nugmin[k] = self.nugmin[k].replace(
"self.shakemap.getLayer('pga').getData()",
"(np.exp(np.log(self.shakemap.getLayer('pga').getData())\
- self.numstd * self.uncert.getLayer('stdpga').getData()))"
)
self.nugmax[k] = self.nugmax[k].replace(
"self.shakemap.getLayer('pga').getData()",
"(np.exp(np.log(self.shakemap.getLayer('pga').getData())\
+ self.numstd * self.uncert.getLayer('stdpga').getData()))"
)
elif "self.shakemap.getLayer('pgv').getData()" in nug:
self.nugmin[k] = self.nugmin[k].replace(
"self.shakemap.getLayer('pgv').getData()",
"(np.exp(np.log(self.shakemap.getLayer('pgv').getData())\
- self.numstd * self.uncert.getLayer('stdpgv').getData()))"
)
self.nugmax[k] = self.nugmax[k].replace(
"self.shakemap.getLayer('pgv').getData()",
"(np.exp(np.log(self.shakemap.getLayer('pgv').getData())\
+ self.numstd * self.uncert.getLayer('stdpgv').getData()))"
)
elif "self.shakemap.getLayer('mmi').getData()" in nug:
self.nugmin[k] = self.nugmin[k].replace(
"self.shakemap.getLayer('mmi').getData()",
"(np.exp(np.log(self.shakemap.getLayer('mmi').getData())\
- self.numstd * self.uncert.getLayer('stdmmi').getData()))"
)
self.nugmax[k] = self.nugmax[k].replace(
"self.shakemap.getLayer('mmi').getData()",
"(np.exp(np.log(self.shakemap.getLayer('mmi').getData())\
+ self.numstd * self.uncert.getLayer('stdmmi').getData()))"
)
self.equationmin = ' + '.join(self.nugmin)
self.equationmax = ' + '.join(self.nugmax)
else:
self.equationmin = None
self.equationmax = None
self.geodict = self.shakemap.getGeoDict()
try:
self.slopemin = float(config[self.model]['slopemin'])
self.slopemax = float(config[self.model]['slopemax'])
except:
print(
'could not find slopemin and/or slopemax in config, no limits will be applied'
)
self.slopemin = 0.
self.slopemax = 90.
def __init__(self,
shakefile,
config,
uncertfile=None,
saveinputs=False,
slopefile=None,
bounds=None,
slopemod=None,
trimfile=None):
"""
Sets up the logistic model
Args:
shakefile (str): Path to shakemap grid.xml file for the event.
config: configobj object defining the model and its inputs. Only
one model should be described in each config file.
uncertfile (str): Path to uncertainty.xml file.
saveinputs (bool): Save input layers as Grid2D objects in addition
to the model? If false (the default), it will just output the
model.
slopefile (str): Optional path to slopefile that will be resampled
to the other input files for applying thresholds. OVERWRITES
VALUE IN CONFIG.
bounds (dict): Default of None uses ShakeMap boundaries, otherwise
a dictionary of boundaries to cut to like
.. code-block:: python
bounds = {
'xmin': lonmin, 'xmax': lonmax,
'ymin': latmin, 'ymax': latmax
}
slopemod (str): How slope input should be modified to be in
degrees: e.g., ``np.arctan(slope) * 180. / np.pi`` or
``slope/100.`` (note that this may be in the config file
already).
trimfile (str): shapefile of earth's landmasses to use to cut
offshore areas.
"""
mnames = getLogisticModelNames(config)
if len(mnames) == 0:
raise Exception('No config file found or problem with config '
'file format')
if len(mnames) > 1:
raise Exception('Config file contains more than one model which '
'is no longer allowed, update your config file '
'to the newer format')
self.model = mnames[0]
self.config = config
cmodel = config[self.model]
self.modeltype = cmodel['gfetype']
self.coeffs = validateCoefficients(cmodel)
# key = layer name, value = file name
self.layers = validateLayers(cmodel)
self.terms, timeField = validateTerms(cmodel, self.coeffs, self.layers)
self.interpolations = validateInterpolations(cmodel, self.layers)
self.units = validateUnits(cmodel, self.layers)
self.gmused = [
value for term, value in cmodel['terms'].items()
if 'pga' in value.lower() or 'pgv' in value.lower()
or 'mmi' in value.lower()
]
self.modelrefs, self.longrefs, self.shortrefs = validateRefs(cmodel)
#self.numstd = numstd
self.clips = validateClips(cmodel, self.layers, self.gmused)
self.notes = ''
if cmodel['baselayer'] not in list(self.layers.keys()):
raise Exception('You must specify a base layer corresponding to '
'one of the files in the layer section.')
self.saveinputs = saveinputs
if slopefile is None:
try:
self.slopefile = cmodel['slopefile']
except:
# print('Slopefile not specified in config, no slope '
# 'thresholds will be applied\n')
self.slopefile = None
else:
self.slopefile = slopefile
if slopemod is None:
try:
self.slopemod = cmodel['slopemod']
except:
self.slopemod = None
# See if trimfile exists
if trimfile is not None:
if not os.path.exists(trimfile):
print('trimfile defined does not exist: %s\nOcean will not be '
'trimmed' % trimfile)
self.trimfile = None
elif os.path.splitext(trimfile)[1] != '.shp':
print('trimfile must be a shapefile, ocean will not be '
'trimmed')
self.trimfile = None
else:
self.trimfile = trimfile
else:
self.trimfile = None
# Get month of event
griddict, eventdict, specdict, fields, uncertainties = \
getHeaderData(shakefile)
MONTH = MONTHS[(eventdict['event_timestamp'].month) - 1]
# Figure out how/if need to cut anything
geodict = ShakeGrid.getFileGeoDict(shakefile, adjust='res')
if bounds is not None: # Make sure bounds are within ShakeMap Grid
if geodict.xmin < geodict.xmax: # only if signs are not opposite
if (geodict.xmin > bounds['xmin']
or geodict.xmax < bounds['xmax']
or geodict.ymin > bounds['ymin']
or geodict.ymax < bounds['ymax']):
print('Specified bounds are outside shakemap area, using '
'ShakeMap bounds instead.')
bounds = None
if bounds is not None:
tempgdict = GeoDict.createDictFromBox(bounds['xmin'],
bounds['xmax'],
bounds['ymin'],
bounds['ymax'],
geodict.dx,
geodict.dy,
inside=False)
# If Shakemap geodict crosses 180/-180 line, fix geodict so things don't break
if geodict.xmin > geodict.xmax:
if tempgdict.xmin < 0:
geodict._xmin -= 360.
else:
geodict._xmax += 360.
gdict = geodict.getBoundsWithin(tempgdict)
else:
gdict = geodict
# Now find the layer that is our base layer and get the largest bounds
# we can guarantee not to exceed shakemap bounds
basefile = self.layers[cmodel['baselayer']]
ftype = getFileType(basefile)
if ftype == 'esri':
basegeodict, firstcol = GDALGrid.getFileGeoDict(basefile)
if basegeodict == gdict:
sampledict = gdict
else:
sampledict = basegeodict.getBoundsWithin(gdict)
elif ftype == 'gmt':
basegeodict, firstcol = GMTGrid.getFileGeoDict(basefile)
if basegeodict == gdict:
sampledict = gdict
else:
sampledict = basegeodict.getBoundsWithin(gdict)
else:
raise Exception('All predictor variable grids must be a valid '
'GMT or ESRI file type.')
# Do we need to subdivide baselayer?
if 'divfactor' in self.config[self.model].keys():
divfactor = float(self.config[self.model]['divfactor'])
if divfactor != 1.:
# adjust sampledict so everything will be resampled
newxmin = sampledict.xmin - sampledict.dx / \
2. + sampledict.dx/(2.*divfactor)
newymin = sampledict.ymin - sampledict.dy / \
2. + sampledict.dy/(2.*divfactor)
newxmax = sampledict.xmax + sampledict.dx / \
2. - sampledict.dx/(2.*divfactor)
newymax = sampledict.ymax + sampledict.dy / \
2. - sampledict.dy/(2.*divfactor)
newdx = sampledict.dx / divfactor
newdy = sampledict.dy / divfactor
sampledict = GeoDict.createDictFromBox(newxmin,
newxmax,
newymin,
newymax,
newdx,
newdy,
inside=True)
# Find slope thresholds, if applicable
self.slopemin = 'none'
self.slopemax = 'none'
if self.slopefile is not None:
try:
self.slopemin = float(config[self.model]['slopemin'])
self.slopemax = float(config[self.model]['slopemax'])
except:
print('Could not find slopemin and/or slopemax in config, '
'limits. No slope thresholds will be applied.')
self.slopemin = 'none'
self.slopemax = 'none'
# Make temporary directory for hdf5 pytables file storage
self.tempdir = tempfile.mkdtemp()
# now load the shakemap, resampling and padding if necessary
temp = ShakeGrid.load(shakefile) # , adjust='res')
self.shakedict = temp.getShakeDict()
self.eventdict = temp.getEventDict()
self.shakemap = {}
# Read both PGA and PGV in, may need them for thresholds
for gm in ['pga', 'pgv']:
junkfile = os.path.join(self.tempdir, 'temp.bil')
GDALGrid.copyFromGrid(temp.getLayer(gm)).save(junkfile)
if gm in self.interpolations.keys():
intermeth = self.interpolations[gm]
else:
intermeth = 'bilinear'
junkgrid = quickcut(junkfile,
sampledict,
precise=True,
method=intermeth)
if gm in self.clips:
junkgrid.setData(
np.clip(junkgrid.getData(), self.clips[gm][0],
self.clips[gm][1]))
self.shakemap[gm] = TempHdf(
junkgrid, os.path.join(self.tempdir, '%s.hdf5' % gm))
os.remove(junkfile)
del (temp)
# get updated geodict
sampledict = junkgrid.getGeoDict()
# take uncertainties into account, if available
if uncertfile is not None:
self.uncert = {}
try:
# Only read in the ones that will be needed
temp = ShakeGrid.load(uncertfile)
already = []
for gm in self.gmused:
if 'pgv' in gm:
gmsimp = 'pgv'
elif 'pga' in gm:
gmsimp = 'pga'
elif 'mmi' in gm:
gmsimp = 'mmi'
if gmsimp in already:
continue
junkfile = os.path.join(self.tempdir, 'temp.bil')
GDALGrid.copyFromGrid(temp.getLayer('std%s' %
gmsimp)).save(junkfile)
if gmsimp in self.interpolations.keys():
intermeth = self.interpolations[gmsimp]
else:
intermeth = 'bilinear'
junkgrid = quickcut(junkfile,
sampledict,
precise=True,
method=intermeth)
if gmsimp in self.clips:
junkgrid.setData(
np.clip(junkgrid.getData(), self.clips[gmsimp][0],
self.clips[gmsimp][1]))
self.uncert['std' + gmsimp] = TempHdf(
junkgrid,
os.path.join(self.tempdir, 'std%s.hdf5' % gmsimp))
already.append(gmsimp)
os.remove(junkfile)
del (temp)
except:
print('Could not read uncertainty file, ignoring '
'uncertainties')
self.uncert = None
else:
self.uncert = None
# Load the predictor layers, save as hdf5 temporary files, put file
# locations into a dictionary.
# Will be replaced in the next section if a slopefile was defined
self.nonzero = None
# key = layer name, value = grid object
self.layerdict = {}
didslope = False
for layername, layerfile in self.layers.items():
start = timer()
if isinstance(layerfile, list):
for lfile in layerfile:
if timeField == 'MONTH':
if lfile.find(MONTH) > -1:
layerfile = lfile
ftype = getFileType(layerfile)
interp = self.interpolations[layername]
temp = quickcut(layerfile,
sampledict,
precise=True,
method=interp)
if layername in self.clips:
temp.setData(
np.clip(temp.getData(),
self.clips[layername][0],
self.clips[layername][1]))
self.layerdict[layername] = TempHdf(
temp,
os.path.join(self.tempdir,
'%s.hdf5' % layername))
del (temp)
else:
interp = self.interpolations[layername]
temp = quickcut(layerfile,
sampledict,
precise=True,
method=interp)
if layername in self.clips:
temp.setData(
np.clip(temp.getData(), self.clips[layername][0],
self.clips[layername][1]))
if layername == 'rock': # Convert unconsolidated sediments to a more reasonable coefficient
sub1 = temp.getData()
# Change to mixed sed rock coeff
sub1[sub1 <= -3.21] = -1.36
temp.setData(sub1)
self.notes += 'unconsolidated sediment coefficient changed\
to -1.36 (weaker) from -3.22 to better reflect that this \
unit is not actually strong\n'
self.layerdict[layername] = TempHdf(
temp, os.path.join(self.tempdir, '%s.hdf5' % layername))
td = temp.getGeoDict()
if td != sampledict:
raise Exception(
'Geodictionaries of resampled files do not match')
if layerfile == self.slopefile:
flag = 0
if self.slopemin == 'none' and self.slopemax == 'none':
flag = 1
if self.slopemod is None:
slope1 = temp.getData().astype(float)
slope = 0
else:
try:
slope = temp.getData().astype(float)
slope1 = eval(self.slopemod)
except:
print('slopemod provided not valid, continuing '
'without slope thresholds.')
flag = 1
if flag == 0:
nonzero = np.array([(slope1 > self.slopemin) &
(slope1 <= self.slopemax)])
self.nonzero = nonzero[0, :, :]
del (slope1)
del (slope)
else:
# Still remove areas where the slope equals exactly
# 0.0 to remove offshore liq areas.
nonzero = np.array([slope1 != 0.0])
self.nonzero = nonzero[0, :, :]
del (slope1)
didslope = True
del (temp)
print('Loading %s layer: %1.1f sec' % (layername, timer() - start))
if didslope is False and self.slopefile is not None:
# Slope didn't get read in yet
temp = quickcut(self.slopefile,
sampledict,
precise=True,
method='bilinear')
flag = 0
if self.slopemin == 'none' and self.slopemax == 'none':
flag = 1
if self.slopemod is None:
slope1 = temp.getData().astype(float)
slope = 0
else:
try:
slope = temp.getData().astype(float)
slope1 = eval(self.slopemod)
except:
print('slopemod provided not valid, continuing without '
'slope thresholds')
flag = 1
if flag == 0:
nonzero = np.array([
(slope1 > self.slopemin) & (slope1 <= self.slopemax)
])
self.nonzero = nonzero[0, :, :]
del (slope1)
del (slope)
else:
# Still remove areas where the slope equals exactly
# 0.0 to remove offshore liq areas.
nonzero = np.array([slope1 != 0.0])
self.nonzero = nonzero[0, :, :]
del (slope1)
self.nuggets = [str(self.coeffs['b0'])]
ckeys = list(self.terms.keys())
ckeys.sort()
for key in ckeys:
term = self.terms[key]
coeff = self.coeffs[key]
self.nuggets.append('(%g * %s)' % (coeff, term))
self.equation = ' + '.join(self.nuggets)
self.geodict = sampledict
def godt2008(shakefile, config, uncertfile=None, saveinputs=False, regressionmodel='J_PGA', bounds=None, slopediv=100., codiv=10.):
""" This function runs the Godt et al. (2008) global method for a given ShakeMap. The Factor of Safety
is calculated using infinite slope analysis assumuing dry conditions. The method uses threshold newmark
displacement and estimates areal coverage by doing the calculations for each slope quantile
TO DO - add 'all' - averages Dn from all four equations, add term to convert PGA and PGV to Ia and use other equations, add Ambraseys and Menu (1988) option
:param shakefile: url or filepath to shakemap xml file
:type shakefile: string
:param config: ConfigObj of config file containing inputs required for running the model
:type config: ConfigObj
:param saveinputs: Whether or not to return the model input layers, False (defeault) returns only the model output (one layer)
:type saveinputs: boolean
:param regressionmodel:
Newmark displacement regression model to use
'J_PGA' (default) - PGA-based model from Jibson (2007) - equation 6
'J_PGA_M' - PGA and M-based model from Jibson (2007) - equation 7
'RS_PGA_M' - PGA and M-based model from from Rathje and Saygili (2009)
'RS_PGA_PGV' - PGA and PGV-based model from Saygili and Rathje (2008) - equation 6
:type regressionmodel: string
:param probtype: Method used to estimate probability. Entering 'jibson2000' uses equation 5 from Jibson et al. (2000) to estimate probability from Newmark displacement. 'threshold' uses a specified threshold of Newmark displacement (defined in config file) and assumes anything greather than this threshold fails
:type probtype: string
:param slopediv: Divide slope by this number to get slope in degrees (Verdin datasets need to be divided by 100)
:type slopediv: float
:param codiv: Divide cohesion by this number to get reasonable numbers (For Godt method, need to divide by 10 because that is how it was calibrated, but values are reasonable without multiplying for regular analysis)
:type codiv: float
:returns maplayers: Dictionary containing output and input layers (if saveinputs=True) along with metadata formatted like maplayers['layer name']={'grid': mapio grid2D object, 'label': 'label for colorbar and top line of subtitle', 'type': 'output or input to model', 'description': 'detailed description of layer for subtitle, potentially including source information'}
:type maplayers: OrderedDict
:raises NameError: when unable to parse the config correctly (probably a formatting issue in the configfile) or when unable to find the shakefile (Shakemap URL or filepath) - these cause program to end
"""
# Empty refs
slopesref = 'unknown'
slopelref = 'unknown'
cohesionlref = 'unknown'
cohesionsref = 'unknown'
frictionsref = 'unknown'
frictionlref = 'unknown'
modellref = 'unknown'
modelsref = 'unknown'
if uncertfile is not None:
print('ground motion uncertainty option not implemented yet')
# Parse config
try: # May want to add error handling so if refs aren't given, just includes unknown
slopefilepath = config['mechanistic_models']['godt_2008']['layers']['slope']['filepath']
slopeunits = config['mechanistic_models']['godt_2008']['layers']['slope']['units']
cohesionfile = config['mechanistic_models']['godt_2008']['layers']['cohesion']['file']
cohesionunits = config['mechanistic_models']['godt_2008']['layers']['cohesion']['units']
frictionfile = config['mechanistic_models']['godt_2008']['layers']['friction']['file']
frictionunits = config['mechanistic_models']['godt_2008']['layers']['friction']['units']
thick = float(config['mechanistic_models']['godt_2008']['parameters']['thick'])
uwt = float(config['mechanistic_models']['godt_2008']['parameters']['uwt'])
nodata_cohesion = float(config['mechanistic_models']['godt_2008']['parameters']['nodata_cohesion'])
nodata_friction = float(config['mechanistic_models']['godt_2008']['parameters']['nodata_friction'])
dnthresh = float(config['mechanistic_models']['godt_2008']['parameters']['dnthresh'])
fsthresh = float(config['mechanistic_models']['godt_2008']['parameters']['fsthresh'])
acthresh = float(config['mechanistic_models']['godt_2008']['parameters']['acthresh'])
except Exception as e:
raise NameError('Could not parse configfile, %s' % e)
return
# TO DO, ADD ERROR CATCHING ON UNITS, MAKE SURE THEY ARE WHAT THEY SHOULD BE FOR THIS MODEL
try: # Try to fetch source information from config
modelsref = config['mechanistic_models']['godt_2008']['shortref']
modellref = config['mechanistic_models']['godt_2008']['longref']
slopesref = config['mechanistic_models']['godt_2008']['layers']['slope']['shortref']
slopelref = config['mechanistic_models']['godt_2008']['layers']['slope']['longref']
cohesionsref = config['mechanistic_models']['godt_2008']['layers']['cohesion']['shortref']
cohesionlref = config['mechanistic_models']['godt_2008']['layers']['cohesion']['longref']
frictionsref = config['mechanistic_models']['godt_2008']['layers']['friction']['shortref']
frictionlref = config['mechanistic_models']['godt_2008']['layers']['friction']['longref']
except:
print('Was not able to retrieve all references from config file. Continuing')
# Load in shakefile
if not os.path.isfile(shakefile):
if isURL(shakefile):
shakefile = getGridURL(shakefile) # returns a file object
else:
raise NameError('Could not find "%s" as a file or a valid url' % (shakefile))
return
shkgdict = ShakeGrid.getFileGeoDict(shakefile, adjust='res')
if bounds is not None: # Make sure bounds are within ShakeMap Grid
if shkgdict.xmin > bounds['xmin'] or shkgdict.xmax < bounds['xmax'] or shkgdict.ymin > bounds['ymin'] or shkgdict.ymax < bounds['ymax']:
print('Specified bounds are outside shakemap area, using ShakeMap bounds instead')
bounds = None
if bounds is not None:
tempgdict = GeoDict({'xmin': bounds['xmin'], 'ymin': bounds['ymin'], 'xmax': bounds['xmax'], 'ymax': bounds['ymax'], 'dx': shkgdict.dx, 'dy': shkgdict.dy, 'nx': shkgdict.nx, 'ny': shkgdict.ny}, adjust='res')
gdict = shkgdict.getBoundsWithin(tempgdict)
shakemap = ShakeGrid.load(shakefile, samplegeodict=gdict, adjust='bounds')
else:
shakemap = ShakeGrid.load(shakefile, adjust='res')
shkgdict = shakemap.getGeoDict() # Get updated geodict
M = shakemap.getEventDict()['magnitude']
# Read in all the slope files, divide all by 100 to get to slope in degrees (because input files are multiplied by 100.)
slopes = []
slopes.append(GDALGrid.load(os.path.join(slopefilepath, 'slope_min.bil'), samplegeodict=shkgdict, resample=True, method='linear').getData()/slopediv)
slopes.append(GDALGrid.load(os.path.join(slopefilepath, 'slope10.bil'), samplegeodict=shkgdict, resample=True, method='linear').getData()/slopediv)
slopes.append(GDALGrid.load(os.path.join(slopefilepath, 'slope30.bil'), samplegeodict=shkgdict, resample=True, method='linear').getData()/slopediv)
slopes.append(GDALGrid.load(os.path.join(slopefilepath, 'slope50.bil'), samplegeodict=shkgdict, resample=True, method='linear').getData()/slopediv)
slopes.append(GDALGrid.load(os.path.join(slopefilepath, 'slope70.bil'), samplegeodict=shkgdict, resample=True, method='linear').getData()/slopediv)
slopes.append(GDALGrid.load(os.path.join(slopefilepath, 'slope90.bil'), samplegeodict=shkgdict, resample=True, method='linear').getData()/slopediv)
slopes.append(GDALGrid.load(os.path.join(slopefilepath, 'slope_max.bil'), samplegeodict=shkgdict, resample=True, method='linear').getData()/slopediv)
slopestack = np.dstack(slopes)
# Change any zero slopes to a very small number to avoid dividing by zero later
slopestack[slopestack == 0] = 1e-8
# Read in the cohesion and friction files and duplicate layers so they are same shape as slope structure
cohesion = np.repeat(GDALGrid.load(cohesionfile, samplegeodict=shakemap.getGeoDict(), resample=True, method='nearest').getData()[:, :, np.newaxis]/codiv, 7, axis=2)
cohesion[cohesion == -999.9] = nodata_cohesion
cohesion[cohesion == 0] = nodata_cohesion
friction = np.repeat(GDALGrid.load(frictionfile, samplegeodict=shakemap.getGeoDict(), resample=True, method='nearest').getData().astype(float)[:, :, np.newaxis], 7, axis=2)
friction[friction == -9999] = nodata_friction
friction[friction == 0] = nodata_friction
# Do the calculations using Jibson (2007) PGA only model for Dn
FS = cohesion/(uwt*thick*np.sin(slopestack*(np.pi/180.))) + np.tan(friction*(np.pi/180.))/np.tan(slopestack*(np.pi/180.))
FS[FS < fsthresh] = fsthresh
# Compute critical acceleration, in g
Ac = (FS-1)*np.sin(slopestack*(np.pi/180.)).astype(float) # This gives ac in g, equations that multiply by g give ac in m/s2
Ac[Ac < acthresh] = acthresh
# Get PGA in g (PGA is %g in ShakeMap, convert to g)
PGA = np.repeat(shakemap.getLayer('pga').getData()[:, :, np.newaxis]/100., 7, axis=2).astype(float)
if 'PGV' in regressionmodel: # Load in PGV also, in cm/sec
PGV = np.repeat(shakemap.getLayer('pgv').getData()[:, :, np.newaxis], 7, axis=2).astype(float)
np.seterr(invalid='ignore') # Ignore errors so still runs when Ac > PGA, just leaves nan instead of crashing
if regressionmodel is 'J_PGA':
Dn = J_PGA(Ac, PGA)
if regressionmodel is 'J_PGA_M':
Dn = J_PGA_M(Ac, PGA, M)
if regressionmodel is 'RS_PGA_M':
Dn = RS_PGA_M(Ac, PGA, M)
if regressionmodel is 'RS_PGA_PGV':
Dn = RS_PGA_PGV(Ac, PGA, PGV)
PROB = Dn.copy()
PROB[PROB < dnthresh] = 0.
PROB[PROB >= dnthresh] = 1.
PROB = np.sum(PROB, axis=2)
PROB[PROB == 1.] = 0.01
PROB[PROB == 2.] = 0.10
PROB[PROB == 3.] = 0.30
PROB[PROB == 4.] = 0.50
PROB[PROB == 5.] = 0.70
PROB[PROB == 6.] = 0.90
PROB[PROB == 7.] = 0.99
# Turn output and inputs into into grids and put in mapLayers dictionary
maplayers = collections.OrderedDict()
temp = shakemap.getShakeDict()
shakedetail = '%s_ver%s' % (temp['shakemap_id'], temp['shakemap_version'])
description = {'name': modelsref, 'longref': modellref, 'units': 'coverage', 'shakemap': shakedetail, 'parameters': {'regressionmodel': regressionmodel, 'thickness_m': thick, 'unitwt_kNm3': uwt, 'dnthresh_cm': dnthresh, 'acthresh_g': acthresh, 'fsthresh': fsthresh}}
maplayers['model'] = {'grid': GDALGrid(PROB, shakemap.getGeoDict()), 'label': 'Areal coverage', 'type': 'output', 'description': description}
if saveinputs is True:
maplayers['pga'] = {'grid': GDALGrid(PGA[:, :, 0], shakemap.getGeoDict()), 'label': 'PGA (g)', 'type': 'input', 'description': {'units': 'g', 'shakemap': shakedetail}}
if 'PGV' in regressionmodel:
maplayers['pgv'] = {'grid': GDALGrid(PGV[:, :, 0], shakemap.getGeoDict()), 'label': 'PGV (cm/s)', 'type': 'input', 'description': {'units': 'cm/s', 'shakemap': shakedetail}}
maplayers['minFS'] = {'grid': GDALGrid(np.min(FS, axis=2), shakemap.getGeoDict()), 'label': 'Min Factor of Safety', 'type': 'input', 'description': {'units': 'unitless'}}
maplayers['max slope'] = {'grid': GDALGrid(slopestack[:, :, -1], shakemap.getGeoDict()), 'label': 'Maximum slope ($^\circ$)', 'type': 'input', 'description': {'units': 'degrees', 'name': slopesref, 'longref': slopelref}}
maplayers['cohesion'] = {'grid': GDALGrid(cohesion[:, :, 0], shakemap.getGeoDict()), 'label': 'Cohesion (kPa)', 'type': 'input', 'description': {'units': 'kPa (adjusted)', 'name': cohesionsref, 'longref': cohesionlref}}
maplayers['friction angle'] = {'grid': GDALGrid(friction[:, :, 0], shakemap.getGeoDict()), 'label': 'Friction angle ($^\circ$)', 'type': 'input', 'description': {'units': 'degrees', 'name': frictionsref, 'longref': frictionlref}}
return maplayers
def HAZUS(shakefile, config, uncertfile=None, saveinputs=False, modeltype='coverage', regressionmodel='J_PGA', probtype='jibson2000', bounds=None):
"""
Runs HAZUS landslide procedure (FEMA, 2003, Chapter 4) using susceptiblity categories from defined by HAZUS manual (I-X)
:param shakefile: URL or complete file path to the location of the Shakemap to use as input
:type shakefile: string:
:param config: Model configuration file object containing locations of input files and other input values config = ConfigObj(configfilepath)
:type config: ConfigObj
:param saveinputs: Whether or not to return the model input layers, False (defeault) returns only the model output (one layer)
:type saveinputs: boolean
:param modeltype: 'coverage' if critical acceleration is exceeded by pga, this gives the estimated areal coverage of landsliding for that cell
'dn_hazus' - Outputs Newmark displacement using HAZUS methods without relating to probability of failure
'dn_prob' - Estimates Newmark displacement using HAZUS methods and relates to probability of failure using param probtype
'ac_classic_dn' - Uses the critical acceleration defined by HAZUS methodology and uses regression model defined by regressionmodel param to get Newmark displacement without relating to probability of failure
'ac_classic_prob' - Uses the critical acceleration defined by HAZUS methodology and uses regression model defined by regressionmodel param to get Newmark displacement and probability defined by probtype method
:type modeltype: string
:param regressionmodel:
Newmark displacement regression model to use
'J_PGA' (default) - PGA-based model from Jibson (2007) - equation 6
'J_PGA_M' - PGA and M-based model from Jibson (2007) - equation 7
'RS_PGA_M' - PGA and M-based model from from Rathje and Saygili (2009)
'RS_PGA_PGV' - PGA and PGV-based model from Saygili and Rathje (2008) - equation 6
:type regressionmodel: string
:param probtype: Method used to estimate probability. Entering 'jibson2000' uses equation 5 from Jibson et al. (2000) to estimate probability from Newmark displacement. 'threshold' uses a specified threshold of Newmark displacement (defined in config file) and assumes anything greather than this threshold fails
:type probtype: string
:param bounds: Boundaries to compute over if different from ShakeMap boundaries as dictionary with keys 'xmin', 'xmax', 'ymin', 'ymax'
:returns maplayers: Dictionary containing output and input layers (if saveinputs=True) along with metadata formatted like maplayers['layer name']={'grid': mapio grid2D object, 'label': 'label for colorbar and top line of subtitle', 'type': 'output or input to model', 'description': 'detailed description of layer for subtitle, potentially including source information'}
:type maplayers: OrderedDict
"""
# Empty refs
suslref = 'unknown'
sussref = 'unknown'
modellref = 'unknown'
modelsref = 'unknown'
# Parse config and read in files
sus = None
susdat = None
if uncertfile is not None:
print('ground motion uncertainty option not implemented yet')
# Read in susceptiblity file
#try:
susfile = config['mechanistic_models']['hazus']['layers']['susceptibility']['file']
shkgdict = ShakeGrid.getFileGeoDict(shakefile, adjust='res')
susdict = GDALGrid.getFileGeoDict(susfile)
if bounds is not None: # Make sure bounds are within ShakeMap Grid
if shkgdict.xmin > bounds['xmin'] or shkgdict.xmax < bounds['xmax'] or shkgdict.ymin > bounds['ymin'] or shkgdict.ymax < bounds['ymax']:
print('Specified bounds are outside shakemap area, using ShakeMap bounds instead')
bounds = None
if bounds is not None:
tempgdict1 = GeoDict({'xmin': bounds['xmin'], 'ymin': bounds['ymin'], 'xmax': bounds['xmax'], 'ymax': bounds['ymax'], 'dx': 100., 'dy': 100., 'nx': 100., 'ny': 100.}, adjust='res')
tempgdict = susdict.getBoundsWithin(tempgdict1)
else:
tempgdict = susdict.getBoundsWithin(shkgdict)
sus = GDALGrid.load(susfile, samplegeodict=tempgdict, resample=False)
gdict = sus.getGeoDict()
susdat = sus.getData()
#except Exception as e:
# raise IOError('Unable to read in susceptibility category file specified in config, %s,' % e)
# return
try: # Try to fetch source information from config
modelsref = config['mechanistic_models']['hazus']['shortref']
modellref = config['mechanistic_models']['hazus']['longref']
sussref = config['mechanistic_models']['hazus']['layers']['susceptibility']['shortref']
suslref = config['mechanistic_models']['hazus']['layers']['susceptibility']['longref']
except:
print('Was not able to retrieve all references from config file. Continuing')
try:
dnthresh = float(config['mechanistic_models']['hazus']['values']['dnthresh'])
except:
if probtype == 'threshold':
dnthresh = 5.
print('Unable to find dnthresh in config, using 5cm')
# Load in shakemap, resample to susceptibility file
shakemap = ShakeGrid.load(shakefile, adjust='res')
PGA = shakemap.getLayer('pga').subdivide(gdict).getData().astype(float)/100. # in units of g
PGV = shakemap.getLayer('pgv').subdivide(gdict).getData().astype(float) # cm/sec
M = shakemap.getEventDict()['magnitude']
# Get critical accelerations in g
Ac = np.empty(np.shape(susdat))
Ac[(susdat < 1) & (susdat > 10)] = 9999.
Ac[susdat == 1] = 0.6
Ac[susdat == 2] = 0.5
Ac[susdat == 3] = 0.4
Ac[susdat == 4] = 0.35
Ac[susdat == 5] = 0.3
Ac[susdat == 6] = 0.25
Ac[susdat == 7] = 0.2
Ac[susdat == 8] = 0.15
Ac[susdat == 9] = 0.1
Ac[susdat == 10] = 0.05
# can delete sus and susdat now, if don't need to output it, to free up memory
if saveinputs is False:
del susdat, sus
if modeltype == 'coverage':
areal = np.zeros(np.shape(PGA))
# This seems to be slow for large matrices
areal[(PGA >= Ac) & (Ac == 0.6)] = 0.01
areal[(PGA >= Ac) & (Ac == 0.5)] = 0.02
areal[(PGA >= Ac) & (Ac == 0.4)] = 0.03
areal[(PGA >= Ac) & (Ac == 0.35)] = 0.05
areal[(PGA >= Ac) & (Ac == 0.3)] = 0.08
areal[(PGA >= Ac) & (Ac == 0.25)] = 0.1
areal[(PGA >= Ac) & (Ac == 0.2)] = 0.15
areal[(PGA >= Ac) & (Ac == 0.15)] = 0.2
areal[(PGA >= Ac) & (Ac == 0.1)] = 0.25
areal[(PGA >= Ac) & (Ac == 0.05)] = 0.3
# # But this way is even slower, takes 2x as long
# numrows, numcols = np.shape(areal)
# for j in np.arange(numrows):
# for k in np.arange(numcols):
# acval = Ac[j, k]
# if PGA[j, k] >= acval:
# if acval == 0.6:
# areal[j, k] = 0.01
# elif acval == 0.5:
# areal[j, k] = 0.02
# elif acval == 0.4:
# areal[j, k] = 0.03
# elif acval == 0.35:
# areal[j, k] = 0.05
# elif acval == 0.3:
# areal[j, k] = 0.08
# elif acval == 0.25:
# areal[j, k] = 0.1
# elif acval == 0.2:
# areal[j, k] = 0.15
# elif acval == 0.15:
# areal[j, k] = 0.2
# elif acval == 0.1:
# areal[j, k] = 0.25
# elif acval == 0.05:
# areal[j, k] = 0.3
elif modeltype == 'dn_hazus' or modeltype == 'dn_prob':
ed_low, ed_high = est_disp(Ac, PGA)
ed_mean = np.mean((np.dstack((ed_low, ed_high))), axis=2) # Get mean estimated displacements
dn = ed_mean * numcycles(M) * PGA
else: # Calculate newmark displacement using a regression model
if regressionmodel is 'J_PGA':
dn = J_PGA(Ac, PGA)
elif regressionmodel is 'J_PGA_M':
dn = J_PGA_M(Ac, PGA, M)
elif regressionmodel is 'RS_PGA_M':
dn = RS_PGA_M(Ac, PGA, M)
elif regressionmodel is 'RS_PGA_PGV':
dn = RS_PGA_PGV(Ac, PGA, PGV)
else:
print('Unrecognized model, using J_PGA\n')
dn = J_PGA(Ac, PGA)
# Calculate probability from dn, if necessary for selected model
if modeltype == 'ac_classic_prob' or modeltype == 'dn_prob':
if probtype.lower() in 'jibson2000':
PROB = 0.335*(1-np.exp(-0.048*dn**1.565))
dnthresh = None
elif probtype.lower() in 'threshold':
PROB = dn.copy()
PROB[PROB <= dnthresh] = 0
PROB[PROB > dnthresh] = 1
else:
raise NameError('invalid probtype, assuming jibson2000')
PROB = 0.335*(1-np.exp(-0.048*dn**1.565))
dnthresh = None
# Turn output and inputs into into grids and put in maplayers dictionary
maplayers = collections.OrderedDict()
temp = shakemap.getShakeDict()
shakedetail = '%s_ver%s' % (temp['shakemap_id'], temp['shakemap_version'])
if modeltype == 'coverage':
maplayers['model'] = {'grid': GDALGrid(areal, gdict), 'label': 'Areal coverage', 'type': 'output', 'description': {'name': modelsref, 'longref': modellref, 'units': 'coverage', 'shakemap': shakedetail, 'parameters': {'modeltype': modeltype}}}
elif modeltype == 'dn_hazus':
maplayers['model'] = {'grid': GDALGrid(dn, gdict), 'label': 'Dn (cm)', 'type': 'output', 'description': {'name': modelsref, 'longref': modellref, 'units': 'displacement', 'shakemap': shakedetail, 'parameters': {'regressionmodel': regressionmodel, 'modeltype': modeltype}}}
elif modeltype == 'ac_classic_dn':
maplayers['model'] = {'grid': GDALGrid(dn, gdict), 'label': 'Dn (cm)', 'type': 'output', 'description': {'name': modelsref, 'longref': modellref, 'units': 'displacement', 'shakemap': shakedetail, 'parameters': {'regressionmodel': regressionmodel, 'modeltype': modeltype}}}
elif modeltype == 'dn_prob':
maplayers['model'] = {'grid': GDALGrid(PROB, gdict), 'label': 'Landslide Probability', 'type': 'output', 'description': {'name': modelsref, 'longref': modellref, 'units': 'probability', 'shakemap': shakedetail, 'parameters': {'regressionmodel': regressionmodel, 'dnthresh_cm': dnthresh, 'modeltype': modeltype, 'probtype': probtype}}}
elif modeltype == 'ac_classic_prob':
maplayers['model'] = {'grid': GDALGrid(PROB, gdict), 'label': 'Landslide Probability', 'type': 'output', 'description': {'name': modelsref, 'longref': modellref, 'units': 'probability', 'shakemap': shakedetail, 'parameters': {'regressionmodel': regressionmodel, 'dnthresh_cm': dnthresh, 'modeltype': modeltype, 'probtype': probtype}}}
if saveinputs is True:
maplayers['suscat'] = {'grid': sus, 'label': 'Susceptibility Category', 'type': 'input', 'description': {'name': sussref, 'longref': suslref, 'units': 'Category'}}
maplayers['Ac'] = {'grid': GDALGrid(Ac, gdict), 'label': 'Ac (g)', 'type': 'output', 'description': {'units': 'g', 'shakemap': shakedetail}}
maplayers['pga'] = {'grid': GDALGrid(PGA, gdict), 'label': 'PGA (g)', 'type': 'input', 'description': {'units': 'g', 'shakemap': shakedetail}}
if 'pgv' in regressionmodel.lower():
maplayers['pgv'] = {'grid': GDALGrid(PGV, gdict), 'label': 'PGV (cm/s)', 'type': 'input', 'description': {'units': 'cm/s', 'shakemap': shakedetail}}
if 'dn' not in modeltype.lower() and modeltype != 'coverage':
maplayers['dn'] = {'grid': GDALGrid(dn, gdict), 'label': 'Dn (cm)', 'type': 'output', 'description': {'units': 'displacement', 'shakemap': shakedetail, 'parameters': {'regressionmodel': regressionmodel, 'modeltype': modeltype}}}
return maplayers
def classic(shakefile, config, uncertfile=None, saveinputs=False, regressionmodel='J_PGA', probtype='jibson2000', slopediv=1., codiv=1., bounds=None):
"""This function uses the Newmark method to estimate probability of failure at each grid cell.
Factor of Safety and critcal accelerations are calculated following Jibson et al. (2000) and the
Newmark displacement is estimated using PGA, PGV, and/or Magnitude (depending on equation used)
from Shakemap with regression equations from Jibson (2007), Rathje and Saygili (2008) and
Saygili and Rathje (2009)
:param shakefile: URL or complete file path to the location of the Shakemap to use as input
:type shakefile: string:
:param config: Model configuration file object containing locations of input files and other input values config = ConfigObj(configfilepath)
:type config: ConfigObj
:param uncertfile: complete file path to the location of the uncertainty.xml for the shakefile, if this is not None, it will compute the model for +-std in addition to the best estimate
:param saveinputs: Whether or not to return the model input layers, False (defeault) returns only the model output (one layer)
:type saveinputs: boolean
:param regressionmodel:
Newmark displacement regression model to use
'J_PGA' (default) - PGA-based model from Jibson (2007) - equation 6
'J_PGA_M' - PGA and M-based model from Jibson (2007) - equation 7
'RS_PGA_M' - PGA and M-based model from from Rathje and Saygili (2009)
'RS_PGA_PGV' - PGA and PGV-based model from Saygili and Rathje (2008) - equation 6
:type regressionmodel: string
:param probtype: Method used to estimate probability. Entering 'jibson2000' uses equation 5 from Jibson et al. (2000) to estimate probability from Newmark displacement. 'threshold' uses a specified threshold of Newmark displacement (defined in config file) and assumes anything greather than this threshold fails
:type probtype: string
:param slopediv: Divide slope by this number to get slope in degrees (Verdin datasets need to be divided by 100)
:type slopediv: float
:param codiv: Divide cohesion by this number to get reasonable numbers (For Godt method, need to divide by 10 because that is how it was calibrated, but values are reasonable without multiplying for regular analysis)
:type codiv: float
:returns maplayers: Dictionary containing output and input layers (if saveinputs=True) along with metadata formatted like maplayers['layer name']={'grid': mapio grid2D object, 'label': 'label for colorbar and top line of subtitle', 'type': 'output or input to model', 'description': 'detailed description of layer for subtitle, potentially including source information'}
:type maplayers: OrderedDict
:raises NameError: when unable to parse the config correctly (probably a formatting issue in the configfile) or when unable to find the shakefile (Shakemap URL or filepath) - these cause program to end
:raises NameError: when probtype does not match a predifined probability type, will cause to default to 'jibson2000'
"""
# Empty refs
slopesref = 'unknown'
slopelref = 'unknown'
cohesionlref = 'unknown'
cohesionsref = 'unknown'
frictionsref = 'unknown'
frictionlref = 'unknown'
modellref = 'unknown'
modelsref = 'unknown'
# Parse config - should make it so it uses defaults if any are missing...
try:
slopefile = config['mechanistic_models']['classic_newmark']['layers']['slope']['file']
slopeunits = config['mechanistic_models']['classic_newmark']['layers']['slope']['units']
cohesionfile = config['mechanistic_models']['classic_newmark']['layers']['cohesion']['file']
cohesionunits = config['mechanistic_models']['classic_newmark']['layers']['cohesion']['units']
frictionfile = config['mechanistic_models']['classic_newmark']['layers']['friction']['file']
frictionunits = config['mechanistic_models']['classic_newmark']['layers']['friction']['units']
thick = float(config['mechanistic_models']['classic_newmark']['parameters']['thick'])
uwt = float(config['mechanistic_models']['classic_newmark']['parameters']['uwt'])
nodata_cohesion = float(config['mechanistic_models']['classic_newmark']['parameters']['nodata_cohesion'])
nodata_friction = float(config['mechanistic_models']['classic_newmark']['parameters']['nodata_friction'])
try:
dnthresh = float(config['mechanistic_models']['classic_newmark']['parameters']['dnthresh'])
except:
if probtype == 'threshold':
dnthresh = 5.
print('Unable to find dnthresh in config, using 5cm')
else:
dnthresh = None
fsthresh = float(config['mechanistic_models']['classic_newmark']['parameters']['fsthresh'])
acthresh = float(config['mechanistic_models']['classic_newmark']['parameters']['acthresh'])
slopethresh = float(config['mechanistic_models']['classic_newmark']['parameters']['slopethresh'])
try:
m = float(config['mechanistic_models']['classic_newmark']['parameters']['m'])
except:
print('no constant saturated thickness specified, m=0 if no watertable file is found')
m = 0.
except Exception as e:
raise NameError('Could not parse configfile, %s' % e)
return
try: # Try to fetch source information from config
modelsref = config['mechanistic_models']['classic_newmark']['shortref']
modellref = config['mechanistic_models']['classic_newmark']['longref']
slopesref = config['mechanistic_models']['classic_newmark']['layers']['slope']['shortref']
slopelref = config['mechanistic_models']['classic_newmark']['layers']['slope']['longref']
cohesionsref = config['mechanistic_models']['classic_newmark']['layers']['cohesion']['shortref']
cohesionlref = config['mechanistic_models']['classic_newmark']['layers']['cohesion']['longref']
frictionsref = config['mechanistic_models']['classic_newmark']['layers']['friction']['shortref']
frictionlref = config['mechanistic_models']['classic_newmark']['layers']['friction']['longref']
except:
print('Was not able to retrieve all references from config file. Continuing')
# Cut and resample all files
shkgdict = ShakeGrid.getFileGeoDict(shakefile, adjust='res')
slpdict = GDALGrid.getFileGeoDict(slopefile)
if bounds is not None: # Make sure bounds are within ShakeMap Grid
if shkgdict.xmin > bounds['xmin'] or shkgdict.xmax < bounds['xmax'] or shkgdict.ymin > bounds['ymin'] or shkgdict.ymax < bounds['ymax']:
print('Specified bounds are outside shakemap area, using ShakeMap bounds instead')
bounds = None
if bounds is not None:
tempgdict = GeoDict({'xmin': bounds['xmin'], 'ymin': bounds['ymin'], 'xmax': bounds['xmax'], 'ymax': bounds['ymax'], 'dx': 100., 'dy': 100., 'nx': 100., 'ny': 100.}, adjust='res')
gdict = slpdict.getBoundsWithin(tempgdict)
else: # Get boundaries from shakemap if not specified
shkgdict = ShakeGrid.getFileGeoDict(shakefile, adjust='res')
slpdict = GDALGrid.getFileGeoDict(slopefile)
gdict = slpdict.getBoundsWithin(shkgdict)
# Load in slope file
slopegrid = GDALGrid.load(slopefile, samplegeodict=gdict, resample=False)
gdict = slopegrid.getGeoDict() # Get this again just in case it changed
slope = slopegrid.getData().astype(float)/slopediv # Adjust slope to degrees, if needed
# Change any zero slopes to a very small number to avoid dividing by zero later
slope[slope == 0] = 1e-8
# Load in shakefile
if not os.path.isfile(shakefile):
if isURL(shakefile):
shakefile = getGridURL(shakefile) # returns a file object
else:
raise NameError('Could not find "%s" as a file or a valid url' % (shakefile))
return
# Load in shakemap, resample to slope file (this will be important when go to higher res)
shakemap = ShakeGrid.load(shakefile, samplegeodict=gdict, resample=True, method='linear', adjust='res')
M = shakemap.getEventDict()['magnitude']
# Read in uncertainty layer, if present
if uncertfile is not None:
try:
uncert = ShakeGrid.load(uncertfile, samplegeodict=gdict, resample=True, method='linear', adjust='res')
except:
print('Could not read uncertainty file, ignoring uncertainties')
uncertfile = None
# Read in the cohesion and friction files, resampled to slope grid
cohesion = GDALGrid.load(cohesionfile, samplegeodict=gdict, resample=True, method='nearest').getData().astype(float)/codiv
cohesion[np.isnan(cohesion)] = nodata_cohesion
friction = GDALGrid.load(frictionfile, samplegeodict=gdict, resample=True, method='nearest').getData().astype(float)
friction[np.isnan(friction)] = nodata_friction
# See if there is a water table depth file and read it in if there is
try:
waterfile = config['mechanistic_models']['classic_newmark']['layers']['watertable']['file']
watertable = GDALGrid.load(waterfile, samplegeodict=gdict, resample=True, method='linear').getData() # Needs to be in meters!
uwtw = float(config['mechanistic_models']['classic_newmark']['parameters']['uwtw'])
try:
watersref = config['mechanistic_models']['classic_newmark']['layers']['watertable']['shortref']
waterlref = config['mechanistic_models']['classic_newmark']['layers']['watertable']['longref']
except:
print('Was not able to retrieve water table references from config file. Continuing')
except:
print(('Water table file not specified or readable, assuming constant saturated thickness proportion of %0.1f' % m))
watertable = None
try:
uwtw = float(config['mechanistic_models']['classic_newmark']['parameters']['uwtw'])
except:
print('Could not read soil wet unit weight, using 18.8 kN/m3')
uwtw = 18.8
# Factor of safety
if watertable is not None:
watertable[watertable > thick] = thick
m = (thick - watertable)/thick
FS = cohesion/(uwt*thick*np.sin(slope*(np.pi/180.))) + np.tan(friction*(np.pi/180.))/np.tan(slope*(np.pi/180.)) - (m*uwtw*np.tan(friction*(np.pi/180.)))/(uwt*np.tan(slope*(np.pi/180.)))
FS[FS < fsthresh] = fsthresh
# Compute critical acceleration, in g
Ac = (FS-1.)*np.sin(slope*(np.pi/180.)) # This gives ac in g, equations that multiply by g give ac in m/s2
Ac[Ac < acthresh] = acthresh
Ac[slope < slopethresh] = float('nan')
# Get PGA in g (PGA is %g in ShakeMap, convert to g)
PGA = shakemap.getLayer('pga').getData().astype(float)/100.
PGV = shakemap.getLayer('pgv').getData().astype(float)
if uncertfile is not None:
stdpga = uncert.getLayer('stdpga')
stdpgv = uncert.getLayer('stdpgv')
# Estimate PGA +- 1std
PGAmin = np.exp(np.log(PGA*100.) - stdpga.getData())/100.
PGAmax = np.exp(np.log(PGA*100.) + stdpga.getData())/100.
PGVmin = np.exp(np.log(PGV) - stdpgv.getData())
PGVmax = np.exp(np.log(PGV) + stdpgv.getData())
np.seterr(invalid='ignore') # Ignore errors so still runs when Ac > PGA, just leaves nan instead of crashing
if regressionmodel is 'J_PGA':
Dn = J_PGA(Ac, PGA)
if uncertfile is not None:
Dnmin = J_PGA(Ac, PGAmin)
Dnmax = J_PGA(Ac, PGAmax)
elif regressionmodel is 'J_PGA_M':
Dn = J_PGA_M(Ac, PGA, M)
if uncertfile is not None:
Dnmin = J_PGA_M(Ac, PGAmin, M)
Dnmax = J_PGA_M(Ac, PGAmax, M)
elif regressionmodel is 'RS_PGA_M':
Dn = RS_PGA_M(Ac, PGA, M)
if uncertfile is not None:
Dnmin = RS_PGA_M(Ac, PGAmin, M)
Dnmax = RS_PGA_M(Ac, PGAmax, M)
elif regressionmodel is 'RS_PGA_PGV':
Dn = RS_PGA_PGV(Ac, PGA, PGV)
if uncertfile is not None:
Dnmin = RS_PGA_PGV(Ac, PGAmin, PGVmin)
Dnmax = RS_PGA_PGV(Ac, PGAmax, PGVmax)
else:
print('Unrecognized regression model, aborting')
return
units = 'probability'
label = 'Landslide Probability'
if probtype.lower() in 'jibson2000':
PROB = 0.335*(1-np.exp(-0.048*Dn**1.565))
dnthresh = None
if uncertfile is not None:
PROBmin = 0.335*(1-np.exp(-0.048*Dnmin**1.565))
PROBmax = 0.335*(1-np.exp(-0.048*Dnmax**1.565))
elif probtype.lower() in 'threshold':
PROB = Dn.copy()
PROB[PROB <= dnthresh] = 0
PROB[PROB > dnthresh] = 1
units = 'prediction'
label = 'Predicted Landslides'
if uncertfile is not None:
PROBmin = Dnmin.copy()
PROBmin[PROBmin <= dnthresh] = 0
PROBmin[PROBmin > dnthresh] = 1
PROBmax = Dnmax.copy()
PROBmax[PROBmax <= dnthresh] = 0
PROBmax[PROBmax > dnthresh] = 1
else:
raise NameError('invalid probtype, assuming jibson2000')
PROB = 0.335*(1-np.exp(-0.048*Dn**1.565))
dnthresh = None
if uncertfile is not None:
PROBmin = 0.335*(1-np.exp(-0.048*Dnmin**1.565))
PROBmax = 0.335*(1-np.exp(-0.048*Dnmax**1.565))
# Turn output and inputs into into grids and put in mapLayers dictionary
maplayers = collections.OrderedDict()
temp = shakemap.getShakeDict()
shakedetail = '%s_ver%s' % (temp['shakemap_id'], temp['shakemap_version'])
if watertable is not None:
des = 'variable'
else:
des = m
description = {'name': modelsref, 'longref': modellref, 'units': units, 'shakemap': shakedetail, 'parameters': {'regressionmodel': regressionmodel, 'thickness_m': thick, 'unitwt_kNm3': uwt, 'dnthresh_cm': dnthresh, 'acthresh_g': acthresh, 'fsthresh': fsthresh, 'slopethresh': slopethresh, 'sat_proportion': des}}
maplayers['model'] = {'grid': GDALGrid(PROB, gdict), 'label': label, 'type': 'output', 'description': description}
if uncertfile is not None:
maplayers['modelmin'] = {'grid': GDALGrid(PROBmin, gdict), 'label': label+' -1std', 'type': 'output', 'description': description}
maplayers['modelmax'] = {'grid': GDALGrid(PROBmax, gdict), 'label': label+' +1std', 'type': 'output', 'description': description}
if saveinputs is True:
maplayers['pga'] = {'grid': GDALGrid(PGA, gdict), 'label': 'PGA (g)', 'type': 'input', 'description': {'units': 'g', 'shakemap': shakedetail}}
maplayers['FS'] = {'grid': GDALGrid(FS, gdict), 'label': 'Factor of Safety', 'type': 'input', 'description': {'units': 'unitless'}}
maplayers['Ac'] = {'grid': GDALGrid(Ac, gdict), 'label': 'Critical acceleration (g)', 'type': 'input'}
maplayers['Dn'] = {'grid': GDALGrid(Dn, gdict), 'label': 'Newmark Displacement (cm)', 'type': 'input'}
maplayers['slope'] = {'grid': GDALGrid(slope, gdict), 'label': 'Max slope ($^\circ$)', 'type': 'input', 'description': {'units': 'degrees', 'name': slopesref, 'longref': slopelref}}
maplayers['cohesion'] = {'grid': GDALGrid(cohesion, gdict), 'label': 'Cohesion (kPa)', 'type': 'input', 'description': {'units': 'kPa (adjusted)', 'name': cohesionsref, 'longref': cohesionlref}}
maplayers['friction angle'] = {'grid': GDALGrid(friction, gdict), 'label': 'Friction angle ($^\circ$)', 'type': 'input', 'description': {'units': 'degrees', 'name': frictionsref, 'longref': frictionlref}}
if uncertfile is not None:
maplayers['pgamin'] = {'grid': GDALGrid(PGAmin, gdict), 'label': 'PGA - 1std (g)', 'type': 'input', 'description': {'units': 'g', 'shakemap': shakedetail}}
maplayers['pgamax'] = {'grid': GDALGrid(PGAmax, gdict), 'label': 'PGA + 1std (g)', 'type': 'input', 'description': {'units': 'g', 'shakemap': shakedetail}}
if 'PGV' in regressionmodel:
maplayers['pgv'] = {'grid': GDALGrid(PGV, gdict), 'label': 'PGV (cm/s)', 'type': 'input', 'description': {'units': 'cm/s', 'shakemap': shakedetail}}
if uncertfile is not None:
maplayers['pgvmin'] = {'grid': GDALGrid(PGVmin, gdict), 'label': 'PGV - 1std (cm/s)', 'type': 'input', 'description': {'units': 'cm/s', 'shakemap': shakedetail}}
maplayers['pgvmax'] = {'grid': GDALGrid(PGVmax, gdict), 'label': 'PGV + 1std (cm/s)', 'type': 'input', 'description': {'units': 'cm/s', 'shakemap': shakedetail}}
if watertable is not None:
maplayers['sat thick prop'] = {'grid': GDALGrid(m, gdict), 'label': 'Saturated thickness proprtion [0,1]', 'type': 'input', 'description': {'units': 'meters', 'name': watersref, 'longref': waterlref}}
return maplayers
def __init__(self, config, shakefile, model, uncertfile=None):
"""Set up the logistic model
:param config: configobj (config .ini file read in using configobj) defining the model and its inputs
:type config: dictionary
:param shakefile: Full file path to shakemap.xml file for the event of interest
:type shakefile: string
:param model: Name of model defined in config that should be run for the event of interest
:type model: string
:param uncertfile:
:type uncertfile:
"""
if model not in getLogisticModelNames(config):
raise Exception('Could not find a model called "%s" in config %s.' % (model, config))
#do everything here short of calculations - parse config, assemble eqn strings, load data.
self.model = model
cmodel = config['logistic_models'][model]
self.modeltype = cmodel['gfetype']
self.coeffs = validateCoefficients(cmodel)
self.layers = validateLayers(cmodel) # key = layer name, value = file name
self.terms, timeField = validateTerms(cmodel, self.coeffs, self.layers)
self.interpolations = validateInterpolations(cmodel, self.layers)
self.units = validateUnits(cmodel, self.layers)
self.gmused = [value for term, value in cmodel['terms'].items() if 'pga' in value.lower() or 'pgv' in
value.lower() or 'mmi' in value.lower()]
self.modelrefs, self.longrefs, self.shortrefs = validateRefs(cmodel)
if 'baselayer' not in cmodel:
raise Exception('You must specify a base layer file in config.')
if cmodel['baselayer'] not in list(self.layers.keys()):
raise Exception('You must specify a base layer corresponding to one of the files in the layer section.')
#get the geodict for the shakemap
geodict = ShakeGrid.getFileGeoDict(shakefile, adjust='res')
griddict, eventdict, specdict, fields, uncertainties = getHeaderData(shakefile)
#YEAR = eventdict['event_timestamp'].year
MONTH = MONTHS[(eventdict['event_timestamp'].month)-1]
#DAY = eventdict['event_timestamp'].day
#HOUR = eventdict['event_timestamp'].hour
#now find the layer that is our base layer and get the largest bounds we can guarantee not to exceed shakemap bounds
basefile = self.layers[cmodel['baselayer']]
ftype = getFileType(basefile)
if ftype == 'esri':
basegeodict, firstcol = GDALGrid.getFileGeoDict(basefile)
sampledict = basegeodict.getBoundsWithin(geodict)
elif ftype == 'gmt':
basegeodict, firstcol = GMTGrid.getFileGeoDict(basefile)
sampledict = basegeodict.getBoundsWithin(geodict)
else:
raise Exception('All predictor variable grids must be a valid GMT or ESRI file type')
#now load the shakemap, resampling and padding if necessary
self.shakemap = ShakeGrid.load(shakefile, samplegeodict=sampledict, resample=True, doPadding=True, adjust='res')
# take uncertainties into account
if uncertfile is not None:
try:
self.uncert = ShakeGrid.load(uncertfile, samplegeodict=sampledict, resample=True, doPadding=True,
adjust='res')
except:
print('Could not read uncertainty file, ignoring uncertainties')
self.uncert = None
else:
self.uncert = None
#load the predictor layers into a dictionary
self.layerdict = {} # key = layer name, value = grid object
for layername, layerfile in self.layers.items():
if isinstance(layerfile, list):
for lfile in layerfile:
if timeField == 'MONTH':
if lfile.find(MONTH) > -1:
layerfile = lfile
ftype = getFileType(layerfile)
interp = self.interpolations[layername]
if ftype == 'gmt':
lyr = GMTGrid.load(layerfile, sampledict, resample=True, method=interp, doPadding=True)
elif ftype == 'esri':
lyr = GDALGrid.load(layerfile, sampledict, resample=True, method=interp, doPadding=True)
else:
msg = 'Layer %s (file %s) does not appear to be a valid GMT or ESRI file.' % (layername, layerfile)
raise Exception(msg)
self.layerdict[layername] = lyr
else:
#first, figure out what kind of file we have (or is it a directory?)
ftype = getFileType(layerfile)
interp = self.interpolations[layername]
if ftype == 'gmt':
lyr = GMTGrid.load(layerfile, sampledict, resample=True, method=interp, doPadding=True)
elif ftype == 'esri':
lyr = GDALGrid.load(layerfile, sampledict, resample=True, method=interp, doPadding=True)
else:
msg = 'Layer %s (file %s) does not appear to be a valid GMT or ESRI file.' % (layername, layerfile)
raise Exception(msg)
self.layerdict[layername] = lyr
shapes = {}
for layername, layer in self.layerdict.items():
shapes[layername] = layer.getData().shape
self.nuggets = [str(self.coeffs['b0'])]
ckeys = list(self.terms.keys())
ckeys.sort()
for key in ckeys:
term = self.terms[key]
coeff = self.coeffs[key]
self.nuggets.append('(%g * %s)' % (coeff, term))
self.equation = ' + '.join(self.nuggets)
if self.uncert is not None:
self.nugmin = copy.copy(self.nuggets)
self.nugmax = copy.copy(self.nuggets)
# Find the term with the shakemap input and replace for these nuggets
for k, nug in enumerate(self.nuggets):
if "self.shakemap.getLayer('pga').getData()" in nug:
self.nugmin[k] = self.nugmin[k].replace("self.shakemap.getLayer('pga').getData()", "(np.exp(np.log(self.shakemap.getLayer('pga').getData()) - self.uncert.getLayer('stdpga').getData()))")
self.nugmax[k] = self.nugmax[k].replace("self.shakemap.getLayer('pga').getData()", "(np.exp(np.log(self.shakemap.getLayer('pga').getData()) + self.uncert.getLayer('stdpga').getData()))")
elif "self.layerdict['pgv'].getData()" in nug:
self.nugmin[k] = self.nugmin[k].replace("self.shakemap.getLayer('pgv').getData()", "(np.exp(np.log(self.shakemap.getLayer('pgv').getData()) - self.uncert.getLayer('stdpgv').getData()))")
self.nugmax[k] = self.nugmax[k].replace("self.shakemap.getLayer('pgv').getData()", "(np.exp(np.log(self.shakemap.getLayer('pgv').getData()) + self.uncert.getLayer('stdpgv').getData()))")
elif "self.layerdict['mmi'].getData()" in nug:
self.nugmin[k] = self.nugmin[k].replace("self.shakemap.getLayer('mmi').getData()", "(np.exp(np.log(self.shakemap.getLayer('mmi').getData()) - self.uncert.getLayer('stdmmi').getData()))")
self.nugmax[k] = self.nugmax[k].replace("self.shakemap.getLayer('mmi').getData()", "(np.exp(np.log(self.shakemap.getLayer('mmi').getData()) + self.uncert.getLayer('stdmmi').getData()))")
self.equationmin = ' + '.join(self.nugmin)
self.equationmax = ' + '.join(self.nugmax)
else:
self.equationmin = None
self.equationmax = None
self.geodict = self.shakemap.getGeoDict()
try:
self.slopemin = float(config['logistic_models'][model]['slopemin'])
self.slopemax = float(config['logistic_models'][model]['slopemax'])
except:
print('could not find slopemin and/or slopemax in config, no limits will be applied')
self.slopemin = 0.
self.slopemax = 90.
def holzer_liq(shakefile,
config,
uncertfile=None,
saveinputs=False,
modeltype=None,
displmodel=None,
probtype=None,
bounds=None):
"""
Method for computing the probability of liquefaction using the Holzer method
using the Wills et al. (2015) Vs30 map of California to define the
susceptibility classes and the Fan et al. global water table model.
"""
layers = config['holzer_liq_cal']['layers']
vs30_file = layers['vs30']['file']
wtd_file = layers['watertable']['file']
shkgdict = ShakeGrid.getFileGeoDict(shakefile)
fgeodict = GMTGrid.getFileGeoDict(vs30_file)[0]
#---------------------------------------------------------------------------
# Loading info
#---------------------------------------------------------------------------
shakemap = ShakeGrid.load(shakefile,
fgeodict,
resample=True,
method='linear',
doPadding=True)
PGA = shakemap.getLayer('pga').getData() / 100 # convert to g
griddict, eventdict, specdict, fields, uncertainties = getHeaderData(
shakefile)
mag = eventdict['magnitude']
#---------------------------------------------------------------------------
# Logistic funciton parameters from Vs30
#---------------------------------------------------------------------------
vs30_grid = GMTGrid.load(vs30_file)
vs30 = vs30_grid.getData()
a0 = np.zeros_like(vs30)
b0 = np.zeros_like(vs30)
c0 = np.zeros_like(vs30)
a1 = np.zeros_like(vs30)
b1 = np.zeros_like(vs30)
c1 = np.zeros_like(vs30)
for k, v in config['holzer_liq_cal']['parameters'].items():
ind = np.where(vs30 == float(v[0]))
a0[ind] = v[1]
b0[ind] = v[2]
c0[ind] = v[3]
a1[ind] = v[4]
b1[ind] = v[5]
c1[ind] = v[6]
#---------------------------------------------------------------------------
# Water table
#---------------------------------------------------------------------------
wtd_grid = GMTGrid.load(wtd_file,
fgeodict,
resample=True,
method=layers['watertable']['interpolation'],
doPadding=True)
tmp = wtd_grid._data
tmp = np.nan_to_num(tmp)
# Compute water weights
w0, w1 = get_water_weights(tmp)
#---------------------------------------------------------------------------
# Compute probability of liquefaction
#---------------------------------------------------------------------------
prob0 = get_prob(PGA, a0, b0, c0, mag)
prob1 = get_prob(PGA, a1, b1, c1, mag)
prob = prob0 * w0 + prob1 * w1
#---------------------------------------------------------------------------
# Turn output and inputs into into grids and put in maplayers dictionary
#---------------------------------------------------------------------------
maplayers = collections.OrderedDict()
temp = shakemap.getShakeDict()
shakedetail = '%s_ver%s' % (temp['shakemap_id'], temp['shakemap_version'])
modelsref = config['holzer_liq_cal']['shortref']
modellref = config['holzer_liq_cal']['longref']
modeltype = 'Holzer/Wills'
maplayers['model'] = {
'grid': GDALGrid(prob, fgeodict),
'label': 'Probability',
'type': 'output',
'description': {
'name': modelsref,
'longref': modellref,
'units': 'coverage',
'shakemap': shakedetail,
'parameters': {
'modeltype': modeltype
}
}
}
if saveinputs is True:
maplayers['pga'] = {
'grid': GDALGrid(PGA, fgeodict),
'label': 'PGA (g)',
'type': 'input',
'description': {
'units': 'g',
'shakemap': shakedetail
}
}
maplayers['vs30'] = {
'grid': GDALGrid(vs30, fgeodict),
'label': 'Vs30 (m/s)',
'type': 'input',
'description': {
'units': 'm/s'
}
}
maplayers['wtd'] = {
'grid': GDALGrid(wtd_grid._data, fgeodict),
'label': 'wtd (m)',
'type': 'input',
'description': {
'units': 'm'
}
}
return maplayers
def check_input_extents(config, shakefile=None, bounds=None):
"""Make sure all input files exist and cover the extent desired
Args:
config: configObj of a single model
shakefile: path to ShakeMap grid.xml file (used for bounds). If not
provided, bounds must be provided
bounds: dictionary of bounds with keys: 'xmin', 'xmax', 'ymin', 'ymax'
Returns:
tuple containing:
notcovered: list of files that do not cover the entire area
defined by bounds or shakefile
newbounds: new dictionary of bounds of subarea of original
bounds or shakefile extent that is covered by all input files
"""
if shakefile is None and bounds is None:
raise Exception('Must define either a shakemap file or bounds')
modelname = config.keys()[0]
# Make dummy geodict to use
if bounds is None:
evdict = ShakeGrid.getFileGeoDict(shakefile)
else:
evdict = GeoDict.createDictFromBox(
bounds['xmin'], bounds['xmax'],
bounds['ymin'], bounds['ymax'],
0.00001, 0.00001, inside=False)
# Check extents of all input layers
notcovered = []
notcovgdicts = []
newbounds = None
for item, value in config[modelname]['layers'].items():
if 'file' in value.keys():
filelook = value['file']
if getFileType(filelook) == 'gmt':
tmpgd, _ = GMTGrid.getFileGeoDict(filelook)
else:
tmpgd, _ = GDALGrid.getFileGeoDict(filelook)
# See if tempgd contains evdict
contains = tmpgd.contains(evdict)
if not contains:
notcovered.append(filelook)
notcovgdicts.append(tmpgd)
# print(filelook)
if len(notcovered) > 0:
# Figure out what bounds COULD be run
xmins = [gd.xmin for gd in notcovgdicts]
xmaxs = [gd.xmax for gd in notcovgdicts]
ymins = [gd.ymin for gd in notcovgdicts]
ymaxs = [gd.ymax for gd in notcovgdicts]
# Set in by a buffer of 0.05 degrees because mapio doesn't like
# when bounds are exactly the same for getboundswithin
newbounds = dict(xmin=evdict.xmin + 0.05,
xmax=evdict.xmax - 0.05,
ymin=evdict.ymin + 0.05,
ymax=evdict.ymax - 0.05)
# Which one is the problem?
if evdict.xmin < np.max(xmins):
newbounds['xmin'] = np.max(xmins) + 0.05
if evdict.xmax > np.min(xmaxs):
newbounds['xmax'] = np.min(xmaxs) - 0.05
if evdict.ymin < np.max(ymins):
newbounds['ymin'] = np.max(ymins) + 0.05
if evdict.ymax > np.min(ymaxs):
newbounds['ymax'] = np.min(ymaxs) - 0.05
# See if this is a possible extent
try:
test = GeoDict.createDictFromBox(
newbounds['xmin'], newbounds['xmax'],
newbounds['ymin'], newbounds['ymax'],
0.00001, 0.00001, inside=False)
except BaseException:
print('Cannot make new bounds that will work')
newbounds = None
return notcovered, newbounds
def test_save():
tdir = tempfile.mkdtemp()
testfile = os.path.join(tdir,'test.xml')
try:
print('Testing save/read functionality for shakemap grids...')
pga = np.arange(0,16,dtype=np.float32).reshape(4,4)
pgv = np.arange(1,17,dtype=np.float32).reshape(4,4)
mmi = np.arange(2,18,dtype=np.float32).reshape(4,4)
geodict = GeoDict({'xmin':0.5,'xmax':3.5,
'ymin':0.5,'ymax':3.5,
'dx':1.0,'dy':1.0,
'ny':4,'nx':4})
layers = OrderedDict()
layers['pga'] = pga
layers['pgv'] = pgv
layers['mmi'] = mmi
shakeDict = {'event_id':'usabcd1234',
'shakemap_id':'usabcd1234',
'shakemap_version':1,
'code_version':'4.0',
'process_timestamp':datetime.utcnow(),
'shakemap_originator':'us',
'map_status':'RELEASED',
'shakemap_event_type':'ACTUAL'}
eventDict = {'event_id':'usabcd1234',
'magnitude':7.6,
'depth':1.4,
'lat':2.0,
'lon':2.0,
'event_timestamp':datetime.utcnow(),
'event_network':'us',
'event_description':'sample event'}
uncDict = {'pga':(0.0,0),
'pgv':(0.0,0),
'mmi':(0.0,0)}
shake = ShakeGrid(layers,geodict,eventDict,shakeDict,uncDict)
print('Testing save/read functionality...')
shake.save(testfile,version=3)
shake2 = ShakeGrid.load(testfile)
for layer in ['pga','pgv','mmi']:
tdata = shake2.getLayer(layer).getData()
np.testing.assert_almost_equal(tdata,layers[layer])
print('Passed save/read functionality for shakemap grids.')
print('Testing getFileGeoDict method...')
fgeodict = ShakeGrid.getFileGeoDict(testfile)
print('Passed save/read functionality for shakemap grids.')
print('Testing loading with bounds (no resampling or padding)...')
sampledict = GeoDict({'xmin':-0.5,'xmax':3.5,
'ymin':-0.5,'ymax':3.5,
'dx':1.0,'dy':1.0,
'ny':5,'nx':5})
shake3 = ShakeGrid.load(testfile,samplegeodict=sampledict,
resample=False,doPadding=False,padValue=np.nan)
tdata = shake3.getLayer('pga').getData()
np.testing.assert_almost_equal(tdata,layers['pga'])
print('Passed loading with bounds (no resampling or padding)...')
print('Testing loading shakemap with padding, no resampling...')
newdict = GeoDict({'xmin':-0.5,'xmax':4.5,
'ymin':-0.5,'ymax':4.5,
'dx':1.0,'dy':1.0,
'ny':6,'nx':6})
shake4 = ShakeGrid.load(testfile,samplegeodict=newdict,
resample=False,doPadding=True,padValue=np.nan)
output = np.array([[np.nan,np.nan,np.nan,np.nan,np.nan,np.nan],
[np.nan,0.0,1.0,2.0,3.0,np.nan],
[np.nan,4.0,5.0,6.0,7.0,np.nan],
[np.nan,8.0,9.0,10.0,11.0,np.nan],
[np.nan,12.0,13.0,14.0,15.0,np.nan],
[np.nan,np.nan,np.nan,np.nan,np.nan,np.nan]])
tdata = shake4.getLayer('pga').getData()
np.testing.assert_almost_equal(tdata,output)
print('Passed loading shakemap with padding, no resampling...')
#make a bigger grid
pga = np.arange(0,36,dtype=np.float32).reshape(6,6)
pgv = np.arange(1,37,dtype=np.float32).reshape(6,6)
mmi = np.arange(2,38,dtype=np.float32).reshape(6,6)
layers = OrderedDict()
layers['pga'] = pga
layers['pgv'] = pgv
layers['mmi'] = mmi
geodict = GeoDict({'xmin':0.5,'xmax':5.5,
'ymin':0.5,'ymax':5.5,
'dx':1.0,'dy':1.0,
'ny':6,'nx':6})
shake = ShakeGrid(layers,geodict,eventDict,shakeDict,uncDict)
shake.save(testfile,version=3)
print('Testing resampling, no padding...')
littledict = GeoDict({'xmin':2.0,'xmax':4.0,
'ymin':2.0,'ymax':4.0,
'dx':1.0,'dy':1.0,
'ny':3,'nx':3})
shake5 = ShakeGrid.load(testfile,samplegeodict=littledict,resample=True,doPadding=False,padValue=np.nan)
output = np.array([[10.5,11.5,12.5],
[16.5,17.5,18.5],
[22.5,23.5,24.5]])
tdata = shake5.getLayer('pga').getData()
np.testing.assert_almost_equal(tdata,output)
print('Passed resampling, no padding...')
print('Testing resampling and padding...')
pga = np.arange(0,16,dtype=np.float32).reshape(4,4)
pgv = np.arange(1,17,dtype=np.float32).reshape(4,4)
mmi = np.arange(2,18,dtype=np.float32).reshape(4,4)
geodict = GeoDict({'xmin':0.5,'ymax':3.5,
'ymin':0.5,'xmax':3.5,
'dx':1.0,'dy':1.0,
'ny':4,'nx':4})
layers = OrderedDict()
layers['pga'] = pga
layers['pgv'] = pgv
layers['mmi'] = mmi
shake = ShakeGrid(layers,geodict,eventDict,shakeDict,uncDict)
shake.save(testfile,version=3)
bigdict = GeoDict({'xmin':0.0,'xmax':4.0,
'ymin':0.0,'ymax':4.0,
'dx':1.0,'dy':1.0,
'ny':5,'nx':5})
shake6 = ShakeGrid.load(testfile,samplegeodict=bigdict,resample=True,doPadding=True,padValue=np.nan)
tdata = shake6.getLayer('pga').getData()
output = np.array([[np.nan,np.nan,np.nan,np.nan,np.nan],
[np.nan,2.5,3.5,4.5,np.nan],
[np.nan,6.5,7.5,8.5,np.nan],
[np.nan,10.5,11.5,12.5,np.nan],
[np.nan,np.nan,np.nan,np.nan,np.nan]])
np.testing.assert_almost_equal(tdata,output)
print('Passed resampling and padding...')
except Exception as error:
print('Failed to read grid.xml format file "%s". Error "%s".' % (xmlfile,str(error)))
assert 0 == 1
finally:
if os.path.isdir(tdir):
shutil.rmtree(tdir)
def hazus_liq(shakefile,
config,
uncertfile=None,
saveinputs=False,
modeltype=None,
displmodel=None,
probtype=None,
bounds=None):
"""
Method for computing the probability of liquefaction using the Hazus method
using the Wills et al. (2015) Vs30 map of California to define the
susceptibility classes and the Fan et al. global water table model.
"""
layers = config['hazus_liq_cal']['layers']
vs30_file = layers['vs30']['file']
wtd_file = layers['watertable']['file']
shkgdict = ShakeGrid.getFileGeoDict(shakefile)
fgeodict = GMTGrid.getFileGeoDict(vs30_file)[0]
#---------------------------------------------------------------------------
# Loading
#---------------------------------------------------------------------------
shakemap = ShakeGrid.load(shakefile,
fgeodict,
resample=True,
method='linear',
doPadding=True)
PGA = shakemap.getLayer('pga').getData() / 100 # convert to g
griddict, eventdict, specdict, fields, uncertainties = getHeaderData(
shakefile)
mag = eventdict['magnitude']
# Correction factor for moment magnitudes other than M=7.5
k_m = 0.0027 * mag**3 - 0.0267 * mag**2 - 0.2055 * mag + 2.9188
#---------------------------------------------------------------------------
# Susceptibility from Vs30
#---------------------------------------------------------------------------
vs30_grid = GMTGrid.load(vs30_file)
vs30 = vs30_grid.getData()
p_ml = np.zeros_like(vs30)
a = np.zeros_like(vs30)
b = np.zeros_like(vs30)
for k, v in config['hazus_liq_cal']['parameters'].items():
ind = np.where(vs30 == float(v[0]))
if v[1] == "VH":
p_ml[ind] = 0.25
a[ind] = 9.09
b[ind] = -0.82
if v[1] == "H":
p_ml[ind] = 0.2
a[ind] = 7.67
b[ind] = -0.92
if v[1] == "M":
p_ml[ind] = 0.1
a[ind] = 6.67
b[ind] = -1.0
if v[1] == "L":
p_ml[ind] = 0.05
a[ind] = 5.57
b[ind] = -1.18
if v[1] == "VL":
p_ml[ind] = 0.02
a[ind] = 4.16
b[ind] = -1.08
# Conditional liquefaction probability for a given susceptibility category
# at a specified PGA
p_liq_pga = a * PGA + b
p_liq_pga = p_liq_pga.clip(min=0, max=1)
#---------------------------------------------------------------------------
# Water table
#---------------------------------------------------------------------------
wtd_grid = GMTGrid.load(wtd_file,
fgeodict,
resample=True,
method=layers['watertable']['interpolation'],
doPadding=True)
tmp = wtd_grid._data
tmp = np.nan_to_num(tmp)
# Convert to ft
wt_ft = tmp * 3.28084
# Correction factor for groundwater depths other than five feet
k_w = 0.022 * wt_ft + 0.93
#---------------------------------------------------------------------------
# Combine to get conditional liquefaction probability
#---------------------------------------------------------------------------
p_liq_sc = p_liq_pga * p_ml / k_m / k_w
#---------------------------------------------------------------------------
# Turn output and inputs into into grids and put in maplayers dictionary
#---------------------------------------------------------------------------
maplayers = collections.OrderedDict()
temp = shakemap.getShakeDict()
shakedetail = '%s_ver%s' % (temp['shakemap_id'], temp['shakemap_version'])
modelsref = config['hazus_liq_cal']['shortref']
modellref = config['hazus_liq_cal']['longref']
modeltype = 'Hazus/Wills'
maplayers['model'] = {
'grid': GDALGrid(p_liq_sc, fgeodict),
'label': 'Probability',
'type': 'output',
'description': {
'name': modelsref,
'longref': modellref,
'units': 'coverage',
'shakemap': shakedetail,
'parameters': {
'modeltype': modeltype
}
}
}
if saveinputs is True:
maplayers['pga'] = {
'grid': GDALGrid(PGA, fgeodict),
'label': 'PGA (g)',
'type': 'input',
'description': {
'units': 'g',
'shakemap': shakedetail
}
}
maplayers['vs30'] = {
'grid': GDALGrid(vs30, fgeodict),
'label': 'Vs30 (m/s)',
'type': 'input',
'description': {
'units': 'm/s'
}
}
maplayers['wtd'] = {
'grid': GDALGrid(wtd_grid._data, fgeodict),
'label': 'wtd (m)',
'type': 'input',
'description': {
'units': 'm'
}
}
return maplayers
def kritikos_fuzzygamma(shakefile, config, bounds=None):
"""
Runs kritikos procedure with fuzzy gamma
"""
cmodel = config['statistic_models']['kritikos_2014']
gamma = cmodel['gamma_value']
## Read in layer files and get data
layers = cmodel['layers']
try:
# Slope
slope_file = layers['slope']
# DFF
dff_file = layers['dff']
# DFS
dfs_file = layers['dfs']
# Slope Position
slope_pos_file = layers['slope_pos']
except:
print('Unable to retrieve grid data.')
try:
div = cmodel['divisor']
# Load in divisors
MMI_div = div['MMI']
slope_div = div['slope']
dff_div = div['dff']
dfs_div = div['dfs']
slope_pos_div = div['slope_pos']
except:
print('Unable to retrieve divisors.')
try:
power = cmodel['power']
# Load in powers
MMI_power = power['MMI']
slope_power = power['slope']
dff_power = power['dff']
dfs_power = power['dfs']
slope_pos_power = power['slope_pos']
except:
print('Unable to retrieve powers.')
# Cut and resample all files
try:
shkgdict = ShakeGrid.getFileGeoDict(shakefile, adjust='res')
slopedict = GDALGrid.getFileGeoDict(slope_file)
if bounds is not None: # Make sure bounds are within ShakeMap Grid
if shkgdict.xmin > bounds['xmin'] or shkgdict.xmax < bounds['xmax'] or shkgdict.ymin > bounds['ymin'] or shkgdict.ymax < bounds['ymax']:
print('Specified bounds are outside shakemap area, using ShakeMap bounds instead')
bounds = None
if bounds is not None:
tempgdict = GeoDict({'xmin': bounds['xmin'], 'ymin': bounds['ymin'], 'xmax': bounds['xmax'], 'ymax': bounds['ymax'], 'dx': 100., 'dy': 100., 'nx': 100., 'ny': 100.}, adjust='res')
gdict = slpdict.getBoundsWithin(tempgdict)
else: # Get boundaries from shakemap if not specified
shkgdict = ShakeGrid.getFileGeoDict(shakefile, adjust='res')
slpdict = GDALGrid.getFileGeoDict(slopefile)
gdict = slpdict.getBoundsWithin(shkgdict)
except:
print('Unable to create base geodict.')
# Load in data
try:
# Load in slope data
slopegrid = GDALGrid.load(slopefile, samplegeodict=gdict, resample=False)
slope_data = slopefrid.getData().astype(float)
# Load in MMI
shakemap = ShakeGrid.load(shakefile, samplegeodict=gdict, resample=True, method='linear', adjust='res')
MMI_data = shakemap.getLayer('MMI').getData().astype(float)
# Load in Dff
dffgrid = GDALGrid.load(slopefile, samplegeodict=gdict, resample=False)
dff_data = dffgrid.getData().astype(float)
# Load in DFS
dfsgrid = GDALGrid.load(slopefile, samplegeodict=gdict, resample=False)
dfs_data = dfsgrid.getData().astype(float)
# Load in Slope Position
slope_pos_grid = GDALGrid.load(slopefile, samplegeodict=gdict, resample=False)
slope_pos_data = slop_pos_grid.getData().astype(float)
except:
print('Data could not be retrieved.')
[[[classification]]]
MMI = 5,6,7,8,9
slope = 0-4, 5-9, 10-14, 15-19, 20-24, 25-29, 30-34, 35-39, 40-44, 45-49, 50+ # Reclassify as 1,2,3,etc.
dff = 0-4, 5-9, 10-19, 20-29, 30-39, 40-49, 50+ # Reclassify as 1,2,3,etc.
dfs = 0-0.49, 0.5-0.99, 1.0-1.49, 1.5-1.99, 2.0-2.49, 2.5+ # Reclassify as 1,2,3,etc.
slope_pos = 'Flat', 'Valley', 'Mid-Slope', 'Ridge' # Reclassify as 1,2,3,etc.
