Datasets:

unum-cloud

/

ann-codesearch-4m

like 0

Follow

Unum 28

[ "def", "ebr_data_transfer", "(", "token", ",", "dstore", ")", ":", "attrs", "=", "dstore", "[", "'losses_by_event'", "]", ".", "attrs", "sent", "=", "humansize", "(", "attrs", "[", "'sent'", "]", ")", "received", "=", "humansize", "(", "attrs", "[", "'tot_received'", "]", ")", "return", "'Event Based Risk: sent %s, received %s'", "%", "(", "sent", ",", "received", ")" ]

[ "Display", "the", "data", "transferred", "in", "an", "event", "based", "risk", "calculation" ]

[ "def", "view_totlosses", "(", "token", ",", "dstore", ")", ":", "oq", "=", "dstore", "[", "'oqparam'", "]", "tot_losses", "=", "dstore", "[", "'losses_by_asset'", "]", "[", "'mean'", "]", ".", "sum", "(", "axis", "=", "0", ")", "return", "rst_table", "(", "tot_losses", ".", "view", "(", "oq", ".", "loss_dt", "(", ")", ")", ",", "fmt", "=", "'%.6E'", ")" ]

[ "This", "is", "a", "debugging", "view", ".", "You", "can", "use", "it", "to", "check", "that", "the", "total", "losses", "i", ".", "e", ".", "the", "losses", "obtained", "by", "summing", "the", "average", "losses", "on", "all", "assets", "are", "indeed", "equal", "to", "the", "aggregate", "losses", ".", "This", "is", "a", "sanity", "check", "for", "the", "correctness", "of", "the", "implementation", "." ]

[ "def", "view_portfolio_losses", "(", "token", ",", "dstore", ")", ":", "oq", "=", "dstore", "[", "'oqparam'", "]", "loss_dt", "=", "oq", ".", "loss_dt", "(", ")", "data", "=", "portfolio_loss", "(", "dstore", ")", ".", "view", "(", "loss_dt", ")", "[", ":", ",", "0", "]", "rlzids", "=", "[", "str", "(", "r", ")", "for", "r", "in", "range", "(", "len", "(", "data", ")", ")", "]", "array", "=", "util", ".", "compose_arrays", "(", "numpy", ".", "array", "(", "rlzids", ")", ",", "data", ",", "'rlz'", ")", "# this is very sensitive to rounding errors, so I am using a low precision", "return", "rst_table", "(", "array", ",", "fmt", "=", "'%.5E'", ")" ]

[ "The", "losses", "for", "the", "full", "portfolio", "for", "each", "realization", "and", "loss", "type", "extracted", "from", "the", "event", "loss", "table", "." ]

[ "def", "view_portfolio_loss", "(", "token", ",", "dstore", ")", ":", "data", "=", "portfolio_loss", "(", "dstore", ")", "# shape (R, L)", "loss_types", "=", "list", "(", "dstore", "[", "'oqparam'", "]", ".", "loss_dt", "(", ")", ".", "names", ")", "header", "=", "[", "'portfolio_loss'", "]", "+", "loss_types", "mean", "=", "[", "'mean'", "]", "+", "[", "row", ".", "mean", "(", ")", "for", "row", "in", "data", ".", "T", "]", "stddev", "=", "[", "'stddev'", "]", "+", "[", "row", ".", "std", "(", "ddof", "=", "1", ")", "for", "row", "in", "data", ".", "T", "]", "return", "rst_table", "(", "[", "mean", ",", "stddev", "]", ",", "header", ")" ]

[ "The", "mean", "and", "stddev", "loss", "for", "the", "full", "portfolio", "for", "each", "loss", "type", "extracted", "from", "the", "event", "loss", "table", "averaged", "over", "the", "realizations" ]

[ "def", "sum_table", "(", "records", ")", ":", "size", "=", "len", "(", "records", "[", "0", "]", ")", "result", "=", "[", "None", "]", "*", "size", "firstrec", "=", "records", "[", "0", "]", "for", "i", "in", "range", "(", "size", ")", ":", "if", "isinstance", "(", "firstrec", "[", "i", "]", ",", "(", "numbers", ".", "Number", ",", "numpy", ".", "ndarray", ")", ")", ":", "result", "[", "i", "]", "=", "sum", "(", "rec", "[", "i", "]", "for", "rec", "in", "records", ")", "else", ":", "result", "[", "i", "]", "=", "'total'", "return", "result" ]

[ "Used", "to", "compute", "summaries", ".", "The", "records", "are", "assumed", "to", "have", "numeric", "fields", "except", "the", "first", "field", "which", "is", "ignored", "since", "it", "typically", "contains", "a", "label", ".", "Here", "is", "an", "example", ":" ]

[ "def", "view_exposure_info", "(", "token", ",", "dstore", ")", ":", "assetcol", "=", "dstore", "[", "'assetcol/array'", "]", "[", ":", "]", "taxonomies", "=", "sorted", "(", "set", "(", "dstore", "[", "'assetcol'", "]", ".", "taxonomies", ")", ")", "cc", "=", "dstore", "[", "'assetcol/cost_calculator'", "]", "ra_flag", "=", "[", "'relative'", ",", "'absolute'", "]", "data", "=", "[", "(", "'#assets'", ",", "len", "(", "assetcol", ")", ")", ",", "(", "'#taxonomies'", ",", "len", "(", "taxonomies", ")", ")", ",", "(", "'deductibile'", ",", "ra_flag", "[", "int", "(", "cc", ".", "deduct_abs", ")", "]", ")", ",", "(", "'insurance_limit'", ",", "ra_flag", "[", "int", "(", "cc", ".", "limit_abs", ")", "]", ")", ",", "]", "return", "rst_table", "(", "data", ")", "+", "'\\n\\n'", "+", "view_assets_by_site", "(", "token", ",", "dstore", ")" ]

[ "Display", "info", "about", "the", "exposure", "model" ]

[ "def", "view_fullreport", "(", "token", ",", "dstore", ")", ":", "# avoid circular imports", "from", "openquake", ".", "calculators", ".", "reportwriter", "import", "ReportWriter", "return", "ReportWriter", "(", "dstore", ")", ".", "make_report", "(", ")" ]

[ "Display", "an", ".", "rst", "report", "about", "the", "computation" ]

[ "def", "performance_view", "(", "dstore", ")", ":", "data", "=", "sorted", "(", "dstore", "[", "'performance_data'", "]", ",", "key", "=", "operator", ".", "itemgetter", "(", "0", ")", ")", "out", "=", "[", "]", "for", "operation", ",", "group", "in", "itertools", ".", "groupby", "(", "data", ",", "operator", ".", "itemgetter", "(", "0", ")", ")", ":", "counts", "=", "0", "time", "=", "0", "mem", "=", "0", "for", "_operation", ",", "time_sec", ",", "memory_mb", ",", "counts_", "in", "group", ":", "counts", "+=", "counts_", "time", "+=", "time_sec", "mem", "=", "max", "(", "mem", ",", "memory_mb", ")", "out", ".", "append", "(", "(", "operation", ",", "time", ",", "mem", ",", "counts", ")", ")", "out", ".", "sort", "(", "key", "=", "operator", ".", "itemgetter", "(", "1", ")", ",", "reverse", "=", "True", ")", "# sort by time", "return", "numpy", ".", "array", "(", "out", ",", "perf_dt", ")" ]

[ "Returns", "the", "performance", "view", "as", "a", "numpy", "array", "." ]

[ "def", "stats", "(", "name", ",", "array", ",", "*", "extras", ")", ":", "std", "=", "numpy", ".", "nan", "if", "len", "(", "array", ")", "==", "1", "else", "numpy", ".", "std", "(", "array", ",", "ddof", "=", "1", ")", "return", "(", "name", ",", "numpy", ".", "mean", "(", "array", ")", ",", "std", ",", "numpy", ".", "min", "(", "array", ")", ",", "numpy", ".", "max", "(", "array", ")", ",", "len", "(", "array", ")", ")", "+", "extras" ]

[ "Returns", "statistics", "from", "an", "array", "of", "numbers", "." ]

[ "def", "view_num_units", "(", "token", ",", "dstore", ")", ":", "taxo", "=", "dstore", "[", "'assetcol/tagcol/taxonomy'", "]", ".", "value", "counts", "=", "collections", ".", "Counter", "(", ")", "for", "asset", "in", "dstore", "[", "'assetcol'", "]", ":", "counts", "[", "taxo", "[", "asset", "[", "'taxonomy'", "]", "]", "]", "+=", "asset", "[", "'number'", "]", "data", "=", "sorted", "(", "counts", ".", "items", "(", ")", ")", "data", ".", "append", "(", "(", "'*ALL*'", ",", "sum", "(", "d", "[", "1", "]", "for", "d", "in", "data", ")", ")", ")", "return", "rst_table", "(", "data", ",", "header", "=", "[", "'taxonomy'", ",", "'num_units'", "]", ")" ]

[ "Display", "the", "number", "of", "units", "by", "taxonomy" ]

[ "def", "view_assets_by_site", "(", "token", ",", "dstore", ")", ":", "taxonomies", "=", "dstore", "[", "'assetcol/tagcol/taxonomy'", "]", ".", "value", "assets_by_site", "=", "dstore", "[", "'assetcol'", "]", ".", "assets_by_site", "(", ")", "data", "=", "[", "'taxonomy mean stddev min max num_sites num_assets'", ".", "split", "(", ")", "]", "num_assets", "=", "AccumDict", "(", ")", "for", "assets", "in", "assets_by_site", ":", "num_assets", "+=", "{", "k", ":", "[", "len", "(", "v", ")", "]", "for", "k", ",", "v", "in", "group_array", "(", "assets", ",", "'taxonomy'", ")", ".", "items", "(", ")", "}", "for", "taxo", "in", "sorted", "(", "num_assets", ")", ":", "val", "=", "numpy", ".", "array", "(", "num_assets", "[", "taxo", "]", ")", "data", ".", "append", "(", "stats", "(", "taxonomies", "[", "taxo", "]", ",", "val", ",", "val", ".", "sum", "(", ")", ")", ")", "if", "len", "(", "num_assets", ")", ">", "1", ":", "# more than one taxonomy, add a summary", "n_assets", "=", "numpy", ".", "array", "(", "[", "len", "(", "assets", ")", "for", "assets", "in", "assets_by_site", "]", ")", "data", ".", "append", "(", "stats", "(", "'*ALL*'", ",", "n_assets", ",", "n_assets", ".", "sum", "(", ")", ")", ")", "return", "rst_table", "(", "data", ")" ]

[ "Display", "statistical", "information", "about", "the", "distribution", "of", "the", "assets" ]

[ "def", "view_required_params_per_trt", "(", "token", ",", "dstore", ")", ":", "csm_info", "=", "dstore", "[", "'csm_info'", "]", "tbl", "=", "[", "]", "for", "grp_id", ",", "trt", "in", "sorted", "(", "csm_info", ".", "grp_by", "(", "\"trt\"", ")", ".", "items", "(", ")", ")", ":", "gsims", "=", "csm_info", ".", "gsim_lt", ".", "get_gsims", "(", "trt", ")", "maker", "=", "ContextMaker", "(", "trt", ",", "gsims", ")", "distances", "=", "sorted", "(", "maker", ".", "REQUIRES_DISTANCES", ")", "siteparams", "=", "sorted", "(", "maker", ".", "REQUIRES_SITES_PARAMETERS", ")", "ruptparams", "=", "sorted", "(", "maker", ".", "REQUIRES_RUPTURE_PARAMETERS", ")", "tbl", ".", "append", "(", "(", "grp_id", ",", "' '", ".", "join", "(", "map", "(", "repr", ",", "map", "(", "repr", ",", "gsims", ")", ")", ")", ",", "distances", ",", "siteparams", ",", "ruptparams", ")", ")", "return", "rst_table", "(", "tbl", ",", "header", "=", "'grp_id gsims distances siteparams ruptparams'", ".", "split", "(", ")", ",", "fmt", "=", "scientificformat", ")" ]

[ "Display", "the", "parameters", "needed", "by", "each", "tectonic", "region", "type" ]

[ "def", "view_task_info", "(", "token", ",", "dstore", ")", ":", "args", "=", "token", ".", "split", "(", "':'", ")", "[", "1", ":", "]", "# called as task_info:task_name", "if", "args", ":", "[", "task", "]", "=", "args", "array", "=", "dstore", "[", "'task_info/'", "+", "task", "]", ".", "value", "rduration", "=", "array", "[", "'duration'", "]", "/", "array", "[", "'weight'", "]", "data", "=", "util", ".", "compose_arrays", "(", "rduration", ",", "array", ",", "'rduration'", ")", "data", ".", "sort", "(", "order", "=", "'duration'", ")", "return", "rst_table", "(", "data", ")", "data", "=", "[", "'operation-duration mean stddev min max outputs'", ".", "split", "(", ")", "]", "for", "task", "in", "dstore", "[", "'task_info'", "]", ":", "val", "=", "dstore", "[", "'task_info/'", "+", "task", "]", "[", "'duration'", "]", "if", "len", "(", "val", ")", ":", "data", ".", "append", "(", "stats", "(", "task", ",", "val", ")", ")", "if", "len", "(", "data", ")", "==", "1", ":", "return", "'Not available'", "return", "rst_table", "(", "data", ")" ]

[ "Display", "statistical", "information", "about", "the", "tasks", "performance", ".", "It", "is", "possible", "to", "get", "full", "information", "about", "a", "specific", "task", "with", "a", "command", "like", "this", "one", "for", "a", "classical", "calculation", "::" ]

[ "def", "view_task_durations", "(", "token", ",", "dstore", ")", ":", "task", "=", "token", ".", "split", "(", "':'", ")", "[", "1", "]", "# called as task_duration:task_name", "array", "=", "dstore", "[", "'task_info/'", "+", "task", "]", "[", "'duration'", "]", "return", "'\\n'", ".", "join", "(", "map", "(", "str", ",", "array", ")", ")" ]

[ "Display", "the", "raw", "task", "durations", ".", "Here", "is", "an", "example", "of", "usage", "::" ]

[ "def", "view_task_hazard", "(", "token", ",", "dstore", ")", ":", "tasks", "=", "set", "(", "dstore", "[", "'task_info'", "]", ")", "if", "'source_data'", "not", "in", "dstore", ":", "return", "'Missing source_data'", "if", "'classical_split_filter'", "in", "tasks", ":", "data", "=", "dstore", "[", "'task_info/classical_split_filter'", "]", ".", "value", "else", ":", "data", "=", "dstore", "[", "'task_info/compute_gmfs'", "]", ".", "value", "data", ".", "sort", "(", "order", "=", "'duration'", ")", "rec", "=", "data", "[", "int", "(", "token", ".", "split", "(", "':'", ")", "[", "1", "]", ")", "]", "taskno", "=", "rec", "[", "'taskno'", "]", "arr", "=", "get_array", "(", "dstore", "[", "'source_data'", "]", ".", "value", ",", "taskno", "=", "taskno", ")", "st", "=", "[", "stats", "(", "'nsites'", ",", "arr", "[", "'nsites'", "]", ")", ",", "stats", "(", "'weight'", ",", "arr", "[", "'weight'", "]", ")", "]", "sources", "=", "dstore", "[", "'task_sources'", "]", "[", "taskno", "-", "1", "]", ".", "split", "(", ")", "srcs", "=", "set", "(", "decode", "(", "s", ")", ".", "split", "(", "':'", ",", "1", ")", "[", "0", "]", "for", "s", "in", "sources", ")", "res", "=", "'taskno=%d, weight=%d, duration=%d s, sources=\"%s\"\\n\\n'", "%", "(", "taskno", ",", "rec", "[", "'weight'", "]", ",", "rec", "[", "'duration'", "]", ",", "' '", ".", "join", "(", "sorted", "(", "srcs", ")", ")", ")", "return", "res", "+", "rst_table", "(", "st", ",", "header", "=", "'variable mean stddev min max n'", ".", "split", "(", ")", ")" ]

