Datasets:

unum-cloud

/

ann-codesearch-4m

like 0

[ "def", "plot_depth_histogram", "(", "catalogue", ",", "bin_width", ",", "normalisation", "=", "False", ",", "bootstrap", "=", "None", ",", "filename", "=", "None", ",", "figure_size", "=", "(", "8", ",", "6", ")", ",", "filetype", "=", "'png'", ",", "dpi", "=", "300", ",", "ax", "=", "None", ")", ":", "if", "ax", "is", "None", ":", "fig", ",", "ax", "=", "plt", ".", "subplots", "(", "figsize", "=", "figure_size", ")", "else", ":", "fig", "=", "ax", ".", "get_figure", "(", ")", "# Create depth range", "if", "len", "(", "catalogue", ".", "data", "[", "'depth'", "]", ")", "==", "0", ":", "# pylint: disable=len-as-condition", "raise", "ValueError", "(", "'No depths reported in catalogue!'", ")", "depth_bins", "=", "np", ".", "arange", "(", "0.", ",", "np", ".", "max", "(", "catalogue", ".", "data", "[", "'depth'", "]", ")", "+", "bin_width", ",", "bin_width", ")", "depth_hist", "=", "catalogue", ".", "get_depth_distribution", "(", "depth_bins", ",", "normalisation", ",", "bootstrap", ")", "ax", ".", "bar", "(", "depth_bins", "[", ":", "-", "1", "]", ",", "depth_hist", ",", "width", "=", "0.95", "*", "bin_width", ",", "edgecolor", "=", "'k'", ")", "ax", ".", "set_xlabel", "(", "'Depth (km)'", ")", "if", "normalisation", ":", "ax", ".", "set_ylabel", "(", "'Probability Mass Function'", ")", "else", ":", "ax", ".", "set_ylabel", "(", "'Count'", ")", "ax", ".", "set_title", "(", "'Depth Histogram'", ")", "_save_image", "(", "fig", ",", "filename", ",", "filetype", ",", "dpi", ")" ]

[ "Creates", "a", "histogram", "of", "the", "depths", "in", "the", "catalogue" ]

[ "def", "plot_magnitude_depth_density", "(", "catalogue", ",", "mag_int", ",", "depth_int", ",", "logscale", "=", "False", ",", "normalisation", "=", "False", ",", "bootstrap", "=", "None", ",", "filename", "=", "None", ",", "figure_size", "=", "(", "8", ",", "6", ")", ",", "filetype", "=", "'png'", ",", "dpi", "=", "300", ",", "ax", "=", "None", ")", ":", "if", "len", "(", "catalogue", ".", "data", "[", "'depth'", "]", ")", "==", "0", ":", "# pylint: disable=len-as-condition", "raise", "ValueError", "(", "'No depths reported in catalogue!'", ")", "depth_bins", "=", "np", ".", "arange", "(", "0.", ",", "np", ".", "max", "(", "catalogue", ".", "data", "[", "'depth'", "]", ")", "+", "depth_int", ",", "depth_int", ")", "mag_bins", "=", "_get_catalogue_bin_limits", "(", "catalogue", ",", "mag_int", ")", "mag_depth_dist", "=", "catalogue", ".", "get_magnitude_depth_distribution", "(", "mag_bins", ",", "depth_bins", ",", "normalisation", ",", "bootstrap", ")", "vmin_val", "=", "np", ".", "min", "(", "mag_depth_dist", "[", "mag_depth_dist", ">", "0.", "]", ")", "if", "ax", "is", "None", ":", "fig", ",", "ax", "=", "plt", ".", "subplots", "(", "figsize", "=", "figure_size", ")", "else", ":", "fig", "=", "ax", ".", "get_figure", "(", ")", "if", "logscale", ":", "normaliser", "=", "LogNorm", "(", "vmin", "=", "vmin_val", ",", "vmax", "=", "np", ".", "max", "(", "mag_depth_dist", ")", ")", "else", ":", "normaliser", "=", "Normalize", "(", "vmin", "=", "0", ",", "vmax", "=", "np", ".", "max", "(", "mag_depth_dist", ")", ")", "im", "=", "ax", ".", "pcolor", "(", "mag_bins", "[", ":", "-", "1", "]", ",", "depth_bins", "[", ":", "-", "1", "]", ",", "mag_depth_dist", ".", "T", ",", "norm", "=", "normaliser", ")", "ax", ".", "set_xlabel", "(", "'Magnitude'", ")", "ax", ".", "set_ylabel", "(", "'Depth (km)'", ")", "ax", ".", "set_xlim", "(", "mag_bins", "[", "0", "]", ",", "mag_bins", "[", "-", "1", "]", ")", "ax", ".", "set_ylim", "(", "depth_bins", "[", "0", "]", ",", "depth_bins", "[", "-", "1", "]", ")", "fig", ".", "colorbar", "(", "im", ",", "ax", "=", "ax", ")", "if", "normalisation", ":", "ax", ".", "set_title", "(", "'Magnitude-Depth Density'", ")", "else", ":", "ax", ".", "set_title", "(", "'Magnitude-Depth Count'", ")", "_save_image", "(", "fig", ",", "filename", ",", "filetype", ",", "dpi", ")" ]

[ "Creates", "a", "density", "plot", "of", "the", "magnitude", "and", "depth", "distribution" ]

[ "def", "plot_magnitude_time_scatter", "(", "catalogue", ",", "plot_error", "=", "False", ",", "fmt_string", "=", "'o'", ",", "filename", "=", "None", ",", "figure_size", "=", "(", "8", ",", "6", ")", ",", "filetype", "=", "'png'", ",", "dpi", "=", "300", ",", "ax", "=", "None", ")", ":", "if", "ax", "is", "None", ":", "fig", ",", "ax", "=", "plt", ".", "subplots", "(", "figsize", "=", "figure_size", ")", "else", ":", "fig", "=", "ax", ".", "get_figure", "(", ")", "dtime", "=", "catalogue", ".", "get_decimal_time", "(", ")", "# pylint: disable=len-as-condition", "if", "len", "(", "catalogue", ".", "data", "[", "'sigmaMagnitude'", "]", ")", "==", "0", ":", "print", "(", "'Magnitude Error is missing - neglecting error bars!'", ")", "plot_error", "=", "False", "if", "plot_error", ":", "ax", ".", "errorbar", "(", "dtime", ",", "catalogue", ".", "data", "[", "'magnitude'", "]", ",", "xerr", "=", "None", ",", "yerr", "=", "catalogue", ".", "data", "[", "'sigmaMagnitude'", "]", ",", "fmt", "=", "fmt_string", ")", "else", ":", "ax", ".", "plot", "(", "dtime", ",", "catalogue", ".", "data", "[", "'magnitude'", "]", ",", "fmt_string", ")", "ax", ".", "set_xlabel", "(", "'Year'", ")", "ax", ".", "set_ylabel", "(", "'Magnitude'", ")", "ax", ".", "set_title", "(", "'Magnitude-Time Plot'", ")", "_save_image", "(", "fig", ",", "filename", ",", "filetype", ",", "dpi", ")" ]

[ "Creates", "a", "simple", "scatter", "plot", "of", "magnitude", "with", "time" ]

[ "def", "plot_magnitude_time_density", "(", "catalogue", ",", "mag_int", ",", "time_int", ",", "completeness", "=", "None", ",", "normalisation", "=", "False", ",", "logscale", "=", "True", ",", "bootstrap", "=", "None", ",", "xlim", "=", "[", "]", ",", "ylim", "=", "[", "]", ",", "filename", "=", "None", ",", "figure_size", "=", "(", "8", ",", "6", ")", ",", "filetype", "=", "'png'", ",", "dpi", "=", "300", ",", "ax", "=", "None", ")", ":", "if", "ax", "is", "None", ":", "fig", ",", "ax", "=", "plt", ".", "subplots", "(", "figsize", "=", "figure_size", ")", "else", ":", "fig", "=", "ax", ".", "get_figure", "(", ")", "# Create the magnitude bins", "if", "isinstance", "(", "mag_int", ",", "(", "np", ".", "ndarray", ",", "list", ")", ")", ":", "mag_bins", "=", "mag_int", "else", ":", "mag_bins", "=", "np", ".", "arange", "(", "np", ".", "min", "(", "catalogue", ".", "data", "[", "'magnitude'", "]", ")", ",", "np", ".", "max", "(", "catalogue", ".", "data", "[", "'magnitude'", "]", ")", "+", "mag_int", "/", "2.", ",", "mag_int", ")", "# Creates the time bins", "if", "isinstance", "(", "time_int", ",", "(", "np", ".", "ndarray", ",", "list", ")", ")", ":", "time_bins", "=", "time_int", "else", ":", "time_bins", "=", "np", ".", "arange", "(", "float", "(", "np", ".", "min", "(", "catalogue", ".", "data", "[", "'year'", "]", ")", ")", ",", "float", "(", "np", ".", "max", "(", "catalogue", ".", "data", "[", "'year'", "]", ")", ")", "+", "1.", ",", "float", "(", "time_int", ")", ")", "# Get magnitude-time distribution", "mag_time_dist", "=", "catalogue", ".", "get_magnitude_time_distribution", "(", "mag_bins", ",", "time_bins", ",", "normalisation", ",", "bootstrap", ")", "# Get smallest non-zero value", "vmin_val", "=", "np", ".", "min", "(", "mag_time_dist", "[", "mag_time_dist", ">", "0.", "]", ")", "# Create plot", "if", "logscale", ":", "norm_data", "=", "LogNorm", "(", "vmin", "=", "vmin_val", ",", "vmax", "=", "np", ".", "max", "(", "mag_time_dist", ")", ")", "else", ":", "if", "normalisation", ":", "norm_data", "=", "Normalize", "(", "vmin", "=", "vmin_val", ",", "vmax", "=", "np", ".", "max", "(", "mag_time_dist", ")", ")", "else", ":", "norm_data", "=", "Normalize", "(", "vmin", "=", "1.0", ",", "vmax", "=", "np", ".", "max", "(", "mag_time_dist", ")", ")", "im", "=", "ax", ".", "pcolor", "(", "time_bins", "[", ":", "-", "1", "]", ",", "mag_bins", "[", ":", "-", "1", "]", ",", "mag_time_dist", ".", "T", ",", "norm", "=", "norm_data", ")", "ax", ".", "set_xlabel", "(", "'Time (year)'", ")", "ax", ".", "set_ylabel", "(", "'Magnitude'", ")", "if", "len", "(", "xlim", ")", "==", "2", ":", "ax", ".", "set_xlim", "(", "xlim", "[", "0", "]", ",", "xlim", "[", "1", "]", ")", "else", ":", "ax", ".", "set_xlim", "(", "time_bins", "[", "0", "]", ",", "time_bins", "[", "-", "1", "]", ")", "if", "len", "(", "ylim", ")", "==", "2", ":", "ax", ".", "set_ylim", "(", "ylim", "[", "0", "]", ",", "ylim", "[", "1", "]", ")", "else", ":", "ax", ".", "set_ylim", "(", "mag_bins", "[", "0", "]", ",", "mag_bins", "[", "-", "1", "]", "+", "(", "mag_bins", "[", "-", "1", "]", "-", "mag_bins", "[", "-", "2", "]", ")", ")", "# Fix the title", "if", "normalisation", ":", "fig", ".", "colorbar", "(", "im", ",", "label", "=", "'Event Density'", ",", "shrink", "=", "0.9", ",", "ax", "=", "ax", ")", "else", ":", "fig", ".", "colorbar", "(", "im", ",", "label", "=", "'Event Count'", ",", "shrink", "=", "0.9", ",", "ax", "=", "ax", ")", "ax", ".", "grid", "(", "True", ")", "# Plot completeness", "if", "completeness", "is", "not", "None", ":", "_plot_completeness", "(", "ax", ",", "completeness", ",", "time_bins", "[", "0", "]", ",", "time_bins", "[", "-", "1", "]", ")", "_save_image", "(", "fig", ",", "filename", ",", "filetype", ",", "dpi", ")" ]

[ "Creates", "a", "plot", "of", "magnitude", "-", "time", "density" ]

[ "def", "_plot_completeness", "(", "ax", ",", "comw", ",", "start_time", ",", "end_time", ")", ":", "comw", "=", "np", ".", "array", "(", "comw", ")", "comp", "=", "np", ".", "column_stack", "(", "[", "np", ".", "hstack", "(", "[", "end_time", ",", "comw", "[", ":", ",", "0", "]", ",", "start_time", "]", ")", ",", "np", ".", "hstack", "(", "[", "comw", "[", "0", ",", "1", "]", ",", "comw", "[", ":", ",", "1", "]", ",", "comw", "[", "-", "1", ",", "1", "]", "]", ")", "]", ")", "ax", ".", "step", "(", "comp", "[", ":", "-", "1", ",", "0", "]", ",", "comp", "[", "1", ":", ",", "1", "]", ",", "linestyle", "=", "'-'", ",", "where", "=", "\"post\"", ",", "linewidth", "=", "3", ",", "color", "=", "'brown'", ")" ]

[ "Adds", "completeness", "intervals", "to", "a", "plot" ]

[ "def", "get_completeness_adjusted_table", "(", "catalogue", ",", "completeness", ",", "dmag", ",", "offset", "=", "1.0E-5", ",", "end_year", "=", "None", ",", "plot", "=", "False", ",", "figure_size", "=", "(", "8", ",", "6", ")", ",", "filename", "=", "None", ",", "filetype", "=", "'png'", ",", "dpi", "=", "300", ",", "ax", "=", "None", ")", ":", "if", "not", "end_year", ":", "end_year", "=", "catalogue", ".", "end_year", "# Find the natural bin limits", "mag_bins", "=", "_get_catalogue_bin_limits", "(", "catalogue", ",", "dmag", ")", "obs_time", "=", "end_year", "-", "completeness", "[", ":", ",", "0", "]", "+", "1.", "obs_rates", "=", "np", ".", "zeros_like", "(", "mag_bins", ")", "durations", "=", "np", ".", "zeros_like", "(", "mag_bins", ")", "n_comp", "=", "np", ".", "shape", "(", "completeness", ")", "[", "0", "]", "for", "iloc", "in", "range", "(", "n_comp", ")", ":", "low_mag", "=", "completeness", "[", "iloc", ",", "1", "]", "comp_year", "=", "completeness", "[", "iloc", ",", "0", "]", "if", "iloc", "==", "(", "n_comp", "-", "1", ")", ":", "idx", "=", "np", ".", "logical_and", "(", "catalogue", ".", "data", "[", "'magnitude'", "]", ">=", "low_mag", "-", "offset", ",", "catalogue", ".", "data", "[", "'year'", "]", ">=", "comp_year", ")", "high_mag", "=", "mag_bins", "[", "-", "1", "]", "obs_idx", "=", "mag_bins", ">=", "(", "low_mag", "-", "offset", ")", "else", ":", "high_mag", "=", "completeness", "[", "iloc", "+", "1", ",", "1", "]", "mag_idx", "=", "np", ".", "logical_and", "(", "catalogue", ".", "data", "[", "'magnitude'", "]", ">=", "low_mag", "-", "offset", ",", "catalogue", ".", "data", "[", "'magnitude'", "]", "<", "(", "high_mag", "-", "offset", ")", ")", "idx", "=", "np", ".", "logical_and", "(", "mag_idx", ",", "catalogue", ".", "data", "[", "'year'", "]", ">=", "(", "comp_year", "-", "offset", ")", ")", "obs_idx", "=", "np", ".", "logical_and", "(", "mag_bins", ">=", "(", "low_mag", "-", "offset", ")", ",", "mag_bins", "<", "(", "high_mag", "+", "offset", ")", ")", "temp_rates", "=", "np", ".", "histogram", "(", "catalogue", ".", "data", "[", "'magnitude'", "]", "[", "idx", "]", ",", "mag_bins", "[", "obs_idx", "]", ")", "[", "0", "]", "temp_rates", "=", "temp_rates", ".", "astype", "(", "float", ")", "/", "obs_time", "[", "iloc", "]", "obs_rates", "[", "obs_idx", "[", ":", "-", "1", "]", "]", "=", "temp_rates", "durations", "[", "obs_idx", "[", ":", "-", "1", "]", "]", "=", "obs_time", "[", "iloc", "]", "selector", "=", "np", ".", "where", "(", "obs_rates", ">", "0.", ")", "[", "0", "]", "mag_bins", "=", "mag_bins", "[", "selector", "]", "obs_rates", "=", "obs_rates", "[", "selector", "]", "durations", "=", "durations", "[", "selector", "]", "# Get cumulative rates", "cum_rates", "=", "np", ".", "array", "(", "[", "sum", "(", "obs_rates", "[", "iloc", ":", "]", ")", "for", "iloc", "in", "range", "(", "0", ",", "len", "(", "obs_rates", ")", ")", "]", ")", "if", "plot", ":", "plt", ".", "figure", "(", "figsize", "=", "figure_size", ")", "plt", ".", "semilogy", "(", "mag_bins", "+", "dmag", "/", "2.", ",", "obs_rates", ",", "\"bo\"", ",", "label", "=", "\"Incremental\"", ")", "plt", ".", "semilogy", "(", "mag_bins", "+", "dmag", "/", "2.", ",", "cum_rates", ",", "\"rs\"", ",", "label", "=", "\"Cumulative\"", ")", "plt", ".", "xlabel", "(", "\"Magnitude (M)\"", ",", "fontsize", "=", "16", ")", "plt", ".", "ylabel", "(", "\"Annual Rate\"", ",", "fontsize", "=", "16", ")", "plt", ".", "grid", "(", "True", ")", "plt", ".", "legend", "(", "fontsize", "=", "16", ")", "if", "filename", ":", "plt", ".", "savefig", "(", "filename", ",", "format", "=", "filetype", ",", "dpi", "=", "dpi", ",", "bbox_inches", "=", "\"tight\"", ")", "return", "np", ".", "column_stack", "(", "[", "mag_bins", ",", "durations", ",", "obs_rates", ",", "cum_rates", ",", "np", ".", "log10", "(", "cum_rates", ")", "]", ")" ]

