def cartoplot_schools(mapsize, shapefile, data):
# Create a Stamen terrain background instance
stamen_terrain = cimgt.Stamen('terrain-background')
fig = plt.figure(figsize=(mapsize, mapsize))
ax = fig.add_subplot(1, 1, 1, projection=stamen_terrain.crs)
# Set range of map, stipulate zoom level
ax.set_extent([-122.7, -121.5, 37.15, 38.15], crs=ccrs.Geodetic())
ax.add_image(stamen_terrain, 12, zorder=0)
# set up colormap
from matplotlib import cm
import matplotlib.colors
cmap = cm.get_cmap('seismic_r', 100)
norm = matplotlib.colors.Normalize(vmin=min(data['School score']),
vmax=max(data['School score']))
color = cmap(norm(data['School score'].values))
# add colorbar
n_cmap = cm.ScalarMappable(norm=norm, cmap='seismic_r')
n_cmap.set_array([])
cax = fig.add_axes([0.185, 0.15, 0.02, 0.25])
cbar = ax.get_figure().colorbar(n_cmap, cax)
# set colorbar label, properties
cbar.set_label('School score\n(% proficient)',
rotation=0,
labelpad=15,
y=0.55,
ha='left')
cbar.ax.tick_params(labelsize=16)
cax.yaxis.set_ticks_position('left')
text = cax.yaxis.label
font = matplotlib.font_manager.FontProperties(family='Helvetica', size=20)
text.set_font_properties(font)
for tick in cbar.ax.yaxis.get_ticklabels():
tick.set_family('Helvetica')
# add shapefile features
shape_feature = ShapelyFeature(Reader(shapefile).geometries(),
ccrs.epsg(26910),
linewidth=2)
# Add commute data by zip code
for counter, geom in enumerate(shape_feature.geometries()):
if data['Area'][counter] < 50:
if data['Population'][counter] > 500:
ax.add_geometries([geom],
crs=shape_feature.crs,
facecolor=color[counter],
edgecolor='k',
alpha=0.8)
else:
continue
# save figure, show figure
fig = plt.gcf()
plt.savefig('schools_plot.jpg', bbox_inches='tight', dpi=600)
plt.show()
def execute(self):
"""
Raises:
NotADirectoryError: When the event data directory does not exist.
FileNotFoundError: When the the shake_result HDF file does not
exist.
"""
install_path, data_path = get_config_paths()
datadir = os.path.join(data_path, self._eventid, 'current', 'products')
if not os.path.isdir(datadir):
raise NotADirectoryError('%s is not a valid directory.' % datadir)
datafile = os.path.join(datadir, 'shake_result.hdf')
if not os.path.isfile(datafile):
raise FileNotFoundError('%s does not exist.' % datafile)
# Open the ShakeMapOutputContainer and extract the data
container = ShakeMapOutputContainer.load(datafile)
if container.getDataType() != 'grid':
raise NotImplementedError('mapping module can only operate on '
'gridded data, not sets of points')
# get the path to the products.conf file, load the config
config_file = os.path.join(install_path, 'config', 'products.conf')
spec_file = get_configspec('products')
validator = get_custom_validator()
config = ConfigObj(config_file, configspec=spec_file)
results = config.validate(validator)
check_extra_values(config, self.logger)
if not isinstance(results, bool) or not results:
config_error(config, results)
# create contour files
self.logger.debug('Mapping...')
# get the filter size from the products.conf
filter_size = config['products']['contour']['filter_size']
# get the operator setting from config
operator = config['products']['mapping']['operator']
# get all of the pieces needed for the mapping functions
layers = config['products']['mapping']['layers']
if 'topography' in layers and layers['topography'] != '':
topofile = layers['topography']
else:
topofile = None
if 'roads' in layers and layers['roads'] != '':
roadfile = layers['roads']
else:
roadfile = None
if 'faults' in layers and layers['faults'] != '':
faultfile = layers['faults']
else:
faultfile = None
if 'countries' in layers and layers['countries'] != '':
countries_file = layers['countries']
else:
countries_file = None
if 'states_provs' in layers and layers['states_provs'] != '':
states_provs_file = layers['states_provs']
else:
states_provs_file = None
if 'oceans' in layers and layers['oceans'] != '':
oceans_file = layers['oceans']
else:
oceans_file = None
if 'lakes' in layers and layers['lakes'] != '':
lakes_file = layers['lakes']
else:
lakes_file = None
# Get the number of parallel workers
max_workers = config['products']['mapping']['max_workers']
# Reading HDF5 files currently takes a long time, due to poor
# programming in MapIO. To save us some time until that issue is
# resolved, we'll coarsely subset the topo grid once here and pass
# it into both mapping functions
# get the bounds of the map
info = container.getMetadata()
xmin = info['output']['map_information']['min']['longitude']
xmax = info['output']['map_information']['max']['longitude']
ymin = info['output']['map_information']['min']['latitude']
ymax = info['output']['map_information']['max']['latitude']
dy = float(
info['output']['map_information']['grid_spacing']['latitude'])
dx = float(
info['output']['map_information']['grid_spacing']['longitude'])
padx = 5 * dx
pady = 5 * dy
sxmin = float(xmin) - padx
sxmax = float(xmax) + padx
symin = float(ymin) - pady
symax = float(ymax) + pady
sampledict = GeoDict.createDictFromBox(sxmin, sxmax, symin, symax, dx,
dy)
if topofile:
topogrid = read(topofile,
samplegeodict=sampledict,
resample=False,
doPadding=True,
padValue=0.0)
else:
tdata = np.full([sampledict.ny, sampledict.nx], 0.0)
topogrid = Grid2D(data=tdata, geodict=sampledict)
model_config = container.getConfig()
imtlist = container.getIMTs()
textfile = os.path.join(
get_data_path(), 'mapping',
'map_strings.' + config['products']['mapping']['language'])
text_dict = get_text_strings(textfile)
if config['products']['mapping']['fontfamily'] != '':
matplotlib.rcParams['font.family'] = \
config['products']['mapping']['fontfamily']
matplotlib.rcParams['axes.unicode_minus'] = False
allcities = Cities.fromDefault()
states_provs = None
countries = None
oceans = None
lakes = None
faults = None
roads = None
if states_provs_file is not None:
states_provs = ShapelyFeature(
Reader(states_provs_file).geometries(),
ccrs.PlateCarree(),
facecolor='none')
elif 'CALLED_FROM_PYTEST' not in os.environ:
states_provs = cfeature.NaturalEarthFeature(
category='cultural',
name='admin_1_states_provinces_lines',
scale='10m',
facecolor='none')
# The feature constructor doesn't necessarily download the
# data, but we want it to so that multiple threads don't
# try to do it at once when they actually access the data.
# So below we just call the geometries() method to trigger
# the download if necessary.
_ = states_provs.geometries()
if countries_file is not None:
countries = ShapelyFeature(Reader(countries_file).geometries(),
ccrs.PlateCarree(),
facecolor='none')
elif 'CALLED_FROM_PYTEST' not in os.environ:
countries = cfeature.NaturalEarthFeature(category='cultural',
name='admin_0_countries',
scale='10m',
facecolor='none')
_ = countries.geometries()
if oceans_file is not None:
oceans = ShapelyFeature(Reader(oceans_file).geometries(),
ccrs.PlateCarree(),
facecolor=WATERCOLOR)
elif 'CALLED_FROM_PYTEST' not in os.environ:
oceans = cfeature.NaturalEarthFeature(category='physical',
name='ocean',
scale='10m',
facecolor=WATERCOLOR)
_ = oceans.geometries()
if lakes_file is not None:
lakes = ShapelyFeature(Reader(lakes_file).geometries(),
ccrs.PlateCarree(),
facecolor=WATERCOLOR)
elif 'CALLED_FROM_PYTEST' not in os.environ:
lakes = cfeature.NaturalEarthFeature(category='physical',
name='lakes',
scale='10m',
facecolor=WATERCOLOR)
_ = lakes.geometries()
if faultfile is not None:
faults = ShapelyFeature(Reader(faultfile).geometries(),
ccrs.PlateCarree(),
facecolor='none')
if roadfile is not None:
roads = ShapelyFeature(Reader(roadfile).geometries(),
ccrs.PlateCarree(),
facecolor='none')
alist = []
llogo = config['products']['mapping'].get('license_logo') or None
ltext = config['products']['mapping'].get('license_text') or None
for imtype in imtlist:
component, imtype = imtype.split('/')
comp = container.getComponents(imtype)[0]
d = {
'imtype': imtype,
'topogrid': topogrid,
'allcities': allcities,
'states_provinces': states_provs,
'countries': countries,
'oceans': oceans,
'lakes': lakes,
'roads': roads,
'faults': faults,
'datadir': datadir,
'operator': operator,
'filter_size': filter_size,
'info': info,
'component': comp,
'imtdict': container.getIMTGrids(imtype, comp),
'ruptdict': copy.deepcopy(container.getRuptureDict()),
'stationdict': container.getStationDict(),
'config': model_config,
'tdict': text_dict,
'display_magnitude': self.display_magnitude,
'pdf_dpi': config['products']['mapping']['pdf_dpi'],
'img_dpi': config['products']['mapping']['img_dpi'],
'license_logo': llogo,
'license_text': ltext,
}
alist.append(d)
if imtype == 'MMI':
g = copy.deepcopy(d)
g['imtype'] = 'thumbnail'
alist.append(g)
h = copy.deepcopy(d)
h['imtype'] = 'overlay'
alist.append(h)
self.contents.addFile('intensityMap', 'Intensity Map',
'Map of macroseismic intensity.',
'intensity.jpg', 'image/jpeg')
self.contents.addFile('intensityMap', 'Intensity Map',
'Map of macroseismic intensity.',
'intensity.pdf', 'application/pdf')
self.contents.addFile('intensityThumbnail',
'Intensity Thumbnail',
'Thumbnail of intensity map.',
'pin-thumbnail.png', 'image/png')
self.contents.addFile(
'intensityOverlay', 'Intensity Overlay and World File',
'Macroseismic intensity rendered as a '
'PNG overlay and associated world file',
'intensity_overlay.png', 'image/png')
self.contents.addFile(
'intensityOverlay', 'Intensity Overlay and World File',
'Macroseismic intensity rendered as a '
'PNG overlay and associated world file',
'intensity_overlay.pngw', 'text/plain')
else:
fileimt = oq_to_file(imtype)
self.contents.addFile(fileimt + 'Map',
fileimt.upper() + ' Map',
'Map of ' + imtype + '.',
fileimt + '.jpg', 'image/jpeg')
self.contents.addFile(fileimt + 'Map',
fileimt.upper() + ' Map',
'Map of ' + imtype + '.',
fileimt + '.pdf', 'application/pdf')
if max_workers > 0:
with cf.ProcessPoolExecutor(max_workers=max_workers) as ex:
results = ex.map(make_map, alist)
list(results)
else:
for adict in alist:
make_map(adict)
container.close()