[ "Display", "info", "about", "a", "given", "task", ".", "Here", "are", "a", "few", "examples", "of", "usage", "::" ]

[ "def", "view_task_risk", "(", "token", ",", "dstore", ")", ":", "[", "key", "]", "=", "dstore", "[", "'task_info'", "]", "data", "=", "dstore", "[", "'task_info/'", "+", "key", "]", ".", "value", "data", ".", "sort", "(", "order", "=", "'duration'", ")", "rec", "=", "data", "[", "int", "(", "token", ".", "split", "(", "':'", ")", "[", "1", "]", ")", "]", "taskno", "=", "rec", "[", "'taskno'", "]", "res", "=", "'taskno=%d, weight=%d, duration=%d s'", "%", "(", "taskno", ",", "rec", "[", "'weight'", "]", ",", "rec", "[", "'duration'", "]", ")", "return", "res" ]

[ "Display", "info", "about", "a", "given", "risk", "task", ".", "Here", "are", "a", "few", "examples", "of", "usage", "::" ]

[ "def", "view_hmap", "(", "token", ",", "dstore", ")", ":", "try", ":", "poe", "=", "valid", ".", "probability", "(", "token", ".", "split", "(", "':'", ")", "[", "1", "]", ")", "except", "IndexError", ":", "poe", "=", "0.1", "mean", "=", "dict", "(", "extract", "(", "dstore", ",", "'hcurves?kind=mean'", ")", ")", "[", "'mean'", "]", "oq", "=", "dstore", "[", "'oqparam'", "]", "hmap", "=", "calc", ".", "make_hmap_array", "(", "mean", ",", "oq", ".", "imtls", ",", "[", "poe", "]", ",", "len", "(", "mean", ")", ")", "dt", "=", "numpy", ".", "dtype", "(", "[", "(", "'sid'", ",", "U32", ")", "]", "+", "[", "(", "imt", ",", "F32", ")", "for", "imt", "in", "oq", ".", "imtls", "]", ")", "array", "=", "numpy", ".", "zeros", "(", "len", "(", "hmap", ")", ",", "dt", ")", "for", "i", ",", "vals", "in", "enumerate", "(", "hmap", ")", ":", "array", "[", "i", "]", "=", "(", "i", ",", ")", "+", "tuple", "(", "vals", ")", "array", ".", "sort", "(", "order", "=", "list", "(", "oq", ".", "imtls", ")", "[", "0", "]", ")", "return", "rst_table", "(", "array", "[", ":", "20", "]", ")" ]

[ "Display", "the", "highest", "20", "points", "of", "the", "mean", "hazard", "map", ".", "Called", "as", "$", "oq", "show", "hmap", ":", "0", ".", "1", "#", "10%", "PoE" ]

[ "def", "view_global_hcurves", "(", "token", ",", "dstore", ")", ":", "oq", "=", "dstore", "[", "'oqparam'", "]", "nsites", "=", "len", "(", "dstore", "[", "'sitecol'", "]", ")", "rlzs_assoc", "=", "dstore", "[", "'csm_info'", "]", ".", "get_rlzs_assoc", "(", ")", "mean", "=", "getters", ".", "PmapGetter", "(", "dstore", ",", "rlzs_assoc", ")", ".", "get_mean", "(", ")", "array", "=", "calc", ".", "convert_to_array", "(", "mean", ",", "nsites", ",", "oq", ".", "imtls", ")", "res", "=", "numpy", ".", "zeros", "(", "1", ",", "array", ".", "dtype", ")", "for", "name", "in", "array", ".", "dtype", ".", "names", ":", "res", "[", "name", "]", "=", "array", "[", "name", "]", ".", "mean", "(", ")", "return", "rst_table", "(", "res", ")" ]

[ "Display", "the", "global", "hazard", "curves", "for", "the", "calculation", ".", "They", "are", "used", "for", "debugging", "purposes", "when", "comparing", "the", "results", "of", "two", "calculations", ".", "They", "are", "the", "mean", "over", "the", "sites", "of", "the", "mean", "hazard", "curves", "." ]

[ "def", "view_dupl_sources_time", "(", "token", ",", "dstore", ")", ":", "info", "=", "dstore", "[", "'source_info'", "]", "items", "=", "sorted", "(", "group_array", "(", "info", ".", "value", ",", "'source_id'", ")", ".", "items", "(", ")", ")", "tbl", "=", "[", "]", "tot_time", "=", "0", "for", "source_id", ",", "records", "in", "items", ":", "if", "len", "(", "records", ")", ">", "1", ":", "# dupl", "calc_time", "=", "records", "[", "'calc_time'", "]", ".", "sum", "(", ")", "tot_time", "+=", "calc_time", "+", "records", "[", "'split_time'", "]", ".", "sum", "(", ")", "tbl", ".", "append", "(", "(", "source_id", ",", "calc_time", ",", "len", "(", "records", ")", ")", ")", "if", "tbl", "and", "info", ".", "attrs", ".", "get", "(", "'has_dupl_sources'", ")", ":", "tot", "=", "info", "[", "'calc_time'", "]", ".", "sum", "(", ")", "+", "info", "[", "'split_time'", "]", ".", "sum", "(", ")", "percent", "=", "tot_time", "/", "tot", "*", "100", "m", "=", "'\\nTotal time in duplicated sources: %d/%d (%d%%)'", "%", "(", "tot_time", ",", "tot", ",", "percent", ")", "return", "rst_table", "(", "tbl", ",", "[", "'source_id'", ",", "'calc_time'", ",", "'num_dupl'", "]", ")", "+", "m", "else", ":", "return", "'There are no duplicated sources'" ]

[ "Display", "the", "time", "spent", "computing", "duplicated", "sources" ]

[ "def", "view_global_poes", "(", "token", ",", "dstore", ")", ":", "tbl", "=", "[", "]", "imtls", "=", "dstore", "[", "'oqparam'", "]", ".", "imtls", "header", "=", "[", "'grp_id'", "]", "+", "[", "str", "(", "poe", ")", "for", "poe", "in", "imtls", ".", "array", "]", "for", "grp", "in", "sorted", "(", "dstore", "[", "'poes'", "]", ")", ":", "poes", "=", "dstore", "[", "'poes/'", "+", "grp", "]", "nsites", "=", "len", "(", "poes", ")", "site_avg", "=", "sum", "(", "poes", "[", "sid", "]", ".", "array", "for", "sid", "in", "poes", ")", "/", "nsites", "gsim_avg", "=", "site_avg", ".", "sum", "(", "axis", "=", "1", ")", "/", "poes", ".", "shape_z", "tbl", ".", "append", "(", "[", "grp", "]", "+", "list", "(", "gsim_avg", ")", ")", "return", "rst_table", "(", "tbl", ",", "header", "=", "header", ")" ]

[ "Display", "global", "probabilities", "averaged", "on", "all", "sites", "and", "all", "GMPEs" ]

[ "def", "view_global_hmaps", "(", "token", ",", "dstore", ")", ":", "oq", "=", "dstore", "[", "'oqparam'", "]", "dt", "=", "numpy", ".", "dtype", "(", "[", "(", "'%s-%s'", "%", "(", "imt", ",", "poe", ")", ",", "F32", ")", "for", "imt", "in", "oq", ".", "imtls", "for", "poe", "in", "oq", ".", "poes", "]", ")", "array", "=", "dstore", "[", "'hmaps/mean'", "]", ".", "value", ".", "view", "(", "dt", ")", "[", ":", ",", "0", "]", "res", "=", "numpy", ".", "zeros", "(", "1", ",", "array", ".", "dtype", ")", "for", "name", "in", "array", ".", "dtype", ".", "names", ":", "res", "[", "name", "]", "=", "array", "[", "name", "]", ".", "mean", "(", ")", "return", "rst_table", "(", "res", ")" ]

[ "Display", "the", "global", "hazard", "maps", "for", "the", "calculation", ".", "They", "are", "used", "for", "debugging", "purposes", "when", "comparing", "the", "results", "of", "two", "calculations", ".", "They", "are", "the", "mean", "over", "the", "sites", "of", "the", "mean", "hazard", "maps", "." ]

[ "def", "view_global_gmfs", "(", "token", ",", "dstore", ")", ":", "imtls", "=", "dstore", "[", "'oqparam'", "]", ".", "imtls", "row", "=", "dstore", "[", "'gmf_data/data'", "]", "[", "'gmv'", "]", ".", "mean", "(", "axis", "=", "0", ")", "return", "rst_table", "(", "[", "row", "]", ",", "header", "=", "imtls", ")" ]

[ "Display", "GMFs", "averaged", "on", "everything", "for", "debugging", "purposes" ]

[ "def", "view_mean_disagg", "(", "token", ",", "dstore", ")", ":", "tbl", "=", "[", "]", "for", "key", ",", "dset", "in", "sorted", "(", "dstore", "[", "'disagg'", "]", ".", "items", "(", ")", ")", ":", "vals", "=", "[", "ds", ".", "value", ".", "mean", "(", ")", "for", "k", ",", "ds", "in", "sorted", "(", "dset", ".", "items", "(", ")", ")", "]", "tbl", ".", "append", "(", "[", "key", "]", "+", "vals", ")", "header", "=", "[", "'key'", "]", "+", "sorted", "(", "dset", ")", "return", "rst_table", "(", "sorted", "(", "tbl", ")", ",", "header", "=", "header", ")" ]

[ "Display", "mean", "quantities", "for", "the", "disaggregation", ".", "Useful", "for", "checking", "differences", "between", "two", "calculations", "." ]

[ "def", "view_elt", "(", "token", ",", "dstore", ")", ":", "oq", "=", "dstore", "[", "'oqparam'", "]", "R", "=", "len", "(", "dstore", "[", "'csm_info'", "]", ".", "rlzs", ")", "dic", "=", "group_array", "(", "dstore", "[", "'losses_by_event'", "]", ".", "value", ",", "'rlzi'", ")", "header", "=", "oq", ".", "loss_dt", "(", ")", ".", "names", "tbl", "=", "[", "]", "for", "rlzi", "in", "range", "(", "R", ")", ":", "if", "rlzi", "in", "dic", ":", "tbl", ".", "append", "(", "dic", "[", "rlzi", "]", "[", "'loss'", "]", ".", "mean", "(", "axis", "=", "0", ")", ")", "else", ":", "tbl", ".", "append", "(", "[", "0.", "]", "*", "len", "(", "header", ")", ")", "return", "rst_table", "(", "tbl", ",", "header", ")" ]

[ "Display", "the", "event", "loss", "table", "averaged", "by", "event" ]

[ "def", "view_pmap", "(", "token", ",", "dstore", ")", ":", "grp", "=", "token", ".", "split", "(", "':'", ")", "[", "1", "]", "# called as pmap:grp", "pmap", "=", "{", "}", "rlzs_assoc", "=", "dstore", "[", "'csm_info'", "]", ".", "get_rlzs_assoc", "(", ")", "pgetter", "=", "getters", ".", "PmapGetter", "(", "dstore", ",", "rlzs_assoc", ")", "pmap", "=", "pgetter", ".", "get_mean", "(", "grp", ")", "return", "str", "(", "pmap", ")" ]

[ "Display", "the", "mean", "ProbabilityMap", "associated", "to", "a", "given", "source", "group", "name" ]

[ "def", "view_act_ruptures_by_src", "(", "token", ",", "dstore", ")", ":", "data", "=", "dstore", "[", "'ruptures'", "]", ".", "value", "[", "[", "'srcidx'", ",", "'serial'", "]", "]", "counts", "=", "sorted", "(", "countby", "(", "data", ",", "'srcidx'", ")", ".", "items", "(", ")", ",", "key", "=", "operator", ".", "itemgetter", "(", "1", ")", ",", "reverse", "=", "True", ")", "src_info", "=", "dstore", "[", "'source_info'", "]", ".", "value", "[", "[", "'grp_id'", ",", "'source_id'", "]", "]", "table", "=", "[", "[", "'src_id'", ",", "'grp_id'", ",", "'act_ruptures'", "]", "]", "for", "srcidx", ",", "act_ruptures", "in", "counts", ":", "src", "=", "src_info", "[", "srcidx", "]", "table", ".", "append", "(", "[", "src", "[", "'source_id'", "]", ",", "src", "[", "'grp_id'", "]", ",", "act_ruptures", "]", ")", "return", "rst_table", "(", "table", ")" ]

[ "Display", "the", "actual", "number", "of", "ruptures", "by", "source", "in", "event", "based", "calculations" ]

[ "def", "view_dupl_sources", "(", "token", ",", "dstore", ")", ":", "fields", "=", "[", "'source_id'", ",", "'code'", ",", "'gidx1'", ",", "'gidx2'", ",", "'num_ruptures'", "]", "dic", "=", "group_array", "(", "dstore", "[", "'source_info'", "]", ".", "value", "[", "fields", "]", ",", "'source_id'", ")", "sameid", "=", "[", "]", "dupl", "=", "[", "]", "for", "source_id", ",", "group", "in", "dic", ".", "items", "(", ")", ":", "if", "len", "(", "group", ")", ">", "1", ":", "# same ID sources", "sources", "=", "[", "]", "for", "rec", "in", "group", ":", "geom", "=", "dstore", "[", "'source_geom'", "]", "[", "rec", "[", "'gidx1'", "]", ":", "rec", "[", "'gidx2'", "]", "]", "src", "=", "Source", "(", "source_id", ",", "rec", "[", "'code'", "]", ",", "geom", ",", "rec", "[", "'num_ruptures'", "]", ")", "sources", ".", "append", "(", "src", ")", "if", "all_equal", "(", "sources", ")", ":", "dupl", ".", "append", "(", "source_id", ")", "sameid", ".", "append", "(", "source_id", ")", "if", "not", "dupl", ":", "return", "''", "msg", "=", "str", "(", "dupl", ")", "+", "'\\n'", "msg", "+=", "(", "'Found %d source(s) with the same ID and %d true duplicate(s)'", "%", "(", "len", "(", "sameid", ")", ",", "len", "(", "dupl", ")", ")", ")", "fakedupl", "=", "set", "(", "sameid", ")", "-", "set", "(", "dupl", ")", "if", "fakedupl", ":", "msg", "+=", "'\\nHere is a fake duplicate: %s'", "%", "fakedupl", ".", "pop", "(", ")", "return", "msg" ]

[ "Show", "the", "sources", "with", "the", "same", "ID", "and", "the", "truly", "duplicated", "sources" ]

[ "def", "view_extreme_groups", "(", "token", ",", "dstore", ")", ":", "data", "=", "dstore", "[", "'disagg_by_grp'", "]", ".", "value", "data", ".", "sort", "(", "order", "=", "'extreme_poe'", ")", "return", "rst_table", "(", "data", "[", ":", ":", "-", "1", "]", ")" ]

[ "Show", "the", "source", "groups", "contributing", "the", "most", "to", "the", "highest", "IML" ]

[ "def", "get_mean_and_stddevs", "(", "self", ",", "sites", ",", "rup", ",", "dists", ",", "imt", ",", "stddev_types", ")", ":", "assert", "all", "(", "stddev_type", "in", "self", ".", "DEFINED_FOR_STANDARD_DEVIATION_TYPES", "for", "stddev_type", "in", "stddev_types", ")", "C", "=", "self", ".", "COEFFS", "[", "imt", "]", "mag", "=", "self", ".", "_convert_magnitude", "(", "rup", ".", "mag", ")", "mean", "=", "(", "C", "[", "'c1'", "]", "+", "C", "[", "'c2'", "]", "*", "mag", "+", "C", "[", "'c10'", "]", "*", "(", "mag", "-", "6", ")", "**", "2", "+", "(", "C", "[", "'c6'", "]", "+", "C", "[", "'c7'", "]", "*", "mag", ")", "*", "np", ".", "log", "(", "dists", ".", "rjb", "+", "np", ".", "exp", "(", "C", "[", "'c4'", "]", ")", ")", ")", "mean", "=", "clip_mean", "(", "imt", ",", "mean", ")", "stddevs", "=", "self", ".", "_compute_stddevs", "(", "C", ",", "dists", ".", "rjb", ".", "size", ",", "stddev_types", ")", "return", "mean", ",", "stddevs" ]

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