[ "Counts", "the", "number", "of", "earthquakes", "in", "each", "magnitude", "bin", "and", "normalises", "the", "rate", "to", "annual", "rates", "taking", "into", "account", "the", "completeness" ]

[ "def", "plot_observed_recurrence", "(", "catalogue", ",", "completeness", ",", "dmag", ",", "end_year", "=", "None", ",", "filename", "=", "None", ",", "figure_size", "=", "(", "8", ",", "6", ")", ",", "filetype", "=", "'png'", ",", "dpi", "=", "300", ",", "ax", "=", "None", ")", ":", "# Get completeness adjusted recurrence table", "if", "isinstance", "(", "completeness", ",", "float", ")", ":", "# Unique completeness", "completeness", "=", "np", ".", "array", "(", "[", "[", "np", ".", "min", "(", "catalogue", ".", "data", "[", "'year'", "]", ")", ",", "completeness", "]", "]", ")", "if", "not", "end_year", ":", "end_year", "=", "catalogue", ".", "update_end_year", "(", ")", "catalogue", ".", "data", "[", "\"dtime\"", "]", "=", "catalogue", ".", "get_decimal_time", "(", ")", "cent_mag", ",", "t_per", ",", "n_obs", "=", "get_completeness_counts", "(", "catalogue", ",", "completeness", ",", "dmag", ")", "obs_rates", "=", "n_obs", "/", "t_per", "cum_obs_rates", "=", "np", ".", "array", "(", "[", "np", ".", "sum", "(", "obs_rates", "[", "i", ":", "]", ")", "for", "i", "in", "range", "(", "len", "(", "obs_rates", ")", ")", "]", ")", "if", "ax", "is", "None", ":", "fig", ",", "ax", "=", "plt", ".", "subplots", "(", "figsize", "=", "figure_size", ")", "else", ":", "fig", "=", "ax", ".", "get_figure", "(", ")", "ax", ".", "semilogy", "(", "cent_mag", ",", "obs_rates", ",", "'bo'", ",", "label", "=", "\"Incremental\"", ")", "ax", ".", "semilogy", "(", "cent_mag", ",", "cum_obs_rates", ",", "'rs'", ",", "label", "=", "\"Cumulative\"", ")", "ax", ".", "set_xlim", "(", "[", "cent_mag", "[", "0", "]", "-", "0.1", ",", "cent_mag", "[", "-", "1", "]", "+", "0.1", "]", ")", "ax", ".", "set_xlabel", "(", "'Magnitude'", ")", "ax", ".", "set_ylabel", "(", "'Annual Rate'", ")", "ax", ".", "legend", "(", ")", "_save_image", "(", "fig", ",", "filename", ",", "filetype", ",", "dpi", ")" ]

[ "Plots", "the", "observed", "recurrence", "taking", "into", "account", "the", "completeness" ]

[ "def", "get_secondary_strain_data", "(", "self", ",", "strain_data", "=", "None", ")", ":", "if", "strain_data", ":", "self", ".", "data", "=", "strain_data", "if", "not", "isinstance", "(", "self", ".", "data", ",", "dict", ")", ":", "raise", "ValueError", "(", "'Strain data not input or incorrectly formatted'", ")", "# Check to ensure essential attributes are in data dictionary", "for", "essential_key", "in", "DATA_VARIABLES", ":", "if", "essential_key", "not", "in", "self", ".", "data", ":", "print", "(", "self", ".", "data", ")", "raise", "ValueError", "(", "'Essential strain information %s missing!'", "%", "essential_key", ")", "self", ".", "data_variables", "=", "deepcopy", "(", "DATA_VARIABLES", ")", "# Second Invarient", "self", ".", "data", "[", "'2nd_inv'", "]", "=", "np", ".", "sqrt", "(", "(", "self", ".", "data", "[", "'exx'", "]", "**", "2.", ")", "+", "(", "self", ".", "data", "[", "'eyy'", "]", "**", "2.", ")", "+", "2.0", "*", "(", "self", ".", "data", "[", "'exy'", "]", "**", "2.", ")", ")", "# Dilatation", "self", ".", "data", "[", "'dilatation'", "]", "=", "self", ".", "data", "[", "'exx'", "]", "+", "self", ".", "data", "[", "'eyy'", "]", "# err", "self", ".", "data", "[", "'err'", "]", "=", "-", "1.", "*", "self", ".", "data", "[", "'dilatation'", "]", "center_normal_rate", "=", "(", "self", ".", "data", "[", "'exx'", "]", "+", "self", ".", "data", "[", "'eyy'", "]", ")", "/", "2.", "radius_rate", "=", "np", ".", "sqrt", "(", "(", "self", ".", "data", "[", "'exx'", "]", "-", "center_normal_rate", ")", "**", "2.", "+", "(", "self", ".", "data", "[", "'exy'", "]", "**", "2.", ")", ")", "# e1h and e2h", "self", ".", "data", "[", "'e1h'", "]", "=", "center_normal_rate", "-", "radius_rate", "self", ".", "data", "[", "'e2h'", "]", "=", "center_normal_rate", "+", "radius_rate", "self", ".", "data", "[", "'area'", "]", "=", "np", ".", "zeros", "(", "self", ".", "get_number_observations", "(", ")", ")", "self", ".", "data_variables", ".", "extend", "(", "[", "'2nd_inv'", ",", "'dilatation'", ",", "'err'", ",", "'e1h'", ",", "'e2h'", "]", ")" ]

[ "Calculate", "the", "following", "and", "add", "to", "data", "dictionary", ":", "1", ")", "2nd", "invarient", "of", "strain", "2", ")", "Dilatation", "rate", "3", ")", "e1h", "and", "e2h", "4", ")", "err" ]

[ "def", "get_number_observations", "(", "self", ")", ":", "if", "isinstance", "(", "self", ".", "data", ",", "dict", ")", "and", "(", "'exx'", "in", "self", ".", "data", ".", "keys", "(", ")", ")", ":", "return", "len", "(", "self", ".", "data", "[", "'exx'", "]", ")", "else", ":", "return", "0" ]

[ "Returns", "the", "number", "of", "observations", "in", "the", "data", "file" ]

[ "def", "plot_lc", "(", "calc_id", ",", "aid", "=", "None", ")", ":", "# read the hazard data", "dstore", "=", "util", ".", "read", "(", "calc_id", ")", "dset", "=", "dstore", "[", "'agg_curves-rlzs'", "]", "if", "aid", "is", "None", ":", "# plot the global curves", "plt", "=", "make_figure", "(", "dset", ".", "attrs", "[", "'return_periods'", "]", ",", "dset", ".", "value", ")", "else", ":", "sys", ".", "exit", "(", "'Not implemented yet'", ")", "plt", ".", "show", "(", ")" ]

[ "Plot", "loss", "curves", "given", "a", "calculation", "id", "and", "an", "asset", "ordinal", "." ]

[ "def", "nga_west2_epistemic_adjustment", "(", "magnitude", ",", "distance", ")", ":", "if", "magnitude", "<", "6.0", ":", "adjustment", "=", "0.22", "*", "np", ".", "ones_like", "(", "distance", ")", "adjustment", "[", "distance", "<", "10.0", "]", "=", "0.37", "elif", "magnitude", ">=", "7.0", ":", "adjustment", "=", "0.36", "*", "np", ".", "ones_like", "(", "distance", ")", "adjustment", "[", "distance", "<", "10.0", "]", "=", "0.40", "adjustment", "[", "distance", ">=", "30.0", "]", "=", "0.33", "else", ":", "adjustment", "=", "0.23", "*", "np", ".", "ones_like", "(", "distance", ")", "adjustment", "[", "distance", "<", "10.0", "]", "=", "0.25", "return", "adjustment" ]

[ "Applies", "the", "average", "adjustment", "factor", "for", "epistemic", "uncertainty", "as", "defined", "in", "Table", "17", "of", "Petersen", "et", "al", ".", "(", "2014", ")", "::" ]

[ "def", "get_weighted_poes", "(", "gsim", ",", "sctx", ",", "rctx", ",", "dctx", ",", "imt", ",", "imls", ",", "truncation_level", ",", "weighting", "=", "DEFAULT_WEIGHTING", ")", ":", "if", "truncation_level", "is", "not", "None", "and", "truncation_level", "<", "0", ":", "raise", "ValueError", "(", "'truncation level must be zero, positive number '", "'or None'", ")", "gsim", ".", "_check_imt", "(", "imt", ")", "adjustment", "=", "nga_west2_epistemic_adjustment", "(", "rctx", ".", "mag", ",", "dctx", ".", "rrup", ")", "adjustment", "=", "adjustment", ".", "reshape", "(", "adjustment", ".", "shape", "+", "(", "1", ",", ")", ")", "if", "truncation_level", "==", "0", ":", "# zero truncation mode, just compare imls to mean", "imls", "=", "gsim", ".", "to_distribution_values", "(", "imls", ")", "mean", ",", "_", "=", "gsim", ".", "get_mean_and_stddevs", "(", "sctx", ",", "rctx", ",", "dctx", ",", "imt", ",", "[", "]", ")", "mean", "=", "mean", ".", "reshape", "(", "mean", ".", "shape", "+", "(", "1", ",", ")", ")", "output", "=", "np", ".", "zeros", "(", "[", "mean", ".", "shape", "[", "0", "]", ",", "imls", ".", "shape", "[", "0", "]", "]", ")", "for", "(", "wgt", ",", "fct", ")", "in", "weighting", ":", "output", "+=", "(", "wgt", "*", "(", "imls", "<=", "(", "mean", "+", "(", "fct", "*", "adjustment", ")", ")", ")", ".", "astype", "(", "float", ")", ")", "return", "output", "else", ":", "# use real normal distribution", "assert", "(", "const", ".", "StdDev", ".", "TOTAL", "in", "gsim", ".", "DEFINED_FOR_STANDARD_DEVIATION_TYPES", ")", "imls", "=", "gsim", ".", "to_distribution_values", "(", "imls", ")", "mean", ",", "[", "stddev", "]", "=", "gsim", ".", "get_mean_and_stddevs", "(", "sctx", ",", "rctx", ",", "dctx", ",", "imt", ",", "[", "const", ".", "StdDev", ".", "TOTAL", "]", ")", "mean", "=", "mean", ".", "reshape", "(", "mean", ".", "shape", "+", "(", "1", ",", ")", ")", "stddev", "=", "stddev", ".", "reshape", "(", "stddev", ".", "shape", "+", "(", "1", ",", ")", ")", "output", "=", "np", ".", "zeros", "(", "[", "mean", ".", "shape", "[", "0", "]", ",", "imls", ".", "shape", "[", "0", "]", "]", ")", "for", "(", "wgt", ",", "fct", ")", "in", "weighting", ":", "values", "=", "(", "imls", "-", "(", "mean", "+", "(", "fct", "*", "adjustment", ")", ")", ")", "/", "stddev", "if", "truncation_level", "is", "None", ":", "output", "+=", "(", "wgt", "*", "_norm_sf", "(", "values", ")", ")", "else", ":", "output", "+=", "(", "wgt", "*", "_truncnorm_sf", "(", "truncation_level", ",", "values", ")", ")", "return", "output" ]

[ "This", "function", "implements", "the", "NGA", "West", "2", "GMPE", "epistemic", "uncertainty", "adjustment", "factor", "without", "re", "-", "calculating", "the", "actual", "GMPE", "each", "time", "." ]

[ "def", "get_mean_and_stddevs", "(", "self", ",", "sctx", ",", "rctx", ",", "dctx", ",", "imt", ",", "stddev_types", ")", ":", "# Get original mean and standard deviations", "mean", ",", "stddevs", "=", "super", "(", ")", ".", "get_mean_and_stddevs", "(", "sctx", ",", "rctx", ",", "dctx", ",", "imt", ",", "stddev_types", ")", "cff", "=", "SInterCan15Mid", ".", "SITE_COEFFS", "[", "imt", "]", "mean", "+=", "np", ".", "log", "(", "cff", "[", "'mf'", "]", ")", "return", "mean", ",", "stddevs" ]

[ "See", ":", "meth", ":", "superclass", "method", "<", ".", "base", ".", "GroundShakingIntensityModel", ".", "get_mean_and_stddevs", ">", "for", "spec", "of", "input", "and", "result", "values", "." ]

[ "def", "get_mean_and_stddevs", "(", "self", ",", "sctx", ",", "rctx", ",", "dctx", ",", "imt", ",", "stddev_types", ")", ":", "# Get original mean and standard deviations", "mean", ",", "stddevs", "=", "super", "(", ")", ".", "get_mean_and_stddevs", "(", "sctx", ",", "rctx", ",", "dctx", ",", "imt", ",", "stddev_types", ")", "# Return mean, increased by the adjustment factor,", "# and standard devation", "return", "mean", "+", "nga_west2_epistemic_adjustment", "(", "rctx", ".", "mag", ",", "dctx", ".", "rrup", ")", ",", "stddevs" ]

[ "See", ":", "meth", ":", "superclass", "method", "<", ".", "base", ".", "GroundShakingIntensityModel", ".", "get_mean_and_stddevs", ">", "for", "spec", "of", "input", "and", "result", "values", "." ]

[ "def", "get_poes", "(", "self", ",", "sctx", ",", "rctx", ",", "dctx", ",", "imt", ",", "imls", ",", "truncation_level", ")", ":", "return", "get_weighted_poes", "(", "self", ",", "sctx", ",", "rctx", ",", "dctx", ",", "imt", ",", "imls", ",", "truncation_level", ")" ]

[ "Adapts", "the", "original", "get_poes", "()", "from", "the", ":", "class", ":", "openquake", ".", "hazardlib", ".", "gsim", ".", "base", ".", "GMPE", "to", "call", "a", "function", "that", "take", "the", "weighted", "sum", "of", "the", "PoEs", "from", "the", "epistemic", "uncertainty", "adjustment" ]

[ "def", "register_fields", "(", "w", ")", ":", "PARAMS_LIST", "=", "[", "BASE_PARAMS", ",", "GEOMETRY_PARAMS", ",", "MFD_PARAMS", "]", "for", "PARAMS", "in", "PARAMS_LIST", ":", "for", "_", ",", "param", ",", "dtype", "in", "PARAMS", ":", "w", ".", "field", "(", "param", ",", "fieldType", "=", "dtype", ",", "size", "=", "FIELD_SIZE", ")", "PARAMS_LIST", "=", "[", "RATE_PARAMS", ",", "STRIKE_PARAMS", ",", "DIP_PARAMS", ",", "RAKE_PARAMS", ",", "NPW_PARAMS", ",", "HDEPTH_PARAMS", ",", "HDW_PARAMS", ",", "PLANES_STRIKES_PARAM", ",", "PLANES_DIPS_PARAM", "]", "for", "PARAMS", "in", "PARAMS_LIST", ":", "for", "param", ",", "dtype", "in", "PARAMS", ":", "w", ".", "field", "(", "param", ",", "fieldType", "=", "dtype", ",", "size", "=", "FIELD_SIZE", ")", "# source typology", "w", ".", "field", "(", "'sourcetype'", ",", "'C'", ")" ]

[ "Register", "shapefile", "fields", "." ]

[ "def", "expand_src_param", "(", "values", ",", "shp_params", ")", ":", "if", "values", "is", "None", ":", "return", "dict", "(", "[", "(", "key", ",", "None", ")", "for", "key", ",", "_", "in", "shp_params", "]", ")", "else", ":", "num_values", "=", "len", "(", "values", ")", "return", "dict", "(", "[", "(", "key", ",", "float", "(", "values", "[", "i", "]", ")", "if", "i", "<", "num_values", "else", "None", ")", "for", "i", ",", "(", "key", ",", "_", ")", "in", "enumerate", "(", "shp_params", ")", "]", ")" ]

[ "Expand", "hazardlib", "source", "attribute", "(", "defined", "through", "list", "of", "values", ")", "into", "dictionary", "of", "shapefile", "parameters", "." ]

[ "def", "extract_source_params", "(", "src", ")", ":", "tags", "=", "get_taglist", "(", "src", ")", "data", "=", "[", "]", "for", "key", ",", "param", ",", "vtype", "in", "BASE_PARAMS", ":", "if", "key", "in", "src", ".", "attrib", ":", "if", "vtype", "==", "\"c\"", ":", "data", ".", "append", "(", "(", "param", ",", "src", ".", "attrib", "[", "key", "]", ")", ")", "elif", "vtype", "==", "\"f\"", ":", "data", ".", "append", "(", "(", "param", ",", "float", "(", "src", ".", "attrib", "[", "key", "]", ")", ")", ")", "else", ":", "data", ".", "append", "(", "(", "param", ",", "None", ")", ")", "elif", "key", "in", "tags", ":", "if", "vtype", "==", "\"c\"", ":", "data", ".", "append", "(", "(", "param", ",", "src", ".", "nodes", "[", "tags", ".", "index", "(", "key", ")", "]", ".", "text", ")", ")", "elif", "vtype", "==", "\"f\"", ":", "data", ".", "append", "(", "(", "param", ",", "float", "(", "src", ".", "nodes", "[", "tags", ".", "index", "(", "key", ")", "]", ".", "text", ")", ")", ")", "else", ":", "data", ".", "append", "(", "(", "param", ",", "None", ")", ")", "else", ":", "data", ".", "append", "(", "(", "param", ",", "None", ")", ")", "return", "dict", "(", "data", ")" ]

[ "Extract", "params", "from", "source", "object", "." ]

