def datetime(obj1, start, finish, *attributes): """ Performs a datetime filter on Varpy var_data class Args: Obj1: A Varpy Volcanic data class containing earthquake catalogue data start: start datetime of retained data (number or datetime string) finish: finish datetime of retained data (number or datetime string) attributes: list of attributes (ecvd,scvd ....) which the filter is going to be applied. Returns: Obj2: Filtered Varpy Var_data class Raises: """ obj2=copy.deepcopy(obj1) if not attributes: if obj2.type == 'volcanic': attributes=['ecvd','evd','scvd'] else: attributes=['ecld, scld'] try: start=conversion.date2int(start) finish=conversion.date2int(finish) except: start = float(start) finish = float(finish) pass for atr in attributes: if atr != 'scvd' : try: var_column = getattr(obj2,atr).header.index('datetime') getattr(obj2,atr).dataset = getattr(obj2,atr).dataset[logical_and(getattr(obj2,atr).dataset[:,var_column]>=start, getattr(obj2,atr).dataset[:,var_column]<finish),:] except: pass else: for key in obj2.scvd.keys(): try: var_column = obj2.scvd[key].header.index('datetime') obj2.scvd[key].dataset=obj2.scvd[key].dataset[logical_and(obj2.scvd[key].dataset[:,var_column]>=start, obj2.scvd[key].dataset[:,var_column]<finish),:] except: pass return obj2
def __apply_model(self, data_type, model_type, model_name, start, finish, **kwargs): """ Private Method. Application of model to the "data_type" of the object. Args: self: A Varpy Var_data object data_type: the datatype name to which to apply the model (ecvd, scvd, ecld, scld) model_type: the model type: retrosepective model fit, prospective model fit or real time (series of prospective model fits) model_name: The name of the model to apply. start: the datetime of the start of the modelled period finish: the datetime of the finish of the modelled period tf: the failure or eruption time Raises: """ try: tmin = conversion.date2int(start) tmax = conversion.date2int(finish) except: tmin = start tmax = finish pass #New_Rosa: First of all, we get the current time. current_time = str(datetime.now()) #New_Rosa: Then, we check if we have already this model in our dictionary of models. #In case not, a new key-value is appended to the self.data_type.models dictionary, where the key is the model_name. getattr(self, data_type).add_model_list(model_name, model_type) try: #New_Rosa: Later, a new Model_Output object is created for storing later the outputs of the model. m1_output = Model_Output() #New_Rosa: Once the Model_Output is created, the model (which name is stored in model_name) is applied, and the outputs are stored in the Model_Output object. #To do: Change the way to call the models model_name_path = 'varpy.modelling.models.' + model_name model = importlib.import_module(model_name_path) getattr(model, model_name)(self, data_type, m1_output, tmin, tmax, **kwargs) #iol_mle.iol_mle(self, data_type, m1_output, tmin, tmax, **kwargs) getattr(self, data_type).models[model_name].update_model(m1_output) #getattr(self,data_type).display_models() except: #New_Rosa: If not, I assume that the function is inside of user_models.py module, and the function is called directly with those arguments #m1_output=getattr(user_models,model_name)(self, data_type, m1_output, tmin, tmax, tf, paras) #getattr(self,data_type).models[model_name].update_model(m1_output) pass
def single_analysis(obj1, data_type, model_name, **kwargs): obj2 = copy.deepcopy(obj1) t_min = kwargs['t_min'] t_max = kwargs['t_max'] try: t_min = conversion.date2int(t_min) t_max = conversion.date2int(t_max) except: t_min = float(t_min) t_max = float(t_max) if 'spatial' in kwargs: obj2 = getattr(window, kwargs['spatial'])(obj2, kwargs['spatial_x_min'], kwargs['spatial_x_max'], kwargs['spatial_y_min'], kwargs['spatial_y_max']) else: obj2 = obj1 if 'single_attribute' in kwargs: obj2 = window.single_attribute(obj2, kwargs['single_attribute'], kwargs['z_min'], kwargs['z_max'], data_type) obj2 = window.datetime(obj2, t_min, t_max, data_type) #4. Determine completeness magnitude, apply magnitude filter, based on "mag_comp" option if 'mag_comp' in kwargs: #May need extra options here, e.g. a default value for when catalogue size is small if kwargs['mag_comp'] is 'maxc': mc = magnitudes.mag_completeness( obj2).ecvd.outputs['completeness_mag'].mc_maxc elif kwargs['mag_comp'] is 'GFT': mc = magnitudes.mag_completeness( obj2).ecvd.outputs['completeness_mag'].Mc_GFT elif kwargs['mag_comp'] is 'mbs': mc = magnitudes.mag_completeness( obj2).ecvd.outputs['completeness_mag'].mc_mbs else: mc = mag_comp obj2 = window.single_attribute(obj2, 'magnitude', mc, 10.0, data_type) #5. Apply model to object if 'tf' in kwargs: obj2.apply_model(data_type, 'retrospective_analysis', model_name, t_min, t_max, **kwargs) else: obj2.apply_model(data_type, 'single_forecast', model_name, t_min, t_max, **kwargs) return obj2
def single_analysis(obj1, data_type, model_name, **kwargs): obj2=copy.deepcopy(obj1) t_min=kwargs['t_min'] t_max=kwargs['t_max'] try: t_min = conversion.date2int(t_min) t_max = conversion.date2int(t_max) except: t_min =float(t_min) t_max=float(t_max) if 'spatial' in kwargs: obj2=getattr(window,kwargs['spatial'])(obj2, kwargs['spatial_x_min'], kwargs['spatial_x_max'] , kwargs['spatial_y_min'],kwargs['spatial_y_max']) else: obj2=obj1 if 'single_attribute' in kwargs: obj2=window.single_attribute(obj2, kwargs['single_attribute'],kwargs['z_min'],kwargs['z_max'], data_type) obj2=window.datetime(obj2, t_min, t_max, data_type) #4. Determine completeness magnitude, apply magnitude filter, based on "mag_comp" option if 'mag_comp' in kwargs: #May need extra options here, e.g. a default value for when catalogue size is small if kwargs['mag_comp'] is 'maxc': mc = magnitudes.mag_completeness(obj2).ecvd.outputs['completeness_mag'].mc_maxc elif kwargs['mag_comp'] is 'GFT': mc = magnitudes.mag_completeness(obj2).ecvd.outputs['completeness_mag'].Mc_GFT elif kwargs['mag_comp'] is 'mbs': mc = magnitudes.mag_completeness(obj2).ecvd.outputs['completeness_mag'].mc_mbs else: mc = mag_comp obj2 = window.single_attribute(obj2, 'magnitude', mc, 10.0, data_type) #5. Apply model to object if 'tf' in kwargs: obj2.apply_model(data_type, 'retrospective_analysis', model_name, t_min, t_max, **kwargs) else: obj2.apply_model(data_type, 'single_forecast', model_name, t_min, t_max, **kwargs) return obj2
def __apply_model(self, data_type, model_type, model_name, start, finish, **kwargs): """ Private Method. Application of model to the "data_type" of the object. Args: self: A Varpy Var_data object data_type: the datatype name to which to apply the model (ecvd, scvd, ecld, scld) model_type: the model type: retrosepective model fit, prospective model fit or real time (series of prospective model fits) model_name: The name of the model to apply. start: the datetime of the start of the modelled period finish: the datetime of the finish of the modelled period tf: the failure or eruption time Raises: """ try: tmin=conversion.date2int(start) tmax=conversion.date2int(finish) except: tmin=start tmax=finish pass #New_Rosa: First of all, we get the current time. current_time=str(datetime.now()) #New_Rosa: Then, we check if we have already this model in our dictionary of models. #In case not, a new key-value is appended to the self.data_type.models dictionary, where the key is the model_name. getattr(self,data_type).add_model_list(model_name,model_type) try: #New_Rosa: Later, a new Model_Output object is created for storing later the outputs of the model. m1_output=Model_Output() #New_Rosa: Once the Model_Output is created, the model (which name is stored in model_name) is applied, and the outputs are stored in the Model_Output object. #To do: Change the way to call the models model_name_path = 'varpy.modelling.models.'+ model_name model = importlib.import_module(model_name_path) getattr(model, model_name)(self, data_type, m1_output, tmin, tmax, **kwargs) #iol_mle.iol_mle(self, data_type, m1_output, tmin, tmax, **kwargs) getattr(self,data_type).models[model_name].update_model(m1_output) #getattr(self,data_type).display_models() except: #New_Rosa: If not, I assume that the function is inside of user_models.py module, and the function is called directly with those arguments #m1_output=getattr(user_models,model_name)(self, data_type, m1_output, tmin, tmax, tf, paras) #getattr(self,data_type).models[model_name].update_model(m1_output) pass
#4 mag_comp = 'GFT' #method for magnitude filtering. 'None' is no filtering #5 model = 'iol_mle' #name of model to apply. Could do many??? #Setup Varpy object d1 = core.Volcanic(ID) #Add data to Varpy object d1.add_datatype('ecvd', ecvd_data_file, ecvd_metadata_file) #Set-up times to run model try: t_min = conversion.date2int(t_min) t_max = conversion.date2int(t_max) except: t_min = float(t_min) t_max = float(t_max) pass times = t_max #Run forecasts in a loop... for t_forc in str(times): #Maybe update object d1 here???? #1. Apply spatial filter #May need a "None" option here d2 = window.latlon(d1, lat_min, lat_max, lon_min, lon_max) #2. Apply depth filter
def ecd_rate_plot(obj1, plot_type=None, t_inc=None, t_lims=None, lon_lims=None, lat_lims=None, z_lims=None, Mc=None, Name=None, Save=None): """ Plot the rate and cumulative number of ecd events with time Args: obj1: a varpy object containing ecd data plot_type: rate, cumulative or both (None) t_inc: the time increment over which to count event rates, default = 1 t_lims: [t_min, t_max] defining time axis limits lon_lims: [lon_min, lon_max] defining x-axis limits lat_lims: [lat_min, lat_max] defining y-axis limits z_lims: [z_min, z_max] defining depth range Mc: magnitude cut-off Returns: fig1: the resulting plot """ if obj1.type == 'volcanic': data = obj1.ecvd.dataset header = obj1.ecvd.header else: data = obj1.ecld.dataset header = obj1.ecld.header if t_lims is not None: try: t_min=conversion.date2int(t_lims[0]) t_max=conversion.date2int(t_lims[1]) except: t_min = float(t_lims[0]) t_max = float(t_lims[1]) pass data = data[logical_and(data[:,header.index('datetime')]>=t_min,data[:,header.index('datetime')]<t_max),:] if lon_lims is not None: data = data[logical_and(data[:,header.index('longitude')]>=lon_lims[0],data[:,header.index('longitude')]<lon_lims[1]),:] if lat_lims is not None: data = data[logical_and(data[:,header.index('latitude')]>=lat_lims[0],data[:,header.index('latitude')]<lat_lims[1]),:] if z_lims is not None: data = data[logical_and(data[:,header.index('depth')]>=z_lims[0],data[:,header.index('depth')]<z_lims[1]),:] if Mc is not None: data = data[data[:,header.index('magnitude')]>=Mc,:] dt_data = data[:,header.index('datetime')] if t_lims is None: t_min = floor(dt_data.min()) t_max = ceil(dt_data.max()) if t_inc is None: t_inc = 1.0 fig1 = plt.figure(1, figsize=(8,6)) ax1 = fig1.add_subplot(111, axisbg='lightgrey') if plot_type == 'rate' or plot_type == None: day_bins = arange(t_min, t_max, t_inc) DER, DER_bes = histogram(dt_data, day_bins) if dt_data[0]>693500: ax1.bar(mdates.num2date(day_bins[:-1]), DER, width=t_inc, color='darkslategrey', edgecolor='darkslategrey') ax1.set_xlabel('Date', fontsize=8) else: ax1.bar(day_bins[:-1], DER, width=t_inc, color='darkslategrey', edgecolor='darkslategrey') ax1.set_xlabel('Day', fontsize=8) ax1.set_ylabel('Daily number of earthquakes', fontsize=8) if plot_type == 'cumulative' or plot_type == None: if plot_type == None: ax2 = ax1.twinx() else: ax2=ax1 if dt_data[0]>693500: ax2.plot(mdates.num2date(dt_data), arange(len(dt_data))+1, 'k') else: ax2.plot(dt_data, arange(len(dt_data))+1, 'k') ax2.set_ylabel('Total earthquakes', fontsize=8) ax1.xaxis.set_ticks_position('bottom') if getattr(obj1, 'evd') != None: eruption_starts = atleast_2d(obj1.evd.dataset)[:,obj1.evd.header.index('start_datetime')] for i in range(len(eruption_starts)): if dt_data[0]>693500: ax1.axvline(mdates.num2date(eruption_starts[i]), color='red', linestyle='--') else: ax1.axvline(eruption_starts[i], color='red', linestyle='--') ax1.set_xlim(t_min,t_max) if Save is not None: if Name is None: timestamp=str(time.time()) else: timestamp=Name png_name=obj1.figure_path+'/ecd_rate_plot-'+timestamp+'.png' eps_name=obj1.figure_path+'/ecd_rate_plot-'+timestamp+'.eps' if 'ecd_rate_plot' not in obj1.figures.keys(): obj1.figures['ecd_rate_plot']=[] obj1.figures['ecd_rate_plot'].append(png_name) obj1.figures['ecd_rate_plot'].append(eps_name) plt.savefig(png_name) plt.savefig(eps_name) return fig1
def multiple_analysis(obj1, data_type, model_name, **kwargs): obj2=copy.deepcopy(obj1) t_step=kwargs['t_step'] if 't_min' not in kwargs: #time limits have not been specified, therefore we are in prospective mode t_min = conversion.date2int(date.today().strftime("%d-%m-%Y")) t_max_a =date.today() + timedelta(days=100) t_max = conversion.date2int(t_max_a.strftime("%d-%m-%Y")) model_type='prospective_forecast' else: t_min=kwargs['t_min'] t_max=kwargs['t_max'] model_type='retrosepective_forecast' try: t_min = conversion.date2int(t_min) t_max = conversion.date2int(t_max) except: t_min =float(t_min) t_max=float(t_max) times = arange(t_min, t_max, t_step) if 'data_file' in kwargs: data_file=kwargs['data_file'] for t_forc in times: if model_type == 'prospective_forecast': obj2.update_datatype(data_type,data_file) if 'spatial' in kwargs: obj2=getattr(window,kwargs['spatial'])(obj2, kwargs['spatial_x_min'], kwargs['spatial_x_max'] , kwargs['spatial_y_min'],kwargs['spatial_y_max']) else: obj2=obj1 if 'single_attribute' in kwargs: obj2=window.single_attribute(obj2, kwargs['single_attribute'],kwargs['z_min'],kwargs['z_max'], data_type) else: obj2=obj1 obj2=window.datetime(obj2,t_min,t_forc, data_type) n_events = len(getattr(obj2,data_type).dataset) if n_events >= 10: #4. Determine completeness magnitude, apply magnitude filter, based on "mag_comp" option if 'mag_comp' in kwargs: if n_events<=50: mc = 0. else: if kwargs['mag_comp'] is 'maxc': mc = magnitudes.mag_completeness(obj2).ecvd.outputs['completeness_mag'].mc_maxc elif kwargs['mag_comp'] is 'GFT': mc = magnitudes.mag_completeness(obj2).ecvd.outputs['completeness_mag'].Mc_GFT elif kwargs['mag_comp'] is 'mbs': mc = magnitudes.mag_completeness(obj2).ecvd.outputs['completeness_mag'].mc_mbs else: mc = mag_comp obj2 = window.single_attribute(obj2, 'magnitude', mc, 10.0, data_type) #5. Apply model to object if 'tf' in kwargs: obj2.apply_model(data_type, model_type, model_name, t_min, t_forc, **kwargs) else: obj2.apply_model(data_type, model_type, model_name, t_min, t_forc, **kwargs) #6. Modify the model output to record the value of mc model_output=getattr(obj2,data_type).last_model_output(model_name) model_output.t_forc=t_forc model_output.mc=mc getattr(obj2,data_type).update_last_model_output(model_name,model_output) else: pass return obj2
def model_plot(obj1, data_type, model_name, plot_type=None, t_inc=None, t_lims=None): if data_type is 'ecvd' or 'ecld': #1. Determine t_min and t_max - check these aren't stored in model information... if t_lims is not None: try: t_min=conversion.date2int(t_lims[0]) t_max=conversion.date2int(t_lims[1]) except: t_min = float(t_lims[0]) t_max = float(t_lims[1]) pass else: if obj1.type == 'volcanic': data = obj1.ecvd.dataset header = obj1.ecvd.header else: data = obj1.ecld.dataset header = obj1.ecld.header dt_data = data[:,header.index('datetime')] t_min = floor(dt_data.min()) t_max = ceil(dt_data.max()) #2. Plot the underlying rate/total graph using "rate_plots" - still need to confirm this works #Seems unnecessary to repeat same plotting code here. fig = rate_plots.ecd_rate_plot(obj1, plot_type, t_inc=None, t_lims=None, Save=None) #3. Get the axes from fig to modify with new series - how best to do this? axes = fig.get_axes() ax1 = axes[0] if plot_type == None: ax2 = axes[1] elif plot_type == 'cumulative': ax2 = axes[0] #4. Create series of times between t_max, t_min to evaulate model rate, totals times = linspace(t_min, t_max, 500) for model in getattr(obj1,data_type).models.keys(): m0=getattr(obj1,data_type).models[model].outputs for m1 in m0: #6. For each model, get parameters params = m1.dataset if plot_type == 'rate' or plot_type == None: #7. Determine, plot rates #Check that the correct "daily rate" are reported... rate_func = m1.metadata['rate_func'] rates = getattr(rate_funcs, rate_func[0])(times-t_min, params) ax1.plot(times, rates, '-r') if plot_type == 'cumulative' or plot_type == None: #8. Determine, plot totals total_func = m1.metadata['total_func'] totals = getattr(rate_funcs, total_func[0])(times-t_min, 0., params) ax2.plot(times, totals, '-r') #9. Legend else: #Alternative for SCVD, SCLD data? print 'SCLD and SCVD data not currently supported' ax1.set_xlim(t_min, t_max) png_name=obj1.figure_path+'/model_plot.png' eps_name=obj1.figure_path+'/model_plot.eps' plt.savefig(png_name) plt.savefig(eps_name)
def iet_plot(obj1, Norm=None, model=None, t_lims=None, lon_lims=None, lat_lims=None, z_lims=None, Mc=None): """ Plot a histogram of interevent times and a pdf of normalized IETs Args: obj1: a varpy object containing event catalogue data Norm: if True, normalize the IET histogram model: option to fit and bootstrap CoIs for model. Existing options: Poisson, Gamma t_lims: [t_min, t_max] defining time axis limits lon_lims: [lon_min, lon_max] defining x-axis limits lat_lims: [lat_min, lat_max] defining y-axis limits z_lims: [z_min, z_max] defining depth range Mc: magnitude cut-off Returns: fig1: a png image of the resulting plot """ if obj1.type == 'volcanic': data = obj1.ecvd.dataset header = obj1.ecvd.header else: data = obj1.ecld.dataset header = obj1.ecld.header if t_lims is not None: try: t_min = conversion.date2int(t_lims[0]) t_max = conversion.date2int(t_lims[1]) except: t_min = float(t_lims[0]) t_max = float(t_lims[1]) pass data = data[logical_and(data[:, header.index('datetime')] >= t_min, data[:, header.index('datetime')] < t_max), :] if lon_lims is not None: data = data[ logical_and(data[:, header.index('longitude')] >= lon_lims[0], data[:, header.index('longitude')] < lon_lims[1]), :] if lat_lims is not None: data = data[ logical_and(data[:, header.index('latitude')] >= lat_lims[0], data[:, header.index('latitude')] < lat_lims[1]), :] if z_lims is not None: data = data[logical_and(data[:, header.index('depth')] >= z_lims[0], data[:, header.index('depth')] < z_lims[1]), :] if Mc is not None: data = data[data[:, header.index('magnitude')] >= Mc, :] dt_data = data[:, header.index('datetime')] iets = diff(dt_data, n=1) iet_mean = mean(iets) iet_bins = logspace(-5.0, 2.0, num=50) mid_iet_bins = iet_bins[:-1] + diff(iet_bins) / 2 iet_counts, iet_bes = histogram(iets, iet_bins) ########## fig1 = plt.figure(1, figsize=(12, 6)) ax1 = fig1.add_subplot(121, axisbg='lightgrey') ax1.semilogx(mid_iet_bins, iet_counts, '-s', color='blue') ax2 = fig1.add_subplot(122, axisbg='lightgrey') ax2.loglog(mid_iet_bins / iet_mean, (iet_mean * iet_counts) / (diff(iet_bins) * len(iets)), '-s', color='blue') if Norm is True: norm = iet_mean else: norm = 1. if model is not None: #Bootstrap 95% COIs iet_bstps = 1000 rates_bstps = zeros((len(iet_bins) - 1, iet_bstps)) if model is 'Gamma': #fit gamma model fit_alpha, fit_loc, fit_beta = gamma.fit(iets, loc=0.0) for j in range(iet_bstps): model_sim = gamma.rvs(fit_alpha, loc=fit_loc, scale=fit_beta, size=len(iets)) rates_bstps[:, j], model_bes = histogram(model_sim, iet_bins) coi_95 = scoreatpercentile(rates_bstps.transpose(), 95, axis=0) coi_5 = scoreatpercentile(rates_bstps.transpose(), 5, axis=0) ax1.semilogx( mid_iet_bins / norm, gamma.pdf(mid_iet_bins, fit_alpha, fit_loc, fit_beta) * diff(iet_bins) * len(iets), 'r') ax1.semilogx(mid_iet_bins / norm, coi_95, 'r:') ax1.semilogx(mid_iet_bins / norm, coi_5, 'r:') ax2.loglog(mid_iet_bins / iet_mean, (iet_mean * gamma.pdf(mid_iet_bins, fit_alpha, fit_loc, fit_beta)), 'r') ax2.loglog(mid_iet_bins / iet_mean, (iet_mean * coi_95) / (diff(iet_bins) * len(iets)), 'r:') ax2.loglog(mid_iet_bins / iet_mean, (iet_mean * coi_5) / (diff(iet_bins) * len(iets)), 'r:') elif model is 'Poisson': #fit exponential model for j in range(iet_bstps): model_sim = expon.rvs(scale=iet_mean, size=len(iets)) rates_bstps[:, j], model_bes = histogram(model_sim, iet_bins) coi_95 = scoreatpercentile(rates_bstps.transpose(), 95, axis=0) coi_5 = scoreatpercentile(rates_bstps.transpose(), 5, axis=0) ax1.semilogx( mid_iet_bins / norm, expon.pdf(mid_iet_bins, loc=0, scale=iet_mean) * diff(iet_bins) * len(iets), 'r') ax1.semilogx(mid_iet_bins / norm, coi_95, 'r:') ax1.semilogx(mid_iet_bins / norm, coi_5, 'r:') ax2.loglog( mid_iet_bins / iet_mean, (iet_mean * expon.pdf(mid_iet_bins, loc=0, scale=iet_mean)), 'r') ax2.loglog(mid_iet_bins / iet_mean, (iet_mean * coi_95) / (diff(iet_bins) * len(iets)), 'r:') ax2.loglog(mid_iet_bins / iet_mean, (iet_mean * coi_5) / (diff(iet_bins) * len(iets)), 'r:') if Norm is True: ax1.set_xlabel(r'$\tau \backslash \bar\tau$ (days)') else: ax1.set_xlabel(r'$\tau$ (days)') ax1.set_ylabel('Frequency') ax1.xaxis.set_ticks_position('bottom') ax2.set_xlim(0.00008, 200) ax2.set_ylim(0.00001, 1000) ax2.set_xlabel(r'$\tau \backslash \bar\tau$ (days)') ax2.set_ylabel('pdf') ax2.xaxis.set_ticks_position('bottom') png_name = obj1.figure_path + '/iet_plots.png' eps_name = obj1.figure_path + '/iet_plots.eps' plt.savefig(png_name) plt.savefig(eps_name)
def model_error_plot(obj1, data_type, model_name, t_lims=None, percentiles=None, n_bs=None): if data_type is 'ecvd' or 'ecld': #1. Determine t_min and t_max - check these aren't stored in model information... if t_lims is not None: try: t_min = conversion.date2int(t_lims[0]) t_max = conversion.date2int(t_lims[1]) except: t_min = float(t_lims[0]) t_max = float(t_lims[1]) pass else: if obj1.type == 'volcanic': data = obj1.ecvd.dataset header = obj1.ecvd.header else: data = obj1.ecld.dataset header = obj1.ecld.header dt_data = data[:, header.index('datetime')] t_min = floor(dt_data.min()) t_max = ceil(dt_data.max()) t_inc = (t_max - t_min) / 11. fig1 = plt.figure(1, figsize=(8, 6)) ax1 = fig1.add_subplot(111, axisbg='lightgrey') rate_bins = linspace(t_min, t_max, 11) mid_bins = rate_bins[:-1] + diff(rate_bins) / 2. DER, DER_bes = histogram(dt_data, rate_bins) if dt_data[0] > 693500: ax1.plot(mdates.num2date(mid_bins), DER, 'o') ax1.set_xlabel('Date', fontsize=8) else: ax1.plot(mid_bins, DER, 'o') ax1.set_xlabel('Day', fontsize=8) ax1.set_ylabel('rate of earthquakes', fontsize=8) #4. Create series of times between t_max, t_min to evaulate model rate, totals times = linspace(t_min, t_max, 500) for model in getattr(obj1, data_type).models.keys(): m0 = getattr(obj1, data_type).models[model].outputs for m1 in m0: #6. For each model, get parameters params = m1.dataset rate_func = m1.metadata['rate_func'] rates = getattr(rate_funcs, rate_func[0])(times - t_min, params) ax1.plot(times, rates * t_inc, '-r') #Bootstrap confidence limits coi_l, coi_u = model_stats.model_CoIs(rate_func, params, rate_bins, percentiles, n_bs) ax1.plot(mid_bins, coi_l, 'r:') ax1.plot(mid_bins, coi_u, 'r:') else: #Alternative for SCVD, SCLD data? print 'SCLD and SCVD data not currently supported' ax1.set_xlim(t_min, t_max) png_name = obj1.figure_path + '/model_plot.png' eps_name = obj1.figure_path + '/model_plot.eps' plt.savefig(png_name) plt.savefig(eps_name)
def model_plot(obj1, data_type, model_name, plot_type=None, t_inc=None, t_lims=None): if data_type is 'ecvd' or 'ecld': #1. Determine t_min and t_max - check these aren't stored in model information... if t_lims is not None: try: t_min = conversion.date2int(t_lims[0]) t_max = conversion.date2int(t_lims[1]) except: t_min = float(t_lims[0]) t_max = float(t_lims[1]) pass else: if obj1.type == 'volcanic': data = obj1.ecvd.dataset header = obj1.ecvd.header else: data = obj1.ecld.dataset header = obj1.ecld.header dt_data = data[:, header.index('datetime')] t_min = floor(dt_data.min()) t_max = ceil(dt_data.max()) #2. Plot the underlying rate/total graph using "rate_plots" - still need to confirm this works #Seems unnecessary to repeat same plotting code here. fig = rate_plots.ecd_rate_plot(obj1, plot_type, t_inc=None, t_lims=None, Save=None) #3. Get the axes from fig to modify with new series - how best to do this? axes = fig.get_axes() ax1 = axes[0] if plot_type == None: ax2 = axes[1] elif plot_type == 'cumulative': ax2 = axes[0] #4. Create series of times between t_max, t_min to evaulate model rate, totals times = linspace(t_min, t_max, 500) for model in getattr(obj1, data_type).models.keys(): m0 = getattr(obj1, data_type).models[model].outputs for m1 in m0: #6. For each model, get parameters params = m1.dataset if plot_type == 'rate' or plot_type == None: #7. Determine, plot rates #Check that the correct "daily rate" are reported... rate_func = m1.metadata['rate_func'] rates = getattr(rate_funcs, rate_func[0])(times - t_min, params) ax1.plot(times, rates, '-r') if plot_type == 'cumulative' or plot_type == None: #8. Determine, plot totals total_func = m1.metadata['total_func'] totals = getattr(rate_funcs, total_func[0])(times - t_min, 0., params) ax2.plot(times, totals, '-r') #9. Legend else: #Alternative for SCVD, SCLD data? print 'SCLD and SCVD data not currently supported' ax1.set_xlim(t_min, t_max) png_name = obj1.figure_path + '/model_plot.png' eps_name = obj1.figure_path + '/model_plot.eps' plt.savefig(png_name) plt.savefig(eps_name)
def datetime(obj1, start, finish, *attributes): """ Performs a datetime filter on Varpy var_data class Args: Obj1: A Varpy Volcanic data class containing earthquake catalogue data start: start datetime of retained data (number or datetime string) finish: finish datetime of retained data (number or datetime string) attributes: list of attributes (ecvd,scvd ....) which the filter is going to be applied. Returns: Obj2: Filtered Varpy Var_data class Raises: """ obj2 = copy.deepcopy(obj1) if not attributes: if obj2.type == 'volcanic': attributes = ['ecvd', 'evd', 'scvd'] else: attributes = ['ecld, scld'] try: start = conversion.date2int(start) finish = conversion.date2int(finish) except: start = float(start) finish = float(finish) pass for atr in attributes: if atr != 'scvd': try: var_column = getattr(obj2, atr).header.index('datetime') getattr(obj2, atr).dataset = getattr( obj2, atr).dataset[logical_and( getattr(obj2, atr).dataset[:, var_column] >= start, getattr(obj2, atr).dataset[:, var_column] < finish), :] except: pass else: for key in obj2.scvd.keys(): try: var_column = obj2.scvd[key].header.index('datetime') obj2.scvd[key].dataset = obj2.scvd[key].dataset[ logical_and( obj2.scvd[key].dataset[:, var_column] >= start, obj2. scvd[key].dataset[:, var_column] < finish), :] except: pass return obj2
def multiple_analysis(obj1, data_type, model_name, **kwargs): obj2 = copy.deepcopy(obj1) t_step = kwargs['t_step'] if 't_min' not in kwargs: #time limits have not been specified, therefore we are in prospective mode t_min = conversion.date2int(date.today().strftime("%d-%m-%Y")) t_max_a = date.today() + timedelta(days=100) t_max = conversion.date2int(t_max_a.strftime("%d-%m-%Y")) model_type = 'prospective_forecast' else: t_min = kwargs['t_min'] t_max = kwargs['t_max'] model_type = 'retrosepective_forecast' try: t_min = conversion.date2int(t_min) t_max = conversion.date2int(t_max) except: t_min = float(t_min) t_max = float(t_max) times = arange(t_min, t_max, t_step) if 'data_file' in kwargs: data_file = kwargs['data_file'] for t_forc in times: if model_type == 'prospective_forecast': obj2.update_datatype(data_type, data_file) if 'spatial' in kwargs: obj2 = getattr(window, kwargs['spatial'])(obj2, kwargs['spatial_x_min'], kwargs['spatial_x_max'], kwargs['spatial_y_min'], kwargs['spatial_y_max']) else: obj2 = obj1 if 'single_attribute' in kwargs: obj2 = window.single_attribute(obj2, kwargs['single_attribute'], kwargs['z_min'], kwargs['z_max'], data_type) else: obj2 = obj1 obj2 = window.datetime(obj2, t_min, t_forc, data_type) n_events = len(getattr(obj2, data_type).dataset) if n_events >= 10: #4. Determine completeness magnitude, apply magnitude filter, based on "mag_comp" option if 'mag_comp' in kwargs: if n_events <= 50: mc = 0. else: if kwargs['mag_comp'] is 'maxc': mc = magnitudes.mag_completeness( obj2).ecvd.outputs['completeness_mag'].mc_maxc elif kwargs['mag_comp'] is 'GFT': mc = magnitudes.mag_completeness( obj2).ecvd.outputs['completeness_mag'].Mc_GFT elif kwargs['mag_comp'] is 'mbs': mc = magnitudes.mag_completeness( obj2).ecvd.outputs['completeness_mag'].mc_mbs else: mc = mag_comp obj2 = window.single_attribute(obj2, 'magnitude', mc, 10.0, data_type) #5. Apply model to object if 'tf' in kwargs: obj2.apply_model(data_type, model_type, model_name, t_min, t_forc, **kwargs) else: obj2.apply_model(data_type, model_type, model_name, t_min, t_forc, **kwargs) #6. Modify the model output to record the value of mc model_output = getattr(obj2, data_type).last_model_output(model_name) model_output.t_forc = t_forc model_output.mc = mc getattr(obj2, data_type).update_last_model_output( model_name, model_output) else: pass return obj2
def scatter_plot(obj1, variable1, variable2=None, colour=None, x_lims=None, y_lims=None, t_lims=None, lon_lims=None, lat_lims=None, z_lims=None, Mc=None): """ Plot the evolution of ecvd variables. If a single variable is specified, this is plotted as a function of datetime. If a second variable is specified, this is plotted on the y-axis, with variable1 on the x-axis Args: obj1: a varpy object containing variable1: first ecvd variable variable2: second ecvd variable (optional) colour: variable to define colour scale x_lims: [x_min, x_max] defining x-axis limits y_lims: [y_min, y_max] defining y-axis limits t_lims: [t_min, t_max] defining time axis limits lon_lims: [lon_min, lon_max] defining x-axis limits lat_lims: [lat_min, lat_max] defining y-axis limits z_lims: [z_min, z_max] defining depth range Mc: magnitude cut-off Returns: fig1: a png image of the resulting plot """ if obj1.type == 'volcanic': data = obj1.ecvd.dataset header = obj1.ecvd.header else: data = obj1.ecld.dataset header = obj1.ecld.header if t_lims is not None: try: t_min = conversion.date2int(t_lims[0]) t_max = conversion.date2int(t_lims[1]) except: t_min = float(t_lims[0]) t_max = float(t_lims[1]) pass data = data[logical_and(data[:, header.index('datetime')] >= t_min, data[:, header.index('datetime')] < t_max), :] if lon_lims is not None: data = data[ logical_and(data[:, header.index('longitude')] >= lon_lims[0], data[:, header.index('longitude')] < lon_lims[1]), :] if lat_lims is not None: data = data[ logical_and(data[:, header.index('latitude')] >= lat_lims[0], data[:, header.index('latitude')] < lat_lims[1]), :] if z_lims is not None: data = data[logical_and(data[:, header.index('depth')] >= z_lims[0], data[:, header.index('depth')] < z_lims[1]), :] if Mc is not None: data = data[data[:, header.index('magnitude')] >= Mc, :] if variable2 is None: v1_data = data[:, header.index('datetime')] v2_data = data[:, header.index(variable1)] if t_lims is None: t_min = floor(v1_data.min()) t_max = ceil(v1_data.max()) else: t_min = t_lims[0] t_max = t_lims[1] if y_lims is None: y_min = v2_data.min() y_max = v2_data.max() else: y_min = y_lims[0] y_max = y_lims[1] else: v1_data = data[:, header.index(variable1)] v2_data = data[:, header.index(variable2)] if x_lims is None: x_min = v1_data.min() x_max = v1_data.max() else: x_min = x_lims[0] x_max = x_lims[1] if y_lims is None: y_min = v2_data.min() y_max = v2_data.max() else: y_min = y_lims[0] y_max = y_lims[1] fig1 = plt.figure(1, figsize=(8, 6)) ax1 = fig1.add_subplot(111, axisbg='lightgrey') c_val = 'blue' #default if colour is not None: cvar_column = header.index(colour) c_val = data[:, cvar_column] if variable2 is None: if v1_data[0] > 693500: ax1.scatter(mdates.num2date(v1_data), v2_data, marker='o', s=9, c=c_val, edgecolor='none') ax1.set_xlabel('Date', fontsize=10) else: ax1.scatter(v1_data, v2_data, marker='o', s=9, c=c_val, edgecolor='none') ax1.set_xlabel('Day', fontsize=10) ax1.set_ylabel(variable1, fontsize=10) ax1.set_xlim(t_min, t_max) ax1.set_ylim(y_min, y_max) if variable1 == 'depth': ax1.invert_yaxis() else: ax1.scatter(v1_data, v2_data, marker='o', s=9, c=c_val, edgecolor='none') ax1.set_xlabel(variable1, fontsize=10) ax1.set_ylabel(variable2, fontsize=10) ax1.set_xlim(x_min, x_max) ax1.set_ylim(y_min, y_max) if variable2 == 'depth': ax1.invert_yaxis() png_name = obj1.figure_path + '/' + variable1 + '_scatter.png' eps_name = obj1.figure_path + '/' + variable1 + '_scatter.eps' plt.savefig(png_name) plt.savefig(eps_name)
def ecd_rate_plot(obj1, plot_type=None, t_inc=None, t_lims=None, lon_lims=None, lat_lims=None, z_lims=None, Mc=None, Name=None, Save=None): """ Plot the rate and cumulative number of ecd events with time Args: obj1: a varpy object containing ecd data plot_type: rate, cumulative or both (None) t_inc: the time increment over which to count event rates, default = 1 t_lims: [t_min, t_max] defining time axis limits lon_lims: [lon_min, lon_max] defining x-axis limits lat_lims: [lat_min, lat_max] defining y-axis limits z_lims: [z_min, z_max] defining depth range Mc: magnitude cut-off Returns: fig1: the resulting plot """ if obj1.type == 'volcanic': data = obj1.ecvd.dataset header = obj1.ecvd.header else: data = obj1.ecld.dataset header = obj1.ecld.header if t_lims is not None: try: t_min = conversion.date2int(t_lims[0]) t_max = conversion.date2int(t_lims[1]) except: t_min = float(t_lims[0]) t_max = float(t_lims[1]) pass data = data[logical_and(data[:, header.index('datetime')] >= t_min, data[:, header.index('datetime')] < t_max), :] if lon_lims is not None: data = data[ logical_and(data[:, header.index('longitude')] >= lon_lims[0], data[:, header.index('longitude')] < lon_lims[1]), :] if lat_lims is not None: data = data[ logical_and(data[:, header.index('latitude')] >= lat_lims[0], data[:, header.index('latitude')] < lat_lims[1]), :] if z_lims is not None: data = data[logical_and(data[:, header.index('depth')] >= z_lims[0], data[:, header.index('depth')] < z_lims[1]), :] if Mc is not None: data = data[data[:, header.index('magnitude')] >= Mc, :] dt_data = data[:, header.index('datetime')] if t_lims is None: t_min = floor(dt_data.min()) t_max = ceil(dt_data.max()) if t_inc is None: t_inc = 1.0 fig1 = plt.figure(1, figsize=(8, 6)) ax1 = fig1.add_subplot(111, axisbg='lightgrey') if plot_type == 'rate' or plot_type == None: day_bins = arange(t_min, t_max, t_inc) DER, DER_bes = histogram(dt_data, day_bins) if dt_data[0] > 693500: ax1.bar(mdates.num2date(day_bins[:-1]), DER, width=t_inc, color='darkslategrey', edgecolor='darkslategrey') ax1.set_xlabel('Date', fontsize=8) else: ax1.bar(day_bins[:-1], DER, width=t_inc, color='darkslategrey', edgecolor='darkslategrey') ax1.set_xlabel('Day', fontsize=8) ax1.set_ylabel('Daily number of earthquakes', fontsize=8) if plot_type == 'cumulative' or plot_type == None: if plot_type == None: ax2 = ax1.twinx() else: ax2 = ax1 if dt_data[0] > 693500: ax2.plot(mdates.num2date(dt_data), arange(len(dt_data)) + 1, 'k') else: ax2.plot(dt_data, arange(len(dt_data)) + 1, 'k') ax2.set_ylabel('Total earthquakes', fontsize=8) ax1.xaxis.set_ticks_position('bottom') if getattr(obj1, 'evd') != None: eruption_starts = atleast_2d( obj1.evd.dataset)[:, obj1.evd.header.index('start_datetime')] for i in range(len(eruption_starts)): if dt_data[0] > 693500: ax1.axvline(mdates.num2date(eruption_starts[i]), color='red', linestyle='--') else: ax1.axvline(eruption_starts[i], color='red', linestyle='--') ax1.set_xlim(t_min, t_max) if Save is not None: if Name is None: timestamp = str(time.time()) else: timestamp = Name png_name = obj1.figure_path + '/ecd_rate_plot-' + timestamp + '.png' eps_name = obj1.figure_path + '/ecd_rate_plot-' + timestamp + '.eps' if 'ecd_rate_plot' not in obj1.figures.keys(): obj1.figures['ecd_rate_plot'] = [] obj1.figures['ecd_rate_plot'].append(png_name) obj1.figures['ecd_rate_plot'].append(eps_name) plt.savefig(png_name) plt.savefig(eps_name) return fig1
#4 mag_comp = 'GFT' #method for magnitude filtering. 'None' is no filtering #5 model = 'iol_mle' #name of model to apply. Could do many??? #Setup Varpy object d1 = core.Volcanic(ID) #Add data to Varpy object d1.add_datatype('ecvd',ecvd_data_file, ecvd_metadata_file) #Set-up times to run model try: t_min=conversion.date2int(t_min) t_max=conversion.date2int(t_max) except: t_min = float(t_min) t_max = float(t_max) pass times = linspace(t_min, t_max, t_step) #Run forecasts in a loop... for t_forc in times: print "iter" print t_forc #Maybe update object d1 here???? #1. Apply spatial filter #May need a "None" option here
def plot_map(obj1, boundary=None, colour=None, t_lims=None, lon_lims=None, lat_lims=None, z_lims=None, Mc=None): """ Plot a map of ecvd locations Args: obj1: a varpy object containing ecvd data colour: variable to define colour scale (e.g. 'depth') boundary: a list of lon_min, lon_max, lat_min, lat_max t_lims: [t_min, t_max] defining time axis limits lon_lims: [lon_min, lon_max] defining x-axis limits lat_lims: [lat_min, lat_max] defining y-axis limits z_lims: [z_min, z_max] defining depth range Mc: magnitude cut-off Returns: fig1: a png image of the resulting plot """ data = obj1.ecvd.dataset header = obj1.ecvd.header if t_lims is not None: try: t_min=conversion.date2int(t_lims[0]) t_max=conversion.date2int(t_lims[1]) except: t_min = float(t_lims[0]) t_max = float(t_lims[1]) pass data = data[logical_and(data[:,header.index('datetime')]>=t_min,data[:,header.index('datetime')]<t_max),:] if lon_lims is not None: data = data[logical_and(data[:,header.index('longitude')]>=lon_lims[0],data[:,header.index('longitude')]<lon_lims[1]),:] if lat_lims is not None: data = data[logical_and(data[:,header.index('latitude')]>=lat_lims[0],data[:,header.index('latitude')]<lat_lims[1]),:] if z_lims is not None: data = data[logical_and(data[:,header.index('depth')]>=z_lims[0],data[:,header.index('depth')]<z_lims[1]),:] if Mc is not None: data = data[data[:,header.index('magnitude')]>=Mc,:] if colour == None: c_val = 'blue' else: cvar_column = header.index(colour) c_val = data[:,cvar_column] lats = data[:,header.index('latitude')] lons = data[:,header.index('longitude')] if boundary == None: lon_min = lons.min() lon_max = lons.max() lat_min = lats.min() lat_max = lats.max() else: lon_min = boundary[0] lon_max = boundary[1] lat_min = boundary[2] lat_max = boundary[3] m = Basemap(llcrnrlon=lon_min, llcrnrlat=lat_min, urcrnrlon=lon_max, urcrnrlat=lat_max, resolution='h',projection='tmerc',lon_0=lon_max +(lon_max-lon_min)/2.,lat_0=lat_max +(lat_max-lat_min)/2.) m.drawcoastlines() x,y = m(lons,lats) m.scatter(x,y, s=10, c=c_val, marker='o', edgecolor='none') delta = 0.001 parallels = arange(around(lat_min,1),around(lat_max,1),delta) meridians = arange(around(lon_min,1),around(lon_max,1),delta) while logical_or(len(parallels)>10,len(meridians)>10,): delta = delta*10 parallels = arange(around(lat_min,1),around(lat_max,1),delta) meridians = arange(around(lon_min,1),around(lon_max,1),delta) m.drawparallels(parallels,labels=[1,0,0,1]) m.drawmeridians(meridians,labels=[1,0,0,1]) m.drawmapboundary(fill_color='lightgrey') #m.fillcontinents(color='grey',lake_color='aqua') #m.readshapefile('../Data/100m_contours', 'Contours') png_name=obj1.figure_path+'/map.png' eps_name=obj1.figure_path+'/map.eps' plt.savefig(png_name) plt.savefig(eps_name) #
def rate_histogram(obj1, model=None, interval=None, t_lims=None, lon_lims=None, lat_lims=None, z_lims=None, Mc=None): """ Plot a histogram of earthquake rates Args: obj1: a varpy object containing event catalogue data model: option to fit and bootstrap CoIs for model. Existing options: Poisson interval: bin width (default is daily) t_lims: [t_min, t_max] defining time axis limits lon_lims: [lon_min, lon_max] defining x-axis limits lat_lims: [lat_min, lat_max] defining y-axis limits z_lims: [z_min, z_max] defining depth range Mc: magnitude cut-off Returns: fig1: a png image of the resulting plot """ if obj1.type == 'volcanic': data = obj1.ecvd.dataset header = obj1.ecvd.header else: data = obj1.ecld.dataset header = obj1.ecld.header if t_lims is not None: try: t_min = conversion.date2int(t_lims[0]) t_max = conversion.date2int(t_lims[1]) except: t_min = float(t_lims[0]) t_max = float(t_lims[1]) pass data = data[logical_and(data[:, header.index('datetime')] >= t_min, data[:, header.index('datetime')] < t_max), :] if lon_lims is not None: data = data[ logical_and(data[:, header.index('longitude')] >= lon_lims[0], data[:, header.index('longitude')] < lon_lims[1]), :] if lat_lims is not None: data = data[ logical_and(data[:, header.index('latitude')] >= lat_lims[0], data[:, header.index('latitude')] < lat_lims[1]), :] if z_lims is not None: data = data[logical_and(data[:, header.index('depth')] >= z_lims[0], data[:, header.index('depth')] < z_lims[1]), :] if Mc is not None: data = data[data[:, header.index('magnitude')] >= Mc, :] dt_data = data[:, header.index('datetime')] if t_lims is None: t_min = floor(dt_data.min()) t_max = ceil(dt_data.max()) if interval is not None: bin_width = interval else: bin_width = 1. der_bins = arange(t_min, t_max + bin_width, bin_width) ders, der_bes = histogram(dt_data, der_bins) rate_bins = arange(-0.5, ders.max() + 1.5) mid_rate_bins = rate_bins[:-1] + diff(rate_bins) / 2. rate_freqs, rate_bes = histogram(ders, rate_bins) fig1 = plt.figure(1, figsize=(8, 6)) ax1 = fig1.add_subplot(111, axisbg='lightgrey') ax1.bar(mid_rate_bins, rate_freqs, color='grey', edgecolor='darkgrey', align='center') if model is not None: der_mean = mean(ders) #Bootstrap 95% COIs rate_bstps = 1000 rates_bstps = zeros((len(rate_bins) - 1, rate_bstps)) for j in range(rate_bstps): if model is 'Poisson': model_sim = poisson.rvs(der_mean, size=len(ders)) rates_bstps[:, j], model_bes = histogram(model_sim, rate_bins) poisson_coi_95 = scoreatpercentile(rates_bstps.transpose(), 95, axis=0) poisson_coi_5 = scoreatpercentile(rates_bstps.transpose(), 5, axis=0) ax1.plot( mid_rate_bins, poisson.pmf(mid_rate_bins, der_mean) * diff(rate_bins) * len(ders), '-or') ax1.plot(mid_rate_bins, poisson_coi_95, 'r:') ax1.plot(mid_rate_bins, poisson_coi_5, 'r:') ax1.set_xlabel('Rate', fontsize=8) ax1.set_ylabel('Frequency', fontsize=8) ax1.xaxis.set_ticks_position('bottom') png_name = obj1.figure_path + '/rate_histogram.png' eps_name = obj1.figure_path + '/rate_histogram.eps' plt.savefig(png_name) plt.savefig(eps_name)
#3. Time variabl3s t_step = 1.0 #time between model applications, in days (for ecvd, maybe minutes for ecld?). #If None means single application #4 mag_comp = 'GFT' #method for magnitude filtering. 'None' is no filtering #5 model = 'iol_mle' #name of model to apply. #Setup Varpy object d1 = core.Volcanic(ID) #Add data to Varpy object d1.add_datatype('ecvd', ecvd_data_file, ecvd_metadata_file) #time limits have not been specified, therefore we are in prospective mode t_min = conversion.date2int(date.today().strftime("%d-%m-%Y")) t_max_a = date.today() + timedelta(days=100) t_max = conversion.date2int(t_max_a.strftime("%d-%m-%Y")) times = linspace(t_min, t_max, t_step) #Run forecasts in a loop... for t_forc in times: #Maybe update object d1 here???? #1. Apply spatial filter #May need a "None" option here d2 = window.latlon(d1, lat_min, lat_max, lon_min, lon_max) #2. Apply depth filter #May need a "None" option here d3 = window.single_attribute(d2, 'depth', z_min, z_max, 'ecvd') #3. Select time window
def model_error_plot(obj1, data_type, model_name, t_lims=None, percentiles=None, n_bs=None): if data_type is 'ecvd' or 'ecld': #1. Determine t_min and t_max - check these aren't stored in model information... if t_lims is not None: try: t_min=conversion.date2int(t_lims[0]) t_max=conversion.date2int(t_lims[1]) except: t_min = float(t_lims[0]) t_max = float(t_lims[1]) pass else: if obj1.type == 'volcanic': data = obj1.ecvd.dataset header = obj1.ecvd.header else: data = obj1.ecld.dataset header = obj1.ecld.header dt_data = data[:,header.index('datetime')] t_min = floor(dt_data.min()) t_max = ceil(dt_data.max()) t_inc = (t_max-t_min)/11. fig1 = plt.figure(1, figsize=(8,6)) ax1 = fig1.add_subplot(111, axisbg='lightgrey') rate_bins = linspace(t_min, t_max, 11) mid_bins = rate_bins[:-1] + diff(rate_bins)/2. DER, DER_bes = histogram(dt_data, rate_bins) if dt_data[0]>693500: ax1.plot(mdates.num2date(mid_bins), DER, 'o') ax1.set_xlabel('Date', fontsize=8) else: ax1.plot(mid_bins, DER, 'o') ax1.set_xlabel('Day', fontsize=8) ax1.set_ylabel('rate of earthquakes', fontsize=8) #4. Create series of times between t_max, t_min to evaulate model rate, totals times = linspace(t_min, t_max, 500) for model in getattr(obj1,data_type).models.keys(): m0=getattr(obj1,data_type).models[model].outputs for m1 in m0: #6. For each model, get parameters params = m1.dataset rate_func = m1.metadata['rate_func'] rates = getattr(rate_funcs, rate_func[0])(times-t_min, params) ax1.plot(times, rates*t_inc, '-r') #Bootstrap confidence limits coi_l, coi_u = model_stats.model_CoIs(rate_func, params, rate_bins, percentiles, n_bs) ax1.plot(mid_bins, coi_l, 'r:') ax1.plot(mid_bins, coi_u, 'r:') else: #Alternative for SCVD, SCLD data? print 'SCLD and SCVD data not currently supported' ax1.set_xlim(t_min, t_max) png_name=obj1.figure_path+'/model_plot.png' eps_name=obj1.figure_path+'/model_plot.eps' plt.savefig(png_name) plt.savefig(eps_name) #
def mag_mc_plot(obj1, colour=None, y_lims=None, t_lims=None, lon_lims=None, lat_lims=None, z_lims=None): """ Plot the evolution of magntiudes with time, and show completeness magnitudes Args: obj1: a varpy object containing variable: the ecvd variable to plot as a function of time colour: variable to define colour scale y_lims: [y_min, y_max] defining y-axis limits t_lims: [t_min, t_max] defining time axis limits lon_lims: [lon_min, lon_max] defining x-axis limits lat_lims: [lat_min, lat_max] defining y-axis limits z_lims: [z_min, z_max] defining depth range Returns: fig1: a png image of the resulting plot """ if obj1.type == 'volcanic': data = obj1.ecvd.dataset header = obj1.ecvd.header else: data = obj1.ecld.dataset header = obj1.ecld.header if t_lims is not None: try: t_min = conversion.date2int(t_lims[0]) t_max = conversion.date2int(t_lims[1]) except: t_min = float(t_lims[0]) t_max = float(t_lims[1]) pass data = data[logical_and(data[:, header.index('datetime')] >= t_min, data[:, header.index('datetime')] < t_max), :] if lon_lims is not None: data = data[ logical_and(data[:, header.index('longitude')] >= lon_lims[0], data[:, header.index('longitude')] < lon_lims[1]), :] if lat_lims is not None: data = data[ logical_and(data[:, header.index('latitude')] >= lat_lims[0], data[:, header.index('latitude')] < lat_lims[1]), :] if z_lims is not None: data = data[logical_and(data[:, header.index('depth')] >= z_lims[0], data[:, header.index('depth')] < z_lims[1]), :] dt_data = data[:, header.index('datetime')] mag_data = data[:, header.index('magnitude')] if t_lims is None: t_min = floor(dt_data.min()) t_max = ceil(dt_data.max()) if y_lims is None: y_lims = [mag_data.min(), mag_data.max()] c_val = 'blue' #default if colour is not None: cvar_column = header.index(colour) c_val = data[:, cvar_column] GFT = mags.mc_GFT(mag_data, 0.1, 0.1) MBS = mags.mc_mbs(mag_data, 0.1, 0.1) mc_maxc = mags.mc_maxc(mag_data, 0.1, 0.1) mc_GFT = GFT.Mc_GFT mc_mbs = MBS.Mc_mbs fig1 = plt.figure(1, figsize=(8, 6)) ax1 = fig1.add_subplot(111, axisbg='lightgrey') if dt_data[0] > 693500: ax1.scatter(mdates.num2date(dt_data), mag_data, marker='o', s=9, c=c_val, edgecolor='none') ax1.set_xlabel('Date', fontsize=8) else: ax1.scatter(dt_data, mag_data, marker='o', s=9, c='blue', edgecolor='none') ax1.set_xlabel('Day', fontsize=8) ax1.set_ylabel('Magnitude', fontsize=8) ax1.xaxis.set_ticks_position('bottom') ax1.set_xlim(t_min, t_max) ax1.set_ylim(y_lims[0], y_lims[1]) ax1.axhline(mc_maxc, color='red', ls='--') ax1.axhline(mc_GFT, color='green', ls='--') ax1.axhline(mc_mbs, color='blue', ls='--') png_name = obj1.figure_path + '/M_time_plot.png' eps_name = obj1.figure_path + '/M_time_plot.eps' plt.savefig(png_name) plt.savefig(eps_name)
def mag_mc_plot(obj1, colour=None, y_lims=None, t_lims=None, lon_lims=None, lat_lims=None, z_lims=None): """ Plot the evolution of magntiudes with time, and show completeness magnitudes Args: obj1: a varpy object containing variable: the ecvd variable to plot as a function of time colour: variable to define colour scale y_lims: [y_min, y_max] defining y-axis limits t_lims: [t_min, t_max] defining time axis limits lon_lims: [lon_min, lon_max] defining x-axis limits lat_lims: [lat_min, lat_max] defining y-axis limits z_lims: [z_min, z_max] defining depth range Returns: fig1: a png image of the resulting plot """ if obj1.type == 'volcanic': data = obj1.ecvd.dataset header = obj1.ecvd.header else: data = obj1.ecld.dataset header = obj1.ecld.header if t_lims is not None: try: t_min=conversion.date2int(t_lims[0]) t_max=conversion.date2int(t_lims[1]) except: t_min = float(t_lims[0]) t_max = float(t_lims[1]) pass data = data[logical_and(data[:,header.index('datetime')]>=t_min,data[:,header.index('datetime')]<t_max),:] if lon_lims is not None: data = data[logical_and(data[:,header.index('longitude')]>=lon_lims[0],data[:,header.index('longitude')]<lon_lims[1]),:] if lat_lims is not None: data = data[logical_and(data[:,header.index('latitude')]>=lat_lims[0],data[:,header.index('latitude')]<lat_lims[1]),:] if z_lims is not None: data = data[logical_and(data[:,header.index('depth')]>=z_lims[0],data[:,header.index('depth')]<z_lims[1]),:] dt_data = data[:,header.index('datetime')] mag_data = data[:,header.index('magnitude')] if t_lims is None: t_min = floor(dt_data.min()) t_max = ceil(dt_data.max()) if y_lims is None: y_lims = [mag_data.min(), mag_data.max()] c_val = 'blue' #default if colour is not None: cvar_column = header.index(colour) c_val = data[:,cvar_column] GFT = mags.mc_GFT(mag_data, 0.1, 0.1) MBS = mags.mc_mbs(mag_data, 0.1, 0.1) mc_maxc = mags.mc_maxc(mag_data, 0.1, 0.1) mc_GFT = GFT.Mc_GFT mc_mbs = MBS.Mc_mbs fig1 = plt.figure(1, figsize=(8,6)) ax1 = fig1.add_subplot(111,axisbg='lightgrey') if dt_data[0]>693500: ax1.scatter(mdates.num2date(dt_data), mag_data, marker='o', s=9, c=c_val, edgecolor='none') ax1.set_xlabel('Date', fontsize=8) else: ax1.scatter(dt_data, mag_data, marker='o', s=9, c='blue', edgecolor='none') ax1.set_xlabel('Day', fontsize=8) ax1.set_ylabel('Magnitude', fontsize=8) ax1.xaxis.set_ticks_position('bottom') ax1.set_xlim(t_min,t_max) ax1.set_ylim(y_lims[0],y_lims[1]) ax1.axhline(mc_maxc, color='red', ls = '--') ax1.axhline(mc_GFT, color='green', ls = '--') ax1.axhline(mc_mbs, color='blue', ls = '--') png_name=obj1.figure_path+'/M_time_plot.png' eps_name=obj1.figure_path+'/M_time_plot.eps' plt.savefig(png_name) plt.savefig(eps_name)
def plot_map(obj1, boundary=None, colour=None, t_lims=None, lon_lims=None, lat_lims=None, z_lims=None, Mc=None): """ Plot a map of ecvd locations Args: obj1: a varpy object containing ecvd data colour: variable to define colour scale (e.g. 'depth') boundary: a list of lon_min, lon_max, lat_min, lat_max t_lims: [t_min, t_max] defining time axis limits lon_lims: [lon_min, lon_max] defining x-axis limits lat_lims: [lat_min, lat_max] defining y-axis limits z_lims: [z_min, z_max] defining depth range Mc: magnitude cut-off Returns: fig1: a png image of the resulting plot """ data = obj1.ecvd.dataset header = obj1.ecvd.header if t_lims is not None: try: t_min = conversion.date2int(t_lims[0]) t_max = conversion.date2int(t_lims[1]) except: t_min = float(t_lims[0]) t_max = float(t_lims[1]) pass data = data[logical_and(data[:, header.index('datetime')] >= t_min, data[:, header.index('datetime')] < t_max), :] if lon_lims is not None: data = data[ logical_and(data[:, header.index('longitude')] >= lon_lims[0], data[:, header.index('longitude')] < lon_lims[1]), :] if lat_lims is not None: data = data[ logical_and(data[:, header.index('latitude')] >= lat_lims[0], data[:, header.index('latitude')] < lat_lims[1]), :] if z_lims is not None: data = data[logical_and(data[:, header.index('depth')] >= z_lims[0], data[:, header.index('depth')] < z_lims[1]), :] if Mc is not None: data = data[data[:, header.index('magnitude')] >= Mc, :] if colour == None: c_val = 'blue' else: cvar_column = header.index(colour) c_val = data[:, cvar_column] lats = data[:, header.index('latitude')] lons = data[:, header.index('longitude')] if boundary == None: lon_min = lons.min() lon_max = lons.max() lat_min = lats.min() lat_max = lats.max() else: lon_min = boundary[0] lon_max = boundary[1] lat_min = boundary[2] lat_max = boundary[3] m = Basemap(llcrnrlon=lon_min, llcrnrlat=lat_min, urcrnrlon=lon_max, urcrnrlat=lat_max, resolution='h', projection='tmerc', lon_0=lon_max + (lon_max - lon_min) / 2., lat_0=lat_max + (lat_max - lat_min) / 2.) m.drawcoastlines() x, y = m(lons, lats) m.scatter(x, y, s=10, c=c_val, marker='o', edgecolor='none') delta = 0.001 parallels = arange(around(lat_min, 1), around(lat_max, 1), delta) meridians = arange(around(lon_min, 1), around(lon_max, 1), delta) while logical_or( len(parallels) > 10, len(meridians) > 10, ): delta = delta * 10 parallels = arange(around(lat_min, 1), around(lat_max, 1), delta) meridians = arange(around(lon_min, 1), around(lon_max, 1), delta) m.drawparallels(parallels, labels=[1, 0, 0, 1]) m.drawmeridians(meridians, labels=[1, 0, 0, 1]) m.drawmapboundary(fill_color='lightgrey') #m.fillcontinents(color='grey',lake_color='aqua') #m.readshapefile('../Data/100m_contours', 'Contours') png_name = obj1.figure_path + '/map.png' eps_name = obj1.figure_path + '/map.eps' plt.savefig(png_name) plt.savefig(eps_name)