[ "def", "zip_all", "(", "directory", ")", ":", "zips", "=", "[", "]", "for", "cwd", ",", "dirs", ",", "files", "in", "os", ".", "walk", "(", "directory", ")", ":", "if", "'ssmLT.xml'", "in", "files", ":", "zips", ".", "append", "(", "zip_source_model", "(", "os", ".", "path", ".", "join", "(", "cwd", ",", "'ssmLT.xml'", ")", ")", ")", "for", "f", "in", "files", ":", "if", "f", ".", "endswith", "(", "'.xml'", ")", "and", "'exposure'", "in", "f", ".", "lower", "(", ")", ":", "zips", ".", "append", "(", "zip_exposure", "(", "os", ".", "path", ".", "join", "(", "cwd", ",", "f", ")", ")", ")", "total", "=", "sum", "(", "os", ".", "path", ".", "getsize", "(", "z", ")", "for", "z", "in", "zips", ")", "logging", ".", "info", "(", "'Generated %s of zipped data'", ",", "general", ".", "humansize", "(", "total", ")", ")" ]

[ "Zip", "source", "models", "and", "exposures", "recursively" ]

[ "def", "zip_source_model", "(", "ssmLT", ",", "archive_zip", "=", "''", ",", "log", "=", "logging", ".", "info", ")", ":", "basedir", "=", "os", ".", "path", ".", "dirname", "(", "ssmLT", ")", "if", "os", ".", "path", ".", "basename", "(", "ssmLT", ")", "!=", "'ssmLT.xml'", ":", "orig", "=", "ssmLT", "ssmLT", "=", "os", ".", "path", ".", "join", "(", "basedir", ",", "'ssmLT.xml'", ")", "with", "open", "(", "ssmLT", ",", "'wb'", ")", "as", "f", ":", "f", ".", "write", "(", "open", "(", "orig", ",", "'rb'", ")", ".", "read", "(", ")", ")", "archive_zip", "=", "archive_zip", "or", "os", ".", "path", ".", "join", "(", "basedir", ",", "'ssmLT.zip'", ")", "if", "os", ".", "path", ".", "exists", "(", "archive_zip", ")", ":", "sys", ".", "exit", "(", "'%s exists already'", "%", "archive_zip", ")", "oq", "=", "mock", ".", "Mock", "(", "inputs", "=", "{", "'source_model_logic_tree'", ":", "ssmLT", "}", ")", "checksum", "=", "readinput", ".", "get_checksum32", "(", "oq", ")", "checkfile", "=", "os", ".", "path", ".", "join", "(", "os", ".", "path", ".", "dirname", "(", "ssmLT", ")", ",", "'CHECKSUM.txt'", ")", "with", "open", "(", "checkfile", ",", "'w'", ")", "as", "f", ":", "f", ".", "write", "(", "str", "(", "checksum", ")", ")", "files", "=", "logictree", ".", "collect_info", "(", "ssmLT", ")", ".", "smpaths", "+", "[", "os", ".", "path", ".", "abspath", "(", "ssmLT", ")", ",", "os", ".", "path", ".", "abspath", "(", "checkfile", ")", "]", "general", ".", "zipfiles", "(", "files", ",", "archive_zip", ",", "log", "=", "log", ",", "cleanup", "=", "True", ")", "return", "archive_zip" ]

[ "Zip", "the", "source", "model", "files", "starting", "from", "the", "smmLT", ".", "xml", "file" ]

[ "def", "zip_exposure", "(", "exposure_xml", ",", "archive_zip", "=", "''", ",", "log", "=", "logging", ".", "info", ")", ":", "archive_zip", "=", "archive_zip", "or", "exposure_xml", "[", ":", "-", "4", "]", "+", "'.zip'", "if", "os", ".", "path", ".", "exists", "(", "archive_zip", ")", ":", "sys", ".", "exit", "(", "'%s exists already'", "%", "archive_zip", ")", "[", "exp", "]", "=", "Exposure", ".", "read_headers", "(", "[", "exposure_xml", "]", ")", "files", "=", "[", "exposure_xml", "]", "+", "exp", ".", "datafiles", "general", ".", "zipfiles", "(", "files", ",", "archive_zip", ",", "log", "=", "log", ",", "cleanup", "=", "True", ")", "return", "archive_zip" ]

[ "Zip", "an", "exposure", ".", "xml", "file", "with", "all", "its", ".", "csv", "subfiles", "(", "if", "any", ")" ]

[ "def", "zip_job", "(", "job_ini", ",", "archive_zip", "=", "''", ",", "risk_ini", "=", "''", ",", "oq", "=", "None", ",", "log", "=", "logging", ".", "info", ")", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "job_ini", ")", ":", "sys", ".", "exit", "(", "'%s does not exist'", "%", "job_ini", ")", "archive_zip", "=", "archive_zip", "or", "'job.zip'", "if", "isinstance", "(", "archive_zip", ",", "str", ")", ":", "# actually it should be path-like", "if", "not", "archive_zip", ".", "endswith", "(", "'.zip'", ")", ":", "sys", ".", "exit", "(", "'%s does not end with .zip'", "%", "archive_zip", ")", "if", "os", ".", "path", ".", "exists", "(", "archive_zip", ")", ":", "sys", ".", "exit", "(", "'%s exists already'", "%", "archive_zip", ")", "# do not validate to avoid permissions error on the export_dir", "oq", "=", "oq", "or", "readinput", ".", "get_oqparam", "(", "job_ini", ",", "validate", "=", "False", ")", "if", "risk_ini", ":", "risk_ini", "=", "os", ".", "path", ".", "normpath", "(", "os", ".", "path", ".", "abspath", "(", "risk_ini", ")", ")", "risk_inputs", "=", "readinput", ".", "get_params", "(", "[", "risk_ini", "]", ")", "[", "'inputs'", "]", "del", "risk_inputs", "[", "'job_ini'", "]", "oq", ".", "inputs", ".", "update", "(", "risk_inputs", ")", "files", "=", "readinput", ".", "get_input_files", "(", "oq", ")", "if", "risk_ini", ":", "files", "=", "[", "risk_ini", "]", "+", "files", "return", "general", ".", "zipfiles", "(", "files", ",", "archive_zip", ",", "log", "=", "log", ")" ]

[ "Zip", "the", "given", "job", ".", "ini", "file", "into", "the", "given", "archive", "together", "with", "all", "related", "files", "." ]

[ "def", "build_report", "(", "job_ini", ",", "output_dir", "=", "None", ")", ":", "calc_id", "=", "logs", ".", "init", "(", ")", "oq", "=", "readinput", ".", "get_oqparam", "(", "job_ini", ")", "if", "oq", ".", "calculation_mode", "==", "'classical'", ":", "oq", ".", "calculation_mode", "=", "'preclassical'", "oq", ".", "ground_motion_fields", "=", "False", "output_dir", "=", "output_dir", "or", "os", ".", "path", ".", "dirname", "(", "job_ini", ")", "from", "openquake", ".", "calculators", "import", "base", "# ugly", "calc", "=", "base", ".", "calculators", "(", "oq", ",", "calc_id", ")", "calc", ".", "save_params", "(", ")", "# needed to save oqparam", "# some taken is care so that the real calculation is not run:", "# the goal is to extract information about the source management only", "calc", ".", "pre_execute", "(", ")", "if", "oq", ".", "calculation_mode", "==", "'preclassical'", ":", "calc", ".", "execute", "(", ")", "rw", "=", "ReportWriter", "(", "calc", ".", "datastore", ")", "rw", ".", "make_report", "(", ")", "report", "=", "(", "os", ".", "path", ".", "join", "(", "output_dir", ",", "'report.rst'", ")", "if", "output_dir", "else", "calc", ".", "datastore", ".", "export_path", "(", "'report.rst'", ")", ")", "try", ":", "rw", ".", "save", "(", "report", ")", "except", "IOError", "as", "exc", ":", "# permission error", "sys", ".", "stderr", ".", "write", "(", "str", "(", "exc", ")", "+", "'\\n'", ")", "readinput", ".", "exposure", "=", "None", "# ugly hack", "return", "report" ]

[ "Write", "a", "report", ".", "csv", "file", "with", "information", "about", "the", "calculation", "without", "running", "it" ]

[ "def", "add", "(", "self", ",", "name", ",", "obj", "=", "None", ")", ":", "if", "obj", ":", "text", "=", "'\\n::\\n\\n'", "+", "indent", "(", "str", "(", "obj", ")", ")", "else", ":", "text", "=", "views", ".", "view", "(", "name", ",", "self", ".", "dstore", ")", "if", "text", ":", "title", "=", "self", ".", "title", "[", "name", "]", "line", "=", "'-'", "*", "len", "(", "title", ")", "self", ".", "text", "+=", "'\\n'", ".", "join", "(", "[", "'\\n\\n'", "+", "title", ",", "line", ",", "text", "]", ")" ]

[ "Add", "the", "view", "named", "name", "to", "the", "report", "text" ]

[ "def", "make_report", "(", "self", ")", ":", "oq", ",", "ds", "=", "self", ".", "oq", ",", "self", ".", "dstore", "for", "name", "in", "(", "'params'", ",", "'inputs'", ")", ":", "self", ".", "add", "(", "name", ")", "if", "'csm_info'", "in", "ds", ":", "self", ".", "add", "(", "'csm_info'", ")", "if", "ds", "[", "'csm_info'", "]", ".", "source_models", "[", "0", "]", ".", "name", "!=", "'scenario'", ":", "# required_params_per_trt makes no sense for GMFs from file", "self", ".", "add", "(", "'required_params_per_trt'", ")", "self", ".", "add", "(", "'rlzs_assoc'", ",", "ds", "[", "'csm_info'", "]", ".", "get_rlzs_assoc", "(", ")", ")", "if", "'csm_info'", "in", "ds", ":", "self", ".", "add", "(", "'ruptures_per_trt'", ")", "if", "'rup_data'", "in", "ds", ":", "self", ".", "add", "(", "'ruptures_events'", ")", "if", "oq", ".", "calculation_mode", "in", "(", "'event_based_risk'", ",", ")", ":", "self", ".", "add", "(", "'avglosses_data_transfer'", ")", "if", "'exposure'", "in", "oq", ".", "inputs", ":", "self", ".", "add", "(", "'exposure_info'", ")", "if", "'source_info'", "in", "ds", ":", "self", ".", "add", "(", "'slow_sources'", ")", "self", ".", "add", "(", "'times_by_source_class'", ")", "self", ".", "add", "(", "'dupl_sources'", ")", "if", "'task_info'", "in", "ds", ":", "self", ".", "add", "(", "'task_info'", ")", "tasks", "=", "set", "(", "ds", "[", "'task_info'", "]", ")", "if", "'classical'", "in", "tasks", ":", "self", ".", "add", "(", "'task_hazard:0'", ")", "self", ".", "add", "(", "'task_hazard:-1'", ")", "self", ".", "add", "(", "'job_info'", ")", "if", "'performance_data'", "in", "ds", ":", "self", ".", "add", "(", "'performance'", ")", "return", "self", ".", "text" ]

[ "Build", "the", "report", "and", "return", "a", "restructed", "text", "string" ]

[ "def", "save", "(", "self", ",", "fname", ")", ":", "with", "open", "(", "fname", ",", "'wb'", ")", "as", "f", ":", "f", ".", "write", "(", "encode", "(", "self", ".", "text", ")", ")" ]

[ "Save", "the", "report" ]

[ "def", "convert_to_LHC", "(", "imt", ")", ":", "# get period t", "if", "isinstance", "(", "imt", ",", "SA", ")", ":", "t", "=", "imt", ".", "period", "else", ":", "t", "=", "0.01", "T1", "=", "0.08", "T2", "=", "0.56", "T3", "=", "4.40", "T4", "=", "8.70", "R1", "=", "1.106", "R2", "=", "1.158", "R3", "=", "1.178", "R4", "=", "1.241", "R5", "=", "1.241", "Ratio", "=", "max", "(", "R1", ",", "max", "(", "min", "(", "R1", "+", "(", "R2", "-", "R1", ")", "/", "np", ".", "log", "(", "T2", "/", "T1", ")", "*", "np", ".", "log", "(", "t", "/", "T1", ")", ",", "R2", "+", "(", "R3", "-", "R2", ")", "/", "np", ".", "log", "(", "T3", "/", "T2", ")", "*", "np", ".", "log", "(", "t", "/", "T2", ")", ")", ",", "min", "(", "R3", "+", "(", "R4", "-", "R3", ")", "/", "np", ".", "log", "(", "T4", "/", "T3", ")", "*", "np", ".", "log", "(", "t", "/", "T3", ")", ",", "R5", ")", ")", ")", "SF", "=", "np", ".", "log", "(", "Ratio", ")", "return", "SF" ]

[ "Converts", "from", "GMRotI50", "to", "Larger", "of", "two", "horizontal", "components", "using", "global", "equation", "of", ":", "Boore", "D", "and", "Kishida", "T", "(", "2016", ")", ".", "Relations", "between", "some", "horizontal", "-", "component", "ground", "-", "motion", "intensity", "measures", "used", "in", "practice", ".", "Bulletin", "of", "the", "Seismological", "Society", "of", "America", "107", "(", "1", ")", "334", "-", "343", ".", "doi", ":", "10", ".", "1785", "/", "0120160250", "No", "standard", "deviation", "modification", "required", "." ]

[ "def", "_get_mean", "(", "self", ",", "sites", ",", "C", ",", "ln_y_ref", ",", "exp1", ",", "exp2", ",", "v1", ")", ":", "# we do not support estimating of basin depth and instead", "# rely on it being available (since we require it).", "z1pt0", "=", "sites", ".", "z1pt0", "# we consider random variables being zero since we want", "# to find the exact mean value.", "eta", "=", "epsilon", "=", "0", "ln_y", "=", "(", "# first line of eq. 13b", "ln_y_ref", "+", "C", "[", "'phi1'", "]", "*", "np", ".", "log", "(", "np", ".", "clip", "(", "sites", ".", "vs30", ",", "-", "np", ".", "inf", ",", "v1", ")", "/", "1130", ")", "# second line", "+", "C", "[", "'phi2'", "]", "*", "(", "exp1", "-", "exp2", ")", "*", "np", ".", "log", "(", "(", "np", ".", "exp", "(", "ln_y_ref", ")", "+", "C", "[", "'phi4'", "]", ")", "/", "C", "[", "'phi4'", "]", ")", "# third line", "+", "C", "[", "'phi5'", "]", "*", "(", "1.0", "-", "1.0", "/", "np", ".", "cosh", "(", "C", "[", "'phi6'", "]", "*", "(", "z1pt0", "-", "C", "[", "'phi7'", "]", ")", ".", "clip", "(", "0", ",", "np", ".", "inf", ")", ")", ")", "+", "C", "[", "'phi8'", "]", "/", "np", ".", "cosh", "(", "0.15", "*", "(", "z1pt0", "-", "15", ")", ".", "clip", "(", "0", ",", "np", ".", "inf", ")", ")", "# fourth line", "+", "eta", "+", "epsilon", ")", "return", "ln_y" ]

[ "Add", "site", "effects", "to", "an", "intensity", "." ]