[ "def", "parse_complex_fault_geometry", "(", "node", ")", ":", "assert", "\"complexFaultGeometry\"", "in", "node", ".", "tag", "# Get general attributes", "geometry", "=", "{", "\"intermediateEdges\"", ":", "[", "]", "}", "for", "subnode", "in", "node", ":", "crds", "=", "subnode", ".", "nodes", "[", "0", "]", ".", "nodes", "[", "0", "]", ".", "text", "if", "\"faultTopEdge\"", "in", "subnode", ".", "tag", ":", "geometry", "[", "\"faultTopEdge\"", "]", "=", "numpy", ".", "array", "(", "[", "[", "crds", "[", "i", "]", ",", "crds", "[", "i", "+", "1", "]", ",", "crds", "[", "i", "+", "2", "]", "]", "for", "i", "in", "range", "(", "0", ",", "len", "(", "crds", ")", ",", "3", ")", "]", ")", "geometry", "[", "\"upperSeismoDepth\"", "]", "=", "numpy", ".", "min", "(", "geometry", "[", "\"faultTopEdge\"", "]", "[", ":", ",", "2", "]", ")", "elif", "\"faultBottomEdge\"", "in", "subnode", ".", "tag", ":", "geometry", "[", "\"faultBottomEdge\"", "]", "=", "numpy", ".", "array", "(", "[", "[", "crds", "[", "i", "]", ",", "crds", "[", "i", "+", "1", "]", ",", "crds", "[", "i", "+", "2", "]", "]", "for", "i", "in", "range", "(", "0", ",", "len", "(", "crds", ")", ",", "3", ")", "]", ")", "geometry", "[", "\"lowerSeismoDepth\"", "]", "=", "numpy", ".", "max", "(", "geometry", "[", "\"faultBottomEdge\"", "]", "[", ":", ",", "2", "]", ")", "elif", "\"intermediateEdge\"", "in", "subnode", ".", "tag", ":", "geometry", "[", "\"intermediateEdges\"", "]", ".", "append", "(", "numpy", ".", "array", "(", "[", "[", "crds", "[", "i", "]", ",", "crds", "[", "i", "+", "1", "]", ",", "crds", "[", "i", "+", "2", "]", "]", "for", "i", "in", "range", "(", "0", ",", "len", "(", "crds", ")", ",", "3", ")", "]", ")", ")", "else", ":", "pass", "geometry", "[", "\"dip\"", "]", "=", "None", "return", "geometry" ]

[ "Parses", "a", "complex", "fault", "geometry", "node", "returning", "both", "the", "attributes", "and", "parameters", "in", "a", "dictionary" ]

[ "def", "parse_planar_fault_geometry", "(", "node", ")", ":", "assert", "\"planarSurface\"", "in", "node", ".", "tag", "geometry", "=", "{", "\"strike\"", ":", "node", ".", "attrib", "[", "\"strike\"", "]", ",", "\"dip\"", ":", "node", ".", "attrib", "[", "\"dip\"", "]", "}", "upper_depth", "=", "numpy", ".", "inf", "lower_depth", "=", "0.0", "tags", "=", "get_taglist", "(", "node", ")", "corner_points", "=", "[", "]", "for", "locn", "in", "[", "\"topLeft\"", ",", "\"topRight\"", ",", "\"bottomRight\"", ",", "\"bottomLeft\"", "]", ":", "plane", "=", "node", ".", "nodes", "[", "tags", ".", "index", "(", "locn", ")", "]", "upper_depth", "=", "plane", "[", "\"depth\"", "]", "if", "plane", "[", "\"depth\"", "]", "<", "upper_depth", "else", "upper_depth", "lower_depth", "=", "plane", "[", "\"depth\"", "]", "if", "plane", "[", "\"depth\"", "]", ">", "lower_depth", "else", "lower_depth", "corner_points", ".", "append", "(", "[", "plane", "[", "\"lon\"", "]", ",", "plane", "[", "\"lat\"", "]", ",", "plane", "[", "\"depth\"", "]", "]", ")", "geometry", "[", "\"upperSeismoDepth\"", "]", "=", "upper_depth", "geometry", "[", "\"lowerSeismoDepth\"", "]", "=", "lower_depth", "geometry", "[", "\"corners\"", "]", "=", "numpy", ".", "array", "(", "corner_points", ")", "return", "geometry" ]

[ "Parses", "a", "planar", "fault", "geometry", "node", "returning", "both", "the", "attributes", "and", "parameters", "in", "a", "dictionary" ]

[ "def", "extract_mfd_params", "(", "src", ")", ":", "tags", "=", "get_taglist", "(", "src", ")", "if", "\"incrementalMFD\"", "in", "tags", ":", "mfd_node", "=", "src", ".", "nodes", "[", "tags", ".", "index", "(", "\"incrementalMFD\"", ")", "]", "elif", "\"truncGutenbergRichterMFD\"", "in", "tags", ":", "mfd_node", "=", "src", ".", "nodes", "[", "tags", ".", "index", "(", "\"truncGutenbergRichterMFD\"", ")", "]", "elif", "\"arbitraryMFD\"", "in", "tags", ":", "mfd_node", "=", "src", ".", "nodes", "[", "tags", ".", "index", "(", "\"arbitraryMFD\"", ")", "]", "elif", "\"YoungsCoppersmithMFD\"", "in", "tags", ":", "mfd_node", "=", "src", ".", "nodes", "[", "tags", ".", "index", "(", "\"YoungsCoppersmithMFD\"", ")", "]", "else", ":", "raise", "ValueError", "(", "\"Source %s contains no supported MFD type!\"", "%", "src", ".", "tag", ")", "data", "=", "[", "]", "rates", "=", "[", "]", "for", "key", ",", "param", ",", "vtype", "in", "MFD_PARAMS", ":", "if", "key", "in", "mfd_node", ".", "attrib", "and", "mfd_node", ".", "attrib", "[", "key", "]", "is", "not", "None", ":", "data", ".", "append", "(", "(", "param", ",", "mfd_node", ".", "attrib", "[", "key", "]", ")", ")", "else", ":", "data", ".", "append", "(", "(", "param", ",", "None", ")", ")", "if", "(", "\"incrementalMFD\"", "or", "\"arbitraryMFD\"", ")", "in", "mfd_node", ".", "tag", ":", "# Extract Rates", "rates", "=", "~", "mfd_node", ".", "occurRates", "n_r", "=", "len", "(", "rates", ")", "if", "n_r", ">", "MAX_RATES", ":", "raise", "ValueError", "(", "\"Number of rates in source %s too large \"", "\"to be placed into shapefile\"", "%", "src", ".", "tag", ")", "rate_dict", "=", "dict", "(", "[", "(", "key", ",", "rates", "[", "i", "]", "if", "i", "<", "n_r", "else", "None", ")", "for", "i", ",", "(", "key", ",", "_", ")", "in", "enumerate", "(", "RATE_PARAMS", ")", "]", ")", "elif", "\"YoungsCoppersmithMFD\"", "in", "mfd_node", ".", "tag", ":", "rate_dict", "=", "dict", "(", "[", "(", "key", ",", "mfd_node", ".", "attrib", "[", "'characteristicRate'", "]", ")", "for", "i", ",", "(", "key", ",", "_", ")", "in", "enumerate", "(", "RATE_PARAMS", ")", "]", ")", "else", ":", "rate_dict", "=", "dict", "(", "[", "(", "key", ",", "None", ")", "for", "i", ",", "(", "key", ",", "_", ")", "in", "enumerate", "(", "RATE_PARAMS", ")", "]", ")", "return", "dict", "(", "data", ")", ",", "rate_dict" ]

[ "Extracts", "the", "MFD", "parameters", "from", "an", "object" ]

[ "def", "extract_source_hypocentral_depths", "(", "src", ")", ":", "if", "\"pointSource\"", "not", "in", "src", ".", "tag", "and", "\"areaSource\"", "not", "in", "src", ".", "tag", ":", "hds", "=", "dict", "(", "[", "(", "key", ",", "None", ")", "for", "key", ",", "_", "in", "HDEPTH_PARAMS", "]", ")", "hdsw", "=", "dict", "(", "[", "(", "key", ",", "None", ")", "for", "key", ",", "_", "in", "HDW_PARAMS", "]", ")", "return", "hds", ",", "hdsw", "tags", "=", "get_taglist", "(", "src", ")", "hdd_nodeset", "=", "src", ".", "nodes", "[", "tags", ".", "index", "(", "\"hypoDepthDist\"", ")", "]", "if", "len", "(", "hdd_nodeset", ")", ">", "MAX_HYPO_DEPTHS", ":", "raise", "ValueError", "(", "\"Number of hypocentral depths %s exceeds stated \"", "\"maximum of %s\"", "%", "(", "str", "(", "len", "(", "hdd_nodeset", ")", ")", ",", "str", "(", "MAX_HYPO_DEPTHS", ")", ")", ")", "if", "len", "(", "hdd_nodeset", ")", ":", "hds", "=", "[", "]", "hdws", "=", "[", "]", "for", "hdd_node", "in", "hdd_nodeset", ":", "hds", ".", "append", "(", "float", "(", "hdd_node", ".", "attrib", "[", "\"depth\"", "]", ")", ")", "hdws", ".", "append", "(", "float", "(", "hdd_node", ".", "attrib", "[", "\"probability\"", "]", ")", ")", "hds", "=", "expand_src_param", "(", "hds", ",", "HDEPTH_PARAMS", ")", "hdsw", "=", "expand_src_param", "(", "hdws", ",", "HDW_PARAMS", ")", "else", ":", "hds", "=", "dict", "(", "[", "(", "key", ",", "None", ")", "for", "key", ",", "_", "in", "HDEPTH_PARAMS", "]", ")", "hdsw", "=", "dict", "(", "[", "(", "key", ",", "None", ")", "for", "key", ",", "_", "in", "HDW_PARAMS", "]", ")", "return", "hds", ",", "hdsw" ]

[ "Extract", "source", "hypocentral", "depths", "." ]

[ "def", "extract_source_planes_strikes_dips", "(", "src", ")", ":", "if", "\"characteristicFaultSource\"", "not", "in", "src", ".", "tag", ":", "strikes", "=", "dict", "(", "[", "(", "key", ",", "None", ")", "for", "key", ",", "_", "in", "PLANES_STRIKES_PARAM", "]", ")", "dips", "=", "dict", "(", "[", "(", "key", ",", "None", ")", "for", "key", ",", "_", "in", "PLANES_DIPS_PARAM", "]", ")", "return", "strikes", ",", "dips", "tags", "=", "get_taglist", "(", "src", ")", "surface_set", "=", "src", ".", "nodes", "[", "tags", ".", "index", "(", "\"surface\"", ")", "]", "strikes", "=", "[", "]", "dips", "=", "[", "]", "num_planes", "=", "0", "for", "surface", "in", "surface_set", ":", "if", "\"planarSurface\"", "in", "surface", ".", "tag", ":", "strikes", ".", "append", "(", "float", "(", "surface", ".", "attrib", "[", "\"strike\"", "]", ")", ")", "dips", ".", "append", "(", "float", "(", "surface", ".", "attrib", "[", "\"dip\"", "]", ")", ")", "num_planes", "+=", "1", "if", "num_planes", ">", "MAX_PLANES", ":", "raise", "ValueError", "(", "\"Number of planes in sourcs %s exceededs maximum \"", "\"of %s\"", "%", "(", "str", "(", "num_planes", ")", ",", "str", "(", "MAX_PLANES", ")", ")", ")", "if", "num_planes", ":", "strikes", "=", "expand_src_param", "(", "strikes", ",", "PLANES_STRIKES_PARAM", ")", "dips", "=", "expand_src_param", "(", "dips", ",", "PLANES_DIPS_PARAM", ")", "else", ":", "strikes", "=", "dict", "(", "[", "(", "key", ",", "None", ")", "for", "key", ",", "_", "in", "PLANES_STRIKES_PARAM", "]", ")", "dips", "=", "dict", "(", "[", "(", "key", ",", "None", ")", "for", "key", ",", "_", "in", "PLANES_DIPS_PARAM", "]", ")", "return", "strikes", ",", "dips" ]

[ "Extract", "strike", "and", "dip", "angles", "for", "source", "defined", "by", "multiple", "planes", "." ]

[ "def", "set_params", "(", "w", ",", "src", ")", ":", "params", "=", "extract_source_params", "(", "src", ")", "# this is done because for characteristic sources geometry is in", "# 'surface' attribute", "params", ".", "update", "(", "extract_geometry_params", "(", "src", ")", ")", "mfd_pars", ",", "rate_pars", "=", "extract_mfd_params", "(", "src", ")", "params", ".", "update", "(", "mfd_pars", ")", "params", ".", "update", "(", "rate_pars", ")", "strikes", ",", "dips", ",", "rakes", ",", "np_weights", "=", "extract_source_nodal_planes", "(", "src", ")", "params", ".", "update", "(", "strikes", ")", "params", ".", "update", "(", "dips", ")", "params", ".", "update", "(", "rakes", ")", "params", ".", "update", "(", "np_weights", ")", "hds", ",", "hdsw", "=", "extract_source_hypocentral_depths", "(", "src", ")", "params", ".", "update", "(", "hds", ")", "params", ".", "update", "(", "hdsw", ")", "pstrikes", ",", "pdips", "=", "extract_source_planes_strikes_dips", "(", "src", ")", "params", ".", "update", "(", "pstrikes", ")", "params", ".", "update", "(", "pdips", ")", "params", "[", "'sourcetype'", "]", "=", "striptag", "(", "src", ".", "tag", ")", "w", ".", "record", "(", "*", "*", "params", ")" ]

[ "Set", "source", "parameters", "." ]

[ "def", "set_area_geometry", "(", "w", ",", "src", ")", ":", "assert", "\"areaSource\"", "in", "src", ".", "tag", "geometry_node", "=", "src", ".", "nodes", "[", "get_taglist", "(", "src", ")", ".", "index", "(", "\"areaGeometry\"", ")", "]", "area_attrs", "=", "parse_area_geometry", "(", "geometry_node", ")", "w", ".", "poly", "(", "parts", "=", "[", "area_attrs", "[", "\"polygon\"", "]", ".", "tolist", "(", ")", "]", ")" ]

[ "Set", "area", "polygon", "as", "shapefile", "geometry" ]

[ "def", "set_point_geometry", "(", "w", ",", "src", ")", ":", "assert", "\"pointSource\"", "in", "src", ".", "tag", "geometry_node", "=", "src", ".", "nodes", "[", "get_taglist", "(", "src", ")", ".", "index", "(", "\"pointGeometry\"", ")", "]", "point_attrs", "=", "parse_point_geometry", "(", "geometry_node", ")", "w", ".", "point", "(", "point_attrs", "[", "\"point\"", "]", "[", "0", "]", ",", "point_attrs", "[", "\"point\"", "]", "[", "1", "]", ")" ]

[ "Set", "point", "location", "as", "shapefile", "geometry", "." ]

[ "def", "set_simple_fault_geometry", "(", "w", ",", "src", ")", ":", "assert", "\"simpleFaultSource\"", "in", "src", ".", "tag", "geometry_node", "=", "src", ".", "nodes", "[", "get_taglist", "(", "src", ")", ".", "index", "(", "\"simpleFaultGeometry\"", ")", "]", "fault_attrs", "=", "parse_simple_fault_geometry", "(", "geometry_node", ")", "w", ".", "line", "(", "parts", "=", "[", "fault_attrs", "[", "\"trace\"", "]", ".", "tolist", "(", ")", "]", ")" ]

[ "Set", "simple", "fault", "trace", "coordinates", "as", "shapefile", "geometry", "." ]

[ "def", "set_simple_fault_geometry_3D", "(", "w", ",", "src", ")", ":", "assert", "\"simpleFaultSource\"", "in", "src", ".", "tag", "geometry_node", "=", "src", ".", "nodes", "[", "get_taglist", "(", "src", ")", ".", "index", "(", "\"simpleFaultGeometry\"", ")", "]", "fault_attrs", "=", "parse_simple_fault_geometry", "(", "geometry_node", ")", "build_polygon_from_fault_attrs", "(", "w", ",", "fault_attrs", ")" ]

[ "Builds", "a", "3D", "polygon", "from", "a", "node", "instance" ]

[ "def", "appraise_source_model", "(", "self", ")", ":", "for", "src", "in", "self", ".", "sources", ":", "# source params", "src_taglist", "=", "get_taglist", "(", "src", ")", "if", "\"areaSource\"", "in", "src", ".", "tag", ":", "self", ".", "has_area_source", "=", "True", "npd_node", "=", "src", ".", "nodes", "[", "src_taglist", ".", "index", "(", "\"nodalPlaneDist\"", ")", "]", "npd_size", "=", "len", "(", "npd_node", ")", "hdd_node", "=", "src", ".", "nodes", "[", "src_taglist", ".", "index", "(", "\"hypoDepthDist\"", ")", "]", "hdd_size", "=", "len", "(", "hdd_node", ")", "self", ".", "num_np", "=", "(", "npd_size", "if", "npd_size", ">", "self", ".", "num_np", "else", "self", ".", "num_np", ")", "self", ".", "num_hd", "=", "(", "hdd_size", "if", "hdd_size", ">", "self", ".", "num_hd", "else", "self", ".", "num_hd", ")", "elif", "\"pointSource\"", "in", "src", ".", "tag", ":", "self", ".", "has_point_source", "=", "True", "npd_node", "=", "src", ".", "nodes", "[", "src_taglist", ".", "index", "(", "\"nodalPlaneDist\"", ")", "]", "npd_size", "=", "len", "(", "npd_node", ")", "hdd_node", "=", "src", ".", "nodes", "[", "src_taglist", ".", "index", "(", "\"hypoDepthDist\"", ")", "]", "hdd_size", "=", "len", "(", "hdd_node", ")", "self", ".", "num_np", "=", "(", "npd_size", "if", "npd_size", ">", "self", ".", "num_np", "else", "self", ".", "num_np", ")", "self", ".", "num_hd", "=", "(", "hdd_size", "if", "hdd_size", ">", "self", ".", "num_hd", "else", "self", ".", "num_hd", ")", "elif", "\"simpleFaultSource\"", "in", "src", ".", "tag", ":", "self", ".", "has_simple_fault_geometry", "=", "True", "elif", "\"complexFaultSource\"", "in", "src", ".", "tag", ":", "self", ".", "has_complex_fault_geometry", "=", "True", "elif", "\"characteristicFaultSource\"", "in", "src", ".", "tag", ":", "# Get the surface node", "surface_node", "=", "src", ".", "nodes", "[", "src_taglist", ".", "index", "(", "\"surface\"", ")", "]", "p_size", "=", "0", "for", "surface", "in", "surface_node", ".", "nodes", ":", "if", "\"simpleFaultGeometry\"", "in", "surface", ".", "tag", ":", "self", ".", "has_simple_fault_geometry", "=", "True", "elif", "\"complexFaultGeometry\"", "in", "surface", ".", "tag", ":", "self", ".", "has_complex_fault_geometry", "=", "True", "elif", "\"planarSurface\"", "in", "surface", ".", "tag", ":", "self", ".", "has_planar_geometry", "=", "True", "p_size", "+=", "1", "self", ".", "num_p", "=", "p_size", "if", "p_size", ">", "self", ".", "num_p", "else", "self", ".", "num_p", "else", ":", "pass", "# MFD params", "if", "\"truncGutenbergRichterMFD\"", "in", "src_taglist", ":", "self", ".", "has_mfd_gr", "=", "True", "elif", "\"incrementalMFD\"", "in", "src_taglist", ":", "self", ".", "has_mfd_incremental", "=", "True", "# Get rate size", "mfd_node", "=", "src", ".", "nodes", "[", "src_taglist", ".", "index", "(", "\"incrementalMFD\"", ")", "]", "r_size", "=", "len", "(", "mfd_node", ".", "nodes", "[", "0", "]", ".", "text", ")", "self", ".", "num_r", "=", "r_size", "if", "r_size", ">", "self", ".", "num_r", "else", "self", ".", "num_r", "else", ":", "pass" ]

