def get_max_extent(self): """ Returns the maximum extends of the domain. Returns a dictionary with the following keys: * minimum_latitude * maximum_latitude * minimum_longitude * maximum_longitude """ return rotations.get_max_extention_of_domain( self.min_latitude, self.max_latitude, self.min_longitude, self.max_longitude, rotation_axis=self.rotation_axis, rotation_angle_in_degree=self.rotation_angle_in_degree)
def plot_domain(min_latitude, max_latitude, min_longitude, max_longitude, boundary_buffer_in_degree=0.0, rotation_axis=[0.0, 0.0, 1.0], rotation_angle_in_degree=0.0, plot_simulation_domain=False, zoom=False, resolution=None, ax=None): """ """ bounds = rotations.get_max_extention_of_domain( min_latitude, max_latitude, min_longitude, max_longitude, rotation_axis=rotation_axis, rotation_angle_in_degree=rotation_angle_in_degree) center_lat = bounds["minimum_latitude"] + ( bounds["maximum_latitude"] - bounds["minimum_latitude"]) / 2.0 center_lng = bounds["minimum_longitude"] + ( bounds["maximum_longitude"] - bounds["minimum_longitude"]) / 2.0 extend_x = bounds["maximum_longitude"] - bounds["minimum_longitude"] extend_y = bounds["maximum_latitude"] - bounds["minimum_latitude"] max_extend = max(extend_x, extend_y) # If the simulation domain is also available, use it to calculate the # max_extend. This results in the simulation domain affecting the zoom # level. if plot_simulation_domain is True: simulation_domain = rotations.get_border_latlng_list( min_latitude, max_latitude, min_longitude, max_longitude) simulation_domain = np.array(simulation_domain) # Arbitrary threshold if zoom is False or max_extend > 90 or plot_simulation_domain: if resolution is None: resolution = "c" m = Basemap(projection='ortho', lon_0=center_lng, lat_0=center_lat, resolution=resolution, ax=ax) stepsize = 10.0 else: if resolution is None: resolution = "l" # Calculate approximate width and height in meters. width = bounds["maximum_longitude"] - bounds["minimum_longitude"] height = bounds["maximum_latitude"] - bounds["minimum_latitude"] if width > 50.0: stepsize = 10.0 elif 20.0 < width <= 50.0: stepsize = 5.0 elif 5.0 < width <= 20.0: stepsize = 2.0 else: stepsize = 1.0 width *= 110000 * 1.1 height *= 110000 * 1.3 # Lambert azimuthal equal area projection. Equal area projections # are useful for interpreting features and this particular one also # does not distort features a lot on regional scales. m = Basemap(projection='laea', resolution=resolution, width=width, height=height, lat_0=center_lat, lon_0=center_lng) # Catch warning that no labels can be drawn with an orthographic # projection. with warnings.catch_warnings(): warnings.simplefilter("ignore") parallels = np.arange(-90.0, 90.0, stepsize) m.drawparallels(parallels, labels=[False, True, False, False], **LINESTYLE) meridians = np.arange(0.0, 360.0, stepsize) m.drawmeridians(meridians, labels=[False, False, False, True], **LINESTYLE) m.drawmapboundary(fill_color='#cccccc') m.fillcontinents(color='white', lake_color='#cccccc', zorder=0) # m.drawcoastlines() border = rotations.get_border_latlng_list( min_latitude, max_latitude, min_longitude, max_longitude, rotation_axis=rotation_axis, rotation_angle_in_degree=rotation_angle_in_degree) border = np.array(border) lats = border[:, 0] lngs = border[:, 1] lngs, lats = m(lngs, lats) m.plot(lngs, lats, color="black", lw=2, label="Physical Domain") if boundary_buffer_in_degree: border = rotations.get_border_latlng_list( min_latitude + boundary_buffer_in_degree, max_latitude - boundary_buffer_in_degree, min_longitude + boundary_buffer_in_degree, max_longitude - boundary_buffer_in_degree, rotation_axis=rotation_axis, rotation_angle_in_degree=rotation_angle_in_degree) border = np.array(border) lats = border[:, 0] lngs = border[:, 1] lngs, lats = m(lngs, lats) m.plot(lngs, lats, color="black", lw=2, alpha=0.4) if plot_simulation_domain is True: lats = simulation_domain[:, 0] lngs = simulation_domain[:, 1] lngs, lats = m(lngs, lats) m.plot(lngs, lats, color="red", lw=2, label="Simulation Domain") if boundary_buffer_in_degree: border = rotations.get_border_latlng_list( min_latitude + boundary_buffer_in_degree, max_latitude - boundary_buffer_in_degree, min_longitude + boundary_buffer_in_degree, max_longitude - boundary_buffer_in_degree) border = np.array(border) lats = border[:, 0] lngs = border[:, 1] lngs, lats = m(lngs, lats) m.plot(lngs, lats, color="red", lw=2, alpha=0.4) plt.legend() plt.gcf().patch.set_alpha(0.0) return m
def plot_raydensity(map_object, station_events, min_lat, max_lat, min_lng, max_lng, rot_axis, rot_angle): """ Create a ray-density plot for all events and all stations. This function is potentially expensive and will use all CPUs available. Does require geographiclib to be installed. """ import ctypes as C from lasif.tools.great_circle_binner import GreatCircleBinner from lasif.utils import Point import multiprocessing import progressbar from scipy.stats import scoreatpercentile bounds = rotations.get_max_extention_of_domain( min_lat, max_lat, min_lng, max_lng, rotation_axis=rot_axis, rotation_angle_in_degree=rot_angle) # Merge everything so that a list with coordinate pairs is created. This # list is then distributed among all processors. station_event_list = [] for event, stations in station_events: e_point = Point(event["latitude"], event["longitude"]) for station in stations.itervalues(): station_event_list.append((e_point, Point(station["latitude"], station["longitude"]))) circle_count = len(station_event_list) # The granularity of the latitude/longitude discretization for the # raypaths. Attempt to get a somewhat meaningful result in any case. lat_lng_count = 1000 if circle_count < 1000: lat_lng_count = 1000 if circle_count < 10000: lat_lng_count = 2000 else: lat_lng_count = 3000 cpu_count = multiprocessing.cpu_count() def to_numpy(raw_array, dtype, shape): data = np.frombuffer(raw_array.get_obj()) data.dtype = dtype return data.reshape(shape) print "\nLaunching %i greatcircle calculations on %i CPUs..." % \ (circle_count, cpu_count) widgets = ["Progress: ", progressbar.Percentage(), progressbar.Bar(), "", progressbar.ETA()] pbar = progressbar.ProgressBar(widgets=widgets, maxval=circle_count).start() def great_circle_binning(sta_evs, bin_data_buffer, bin_data_shape, lock, counter): new_bins = GreatCircleBinner( bounds["minimum_latitude"], bounds["maximum_latitude"], lat_lng_count, bounds["minimum_longitude"], bounds["maximum_longitude"], lat_lng_count) for event, station in sta_evs: with lock: counter.value += 1 if not counter.value % 25: pbar.update(counter.value) new_bins.add_greatcircle(event, station) bin_data = to_numpy(bin_data_buffer, np.uint32, bin_data_shape) with bin_data_buffer.get_lock(): bin_data += new_bins.bins # Split the data in cpu_count parts. def chunk(seq, num): avg = len(seq) / float(num) out = [] last = 0.0 while last < len(seq): out.append(seq[int(last):int(last + avg)]) last += avg return out chunks = chunk(station_event_list, cpu_count) # One instance that collects everything. collected_bins = GreatCircleBinner( bounds["minimum_latitude"], bounds["maximum_latitude"], lat_lng_count, bounds["minimum_longitude"], bounds["maximum_longitude"], lat_lng_count) # Use a multiprocessing shared memory array and map it to a numpy view. collected_bins_data = multiprocessing.Array(C.c_uint32, collected_bins.bins.size) collected_bins.bins = to_numpy(collected_bins_data, np.uint32, collected_bins.bins.shape) # Create, launch and join one process per CPU. Use a shared value as a # counter and a lock to avoid race conditions. processes = [] lock = multiprocessing.Lock() counter = multiprocessing.Value("i", 0) for _i in xrange(cpu_count): processes.append(multiprocessing.Process( target=great_circle_binning, args=(chunks[_i], collected_bins_data, collected_bins.bins.shape, lock, counter))) for process in processes: process.start() for process in processes: process.join() pbar.finish() title = "%i Events with %i recorded 3 component waveforms" % ( len(station_events), circle_count) # plt.gca().set_title(title, size="large") plt.title(title, size="xx-large") data = collected_bins.bins.transpose() if data.max() >= 10: data = np.log10(data) data += 0.1 data[np.isinf(data)] = 0.0 max_val = scoreatpercentile(data.ravel(), 99) else: max_val = data.max() cmap = cm.get_cmap("gist_heat") cmap._init() cmap._lut[:120, -1] = np.linspace(0, 1.0, 120) ** 2 # Slightly change the appearance of the map so it suits the rays. map_object.drawmapboundary(fill_color='#bbbbbb') map_object.fillcontinents(color='#dddddd', lake_color='#dddddd', zorder=0) lngs, lats = collected_bins.coordinates ln, la = map_object(lngs, lats) map_object.pcolormesh(ln, la, data, cmap=cmap, vmin=0, vmax=max_val) # Draw the coastlines so they appear over the rays. Otherwise things are # sometimes hard to see. map_object.drawcoastlines() map_object.drawcountries(linewidth=0.2) map_object.drawmeridians(np.arange(0, 360, 30), **LINESTYLE) map_object.drawparallels(np.arange(-90, 90, 30), **LINESTYLE)
def plot_domain(min_latitude, max_latitude, min_longitude, max_longitude, boundary_buffer_in_degree=0.0, rotation_axis=[0.0, 0.0, 1.0], rotation_angle_in_degree=0.0, show_plot=True, plot_simulation_domain=False, zoom=False, resolution=None): """ """ bounds = rotations.get_max_extention_of_domain(min_latitude, max_latitude, min_longitude, max_longitude, rotation_axis=rotation_axis, rotation_angle_in_degree=rotation_angle_in_degree) center_lat = bounds["minimum_latitude"] + (bounds["maximum_latitude"] - bounds["minimum_latitude"]) / 2.0 center_lng = bounds["minimum_longitude"] + (bounds["maximum_longitude"] - bounds["minimum_longitude"]) / 2.0 extend_x = bounds["maximum_longitude"] - bounds["minimum_longitude"] extend_y = bounds["maximum_latitude"] - bounds["minimum_latitude"] max_extend = max(extend_x, extend_y) # Arbitrary threshold if zoom is False or max_extend > 70: if resolution is None: resolution = "c" m = Basemap(projection='ortho', lon_0=center_lng, lat_0=center_lat, resolution=resolution) else: if resolution is None: resolution = "l" buffer = max_extend * 0.1 m = Basemap(projection='merc', resolution=resolution, llcrnrlat=bounds["minimum_latitude"] - buffer, urcrnrlat=bounds["maximum_latitude"] + buffer, llcrnrlon=bounds["minimum_longitude"] - buffer, urcrnrlon=bounds["maximum_longitude"] + buffer) m.drawmapboundary(fill_color='#cccccc') m.fillcontinents(color='white', lake_color='#cccccc', zorder=0) border = rotations.get_border_latlng_list(min_latitude, max_latitude, min_longitude, max_longitude, rotation_axis=rotation_axis, rotation_angle_in_degree=rotation_angle_in_degree) border = np.array(border) lats = border[:, 0] lngs = border[:, 1] lngs, lats = m(lngs, lats) m.plot(lngs, lats, color="black", lw=2, label="Physical Domain") if boundary_buffer_in_degree: border = rotations.get_border_latlng_list( min_latitude + boundary_buffer_in_degree, max_latitude - boundary_buffer_in_degree, min_longitude + boundary_buffer_in_degree, max_longitude - boundary_buffer_in_degree, rotation_axis=rotation_axis, rotation_angle_in_degree=rotation_angle_in_degree) border = np.array(border) lats = border[:, 0] lngs = border[:, 1] lngs, lats = m(lngs, lats) m.plot(lngs, lats, color="black", lw=2, alpha=0.4) if plot_simulation_domain is True: border = rotations.get_border_latlng_list(min_latitude, max_latitude, min_longitude, max_longitude) border = np.array(border) lats = border[:, 0] lngs = border[:, 1] lngs, lats = m(lngs, lats) m.plot(lngs, lats, color="red", lw=2, label="Simulation Domain") if boundary_buffer_in_degree: border = rotations.get_border_latlng_list( min_latitude + boundary_buffer_in_degree, max_latitude - boundary_buffer_in_degree, min_longitude + boundary_buffer_in_degree, max_longitude - boundary_buffer_in_degree) border = np.array(border) lats = border[:, 0] lngs = border[:, 1] lngs, lats = m(lngs, lats) m.plot(lngs, lats, color="red", lw=2, alpha=0.4) plt.legend() if show_plot is True: plt.show() return m
def plot_domain(min_latitude=None, max_latitude=None, min_longitude=None, max_longitude=None, boundary_buffer_in_degree=0.0, rotation_axis=[0.0, 0.0, 1.0], rotation_angle_in_degree=0.0, plot_simulation_domain=False, zoom=False, resolution=None, ax=None): """ """ # If all are None, the domain is considered to be global. if [min_latitude, max_latitude, min_longitude, max_longitude] == \ [None, None, None, None]: if resolution is None: resolution = "c" # Equal area mollweide projection. m = Basemap(projection='moll', lon_0=0, resolution=resolution, ax=ax) m.drawmapboundary(fill_color='#cccccc') m.fillcontinents(color='white', lake_color='#cccccc', zorder=0) plt.gcf().patch.set_alpha(0.0) return m bounds = rotations.get_max_extention_of_domain( min_latitude, max_latitude, min_longitude, max_longitude, rotation_axis=rotation_axis, rotation_angle_in_degree=rotation_angle_in_degree) center_lat = bounds["minimum_latitude"] + ( bounds["maximum_latitude"] - bounds["minimum_latitude"]) / 2.0 center_lng = bounds["minimum_longitude"] + ( bounds["maximum_longitude"] - bounds["minimum_longitude"]) / 2.0 extent_x = bounds["maximum_longitude"] - bounds["minimum_longitude"] extent_y = bounds["maximum_latitude"] - bounds["minimum_latitude"] max_extent = max(extent_x, extent_y) # Arbitrary threshold if max_extent > 160: buffer = 15 if resolution is None: resolution = "c" m = Basemap(lon_0=center_lng, lat_0=center_lat, projection='cea', resolution=resolution, ax=ax, llcrnrlat=bounds["minimum_latitude"] - buffer, urcrnrlat=min( bounds["maximum_latitude"] + buffer * 2, 90.0), urcrnrlon=bounds["maximum_longitude"] + buffer, llcrnrlon=bounds["minimum_longitude"] - buffer) # from IPython.core.debugger import Tracer; Tracer(colors="Linux")() # m.llcrnrlat = 0 stepsize = 45.0 elif zoom is False or max_extent > 90 or plot_simulation_domain: if resolution is None: resolution = "c" m = Basemap(projection='ortho', lon_0=center_lng, lat_0=center_lat, resolution=resolution, ax=ax) stepsize = 10.0 else: if resolution is None: resolution = "l" # Calculate approximate width and height in meters. width = bounds["maximum_longitude"] - bounds["minimum_longitude"] height = bounds["maximum_latitude"] - bounds["minimum_latitude"] if width > 50.0: stepsize = 10.0 elif 20.0 < width <= 50.0: stepsize = 5.0 elif 5.0 < width <= 20.0: stepsize = 2.0 else: stepsize = 1.0 width *= 110000 * 1.1 height *= 110000 * 1.3 # Lambert azimuthal equal area projection. Equal area projections # are useful for interpreting features and this particular one also # does not distort features a lot on regional scales. m = Basemap(projection='laea', resolution=resolution, width=width, height=height, lat_0=center_lat, lon_0=center_lng) # Catch warning that no labels can be drawn with an orthographic # projection. with warnings.catch_warnings(): warnings.simplefilter("ignore") parallels = np.arange(-90.0, 90.0, stepsize) m.drawparallels(parallels, labels=[False, True, False, False], **LINESTYLE) meridians = np.arange(0.0, 360.0, stepsize) m.drawmeridians(meridians, labels=[False, False, False, True], **LINESTYLE) m.drawmapboundary(fill_color='#cccccc') m.fillcontinents(color='white', lake_color='#cccccc', zorder=0) border = rotations.get_border_latlng_list( min_latitude, max_latitude, min_longitude, max_longitude, rotation_axis=rotation_axis, rotation_angle_in_degree=rotation_angle_in_degree) border = np.array(border) lats = border[:, 0] lngs = border[:, 1] lngs, lats = m(lngs, lats) m.plot(lngs, lats, color="black", lw=2, label="Physical Domain") if boundary_buffer_in_degree: border = rotations.get_border_latlng_list( min_latitude + boundary_buffer_in_degree, max_latitude - boundary_buffer_in_degree, min_longitude + boundary_buffer_in_degree, max_longitude - boundary_buffer_in_degree, rotation_axis=rotation_axis, rotation_angle_in_degree=rotation_angle_in_degree) border = np.array(border) lats = border[:, 0] lngs = border[:, 1] lngs, lats = m(lngs, lats) m.plot(lngs, lats, color="black", lw=2, alpha=0.4) if plot_simulation_domain is True: simulation_domain = rotations.get_border_latlng_list( min_latitude, max_latitude, min_longitude, max_longitude) simulation_domain = np.array(simulation_domain) lats = simulation_domain[:, 0] lngs = simulation_domain[:, 1] lngs, lats = m(lngs, lats) m.plot(lngs, lats, color="red", lw=2, label="Simulation Domain") if boundary_buffer_in_degree: border = rotations.get_border_latlng_list( min_latitude + boundary_buffer_in_degree, max_latitude - boundary_buffer_in_degree, min_longitude + boundary_buffer_in_degree, max_longitude - boundary_buffer_in_degree) border = np.array(border) lats = border[:, 0] lngs = border[:, 1] lngs, lats = m(lngs, lats) m.plot(lngs, lats, color="red", lw=2, alpha=0.4) plt.legend() plt.gcf().patch.set_alpha(0.0) return m
def plot_domain(min_latitude, max_latitude, min_longitude, max_longitude, boundary_buffer_in_degree=0.0, rotation_axis=[0.0, 0.0, 1.0], rotation_angle_in_degree=0.0, show_plot=True, plot_simulation_domain=False, zoom=False, resolution=None): """ """ bounds = rotations.get_max_extention_of_domain( min_latitude, max_latitude, min_longitude, max_longitude, rotation_axis=rotation_axis, rotation_angle_in_degree=rotation_angle_in_degree) center_lat = bounds["minimum_latitude"] + ( bounds["maximum_latitude"] - bounds["minimum_latitude"]) / 2.0 center_lng = bounds["minimum_longitude"] + ( bounds["maximum_longitude"] - bounds["minimum_longitude"]) / 2.0 extend_x = bounds["maximum_longitude"] - bounds["minimum_longitude"] extend_y = bounds["maximum_latitude"] - bounds["minimum_latitude"] max_extend = max(extend_x, extend_y) # Arbitrary threshold if zoom is False or max_extend > 70: if resolution is None: resolution = "c" m = Basemap(projection='ortho', lon_0=center_lng, lat_0=center_lat, resolution=resolution) else: if resolution is None: resolution = "l" buffer = max_extend * 0.1 m = Basemap(projection='merc', resolution=resolution, llcrnrlat=bounds["minimum_latitude"] - buffer, urcrnrlat=bounds["maximum_latitude"] + buffer, llcrnrlon=bounds["minimum_longitude"] - buffer, urcrnrlon=bounds["maximum_longitude"] + buffer) m.drawmapboundary(fill_color='#cccccc') m.fillcontinents(color='white', lake_color='#cccccc', zorder=0) border = rotations.get_border_latlng_list( min_latitude, max_latitude, min_longitude, max_longitude, rotation_axis=rotation_axis, rotation_angle_in_degree=rotation_angle_in_degree) border = np.array(border) lats = border[:, 0] lngs = border[:, 1] lngs, lats = m(lngs, lats) m.plot(lngs, lats, color="black", lw=2, label="Physical Domain") if boundary_buffer_in_degree: border = rotations.get_border_latlng_list( min_latitude + boundary_buffer_in_degree, max_latitude - boundary_buffer_in_degree, min_longitude + boundary_buffer_in_degree, max_longitude - boundary_buffer_in_degree, rotation_axis=rotation_axis, rotation_angle_in_degree=rotation_angle_in_degree) border = np.array(border) lats = border[:, 0] lngs = border[:, 1] lngs, lats = m(lngs, lats) m.plot(lngs, lats, color="black", lw=2, alpha=0.4) if plot_simulation_domain is True: border = rotations.get_border_latlng_list(min_latitude, max_latitude, min_longitude, max_longitude) border = np.array(border) lats = border[:, 0] lngs = border[:, 1] lngs, lats = m(lngs, lats) m.plot(lngs, lats, color="red", lw=2, label="Simulation Domain") if boundary_buffer_in_degree: border = rotations.get_border_latlng_list( min_latitude + boundary_buffer_in_degree, max_latitude - boundary_buffer_in_degree, min_longitude + boundary_buffer_in_degree, max_longitude - boundary_buffer_in_degree) border = np.array(border) lats = border[:, 0] lngs = border[:, 1] lngs, lats = m(lngs, lats) m.plot(lngs, lats, color="red", lw=2, alpha=0.4) plt.legend() if show_plot is True: plt.show() return m
def plot_raydensity(map_object, station_events, min_lat, max_lat, min_lng, max_lng, rot_axis, rot_angle): """ Create a ray-density plot for all events and all stations. This function is potentially expensive and will use all CPUs available. Does require geographiclib to be installed. """ import ctypes as C from lasif.tools.great_circle_binner import GreatCircleBinner, Point import multiprocessing import progressbar from scipy.stats import scoreatpercentile bounds = rotations.get_max_extention_of_domain( min_lat, max_lat, min_lng, max_lng, rotation_axis=rot_axis, rotation_angle_in_degree=rot_angle) # Merge everything so that a list with coordinate pairs is created. This # list is then distributed among all processors. station_event_list = [] for event, stations in station_events: org = event.preferred_origin() or event.origins[0] e_point = Point(org.latitude, org.longitude) for station in stations.itervalues(): station_event_list.append( (e_point, Point(station["latitude"], station["longitude"]))) circle_count = len(station_event_list) # The granularity of the latitude/longitude discretization for the # raypaths. Attempt to get a somewhat meaningful result in any case. lat_lng_count = 1000 if circle_count < 1000: lat_lng_count = 1000 if circle_count < 10000: lat_lng_count = 2000 else: lat_lng_count = 3000 cpu_count = multiprocessing.cpu_count() def to_numpy(raw_array, dtype, shape): data = np.frombuffer(raw_array.get_obj()) data.dtype = dtype return data.reshape(shape) print "\nLaunching %i greatcircle calculations on %i CPUs..." % \ (circle_count, cpu_count) widgets = [ "Progress: ", progressbar.Percentage(), progressbar.Bar(), "", progressbar.ETA() ] pbar = progressbar.ProgressBar(widgets=widgets, maxval=circle_count).start() def great_circle_binning(sta_evs, bin_data_buffer, bin_data_shape, lock, counter): new_bins = GreatCircleBinner(bounds["minimum_latitude"], bounds["maximum_latitude"], lat_lng_count, bounds["minimum_longitude"], bounds["maximum_longitude"], lat_lng_count) for event, station in sta_evs: with lock: counter.value += 1 if not counter.value % 25: pbar.update(counter.value) new_bins.add_greatcircle(event, station) bin_data = to_numpy(bin_data_buffer, np.uint32, bin_data_shape) with bin_data_buffer.get_lock(): bin_data += new_bins.bins # Split the data in cpu_count parts. def chunk(seq, num): avg = len(seq) / float(num) out = [] last = 0.0 while last < len(seq): out.append(seq[int(last):int(last + avg)]) last += avg return out chunks = chunk(station_event_list, cpu_count) # One instance that collects everything. collected_bins = GreatCircleBinner(bounds["minimum_latitude"], bounds["maximum_latitude"], lat_lng_count, bounds["minimum_longitude"], bounds["maximum_longitude"], lat_lng_count) # Use a multiprocessing shared memory array and map it to a numpy view. collected_bins_data = multiprocessing.Array(C.c_uint32, collected_bins.bins.size) collected_bins.bins = to_numpy(collected_bins_data, np.uint32, collected_bins.bins.shape) # Create, launch and join one process per CPU. Use a shared value as a # counter and a lock to avoid race conditions. processes = [] lock = multiprocessing.Lock() counter = multiprocessing.Value("i", 0) for _i in xrange(cpu_count): processes.append( multiprocessing.Process(target=great_circle_binning, args=(chunks[_i], collected_bins_data, collected_bins.bins.shape, lock, counter))) for process in processes: process.start() for process in processes: process.join() pbar.finish() title = "%i Events with %i recorded 3 component waveforms" % ( len(station_events), circle_count) #plt.gca().set_title(title, size="large") plt.title(title, size="xx-large") data = collected_bins.bins.transpose() if data.max() >= 10: data = np.log10(data) data += 0.1 data[np.isinf(data)] = 0.0 max_val = scoreatpercentile(data.ravel(), 99) else: max_val = data.max() cmap = cm.get_cmap("gist_heat") cmap._init() cmap._lut[:120, -1] = np.linspace(0, 1.0, 120)**2 # Slightly change the appearance of the map so it suits the rays. map_object.drawmapboundary(fill_color='#bbbbbb') map_object.fillcontinents(color='#dddddd', lake_color='#dddddd', zorder=0) lngs, lats = collected_bins.coordinates ln, la = map_object(lngs, lats) map_object.pcolormesh(ln, la, data, cmap=cmap, vmin=0, vmax=max_val) # Draw the coastlines so they appear over the rays. Otherwise things are # sometimes hard to see. map_object.drawcoastlines() map_object.drawcountries(linewidth=0.2) map_object.drawmeridians(np.arange(0, 360, 30)) map_object.drawparallels(np.arange(-90, 90, 30))