[ "def", "_get_v1", "(", "self", ",", "imt", ")", ":", "if", "imt", "==", "PGA", "(", ")", ":", "v1", "=", "1800.", "else", ":", "T", "=", "imt", ".", "period", "v1a", "=", "np", ".", "clip", "(", "(", "1130", "*", "(", "T", "/", "0.75", ")", "**", "-", "0.11", ")", ",", "1130", ",", "np", ".", "inf", ")", "v1", "=", "np", ".", "clip", "(", "v1a", ",", "-", "np", ".", "inf", ",", "1800.", ")", "return", "v1" ]

[ "Calculates", "Bradley", "s", "V1", "term", ".", "Equation", "2", "(", "page", "1814", ")", "and", "6", "(", "page", "1816", ")", "based", "on", "SA", "period" ]

[ "def", "get_mean_and_stddevs", "(", "self", ",", "sites", ",", "rup", ",", "dists", ",", "imt", ",", "stddev_types", ")", ":", "# extracting dictionary of coefficients specific to required", "# intensity measure type.", "C", "=", "self", ".", "COEFFS", "[", "imt", "]", "# intensity on a reference soil is used for both mean", "# and stddev calculations.", "ln_y_ref", "=", "self", ".", "_get_ln_y_ref", "(", "rup", ",", "dists", ",", "C", ")", "# exp1 and exp2 are parts of eq. 7", "exp1", "=", "np", ".", "exp", "(", "C", "[", "'phi3'", "]", "*", "(", "sites", ".", "vs30", ".", "clip", "(", "-", "np", ".", "inf", ",", "1130", ")", "-", "360", ")", ")", "exp2", "=", "np", ".", "exp", "(", "C", "[", "'phi3'", "]", "*", "(", "1130", "-", "360", ")", ")", "# v1 is the period dependent site term. The Vs30 above which, the", "# amplification is constant", "v1", "=", "self", ".", "_get_v1", "(", "imt", ")", "mean", "=", "self", ".", "_get_mean", "(", "sites", ",", "C", ",", "ln_y_ref", ",", "exp1", ",", "exp2", ",", "v1", ")", "mean", "+=", "convert_to_LHC", "(", "imt", ")", "stddevs", "=", "self", ".", "_get_stddevs", "(", "sites", ",", "rup", ",", "C", ",", "stddev_types", ",", "ln_y_ref", ",", "exp1", ",", "exp2", ")", "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", ",", "sites", ",", "rup", ",", "dists", ",", "imt", ",", "stddev_types", ")", ":", "assert", "all", "(", "stddev_type", "in", "self", ".", "DEFINED_FOR_STANDARD_DEVIATION_TYPES", "for", "stddev_type", "in", "stddev_types", ")", "if", "imt", "not", "in", "self", ".", "IMTS_TABLES", ":", "raise", "ValueError", "(", "'IMT %s not supported in FrankelEtAl1996NSHMP. '", "%", "repr", "(", "imt", ")", "+", "'FrankelEtAl1996NSHMP does not allow interpolation for '", "+", "'unsupported periods.'", ")", "mean", "=", "self", ".", "_compute_mean", "(", "imt", ",", "rup", ".", "mag", ",", "dists", ".", "rhypo", ".", "copy", "(", ")", ")", "mean", "=", "clip_mean", "(", "imt", ",", "mean", ")", "stddevs", "=", "self", ".", "_compute_stddevs", "(", "imt", ",", "dists", ".", "rhypo", ".", "shape", ",", "stddev_types", ")", "return", "mean", ",", "stddevs" ]

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

[ "def", "_compute_mean", "(", "self", ",", "imt", ",", "mag", ",", "rhypo", ")", ":", "mag", "=", "np", ".", "zeros_like", "(", "rhypo", ")", "+", "self", ".", "_convert_magnitude", "(", "mag", ")", "# to avoid run time warning in case rhypo is zero set minimum distance", "# to 10, which is anyhow the minimum distance allowed by the tables", "rhypo", "[", "rhypo", "<", "10", "]", "=", "10", "rhypo", "=", "np", ".", "log10", "(", "rhypo", ")", "# create lookup table and interpolate it at magnitude/distance values", "table", "=", "RectBivariateSpline", "(", "self", ".", "MAGS", ",", "self", ".", "DISTS", ",", "self", ".", "IMTS_TABLES", "[", "imt", "]", ".", "T", ")", "mean", "=", "table", ".", "ev", "(", "mag", ",", "rhypo", ")", "# convert mean from base 10 to base e", "return", "mean", "*", "np", ".", "log", "(", "10", ")" ]

[ "Compute", "mean", "value", "from", "lookup", "table", "." ]

[ "def", "_get_recurrence_model", "(", "input_model", ")", ":", "if", "not", "isinstance", "(", "input_model", ",", "(", "TruncatedGRMFD", ",", "EvenlyDiscretizedMFD", ",", "YoungsCoppersmith1985MFD", ")", ")", ":", "raise", "ValueError", "(", "'Recurrence model not recognised'", ")", "# Get model annual occurrence rates", "annual_rates", "=", "input_model", ".", "get_annual_occurrence_rates", "(", ")", "annual_rates", "=", "np", ".", "array", "(", "[", "[", "val", "[", "0", "]", ",", "val", "[", "1", "]", "]", "for", "val", "in", "annual_rates", "]", ")", "# Get cumulative rates", "cumulative_rates", "=", "np", ".", "array", "(", "[", "np", ".", "sum", "(", "annual_rates", "[", "iloc", ":", ",", "1", "]", ")", "for", "iloc", "in", "range", "(", "0", ",", "len", "(", "annual_rates", ")", ",", "1", ")", "]", ")", "return", "annual_rates", ",", "cumulative_rates" ]

[ "Returns", "the", "annual", "and", "cumulative", "recurrence", "rates", "predicted", "by", "the", "recurrence", "model" ]

[ "def", "_check_completeness_table", "(", "completeness", ",", "catalogue", ")", ":", "if", "isinstance", "(", "completeness", ",", "np", ".", "ndarray", ")", "and", "np", ".", "shape", "(", "completeness", ")", "[", "1", "]", "==", "2", ":", "return", "completeness", "elif", "isinstance", "(", "completeness", ",", "float", ")", ":", "return", "np", ".", "array", "(", "[", "[", "float", "(", "np", ".", "min", "(", "catalogue", ".", "data", "[", "'year'", "]", ")", ")", ",", "completeness", "]", "]", ")", "elif", "completeness", "is", "None", ":", "return", "np", ".", "array", "(", "[", "[", "float", "(", "np", ".", "min", "(", "catalogue", ".", "data", "[", "'year'", "]", ")", ")", ",", "np", ".", "min", "(", "catalogue", ".", "data", "[", "'magnitude'", "]", ")", "]", "]", ")", "else", ":", "raise", "ValueError", "(", "'Completeness representation not recognised'", ")" ]

[ "Generates", "the", "completeness", "table", "according", "to", "different", "instances" ]

[ "def", "plot_recurrence_model", "(", "input_model", ",", "catalogue", ",", "completeness", ",", "dmag", "=", "0.1", ",", "filename", "=", "None", ",", "figure_size", "=", "(", "8", ",", "6", ")", ",", "filetype", "=", "'png'", ",", "dpi", "=", "300", ",", "ax", "=", "None", ")", ":", "annual_rates", ",", "cumulative_rates", "=", "_get_recurrence_model", "(", "input_model", ")", "# Get observed annual recurrence", "if", "not", "catalogue", ".", "end_year", ":", "catalogue", ".", "update_end_year", "(", ")", "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'", ")", "ax", ".", "semilogy", "(", "annual_rates", "[", ":", ",", "0", "]", ",", "annual_rates", "[", ":", ",", "1", "]", ",", "'b-'", ")", "ax", ".", "semilogy", "(", "cent_mag", ",", "cum_obs_rates", ",", "'rs'", ")", "ax", ".", "semilogy", "(", "annual_rates", "[", ":", ",", "0", "]", ",", "cumulative_rates", ",", "'r-'", ")", "ax", ".", "grid", "(", "which", "=", "'both'", ")", "ax", ".", "set_xlabel", "(", "'Magnitude'", ")", "ax", ".", "set_ylabel", "(", "'Annual Rate'", ")", "ax", ".", "legend", "(", "[", "'Observed Incremental Rate'", ",", "'Model Incremental Rate'", ",", "'Observed Cumulative Rate'", ",", "'Model Cumulative Rate'", "]", ")", "ax", ".", "tick_params", "(", "labelsize", "=", "12", ")", "_save_image", "(", "fig", ",", "filename", ",", "filetype", ",", "dpi", ")" ]

[ "Plot", "a", "calculated", "recurrence", "model", "over", "an", "observed", "catalogue", "adjusted", "for", "time", "-", "varying", "completeness" ]

[ "def", "plot_trunc_gr_model", "(", "aval", ",", "bval", ",", "min_mag", ",", "max_mag", ",", "dmag", ",", "catalogue", "=", "None", ",", "completeness", "=", "None", ",", "filename", "=", "None", ",", "figure_size", "=", "(", "8", ",", "6", ")", ",", "filetype", "=", "'png'", ",", "dpi", "=", "300", ",", "ax", "=", "None", ")", ":", "input_model", "=", "TruncatedGRMFD", "(", "min_mag", ",", "max_mag", ",", "dmag", ",", "aval", ",", "bval", ")", "if", "not", "catalogue", ":", "# Plot only the modelled recurrence", "annual_rates", ",", "cumulative_rates", "=", "_get_recurrence_model", "(", "input_model", ")", "if", "ax", "is", "None", ":", "fig", ",", "ax", "=", "plt", ".", "subplots", "(", "figsize", "=", "figure_size", ")", "else", ":", "fig", "=", "ax", ".", "get_figure", "(", ")", "ax", ".", "semilogy", "(", "annual_rates", "[", ":", ",", "0", "]", ",", "annual_rates", "[", ":", ",", "1", "]", ",", "'b-'", ")", "ax", ".", "semilogy", "(", "annual_rates", "[", ":", ",", "0", "]", ",", "cumulative_rates", ",", "'r-'", ")", "ax", ".", "xlabel", "(", "'Magnitude'", ")", "ax", ".", "set_ylabel", "(", "'Annual Rate'", ")", "ax", ".", "set_legend", "(", "[", "'Incremental Rate'", ",", "'Cumulative Rate'", "]", ")", "_save_image", "(", "fig", ",", "filename", ",", "filetype", ",", "dpi", ")", "else", ":", "completeness", "=", "_check_completeness_table", "(", "completeness", ",", "catalogue", ")", "plot_recurrence_model", "(", "input_model", ",", "catalogue", ",", "completeness", ",", "dmag", ",", "filename", "=", "filename", ",", "figure_size", "=", "figure_size", ",", "filetype", "=", "filetype", ",", "dpi", "=", "dpi", ",", "ax", "=", "ax", ")" ]

[ "Plots", "a", "Gutenberg", "-", "Richter", "model" ]

[ "def", "get_tag_version", "(", "nrml_node", ")", ":", "version", ",", "tag", "=", "re", ".", "search", "(", "r'(nrml/[\\d\\.]+)\\}(\\w+)'", ",", "nrml_node", ".", "tag", ")", ".", "groups", "(", ")", "return", "tag", ",", "version" ]

[ "Extract", "from", "a", "node", "of", "kind", "NRML", "the", "tag", "and", "the", "version", ".", "For", "instance", "from", "{", "http", ":", "//", "openquake", ".", "org", "/", "xmlns", "/", "nrml", "/", "0", ".", "4", "}", "fragilityModel", "one", "gets", "the", "pair", "(", "fragilityModel", "nrml", "/", "0", ".", "4", ")", "." ]

[ "def", "to_python", "(", "fname", ",", "*", "args", ")", ":", "[", "node", "]", "=", "read", "(", "fname", ")", "return", "node_to_obj", "(", "node", ",", "fname", ",", "*", "args", ")" ]

[ "Parse", "a", "NRML", "file", "and", "return", "an", "associated", "Python", "object", ".", "It", "works", "by", "calling", "nrml", ".", "read", "()", "and", "node_to_obj", "()", "in", "sequence", "." ]

[ "def", "read_source_models", "(", "fnames", ",", "converter", ",", "monitor", ")", ":", "for", "fname", "in", "fnames", ":", "if", "fname", ".", "endswith", "(", "(", "'.xml'", ",", "'.nrml'", ")", ")", ":", "sm", "=", "to_python", "(", "fname", ",", "converter", ")", "elif", "fname", ".", "endswith", "(", "'.hdf5'", ")", ":", "sm", "=", "sourceconverter", ".", "to_python", "(", "fname", ",", "converter", ")", "else", ":", "raise", "ValueError", "(", "'Unrecognized extension in %s'", "%", "fname", ")", "sm", ".", "fname", "=", "fname", "yield", "sm" ]

[ ":", "param", "fnames", ":", "list", "of", "source", "model", "files", ":", "param", "converter", ":", "a", "SourceConverter", "instance", ":", "param", "monitor", ":", "a", ":", "class", ":", "openquake", ".", "performance", ".", "Monitor", "instance", ":", "yields", ":", "SourceModel", "instances" ]

[ "def", "read", "(", "source", ",", "chatty", "=", "True", ",", "stop", "=", "None", ")", ":", "vparser", "=", "ValidatingXmlParser", "(", "validators", ",", "stop", ")", "nrml", "=", "vparser", ".", "parse_file", "(", "source", ")", "if", "striptag", "(", "nrml", ".", "tag", ")", "!=", "'nrml'", ":", "raise", "ValueError", "(", "'%s: expected a node of kind nrml, got %s'", "%", "(", "source", ",", "nrml", ".", "tag", ")", ")", "# extract the XML namespace URL ('http://openquake.org/xmlns/nrml/0.5')", "xmlns", "=", "nrml", ".", "tag", ".", "split", "(", "'}'", ")", "[", "0", "]", "[", "1", ":", "]", "if", "xmlns", "!=", "NRML05", "and", "chatty", ":", "# for the moment NRML04 is still supported, so we hide the warning", "logging", ".", "debug", "(", "'%s is at an outdated version: %s'", ",", "source", ",", "xmlns", ")", "nrml", "[", "'xmlns'", "]", "=", "xmlns", "nrml", "[", "'xmlns:gml'", "]", "=", "GML_NAMESPACE", "return", "nrml" ]

[ "Convert", "a", "NRML", "file", "into", "a", "validated", "Node", "object", ".", "Keeps", "the", "entire", "tree", "in", "memory", "." ]

[ "def", "write", "(", "nodes", ",", "output", "=", "sys", ".", "stdout", ",", "fmt", "=", "'%.7E'", ",", "gml", "=", "True", ",", "xmlns", "=", "None", ")", ":", "root", "=", "Node", "(", "'nrml'", ",", "nodes", "=", "nodes", ")", "namespaces", "=", "{", "xmlns", "or", "NRML05", ":", "''", "}", "if", "gml", ":", "namespaces", "[", "GML_NAMESPACE", "]", "=", "'gml:'", "with", "floatformat", "(", "fmt", ")", ":", "node_to_xml", "(", "root", ",", "output", ",", "namespaces", ")", "if", "hasattr", "(", "output", ",", "'mode'", ")", "and", "'+'", "in", "output", ".", "mode", ":", "# read-write mode", "output", ".", "seek", "(", "0", ")", "read", "(", "output", ")" ]

[ "Convert", "nodes", "into", "a", "NRML", "file", ".", "output", "must", "be", "a", "file", "object", "open", "in", "write", "mode", ".", "If", "you", "want", "to", "perform", "a", "consistency", "check", "open", "it", "in", "read", "-", "write", "mode", "then", "it", "will", "be", "read", "after", "creation", "and", "validated", "." ]