[ "Identify", "parameters", "defined", "in", "NRML", "source", "model", "file", "so", "that", "shapefile", "contains", "only", "source", "model", "specific", "fields", "." ]

[ "def", "read", "(", "self", ",", "nrml_file", ",", "validate", "=", "False", ",", "simple_fault_spacing", "=", "1.0", ",", "complex_mesh_spacing", "=", "5.0", ",", "mfd_spacing", "=", "0.1", ")", ":", "self", ".", "source_file", "=", "nrml_file", "if", "validate", ":", "converter", "=", "SourceConverter", "(", "1.0", ",", "simple_fault_spacing", ",", "complex_mesh_spacing", ",", "mfd_spacing", ",", "10.0", ")", "converter", ".", "fname", "=", "nrml_file", "root", "=", "nrml", ".", "read", "(", "nrml_file", ")", "if", "root", "[", "'xmlns'", "]", "==", "'http://openquake.org/xmlns/nrml/0.4'", ":", "sg_nodes", "=", "[", "root", ".", "sourceModel", ".", "nodes", "]", "else", ":", "# NRML 0.5", "sg_nodes", "=", "root", ".", "sourceModel", ".", "nodes", "sources", "=", "[", "]", "for", "sg_node", "in", "sg_nodes", ":", "for", "no", ",", "src_node", "in", "enumerate", "(", "sg_node", ",", "1", ")", ":", "if", "validate", ":", "print", "(", "\"Validating Source %s\"", "%", "src_node", ".", "attrib", "[", "\"id\"", "]", ")", "converter", ".", "convert_node", "(", "src_node", ")", "sources", ".", "append", "(", "src_node", ")", "return", "SourceModel", "(", "sources", ")" ]

[ "Build", "the", "source", "model", "from", "nrml", "format" ]

[ "def", "write", "(", "self", ",", "destination", ",", "source_model", ",", "name", "=", "None", ")", ":", "if", "os", ".", "path", ".", "exists", "(", "destination", ")", ":", "os", ".", "remove", "(", "destination", ")", "self", ".", "destination", "=", "destination", "if", "name", ":", "source_model", ".", "name", "=", "name", "output_source_model", "=", "Node", "(", "\"sourceModel\"", ",", "{", "\"name\"", ":", "name", "}", ")", "dic", "=", "groupby", "(", "source_model", ".", "sources", ",", "operator", ".", "itemgetter", "(", "'tectonicRegion'", ")", ")", "for", "i", ",", "(", "trt", ",", "srcs", ")", "in", "enumerate", "(", "dic", ".", "items", "(", ")", ",", "1", ")", ":", "output_source_model", ".", "append", "(", "Node", "(", "'sourceGroup'", ",", "{", "'tectonicRegion'", ":", "trt", ",", "'name'", ":", "'group %d'", "%", "i", "}", ",", "nodes", "=", "srcs", ")", ")", "print", "(", "\"Exporting Source Model to %s\"", "%", "self", ".", "destination", ")", "with", "open", "(", "self", ".", "destination", ",", "\"wb\"", ")", "as", "f", ":", "nrml", ".", "write", "(", "[", "output_source_model", "]", ",", "f", ",", "\"%s\"", ")" ]

[ "Exports", "to", "NRML" ]

[ "def", "filter_params", "(", "self", ",", "src_mod", ")", ":", "# point and area related params", "STRIKE_PARAMS", "[", "src_mod", ".", "num_np", ":", "]", "=", "[", "]", "DIP_PARAMS", "[", "src_mod", ".", "num_np", ":", "]", "=", "[", "]", "RAKE_PARAMS", "[", "src_mod", ".", "num_np", ":", "]", "=", "[", "]", "NPW_PARAMS", "[", "src_mod", ".", "num_np", ":", "]", "=", "[", "]", "HDEPTH_PARAMS", "[", "src_mod", ".", "num_hd", ":", "]", "=", "[", "]", "HDW_PARAMS", "[", "src_mod", ".", "num_hd", ":", "]", "=", "[", "]", "# planar rupture related params", "PLANES_STRIKES_PARAM", "[", "src_mod", ".", "num_p", ":", "]", "=", "[", "]", "PLANES_DIPS_PARAM", "[", "src_mod", ".", "num_p", ":", "]", "=", "[", "]", "# rate params", "RATE_PARAMS", "[", "src_mod", ".", "num_r", ":", "]", "=", "[", "]", "if", "src_mod", ".", "has_simple_fault_geometry", "is", "False", ":", "GEOMETRY_PARAMS", ".", "remove", "(", "(", "'dip'", ",", "'dip'", ",", "'f'", ")", ")", "if", "(", "src_mod", ".", "has_simple_fault_geometry", "is", "False", "and", "src_mod", ".", "has_complex_fault_geometry", "is", "False", "and", "src_mod", ".", "has_planar_geometry", "is", "False", ")", ":", "BASE_PARAMS", ".", "remove", "(", "(", "'rake'", ",", "'rake'", ",", "'f'", ")", ")", "if", "(", "src_mod", ".", "has_simple_fault_geometry", "is", "False", "and", "src_mod", ".", "has_complex_fault_geometry", "is", "False", "and", "src_mod", ".", "has_area_source", "is", "False", "and", "src_mod", ".", "has_point_source", "is", "False", ")", ":", "GEOMETRY_PARAMS", "[", ":", "]", "=", "[", "]", "if", "src_mod", ".", "has_mfd_incremental", "is", "False", ":", "MFD_PARAMS", ".", "remove", "(", "(", "'binWidth'", ",", "'bin_width'", ",", "'f'", ")", ")" ]

[ "Remove", "params", "uneeded", "by", "source_model" ]

[ "def", "read", "(", "self", ",", "input_shapefile", ",", "validate", "=", "False", ",", "simple_fault_spacing", "=", "1.0", ",", "complex_mesh_spacing", "=", "5.0", ",", "mfd_spacing", "=", "0.1", ")", ":", "reader", "=", "shapefile", ".", "Reader", "(", "input_shapefile", ")", "fields", "=", "[", "field", "[", "0", "]", "for", "field", "in", "reader", ".", "fields", "[", "1", ":", "]", "]", "shapes", "=", "reader", ".", "shapes", "(", ")", "records", "=", "reader", ".", "records", "(", ")", "sources", "=", "[", "]", "if", "validate", ":", "converter", "=", "SourceConverter", "(", "1.0", ",", "simple_fault_spacing", ",", "complex_mesh_spacing", ",", "mfd_spacing", ",", "10.0", ")", "for", "iloc", "in", "range", "(", "0", ",", "reader", ".", "numRecords", ")", ":", "# Build record dictionary", "record", "=", "record_to_dict", "(", "records", "[", "iloc", "]", ",", "fields", ")", "shape", "=", "shapes", "[", "iloc", "]", "if", "\"pointSource\"", "in", "record", "[", "\"sourcetype\"", "]", ":", "src", "=", "build_point_source_from_shp", "(", "shape", ",", "record", ")", "elif", "\"areaSource\"", "in", "record", "[", "\"sourcetype\"", "]", ":", "src", "=", "build_area_source_from_shp", "(", "shape", ",", "record", ")", "elif", "\"simpleFaultSource\"", "in", "record", "[", "\"sourcetype\"", "]", ":", "src", "=", "build_simple_fault_source_from_shp", "(", "shape", ",", "record", ")", "elif", "\"complexFaultSource\"", "in", "record", "[", "\"sourcetype\"", "]", ":", "src", "=", "build_complex_fault_source_from_shp", "(", "shape", ",", "record", ")", "elif", "\"characteristicFaultSource\"", "in", "record", "[", "\"sourcetype\"", "]", ":", "print", "(", "\"Characteristic Fault Source Not Yet Supported - Sorry!\"", ")", "src", "=", "None", "if", "src", "and", "validate", ":", "print", "(", "\"Validating Source %s\"", "%", "src", ".", "attrib", "[", "\"id\"", "]", ")", "converter", ".", "convert_node", "(", "src", ")", "if", "src", ":", "sources", ".", "append", "(", "src", ")", "return", "SourceModel", "(", "sources", ")" ]

[ "Build", "the", "source", "model", "from", "nrml", "format" ]

[ "def", "write", "(", "self", ",", "destination", ",", "source_model", ",", "name", "=", "None", ")", ":", "if", "os", ".", "path", ".", "exists", "(", "destination", "+", "\".shp\"", ")", ":", "os", ".", "system", "(", "\"rm %s.*\"", "%", "destination", ")", "self", ".", "destination", "=", "destination", "self", ".", "filter_params", "(", "source_model", ")", "w_area", "=", "shapefile", ".", "Writer", "(", "shapefile", ".", "POLYGON", ")", "w_point", "=", "shapefile", ".", "Writer", "(", "shapefile", ".", "POINT", ")", "w_simple", "=", "shapefile", ".", "Writer", "(", "shapefile", ".", "POLYLINE", ")", "w_simple3d", "=", "shapefile", ".", "Writer", "(", "shapefile", ".", "POLYGONZ", ")", "w_complex", "=", "shapefile", ".", "Writer", "(", "shapefile", ".", "POLYLINEZ", ")", "w_planar", "=", "shapefile", ".", "Writer", "(", "shapefile", ".", "POLYGONZ", ")", "register_fields", "(", "w_area", ")", "register_fields", "(", "w_point", ")", "register_fields", "(", "w_simple", ")", "register_fields", "(", "w_simple3d", ")", "register_fields", "(", "w_complex", ")", "register_fields", "(", "w_planar", ")", "for", "src", "in", "source_model", ".", "sources", ":", "# Order is important here", "if", "\"areaSource\"", "in", "src", ".", "tag", ":", "set_params", "(", "w_area", ",", "src", ")", "set_area_geometry", "(", "w_area", ",", "src", ")", "elif", "\"pointSource\"", "in", "src", ".", "tag", ":", "set_params", "(", "w_point", ",", "src", ")", "set_point_geometry", "(", "w_point", ",", "src", ")", "elif", "\"complexFaultSource\"", "in", "src", ".", "tag", ":", "set_params", "(", "w_complex", ",", "src", ")", "set_complex_fault_geometry", "(", "w_complex", ",", "src", ")", "elif", "\"simpleFaultSource\"", "in", "src", ".", "tag", ":", "set_params", "(", "w_simple", ",", "src", ")", "set_simple_fault_geometry", "(", "w_simple", ",", "src", ")", "# Create the 3D polygon", "set_params", "(", "w_simple3d", ",", "src", ")", "set_simple_fault_geometry_3D", "(", "w_simple3d", ",", "src", ")", "elif", "\"characteristicFaultSource\"", "in", "src", ".", "tag", ":", "src_taglist", "=", "get_taglist", "(", "src", ")", "surface_node", "=", "src", ".", "nodes", "[", "src_taglist", ".", "index", "(", "\"surface\"", ")", "]", "for", "subnode", "in", "surface_node", ":", "if", "\"simpleFaultGeometry\"", "in", "subnode", ".", "tag", ":", "set_params", "(", "w_simple", ",", "src", ")", "set_params", "(", "w_simple3d", ",", "src", ")", "elif", "\"complexFaultGeometry\"", "in", "subnode", ".", "tag", ":", "set_params", "(", "w_complex", ",", "src", ")", "elif", "\"planarSurface\"", "in", "subnode", ".", "tag", ":", "set_params", "(", "w_planar", ",", "src", ")", "else", ":", "raise", "ValueError", "(", "'Geometry class %s not recognized'", "%", "subnode", ".", "tag", ")", "set_characteristic_geometry", "(", "w_simple", ",", "w_simple3d", ",", "w_complex", ",", "w_planar", ",", "src", ")", "else", ":", "raise", "ValueError", "(", "'Source type %s not recognized'", "%", "src", ".", "tag", ")", "root", "=", "self", ".", "destination", "if", "len", "(", "w_area", ".", "shapes", "(", ")", ")", ">", "0", ":", "w_area", ".", "save", "(", "'%s_area'", "%", "root", ")", "if", "len", "(", "w_point", ".", "shapes", "(", ")", ")", ">", "0", ":", "w_point", ".", "save", "(", "'%s_point'", "%", "root", ")", "if", "len", "(", "w_complex", ".", "shapes", "(", ")", ")", ">", "0", ":", "w_complex", ".", "save", "(", "'%s_complex'", "%", "root", ")", "if", "len", "(", "w_simple", ".", "shapes", "(", ")", ")", ">", "0", ":", "w_simple", ".", "save", "(", "'%s_simple'", "%", "root", ")", "w_simple3d", ".", "save", "(", "'%s_simple3d'", "%", "root", ")", "if", "len", "(", "w_planar", ".", "shapes", "(", ")", ")", ">", "0", ":", "w_planar", ".", "save", "(", "'%s_planar'", "%", "root", ")" ]

[ "Save", "sources", "-", "to", "multiple", "shapefiles", "corresponding", "to", "different", "source", "typolgies", "/", "geometries", "(", "_point", "_area", "_simple", "_complex", "_planar", ")" ]

[ "def", "shell", "(", "script", "=", "None", ",", "args", "=", "(", ")", ")", ":", "if", "script", ":", "sys", ".", "argv", "=", "sys", ".", "argv", "[", "2", ":", "]", "# strip ['oq', 'shell']", "runpy", ".", "run_path", "(", "script", ",", "run_name", "=", "'__main__'", ")", "return", "o", "=", "OpenQuake", "(", ")", "# noqa", "try", ":", "import", "IPython", "IPython", ".", "embed", "(", "banner1", "=", "'IPython shell with a global object \"o\"'", ")", "except", "ImportError", ":", "import", "code", "code", ".", "interact", "(", "banner", "=", "'Python shell with a global object \"o\"'", ",", "local", "=", "dict", "(", "o", "=", "o", ")", ")" ]

[ "Start", "an", "embedded", "(", "i", ")", "python", "instance", "with", "a", "global", "object", "o", "or", "run", "a", "Python", "script", "in", "the", "engine", "environment", "." ]

[ "def", "get_bilinear_residuals_stepp", "(", "input_params", ",", "xvals", ",", "yvals", ",", "slope1_fit", ")", ":", "params", "=", "np", ".", "hstack", "(", "[", "slope1_fit", ",", "input_params", "]", ")", "num_x", "=", "len", "(", "xvals", ")", "y_model", "=", "np", ".", "zeros", "(", "num_x", ",", "dtype", "=", "float", ")", "residuals", "=", "np", ".", "zeros", "(", "num_x", ",", "dtype", "=", "float", ")", "for", "iloc", "in", "range", "(", "0", ",", "num_x", ")", ":", "y_model", "[", "iloc", "]", "=", "piecewise_linear_scalar", "(", "params", ",", "xvals", "[", "iloc", "]", ")", "residuals", "[", "iloc", "]", "=", "(", "yvals", "[", "iloc", "]", "-", "y_model", "[", "iloc", "]", ")", "**", "2.0", "return", "np", ".", "sum", "(", "residuals", ")" ]

[ "Returns", "the", "residual", "sum", "-", "of", "-", "squares", "value", "of", "a", "bilinear", "fit", "to", "a", "data", "set", "-", "with", "a", "segment", "-", "1", "gradient", "fixed", "by", "an", "input", "value", "(", "slope_1_fit", ")" ]

[ "def", "floatformat", "(", "fmt_string", ")", ":", "fmt_defaults", "=", "scientificformat", ".", "__defaults__", "scientificformat", ".", "__defaults__", "=", "(", "fmt_string", ",", ")", "+", "fmt_defaults", "[", "1", ":", "]", "try", ":", "yield", "finally", ":", "scientificformat", ".", "__defaults__", "=", "fmt_defaults" ]

[ "Context", "manager", "to", "change", "the", "default", "format", "string", "for", "the", "function", ":", "func", ":", "openquake", ".", "commonlib", ".", "writers", ".", "scientificformat", "." ]

[ "def", "scientificformat", "(", "value", ",", "fmt", "=", "'%13.9E'", ",", "sep", "=", "' '", ",", "sep2", "=", "':'", ")", ":", "if", "isinstance", "(", "value", ",", "numpy", ".", "bool_", ")", ":", "return", "'1'", "if", "value", "else", "'0'", "elif", "isinstance", "(", "value", ",", "bytes", ")", ":", "return", "value", ".", "decode", "(", "'utf8'", ")", "elif", "isinstance", "(", "value", ",", "str", ")", ":", "return", "value", "elif", "hasattr", "(", "value", ",", "'__len__'", ")", ":", "return", "sep", ".", "join", "(", "(", "scientificformat", "(", "f", ",", "fmt", ",", "sep2", ")", "for", "f", "in", "value", ")", ")", "elif", "isinstance", "(", "value", ",", "(", "float", ",", "numpy", ".", "float64", ",", "numpy", ".", "float32", ")", ")", ":", "fmt_value", "=", "fmt", "%", "value", "if", "set", "(", "fmt_value", ")", "<=", "zeroset", ":", "# '-0.0000000E+00' is converted into '0.0000000E+00", "fmt_value", "=", "fmt_value", ".", "replace", "(", "'-'", ",", "''", ")", "return", "fmt_value", "return", "str", "(", "value", ")" ]