[ "def", "to_string", "(", "node", ")", ":", "with", "io", ".", "BytesIO", "(", ")", "as", "f", ":", "write", "(", "[", "node", "]", ",", "f", ")", "return", "f", ".", "getvalue", "(", ")", ".", "decode", "(", "'utf-8'", ")" ]

[ "Convert", "a", "node", "into", "a", "string", "in", "NRML", "format" ]

[ "def", "get_mean_and_stddevs", "(", "self", ",", "sites", ",", "rup", ",", "dists", ",", "imt", ",", "stddev_types", ")", ":", "C", "=", "self", ".", "COEFFS", "[", "imt", "]", "# Get the mean", "mean", "=", "self", ".", "get_mean", "(", "C", ",", "rup", ",", "sites", ",", "dists", ")", "if", "imt", ".", "name", "==", "\"PGV\"", ":", "# Convert from log10 m/s to ln cm/s", "mean", "=", "np", ".", "log", "(", "(", "10.0", "**", "mean", ")", "*", "100.", ")", "else", ":", "# convert from log10 m/s/s to ln g", "mean", "=", "np", ".", "log", "(", "(", "10.0", "**", "mean", ")", "/", "g", ")", "# Get the standard deviations", "stddevs", "=", "self", ".", "get_stddevs", "(", "C", ",", "mean", ".", "shape", ",", "stddev_types", ")", "return", "mean", ",", "stddevs" ]

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

[ "def", "get_mean", "(", "self", ",", "C", ",", "rup", ",", "sites", ",", "dists", ")", ":", "# W2 needs to be a 1 by 5 matrix (not a vector", "w_2", "=", "np", ".", "array", "(", "[", "[", "C", "[", "\"W_21\"", "]", ",", "C", "[", "\"W_22\"", "]", ",", "C", "[", "\"W_23\"", "]", ",", "C", "[", "\"W_24\"", "]", ",", "C", "[", "\"W_25\"", "]", "]", "]", ")", "# Gets the style of faulting dummy variable", "sof", "=", "self", ".", "_get_sof_dummy_variable", "(", "rup", ".", "rake", ")", "# Get the normalised coefficients", "p_n", "=", "self", ".", "get_pn", "(", "rup", ",", "sites", ",", "dists", ",", "sof", ")", "mean", "=", "np", ".", "zeros_like", "(", "dists", ".", "rjb", ")", "# Need to loop over sites - maybe this can be improved in future?", "# ndenumerate is used to allow for application to 2-D arrays", "for", "idx", ",", "rval", "in", "np", ".", "ndenumerate", "(", "p_n", "[", "0", "]", ")", ":", "# Place normalised coefficients into a single array", "p_n_i", "=", "np", ".", "array", "(", "[", "rval", ",", "p_n", "[", "1", "]", ",", "p_n", "[", "2", "]", "[", "idx", "]", ",", "p_n", "[", "3", "]", ",", "p_n", "[", "4", "]", "]", ")", "# Executes the main ANN model", "mean_i", "=", "np", ".", "dot", "(", "w_2", ",", "np", ".", "tanh", "(", "np", ".", "dot", "(", "self", ".", "W_1", ",", "p_n_i", ")", "+", "self", ".", "B_1", ")", ")", "mean", "[", "idx", "]", "=", "(", "0.5", "*", "(", "mean_i", "+", "C", "[", "\"B_2\"", "]", "+", "1.0", ")", "*", "(", "C", "[", "\"tmax\"", "]", "-", "C", "[", "\"tmin\"", "]", ")", ")", "+", "C", "[", "\"tmin\"", "]", "return", "mean" ]

[ "Returns", "the", "mean", "ground", "motion", "in", "terms", "of", "log10", "m", "/", "s", "/", "s", "implementing", "equation", "2", "(", "page", "502", ")" ]

[ "def", "get_mean_and_stddevs", "(", "self", ",", "sites", ",", "rup", ",", "dists", ",", "imt", ",", "stddev_types", ")", ":", "# extracting dictionary of coefficients specific to required", "# intensity measure type.", "C", "=", "self", ".", "COEFFS", "[", "imt", "]", "mean", "=", "(", "self", ".", "_compute_style_of_faulting_term", "(", "rup", ",", "C", ")", "+", "self", ".", "_compute_magnitude_scaling", "(", "rup", ".", "mag", ",", "C", ")", "+", "self", ".", "_compute_distance_scaling", "(", "dists", ".", "rjb", ",", "C", ")", "+", "self", ".", "_compute_site_term", "(", "sites", ".", "vs30", ",", "C", ")", ")", "stddevs", "=", "self", ".", "_get_stddevs", "(", "C", ",", "stddev_types", ",", "num_sites", "=", "len", "(", "sites", ".", "vs30", ")", ")", "return", "mean", ",", "stddevs" ]

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

[ "def", "_compute_distance_scaling", "(", "self", ",", "rjb", ",", "C", ")", ":", "# Calculate distance according to Page 141, Eq 2.", "rdist", "=", "np", ".", "sqrt", "(", "(", "rjb", "**", "2.", ")", "+", "(", "C", "[", "'h'", "]", "**", "2.", ")", ")", "return", "C", "[", "'B5'", "]", "*", "np", ".", "log", "(", "rdist", ")" ]

[ "Compute", "distance", "-", "scaling", "term", "(", "Page", "141", "Eq", "1", ")" ]

[ "def", "_compute_magnitude_scaling", "(", "self", ",", "mag", ",", "C", ")", ":", "dmag", "=", "mag", "-", "6.", "return", "(", "C", "[", "'B2'", "]", "*", "dmag", ")", "+", "(", "C", "[", "'B3'", "]", "*", "(", "dmag", "**", "2.", ")", ")" ]

[ "Compute", "magnitude", "-", "scaling", "term", "(", "Page", "141", "Eq", "1", ")" ]

[ "def", "_compute_style_of_faulting_term", "(", "self", ",", "rup", ",", "C", ")", ":", "if", "np", ".", "abs", "(", "rup", ".", "rake", ")", "<=", "30.0", "or", "(", "180.0", "-", "np", ".", "abs", "(", "rup", ".", "rake", ")", ")", "<=", "30.0", ":", "# strike-slip", "return", "C", "[", "'B1ss'", "]", "elif", "rup", ".", "rake", ">", "30.0", "and", "rup", ".", "rake", "<", "150.0", ":", "# reverse", "return", "C", "[", "'B1rv'", "]", "else", ":", "# unspecified (also includes Normal faulting!)", "return", "C", "[", "'B1all'", "]" ]

[ "Computes", "the", "coefficient", "to", "scale", "for", "reverse", "or", "strike", "-", "slip", "events", "Fault", "type", "(", "Strike", "-", "slip", "Normal", "Thrust", "/", "reverse", ")", "is", "derived", "from", "rake", "angle", ".", "Rakes", "angles", "within", "30", "of", "horizontal", "are", "strike", "-", "slip", "angles", "from", "30", "to", "150", "are", "reverse", "and", "angles", "from", "-", "30", "to", "-", "150", "are", "normal", ".", "See", "paragraph", "Predictor", "Variables", "pag", "103", ".", "Note", "that", "Unspecified", "case", "is", "used", "to", "refer", "to", "all", "other", "rake", "angles", "." ]

[ "def", "get_mean_and_stddevs", "(", "self", ",", "sites", ",", "rup", ",", "dists", ",", "imt", ",", "stddev_types", ")", ":", "# extract dictionaries of coefficients specific to required", "# intensity measure type and for PGA", "C", "=", "self", ".", "COEFFS", "[", "imt", "]", "C_PGA", "=", "self", ".", "COEFFS", "[", "PGA", "(", ")", "]", "# Get mean and standard deviation of PGA on rock (Vs30 1100 m/s^2)", "pga1100", "=", "np", ".", "exp", "(", "self", ".", "get_mean_values", "(", "C_PGA", ",", "sites", ",", "rup", ",", "dists", ",", "None", ")", ")", "# Get mean and standard deviations for IMT", "mean", "=", "self", ".", "get_mean_values", "(", "C", ",", "sites", ",", "rup", ",", "dists", ",", "pga1100", ")", "if", "imt", ".", "name", "==", "\"SA\"", "and", "imt", ".", "period", "<=", "0.25", ":", "# According to Campbell & Bozorgnia (2013) [NGA West 2 Report]", "# If Sa (T) < PGA for T < 0.25 then set mean Sa(T) to mean PGA", "# Get PGA on soil", "pga", "=", "self", ".", "get_mean_values", "(", "C_PGA", ",", "sites", ",", "rup", ",", "dists", ",", "pga1100", ")", "idx", "=", "mean", "<=", "pga", "mean", "[", "idx", "]", "=", "pga", "[", "idx", "]", "# Get standard deviations", "stddevs", "=", "self", ".", "_get_stddevs", "(", "C", ",", "C_PGA", ",", "rup", ",", "sites", ",", "pga1100", ",", "stddev_types", ")", "return", "mean", ",", "stddevs" ]

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

[ "def", "get_mean_values", "(", "self", ",", "C", ",", "sites", ",", "rup", ",", "dists", ",", "a1100", ")", ":", "if", "isinstance", "(", "a1100", ",", "np", ".", "ndarray", ")", ":", "# Site model defined", "temp_vs30", "=", "sites", ".", "vs30", "temp_z2pt5", "=", "sites", ".", "z2pt5", "else", ":", "# Default site and basin model", "temp_vs30", "=", "1100.0", "*", "np", ".", "ones", "(", "len", "(", "sites", ".", "vs30", ")", ")", "temp_z2pt5", "=", "self", ".", "_select_basin_model", "(", "1100.0", ")", "*", "np", ".", "ones_like", "(", "temp_vs30", ")", "return", "(", "self", ".", "_get_magnitude_term", "(", "C", ",", "rup", ".", "mag", ")", "+", "self", ".", "_get_geometric_attenuation_term", "(", "C", ",", "rup", ".", "mag", ",", "dists", ".", "rrup", ")", "+", "self", ".", "_get_style_of_faulting_term", "(", "C", ",", "rup", ")", "+", "self", ".", "_get_hanging_wall_term", "(", "C", ",", "rup", ",", "dists", ")", "+", "self", ".", "_get_shallow_site_response_term", "(", "C", ",", "temp_vs30", ",", "a1100", ")", "+", "self", ".", "_get_basin_response_term", "(", "C", ",", "temp_z2pt5", ")", "+", "self", ".", "_get_hypocentral_depth_term", "(", "C", ",", "rup", ")", "+", "self", ".", "_get_fault_dip_term", "(", "C", ",", "rup", ")", "+", "self", ".", "_get_anelastic_attenuation_term", "(", "C", ",", "dists", ".", "rrup", ")", ")" ]

[ "Returns", "the", "mean", "values", "for", "a", "specific", "IMT" ]

[ "def", "_get_magnitude_term", "(", "self", ",", "C", ",", "mag", ")", ":", "f_mag", "=", "C", "[", "\"c0\"", "]", "+", "C", "[", "\"c1\"", "]", "*", "mag", "if", "(", "mag", ">", "4.5", ")", "and", "(", "mag", "<=", "5.5", ")", ":", "return", "f_mag", "+", "(", "C", "[", "\"c2\"", "]", "*", "(", "mag", "-", "4.5", ")", ")", "elif", "(", "mag", ">", "5.5", ")", "and", "(", "mag", "<=", "6.5", ")", ":", "return", "f_mag", "+", "(", "C", "[", "\"c2\"", "]", "*", "(", "mag", "-", "4.5", ")", ")", "+", "(", "C", "[", "\"c3\"", "]", "*", "(", "mag", "-", "5.5", ")", ")", "elif", "mag", ">", "6.5", ":", "return", "f_mag", "+", "(", "C", "[", "\"c2\"", "]", "*", "(", "mag", "-", "4.5", ")", ")", "+", "(", "C", "[", "\"c3\"", "]", "*", "(", "mag", "-", "5.5", ")", ")", "+", "(", "C", "[", "\"c4\"", "]", "*", "(", "mag", "-", "6.5", ")", ")", "else", ":", "return", "f_mag" ]

[ "Returns", "the", "magnitude", "scaling", "term", "defined", "in", "equation", "2" ]

[ "def", "_get_geometric_attenuation_term", "(", "self", ",", "C", ",", "mag", ",", "rrup", ")", ":", "return", "(", "C", "[", "\"c5\"", "]", "+", "C", "[", "\"c6\"", "]", "*", "mag", ")", "*", "np", ".", "log", "(", "np", ".", "sqrt", "(", "(", "rrup", "**", "2.", ")", "+", "(", "C", "[", "\"c7\"", "]", "**", "2.", ")", ")", ")" ]

[ "Returns", "the", "geometric", "attenuation", "term", "defined", "in", "equation", "3" ]

[ "def", "_get_style_of_faulting_term", "(", "self", ",", "C", ",", "rup", ")", ":", "if", "(", "rup", ".", "rake", ">", "30.0", ")", "and", "(", "rup", ".", "rake", "<", "150.", ")", ":", "frv", "=", "1.0", "fnm", "=", "0.0", "elif", "(", "rup", ".", "rake", ">", "-", "150.0", ")", "and", "(", "rup", ".", "rake", "<", "-", "30.0", ")", ":", "fnm", "=", "1.0", "frv", "=", "0.0", "else", ":", "fnm", "=", "0.0", "frv", "=", "0.0", "fflt_f", "=", "(", "self", ".", "CONSTS", "[", "\"c8\"", "]", "*", "frv", ")", "+", "(", "C", "[", "\"c9\"", "]", "*", "fnm", ")", "if", "rup", ".", "mag", "<=", "4.5", ":", "fflt_m", "=", "0.0", "elif", "rup", ".", "mag", ">", "5.5", ":", "fflt_m", "=", "1.0", "else", ":", "fflt_m", "=", "rup", ".", "mag", "-", "4.5", "return", "fflt_f", "*", "fflt_m" ]

[ "Returns", "the", "style", "-", "of", "-", "faulting", "scaling", "term", "defined", "in", "equations", "4", "to", "6" ]

[ "def", "_get_hanging_wall_term", "(", "self", ",", "C", ",", "rup", ",", "dists", ")", ":", "return", "(", "C", "[", "\"c10\"", "]", "*", "self", ".", "_get_hanging_wall_coeffs_rx", "(", "C", ",", "rup", ",", "dists", ".", "rx", ")", "*", "self", ".", "_get_hanging_wall_coeffs_rrup", "(", "dists", ")", "*", "self", ".", "_get_hanging_wall_coeffs_mag", "(", "C", ",", "rup", ".", "mag", ")", "*", "self", ".", "_get_hanging_wall_coeffs_ztor", "(", "rup", ".", "ztor", ")", "*", "self", ".", "_get_hanging_wall_coeffs_dip", "(", "rup", ".", "dip", ")", ")" ]

[ "Returns", "the", "hanging", "wall", "scaling", "term", "defined", "in", "equations", "7", "to", "16" ]

[ "def", "_get_hanging_wall_coeffs_rx", "(", "self", ",", "C", ",", "rup", ",", "r_x", ")", ":", "# Define coefficients R1 and R2", "r_1", "=", "rup", ".", "width", "*", "cos", "(", "radians", "(", "rup", ".", "dip", ")", ")", "r_2", "=", "62.0", "*", "rup", ".", "mag", "-", "350.0", "fhngrx", "=", "np", ".", "zeros", "(", "len", "(", "r_x", ")", ")", "# Case when 0 <= Rx <= R1", "idx", "=", "np", ".", "logical_and", "(", "r_x", ">=", "0.", ",", "r_x", "<", "r_1", ")", "fhngrx", "[", "idx", "]", "=", "self", ".", "_get_f1rx", "(", "C", ",", "r_x", "[", "idx", "]", ",", "r_1", ")", "# Case when Rx > R1", "idx", "=", "r_x", ">=", "r_1", "f2rx", "=", "self", ".", "_get_f2rx", "(", "C", ",", "r_x", "[", "idx", "]", ",", "r_1", ",", "r_2", ")", "f2rx", "[", "f2rx", "<", "0.0", "]", "=", "0.0", "fhngrx", "[", "idx", "]", "=", "f2rx", "return", "fhngrx" ]