[ ":", "param", "value", ":", "the", "value", "to", "convert", "into", "a", "string", ":", "param", "fmt", ":", "the", "formatting", "string", "to", "use", "for", "float", "values", ":", "param", "sep", ":", "separator", "to", "use", "for", "vector", "-", "like", "values", ":", "param", "sep2", ":", "second", "separator", "to", "use", "for", "matrix", "-", "like", "values" ]

[ "def", "tostring", "(", "node", ",", "indent", "=", "4", ",", "nsmap", "=", "None", ")", ":", "out", "=", "io", ".", "BytesIO", "(", ")", "writer", "=", "StreamingXMLWriter", "(", "out", ",", "indent", ",", "nsmap", "=", "nsmap", ")", "writer", ".", "serialize", "(", "node", ")", "return", "out", ".", "getvalue", "(", ")" ]

[ "Convert", "a", "node", "into", "an", "XML", "string", "by", "using", "the", "StreamingXMLWriter", ".", "This", "is", "useful", "for", "testing", "purposes", "." ]

[ "def", "parse", "(", "source", ",", "remove_comments", "=", "True", ",", "*", "*", "kw", ")", ":", "return", "ElementTree", ".", "parse", "(", "source", ",", "SourceLineParser", "(", ")", ",", "*", "*", "kw", ")" ]

[ "Thin", "wrapper", "around", "ElementTree", ".", "parse" ]

[ "def", "iterparse", "(", "source", ",", "events", "=", "(", "'end'", ",", ")", ",", "remove_comments", "=", "True", ",", "*", "*", "kw", ")", ":", "return", "ElementTree", ".", "iterparse", "(", "source", ",", "events", ",", "SourceLineParser", "(", ")", ",", "*", "*", "kw", ")" ]

[ "Thin", "wrapper", "around", "ElementTree", ".", "iterparse" ]

[ "def", "_displayattrs", "(", "attrib", ",", "expandattrs", ")", ":", "if", "not", "attrib", ":", "return", "''", "if", "expandattrs", ":", "alist", "=", "[", "'%s=%r'", "%", "item", "for", "item", "in", "sorted", "(", "attrib", ".", "items", "(", ")", ")", "]", "else", ":", "alist", "=", "list", "(", "attrib", ")", "return", "'{%s}'", "%", "', '", ".", "join", "(", "alist", ")" ]

[ "Helper", "function", "to", "display", "the", "attributes", "of", "a", "Node", "object", "in", "lexicographic", "order", "." ]

[ "def", "_display", "(", "node", ",", "indent", ",", "expandattrs", ",", "expandvals", ",", "output", ")", ":", "attrs", "=", "_displayattrs", "(", "node", ".", "attrib", ",", "expandattrs", ")", "if", "node", ".", "text", "is", "None", "or", "not", "expandvals", ":", "val", "=", "''", "elif", "isinstance", "(", "node", ".", "text", ",", "str", ")", ":", "val", "=", "' %s'", "%", "repr", "(", "node", ".", "text", ".", "strip", "(", ")", ")", "else", ":", "val", "=", "' %s'", "%", "repr", "(", "node", ".", "text", ")", "# node.text can be a tuple", "output", ".", "write", "(", "encode", "(", "indent", "+", "striptag", "(", "node", ".", "tag", ")", "+", "attrs", "+", "val", "+", "'\\n'", ")", ")", "for", "sub_node", "in", "node", ":", "_display", "(", "sub_node", ",", "indent", "+", "' '", ",", "expandattrs", ",", "expandvals", ",", "output", ")" ]

[ "Core", "function", "to", "display", "a", "Node", "object" ]

[ "def", "node_display", "(", "root", ",", "expandattrs", "=", "False", ",", "expandvals", "=", "False", ",", "output", "=", "sys", ".", "stdout", ")", ":", "_display", "(", "root", ",", "''", ",", "expandattrs", ",", "expandvals", ",", "output", ")" ]

[ "Write", "an", "indented", "representation", "of", "the", "Node", "object", "on", "the", "output", ";", "this", "is", "intended", "for", "testing", "/", "debugging", "purposes", "." ]

[ "def", "to_literal", "(", "self", ")", ":", "if", "not", "self", ".", "nodes", ":", "return", "(", "self", ".", "tag", ",", "self", ".", "attrib", ",", "self", ".", "text", ",", "[", "]", ")", "else", ":", "return", "(", "self", ".", "tag", ",", "self", ".", "attrib", ",", "self", ".", "text", ",", "list", "(", "map", "(", "to_literal", ",", "self", ".", "nodes", ")", ")", ")" ]

[ "Convert", "the", "node", "into", "a", "literal", "Python", "object" ]

[ "def", "pprint", "(", "self", ",", "stream", "=", "None", ",", "indent", "=", "1", ",", "width", "=", "80", ",", "depth", "=", "None", ")", ":", "pp", ".", "pprint", "(", "to_literal", "(", "self", ")", ",", "stream", ",", "indent", ",", "width", ",", "depth", ")" ]

[ "Pretty", "print", "the", "underlying", "literal", "Python", "object" ]

[ "def", "node_from_dict", "(", "dic", ",", "nodefactory", "=", "Node", ")", ":", "tag", "=", "dic", "[", "'tag'", "]", "text", "=", "dic", ".", "get", "(", "'text'", ")", "attrib", "=", "dic", ".", "get", "(", "'attrib'", ",", "{", "}", ")", "nodes", "=", "dic", ".", "get", "(", "'nodes'", ",", "[", "]", ")", "if", "not", "nodes", ":", "return", "nodefactory", "(", "tag", ",", "attrib", ",", "text", ")", "return", "nodefactory", "(", "tag", ",", "attrib", ",", "nodes", "=", "list", "(", "map", "(", "node_from_dict", ",", "nodes", ")", ")", ")" ]

[ "Convert", "a", "(", "nested", ")", "dictionary", "with", "attributes", "tag", "attrib", "text", "nodes", "into", "a", "Node", "object", "." ]

[ "def", "node_to_dict", "(", "node", ")", ":", "dic", "=", "dict", "(", "tag", "=", "striptag", "(", "node", ".", "tag", ")", ")", "if", "node", ".", "attrib", ":", "dic", "[", "'attrib'", "]", "=", "node", ".", "attrib", "if", "node", ".", "text", "is", "not", "None", ":", "dic", "[", "'text'", "]", "=", "node", ".", "text", "if", "node", ".", "nodes", ":", "dic", "[", "'nodes'", "]", "=", "[", "node_to_dict", "(", "n", ")", "for", "n", "in", "node", "]", "return", "dic" ]

[ "Convert", "a", "Node", "object", "into", "a", "(", "nested", ")", "dictionary", "with", "attributes", "tag", "attrib", "text", "nodes", "." ]

[ "def", "node_from_elem", "(", "elem", ",", "nodefactory", "=", "Node", ",", "lazy", "=", "(", ")", ")", ":", "children", "=", "list", "(", "elem", ")", "lineno", "=", "getattr", "(", "elem", ",", "'lineno'", ",", "None", ")", "if", "not", "children", ":", "return", "nodefactory", "(", "elem", ".", "tag", ",", "dict", "(", "elem", ".", "attrib", ")", ",", "elem", ".", "text", ",", "lineno", "=", "lineno", ")", "if", "striptag", "(", "elem", ".", "tag", ")", "in", "lazy", ":", "nodes", "=", "(", "node_from_elem", "(", "ch", ",", "nodefactory", ",", "lazy", ")", "for", "ch", "in", "children", ")", "else", ":", "nodes", "=", "[", "node_from_elem", "(", "ch", ",", "nodefactory", ",", "lazy", ")", "for", "ch", "in", "children", "]", "return", "nodefactory", "(", "elem", ".", "tag", ",", "dict", "(", "elem", ".", "attrib", ")", ",", "nodes", "=", "nodes", ",", "lineno", "=", "lineno", ")" ]

[ "Convert", "(", "recursively", ")", "an", "ElementTree", "object", "into", "a", "Node", "object", "." ]

[ "def", "node_to_elem", "(", "root", ")", ":", "def", "generate_elem", "(", "append", ",", "node", ",", "level", ")", ":", "var", "=", "\"e\"", "+", "str", "(", "level", ")", "arg", "=", "repr", "(", "node", ".", "tag", ")", "if", "node", ".", "attrib", ":", "arg", "+=", "\", **%r\"", "%", "node", ".", "attrib", "if", "level", "==", "1", ":", "append", "(", "\"e1 = Element(%s)\"", "%", "arg", ")", "else", ":", "append", "(", "\"%s = SubElement(e%d, %s)\"", "%", "(", "var", ",", "level", "-", "1", ",", "arg", ")", ")", "if", "not", "node", ".", "nodes", ":", "append", "(", "\"%s.text = %r\"", "%", "(", "var", ",", "node", ".", "text", ")", ")", "for", "x", "in", "node", ":", "generate_elem", "(", "append", ",", "x", ",", "level", "+", "1", ")", "# generate code to create a tree", "output", "=", "[", "]", "generate_elem", "(", "output", ".", "append", ",", "root", ",", "1", ")", "# print \"\\n\".join(output)", "namespace", "=", "{", "\"Element\"", ":", "ElementTree", ".", "Element", ",", "\"SubElement\"", ":", "ElementTree", ".", "SubElement", "}", "exec", "(", "\"\\n\"", ".", "join", "(", "output", ")", ",", "globals", "(", ")", ",", "namespace", ")", "return", "namespace", "[", "\"e1\"", "]" ]

[ "Convert", "(", "recursively", ")", "a", "Node", "object", "into", "an", "ElementTree", "object", "." ]

[ "def", "read_nodes", "(", "fname", ",", "filter_elem", ",", "nodefactory", "=", "Node", ",", "remove_comments", "=", "True", ")", ":", "try", ":", "for", "_", ",", "el", "in", "iterparse", "(", "fname", ",", "remove_comments", "=", "remove_comments", ")", ":", "if", "filter_elem", "(", "el", ")", ":", "yield", "node_from_elem", "(", "el", ",", "nodefactory", ")", "el", ".", "clear", "(", ")", "# save memory", "except", "Exception", ":", "etype", ",", "exc", ",", "tb", "=", "sys", ".", "exc_info", "(", ")", "msg", "=", "str", "(", "exc", ")", "if", "not", "str", "(", "fname", ")", "in", "msg", ":", "msg", "=", "'%s in %s'", "%", "(", "msg", ",", "fname", ")", "raise_", "(", "etype", ",", "msg", ",", "tb", ")" ]

[ "Convert", "an", "XML", "file", "into", "a", "lazy", "iterator", "over", "Node", "objects", "satifying", "the", "given", "specification", "i", ".", "e", ".", "a", "function", "element", "-", ">", "boolean", "." ]

[ "def", "node_from_xml", "(", "xmlfile", ",", "nodefactory", "=", "Node", ")", ":", "root", "=", "parse", "(", "xmlfile", ")", ".", "getroot", "(", ")", "return", "node_from_elem", "(", "root", ",", "nodefactory", ")" ]

[ "Convert", "a", ".", "xml", "file", "into", "a", "Node", "object", "." ]

[ "def", "node_to_xml", "(", "node", ",", "output", "=", "sys", ".", "stdout", ",", "nsmap", "=", "None", ")", ":", "if", "nsmap", ":", "for", "ns", ",", "prefix", "in", "nsmap", ".", "items", "(", ")", ":", "if", "prefix", ":", "node", "[", "'xmlns:'", "+", "prefix", "[", ":", "-", "1", "]", "]", "=", "ns", "else", ":", "node", "[", "'xmlns'", "]", "=", "ns", "with", "StreamingXMLWriter", "(", "output", ",", "nsmap", "=", "nsmap", ")", "as", "w", ":", "w", ".", "serialize", "(", "node", ")" ]

[ "Convert", "a", "Node", "object", "into", "a", "pretty", ".", "xml", "file", "without", "keeping", "everything", "in", "memory", ".", "If", "you", "just", "want", "the", "string", "representation", "use", "tostring", "(", "node", ")", "." ]

[ "def", "node_from_ini", "(", "ini_file", ",", "nodefactory", "=", "Node", ",", "root_name", "=", "'ini'", ")", ":", "fileobj", "=", "open", "(", "ini_file", ")", "if", "isinstance", "(", "ini_file", ",", "str", ")", "else", "ini_file", "cfp", "=", "configparser", ".", "RawConfigParser", "(", ")", "cfp", ".", "read_file", "(", "fileobj", ")", "root", "=", "nodefactory", "(", "root_name", ")", "sections", "=", "cfp", ".", "sections", "(", ")", "for", "section", "in", "sections", ":", "params", "=", "dict", "(", "cfp", ".", "items", "(", "section", ")", ")", "root", ".", "append", "(", "Node", "(", "section", ",", "params", ")", ")", "return", "root" ]

[ "Convert", "a", ".", "ini", "file", "into", "a", "Node", "object", "." ]

[ "def", "node_to_ini", "(", "node", ",", "output", "=", "sys", ".", "stdout", ")", ":", "for", "subnode", "in", "node", ":", "output", ".", "write", "(", "u'\\n[%s]\\n'", "%", "subnode", ".", "tag", ")", "for", "name", ",", "value", "in", "sorted", "(", "subnode", ".", "attrib", ".", "items", "(", ")", ")", ":", "output", ".", "write", "(", "u'%s=%s\\n'", "%", "(", "name", ",", "value", ")", ")", "output", ".", "flush", "(", ")" ]

[ "Convert", "a", "Node", "object", "with", "the", "right", "structure", "into", "a", ".", "ini", "file", "." ]

[ "def", "node_copy", "(", "node", ",", "nodefactory", "=", "Node", ")", ":", "return", "nodefactory", "(", "node", ".", "tag", ",", "node", ".", "attrib", ".", "copy", "(", ")", ",", "node", ".", "text", ",", "[", "node_copy", "(", "n", ",", "nodefactory", ")", "for", "n", "in", "node", "]", ")" ]

[ "Make", "a", "deep", "copy", "of", "the", "node" ]

[ "def", "context", "(", "fname", ",", "node", ")", ":", "try", ":", "yield", "node", "except", "Exception", ":", "etype", ",", "exc", ",", "tb", "=", "sys", ".", "exc_info", "(", ")", "msg", "=", "'node %s: %s, line %s of %s'", "%", "(", "striptag", "(", "node", ".", "tag", ")", ",", "exc", ",", "getattr", "(", "node", ",", "'lineno'", ",", "'?'", ")", ",", "fname", ")", "raise_", "(", "etype", ",", "msg", ",", "tb", ")" ]

[ "Context", "manager", "managing", "exceptions", "and", "adding", "line", "number", "of", "the", "current", "node", "and", "name", "of", "the", "current", "file", "to", "the", "error", "message", "." ]

[ "def", "shorten", "(", "self", ",", "tag", ")", ":", "if", "tag", ".", "startswith", "(", "'{'", ")", ":", "ns", ",", "_tag", "=", "tag", ".", "rsplit", "(", "'}'", ")", "tag", "=", "self", ".", "nsmap", ".", "get", "(", "ns", "[", "1", ":", "]", ",", "''", ")", "+", "_tag", "return", "tag" ]

[ "Get", "the", "short", "representation", "of", "a", "fully", "qualified", "tag" ]

[ "def", "_write", "(", "self", ",", "text", ")", ":", "spaces", "=", "' '", "*", "(", "self", ".", "indent", "*", "self", ".", "indentlevel", ")", "t", "=", "spaces", "+", "text", ".", "strip", "(", ")", "+", "'\\n'", "if", "hasattr", "(", "t", ",", "'encode'", ")", ":", "t", "=", "t", ".", "encode", "(", "self", ".", "encoding", ",", "'xmlcharrefreplace'", ")", "self", ".", "stream", ".", "write", "(", "t", ")" ]

[ "Write", "text", "by", "respecting", "the", "current", "indentlevel" ]

[ "def", "emptyElement", "(", "self", ",", "name", ",", "attrs", ")", ":", "attr", "=", "' '", ".", "join", "(", "'%s=%s'", "%", "(", "n", ",", "quoteattr", "(", "scientificformat", "(", "v", ")", ")", ")", "for", "n", ",", "v", "in", "sorted", "(", "attrs", ".", "items", "(", ")", ")", ")", "self", ".", "_write", "(", "'<%s %s/>'", "%", "(", "name", ",", "attr", ")", ")" ]

[ "Add", "an", "empty", "element", "(", "may", "have", "attributes", ")" ]

[ "def", "start_tag", "(", "self", ",", "name", ",", "attrs", "=", "None", ")", ":", "if", "not", "attrs", ":", "self", ".", "_write", "(", "'<%s>'", "%", "name", ")", "else", ":", "self", ".", "_write", "(", "'<'", "+", "name", ")", "for", "(", "name", ",", "value", ")", "in", "sorted", "(", "attrs", ".", "items", "(", ")", ")", ":", "self", ".", "_write", "(", "' %s=%s'", "%", "(", "name", ",", "quoteattr", "(", "scientificformat", "(", "value", ")", ")", ")", ")", "self", ".", "_write", "(", "'>'", ")", "self", ".", "indentlevel", "+=", "1" ]

[ "Open", "an", "XML", "tag" ]

[ "def", "serialize", "(", "self", ",", "node", ")", ":", "if", "isinstance", "(", "node", ".", "tag", ",", "types", ".", "FunctionType", ")", ":", "# this looks like a bug of ElementTree: comments are stored as", "# functions!?? see https://hg.python.org/sandbox/python2.7/file/tip/Lib/xml/etree/ElementTree.py#l458", "return", "if", "self", ".", "nsmap", "is", "not", "None", ":", "tag", "=", "self", ".", "shorten", "(", "node", ".", "tag", ")", "else", ":", "tag", "=", "node", ".", "tag", "with", "warnings", ".", "catch_warnings", "(", ")", ":", "# unwanted ElementTree warning", "warnings", ".", "simplefilter", "(", "'ignore'", ")", "leafnode", "=", "not", "node", "# NB: we cannot use len(node) to identify leafs since nodes containing", "# an iterator have no length. They are always True, even if empty :-(", "if", "leafnode", "and", "node", ".", "text", "is", "None", ":", "self", ".", "emptyElement", "(", "tag", ",", "node", ".", "attrib", ")", "return", "self", ".", "start_tag", "(", "tag", ",", "node", ".", "attrib", ")", "if", "node", ".", "text", "is", "not", "None", ":", "txt", "=", "escape", "(", "scientificformat", "(", "node", ".", "text", ")", ".", "strip", "(", ")", ")", "if", "txt", ":", "self", ".", "_write", "(", "txt", ")", "for", "subnode", "in", "node", ":", "self", ".", "serialize", "(", "subnode", ")", "self", ".", "end_tag", "(", "tag", ")" ]

[ "Serialize", "a", "node", "object", "(", "typically", "an", "ElementTree", "object", ")" ]

[ "def", "getnodes", "(", "self", ",", "name", ")", ":", "for", "node", "in", "self", ".", "nodes", ":", "if", "striptag", "(", "node", ".", "tag", ")", "==", "name", ":", "yield", "node" ]

[ "Return", "the", "direct", "subnodes", "with", "name", "name" ]

[ "def", "append", "(", "self", ",", "node", ")", ":", "if", "not", "isinstance", "(", "node", ",", "self", ".", "__class__", ")", ":", "raise", "TypeError", "(", "'Expected Node instance, got %r'", "%", "node", ")", "self", ".", "nodes", ".", "append", "(", "node", ")" ]

[ "Append", "a", "new", "subnode" ]

[ "def", "to_str", "(", "self", ",", "expandattrs", "=", "True", ",", "expandvals", "=", "True", ")", ":", "out", "=", "io", ".", "BytesIO", "(", ")", "node_display", "(", "self", ",", "expandattrs", ",", "expandvals", ",", "out", ")", "return", "decode", "(", "out", ".", "getvalue", "(", ")", ")" ]

[ "Convert", "the", "node", "into", "a", "string", "intended", "for", "testing", "/", "debugging", "purposes" ]

[ "def", "parse_bytes", "(", "self", ",", "bytestr", ",", "isfinal", "=", "True", ")", ":", "with", "self", ".", "_context", "(", ")", ":", "self", ".", "filename", "=", "None", "self", ".", "p", ".", "Parse", "(", "bytestr", ",", "isfinal", ")", "return", "self", ".", "_root" ]

[ "Parse", "a", "byte", "string", ".", "If", "the", "string", "is", "very", "large", "split", "it", "in", "chuncks", "and", "parse", "each", "chunk", "with", "isfinal", "=", "False", "then", "parse", "an", "empty", "chunk", "with", "isfinal", "=", "True", "." ]

[ "def", "parse_file", "(", "self", ",", "file_or_fname", ")", ":", "with", "self", ".", "_context", "(", ")", ":", "if", "hasattr", "(", "file_or_fname", ",", "'read'", ")", ":", "self", ".", "filename", "=", "getattr", "(", "file_or_fname", ",", "'name'", ",", "file_or_fname", ".", "__class__", ".", "__name__", ")", "self", ".", "p", ".", "ParseFile", "(", "file_or_fname", ")", "else", ":", "self", ".", "filename", "=", "file_or_fname", "with", "open", "(", "file_or_fname", ",", "'rb'", ")", "as", "f", ":", "self", ".", "p", ".", "ParseFile", "(", "f", ")", "return", "self", ".", "_root" ]

[ "Parse", "a", "file", "or", "a", "filename" ]

[ "def", "completeness", "(", "self", ",", "catalogue", ",", "config", ",", "saveplot", "=", "False", ",", "filetype", "=", "'png'", ",", "timeout", "=", "120", ")", ":", "if", "saveplot", "and", "not", "isinstance", "(", "saveplot", ",", "str", ")", ":", "raise", "ValueError", "(", "'To save the figures enter a filename: '", ")", "# Get magntitude bins", "magnitude_bins", "=", "self", ".", "_get_magnitudes_from_spacing", "(", "catalogue", ".", "data", "[", "'magnitude'", "]", ",", "config", "[", "'magnitude_bin'", "]", ")", "dec_time", "=", "catalogue", ".", "get_decimal_time", "(", ")", "completeness_table", "=", "np", ".", "zeros", "(", "[", "len", "(", "magnitude_bins", ")", "-", "1", ",", "2", "]", ",", "dtype", "=", "float", ")", "min_year", "=", "float", "(", "np", ".", "min", "(", "catalogue", ".", "data", "[", "'year'", "]", ")", ")", "max_year", "=", "float", "(", "np", ".", "max", "(", "catalogue", ".", "data", "[", "'year'", "]", ")", ")", "+", "1.0", "has_completeness", "=", "np", ".", "zeros", "(", "len", "(", "magnitude_bins", ")", "-", "1", ",", "dtype", "=", "bool", ")", "for", "iloc", "in", "range", "(", "0", ",", "len", "(", "magnitude_bins", ")", "-", "1", ")", ":", "lower_mag", "=", "magnitude_bins", "[", "iloc", "]", "upper_mag", "=", "magnitude_bins", "[", "iloc", "+", "1", "]", "idx", "=", "np", ".", "logical_and", "(", "catalogue", ".", "data", "[", "'magnitude'", "]", ">=", "lower_mag", ",", "catalogue", ".", "data", "[", "'magnitude'", "]", "<", "upper_mag", ")", "cumvals", "=", "np", ".", "cumsum", "(", "np", ".", "ones", "(", "np", ".", "sum", "(", "idx", ")", ")", ")", "plt", ".", "plot", "(", "dec_time", "[", "idx", "]", ",", "cumvals", ",", "'.'", ")", "plt", ".", "xlim", "(", "min_year", ",", "max_year", "+", "5", ")", "title_string", "=", "'Magnitude %5.2f to %5.2f'", "%", "(", "lower_mag", ",", "upper_mag", ")", "plt", ".", "title", "(", "title_string", ")", "pts", "=", "pylab", ".", "ginput", "(", "1", ",", "timeout", "=", "timeout", ")", "[", "0", "]", "if", "pts", "[", "0", "]", "<=", "max_year", ":", "# Magnitude bin has no completeness!", "has_completeness", "[", "iloc", "]", "=", "True", "completeness_table", "[", "iloc", ",", "0", "]", "=", "np", ".", "floor", "(", "pts", "[", "0", "]", ")", "completeness_table", "[", "iloc", ",", "1", "]", "=", "magnitude_bins", "[", "iloc", "]", "print", "(", "completeness_table", "[", "iloc", ",", ":", "]", ",", "has_completeness", "[", "iloc", "]", ")", "if", "config", "[", "'increment_lock'", "]", "and", "(", "iloc", ">", "0", ")", "and", "(", "completeness_table", "[", "iloc", ",", "0", "]", ">", "completeness_table", "[", "iloc", "-", "1", ",", "0", "]", ")", ":", "completeness_table", "[", "iloc", ",", "0", "]", "=", "completeness_table", "[", "iloc", "-", "1", ",", "0", "]", "# Add marker line to indicate completeness point", "marker_line", "=", "np", ".", "array", "(", "[", "[", "0.", ",", "completeness_table", "[", "iloc", ",", "0", "]", "]", ",", "[", "cumvals", "[", "-", "1", "]", ",", "completeness_table", "[", "iloc", ",", "0", "]", "]", "]", ")", "plt", ".", "plot", "(", "marker_line", "[", ":", ",", "0", "]", ",", "marker_line", "[", ":", ",", "1", "]", ",", "'r-'", ")", "if", "saveplot", ":", "filename", "=", "saveplot", "+", "'_'", "+", "(", "'%5.2f'", "%", "lower_mag", ")", "+", "(", "'%5.2f'", "%", "upper_mag", ")", "+", "'.'", "+", "filetype", "plt", ".", "savefig", "(", "filename", ",", "format", "=", "filetype", ")", "plt", ".", "close", "(", ")", "return", "completeness_table", "[", "has_completeness", ",", ":", "]" ]

[ ":", "param", "catalogue", ":", "Earthquake", "catalogue", "as", "instance", "of", ":", "class", ":", "openquake", ".", "hmtk", ".", "seismicity", ".", "catalogue", ".", "Catalogue", ":", "param", "dict", "config", ":", "Configuration", "parameters", "of", "the", "algorithm", "containing", "the", "following", "information", ":", "magnitude_bin", "Size", "of", "magnitude", "bin", "(", "non", "-", "negative", "float", ")", "time_bin", "Size", "(", "in", "dec", ".", "years", ")", "of", "the", "time", "window", "(", "non", "-", "negative", "float", ")", "increment_lock", "Boolean", "to", "indicate", "whether", "to", "ensure", "completeness", "magnitudes", "always", "decrease", "with", "more", "recent", "bins", ":", "returns", ":", "2", "-", "column", "table", "indicating", "year", "of", "completeness", "and", "corresponding", "magnitude", "numpy", ".", "ndarray" ]

[ "def", "_get_magnitudes_from_spacing", "(", "self", ",", "magnitudes", ",", "delta_m", ")", ":", "min_mag", "=", "np", ".", "min", "(", "magnitudes", ")", "max_mag", "=", "np", ".", "max", "(", "magnitudes", ")", "if", "(", "max_mag", "-", "min_mag", ")", "<", "delta_m", ":", "raise", "ValueError", "(", "'Bin width greater than magnitude range!'", ")", "mag_bins", "=", "np", ".", "arange", "(", "np", ".", "floor", "(", "min_mag", ")", ",", "np", ".", "ceil", "(", "max_mag", ")", ",", "delta_m", ")", "# Check to see if there are magnitudes in lower and upper bins", "is_mag", "=", "np", ".", "logical_and", "(", "mag_bins", "-", "max_mag", "<", "delta_m", ",", "min_mag", "-", "mag_bins", "<", "delta_m", ")", "mag_bins", "=", "mag_bins", "[", "is_mag", "]", "return", "mag_bins" ]

[ "If", "a", "single", "magnitude", "spacing", "is", "input", "then", "create", "the", "bins" ]

[ "def", "_merge_data", "(", "dat1", ",", "dat2", ")", ":", "cnt", "=", "0", "for", "key", "in", "dat1", ":", "flg1", "=", "len", "(", "dat1", "[", "key", "]", ")", ">", "0", "flg2", "=", "len", "(", "dat2", "[", "key", "]", ")", ">", "0", "if", "flg1", "!=", "flg2", ":", "cnt", "+=", "1", "if", "cnt", ":", "raise", "Warning", "(", "'Cannot merge catalogues with different'", "+", "' attributes'", ")", "return", "None", "else", ":", "for", "key", "in", "dat1", ":", "if", "isinstance", "(", "dat1", "[", "key", "]", ",", "np", ".", "ndarray", ")", ":", "dat1", "[", "key", "]", "=", "np", ".", "concatenate", "(", "(", "dat1", "[", "key", "]", ",", "dat2", "[", "key", "]", ")", ",", "axis", "=", "0", ")", "elif", "isinstance", "(", "dat1", "[", "key", "]", ",", "list", ")", ":", "dat1", "[", "key", "]", "+=", "dat2", "[", "key", "]", "else", ":", "raise", "ValueError", "(", "'Unknown type'", ")", "return", "dat1" ]

[ "Merge", "two", "data", "dictionaries", "containing", "catalogue", "data" ]

[ "def", "_get_row_str", "(", "self", ",", "i", ")", ":", "row_data", "=", "[", "\"{:s}\"", ".", "format", "(", "self", ".", "data", "[", "'eventID'", "]", "[", "i", "]", ")", ",", "\"{:g}\"", ".", "format", "(", "self", ".", "data", "[", "'year'", "]", "[", "i", "]", ")", ",", "\"{:g}\"", ".", "format", "(", "self", ".", "data", "[", "'month'", "]", "[", "i", "]", ")", ",", "\"{:g}\"", ".", "format", "(", "self", ".", "data", "[", "'day'", "]", "[", "i", "]", ")", ",", "\"{:g}\"", ".", "format", "(", "self", ".", "data", "[", "'hour'", "]", "[", "i", "]", ")", ",", "\"{:g}\"", ".", "format", "(", "self", ".", "data", "[", "'minute'", "]", "[", "i", "]", ")", ",", "\"{:.1f}\"", ".", "format", "(", "self", ".", "data", "[", "'second'", "]", "[", "i", "]", ")", ",", "\"{:.3f}\"", ".", "format", "(", "self", ".", "data", "[", "'longitude'", "]", "[", "i", "]", ")", ",", "\"{:.3f}\"", ".", "format", "(", "self", ".", "data", "[", "'latitude'", "]", "[", "i", "]", ")", ",", "\"{:.1f}\"", ".", "format", "(", "self", ".", "data", "[", "'depth'", "]", "[", "i", "]", ")", ",", "\"{:.1f}\"", ".", "format", "(", "self", ".", "data", "[", "'magnitude'", "]", "[", "i", "]", ")", "]", "return", "\" \"", ".", "join", "(", "row_data", ")" ]

[ "Returns", "a", "string", "representation", "of", "the", "key", "information", "in", "a", "row" ]

[ "def", "write_catalogue", "(", "self", ",", "output_file", ",", "key_list", "=", "SORTED_ATTRIBUTE_LIST", ")", ":", "with", "open", "(", "output_file", ",", "'w'", ")", "as", "of", ":", "writer", "=", "csv", ".", "DictWriter", "(", "of", ",", "fieldnames", "=", "key_list", ")", "writer", ".", "writeheader", "(", ")", "for", "i", "in", "range", "(", "self", ".", "get_number_events", "(", ")", ")", ":", "row_dict", "=", "{", "}", "for", "key", "in", "key_list", ":", "if", "len", "(", "self", ".", "data", "[", "key", "]", ")", ">", "0", ":", "data", "=", "self", ".", "data", "[", "key", "]", "[", "i", "]", "if", "key", "in", "self", ".", "INT_ATTRIBUTE_LIST", ":", "if", "np", ".", "isnan", "(", "data", ")", ":", "data", "=", "''", "else", ":", "data", "=", "int", "(", "data", ")", "if", "key", "in", "self", ".", "FLOAT_ATTRIBUTE_LIST", ":", "if", "np", ".", "isnan", "(", "data", ")", ":", "data", "=", "''", "else", ":", "data", "=", "float", "(", "data", ")", "row_dict", "[", "key", "]", "=", "data", "writer", ".", "writerow", "(", "row_dict", ")" ]

[ "Writes", "the", "catalogue", "to", "file", "using", "HTMK", "format", "(", "CSV", ")", "." ]

[ "def", "load_to_array", "(", "self", ",", "keys", ")", ":", "# Preallocate the numpy array", "data", "=", "np", ".", "empty", "(", "(", "len", "(", "self", ".", "data", "[", "keys", "[", "0", "]", "]", ")", ",", "len", "(", "keys", ")", ")", ")", "for", "i", "in", "range", "(", "0", ",", "len", "(", "self", ".", "data", "[", "keys", "[", "0", "]", "]", ")", ")", ":", "for", "j", ",", "key", "in", "enumerate", "(", "keys", ")", ":", "data", "[", "i", ",", "j", "]", "=", "self", ".", "data", "[", "key", "]", "[", "i", "]", "return", "data" ]

[ "This", "loads", "the", "data", "contained", "in", "the", "catalogue", "into", "a", "numpy", "array", ".", "The", "method", "works", "only", "for", "float", "data" ]

[ "def", "load_from_array", "(", "self", ",", "keys", ",", "data_array", ")", ":", "if", "len", "(", "keys", ")", "!=", "np", ".", "shape", "(", "data_array", ")", "[", "1", "]", ":", "raise", "ValueError", "(", "'Key list does not match shape of array!'", ")", "for", "i", ",", "key", "in", "enumerate", "(", "keys", ")", ":", "if", "key", "in", "self", ".", "INT_ATTRIBUTE_LIST", ":", "self", ".", "data", "[", "key", "]", "=", "data_array", "[", ":", ",", "i", "]", ".", "astype", "(", "int", ")", "else", ":", "self", ".", "data", "[", "key", "]", "=", "data_array", "[", ":", ",", "i", "]", "if", "key", "not", "in", "self", ".", "TOTAL_ATTRIBUTE_LIST", ":", "print", "(", "'Key %s not a recognised catalogue attribute'", "%", "key", ")", "self", ".", "update_end_year", "(", ")" ]

[ "This", "loads", "the", "data", "contained", "in", "an", "array", "into", "the", "catalogue", "object" ]

[ "def", "catalogue_mt_filter", "(", "self", ",", "mt_table", ",", "flag", "=", "None", ")", ":", "if", "flag", "is", "None", ":", "# No flag defined, therefore all events are initially valid", "flag", "=", "np", ".", "ones", "(", "self", ".", "get_number_events", "(", ")", ",", "dtype", "=", "bool", ")", "for", "comp_val", "in", "mt_table", ":", "id0", "=", "np", ".", "logical_and", "(", "self", ".", "data", "[", "'year'", "]", ".", "astype", "(", "float", ")", "<", "comp_val", "[", "0", "]", ",", "self", ".", "data", "[", "'magnitude'", "]", "<", "comp_val", "[", "1", "]", ")", "print", "(", "id0", ")", "flag", "[", "id0", "]", "=", "False", "if", "not", "np", ".", "all", "(", "flag", ")", ":", "self", ".", "purge_catalogue", "(", "flag", ")" ]

[ "Filter", "the", "catalogue", "using", "a", "magnitude", "-", "time", "table", ".", "The", "table", "has", "two", "columns", "and", "n", "-", "rows", "." ]

[ "def", "get_bounding_box", "(", "self", ")", ":", "return", "(", "np", ".", "min", "(", "self", ".", "data", "[", "\"longitude\"", "]", ")", ",", "np", ".", "max", "(", "self", ".", "data", "[", "\"longitude\"", "]", ")", ",", "np", ".", "min", "(", "self", ".", "data", "[", "\"latitude\"", "]", ")", ",", "np", ".", "max", "(", "self", ".", "data", "[", "\"latitude\"", "]", ")", ")" ]