[ "Returns", "the", "hanging", "wall", "r", "-", "x", "caling", "term", "defined", "in", "equation", "7", "to", "12" ]

[ "def", "_get_f1rx", "(", "self", ",", "C", ",", "r_x", ",", "r_1", ")", ":", "rxr1", "=", "r_x", "/", "r_1", "return", "C", "[", "\"h1\"", "]", "+", "(", "C", "[", "\"h2\"", "]", "*", "rxr1", ")", "+", "(", "C", "[", "\"h3\"", "]", "*", "(", "rxr1", "**", "2.", ")", ")" ]

[ "Defines", "the", "f1", "scaling", "coefficient", "defined", "in", "equation", "9" ]

[ "def", "_get_f2rx", "(", "self", ",", "C", ",", "r_x", ",", "r_1", ",", "r_2", ")", ":", "drx", "=", "(", "r_x", "-", "r_1", ")", "/", "(", "r_2", "-", "r_1", ")", "return", "self", ".", "CONSTS", "[", "\"h4\"", "]", "+", "(", "C", "[", "\"h5\"", "]", "*", "drx", ")", "+", "(", "C", "[", "\"h6\"", "]", "*", "(", "drx", "**", "2.", ")", ")" ]

[ "Defines", "the", "f2", "scaling", "coefficient", "defined", "in", "equation", "10" ]

[ "def", "_get_hanging_wall_coeffs_rrup", "(", "self", ",", "dists", ")", ":", "fhngrrup", "=", "np", ".", "ones", "(", "len", "(", "dists", ".", "rrup", ")", ")", "idx", "=", "dists", ".", "rrup", ">", "0.0", "fhngrrup", "[", "idx", "]", "=", "(", "dists", ".", "rrup", "[", "idx", "]", "-", "dists", ".", "rjb", "[", "idx", "]", ")", "/", "dists", ".", "rrup", "[", "idx", "]", "return", "fhngrrup" ]

[ "Returns", "the", "hanging", "wall", "rrup", "term", "defined", "in", "equation", "13" ]

[ "def", "_get_hanging_wall_coeffs_mag", "(", "self", ",", "C", ",", "mag", ")", ":", "if", "mag", "<", "5.5", ":", "return", "0.0", "elif", "mag", ">", "6.5", ":", "return", "1.0", "+", "C", "[", "\"a2\"", "]", "*", "(", "mag", "-", "6.5", ")", "else", ":", "return", "(", "mag", "-", "5.5", ")", "*", "(", "1.0", "+", "C", "[", "\"a2\"", "]", "*", "(", "mag", "-", "6.5", ")", ")" ]

[ "Returns", "the", "hanging", "wall", "magnitude", "term", "defined", "in", "equation", "14" ]

[ "def", "_get_hypocentral_depth_term", "(", "self", ",", "C", ",", "rup", ")", ":", "if", "rup", ".", "hypo_depth", "<=", "7.0", ":", "fhyp_h", "=", "0.0", "elif", "rup", ".", "hypo_depth", ">", "20.0", ":", "fhyp_h", "=", "13.0", "else", ":", "fhyp_h", "=", "rup", ".", "hypo_depth", "-", "7.0", "if", "rup", ".", "mag", "<=", "5.5", ":", "fhyp_m", "=", "C", "[", "\"c17\"", "]", "elif", "rup", ".", "mag", ">", "6.5", ":", "fhyp_m", "=", "C", "[", "\"c18\"", "]", "else", ":", "fhyp_m", "=", "C", "[", "\"c17\"", "]", "+", "(", "(", "C", "[", "\"c18\"", "]", "-", "C", "[", "\"c17\"", "]", ")", "*", "(", "rup", ".", "mag", "-", "5.5", ")", ")", "return", "fhyp_h", "*", "fhyp_m" ]

[ "Returns", "the", "hypocentral", "depth", "scaling", "term", "defined", "in", "equations", "21", "-", "23" ]

[ "def", "_get_fault_dip_term", "(", "self", ",", "C", ",", "rup", ")", ":", "if", "rup", ".", "mag", "<", "4.5", ":", "return", "C", "[", "\"c19\"", "]", "*", "rup", ".", "dip", "elif", "rup", ".", "mag", ">", "5.5", ":", "return", "0.0", "else", ":", "return", "C", "[", "\"c19\"", "]", "*", "(", "5.5", "-", "rup", ".", "mag", ")", "*", "rup", ".", "dip" ]

[ "Returns", "the", "fault", "dip", "term", "defined", "in", "equation", "24" ]

[ "def", "_get_anelastic_attenuation_term", "(", "self", ",", "C", ",", "rrup", ")", ":", "f_atn", "=", "np", ".", "zeros", "(", "len", "(", "rrup", ")", ")", "idx", "=", "rrup", ">=", "80.0", "f_atn", "[", "idx", "]", "=", "(", "C", "[", "\"c20\"", "]", "+", "C", "[", "\"Dc20\"", "]", ")", "*", "(", "rrup", "[", "idx", "]", "-", "80.0", ")", "return", "f_atn" ]

[ "Returns", "the", "anelastic", "attenuation", "term", "defined", "in", "equation", "25" ]

[ "def", "_select_basin_model", "(", "self", ",", "vs30", ")", ":", "if", "self", ".", "CONSTS", "[", "\"SJ\"", "]", ":", "# Japan Basin Model - Equation 34 of Campbell & Bozorgnia (2014)", "return", "np", ".", "exp", "(", "5.359", "-", "1.102", "*", "np", ".", "log", "(", "vs30", ")", ")", "else", ":", "# California Basin Model - Equation 33 of", "# Campbell & Bozorgnia (2014)", "return", "np", ".", "exp", "(", "7.089", "-", "1.144", "*", "np", ".", "log", "(", "vs30", ")", ")" ]

[ "Select", "the", "preferred", "basin", "model", "(", "California", "or", "Japan", ")", "to", "scale", "basin", "depth", "with", "respect", "to", "Vs30" ]

[ "def", "_get_basin_response_term", "(", "self", ",", "C", ",", "z2pt5", ")", ":", "f_sed", "=", "np", ".", "zeros", "(", "len", "(", "z2pt5", ")", ")", "idx", "=", "z2pt5", "<", "1.0", "f_sed", "[", "idx", "]", "=", "(", "C", "[", "\"c14\"", "]", "+", "C", "[", "\"c15\"", "]", "*", "float", "(", "self", ".", "CONSTS", "[", "\"SJ\"", "]", ")", ")", "*", "(", "z2pt5", "[", "idx", "]", "-", "1.0", ")", "idx", "=", "z2pt5", ">", "3.0", "f_sed", "[", "idx", "]", "=", "C", "[", "\"c16\"", "]", "*", "C", "[", "\"k3\"", "]", "*", "exp", "(", "-", "0.75", ")", "*", "(", "1.0", "-", "np", ".", "exp", "(", "-", "0.25", "*", "(", "z2pt5", "[", "idx", "]", "-", "3.0", ")", ")", ")", "return", "f_sed" ]

[ "Returns", "the", "basin", "response", "term", "defined", "in", "equation", "20" ]

[ "def", "_get_shallow_site_response_term", "(", "self", ",", "C", ",", "vs30", ",", "pga_rock", ")", ":", "vs_mod", "=", "vs30", "/", "C", "[", "\"k1\"", "]", "# Get linear global site response term", "f_site_g", "=", "C", "[", "\"c11\"", "]", "*", "np", ".", "log", "(", "vs_mod", ")", "idx", "=", "vs30", ">", "C", "[", "\"k1\"", "]", "f_site_g", "[", "idx", "]", "=", "f_site_g", "[", "idx", "]", "+", "(", "C", "[", "\"k2\"", "]", "*", "self", ".", "CONSTS", "[", "\"n\"", "]", "*", "np", ".", "log", "(", "vs_mod", "[", "idx", "]", ")", ")", "# Get nonlinear site response term", "idx", "=", "np", ".", "logical_not", "(", "idx", ")", "if", "np", ".", "any", "(", "idx", ")", ":", "f_site_g", "[", "idx", "]", "=", "f_site_g", "[", "idx", "]", "+", "C", "[", "\"k2\"", "]", "*", "(", "np", ".", "log", "(", "pga_rock", "[", "idx", "]", "+", "self", ".", "CONSTS", "[", "\"c\"", "]", "*", "(", "vs_mod", "[", "idx", "]", "**", "self", ".", "CONSTS", "[", "\"n\"", "]", ")", ")", "-", "np", ".", "log", "(", "pga_rock", "[", "idx", "]", "+", "self", ".", "CONSTS", "[", "\"c\"", "]", ")", ")", "# For Japan sites (SJ = 1) further scaling is needed (equation 19)", "if", "self", ".", "CONSTS", "[", "\"SJ\"", "]", ":", "fsite_j", "=", "np", ".", "log", "(", "vs_mod", ")", "idx", "=", "vs30", ">", "200.0", "if", "np", ".", "any", "(", "idx", ")", ":", "fsite_j", "[", "idx", "]", "=", "(", "C", "[", "\"c13\"", "]", "+", "C", "[", "\"k2\"", "]", "*", "self", ".", "CONSTS", "[", "\"n\"", "]", ")", "*", "fsite_j", "[", "idx", "]", "idx", "=", "np", ".", "logical_not", "(", "idx", ")", "if", "np", ".", "any", "(", "idx", ")", ":", "fsite_j", "[", "idx", "]", "=", "(", "C", "[", "\"c12\"", "]", "+", "C", "[", "\"k2\"", "]", "*", "self", ".", "CONSTS", "[", "\"n\"", "]", ")", "*", "(", "fsite_j", "[", "idx", "]", "-", "np", ".", "log", "(", "200.0", "/", "C", "[", "\"k1\"", "]", ")", ")", "return", "f_site_g", "+", "fsite_j", "else", ":", "return", "f_site_g" ]

[ "Returns", "the", "shallow", "site", "response", "term", "defined", "in", "equations", "17", "18", "and", "19" ]

[ "def", "_get_stddevs", "(", "self", ",", "C", ",", "C_PGA", ",", "rup", ",", "sites", ",", "pga1100", ",", "stddev_types", ")", ":", "# Get stddevs for PGA on basement rock", "tau_lnpga_b", ",", "phi_lnpga_b", "=", "self", ".", "_get_stddevs_pga", "(", "C_PGA", ",", "rup", ")", "num_sites", "=", "len", "(", "sites", ".", "vs30", ")", "# Get tau_lny on the basement rock", "tau_lnyb", "=", "self", ".", "_get_taulny", "(", "C", ",", "rup", ".", "mag", ")", "# Get phi_lny on the basement rock", "phi_lnyb", "=", "np", ".", "sqrt", "(", "self", ".", "_get_philny", "(", "C", ",", "rup", ".", "mag", ")", "**", "2.", "-", "self", ".", "CONSTS", "[", "\"philnAF\"", "]", "**", "2.", ")", "# Get site scaling term", "alpha", "=", "self", ".", "_get_alpha", "(", "C", ",", "sites", ".", "vs30", ",", "pga1100", ")", "# Evaluate tau according to equation 29", "tau", "=", "np", ".", "sqrt", "(", "(", "tau_lnyb", "**", "2.", ")", "+", "(", "(", "alpha", "**", "2.", ")", "*", "(", "tau_lnpga_b", "**", "2.", ")", ")", "+", "(", "2.0", "*", "alpha", "*", "C", "[", "\"rholny\"", "]", "*", "tau_lnyb", "*", "tau_lnpga_b", ")", ")", "# Evaluate phi according to equation 30", "phi", "=", "np", ".", "sqrt", "(", "(", "phi_lnyb", "**", "2.", ")", "+", "(", "self", ".", "CONSTS", "[", "\"philnAF\"", "]", "**", "2.", ")", "+", "(", "(", "alpha", "**", "2.", ")", "*", "(", "phi_lnpga_b", "**", "2.", ")", ")", "+", "(", "2.0", "*", "alpha", "*", "C", "[", "\"rholny\"", "]", "*", "phi_lnyb", "*", "phi_lnpga_b", ")", ")", "stddevs", "=", "[", "]", "for", "stddev_type", "in", "stddev_types", ":", "assert", "stddev_type", "in", "self", ".", "DEFINED_FOR_STANDARD_DEVIATION_TYPES", "if", "stddev_type", "==", "const", ".", "StdDev", ".", "TOTAL", ":", "stddevs", ".", "append", "(", "np", ".", "sqrt", "(", "(", "tau", "**", "2.", ")", "+", "(", "phi", "**", "2.", ")", ")", "+", "np", ".", "zeros", "(", "num_sites", ")", ")", "elif", "stddev_type", "==", "const", ".", "StdDev", ".", "INTRA_EVENT", ":", "stddevs", ".", "append", "(", "phi", "+", "np", ".", "zeros", "(", "num_sites", ")", ")", "elif", "stddev_type", "==", "const", ".", "StdDev", ".", "INTER_EVENT", ":", "stddevs", ".", "append", "(", "tau", "+", "np", ".", "zeros", "(", "num_sites", ")", ")", "return", "stddevs" ]

[ "Returns", "the", "inter", "-", "and", "intra", "-", "event", "and", "total", "standard", "deviations" ]

[ "def", "_get_stddevs_pga", "(", "self", ",", "C", ",", "rup", ")", ":", "tau_lnpga_b", "=", "self", ".", "_get_taulny", "(", "C", ",", "rup", ".", "mag", ")", "phi_lnpga_b", "=", "np", ".", "sqrt", "(", "self", ".", "_get_philny", "(", "C", ",", "rup", ".", "mag", ")", "**", "2.", "-", "self", ".", "CONSTS", "[", "\"philnAF\"", "]", "**", "2.", ")", "return", "tau_lnpga_b", ",", "phi_lnpga_b" ]

[ "Returns", "the", "inter", "-", "and", "intra", "-", "event", "coefficients", "for", "PGA" ]

[ "def", "_get_taulny", "(", "self", ",", "C", ",", "mag", ")", ":", "if", "mag", "<=", "4.5", ":", "return", "C", "[", "\"tau1\"", "]", "elif", "mag", ">=", "5.5", ":", "return", "C", "[", "\"tau2\"", "]", "else", ":", "return", "C", "[", "\"tau2\"", "]", "+", "(", "C", "[", "\"tau1\"", "]", "-", "C", "[", "\"tau2\"", "]", ")", "*", "(", "5.5", "-", "mag", ")" ]

[ "Returns", "the", "inter", "-", "event", "random", "effects", "coefficient", "(", "tau", ")", "Equation", "28", "." ]

[ "def", "_get_philny", "(", "self", ",", "C", ",", "mag", ")", ":", "if", "mag", "<=", "4.5", ":", "return", "C", "[", "\"phi1\"", "]", "elif", "mag", ">=", "5.5", ":", "return", "C", "[", "\"phi2\"", "]", "else", ":", "return", "C", "[", "\"phi2\"", "]", "+", "(", "C", "[", "\"phi1\"", "]", "-", "C", "[", "\"phi2\"", "]", ")", "*", "(", "5.5", "-", "mag", ")" ]

[ "Returns", "the", "intra", "-", "event", "random", "effects", "coefficient", "(", "phi", ")", "Equation", "28", "." ]

[ "def", "_get_alpha", "(", "self", ",", "C", ",", "vs30", ",", "pga_rock", ")", ":", "alpha", "=", "np", ".", "zeros", "(", "len", "(", "pga_rock", ")", ")", "idx", "=", "vs30", "<", "C", "[", "\"k1\"", "]", "if", "np", ".", "any", "(", "idx", ")", ":", "af1", "=", "pga_rock", "[", "idx", "]", "+", "self", ".", "CONSTS", "[", "\"c\"", "]", "*", "(", "(", "vs30", "[", "idx", "]", "/", "C", "[", "\"k1\"", "]", ")", "**", "self", ".", "CONSTS", "[", "\"n\"", "]", ")", "af2", "=", "pga_rock", "[", "idx", "]", "+", "self", ".", "CONSTS", "[", "\"c\"", "]", "alpha", "[", "idx", "]", "=", "C", "[", "\"k2\"", "]", "*", "pga_rock", "[", "idx", "]", "*", "(", "(", "1.0", "/", "af1", ")", "-", "(", "1.0", "/", "af2", ")", ")", "return", "alpha" ]

[ "Returns", "the", "alpha", "the", "linearised", "functional", "relationship", "between", "the", "site", "amplification", "and", "the", "PGA", "on", "rock", ".", "Equation", "31", "." ]

[ "def", "decimal_year", "(", "year", ",", "month", ",", "day", ")", ":", "marker", "=", "np", ".", "array", "(", "[", "0.", ",", "31.", ",", "59.", ",", "90.", ",", "120.", ",", "151.", ",", "181.", ",", "212.", ",", "243.", ",", "273.", ",", "304.", ",", "334.", "]", ")", "tmonth", "=", "(", "month", "-", "1", ")", ".", "astype", "(", "int", ")", "day_count", "=", "marker", "[", "tmonth", "]", "+", "day", "-", "1.", "dec_year", "=", "year", "+", "(", "day_count", "/", "365.", ")", "return", "dec_year" ]

[ "Allows", "to", "calculate", "the", "decimal", "year", "for", "a", "vector", "of", "dates", "(", "TODO", "this", "is", "legacy", "code", "kept", "to", "maintain", "comparability", "with", "previous", "declustering", "algorithms!", ")" ]

[ "def", "decimal_time", "(", "year", ",", "month", ",", "day", ",", "hour", ",", "minute", ",", "second", ")", ":", "tmo", "=", "np", ".", "ones_like", "(", "year", ",", "dtype", "=", "int", ")", "tda", "=", "np", ".", "ones_like", "(", "year", ",", "dtype", "=", "int", ")", "tho", "=", "np", ".", "zeros_like", "(", "year", ",", "dtype", "=", "int", ")", "tmi", "=", "np", ".", "zeros_like", "(", "year", ",", "dtype", "=", "int", ")", "tse", "=", "np", ".", "zeros_like", "(", "year", ",", "dtype", "=", "float", ")", "#", "# Checking inputs", "if", "any", "(", "month", "<", "1", ")", "or", "any", "(", "month", ">", "12", ")", ":", "raise", "ValueError", "(", "'Month must be in [1, 12]'", ")", "if", "any", "(", "day", "<", "1", ")", "or", "any", "(", "day", ">", "31", ")", ":", "raise", "ValueError", "(", "'Day must be in [1, 31]'", ")", "if", "any", "(", "hour", "<", "0", ")", "or", "any", "(", "hour", ">", "24", ")", ":", "raise", "ValueError", "(", "'Hour must be in [0, 24]'", ")", "if", "any", "(", "minute", "<", "0", ")", "or", "any", "(", "minute", ">", "60", ")", ":", "raise", "ValueError", "(", "'Minute must be in [0, 60]'", ")", "if", "any", "(", "second", "<", "0", ")", "or", "any", "(", "second", ">", "60", ")", ":", "raise", "ValueError", "(", "'Second must be in [0, 60]'", ")", "#", "# Initialising values", "if", "any", "(", "month", ")", ":", "tmo", "=", "month", "if", "any", "(", "day", ")", ":", "tda", "=", "day", "if", "any", "(", "hour", ")", ":", "tho", "=", "hour", "if", "any", "(", "minute", ")", ":", "tmi", "=", "minute", "if", "any", "(", "second", ")", ":", "tse", "=", "second", "#", "# Computing decimal", "tmonth", "=", "tmo", "-", "1", "day_count", "=", "MARKER_NORMAL", "[", "tmonth", "]", "+", "tda", "-", "1", "id_leap", "=", "leap_check", "(", "year", ")", "leap_loc", "=", "np", ".", "where", "(", "id_leap", ")", "[", "0", "]", "day_count", "[", "leap_loc", "]", "=", "MARKER_LEAP", "[", "tmonth", "[", "leap_loc", "]", "]", "+", "tda", "[", "leap_loc", "]", "-", "1", "year_secs", "=", "(", "(", "day_count", ".", "astype", "(", "float", ")", "*", "SECONDS_PER_DAY", ")", "+", "tse", "+", "(", "60.", "*", "tmi", ".", "astype", "(", "float", ")", ")", "+", "(", "3600.", "*", "tho", ".", "astype", "(", "float", ")", ")", ")", "dtime", "=", "year", ".", "astype", "(", "float", ")", "+", "(", "year_secs", "/", "(", "365.", "*", "24.", "*", "3600.", ")", ")", "dtime", "[", "leap_loc", "]", "=", "year", "[", "leap_loc", "]", ".", "astype", "(", "float", ")", "+", "(", "year_secs", "[", "leap_loc", "]", "/", "(", "366.", "*", "24.", "*", "3600.", ")", ")", "return", "dtime" ]

[ "Returns", "the", "full", "time", "as", "a", "decimal", "value" ]

[ "def", "haversine", "(", "lon1", ",", "lat1", ",", "lon2", ",", "lat2", ",", "radians", "=", "False", ",", "earth_rad", "=", "6371.227", ")", ":", "if", "not", "radians", ":", "cfact", "=", "np", ".", "pi", "/", "180.", "lon1", "=", "cfact", "*", "lon1", "lat1", "=", "cfact", "*", "lat1", "lon2", "=", "cfact", "*", "lon2", "lat2", "=", "cfact", "*", "lat2", "# Number of locations in each set of points", "if", "not", "np", ".", "shape", "(", "lon1", ")", ":", "nlocs1", "=", "1", "lon1", "=", "np", ".", "array", "(", "[", "lon1", "]", ")", "lat1", "=", "np", ".", "array", "(", "[", "lat1", "]", ")", "else", ":", "nlocs1", "=", "np", ".", "max", "(", "np", ".", "shape", "(", "lon1", ")", ")", "if", "not", "np", ".", "shape", "(", "lon2", ")", ":", "nlocs2", "=", "1", "lon2", "=", "np", ".", "array", "(", "[", "lon2", "]", ")", "lat2", "=", "np", ".", "array", "(", "[", "lat2", "]", ")", "else", ":", "nlocs2", "=", "np", ".", "max", "(", "np", ".", "shape", "(", "lon2", ")", ")", "# Pre-allocate array", "distance", "=", "np", ".", "zeros", "(", "(", "nlocs1", ",", "nlocs2", ")", ")", "i", "=", "0", "while", "i", "<", "nlocs2", ":", "# Perform distance calculation", "dlat", "=", "lat1", "-", "lat2", "[", "i", "]", "dlon", "=", "lon1", "-", "lon2", "[", "i", "]", "aval", "=", "(", "np", ".", "sin", "(", "dlat", "/", "2.", ")", "**", "2.", ")", "+", "(", "np", ".", "cos", "(", "lat1", ")", "*", "np", ".", "cos", "(", "lat2", "[", "i", "]", ")", "*", "(", "np", ".", "sin", "(", "dlon", "/", "2.", ")", "**", "2.", ")", ")", "distance", "[", ":", ",", "i", "]", "=", "(", "2.", "*", "earth_rad", "*", "np", ".", "arctan2", "(", "np", ".", "sqrt", "(", "aval", ")", ",", "np", ".", "sqrt", "(", "1", "-", "aval", ")", ")", ")", ".", "T", "i", "+=", "1", "return", "distance" ]

[ "Allows", "to", "calculate", "geographical", "distance", "using", "the", "haversine", "formula", "." ]

[ "def", "greg2julian", "(", "year", ",", "month", ",", "day", ",", "hour", ",", "minute", ",", "second", ")", ":", "year", "=", "year", ".", "astype", "(", "float", ")", "month", "=", "month", ".", "astype", "(", "float", ")", "day", "=", "day", ".", "astype", "(", "float", ")", "timeut", "=", "hour", ".", "astype", "(", "float", ")", "+", "(", "minute", ".", "astype", "(", "float", ")", "/", "60.0", ")", "+", "(", "second", "/", "3600.0", ")", "julian_time", "=", "(", "(", "367.0", "*", "year", ")", "-", "np", ".", "floor", "(", "7.0", "*", "(", "year", "+", "np", ".", "floor", "(", "(", "month", "+", "9.0", ")", "/", "12.0", ")", ")", "/", "4.0", ")", "-", "np", ".", "floor", "(", "3.0", "*", "(", "np", ".", "floor", "(", "(", "year", "+", "(", "month", "-", "9.0", ")", "/", "7.0", ")", "/", "100.0", ")", "+", "1.0", ")", "/", "4.0", ")", "+", "np", ".", "floor", "(", "(", "275.0", "*", "month", ")", "/", "9.0", ")", "+", "day", "+", "1721028.5", "+", "(", "timeut", "/", "24.0", ")", ")", "return", "julian_time" ]

[ "Function", "to", "convert", "a", "date", "from", "Gregorian", "to", "Julian", "format" ]

[ "def", "piecewise_linear_scalar", "(", "params", ",", "xval", ")", ":", "n_params", "=", "len", "(", "params", ")", "n_seg", ",", "remainder", "=", "divmod", "(", "n_params", ",", "2", ")", "if", "remainder", ":", "raise", "ValueError", "(", "'Piecewise Function requires 2 * nsegments parameters'", ")", "if", "n_seg", "==", "1", ":", "return", "params", "[", "1", "]", "+", "params", "[", "0", "]", "*", "xval", "gradients", "=", "params", "[", "0", ":", "n_seg", "]", "turning_points", "=", "params", "[", "n_seg", ":", "-", "1", "]", "c_val", "=", "np", ".", "array", "(", "[", "params", "[", "-", "1", "]", "]", ")", "for", "iloc", "in", "range", "(", "1", ",", "n_seg", ")", ":", "c_val", "=", "np", ".", "hstack", "(", "[", "c_val", ",", "(", "c_val", "[", "iloc", "-", "1", "]", "+", "gradients", "[", "iloc", "-", "1", "]", "*", "turning_points", "[", "iloc", "-", "1", "]", ")", "-", "(", "gradients", "[", "iloc", "]", "*", "turning_points", "[", "iloc", "-", "1", "]", ")", "]", ")", "if", "xval", "<=", "turning_points", "[", "0", "]", ":", "return", "gradients", "[", "0", "]", "*", "xval", "+", "c_val", "[", "0", "]", "elif", "xval", ">", "turning_points", "[", "-", "1", "]", ":", "return", "gradients", "[", "-", "1", "]", "*", "xval", "+", "c_val", "[", "-", "1", "]", "else", ":", "select", "=", "np", ".", "nonzero", "(", "turning_points", "<=", "xval", ")", "[", "0", "]", "[", "-", "1", "]", "+", "1", "return", "gradients", "[", "select", "]", "*", "xval", "+", "c_val", "[", "select", "]" ]

[ "Piecewise", "linear", "function", "for", "a", "scalar", "variable", "xval", "(", "float", ")", "." ]

[ "def", "sample_truncated_gaussian_vector", "(", "data", ",", "uncertainties", ",", "bounds", "=", "None", ")", ":", "nvals", "=", "len", "(", "data", ")", "if", "bounds", ":", "# if bounds[0] or (fabs(bounds[0]) < PRECISION):", "if", "bounds", "[", "0", "]", "is", "not", "None", ":", "lower_bound", "=", "(", "bounds", "[", "0", "]", "-", "data", ")", "/", "uncertainties", "else", ":", "lower_bound", "=", "-", "np", ".", "inf", "*", "np", ".", "ones_like", "(", "data", ")", "# if bounds[1] or (fabs(bounds[1]) < PRECISION):", "if", "bounds", "[", "1", "]", "is", "not", "None", ":", "upper_bound", "=", "(", "bounds", "[", "1", "]", "-", "data", ")", "/", "uncertainties", "else", ":", "upper_bound", "=", "np", ".", "inf", "*", "np", ".", "ones_like", "(", "data", ")", "sample", "=", "hmtk_truncnorm", ".", "rvs", "(", "lower_bound", ",", "upper_bound", ",", "size", "=", "nvals", ")", "else", ":", "sample", "=", "np", ".", "random", ".", "normal", "(", "0.", ",", "1.", ",", "nvals", ")", "return", "data", "+", "uncertainties", "*", "sample" ]

[ "Samples", "a", "Gaussian", "distribution", "subject", "to", "boundaries", "on", "the", "data" ]

[ "def", "hmtk_histogram_1D", "(", "values", ",", "intervals", ",", "offset", "=", "1.0E-10", ")", ":", "nbins", "=", "len", "(", "intervals", ")", "-", "1", "counter", "=", "np", ".", "zeros", "(", "nbins", ",", "dtype", "=", "float", ")", "x_ints", "=", "intervals", "-", "offset", "for", "i", "in", "range", "(", "nbins", ")", ":", "idx", "=", "np", ".", "logical_and", "(", "values", ">=", "x_ints", "[", "i", "]", ",", "values", "<", "x_ints", "[", "i", "+", "1", "]", ")", "counter", "[", "i", "]", "+=", "float", "(", "np", ".", "sum", "(", "idx", ")", ")", "return", "counter" ]

[ "So", "here", "s", "the", "problem", ".", "We", "tend", "to", "refer", "to", "certain", "data", "(", "like", "magnitudes", ")", "rounded", "to", "the", "nearest", "0", ".", "1", "(", "or", "similar", "i", ".", "e", ".", "4", ".", "1", "5", ".", "7", "8", ".", "3", "etc", ".", ")", ".", "We", "also", "like", "our", "tables", "to", "fall", "on", "on", "the", "same", "interval", "i", ".", "e", ".", "3", ".", "1", "3", ".", "2", "3", ".", "3", "etc", ".", "We", "usually", "assume", "that", "the", "counter", "should", "correspond", "to", "the", "low", "edge", "i", ".", "e", ".", "3", ".", "1", "is", "in", "the", "group", "3", ".", "1", "to", "3", ".", "2", "(", "i", ".", "e", ".", "L", "<", "=", "M", "<", "U", ")", ".", "Floating", "point", "precision", "can", "be", "a", "bitch!", "Because", "when", "we", "read", "in", "magnitudes", "from", "files", "3", ".", "1", "might", "be", "represented", "as", "3", ".", "0999999999", "or", "as", "3", ".", "1000000000001", "and", "this", "is", "seemingly", "random", ".", "Similarly", "if", "np", ".", "arange", "()", "is", "used", "to", "generate", "the", "bin", "intervals", "then", "we", "see", "similar", "floating", "point", "problems", "emerging", ".", "As", "we", "are", "frequently", "encountering", "density", "plots", "with", "empty", "rows", "or", "columns", "where", "data", "should", "be", "but", "isn", "t", "because", "it", "has", "been", "assigned", "to", "the", "wrong", "group", "." ]