[ "Returns", "the", "bounding", "box", "of", "the", "catalogue" ]

[ "def", "get_observed_mmax_sigma", "(", "self", ",", "default", "=", "None", ")", ":", "if", "not", "isinstance", "(", "self", ".", "data", "[", "'sigmaMagnitude'", "]", ",", "np", ".", "ndarray", ")", ":", "obsmaxsig", "=", "default", "else", ":", "obsmaxsig", "=", "self", ".", "data", "[", "'sigmaMagnitude'", "]", "[", "np", ".", "argmax", "(", "self", ".", "data", "[", "'magnitude'", "]", ")", "]", "return", "obsmaxsig" ]

[ ":", "returns", ":", "the", "sigma", "for", "the", "maximum", "observed", "magnitude" ]

[ "def", "get_decimal_time", "(", "self", ")", ":", "return", "decimal_time", "(", "self", ".", "data", "[", "'year'", "]", ",", "self", ".", "data", "[", "'month'", "]", ",", "self", ".", "data", "[", "'day'", "]", ",", "self", ".", "data", "[", "'hour'", "]", ",", "self", ".", "data", "[", "'minute'", "]", ",", "self", ".", "data", "[", "'second'", "]", ")" ]

[ "Returns", "the", "time", "of", "the", "catalogue", "as", "a", "decimal" ]

[ "def", "sort_catalogue_chronologically", "(", "self", ")", ":", "dec_time", "=", "self", ".", "get_decimal_time", "(", ")", "idx", "=", "np", ".", "argsort", "(", "dec_time", ")", "if", "np", ".", "all", "(", "(", "idx", "[", "1", ":", "]", "-", "idx", "[", ":", "-", "1", "]", ")", ">", "0.", ")", ":", "# Catalogue was already in chronological order", "return", "self", ".", "select_catalogue_events", "(", "idx", ")" ]

[ "Sorts", "the", "catalogue", "into", "chronological", "order" ]

[ "def", "purge_catalogue", "(", "self", ",", "flag_vector", ")", ":", "id0", "=", "np", ".", "where", "(", "flag_vector", ")", "[", "0", "]", "self", ".", "select_catalogue_events", "(", "id0", ")", "self", ".", "get_number_events", "(", ")" ]

[ "Purges", "present", "catalogue", "with", "invalid", "events", "defined", "by", "flag_vector" ]

[ "def", "select_catalogue_events", "(", "self", ",", "id0", ")", ":", "for", "key", "in", "self", ".", "data", ":", "if", "isinstance", "(", "self", ".", "data", "[", "key", "]", ",", "np", ".", "ndarray", ")", "and", "len", "(", "self", ".", "data", "[", "key", "]", ")", ">", "0", ":", "# Dictionary element is numpy array - use logical indexing", "self", ".", "data", "[", "key", "]", "=", "self", ".", "data", "[", "key", "]", "[", "id0", "]", "elif", "isinstance", "(", "self", ".", "data", "[", "key", "]", ",", "list", ")", "and", "len", "(", "self", ".", "data", "[", "key", "]", ")", ">", "0", ":", "# Dictionary element is list", "self", ".", "data", "[", "key", "]", "=", "[", "self", ".", "data", "[", "key", "]", "[", "iloc", "]", "for", "iloc", "in", "id0", "]", "else", ":", "continue" ]

[ "Orders", "the", "events", "in", "the", "catalogue", "according", "to", "an", "indexing", "vector", "." ]

[ "def", "get_depth_distribution", "(", "self", ",", "depth_bins", ",", "normalisation", "=", "False", ",", "bootstrap", "=", "None", ")", ":", "if", "len", "(", "self", ".", "data", "[", "'depth'", "]", ")", "==", "0", ":", "# If depth information is missing", "raise", "ValueError", "(", "'Depths missing in catalogue'", ")", "if", "len", "(", "self", ".", "data", "[", "'depthError'", "]", ")", "==", "0", ":", "self", ".", "data", "[", "'depthError'", "]", "=", "np", ".", "zeros", "(", "self", ".", "get_number_events", "(", ")", ",", "dtype", "=", "float", ")", "return", "bootstrap_histogram_1D", "(", "self", ".", "data", "[", "'depth'", "]", ",", "depth_bins", ",", "self", ".", "data", "[", "'depthError'", "]", ",", "normalisation", "=", "normalisation", ",", "number_bootstraps", "=", "bootstrap", ",", "boundaries", "=", "(", "0.", ",", "None", ")", ")" ]

[ "Gets", "the", "depth", "distribution", "of", "the", "earthquake", "catalogue", "to", "return", "a", "single", "histogram", ".", "Depths", "may", "be", "normalised", ".", "If", "uncertainties", "are", "found", "in", "the", "catalogue", "the", "distrbution", "may", "be", "bootstrap", "sampled" ]

[ "def", "get_depth_pmf", "(", "self", ",", "depth_bins", ",", "default_depth", "=", "5.0", ",", "bootstrap", "=", "None", ")", ":", "if", "len", "(", "self", ".", "data", "[", "'depth'", "]", ")", "==", "0", ":", "# If depth information is missing", "return", "PMF", "(", "[", "(", "1.0", ",", "default_depth", ")", "]", ")", "# Get the depth distribution", "depth_hist", "=", "self", ".", "get_depth_distribution", "(", "depth_bins", ",", "normalisation", "=", "True", ",", "bootstrap", "=", "bootstrap", ")", "# If the histogram does not sum to 1.0 then remove the difference", "# from the lowest bin", "depth_hist", "=", "np", ".", "around", "(", "depth_hist", ",", "3", ")", "while", "depth_hist", ".", "sum", "(", ")", "-", "1.0", ":", "depth_hist", "[", "-", "1", "]", "-=", "depth_hist", ".", "sum", "(", ")", "-", "1.0", "depth_hist", "=", "np", ".", "around", "(", "depth_hist", ",", "3", ")", "pmf_list", "=", "[", "]", "for", "iloc", ",", "prob", "in", "enumerate", "(", "depth_hist", ")", ":", "pmf_list", ".", "append", "(", "(", "prob", ",", "(", "depth_bins", "[", "iloc", "]", "+", "depth_bins", "[", "iloc", "+", "1", "]", ")", "/", "2.0", ")", ")", "return", "PMF", "(", "pmf_list", ")" ]

[ "Returns", "the", "depth", "distribution", "of", "the", "catalogue", "as", "a", "probability", "mass", "function" ]

[ "def", "get_magnitude_depth_distribution", "(", "self", ",", "magnitude_bins", ",", "depth_bins", ",", "normalisation", "=", "False", ",", "bootstrap", "=", "None", ")", ":", "if", "len", "(", "self", ".", "data", "[", "'depth'", "]", ")", "==", "0", ":", "# If depth information is missing", "raise", "ValueError", "(", "'Depths missing in catalogue'", ")", "if", "len", "(", "self", ".", "data", "[", "'depthError'", "]", ")", "==", "0", ":", "self", ".", "data", "[", "'depthError'", "]", "=", "np", ".", "zeros", "(", "self", ".", "get_number_events", "(", ")", ",", "dtype", "=", "float", ")", "if", "len", "(", "self", ".", "data", "[", "'sigmaMagnitude'", "]", ")", "==", "0", ":", "self", ".", "data", "[", "'sigmaMagnitude'", "]", "=", "np", ".", "zeros", "(", "self", ".", "get_number_events", "(", ")", ",", "dtype", "=", "float", ")", "return", "bootstrap_histogram_2D", "(", "self", ".", "data", "[", "'magnitude'", "]", ",", "self", ".", "data", "[", "'depth'", "]", ",", "magnitude_bins", ",", "depth_bins", ",", "boundaries", "=", "[", "(", "0.", ",", "None", ")", ",", "(", "None", ",", "None", ")", "]", ",", "xsigma", "=", "self", ".", "data", "[", "'sigmaMagnitude'", "]", ",", "ysigma", "=", "self", ".", "data", "[", "'depthError'", "]", ",", "normalisation", "=", "normalisation", ",", "number_bootstraps", "=", "bootstrap", ")" ]

[ "Returns", "a", "2", "-", "D", "magnitude", "-", "depth", "histogram", "for", "the", "catalogue" ]

[ "def", "get_magnitude_time_distribution", "(", "self", ",", "magnitude_bins", ",", "time_bins", ",", "normalisation", "=", "False", ",", "bootstrap", "=", "None", ")", ":", "return", "bootstrap_histogram_2D", "(", "self", ".", "get_decimal_time", "(", ")", ",", "self", ".", "data", "[", "'magnitude'", "]", ",", "time_bins", ",", "magnitude_bins", ",", "xsigma", "=", "np", ".", "zeros", "(", "self", ".", "get_number_events", "(", ")", ")", ",", "ysigma", "=", "self", ".", "data", "[", "'sigmaMagnitude'", "]", ",", "normalisation", "=", "normalisation", ",", "number_bootstraps", "=", "bootstrap", ")" ]

[ "Returns", "a", "2", "-", "D", "histogram", "indicating", "the", "number", "of", "earthquakes", "in", "a", "set", "of", "time", "-", "magnitude", "bins", ".", "Time", "is", "in", "decimal", "years!" ]

[ "def", "concatenate", "(", "self", ",", "catalogue", ")", ":", "atts", "=", "getattr", "(", "self", ",", "'data'", ")", "attn", "=", "getattr", "(", "catalogue", ",", "'data'", ")", "data", "=", "_merge_data", "(", "atts", ",", "attn", ")", "if", "data", "is", "not", "None", ":", "setattr", "(", "self", ",", "'data'", ",", "data", ")", "for", "attrib", "in", "vars", "(", "self", ")", ":", "atts", "=", "getattr", "(", "self", ",", "attrib", ")", "attn", "=", "getattr", "(", "catalogue", ",", "attrib", ")", "if", "attrib", "is", "'end_year'", ":", "setattr", "(", "self", ",", "attrib", ",", "max", "(", "atts", ",", "attn", ")", ")", "elif", "attrib", "is", "'start_year'", ":", "setattr", "(", "self", ",", "attrib", ",", "min", "(", "atts", ",", "attn", ")", ")", "elif", "attrib", "is", "'data'", ":", "pass", "elif", "attrib", "is", "'number_earthquakes'", ":", "setattr", "(", "self", ",", "attrib", ",", "atts", "+", "attn", ")", "elif", "attrib", "is", "'processes'", ":", "if", "atts", "!=", "attn", ":", "raise", "ValueError", "(", "'The catalogues cannot be merged'", "+", "' since the they have'", "+", "' a different processing history'", ")", "else", ":", "raise", "ValueError", "(", "'unknown attribute: %s'", "%", "attrib", ")", "self", ".", "sort_catalogue_chronologically", "(", ")" ]

[ "This", "method", "attaches", "one", "catalogue", "to", "the", "current", "one" ]

[ "def", "classical_bcr", "(", "riskinputs", ",", "riskmodel", ",", "param", ",", "monitor", ")", ":", "R", "=", "riskinputs", "[", "0", "]", ".", "hazard_getter", ".", "num_rlzs", "result", "=", "AccumDict", "(", "accum", "=", "numpy", ".", "zeros", "(", "(", "R", ",", "3", ")", ",", "F32", ")", ")", "for", "ri", "in", "riskinputs", ":", "for", "out", "in", "riskmodel", ".", "gen_outputs", "(", "ri", ",", "monitor", ")", ":", "for", "asset", ",", "(", "eal_orig", ",", "eal_retro", ",", "bcr", ")", "in", "zip", "(", "ri", ".", "assets", ",", "out", "[", "'structural'", "]", ")", ":", "aval", "=", "asset", "[", "'value-structural'", "]", "result", "[", "asset", "[", "'ordinal'", "]", "]", "[", "out", ".", "rlzi", "]", "=", "numpy", ".", "array", "(", "[", "eal_orig", "*", "aval", ",", "eal_retro", "*", "aval", ",", "bcr", "]", ")", "return", "{", "'bcr_data'", ":", "result", "}" ]

[ "Compute", "and", "return", "the", "average", "losses", "for", "each", "asset", "." ]

[ "def", "expose_outputs", "(", "dstore", ",", "owner", "=", "getpass", ".", "getuser", "(", ")", ",", "status", "=", "'complete'", ")", ":", "oq", "=", "dstore", "[", "'oqparam'", "]", "exportable", "=", "set", "(", "ekey", "[", "0", "]", "for", "ekey", "in", "export", ".", "export", ")", "calcmode", "=", "oq", ".", "calculation_mode", "dskeys", "=", "set", "(", "dstore", ")", "&", "exportable", "# exportable datastore keys", "dskeys", ".", "add", "(", "'fullreport'", ")", "rlzs", "=", "dstore", "[", "'csm_info'", "]", ".", "rlzs", "if", "len", "(", "rlzs", ")", ">", "1", ":", "dskeys", ".", "add", "(", "'realizations'", ")", "if", "len", "(", "dstore", "[", "'csm_info/sg_data'", "]", ")", ">", "1", ":", "# export sourcegroups.csv", "dskeys", ".", "add", "(", "'sourcegroups'", ")", "hdf5", "=", "dstore", ".", "hdf5", "if", "'hcurves-stats'", "in", "hdf5", "or", "'hcurves-rlzs'", "in", "hdf5", ":", "if", "oq", ".", "hazard_stats", "(", ")", "or", "oq", ".", "individual_curves", "or", "len", "(", "rlzs", ")", "==", "1", ":", "dskeys", ".", "add", "(", "'hcurves'", ")", "if", "oq", ".", "uniform_hazard_spectra", ":", "dskeys", ".", "add", "(", "'uhs'", ")", "# export them", "if", "oq", ".", "hazard_maps", ":", "dskeys", ".", "add", "(", "'hmaps'", ")", "# export them", "if", "'avg_losses-stats'", "in", "dstore", "or", "(", "'avg_losses-rlzs'", "in", "dstore", "and", "len", "(", "rlzs", ")", ")", ":", "dskeys", ".", "add", "(", "'avg_losses-stats'", ")", "if", "'curves-rlzs'", "in", "dstore", "and", "len", "(", "rlzs", ")", "==", "1", ":", "dskeys", ".", "add", "(", "'loss_curves-rlzs'", ")", "if", "'curves-stats'", "in", "dstore", "and", "len", "(", "rlzs", ")", ">", "1", ":", "dskeys", ".", "add", "(", "'loss_curves-stats'", ")", "if", "oq", ".", "conditional_loss_poes", ":", "# expose loss_maps outputs", "if", "'loss_curves-stats'", "in", "dstore", ":", "dskeys", ".", "add", "(", "'loss_maps-stats'", ")", "if", "'all_loss_ratios'", "in", "dskeys", ":", "dskeys", ".", "remove", "(", "'all_loss_ratios'", ")", "# export only specific IDs", "if", "'ruptures'", "in", "dskeys", "and", "'scenario'", "in", "calcmode", ":", "exportable", ".", "remove", "(", "'ruptures'", ")", "# do not export, as requested by Vitor", "if", "'rup_loss_table'", "in", "dskeys", ":", "# keep it hidden for the moment", "dskeys", ".", "remove", "(", "'rup_loss_table'", ")", "if", "'hmaps'", "in", "dskeys", "and", "not", "oq", ".", "hazard_maps", ":", "dskeys", ".", "remove", "(", "'hmaps'", ")", "# do not export the hazard maps", "if", "logs", ".", "dbcmd", "(", "'get_job'", ",", "dstore", ".", "calc_id", ")", "is", "None", ":", "# the calculation has not been imported in the db yet", "logs", ".", "dbcmd", "(", "'import_job'", ",", "dstore", ".", "calc_id", ",", "oq", ".", "calculation_mode", ",", "oq", ".", "description", "+", "' [parent]'", ",", "owner", ",", "status", ",", "oq", ".", "hazard_calculation_id", ",", "dstore", ".", "datadir", ")", "keysize", "=", "[", "]", "for", "key", "in", "sorted", "(", "dskeys", "&", "exportable", ")", ":", "try", ":", "size_mb", "=", "dstore", ".", "get_attr", "(", "key", ",", "'nbytes'", ")", "/", "MB", "except", "(", "KeyError", ",", "AttributeError", ")", ":", "size_mb", "=", "None", "keysize", ".", "append", "(", "(", "key", ",", "size_mb", ")", ")", "ds_size", "=", "os", ".", "path", ".", "getsize", "(", "dstore", ".", "filename", ")", "/", "MB", "logs", ".", "dbcmd", "(", "'create_outputs'", ",", "dstore", ".", "calc_id", ",", "keysize", ",", "ds_size", ")" ]

[ "Build", "a", "correspondence", "between", "the", "outputs", "in", "the", "datastore", "and", "the", "ones", "in", "the", "database", "." ]

[ "def", "raiseMasterKilled", "(", "signum", ",", "_stack", ")", ":", "# Disable further CTRL-C to allow tasks revocation when Celery is used", "if", "OQ_DISTRIBUTE", ".", "startswith", "(", "'celery'", ")", ":", "signal", ".", "signal", "(", "signal", ".", "SIGINT", ",", "inhibitSigInt", ")", "msg", "=", "'Received a signal %d'", "%", "signum", "if", "signum", "in", "(", "signal", ".", "SIGTERM", ",", "signal", ".", "SIGINT", ")", ":", "msg", "=", "'The openquake master process was killed manually'", "# kill the calculation only if os.getppid() != _PPID, i.e. the controlling", "# terminal died; in the workers, do nothing", "# NB: there is no SIGHUP on Windows", "if", "hasattr", "(", "signal", ",", "'SIGHUP'", ")", ":", "if", "signum", "==", "signal", ".", "SIGHUP", ":", "if", "os", ".", "getppid", "(", ")", "==", "_PPID", ":", "return", "else", ":", "msg", "=", "'The openquake master lost its controlling terminal'", "raise", "MasterKilled", "(", "msg", ")" ]

[ "When", "a", "SIGTERM", "is", "received", "raise", "the", "MasterKilled", "exception", "with", "an", "appropriate", "error", "message", "." ]