[ "def", "hmtk_histogram_2D", "(", "xvalues", ",", "yvalues", ",", "bins", ",", "x_offset", "=", "1.0E-10", ",", "y_offset", "=", "1.0E-10", ")", ":", "xbins", ",", "ybins", "=", "(", "bins", "[", "0", "]", "-", "x_offset", ",", "bins", "[", "1", "]", "-", "y_offset", ")", "n_x", "=", "len", "(", "xbins", ")", "-", "1", "n_y", "=", "len", "(", "ybins", ")", "-", "1", "counter", "=", "np", ".", "zeros", "(", "[", "n_y", ",", "n_x", "]", ",", "dtype", "=", "float", ")", "for", "j", "in", "range", "(", "n_y", ")", ":", "y_idx", "=", "np", ".", "logical_and", "(", "yvalues", ">=", "ybins", "[", "j", "]", ",", "yvalues", "<", "ybins", "[", "j", "+", "1", "]", ")", "x_vals", "=", "xvalues", "[", "y_idx", "]", "for", "i", "in", "range", "(", "n_x", ")", ":", "idx", "=", "np", ".", "logical_and", "(", "x_vals", ">=", "xbins", "[", "i", "]", ",", "x_vals", "<", "xbins", "[", "i", "+", "1", "]", ")", "counter", "[", "j", ",", "i", "]", "+=", "float", "(", "np", ".", "sum", "(", "idx", ")", ")", "return", "counter", ".", "T" ]

[ "See", "the", "explanation", "for", "the", "1D", "case", "-", "now", "applied", "to", "2D", "." ]

[ "def", "bootstrap_histogram_1D", "(", "values", ",", "intervals", ",", "uncertainties", "=", "None", ",", "normalisation", "=", "False", ",", "number_bootstraps", "=", "None", ",", "boundaries", "=", "None", ")", ":", "if", "not", "number_bootstraps", "or", "np", ".", "all", "(", "np", ".", "fabs", "(", "uncertainties", "<", "PRECISION", ")", ")", ":", "# No bootstraps or all uncertaintes are zero - return ordinary", "# histogram", "#output = np.histogram(values, intervals)[0]", "output", "=", "hmtk_histogram_1D", "(", "values", ",", "intervals", ")", "if", "normalisation", ":", "output", "=", "output", "/", "float", "(", "np", ".", "sum", "(", "output", ")", ")", "else", ":", "output", "=", "output", "return", "output", "else", ":", "temp_hist", "=", "np", ".", "zeros", "(", "[", "len", "(", "intervals", ")", "-", "1", ",", "number_bootstraps", "]", ",", "dtype", "=", "float", ")", "for", "iloc", "in", "range", "(", "0", ",", "number_bootstraps", ")", ":", "sample", "=", "sample_truncated_gaussian_vector", "(", "values", ",", "uncertainties", ",", "boundaries", ")", "#output = np.histogram(sample, intervals)[0]", "output", "=", "hmtk_histogram_1D", "(", "sample", ",", "intervals", ")", "temp_hist", "[", ":", ",", "iloc", "]", "=", "output", "output", "=", "np", ".", "sum", "(", "temp_hist", ",", "axis", "=", "1", ")", "if", "normalisation", ":", "output", "=", "output", "/", "float", "(", "np", ".", "sum", "(", "output", ")", ")", "else", ":", "output", "=", "output", "/", "float", "(", "number_bootstraps", ")", "return", "output" ]

[ "Bootstrap", "samples", "a", "set", "of", "vectors" ]

[ "def", "bootstrap_histogram_2D", "(", "xvalues", ",", "yvalues", ",", "xbins", ",", "ybins", ",", "boundaries", "=", "[", "None", ",", "None", "]", ",", "xsigma", "=", "None", ",", "ysigma", "=", "None", ",", "normalisation", "=", "False", ",", "number_bootstraps", "=", "None", ")", ":", "if", "(", "xsigma", "is", "None", "and", "ysigma", "is", "None", ")", "or", "not", "number_bootstraps", ":", "# No sampling - return simple 2-D histrogram", "#output = np.histogram2d(xvalues, yvalues, bins=[xbins, ybins])[0]", "output", "=", "hmtk_histogram_2D", "(", "xvalues", ",", "yvalues", ",", "bins", "=", "(", "xbins", ",", "ybins", ")", ")", "if", "normalisation", ":", "output", "=", "output", "/", "float", "(", "np", ".", "sum", "(", "output", ")", ")", "return", "output", "else", ":", "if", "xsigma", "is", "None", ":", "xsigma", "=", "np", ".", "zeros", "(", "len", "(", "xvalues", ")", ",", "dtype", "=", "float", ")", "if", "ysigma", "is", "None", ":", "ysigma", "=", "np", ".", "zeros", "(", "len", "(", "yvalues", ")", ",", "dtype", "=", "float", ")", "temp_hist", "=", "np", ".", "zeros", "(", "[", "len", "(", "xbins", ")", "-", "1", ",", "len", "(", "ybins", ")", "-", "1", ",", "number_bootstraps", "]", ",", "dtype", "=", "float", ")", "for", "iloc", "in", "range", "(", "0", ",", "number_bootstraps", ")", ":", "xsample", "=", "sample_truncated_gaussian_vector", "(", "xvalues", ",", "xsigma", ",", "boundaries", "[", "0", "]", ")", "ysample", "=", "sample_truncated_gaussian_vector", "(", "yvalues", ",", "ysigma", ",", "boundaries", "[", "0", "]", ")", "# temp_hist[:, :, iloc] = np.histogram2d(xsample,", "# ysample,", "# bins=[xbins, ybins])[0]", "temp_hist", "[", ":", ",", ":", ",", "iloc", "]", "=", "hmtk_histogram_2D", "(", "xsample", ",", "ysample", ",", "bins", "=", "(", "xbins", ",", "ybins", ")", ")", "if", "normalisation", ":", "output", "=", "np", ".", "sum", "(", "temp_hist", ",", "axis", "=", "2", ")", "output", "=", "output", "/", "np", ".", "sum", "(", "output", ")", "else", ":", "output", "=", "np", ".", "sum", "(", "temp_hist", ",", "axis", "=", "2", ")", "/", "float", "(", "number_bootstraps", ")", "return", "output" ]

[ "Calculates", "a", "2D", "histogram", "of", "data", "allowing", "for", "normalisation", "and", "bootstrap", "sampling" ]

[ "def", "lonlat_to_laea", "(", "lon", ",", "lat", ",", "lon0", ",", "lat0", ",", "f_e", "=", "0.0", ",", "f_n", "=", "0.0", ")", ":", "lon", "=", "np", ".", "radians", "(", "lon", ")", "lat", "=", "np", ".", "radians", "(", "lat", ")", "lon0", "=", "np", ".", "radians", "(", "lon0", ")", "lat0", "=", "np", ".", "radians", "(", "lat0", ")", "q_0", "=", "TO_Q", "(", "lat0", ")", "q_p", "=", "TO_Q", "(", "np", ".", "pi", "/", "2.", ")", "q_val", "=", "TO_Q", "(", "lat", ")", "beta", "=", "np", ".", "arcsin", "(", "q_val", "/", "q_p", ")", "beta0", "=", "np", ".", "arcsin", "(", "q_0", "/", "q_p", ")", "r_q", "=", "WGS84", "[", "\"a\"", "]", "*", "np", ".", "sqrt", "(", "q_p", "/", "2.", ")", "dval", "=", "WGS84", "[", "\"a\"", "]", "*", "(", "np", ".", "cos", "(", "lat0", ")", "/", "np", ".", "sqrt", "(", "1.0", "-", "(", "WGS84", "[", "\"e2\"", "]", "*", "(", "np", ".", "sin", "(", "lat0", ")", "**", "2.", ")", ")", ")", "/", "(", "r_q", "*", "np", ".", "cos", "(", "beta0", ")", ")", ")", "bval", "=", "r_q", "*", "np", ".", "sqrt", "(", "2.", "/", "(", "1.0", "+", "(", "np", ".", "sin", "(", "beta0", ")", "*", "np", ".", "sin", "(", "beta", ")", ")", "+", "(", "np", ".", "cos", "(", "beta", ")", "*", "np", ".", "cos", "(", "beta0", ")", "*", "np", ".", "cos", "(", "lon", "-", "lon0", ")", ")", ")", ")", "easting", "=", "f_e", "+", "(", "(", "bval", "*", "dval", ")", "*", "(", "np", ".", "cos", "(", "beta", ")", "*", "np", ".", "sin", "(", "lon", "-", "lon0", ")", ")", ")", "northing", "=", "f_n", "+", "(", "bval", "/", "dval", ")", "*", "(", "(", "np", ".", "cos", "(", "beta0", ")", "*", "np", ".", "sin", "(", "beta", ")", ")", "-", "(", "np", ".", "sin", "(", "beta0", ")", "*", "np", ".", "cos", "(", "beta", ")", "*", "np", ".", "cos", "(", "lon", "-", "lon0", ")", ")", ")", "return", "easting", ",", "northing" ]

[ "Converts", "vectors", "of", "longitude", "and", "latitude", "into", "Lambert", "Azimuthal", "Equal", "Area", "projection", "(", "km", ")", "with", "respect", "to", "an", "origin", "point" ]

[ "def", "area_of_polygon", "(", "polygon", ")", ":", "lon0", "=", "np", ".", "mean", "(", "polygon", ".", "lons", ")", "lat0", "=", "np", ".", "mean", "(", "polygon", ".", "lats", ")", "# Transform to lamber equal area projection", "x", ",", "y", "=", "lonlat_to_laea", "(", "polygon", ".", "lons", ",", "polygon", ".", "lats", ",", "lon0", ",", "lat0", ")", "# Build shapely polygons", "poly", "=", "geometry", ".", "Polygon", "(", "zip", "(", "x", ",", "y", ")", ")", "return", "poly", ".", "area" ]

[ "Returns", "the", "area", "of", "an", "OpenQuake", "polygon", "in", "square", "kilometres" ]

[ "def", "input_dir", "(", "self", ")", ":", "return", "os", ".", "path", ".", "abspath", "(", "os", ".", "path", ".", "dirname", "(", "self", ".", "inputs", "[", "'job_ini'", "]", ")", ")" ]

[ ":", "returns", ":", "absolute", "path", "to", "where", "the", "job", ".", "ini", "is" ]

[ "def", "get_reqv", "(", "self", ")", ":", "if", "'reqv'", "not", "in", "self", ".", "inputs", ":", "return", "return", "{", "key", ":", "valid", ".", "RjbEquivalent", "(", "value", ")", "for", "key", ",", "value", "in", "self", ".", "inputs", "[", "'reqv'", "]", ".", "items", "(", ")", "}" ]

[ ":", "returns", ":", "an", "instance", "of", "class", ":", "RjbEquivalent", "if", "reqv_hdf5", "is", "set" ]

[ "def", "check_gsims", "(", "self", ",", "gsims", ")", ":", "imts", "=", "set", "(", "from_string", "(", "imt", ")", ".", "name", "for", "imt", "in", "self", ".", "imtls", ")", "for", "gsim", "in", "gsims", ":", "restrict_imts", "=", "gsim", ".", "DEFINED_FOR_INTENSITY_MEASURE_TYPES", "if", "restrict_imts", ":", "names", "=", "set", "(", "cls", ".", "__name__", "for", "cls", "in", "restrict_imts", ")", "invalid_imts", "=", "', '", ".", "join", "(", "imts", "-", "names", ")", "if", "invalid_imts", ":", "raise", "ValueError", "(", "'The IMT %s is not accepted by the GSIM %s'", "%", "(", "invalid_imts", ",", "gsim", ")", ")", "if", "'site_model'", "not", "in", "self", ".", "inputs", ":", "# look at the required sites parameters: they must have", "# a valid value; the other parameters can keep a NaN", "# value since they are not used by the calculator", "for", "param", "in", "gsim", ".", "REQUIRES_SITES_PARAMETERS", ":", "if", "param", "in", "(", "'lon'", ",", "'lat'", ")", ":", "# no check", "continue", "param_name", "=", "self", ".", "siteparam", "[", "param", "]", "param_value", "=", "getattr", "(", "self", ",", "param_name", ")", "if", "(", "isinstance", "(", "param_value", ",", "float", ")", "and", "numpy", ".", "isnan", "(", "param_value", ")", ")", ":", "raise", "ValueError", "(", "'Please set a value for %r, this is required by '", "'the GSIM %s'", "%", "(", "param_name", ",", "gsim", ")", ")" ]

[ ":", "param", "gsims", ":", "a", "sequence", "of", "GSIM", "instances" ]

[ "def", "ses_ratio", "(", "self", ")", ":", "if", "self", ".", "investigation_time", "is", "None", ":", "raise", "ValueError", "(", "'Missing investigation_time in the .ini file'", ")", "return", "(", "self", ".", "risk_investigation_time", "or", "self", ".", "investigation_time", ")", "/", "(", "self", ".", "investigation_time", "*", "self", ".", "ses_per_logic_tree_path", ")" ]

[ "The", "ratio" ]

[ "def", "all_cost_types", "(", "self", ")", ":", "# rt has the form 'vulnerability/structural', 'fragility/...', ...", "costtypes", "=", "sorted", "(", "rt", ".", "rsplit", "(", "'/'", ")", "[", "1", "]", "for", "rt", "in", "self", ".", "risk_files", ")", "if", "not", "costtypes", "and", "self", ".", "hazard_calculation_id", ":", "with", "util", ".", "read", "(", "self", ".", "hazard_calculation_id", ")", "as", "ds", ":", "parent", "=", "ds", "[", "'oqparam'", "]", "self", ".", "_risk_files", "=", "get_risk_files", "(", "parent", ".", "inputs", ")", "costtypes", "=", "sorted", "(", "rt", ".", "rsplit", "(", "'/'", ")", "[", "1", "]", "for", "rt", "in", "self", ".", "risk_files", ")", "return", "costtypes" ]

[ "Return", "the", "cost", "types", "of", "the", "computation", "(", "including", "occupants", "if", "it", "is", "there", ")", "in", "order", "." ]

[ "def", "min_iml", "(", "self", ")", ":", "mini", "=", "self", ".", "minimum_intensity", "if", "mini", ":", "for", "imt", "in", "self", ".", "imtls", ":", "try", ":", "mini", "[", "imt", "]", "=", "calc", ".", "filters", ".", "getdefault", "(", "mini", ",", "imt", ")", "except", "KeyError", ":", "raise", "ValueError", "(", "'The parameter `minimum_intensity` in the job.ini '", "'file is missing the IMT %r'", "%", "imt", ")", "if", "'default'", "in", "mini", ":", "del", "mini", "[", "'default'", "]", "return", "F32", "(", "[", "mini", ".", "get", "(", "imt", ",", "0", ")", "for", "imt", "in", "self", ".", "imtls", "]", ")" ]

[ ":", "returns", ":", "a", "numpy", "array", "of", "intensities", "one", "per", "IMT" ]

[ "def", "set_risk_imtls", "(", "self", ",", "risk_models", ")", ":", "# NB: different loss types may have different IMLs for the same IMT", "# in that case we merge the IMLs", "imtls", "=", "{", "}", "for", "taxonomy", ",", "risk_functions", "in", "risk_models", ".", "items", "(", ")", ":", "for", "risk_type", ",", "rf", "in", "risk_functions", ".", "items", "(", ")", ":", "imt", "=", "rf", ".", "imt", "from_string", "(", "imt", ")", "# make sure it is a valid IMT", "imls", "=", "list", "(", "rf", ".", "imls", ")", "if", "imt", "in", "imtls", "and", "imtls", "[", "imt", "]", "!=", "imls", ":", "logging", ".", "debug", "(", "'Different levels for IMT %s: got %s, expected %s'", ",", "imt", ",", "imls", ",", "imtls", "[", "imt", "]", ")", "imtls", "[", "imt", "]", "=", "sorted", "(", "set", "(", "imls", "+", "imtls", "[", "imt", "]", ")", ")", "else", ":", "imtls", "[", "imt", "]", "=", "imls", "self", ".", "risk_imtls", "=", "imtls", "if", "self", ".", "uniform_hazard_spectra", ":", "self", ".", "check_uniform_hazard_spectra", "(", ")" ]

[ ":", "param", "risk_models", ":", "a", "dictionary", "taxonomy", "-", ">", "loss_type", "-", ">", "risk_function" ]