[ "def", "job_from_file", "(", "job_ini", ",", "job_id", ",", "username", ",", "*", "*", "kw", ")", ":", "hc_id", "=", "kw", ".", "get", "(", "'hazard_calculation_id'", ")", "try", ":", "oq", "=", "readinput", ".", "get_oqparam", "(", "job_ini", ",", "hc_id", "=", "hc_id", ")", "except", "Exception", ":", "logs", ".", "dbcmd", "(", "'finish'", ",", "job_id", ",", "'failed'", ")", "raise", "if", "'calculation_mode'", "in", "kw", ":", "oq", ".", "calculation_mode", "=", "kw", ".", "pop", "(", "'calculation_mode'", ")", "if", "'description'", "in", "kw", ":", "oq", ".", "description", "=", "kw", ".", "pop", "(", "'description'", ")", "if", "'exposure_file'", "in", "kw", ":", "# hack used in commands.engine", "fnames", "=", "kw", ".", "pop", "(", "'exposure_file'", ")", ".", "split", "(", ")", "if", "fnames", ":", "oq", ".", "inputs", "[", "'exposure'", "]", "=", "fnames", "elif", "'exposure'", "in", "oq", ".", "inputs", ":", "del", "oq", ".", "inputs", "[", "'exposure'", "]", "logs", ".", "dbcmd", "(", "'update_job'", ",", "job_id", ",", "dict", "(", "calculation_mode", "=", "oq", ".", "calculation_mode", ",", "description", "=", "oq", ".", "description", ",", "user_name", "=", "username", ",", "hazard_calculation_id", "=", "hc_id", ")", ")", "return", "oq" ]

[ "Create", "a", "full", "job", "profile", "from", "a", "job", "config", "file", "." ]

[ "def", "poll_queue", "(", "job_id", ",", "pid", ",", "poll_time", ")", ":", "if", "config", ".", "distribution", ".", "serialize_jobs", ":", "first_time", "=", "True", "while", "True", ":", "jobs", "=", "logs", ".", "dbcmd", "(", "GET_JOBS", ")", "failed", "=", "[", "job", ".", "id", "for", "job", "in", "jobs", "if", "not", "psutil", ".", "pid_exists", "(", "job", ".", "pid", ")", "]", "if", "failed", ":", "logs", ".", "dbcmd", "(", "\"UPDATE job SET status='failed', is_running=0 \"", "\"WHERE id in (?X)\"", ",", "failed", ")", "elif", "any", "(", "job", ".", "id", "<", "job_id", "for", "job", "in", "jobs", ")", ":", "if", "first_time", ":", "logs", ".", "LOG", ".", "warn", "(", "'Waiting for jobs %s'", ",", "[", "j", ".", "id", "for", "j", "in", "jobs", "]", ")", "logs", ".", "dbcmd", "(", "'update_job'", ",", "job_id", ",", "{", "'status'", ":", "'submitted'", ",", "'pid'", ":", "pid", "}", ")", "first_time", "=", "False", "time", ".", "sleep", "(", "poll_time", ")", "else", ":", "break", "logs", ".", "dbcmd", "(", "'update_job'", ",", "job_id", ",", "{", "'status'", ":", "'executing'", ",", "'pid'", ":", "_PID", "}", ")" ]

[ "Check", "the", "queue", "of", "executing", "/", "submitted", "jobs", "and", "exit", "when", "there", "is", "a", "free", "slot", "." ]

[ "def", "run_calc", "(", "job_id", ",", "oqparam", ",", "exports", ",", "hazard_calculation_id", "=", "None", ",", "*", "*", "kw", ")", ":", "setproctitle", "(", "'oq-job-%d'", "%", "job_id", ")", "calc", "=", "base", ".", "calculators", "(", "oqparam", ",", "calc_id", "=", "job_id", ")", "logging", ".", "info", "(", "'%s running %s [--hc=%s]'", ",", "getpass", ".", "getuser", "(", ")", ",", "calc", ".", "oqparam", ".", "inputs", "[", "'job_ini'", "]", ",", "calc", ".", "oqparam", ".", "hazard_calculation_id", ")", "logging", ".", "info", "(", "'Using engine version %s'", ",", "__version__", ")", "msg", "=", "check_obsolete_version", "(", "oqparam", ".", "calculation_mode", ")", "if", "msg", ":", "logs", ".", "LOG", ".", "warn", "(", "msg", ")", "if", "OQ_DISTRIBUTE", ".", "startswith", "(", "(", "'celery'", ",", "'zmq'", ")", ")", ":", "set_concurrent_tasks_default", "(", "job_id", ")", "calc", ".", "from_engine", "=", "True", "tb", "=", "'None\\n'", "try", ":", "if", "not", "oqparam", ".", "hazard_calculation_id", ":", "if", "'input_zip'", "in", "oqparam", ".", "inputs", ":", "# starting from an archive", "with", "open", "(", "oqparam", ".", "inputs", "[", "'input_zip'", "]", ",", "'rb'", ")", "as", "arch", ":", "data", "=", "numpy", ".", "array", "(", "arch", ".", "read", "(", ")", ")", "else", ":", "logs", ".", "LOG", ".", "info", "(", "'zipping the input files'", ")", "bio", "=", "io", ".", "BytesIO", "(", ")", "oqzip", ".", "zip_job", "(", "oqparam", ".", "inputs", "[", "'job_ini'", "]", ",", "bio", ",", "(", ")", ",", "oqparam", ",", "logging", ".", "debug", ")", "data", "=", "numpy", ".", "array", "(", "bio", ".", "getvalue", "(", ")", ")", "del", "bio", "calc", ".", "datastore", "[", "'input/zip'", "]", "=", "data", "calc", ".", "datastore", ".", "set_attrs", "(", "'input/zip'", ",", "nbytes", "=", "data", ".", "nbytes", ")", "del", "data", "# save memory", "poll_queue", "(", "job_id", ",", "_PID", ",", "poll_time", "=", "15", ")", "t0", "=", "time", ".", "time", "(", ")", "calc", ".", "run", "(", "exports", "=", "exports", ",", "hazard_calculation_id", "=", "hazard_calculation_id", ",", "close", "=", "False", ",", "*", "*", "kw", ")", "logs", ".", "LOG", ".", "info", "(", "'Exposing the outputs to the database'", ")", "expose_outputs", "(", "calc", ".", "datastore", ")", "duration", "=", "time", ".", "time", "(", ")", "-", "t0", "calc", ".", "_monitor", ".", "flush", "(", ")", "records", "=", "views", ".", "performance_view", "(", "calc", ".", "datastore", ")", "logs", ".", "dbcmd", "(", "'save_performance'", ",", "job_id", ",", "records", ")", "calc", ".", "datastore", ".", "close", "(", ")", "logs", ".", "LOG", ".", "info", "(", "'Calculation %d finished correctly in %d seconds'", ",", "job_id", ",", "duration", ")", "logs", ".", "dbcmd", "(", "'finish'", ",", "job_id", ",", "'complete'", ")", "except", "BaseException", "as", "exc", ":", "if", "isinstance", "(", "exc", ",", "MasterKilled", ")", ":", "msg", "=", "'aborted'", "else", ":", "msg", "=", "'failed'", "tb", "=", "traceback", ".", "format_exc", "(", ")", "try", ":", "logs", ".", "LOG", ".", "critical", "(", "tb", ")", "logs", ".", "dbcmd", "(", "'finish'", ",", "job_id", ",", "msg", ")", "except", "BaseException", ":", "# an OperationalError may always happen", "sys", ".", "stderr", ".", "write", "(", "tb", ")", "raise", "finally", ":", "# if there was an error in the calculation, this part may fail;", "# in such a situation, we simply log the cleanup error without", "# taking further action, so that the real error can propagate", "try", ":", "if", "OQ_DISTRIBUTE", ".", "startswith", "(", "'celery'", ")", ":", "celery_cleanup", "(", "TERMINATE", ")", "except", "BaseException", ":", "# log the finalization error only if there is no real error", "if", "tb", "==", "'None\\n'", ":", "logs", ".", "LOG", ".", "error", "(", "'finalizing'", ",", "exc_info", "=", "True", ")", "return", "calc" ]

[ "Run", "a", "calculation", "." ]

[ "def", "version_triple", "(", "tag", ")", ":", "groups", "=", "re", ".", "match", "(", "r'v?(\\d+)\\.(\\d+)\\.(\\d+)'", ",", "tag", ")", ".", "groups", "(", ")", "return", "tuple", "(", "int", "(", "n", ")", "for", "n", "in", "groups", ")" ]

[ "returns", ":", "a", "triple", "of", "integers", "from", "a", "version", "tag" ]

[ "def", "check_obsolete_version", "(", "calculation_mode", "=", "'WebUI'", ")", ":", "if", "os", ".", "environ", ".", "get", "(", "'JENKINS_URL'", ")", "or", "os", ".", "environ", ".", "get", "(", "'TRAVIS'", ")", ":", "# avoid flooding our API server with requests from CI systems", "return", "headers", "=", "{", "'User-Agent'", ":", "'OpenQuake Engine %s;%s;%s;%s'", "%", "(", "__version__", ",", "calculation_mode", ",", "platform", ".", "platform", "(", ")", ",", "config", ".", "distribution", ".", "oq_distribute", ")", "}", "try", ":", "req", "=", "Request", "(", "OQ_API", "+", "'/engine/latest'", ",", "headers", "=", "headers", ")", "# NB: a timeout < 1 does not work", "data", "=", "urlopen", "(", "req", ",", "timeout", "=", "1", ")", ".", "read", "(", ")", "# bytes", "tag_name", "=", "json", ".", "loads", "(", "decode", "(", "data", ")", ")", "[", "'tag_name'", "]", "current", "=", "version_triple", "(", "__version__", ")", "latest", "=", "version_triple", "(", "tag_name", ")", "except", "Exception", ":", "# page not available or wrong version tag", "return", "if", "current", "<", "latest", ":", "return", "(", "'Version %s of the engine is available, but you are '", "'still using version %s'", "%", "(", "tag_name", ",", "__version__", ")", ")", "else", ":", "return", "''" ]

[ "Check", "if", "there", "is", "a", "newer", "version", "of", "the", "engine", "." ]

[ "def", "encode", "(", "val", ")", ":", "if", "isinstance", "(", "val", ",", "(", "list", ",", "tuple", ")", ")", ":", "# encode a list or tuple of strings", "return", "[", "encode", "(", "v", ")", "for", "v", "in", "val", "]", "elif", "isinstance", "(", "val", ",", "str", ")", ":", "return", "val", ".", "encode", "(", "'utf-8'", ")", "else", ":", "# assume it was an already encoded object", "return", "val" ]

[ "Encode", "a", "string", "assuming", "the", "encoding", "is", "UTF", "-", "8", "." ]

[ "def", "raise_", "(", "tp", ",", "value", "=", "None", ",", "tb", "=", "None", ")", ":", "if", "value", "is", "not", "None", "and", "isinstance", "(", "tp", ",", "Exception", ")", ":", "raise", "TypeError", "(", "\"instance exception may not have a separate value\"", ")", "if", "value", "is", "not", "None", ":", "exc", "=", "tp", "(", "value", ")", "else", ":", "exc", "=", "tp", "if", "exc", ".", "__traceback__", "is", "not", "tb", ":", "raise", "exc", ".", "with_traceback", "(", "tb", ")", "raise", "exc" ]

[ "A", "function", "that", "matches", "the", "Python", "2", ".", "x", "raise", "statement", ".", "This", "allows", "re", "-", "raising", "exceptions", "with", "the", "cls", "value", "and", "traceback", "on", "Python", "2", "and", "3", "." ]

[ "def", "dbserver", "(", "cmd", ",", "dbhostport", "=", "None", ",", "dbpath", "=", "os", ".", "path", ".", "expanduser", "(", "config", ".", "dbserver", ".", "file", ")", ")", ":", "if", "config", ".", "dbserver", ".", "multi_user", "and", "getpass", ".", "getuser", "(", ")", "!=", "'openquake'", ":", "sys", ".", "exit", "(", "'oq dbserver only works in single user mode'", ")", "status", "=", "dbs", ".", "get_status", "(", ")", "if", "cmd", "==", "'status'", ":", "print", "(", "'dbserver '", "+", "status", ")", "elif", "cmd", "==", "'stop'", ":", "if", "status", "==", "'running'", ":", "pid", "=", "logs", ".", "dbcmd", "(", "'getpid'", ")", "os", ".", "kill", "(", "pid", ",", "signal", ".", "SIGINT", ")", "# this is trapped by the DbServer", "else", ":", "print", "(", "'dbserver already stopped'", ")", "elif", "cmd", "==", "'start'", ":", "if", "status", "==", "'not-running'", ":", "dbs", ".", "run_server", "(", "dbpath", ",", "dbhostport", ")", "else", ":", "print", "(", "'dbserver already running'", ")", "elif", "cmd", "==", "'restart'", ":", "if", "status", "==", "'running'", ":", "pid", "=", "logs", ".", "dbcmd", "(", "'getpid'", ")", "os", ".", "kill", "(", "pid", ",", "signal", ".", "SIGINT", ")", "dbs", ".", "run_server", "(", "dbpath", ",", "dbhostport", ")" ]

[ "start", "/", "stop", "/", "restart", "the", "database", "server", "or", "return", "its", "status" ]

[ "def", "plot_pyro", "(", "calc_id", "=", "-", "1", ")", ":", "# NB: matplotlib is imported inside since it is a costly import", "import", "matplotlib", ".", "pyplot", "as", "p", "dstore", "=", "util", ".", "read", "(", "calc_id", ")", "sitecol", "=", "dstore", "[", "'sitecol'", "]", "asset_risk", "=", "dstore", "[", "'asset_risk'", "]", ".", "value", "pyro", ",", "=", "numpy", ".", "where", "(", "dstore", "[", "'multi_peril'", "]", "[", "'PYRO'", "]", "==", "1", ")", "lons", "=", "sitecol", ".", "lons", "[", "pyro", "]", "lats", "=", "sitecol", ".", "lats", "[", "pyro", "]", "p", ".", "scatter", "(", "lons", ",", "lats", ",", "marker", "=", "'o'", ",", "color", "=", "'red'", ")", "building_pyro", ",", "=", "numpy", ".", "where", "(", "asset_risk", "[", "'building-PYRO'", "]", "==", "1", ")", "lons", "=", "sitecol", ".", "lons", "[", "building_pyro", "]", "lats", "=", "sitecol", ".", "lats", "[", "building_pyro", "]", "p", ".", "scatter", "(", "lons", ",", "lats", ",", "marker", "=", "'.'", ",", "color", "=", "'green'", ")", "p", ".", "show", "(", ")" ]

[ "Plot", "the", "pyroclastic", "cloud", "and", "the", "assets" ]

[ "def", "get_resampled_coordinates", "(", "lons", ",", "lats", ")", ":", "num_coords", "=", "len", "(", "lons", ")", "assert", "num_coords", "==", "len", "(", "lats", ")", "lons1", "=", "numpy", ".", "array", "(", "lons", ")", "lats1", "=", "numpy", ".", "array", "(", "lats", ")", "lons2", "=", "numpy", ".", "concatenate", "(", "(", "lons1", "[", "1", ":", "]", ",", "lons1", "[", ":", "1", "]", ")", ")", "lats2", "=", "numpy", ".", "concatenate", "(", "(", "lats1", "[", "1", ":", "]", ",", "lats1", "[", ":", "1", "]", ")", ")", "distances", "=", "geodetic", ".", "geodetic_distance", "(", "lons1", ",", "lats1", ",", "lons2", ",", "lats2", ")", "resampled_lons", "=", "[", "lons", "[", "0", "]", "]", "resampled_lats", "=", "[", "lats", "[", "0", "]", "]", "for", "i", "in", "range", "(", "num_coords", ")", ":", "next_point", "=", "(", "i", "+", "1", ")", "%", "num_coords", "lon1", ",", "lat1", "=", "lons", "[", "i", "]", ",", "lats", "[", "i", "]", "lon2", ",", "lat2", "=", "lons", "[", "next_point", "]", ",", "lats", "[", "next_point", "]", "distance", "=", "distances", "[", "i", "]", "num_points", "=", "int", "(", "distance", "/", "UPSAMPLING_STEP_KM", ")", "+", "1", "if", "num_points", ">=", "2", ":", "# We need to increase the resolution of this arc by adding new", "# points.", "new_lons", ",", "new_lats", ",", "_", "=", "geodetic", ".", "npoints_between", "(", "lon1", ",", "lat1", ",", "0", ",", "lon2", ",", "lat2", ",", "0", ",", "num_points", ")", "resampled_lons", ".", "extend", "(", "new_lons", "[", "1", ":", "]", ")", "resampled_lats", ".", "extend", "(", "new_lats", "[", "1", ":", "]", ")", "else", ":", "resampled_lons", ".", "append", "(", "lon2", ")", "resampled_lats", ".", "append", "(", "lat2", ")", "# NB: we cut off the last point because it repeats the first one", "return", "numpy", ".", "array", "(", "resampled_lons", "[", ":", "-", "1", "]", ")", ",", "numpy", ".", "array", "(", "resampled_lats", "[", ":", "-", "1", "]", ")" ]

[ "Resample", "polygon", "line", "segments", "and", "return", "the", "coordinates", "of", "the", "new", "vertices", ".", "This", "limits", "distortions", "when", "projecting", "a", "polygon", "onto", "a", "spherical", "surface", "." ]

[ "def", "surface_nodes", "(", "self", ")", ":", "line", "=", "[", "]", "for", "point", "in", "self", ".", "mesh", ":", "line", ".", "append", "(", "point", ".", "longitude", ")", "line", ".", "append", "(", "point", ".", "latitude", ")", "line", ".", "append", "(", "point", ".", "depth", ")", "return", "[", "Node", "(", "'griddedSurface'", ",", "nodes", "=", "[", "Node", "(", "'gml:posList'", ",", "{", "}", ",", "line", ")", "]", ")", "]" ]

[ ":", "param", "points", ":", "a", "list", "of", "Point", "objects", ":", "returns", ":", "a", "Node", "of", "kind", "griddedSurface" ]