Datasets:

unum-cloud

/

ann-codesearch-4m

like 0

Follow

Unum 28

[ "def", "_compute_anelastic_attenuation_term", "(", "self", ",", "C", ",", "rrup", ",", "mag", ")", ":", "r", "=", "(", "rrup", "**", "2.", "+", "(", "C", "[", "'c5'", "]", "*", "np", ".", "exp", "(", "C", "[", "'c6'", "]", "*", "mag", "+", "C", "[", "'c7'", "]", "*", "(", "8.5", "-", "mag", ")", "**", "2.5", ")", ")", "**", "2.", ")", "**", ".5", "f3", "=", "(", "(", "C", "[", "'c4'", "]", "+", "C", "[", "'c13'", "]", "*", "mag", ")", "*", "np", ".", "log", "(", "r", ")", "+", "(", "C", "[", "'c8'", "]", "+", "C", "[", "'c12'", "]", "*", "mag", ")", "*", "r", ")", "return", "f3" ]

[ "Compute", "magnitude", "-", "distance", "scaling", "term", "as", "defined", "in", "equation", "21", "page", "2291", "(", "Tavakoli", "and", "Pezeshk", "2005", ")" ]

[ "def", "edge_node", "(", "name", ",", "points", ")", ":", "line", "=", "[", "]", "for", "point", "in", "points", ":", "line", ".", "append", "(", "point", ".", "longitude", ")", "line", ".", "append", "(", "point", ".", "latitude", ")", "line", ".", "append", "(", "point", ".", "depth", ")", "pos", "=", "Node", "(", "'gml:posList'", ",", "{", "}", ",", "line", ")", "node", "=", "Node", "(", "name", ",", "nodes", "=", "[", "Node", "(", "'gml:LineString'", ",", "nodes", "=", "[", "pos", "]", ")", "]", ")", "return", "node" ]

[ ":", "param", "name", ":", "faultTopEdge", "intermediateEdge", "or", "faultBottomEdge", ":", "param", "points", ":", "a", "list", "of", "Point", "objects", ":", "returns", ":", "a", "Node", "of", "kind", "faultTopEdge", "intermediateEdge", "or", "faultBottomEdge" ]

[ "def", "complex_fault_node", "(", "edges", ")", ":", "node", "=", "Node", "(", "'complexFaultGeometry'", ")", "node", ".", "append", "(", "edge_node", "(", "'faultTopEdge'", ",", "edges", "[", "0", "]", ")", ")", "for", "edge", "in", "edges", "[", "1", ":", "-", "1", "]", ":", "node", ".", "append", "(", "edge_node", "(", "'intermediateEdge'", ",", "edge", ")", ")", "node", ".", "append", "(", "edge_node", "(", "'faultBottomEdge'", ",", "edges", "[", "-", "1", "]", ")", ")", "return", "node" ]

[ ":", "param", "edges", ":", "a", "list", "of", "lists", "of", "points", ":", "returns", ":", "a", "Node", "of", "kind", "complexFaultGeometry" ]

[ "def", "get_dip", "(", "self", ")", ":", "# uses the same approach as in simple fault surface", "if", "self", ".", "dip", "is", "None", ":", "mesh", "=", "self", ".", "mesh", "self", ".", "dip", ",", "self", ".", "strike", "=", "mesh", ".", "get_mean_inclination_and_azimuth", "(", ")", "return", "self", ".", "dip" ]

[ "Return", "the", "fault", "dip", "as", "the", "average", "dip", "over", "the", "mesh", "." ]

[ "def", "check_aki_richards_convention", "(", "cls", ",", "edges", ")", ":", "# 1) extract 4 corner points of surface mesh", "# 2) compute cross products between left and right edges and top edge", "# (these define vectors normal to the surface)", "# 3) compute dot products between cross product results and", "# position vectors associated with upper left and right corners (if", "# both angles are less then 90 degrees then the surface is correctly", "# defined)", "ul", "=", "edges", "[", "0", "]", ".", "points", "[", "0", "]", "ur", "=", "edges", "[", "0", "]", ".", "points", "[", "-", "1", "]", "bl", "=", "edges", "[", "-", "1", "]", ".", "points", "[", "0", "]", "br", "=", "edges", "[", "-", "1", "]", ".", "points", "[", "-", "1", "]", "ul", ",", "ur", ",", "bl", ",", "br", "=", "spherical_to_cartesian", "(", "[", "ul", ".", "longitude", ",", "ur", ".", "longitude", ",", "bl", ".", "longitude", ",", "br", ".", "longitude", "]", ",", "[", "ul", ".", "latitude", ",", "ur", ".", "latitude", ",", "bl", ".", "latitude", ",", "br", ".", "latitude", "]", ",", "[", "ul", ".", "depth", ",", "ur", ".", "depth", ",", "bl", ".", "depth", ",", "br", ".", "depth", "]", ",", ")", "top_edge", "=", "ur", "-", "ul", "left_edge", "=", "bl", "-", "ul", "right_edge", "=", "br", "-", "ur", "left_cross_top", "=", "numpy", ".", "cross", "(", "left_edge", ",", "top_edge", ")", "right_cross_top", "=", "numpy", ".", "cross", "(", "right_edge", ",", "top_edge", ")", "left_cross_top", "/=", "numpy", ".", "sqrt", "(", "numpy", ".", "dot", "(", "left_cross_top", ",", "left_cross_top", ")", ")", "right_cross_top", "/=", "numpy", ".", "sqrt", "(", "numpy", ".", "dot", "(", "right_cross_top", ",", "right_cross_top", ")", ")", "ul", "/=", "numpy", ".", "sqrt", "(", "numpy", ".", "dot", "(", "ul", ",", "ul", ")", ")", "ur", "/=", "numpy", ".", "sqrt", "(", "numpy", ".", "dot", "(", "ur", ",", "ur", ")", ")", "# rounding to 1st digit, to avoid ValueError raised for floating point", "# imprecision", "angle_ul", "=", "round", "(", "numpy", ".", "degrees", "(", "numpy", ".", "arccos", "(", "numpy", ".", "dot", "(", "ul", ",", "left_cross_top", ")", ")", ")", ",", "1", ")", "angle_ur", "=", "round", "(", "numpy", ".", "degrees", "(", "numpy", ".", "arccos", "(", "numpy", ".", "dot", "(", "ur", ",", "right_cross_top", ")", ")", ")", ",", "1", ")", "if", "(", "angle_ul", ">", "90", ")", "or", "(", "angle_ur", ">", "90", ")", ":", "raise", "ValueError", "(", "\"Surface does not conform with Aki & Richards convention\"", ")" ]

[ "Verify", "that", "surface", "(", "as", "defined", "by", "corner", "points", ")", "conforms", "with", "Aki", "and", "Richard", "convention", "(", "i", ".", "e", ".", "surface", "dips", "right", "of", "surface", "strike", ")" ]

[ "def", "check_surface_validity", "(", "cls", ",", "edges", ")", ":", "# extract coordinates of surface boundary (as defined from edges)", "full_boundary", "=", "[", "]", "left_boundary", "=", "[", "]", "right_boundary", "=", "[", "]", "for", "i", "in", "range", "(", "1", ",", "len", "(", "edges", ")", "-", "1", ")", ":", "left_boundary", ".", "append", "(", "edges", "[", "i", "]", ".", "points", "[", "0", "]", ")", "right_boundary", ".", "append", "(", "edges", "[", "i", "]", ".", "points", "[", "-", "1", "]", ")", "full_boundary", ".", "extend", "(", "edges", "[", "0", "]", ".", "points", ")", "full_boundary", ".", "extend", "(", "right_boundary", ")", "full_boundary", ".", "extend", "(", "edges", "[", "-", "1", "]", ".", "points", "[", ":", ":", "-", "1", "]", ")", "full_boundary", ".", "extend", "(", "left_boundary", "[", ":", ":", "-", "1", "]", ")", "lons", "=", "[", "p", ".", "longitude", "for", "p", "in", "full_boundary", "]", "lats", "=", "[", "p", ".", "latitude", "for", "p", "in", "full_boundary", "]", "depths", "=", "[", "p", ".", "depth", "for", "p", "in", "full_boundary", "]", "# define reference plane. Corner points are separated by an arbitrary", "# distance of 10 km. The mesh spacing is set to 2 km. Both corner", "# distance and mesh spacing values do not affect the algorithm results.", "ul", "=", "edges", "[", "0", "]", ".", "points", "[", "0", "]", "strike", "=", "ul", ".", "azimuth", "(", "edges", "[", "0", "]", ".", "points", "[", "-", "1", "]", ")", "dist", "=", "10.", "ur", "=", "ul", ".", "point_at", "(", "dist", ",", "0", ",", "strike", ")", "bl", "=", "Point", "(", "ul", ".", "longitude", ",", "ul", ".", "latitude", ",", "ul", ".", "depth", "+", "dist", ")", "br", "=", "bl", ".", "point_at", "(", "dist", ",", "0", ",", "strike", ")", "# project surface boundary to reference plane and check for", "# validity.", "ref_plane", "=", "PlanarSurface", ".", "from_corner_points", "(", "ul", ",", "ur", ",", "br", ",", "bl", ")", "_", ",", "xx", ",", "yy", "=", "ref_plane", ".", "_project", "(", "spherical_to_cartesian", "(", "lons", ",", "lats", ",", "depths", ")", ")", "coords", "=", "[", "(", "x", ",", "y", ")", "for", "x", ",", "y", "in", "zip", "(", "xx", ",", "yy", ")", "]", "p", "=", "shapely", ".", "geometry", ".", "Polygon", "(", "coords", ")", "if", "not", "p", ".", "is_valid", ":", "raise", "ValueError", "(", "'Edges points are not in the right order'", ")" ]

[ "Check", "validity", "of", "the", "surface", "." ]

[ "def", "check_fault_data", "(", "cls", ",", "edges", ",", "mesh_spacing", ")", ":", "if", "not", "len", "(", "edges", ")", ">=", "2", ":", "raise", "ValueError", "(", "\"at least two edges are required\"", ")", "if", "not", "all", "(", "len", "(", "edge", ")", ">=", "2", "for", "edge", "in", "edges", ")", ":", "raise", "ValueError", "(", "\"at least two points must be defined \"", "\"in each edge\"", ")", "if", "not", "mesh_spacing", ">", "0.0", ":", "raise", "ValueError", "(", "\"mesh spacing must be positive\"", ")", "cls", ".", "check_surface_validity", "(", "edges", ")", "cls", ".", "check_aki_richards_convention", "(", "edges", ")" ]

[ "Verify", "the", "fault", "data", "and", "raise", "ValueError", "if", "anything", "is", "wrong", "." ]

[ "def", "from_fault_data", "(", "cls", ",", "edges", ",", "mesh_spacing", ")", ":", "cls", ".", "check_fault_data", "(", "edges", ",", "mesh_spacing", ")", "surface_nodes", "=", "[", "complex_fault_node", "(", "edges", ")", "]", "mean_length", "=", "numpy", ".", "mean", "(", "[", "edge", ".", "get_length", "(", ")", "for", "edge", "in", "edges", "]", ")", "num_hor_points", "=", "int", "(", "round", "(", "mean_length", "/", "mesh_spacing", ")", ")", "+", "1", "if", "num_hor_points", "<=", "1", ":", "raise", "ValueError", "(", "'mesh spacing %.1f km is too big for mean length %.1f km'", "%", "(", "mesh_spacing", ",", "mean_length", ")", ")", "edges", "=", "[", "edge", ".", "resample_to_num_points", "(", "num_hor_points", ")", ".", "points", "for", "i", ",", "edge", "in", "enumerate", "(", "edges", ")", "]", "vert_edges", "=", "[", "Line", "(", "v_edge", ")", "for", "v_edge", "in", "zip", "(", "*", "edges", ")", "]", "mean_width", "=", "numpy", ".", "mean", "(", "[", "v_edge", ".", "get_length", "(", ")", "for", "v_edge", "in", "vert_edges", "]", ")", "num_vert_points", "=", "int", "(", "round", "(", "mean_width", "/", "mesh_spacing", ")", ")", "+", "1", "if", "num_vert_points", "<=", "1", ":", "raise", "ValueError", "(", "'mesh spacing %.1f km is too big for mean width %.1f km'", "%", "(", "mesh_spacing", ",", "mean_width", ")", ")", "points", "=", "zip", "(", "*", "[", "v_edge", ".", "resample_to_num_points", "(", "num_vert_points", ")", ".", "points", "for", "v_edge", "in", "vert_edges", "]", ")", "mesh", "=", "RectangularMesh", ".", "from_points_list", "(", "list", "(", "points", ")", ")", "assert", "1", "not", "in", "mesh", ".", "shape", "self", "=", "cls", "(", "mesh", ")", "self", ".", "surface_nodes", "=", "surface_nodes", "return", "self" ]

[ "Create", "and", "return", "a", "fault", "surface", "using", "fault", "source", "data", "." ]

[ "def", "surface_projection_from_fault_data", "(", "cls", ",", "edges", ")", ":", "# collect lons and lats of all the vertices of all the edges", "lons", "=", "[", "]", "lats", "=", "[", "]", "for", "edge", "in", "edges", ":", "for", "point", "in", "edge", ":", "lons", ".", "append", "(", "point", ".", "longitude", ")", "lats", ".", "append", "(", "point", ".", "latitude", ")", "lons", "=", "numpy", ".", "array", "(", "lons", ",", "dtype", "=", "float", ")", "lats", "=", "numpy", ".", "array", "(", "lats", ",", "dtype", "=", "float", ")", "return", "Mesh", "(", "lons", ",", "lats", ",", "depths", "=", "None", ")", ".", "get_convex_hull", "(", ")" ]

[ "Get", "a", "surface", "projection", "of", "the", "complex", "fault", "surface", "." ]

[ "def", "fix_ones", "(", "pmap", ")", ":", "for", "sid", "in", "pmap", ":", "array", "=", "pmap", "[", "sid", "]", ".", "array", "array", "[", "array", "==", "1.", "]", "=", ".9999999999999999", "return", "pmap" ]

[ "Physically", "an", "extremely", "small", "intensity", "measure", "level", "can", "have", "an", "extremely", "large", "probability", "of", "exceedence", "however", "that", "probability", "cannot", "be", "exactly", "1", "unless", "the", "level", "is", "exactly", "0", ".", "Numerically", "the", "PoE", "can", "be", "1", "and", "this", "give", "issues", "when", "calculating", "the", "damage", "(", "there", "is", "a", "log", "(", "0", ")", "in", ":", "class", ":", "openquake", ".", "risklib", ".", "scientific", ".", "annual_frequency_of_exceedence", ")", ".", "Here", "we", "solve", "the", "issue", "by", "replacing", "the", "unphysical", "probabilities", "1", "with", ".", "9999999999999999", "(", "the", "float64", "closest", "to", "1", ")", "." ]

[ "def", "build_weights", "(", "realizations", ",", "imt_dt", ")", ":", "arr", "=", "numpy", ".", "zeros", "(", "(", "len", "(", "realizations", ")", ",", "len", "(", "imt_dt", ".", "names", ")", ")", ")", "for", "m", ",", "imt", "in", "enumerate", "(", "imt_dt", ".", "names", ")", ":", "arr", "[", ":", ",", "m", "]", "=", "[", "rlz", ".", "weight", "[", "imt", "]", "for", "rlz", "in", "realizations", "]", "return", "arr" ]

[ ":", "returns", ":", "an", "array", "with", "the", "realization", "weights", "of", "shape", "(", "R", "M", ")" ]

[ "def", "set_array", "(", "longarray", ",", "shortarray", ")", ":", "longarray", "[", ":", "len", "(", "shortarray", ")", "]", "=", "shortarray", "longarray", "[", "len", "(", "shortarray", ")", ":", "]", "=", "numpy", ".", "nan" ]

[ ":", "param", "longarray", ":", "a", "numpy", "array", "of", "floats", "of", "length", "L", ">", "=", "l", ":", "param", "shortarray", ":", "a", "numpy", "array", "of", "floats", "of", "length", "l" ]

[ "def", "check_time_event", "(", "oqparam", ",", "occupancy_periods", ")", ":", "time_event", "=", "oqparam", ".", "time_event", "if", "time_event", "and", "time_event", "not", "in", "occupancy_periods", ":", "raise", "ValueError", "(", "'time_event is %s in %s, but the exposure contains %s'", "%", "(", "time_event", ",", "oqparam", ".", "inputs", "[", "'job_ini'", "]", ",", "', '", ".", "join", "(", "occupancy_periods", ")", ")", ")" ]

[ "Check", "the", "time_event", "parameter", "in", "the", "datastore", "by", "comparing", "with", "the", "periods", "found", "in", "the", "exposure", "." ]

[ "def", "build_hmaps", "(", "hcurves_by_kind", ",", "slice_", ",", "imtls", ",", "poes", ",", "monitor", ")", ":", "dic", "=", "{", "}", "for", "kind", ",", "hcurves", "in", "hcurves_by_kind", ".", "items", "(", ")", ":", "dic", "[", "kind", "]", "=", "calc", ".", "make_hmap_array", "(", "hcurves", ",", "imtls", ",", "poes", ",", "len", "(", "hcurves", ")", ")", "return", "dic", ",", "slice_" ]

[ "Build", "hazard", "maps", "from", "a", "slice", "of", "hazard", "curves", ".", ":", "returns", ":", "a", "pair", "(", "{", "kind", ":", "hmaps", "}", "slice", ")" ]

[ "def", "get_gmv_data", "(", "sids", ",", "gmfs", ",", "events", ")", ":", "N", ",", "E", ",", "M", "=", "gmfs", ".", "shape", "gmv_data_dt", "=", "numpy", ".", "dtype", "(", "[", "(", "'rlzi'", ",", "U16", ")", ",", "(", "'sid'", ",", "U32", ")", ",", "(", "'eid'", ",", "U64", ")", ",", "(", "'gmv'", ",", "(", "F32", ",", "(", "M", ",", ")", ")", ")", "]", ")", "# NB: ordering of the loops: first site, then event", "lst", "=", "[", "(", "event", "[", "'rlz'", "]", ",", "sids", "[", "s", "]", ",", "ei", ",", "gmfs", "[", "s", ",", "ei", "]", ")", "for", "s", "in", "numpy", ".", "arange", "(", "N", ",", "dtype", "=", "U32", ")", "for", "ei", ",", "event", "in", "enumerate", "(", "events", ")", "]", "return", "numpy", ".", "array", "(", "lst", ",", "gmv_data_dt", ")" ]

[ "Convert", "an", "array", "of", "shape", "(", "N", "E", "M", ")", "into", "an", "array", "of", "type", "gmv_data_dt" ]

[ "def", "save_gmfs", "(", "calculator", ")", ":", "dstore", "=", "calculator", ".", "datastore", "oq", "=", "calculator", ".", "oqparam", "logging", ".", "info", "(", "'Reading gmfs from file'", ")", "if", "oq", ".", "inputs", "[", "'gmfs'", "]", ".", "endswith", "(", "'.csv'", ")", ":", "# TODO: check if import_gmfs can be removed", "eids", "=", "import_gmfs", "(", "dstore", ",", "oq", ".", "inputs", "[", "'gmfs'", "]", ",", "calculator", ".", "sitecol", ".", "complete", ".", "sids", ")", "else", ":", "# XML", "eids", ",", "gmfs", "=", "readinput", ".", "eids", ",", "readinput", ".", "gmfs", "E", "=", "len", "(", "eids", ")", "events", "=", "numpy", ".", "zeros", "(", "E", ",", "rupture", ".", "events_dt", ")", "events", "[", "'eid'", "]", "=", "eids", "calculator", ".", "eids", "=", "eids", "if", "hasattr", "(", "oq", ",", "'number_of_ground_motion_fields'", ")", ":", "if", "oq", ".", "number_of_ground_motion_fields", "!=", "E", ":", "raise", "RuntimeError", "(", "'Expected %d ground motion fields, found %d'", "%", "(", "oq", ".", "number_of_ground_motion_fields", ",", "E", ")", ")", "else", ":", "# set the number of GMFs from the file", "oq", ".", "number_of_ground_motion_fields", "=", "E", "# NB: save_gmfs redefine oq.sites in case of GMFs from XML or CSV", "if", "oq", ".", "inputs", "[", "'gmfs'", "]", ".", "endswith", "(", "'.xml'", ")", ":", "haz_sitecol", "=", "readinput", ".", "get_site_collection", "(", "oq", ")", "N", ",", "E", ",", "M", "=", "gmfs", ".", "shape", "save_gmf_data", "(", "dstore", ",", "haz_sitecol", ",", "gmfs", "[", "haz_sitecol", ".", "sids", "]", ",", "oq", ".", "imtls", ",", "events", ")" ]

[ ":", "param", "calculator", ":", "a", "scenario_risk", "/", "damage", "or", "event_based_risk", "calculator", ":", "returns", ":", "a", "pair", "(", "eids", "R", ")", "where", "R", "is", "the", "number", "of", "realizations" ]

[ "def", "save_gmf_data", "(", "dstore", ",", "sitecol", ",", "gmfs", ",", "imts", ",", "events", "=", "(", ")", ")", ":", "if", "len", "(", "events", ")", "==", "0", ":", "E", "=", "gmfs", ".", "shape", "[", "1", "]", "events", "=", "numpy", ".", "zeros", "(", "E", ",", "rupture", ".", "events_dt", ")", "events", "[", "'eid'", "]", "=", "numpy", ".", "arange", "(", "E", ",", "dtype", "=", "U64", ")", "dstore", "[", "'events'", "]", "=", "events", "offset", "=", "0", "gmfa", "=", "get_gmv_data", "(", "sitecol", ".", "sids", ",", "gmfs", ",", "events", ")", "dstore", "[", "'gmf_data/data'", "]", "=", "gmfa", "dic", "=", "general", ".", "group_array", "(", "gmfa", ",", "'sid'", ")", "lst", "=", "[", "]", "all_sids", "=", "sitecol", ".", "complete", ".", "sids", "for", "sid", "in", "all_sids", ":", "rows", "=", "dic", ".", "get", "(", "sid", ",", "(", ")", ")", "n", "=", "len", "(", "rows", ")", "lst", ".", "append", "(", "(", "offset", ",", "offset", "+", "n", ")", ")", "offset", "+=", "n", "dstore", "[", "'gmf_data/imts'", "]", "=", "' '", ".", "join", "(", "imts", ")", "dstore", "[", "'gmf_data/indices'", "]", "=", "numpy", ".", "array", "(", "lst", ",", "U32", ")" ]

[ ":", "param", "dstore", ":", "a", ":", "class", ":", "openquake", ".", "baselib", ".", "datastore", ".", "DataStore", "instance", ":", "param", "sitecol", ":", "a", ":", "class", ":", "openquake", ".", "hazardlib", ".", "site", ".", "SiteCollection", "instance", ":", "param", "gmfs", ":", "an", "array", "of", "shape", "(", "N", "E", "M", ")", ":", "param", "imts", ":", "a", "list", "of", "IMT", "strings", ":", "param", "events", ":", "E", "event", "IDs", "or", "the", "empty", "tuple" ]

[ "def", "get_idxs", "(", "data", ",", "eid2idx", ")", ":", "uniq", ",", "inv", "=", "numpy", ".", "unique", "(", "data", "[", "'eid'", "]", ",", "return_inverse", "=", "True", ")", "idxs", "=", "numpy", ".", "array", "(", "[", "eid2idx", "[", "eid", "]", "for", "eid", "in", "uniq", "]", ")", "[", "inv", "]", "return", "idxs" ]

[ "Convert", "from", "event", "IDs", "to", "event", "indices", "." ]

[ "def", "import_gmfs", "(", "dstore", ",", "fname", ",", "sids", ")", ":", "array", "=", "writers", ".", "read_composite_array", "(", "fname", ")", ".", "array", "# has header rlzi, sid, eid, gmv_PGA, ...", "imts", "=", "[", "name", "[", "4", ":", "]", "for", "name", "in", "array", ".", "dtype", ".", "names", "[", "3", ":", "]", "]", "n_imts", "=", "len", "(", "imts", ")", "gmf_data_dt", "=", "numpy", ".", "dtype", "(", "[", "(", "'rlzi'", ",", "U16", ")", ",", "(", "'sid'", ",", "U32", ")", ",", "(", "'eid'", ",", "U64", ")", ",", "(", "'gmv'", ",", "(", "F32", ",", "(", "n_imts", ",", ")", ")", ")", "]", ")", "# store the events", "eids", "=", "numpy", ".", "unique", "(", "array", "[", "'eid'", "]", ")", "eids", ".", "sort", "(", ")", "E", "=", "len", "(", "eids", ")", "eid2idx", "=", "dict", "(", "zip", "(", "eids", ",", "range", "(", "E", ")", ")", ")", "events", "=", "numpy", ".", "zeros", "(", "E", ",", "rupture", ".", "events_dt", ")", "events", "[", "'eid'", "]", "=", "eids", "dstore", "[", "'events'", "]", "=", "events", "# store the GMFs", "dic", "=", "general", ".", "group_array", "(", "array", ".", "view", "(", "gmf_data_dt", ")", ",", "'sid'", ")", "lst", "=", "[", "]", "offset", "=", "0", "for", "sid", "in", "sids", ":", "n", "=", "len", "(", "dic", ".", "get", "(", "sid", ",", "[", "]", ")", ")", "lst", ".", "append", "(", "(", "offset", ",", "offset", "+", "n", ")", ")", "if", "n", ":", "offset", "+=", "n", "gmvs", "=", "dic", "[", "sid", "]", "gmvs", "[", "'eid'", "]", "=", "get_idxs", "(", "gmvs", ",", "eid2idx", ")", "gmvs", "[", "'rlzi'", "]", "=", "0", "# effectively there is only 1 realization", "dstore", ".", "extend", "(", "'gmf_data/data'", ",", "gmvs", ")", "dstore", "[", "'gmf_data/indices'", "]", "=", "numpy", ".", "array", "(", "lst", ",", "U32", ")", "dstore", "[", "'gmf_data/imts'", "]", "=", "' '", ".", "join", "(", "imts", ")", "sig_eps_dt", "=", "[", "(", "'eid'", ",", "U64", ")", ",", "(", "'sig'", ",", "(", "F32", ",", "n_imts", ")", ")", ",", "(", "'eps'", ",", "(", "F32", ",", "n_imts", ")", ")", "]", "dstore", "[", "'gmf_data/sigma_epsilon'", "]", "=", "numpy", ".", "zeros", "(", "0", ",", "sig_eps_dt", ")", "dstore", "[", "'weights'", "]", "=", "numpy", ".", "ones", "(", "(", "1", ",", "n_imts", ")", ")", "return", "eids" ]

[ "Import", "in", "the", "datastore", "a", "ground", "motion", "field", "CSV", "file", "." ]

[ "def", "monitor", "(", "self", ",", "operation", "=", "''", ",", "*", "*", "kw", ")", ":", "mon", "=", "self", ".", "_monitor", "(", "operation", ",", "hdf5", "=", "self", ".", "datastore", ".", "hdf5", ")", "self", ".", "_monitor", ".", "calc_id", "=", "mon", ".", "calc_id", "=", "self", ".", "datastore", ".", "calc_id", "vars", "(", "mon", ")", ".", "update", "(", "kw", ")", "return", "mon" ]

[ ":", "returns", ":", "a", "new", "Monitor", "instance" ]

[ "def", "save_params", "(", "self", ",", "*", "*", "kw", ")", ":", "if", "(", "'hazard_calculation_id'", "in", "kw", "and", "kw", "[", "'hazard_calculation_id'", "]", "is", "None", ")", ":", "del", "kw", "[", "'hazard_calculation_id'", "]", "vars", "(", "self", ".", "oqparam", ")", ".", "update", "(", "*", "*", "kw", ")", "self", ".", "datastore", "[", "'oqparam'", "]", "=", "self", ".", "oqparam", "# save the updated oqparam", "attrs", "=", "self", ".", "datastore", "[", "'/'", "]", ".", "attrs", "attrs", "[", "'engine_version'", "]", "=", "engine_version", "attrs", "[", "'date'", "]", "=", "datetime", ".", "now", "(", ")", ".", "isoformat", "(", ")", "[", ":", "19", "]", "if", "'checksum32'", "not", "in", "attrs", ":", "attrs", "[", "'checksum32'", "]", "=", "readinput", ".", "get_checksum32", "(", "self", ".", "oqparam", ")", "self", ".", "datastore", ".", "flush", "(", ")" ]

[ "Update", "the", "current", "calculation", "parameters", "and", "save", "engine_version" ]

[ "def", "check_precalc", "(", "self", ",", "precalc_mode", ")", ":", "calc_mode", "=", "self", ".", "oqparam", ".", "calculation_mode", "ok_mode", "=", "self", ".", "accept_precalc", "if", "calc_mode", "!=", "precalc_mode", "and", "precalc_mode", "not", "in", "ok_mode", ":", "raise", "InvalidCalculationID", "(", "'In order to run a calculation of kind %r, '", "'you need to provide a calculation of kind %r, '", "'but you provided a %r instead'", "%", "(", "calc_mode", ",", "ok_mode", ",", "precalc_mode", ")", ")" ]

[ "Defensive", "programming", "against", "users", "providing", "an", "incorrect", "pre", "-", "calculation", "ID", "(", "with", "--", "hazard", "-", "calculation", "-", "id", ")", "." ]

[ "def", "run", "(", "self", ",", "pre_execute", "=", "True", ",", "concurrent_tasks", "=", "None", ",", "close", "=", "True", ",", "*", "*", "kw", ")", ":", "with", "self", ".", "_monitor", ":", "self", ".", "_monitor", ".", "username", "=", "kw", ".", "get", "(", "'username'", ",", "''", ")", "self", ".", "_monitor", ".", "hdf5", "=", "self", ".", "datastore", ".", "hdf5", "if", "concurrent_tasks", "is", "None", ":", "# use the job.ini parameter", "ct", "=", "self", ".", "oqparam", ".", "concurrent_tasks", "else", ":", "# used the parameter passed in the command-line", "ct", "=", "concurrent_tasks", "if", "ct", "==", "0", ":", "# disable distribution temporarily", "oq_distribute", "=", "os", ".", "environ", ".", "get", "(", "'OQ_DISTRIBUTE'", ")", "os", ".", "environ", "[", "'OQ_DISTRIBUTE'", "]", "=", "'no'", "if", "ct", "!=", "self", ".", "oqparam", ".", "concurrent_tasks", ":", "# save the used concurrent_tasks", "self", ".", "oqparam", ".", "concurrent_tasks", "=", "ct", "self", ".", "save_params", "(", "*", "*", "kw", ")", "try", ":", "if", "pre_execute", ":", "self", ".", "pre_execute", "(", ")", "self", ".", "result", "=", "self", ".", "execute", "(", ")", "if", "self", ".", "result", "is", "not", "None", ":", "self", ".", "post_execute", "(", "self", ".", "result", ")", "self", ".", "before_export", "(", ")", "self", ".", "export", "(", "kw", ".", "get", "(", "'exports'", ",", "''", ")", ")", "except", "Exception", ":", "if", "kw", ".", "get", "(", "'pdb'", ")", ":", "# post-mortem debug", "tb", "=", "sys", ".", "exc_info", "(", ")", "[", "2", "]", "traceback", ".", "print_tb", "(", "tb", ")", "pdb", ".", "post_mortem", "(", "tb", ")", "else", ":", "logging", ".", "critical", "(", "''", ",", "exc_info", "=", "True", ")", "raise", "finally", ":", "# cleanup globals", "if", "ct", "==", "0", ":", "# restore OQ_DISTRIBUTE", "if", "oq_distribute", "is", "None", ":", "# was not set", "del", "os", ".", "environ", "[", "'OQ_DISTRIBUTE'", "]", "else", ":", "os", ".", "environ", "[", "'OQ_DISTRIBUTE'", "]", "=", "oq_distribute", "readinput", ".", "pmap", "=", "None", "readinput", ".", "exposure", "=", "None", "readinput", ".", "gmfs", "=", "None", "readinput", ".", "eids", "=", "None", "self", ".", "_monitor", ".", "flush", "(", ")", "if", "close", ":", "# in the engine we close later", "self", ".", "result", "=", "None", "try", ":", "self", ".", "datastore", ".", "close", "(", ")", "except", "(", "RuntimeError", ",", "ValueError", ")", ":", "# sometimes produces errors but they are difficult to", "# reproduce", "logging", ".", "warning", "(", "''", ",", "exc_info", "=", "True", ")", "return", "getattr", "(", "self", ",", "'exported'", ",", "{", "}", ")" ]

[ "Run", "the", "calculation", "and", "return", "the", "exported", "outputs", "." ]

[ "def", "export", "(", "self", ",", "exports", "=", "None", ")", ":", "self", ".", "exported", "=", "getattr", "(", "self", ".", "precalc", ",", "'exported'", ",", "{", "}", ")", "if", "isinstance", "(", "exports", ",", "tuple", ")", ":", "fmts", "=", "exports", "elif", "exports", ":", "# is a string", "fmts", "=", "exports", ".", "split", "(", "','", ")", "elif", "isinstance", "(", "self", ".", "oqparam", ".", "exports", ",", "tuple", ")", ":", "fmts", "=", "self", ".", "oqparam", ".", "exports", "else", ":", "# is a string", "fmts", "=", "self", ".", "oqparam", ".", "exports", ".", "split", "(", "','", ")", "keys", "=", "set", "(", "self", ".", "datastore", ")", "has_hcurves", "=", "(", "'hcurves-stats'", "in", "self", ".", "datastore", "or", "'hcurves-rlzs'", "in", "self", ".", "datastore", ")", "if", "has_hcurves", ":", "keys", ".", "add", "(", "'hcurves'", ")", "for", "fmt", "in", "fmts", ":", "if", "not", "fmt", ":", "continue", "for", "key", "in", "sorted", "(", "keys", ")", ":", "# top level keys", "if", "'rlzs'", "in", "key", "and", "self", ".", "R", ">", "1", ":", "continue", "# skip individual curves", "self", ".", "_export", "(", "(", "key", ",", "fmt", ")", ")", "if", "has_hcurves", "and", "self", ".", "oqparam", ".", "hazard_maps", ":", "self", ".", "_export", "(", "(", "'hmaps'", ",", "fmt", ")", ")", "if", "has_hcurves", "and", "self", ".", "oqparam", ".", "uniform_hazard_spectra", ":", "self", ".", "_export", "(", "(", "'uhs'", ",", "fmt", ")", ")" ]

[ "Export", "all", "the", "outputs", "in", "the", "datastore", "in", "the", "given", "export", "formats", ".", "Individual", "outputs", "are", "not", "exported", "if", "there", "are", "multiple", "realizations", "." ]

[ "def", "before_export", "(", "self", ")", ":", "# sanity check that eff_ruptures have been set, i.e. are not -1", "try", ":", "csm_info", "=", "self", ".", "datastore", "[", "'csm_info'", "]", "except", "KeyError", ":", "csm_info", "=", "self", ".", "datastore", "[", "'csm_info'", "]", "=", "self", ".", "csm", ".", "info", "for", "sm", "in", "csm_info", ".", "source_models", ":", "for", "sg", "in", "sm", ".", "src_groups", ":", "assert", "sg", ".", "eff_ruptures", "!=", "-", "1", ",", "sg", "for", "key", "in", "self", ".", "datastore", ":", "self", ".", "datastore", ".", "set_nbytes", "(", "key", ")", "self", ".", "datastore", ".", "flush", "(", ")" ]

[ "Set", "the", "attributes", "nbytes" ]

[ "def", "block_splitter", "(", "self", ",", "sources", ",", "weight", "=", "get_weight", ",", "key", "=", "lambda", "src", ":", "1", ")", ":", "ct", "=", "self", ".", "oqparam", ".", "concurrent_tasks", "or", "1", "maxweight", "=", "self", ".", "csm", ".", "get_maxweight", "(", "weight", ",", "ct", ",", "source", ".", "MINWEIGHT", ")", "if", "not", "hasattr", "(", "self", ",", "'logged'", ")", ":", "if", "maxweight", "==", "source", ".", "MINWEIGHT", ":", "logging", ".", "info", "(", "'Using minweight=%d'", ",", "source", ".", "MINWEIGHT", ")", "else", ":", "logging", ".", "info", "(", "'Using maxweight=%d'", ",", "maxweight", ")", "self", ".", "logged", "=", "True", "return", "general", ".", "block_splitter", "(", "sources", ",", "maxweight", ",", "weight", ",", "key", ")" ]

[ ":", "param", "sources", ":", "a", "list", "of", "sources", ":", "param", "weight", ":", "a", "weight", "function", "(", "default", ".", "weight", ")", ":", "param", "key", ":", "None", "or", "src_group_id", ":", "returns", ":", "an", "iterator", "over", "blocks", "of", "sources" ]

[ "def", "src_filter", "(", "self", ")", ":", "oq", "=", "self", ".", "oqparam", "self", ".", "hdf5cache", "=", "self", ".", "datastore", ".", "hdf5cache", "(", ")", "sitecol", "=", "self", ".", "sitecol", ".", "complete", "if", "self", ".", "sitecol", "else", "None", "if", "'ucerf'", "in", "oq", ".", "calculation_mode", ":", "return", "UcerfFilter", "(", "sitecol", ",", "oq", ".", "maximum_distance", ",", "self", ".", "hdf5cache", ")", "return", "SourceFilter", "(", "sitecol", ",", "oq", ".", "maximum_distance", ",", "self", ".", "hdf5cache", ")" ]

[ ":", "returns", ":", "a", "SourceFilter", "/", "UcerfFilter" ]

[ "def", "rtree_filter", "(", "self", ")", ":", "return", "RtreeFilter", "(", "self", ".", "src_filter", ".", "sitecol", ",", "self", ".", "oqparam", ".", "maximum_distance", ",", "self", ".", "src_filter", ".", "filename", ")" ]

[ ":", "returns", ":", "an", "RtreeFilter" ]

[ "def", "N", "(", "self", ")", ":", "if", "hasattr", "(", "self", ",", "'sitecol'", ")", ":", "return", "len", "(", "self", ".", "sitecol", ".", "complete", ")", "if", "self", ".", "sitecol", "else", "None", "return", "len", "(", "self", ".", "datastore", "[", "'sitecol/array'", "]", ")" ]

[ ":", "returns", ":", "the", "total", "number", "of", "sites" ]

[ "def", "read_inputs", "(", "self", ")", ":", "oq", "=", "self", ".", "oqparam", "self", ".", "_read_risk_data", "(", ")", "self", ".", "check_overflow", "(", ")", "# check if self.sitecol is too large", "if", "(", "'source_model_logic_tree'", "in", "oq", ".", "inputs", "and", "oq", ".", "hazard_calculation_id", "is", "None", ")", ":", "self", ".", "csm", "=", "readinput", ".", "get_composite_source_model", "(", "oq", ",", "self", ".", "monitor", "(", ")", ",", "srcfilter", "=", "self", ".", "src_filter", ")", "self", ".", "init", "(", ")" ]

[ "Read", "risk", "data", "and", "sources", "if", "any" ]

[ "def", "pre_execute", "(", "self", ")", ":", "oq", "=", "self", ".", "oqparam", "if", "'gmfs'", "in", "oq", ".", "inputs", "or", "'multi_peril'", "in", "oq", ".", "inputs", ":", "# read hazard from files", "assert", "not", "oq", ".", "hazard_calculation_id", ",", "(", "'You cannot use --hc together with gmfs_file'", ")", "self", ".", "read_inputs", "(", ")", "if", "'gmfs'", "in", "oq", ".", "inputs", ":", "save_gmfs", "(", "self", ")", "else", ":", "self", ".", "save_multi_peril", "(", ")", "elif", "'hazard_curves'", "in", "oq", ".", "inputs", ":", "# read hazard from file", "assert", "not", "oq", ".", "hazard_calculation_id", ",", "(", "'You cannot use --hc together with hazard_curves'", ")", "haz_sitecol", "=", "readinput", ".", "get_site_collection", "(", "oq", ")", "# NB: horrible: get_site_collection calls get_pmap_from_nrml", "# that sets oq.investigation_time, so it must be called first", "self", ".", "load_riskmodel", "(", ")", "# must be after get_site_collection", "self", ".", "read_exposure", "(", "haz_sitecol", ")", "# define .assets_by_site", "self", ".", "datastore", "[", "'poes/grp-00'", "]", "=", "fix_ones", "(", "readinput", ".", "pmap", ")", "self", ".", "datastore", "[", "'sitecol'", "]", "=", "self", ".", "sitecol", "self", ".", "datastore", "[", "'assetcol'", "]", "=", "self", ".", "assetcol", "self", ".", "datastore", "[", "'csm_info'", "]", "=", "fake", "=", "source", ".", "CompositionInfo", ".", "fake", "(", ")", "self", ".", "rlzs_assoc", "=", "fake", ".", "get_rlzs_assoc", "(", ")", "elif", "oq", ".", "hazard_calculation_id", ":", "parent", "=", "util", ".", "read", "(", "oq", ".", "hazard_calculation_id", ")", "self", ".", "check_precalc", "(", "parent", "[", "'oqparam'", "]", ".", "calculation_mode", ")", "self", ".", "datastore", ".", "parent", "=", "parent", "# copy missing parameters from the parent", "params", "=", "{", "name", ":", "value", "for", "name", ",", "value", "in", "vars", "(", "parent", "[", "'oqparam'", "]", ")", ".", "items", "(", ")", "if", "name", "not", "in", "vars", "(", "self", ".", "oqparam", ")", "}", "self", ".", "save_params", "(", "*", "*", "params", ")", "self", ".", "read_inputs", "(", ")", "oqp", "=", "parent", "[", "'oqparam'", "]", "if", "oqp", ".", "investigation_time", "!=", "oq", ".", "investigation_time", ":", "raise", "ValueError", "(", "'The parent calculation was using investigation_time=%s'", "' != %s'", "%", "(", "oqp", ".", "investigation_time", ",", "oq", ".", "investigation_time", ")", ")", "if", "oqp", ".", "minimum_intensity", "!=", "oq", ".", "minimum_intensity", ":", "raise", "ValueError", "(", "'The parent calculation was using minimum_intensity=%s'", "' != %s'", "%", "(", "oqp", ".", "minimum_intensity", ",", "oq", ".", "minimum_intensity", ")", ")", "missing_imts", "=", "set", "(", "oq", ".", "risk_imtls", ")", "-", "set", "(", "oqp", ".", "imtls", ")", "if", "missing_imts", ":", "raise", "ValueError", "(", "'The parent calculation is missing the IMT(s) %s'", "%", "', '", ".", "join", "(", "missing_imts", ")", ")", "elif", "self", ".", "__class__", ".", "precalc", ":", "calc", "=", "calculators", "[", "self", ".", "__class__", ".", "precalc", "]", "(", "self", ".", "oqparam", ",", "self", ".", "datastore", ".", "calc_id", ")", "calc", ".", "run", "(", ")", "self", ".", "param", "=", "calc", ".", "param", "self", ".", "sitecol", "=", "calc", ".", "sitecol", "self", ".", "assetcol", "=", "calc", ".", "assetcol", "self", ".", "riskmodel", "=", "calc", ".", "riskmodel", "if", "hasattr", "(", "calc", ",", "'rlzs_assoc'", ")", ":", "self", ".", "rlzs_assoc", "=", "calc", ".", "rlzs_assoc", "else", ":", "# this happens for instance for a scenario_damage without", "# rupture, gmfs, multi_peril", "raise", "InvalidFile", "(", "'%(job_ini)s: missing gmfs_csv, multi_peril_csv'", "%", "oq", ".", "inputs", ")", "if", "hasattr", "(", "calc", ",", "'csm'", ")", ":", "# no scenario", "self", ".", "csm", "=", "calc", ".", "csm", "else", ":", "self", ".", "read_inputs", "(", ")", "if", "self", ".", "riskmodel", ":", "self", ".", "save_riskmodel", "(", ")" ]

[ "Check", "if", "there", "is", "a", "previous", "calculation", "ID", ".", "If", "yes", "read", "the", "inputs", "by", "retrieving", "the", "previous", "calculation", ";", "if", "not", "read", "the", "inputs", "directly", "." ]

[ "def", "init", "(", "self", ")", ":", "oq", "=", "self", ".", "oqparam", "if", "not", "oq", ".", "risk_imtls", ":", "if", "self", ".", "datastore", ".", "parent", ":", "oq", ".", "risk_imtls", "=", "(", "self", ".", "datastore", ".", "parent", "[", "'oqparam'", "]", ".", "risk_imtls", ")", "if", "'precalc'", "in", "vars", "(", "self", ")", ":", "self", ".", "rlzs_assoc", "=", "self", ".", "precalc", ".", "rlzs_assoc", "elif", "'csm_info'", "in", "self", ".", "datastore", ":", "csm_info", "=", "self", ".", "datastore", "[", "'csm_info'", "]", "if", "oq", ".", "hazard_calculation_id", "and", "'gsim_logic_tree'", "in", "oq", ".", "inputs", ":", "# redefine the realizations by reading the weights from the", "# gsim_logic_tree_file that could be different from the parent", "csm_info", ".", "gsim_lt", "=", "logictree", ".", "GsimLogicTree", "(", "oq", ".", "inputs", "[", "'gsim_logic_tree'", "]", ",", "set", "(", "csm_info", ".", "trts", ")", ")", "self", ".", "rlzs_assoc", "=", "csm_info", ".", "get_rlzs_assoc", "(", ")", "elif", "hasattr", "(", "self", ",", "'csm'", ")", ":", "self", ".", "check_floating_spinning", "(", ")", "self", ".", "rlzs_assoc", "=", "self", ".", "csm", ".", "info", ".", "get_rlzs_assoc", "(", ")", "else", ":", "# build a fake; used by risk-from-file calculators", "self", ".", "datastore", "[", "'csm_info'", "]", "=", "fake", "=", "source", ".", "CompositionInfo", ".", "fake", "(", ")", "self", ".", "rlzs_assoc", "=", "fake", ".", "get_rlzs_assoc", "(", ")" ]

[ "To", "be", "overridden", "to", "initialize", "the", "datasets", "needed", "by", "the", "calculation" ]

[ "def", "R", "(", "self", ")", ":", "try", ":", "return", "self", ".", "csm", ".", "info", ".", "get_num_rlzs", "(", ")", "except", "AttributeError", ":", "# no self.csm", "return", "self", ".", "datastore", "[", "'csm_info'", "]", ".", "get_num_rlzs", "(", ")" ]

[ ":", "returns", ":", "the", "number", "of", "realizations" ]

[ "def", "read_exposure", "(", "self", ",", "haz_sitecol", "=", "None", ")", ":", "# after load_risk_model", "with", "self", ".", "monitor", "(", "'reading exposure'", ",", "autoflush", "=", "True", ")", ":", "self", ".", "sitecol", ",", "self", ".", "assetcol", ",", "discarded", "=", "(", "readinput", ".", "get_sitecol_assetcol", "(", "self", ".", "oqparam", ",", "haz_sitecol", ",", "self", ".", "riskmodel", ".", "loss_types", ")", ")", "if", "len", "(", "discarded", ")", ":", "self", ".", "datastore", "[", "'discarded'", "]", "=", "discarded", "if", "hasattr", "(", "self", ",", "'rup'", ")", ":", "# this is normal for the case of scenario from rupture", "logging", ".", "info", "(", "'%d assets were discarded because too far '", "'from the rupture; use `oq show discarded` '", "'to show them and `oq plot_assets` to plot '", "'them'", "%", "len", "(", "discarded", ")", ")", "elif", "not", "self", ".", "oqparam", ".", "discard_assets", ":", "# raise an error", "self", ".", "datastore", "[", "'sitecol'", "]", "=", "self", ".", "sitecol", "self", ".", "datastore", "[", "'assetcol'", "]", "=", "self", ".", "assetcol", "raise", "RuntimeError", "(", "'%d assets were discarded; use `oq show discarded` to'", "' show them and `oq plot_assets` to plot them'", "%", "len", "(", "discarded", ")", ")", "# reduce the riskmodel to the relevant taxonomies", "taxonomies", "=", "set", "(", "taxo", "for", "taxo", "in", "self", ".", "assetcol", ".", "tagcol", ".", "taxonomy", "if", "taxo", "!=", "'?'", ")", "if", "len", "(", "self", ".", "riskmodel", ".", "taxonomies", ")", ">", "len", "(", "taxonomies", ")", ":", "logging", ".", "info", "(", "'Reducing risk model from %d to %d taxonomies'", ",", "len", "(", "self", ".", "riskmodel", ".", "taxonomies", ")", ",", "len", "(", "taxonomies", ")", ")", "self", ".", "riskmodel", "=", "self", ".", "riskmodel", ".", "reduce", "(", "taxonomies", ")", "return", "readinput", ".", "exposure" ]

[ "Read", "the", "exposure", "the", "riskmodel", "and", "update", "the", "attributes", ".", "sitecol", ".", "assetcol" ]

[ "def", "load_riskmodel", "(", "self", ")", ":", "# to be called before read_exposure", "# NB: this is called even if there is no risk model", "logging", ".", "info", "(", "'Reading the risk model if present'", ")", "self", ".", "riskmodel", "=", "readinput", ".", "get_risk_model", "(", "self", ".", "oqparam", ")", "if", "not", "self", ".", "riskmodel", ":", "parent", "=", "self", ".", "datastore", ".", "parent", "if", "'risk_model'", "in", "parent", ":", "self", ".", "riskmodel", "=", "riskinput", ".", "CompositeRiskModel", ".", "read", "(", "parent", ")", "return", "if", "self", ".", "oqparam", ".", "ground_motion_fields", "and", "not", "self", ".", "oqparam", ".", "imtls", ":", "raise", "InvalidFile", "(", "'No intensity_measure_types specified in %s'", "%", "self", ".", "oqparam", ".", "inputs", "[", "'job_ini'", "]", ")", "self", ".", "save_params", "(", ")" ]

[ "Read", "the", "risk", "model", "and", "set", "the", "attribute", ".", "riskmodel", ".", "The", "riskmodel", "can", "be", "empty", "for", "hazard", "calculations", ".", "Save", "the", "loss", "ratios", "(", "if", "any", ")", "in", "the", "datastore", "." ]

[ "def", "save_riskmodel", "(", "self", ")", ":", "self", ".", "datastore", "[", "'risk_model'", "]", "=", "rm", "=", "self", ".", "riskmodel", "self", ".", "datastore", "[", "'taxonomy_mapping'", "]", "=", "self", ".", "riskmodel", ".", "tmap", "attrs", "=", "self", ".", "datastore", ".", "getitem", "(", "'risk_model'", ")", ".", "attrs", "attrs", "[", "'min_iml'", "]", "=", "hdf5", ".", "array_of_vstr", "(", "sorted", "(", "rm", ".", "min_iml", ".", "items", "(", ")", ")", ")", "self", ".", "datastore", ".", "set_nbytes", "(", "'risk_model'", ")" ]

[ "Save", "the", "risk", "models", "in", "the", "datastore" ]

[ "def", "store_rlz_info", "(", "self", ",", "eff_ruptures", "=", "None", ")", ":", "if", "hasattr", "(", "self", ",", "'csm'", ")", ":", "# no scenario", "self", ".", "csm", ".", "info", ".", "update_eff_ruptures", "(", "eff_ruptures", ")", "self", ".", "rlzs_assoc", "=", "self", ".", "csm", ".", "info", ".", "get_rlzs_assoc", "(", "self", ".", "oqparam", ".", "sm_lt_path", ")", "if", "not", "self", ".", "rlzs_assoc", ":", "raise", "RuntimeError", "(", "'Empty logic tree: too much filtering?'", ")", "self", ".", "datastore", "[", "'csm_info'", "]", "=", "self", ".", "csm", ".", "info", "R", "=", "len", "(", "self", ".", "rlzs_assoc", ".", "realizations", ")", "logging", ".", "info", "(", "'There are %d realization(s)'", ",", "R", ")", "if", "self", ".", "oqparam", ".", "imtls", ":", "self", ".", "datastore", "[", "'weights'", "]", "=", "arr", "=", "build_weights", "(", "self", ".", "rlzs_assoc", ".", "realizations", ",", "self", ".", "oqparam", ".", "imt_dt", "(", ")", ")", "self", ".", "datastore", ".", "set_attrs", "(", "'weights'", ",", "nbytes", "=", "arr", ".", "nbytes", ")", "if", "hasattr", "(", "self", ",", "'hdf5cache'", ")", ":", "# no scenario", "with", "hdf5", ".", "File", "(", "self", ".", "hdf5cache", ",", "'r+'", ")", "as", "cache", ":", "cache", "[", "'weights'", "]", "=", "arr", "if", "'event_based'", "in", "self", ".", "oqparam", ".", "calculation_mode", "and", "R", ">=", "TWO16", ":", "# rlzi is 16 bit integer in the GMFs, so there is hard limit or R", "raise", "ValueError", "(", "'The logic tree has %d realizations, the maximum '", "'is %d'", "%", "(", "R", ",", "TWO16", ")", ")", "elif", "R", ">", "10000", ":", "logging", ".", "warning", "(", "'The logic tree has %d realizations(!), please consider '", "'sampling it'", ",", "R", ")", "self", ".", "datastore", ".", "flush", "(", ")" ]

[ "Save", "info", "about", "the", "composite", "source", "model", "inside", "the", "csm_info", "dataset" ]

[ "def", "store_source_info", "(", "self", ",", "calc_times", ")", ":", "if", "calc_times", ":", "source_info", "=", "self", ".", "datastore", "[", "'source_info'", "]", "arr", "=", "numpy", ".", "zeros", "(", "(", "len", "(", "source_info", ")", ",", "3", ")", ",", "F32", ")", "ids", ",", "vals", "=", "zip", "(", "*", "sorted", "(", "calc_times", ".", "items", "(", ")", ")", ")", "arr", "[", "numpy", ".", "array", "(", "ids", ")", "]", "=", "vals", "source_info", "[", "'weight'", "]", "+=", "arr", "[", ":", ",", "0", "]", "source_info", "[", "'num_sites'", "]", "+=", "arr", "[", ":", ",", "1", "]", "source_info", "[", "'calc_time'", "]", "+=", "arr", "[", ":", ",", "2", "]" ]

[ "Save", "(", "weight", "num_sites", "calc_time", ")", "inside", "the", "source_info", "dataset" ]

[ "def", "read_shakemap", "(", "self", ",", "haz_sitecol", ",", "assetcol", ")", ":", "oq", "=", "self", ".", "oqparam", "E", "=", "oq", ".", "number_of_ground_motion_fields", "oq", ".", "risk_imtls", "=", "oq", ".", "imtls", "or", "self", ".", "datastore", ".", "parent", "[", "'oqparam'", "]", ".", "imtls", "extra", "=", "self", ".", "riskmodel", ".", "get_extra_imts", "(", "oq", ".", "risk_imtls", ")", "if", "extra", ":", "logging", ".", "warning", "(", "'There are risk functions for not available IMTs '", "'which will be ignored: %s'", "%", "extra", ")", "logging", ".", "info", "(", "'Getting/reducing shakemap'", ")", "with", "self", ".", "monitor", "(", "'getting/reducing shakemap'", ")", ":", "smap", "=", "oq", ".", "shakemap_id", "if", "oq", ".", "shakemap_id", "else", "numpy", ".", "load", "(", "oq", ".", "inputs", "[", "'shakemap'", "]", ")", "sitecol", ",", "shakemap", ",", "discarded", "=", "get_sitecol_shakemap", "(", "smap", ",", "oq", ".", "imtls", ",", "haz_sitecol", ",", "oq", ".", "asset_hazard_distance", "[", "'default'", "]", ",", "oq", ".", "discard_assets", ")", "if", "len", "(", "discarded", ")", ":", "self", ".", "datastore", "[", "'discarded'", "]", "=", "discarded", "assetcol", "=", "assetcol", ".", "reduce_also", "(", "sitecol", ")", "logging", ".", "info", "(", "'Building GMFs'", ")", "with", "self", ".", "monitor", "(", "'building/saving GMFs'", ")", ":", "imts", ",", "gmfs", "=", "to_gmfs", "(", "shakemap", ",", "oq", ".", "spatial_correlation", ",", "oq", ".", "cross_correlation", ",", "oq", ".", "site_effects", ",", "oq", ".", "truncation_level", ",", "E", ",", "oq", ".", "random_seed", ",", "oq", ".", "imtls", ")", "save_gmf_data", "(", "self", ".", "datastore", ",", "sitecol", ",", "gmfs", ",", "imts", ")", "return", "sitecol", ",", "assetcol" ]

[ "Enabled", "only", "if", "there", "is", "a", "shakemap_id", "parameter", "in", "the", "job", ".", "ini", ".", "Download", "unzip", "parse", "USGS", "shakemap", "files", "and", "build", "a", "corresponding", "set", "of", "GMFs", "which", "are", "then", "filtered", "with", "the", "hazard", "site", "collection", "and", "stored", "in", "the", "datastore", "." ]

[ "def", "build_riskinputs", "(", "self", ",", "kind", ")", ":", "logging", ".", "info", "(", "'Building risk inputs from %d realization(s)'", ",", "self", ".", "R", ")", "imtls", "=", "self", ".", "oqparam", ".", "imtls", "if", "not", "set", "(", "self", ".", "oqparam", ".", "risk_imtls", ")", "&", "set", "(", "imtls", ")", ":", "rsk", "=", "', '", ".", "join", "(", "self", ".", "oqparam", ".", "risk_imtls", ")", "haz", "=", "', '", ".", "join", "(", "imtls", ")", "raise", "ValueError", "(", "'The IMTs in the risk models (%s) are disjoint '", "\"from the IMTs in the hazard (%s)\"", "%", "(", "rsk", ",", "haz", ")", ")", "self", ".", "riskmodel", ".", "taxonomy", "=", "self", ".", "assetcol", ".", "tagcol", ".", "taxonomy", "with", "self", ".", "monitor", "(", "'building riskinputs'", ",", "autoflush", "=", "True", ")", ":", "riskinputs", "=", "list", "(", "self", ".", "_gen_riskinputs", "(", "kind", ")", ")", "assert", "riskinputs", "logging", ".", "info", "(", "'Built %d risk inputs'", ",", "len", "(", "riskinputs", ")", ")", "return", "riskinputs" ]

[ ":", "param", "kind", ":", "kind", "of", "hazard", "getter", "can", "be", "poe", "or", "gmf", ":", "returns", ":", "a", "list", "of", "RiskInputs", "objects", "sorted", "by", "IMT", "." ]

[ "def", "get_getter", "(", "self", ",", "kind", ",", "sid", ")", ":", "hdf5cache", "=", "getattr", "(", "self", ",", "'hdf5cache'", ",", "None", ")", "if", "hdf5cache", ":", "dstore", "=", "hdf5cache", "elif", "(", "self", ".", "oqparam", ".", "hazard_calculation_id", "and", "'gmf_data'", "not", "in", "self", ".", "datastore", ")", ":", "# 'gmf_data' in self.datastore happens for ShakeMap calculations", "self", ".", "datastore", ".", "parent", ".", "close", "(", ")", "# make sure it is closed", "dstore", "=", "self", ".", "datastore", ".", "parent", "else", ":", "dstore", "=", "self", ".", "datastore", "if", "kind", "==", "'poe'", ":", "# hcurves, shape (R, N)", "getter", "=", "getters", ".", "PmapGetter", "(", "dstore", ",", "self", ".", "rlzs_assoc", ",", "[", "sid", "]", ")", "else", ":", "# gmf", "getter", "=", "getters", ".", "GmfDataGetter", "(", "dstore", ",", "[", "sid", "]", ",", "self", ".", "R", ")", "if", "dstore", "is", "self", ".", "datastore", ":", "getter", ".", "init", "(", ")", "return", "getter" ]

[ ":", "param", "kind", ":", "poe", "or", "gmf", ":", "param", "sid", ":", "a", "site", "ID", ":", "returns", ":", "a", "PmapGetter", "or", "GmfDataGetter" ]

[ "def", "execute", "(", "self", ")", ":", "if", "not", "hasattr", "(", "self", ",", "'riskinputs'", ")", ":", "# in the reportwriter", "return", "res", "=", "Starmap", ".", "apply", "(", "self", ".", "core_task", ".", "__func__", ",", "(", "self", ".", "riskinputs", ",", "self", ".", "riskmodel", ",", "self", ".", "param", ",", "self", ".", "monitor", "(", ")", ")", ",", "concurrent_tasks", "=", "self", ".", "oqparam", ".", "concurrent_tasks", "or", "1", ",", "weight", "=", "get_weight", ")", ".", "reduce", "(", "self", ".", "combine", ")", "return", "res" ]

[ "Parallelize", "on", "the", "riskinputs", "and", "returns", "a", "dictionary", "of", "results", ".", "Require", "a", ".", "core_task", "to", "be", "defined", "with", "signature", "(", "riskinputs", "riskmodel", "rlzs_assoc", "monitor", ")", "." ]

[ "def", "bind", "(", "end_point", ",", "socket_type", ")", ":", "sock", "=", "context", ".", "socket", "(", "socket_type", ")", "try", ":", "sock", ".", "bind", "(", "end_point", ")", "except", "zmq", ".", "error", ".", "ZMQError", "as", "exc", ":", "sock", ".", "close", "(", ")", "raise", "exc", ".", "__class__", "(", "'%s: %s'", "%", "(", "exc", ",", "end_point", ")", ")", "return", "sock" ]

[ "Bind", "to", "a", "zmq", "URL", ";", "raise", "a", "proper", "error", "if", "the", "URL", "is", "invalid", ";", "return", "a", "zmq", "socket", "." ]

[ "def", "send", "(", "self", ",", "obj", ")", ":", "self", ".", "zsocket", ".", "send_pyobj", "(", "obj", ")", "self", ".", "num_sent", "+=", "1", "if", "self", ".", "socket_type", "==", "zmq", ".", "REQ", ":", "return", "self", ".", "zsocket", ".", "recv_pyobj", "(", ")" ]

[ "Send", "an", "object", "to", "the", "remote", "server", ";", "block", "and", "return", "the", "reply", "if", "the", "socket", "type", "is", "REQ", "." ]

[ "def", "angular_distance", "(", "km", ",", "lat", ",", "lat2", "=", "None", ")", ":", "if", "lat2", "is", "not", "None", ":", "# use the largest latitude to compute the angular distance", "lat", "=", "max", "(", "abs", "(", "lat", ")", ",", "abs", "(", "lat2", ")", ")", "return", "km", "*", "KM_TO_DEGREES", "/", "math", ".", "cos", "(", "lat", "*", "DEGREES_TO_RAD", ")" ]

[ "Return", "the", "angular", "distance", "of", "two", "points", "at", "the", "given", "latitude", "." ]

[ "def", "assoc", "(", "objects", ",", "sitecol", ",", "assoc_dist", ",", "mode", ",", "asset_refs", "=", "(", ")", ")", ":", "if", "isinstance", "(", "objects", ",", "numpy", ".", "ndarray", ")", "or", "hasattr", "(", "objects", ",", "'lons'", ")", ":", "# objects is a geo array with lon, lat fields or a mesh-like instance", "return", "_GeographicObjects", "(", "objects", ")", ".", "assoc", "(", "sitecol", ",", "assoc_dist", ",", "mode", ")", "else", ":", "# objects is the list assets_by_site", "return", "_GeographicObjects", "(", "sitecol", ")", ".", "assoc2", "(", "objects", ",", "assoc_dist", ",", "mode", ",", "asset_refs", ")" ]

[ "Associate", "geographic", "objects", "to", "a", "site", "collection", "." ]

[ "def", "clean_points", "(", "points", ")", ":", "if", "not", "points", ":", "return", "points", "result", "=", "[", "points", "[", "0", "]", "]", "for", "point", "in", "points", ":", "if", "point", "!=", "result", "[", "-", "1", "]", ":", "result", ".", "append", "(", "point", ")", "return", "result" ]

[ "Given", "a", "list", "of", ":", "class", ":", "~openquake", ".", "hazardlib", ".", "geo", ".", "point", ".", "Point", "objects", "return", "a", "new", "list", "with", "adjacent", "duplicate", "points", "removed", "." ]

[ "def", "line_intersects_itself", "(", "lons", ",", "lats", ",", "closed_shape", "=", "False", ")", ":", "assert", "len", "(", "lons", ")", "==", "len", "(", "lats", ")", "if", "len", "(", "lons", ")", "<=", "3", ":", "# line can not intersect itself unless there are", "# at least four points", "return", "False", "west", ",", "east", ",", "north", ",", "south", "=", "get_spherical_bounding_box", "(", "lons", ",", "lats", ")", "proj", "=", "OrthographicProjection", "(", "west", ",", "east", ",", "north", ",", "south", ")", "xx", ",", "yy", "=", "proj", "(", "lons", ",", "lats", ")", "if", "not", "shapely", ".", "geometry", ".", "LineString", "(", "list", "(", "zip", "(", "xx", ",", "yy", ")", ")", ")", ".", "is_simple", ":", "return", "True", "if", "closed_shape", ":", "xx", ",", "yy", "=", "proj", "(", "numpy", ".", "roll", "(", "lons", ",", "1", ")", ",", "numpy", ".", "roll", "(", "lats", ",", "1", ")", ")", "if", "not", "shapely", ".", "geometry", ".", "LineString", "(", "list", "(", "zip", "(", "xx", ",", "yy", ")", ")", ")", ".", "is_simple", ":", "return", "True", "return", "False" ]

[ "Return", "True", "if", "line", "of", "points", "intersects", "itself", ".", "Line", "with", "the", "last", "point", "repeating", "the", "first", "one", "considered", "intersecting", "itself", "." ]

[ "def", "get_bounding_box", "(", "obj", ",", "maxdist", ")", ":", "if", "hasattr", "(", "obj", ",", "'get_bounding_box'", ")", ":", "return", "obj", ".", "get_bounding_box", "(", "maxdist", ")", "elif", "hasattr", "(", "obj", ",", "'polygon'", ")", ":", "bbox", "=", "obj", ".", "polygon", ".", "get_bbox", "(", ")", "else", ":", "if", "isinstance", "(", "obj", ",", "list", ")", ":", "# a list of locations", "lons", "=", "numpy", ".", "array", "(", "[", "loc", ".", "longitude", "for", "loc", "in", "obj", "]", ")", "lats", "=", "numpy", ".", "array", "(", "[", "loc", ".", "latitude", "for", "loc", "in", "obj", "]", ")", "else", ":", "# assume an array with fields lon, lat", "lons", ",", "lats", "=", "obj", "[", "'lon'", "]", ",", "obj", "[", "'lat'", "]", "min_lon", ",", "max_lon", "=", "lons", ".", "min", "(", ")", ",", "lons", ".", "max", "(", ")", "if", "cross_idl", "(", "min_lon", ",", "max_lon", ")", ":", "lons", "%=", "360", "bbox", "=", "lons", ".", "min", "(", ")", ",", "lats", ".", "min", "(", ")", ",", "lons", ".", "max", "(", ")", ",", "lats", ".", "max", "(", ")", "a1", "=", "min", "(", "maxdist", "*", "KM_TO_DEGREES", ",", "90", ")", "a2", "=", "min", "(", "angular_distance", "(", "maxdist", ",", "bbox", "[", "1", "]", ",", "bbox", "[", "3", "]", ")", ",", "180", ")", "return", "bbox", "[", "0", "]", "-", "a2", ",", "bbox", "[", "1", "]", "-", "a1", ",", "bbox", "[", "2", "]", "+", "a2", ",", "bbox", "[", "3", "]", "+", "a1" ]

[ "Return", "the", "dilated", "bounding", "box", "of", "a", "geometric", "object", "." ]

[ "def", "get_spherical_bounding_box", "(", "lons", ",", "lats", ")", ":", "north", ",", "south", "=", "numpy", ".", "max", "(", "lats", ")", ",", "numpy", ".", "min", "(", "lats", ")", "west", ",", "east", "=", "numpy", ".", "min", "(", "lons", ")", ",", "numpy", ".", "max", "(", "lons", ")", "assert", "(", "-", "180", "<=", "west", "<=", "180", ")", "and", "(", "-", "180", "<=", "east", "<=", "180", ")", ",", "(", "west", ",", "east", ")", "if", "get_longitudinal_extent", "(", "west", ",", "east", ")", "<", "0", ":", "# points are lying on both sides of the international date line", "# (meridian 180). the actual west longitude is the lowest positive", "# longitude and east one is the highest negative.", "if", "hasattr", "(", "lons", ",", "'flatten'", ")", ":", "# fixes test_surface_crossing_international_date_line", "lons", "=", "lons", ".", "flatten", "(", ")", "west", "=", "min", "(", "lon", "for", "lon", "in", "lons", "if", "lon", ">", "0", ")", "east", "=", "max", "(", "lon", "for", "lon", "in", "lons", "if", "lon", "<", "0", ")", "if", "not", "all", "(", "(", "get_longitudinal_extent", "(", "west", ",", "lon", ")", ">=", "0", "and", "get_longitudinal_extent", "(", "lon", ",", "east", ")", ">=", "0", ")", "for", "lon", "in", "lons", ")", ":", "raise", "ValueError", "(", "'points collection has longitudinal extent '", "'wider than 180 deg'", ")", "return", "SphericalBB", "(", "west", ",", "east", ",", "north", ",", "south", ")" ]

[ "Given", "a", "collection", "of", "points", "find", "and", "return", "the", "bounding", "box", "as", "a", "pair", "of", "longitudes", "and", "a", "pair", "of", "latitudes", "." ]

[ "def", "get_middle_point", "(", "lon1", ",", "lat1", ",", "lon2", ",", "lat2", ")", ":", "if", "lon1", "==", "lon2", "and", "lat1", "==", "lat2", ":", "return", "lon1", ",", "lat1", "dist", "=", "geodetic", ".", "geodetic_distance", "(", "lon1", ",", "lat1", ",", "lon2", ",", "lat2", ")", "azimuth", "=", "geodetic", ".", "azimuth", "(", "lon1", ",", "lat1", ",", "lon2", ",", "lat2", ")", "return", "geodetic", ".", "point_at", "(", "lon1", ",", "lat1", ",", "azimuth", ",", "dist", "/", "2.0", ")" ]

[ "Given", "two", "points", "return", "the", "point", "exactly", "in", "the", "middle", "lying", "on", "the", "same", "great", "circle", "arc", "." ]

[ "def", "cartesian_to_spherical", "(", "vectors", ")", ":", "rr", "=", "numpy", ".", "sqrt", "(", "numpy", ".", "sum", "(", "vectors", "*", "vectors", ",", "axis", "=", "-", "1", ")", ")", "xx", ",", "yy", ",", "zz", "=", "vectors", ".", "T", "lats", "=", "numpy", ".", "degrees", "(", "numpy", ".", "arcsin", "(", "(", "zz", "/", "rr", ")", ".", "clip", "(", "-", "1.", ",", "1.", ")", ")", ")", "lons", "=", "numpy", ".", "degrees", "(", "numpy", ".", "arctan2", "(", "yy", ",", "xx", ")", ")", "depths", "=", "EARTH_RADIUS", "-", "rr", "return", "lons", ".", "T", ",", "lats", ".", "T", ",", "depths" ]

[ "Return", "the", "spherical", "coordinates", "for", "coordinates", "in", "Cartesian", "space", "." ]

[ "def", "triangle_area", "(", "e1", ",", "e2", ",", "e3", ")", ":", "# calculating edges length", "e1_length", "=", "numpy", ".", "sqrt", "(", "numpy", ".", "sum", "(", "e1", "*", "e1", ",", "axis", "=", "-", "1", ")", ")", "e2_length", "=", "numpy", ".", "sqrt", "(", "numpy", ".", "sum", "(", "e2", "*", "e2", ",", "axis", "=", "-", "1", ")", ")", "e3_length", "=", "numpy", ".", "sqrt", "(", "numpy", ".", "sum", "(", "e3", "*", "e3", ",", "axis", "=", "-", "1", ")", ")", "# calculating half perimeter", "s", "=", "(", "e1_length", "+", "e2_length", "+", "e3_length", ")", "/", "2.0", "# applying Heron's formula", "return", "numpy", ".", "sqrt", "(", "s", "*", "(", "s", "-", "e1_length", ")", "*", "(", "s", "-", "e2_length", ")", "*", "(", "s", "-", "e3_length", ")", ")" ]

[ "Get", "the", "area", "of", "triangle", "formed", "by", "three", "vectors", "." ]

[ "def", "normalized", "(", "vector", ")", ":", "length", "=", "numpy", ".", "sum", "(", "vector", "*", "vector", ",", "axis", "=", "-", "1", ")", "length", "=", "numpy", ".", "sqrt", "(", "length", ".", "reshape", "(", "length", ".", "shape", "+", "(", "1", ",", ")", ")", ")", "return", "vector", "/", "length" ]

[ "Get", "unit", "vector", "for", "a", "given", "one", "." ]

[ "def", "point_to_polygon_distance", "(", "polygon", ",", "pxx", ",", "pyy", ")", ":", "pxx", "=", "numpy", ".", "array", "(", "pxx", ")", "pyy", "=", "numpy", ".", "array", "(", "pyy", ")", "assert", "pxx", ".", "shape", "==", "pyy", ".", "shape", "if", "pxx", ".", "ndim", "==", "0", ":", "pxx", "=", "pxx", ".", "reshape", "(", "(", "1", ",", ")", ")", "pyy", "=", "pyy", ".", "reshape", "(", "(", "1", ",", ")", ")", "result", "=", "numpy", ".", "array", "(", "[", "polygon", ".", "distance", "(", "shapely", ".", "geometry", ".", "Point", "(", "pxx", ".", "item", "(", "i", ")", ",", "pyy", ".", "item", "(", "i", ")", ")", ")", "for", "i", "in", "range", "(", "pxx", ".", "size", ")", "]", ")", "return", "result", ".", "reshape", "(", "pxx", ".", "shape", ")" ]

[ "Calculate", "the", "distance", "to", "polygon", "for", "each", "point", "of", "the", "collection", "on", "the", "2d", "Cartesian", "plane", "." ]

[ "def", "cross_idl", "(", "lon1", ",", "lon2", ",", "*", "lons", ")", ":", "lons", "=", "(", "lon1", ",", "lon2", ")", "+", "lons", "l1", ",", "l2", "=", "min", "(", "lons", ")", ",", "max", "(", "lons", ")", "# a line crosses the international date line if the end positions", "# have different sign and they are more than 180 degrees longitude apart", "return", "l1", "*", "l2", "<", "0", "and", "abs", "(", "l1", "-", "l2", ")", ">", "180" ]

[ "Return", "True", "if", "two", "longitude", "values", "define", "line", "crossing", "international", "date", "line", "." ]

[ "def", "normalize_lons", "(", "l1", ",", "l2", ")", ":", "if", "l1", ">", "l2", ":", "# exchange lons", "l1", ",", "l2", "=", "l2", ",", "l1", "delta", "=", "l2", "-", "l1", "if", "l1", "<", "0", "and", "l2", ">", "0", "and", "delta", ">", "180", ":", "return", "[", "(", "-", "180", ",", "l1", ")", ",", "(", "l2", ",", "180", ")", "]", "elif", "l1", ">", "0", "and", "l2", ">", "180", "and", "delta", "<", "180", ":", "return", "[", "(", "l1", ",", "180", ")", ",", "(", "-", "180", ",", "l2", "-", "360", ")", "]", "elif", "l1", "<", "-", "180", "and", "l2", "<", "0", "and", "delta", "<", "180", ":", "return", "[", "(", "l1", "+", "360", ",", "180", ")", ",", "(", "l2", ",", "-", "180", ")", "]", "return", "[", "(", "l1", ",", "l2", ")", "]" ]

[ "An", "international", "date", "line", "safe", "way", "of", "returning", "a", "range", "of", "longitudes", "." ]

[ "def", "within", "(", "bbox", ",", "lonlat_index", ")", ":", "lon1", ",", "lat1", ",", "lon2", ",", "lat2", "=", "bbox", "set_", "=", "set", "(", ")", "for", "l1", ",", "l2", "in", "normalize_lons", "(", "lon1", ",", "lon2", ")", ":", "box", "=", "(", "l1", ",", "lat1", ",", "l2", ",", "lat2", ")", "set_", "|=", "set", "(", "lonlat_index", ".", "intersection", "(", "box", ")", ")", "return", "numpy", ".", "array", "(", "sorted", "(", "set_", ")", ",", "numpy", ".", "uint32", ")" ]

[ ":", "param", "bbox", ":", "a", "bounding", "box", "in", "lon", "lat", ":", "param", "lonlat_index", ":", "an", "rtree", "index", "in", "lon", "lat", ":", "returns", ":", "array", "of", "indices", "within", "the", "bounding", "box" ]

[ "def", "plane_fit", "(", "points", ")", ":", "points", "=", "numpy", ".", "transpose", "(", "points", ")", "points", "=", "numpy", ".", "reshape", "(", "points", ",", "(", "numpy", ".", "shape", "(", "points", ")", "[", "0", "]", ",", "-", "1", ")", ")", "assert", "points", ".", "shape", "[", "0", "]", "<", "points", ".", "shape", "[", "1", "]", ",", "points", ".", "shape", "ctr", "=", "points", ".", "mean", "(", "axis", "=", "1", ")", "x", "=", "points", "-", "ctr", "[", ":", ",", "None", "]", "M", "=", "numpy", ".", "dot", "(", "x", ",", "x", ".", "T", ")", "return", "ctr", ",", "numpy", ".", "linalg", ".", "svd", "(", "M", ")", "[", "0", "]", "[", ":", ",", "-", "1", "]" ]

[ "This", "fits", "an", "n", "-", "dimensional", "plane", "to", "a", "set", "of", "points", ".", "See", "http", ":", "//", "stackoverflow", ".", "com", "/", "questions", "/", "12299540", "/", "plane", "-", "fitting", "-", "to", "-", "4", "-", "or", "-", "more", "-", "xyz", "-", "points" ]

[ "def", "get_closest", "(", "self", ",", "lon", ",", "lat", ",", "depth", "=", "0", ")", ":", "xyz", "=", "spherical_to_cartesian", "(", "lon", ",", "lat", ",", "depth", ")", "min_dist", ",", "idx", "=", "self", ".", "kdtree", ".", "query", "(", "xyz", ")", "return", "self", ".", "objects", "[", "idx", "]", ",", "min_dist" ]

[ "Get", "the", "closest", "object", "to", "the", "given", "longitude", "and", "latitude", "and", "its", "distance", "." ]

[ "def", "assoc", "(", "self", ",", "sitecol", ",", "assoc_dist", ",", "mode", ")", ":", "assert", "mode", "in", "'strict warn filter'", ",", "mode", "dic", "=", "{", "}", "discarded", "=", "[", "]", "for", "sid", ",", "lon", ",", "lat", "in", "zip", "(", "sitecol", ".", "sids", ",", "sitecol", ".", "lons", ",", "sitecol", ".", "lats", ")", ":", "obj", ",", "distance", "=", "self", ".", "get_closest", "(", "lon", ",", "lat", ")", "if", "assoc_dist", "is", "None", ":", "dic", "[", "sid", "]", "=", "obj", "# associate all", "elif", "distance", "<=", "assoc_dist", ":", "dic", "[", "sid", "]", "=", "obj", "# associate within", "elif", "mode", "==", "'warn'", ":", "dic", "[", "sid", "]", "=", "obj", "# associate outside", "logging", ".", "warning", "(", "'The closest vs30 site (%.1f %.1f) is distant more than %d'", "' km from site #%d (%.1f %.1f)'", ",", "obj", "[", "'lon'", "]", ",", "obj", "[", "'lat'", "]", ",", "int", "(", "distance", ")", ",", "sid", ",", "lon", ",", "lat", ")", "elif", "mode", "==", "'filter'", ":", "discarded", ".", "append", "(", "obj", ")", "elif", "mode", "==", "'strict'", ":", "raise", "SiteAssociationError", "(", "'There is nothing closer than %s km '", "'to site (%s %s)'", "%", "(", "assoc_dist", ",", "lon", ",", "lat", ")", ")", "if", "not", "dic", ":", "raise", "SiteAssociationError", "(", "'No sites could be associated within %s km'", "%", "assoc_dist", ")", "return", "(", "sitecol", ".", "filtered", "(", "dic", ")", ",", "numpy", ".", "array", "(", "[", "dic", "[", "sid", "]", "for", "sid", "in", "sorted", "(", "dic", ")", "]", ")", ",", "discarded", ")" ]

[ ":", "param", "sitecol", ":", "a", "(", "filtered", ")", "site", "collection", ":", "param", "assoc_dist", ":", "the", "maximum", "distance", "for", "association", ":", "param", "mode", ":", "strict", "warn", "or", "filter", ":", "returns", ":", "filtered", "site", "collection", "filtered", "objects", "discarded" ]

[ "def", "assoc2", "(", "self", ",", "assets_by_site", ",", "assoc_dist", ",", "mode", ",", "asset_refs", ")", ":", "assert", "mode", "in", "'strict filter'", ",", "mode", "self", ".", "objects", ".", "filtered", "# self.objects must be a SiteCollection", "asset_dt", "=", "numpy", ".", "dtype", "(", "[", "(", "'asset_ref'", ",", "vstr", ")", ",", "(", "'lon'", ",", "F32", ")", ",", "(", "'lat'", ",", "F32", ")", "]", ")", "assets_by_sid", "=", "collections", ".", "defaultdict", "(", "list", ")", "discarded", "=", "[", "]", "for", "assets", "in", "assets_by_site", ":", "lon", ",", "lat", "=", "assets", "[", "0", "]", ".", "location", "obj", ",", "distance", "=", "self", ".", "get_closest", "(", "lon", ",", "lat", ")", "if", "distance", "<=", "assoc_dist", ":", "# keep the assets, otherwise discard them", "assets_by_sid", "[", "obj", "[", "'sids'", "]", "]", ".", "extend", "(", "assets", ")", "elif", "mode", "==", "'strict'", ":", "raise", "SiteAssociationError", "(", "'There is nothing closer than %s km '", "'to site (%s %s)'", "%", "(", "assoc_dist", ",", "lon", ",", "lat", ")", ")", "else", ":", "discarded", ".", "extend", "(", "assets", ")", "sids", "=", "sorted", "(", "assets_by_sid", ")", "if", "not", "sids", ":", "raise", "SiteAssociationError", "(", "'Could not associate any site to any assets within the '", "'asset_hazard_distance of %s km'", "%", "assoc_dist", ")", "assets_by_site", "=", "[", "sorted", "(", "assets_by_sid", "[", "sid", "]", ",", "key", "=", "operator", ".", "attrgetter", "(", "'ordinal'", ")", ")", "for", "sid", "in", "sids", "]", "data", "=", "[", "(", "asset_refs", "[", "asset", ".", "ordinal", "]", ",", ")", "+", "asset", ".", "location", "for", "asset", "in", "discarded", "]", "discarded", "=", "numpy", ".", "array", "(", "data", ",", "asset_dt", ")", "return", "self", ".", "objects", ".", "filtered", "(", "sids", ")", ",", "assets_by_site", ",", "discarded" ]

[ "Associated", "a", "list", "of", "assets", "by", "site", "to", "the", "site", "collection", "used", "to", "instantiate", "GeographicObjects", "." ]

[ "def", "get_vulnerability_functions_04", "(", "node", ",", "fname", ")", ":", "logging", ".", "warning", "(", "'Please upgrade %s to NRML 0.5'", ",", "fname", ")", "# NB: the IMTs can be duplicated and with different levels, each", "# vulnerability function in a set will get its own levels", "imts", "=", "set", "(", ")", "vf_ids", "=", "set", "(", ")", "# imt, vf_id -> vulnerability function", "vmodel", "=", "scientific", ".", "VulnerabilityModel", "(", "*", "*", "node", ".", "attrib", ")", "for", "vset", "in", "node", ":", "imt_str", "=", "vset", ".", "IML", "[", "'IMT'", "]", "imls", "=", "~", "vset", ".", "IML", "imts", ".", "add", "(", "imt_str", ")", "for", "vfun", "in", "vset", ".", "getnodes", "(", "'discreteVulnerability'", ")", ":", "vf_id", "=", "vfun", "[", "'vulnerabilityFunctionID'", "]", "if", "vf_id", "in", "vf_ids", ":", "raise", "InvalidFile", "(", "'Duplicated vulnerabilityFunctionID: %s: %s, line %d'", "%", "(", "vf_id", ",", "fname", ",", "vfun", ".", "lineno", ")", ")", "vf_ids", ".", "add", "(", "vf_id", ")", "with", "context", "(", "fname", ",", "vfun", ")", ":", "loss_ratios", "=", "~", "vfun", ".", "lossRatio", "coefficients", "=", "~", "vfun", ".", "coefficientsVariation", "if", "len", "(", "loss_ratios", ")", "!=", "len", "(", "imls", ")", ":", "raise", "InvalidFile", "(", "'There are %d loss ratios, but %d imls: %s, line %d'", "%", "(", "len", "(", "loss_ratios", ")", ",", "len", "(", "imls", ")", ",", "fname", ",", "vfun", ".", "lossRatio", ".", "lineno", ")", ")", "if", "len", "(", "coefficients", ")", "!=", "len", "(", "imls", ")", ":", "raise", "InvalidFile", "(", "'There are %d coefficients, but %d imls: %s, line %d'", "%", "(", "len", "(", "coefficients", ")", ",", "len", "(", "imls", ")", ",", "fname", ",", "vfun", ".", "coefficientsVariation", ".", "lineno", ")", ")", "with", "context", "(", "fname", ",", "vfun", ")", ":", "vmodel", "[", "imt_str", ",", "vf_id", "]", "=", "scientific", ".", "VulnerabilityFunction", "(", "vf_id", ",", "imt_str", ",", "imls", ",", "loss_ratios", ",", "coefficients", ",", "vfun", "[", "'probabilisticDistribution'", "]", ")", "return", "vmodel" ]

[ ":", "param", "node", ":", "a", "vulnerabilityModel", "node", ":", "param", "fname", ":", "path", "to", "the", "vulnerability", "file", ":", "returns", ":", "a", "dictionary", "imt", "vf_id", "-", ">", "vulnerability", "function" ]

[ "def", "get_vulnerability_functions_05", "(", "node", ",", "fname", ")", ":", "# NB: the IMTs can be duplicated and with different levels, each", "# vulnerability function in a set will get its own levels", "vf_ids", "=", "set", "(", ")", "vmodel", "=", "scientific", ".", "VulnerabilityModel", "(", "*", "*", "node", ".", "attrib", ")", "# imt, vf_id -> vulnerability function", "for", "vfun", "in", "node", ".", "getnodes", "(", "'vulnerabilityFunction'", ")", ":", "with", "context", "(", "fname", ",", "vfun", ")", ":", "imt", "=", "vfun", ".", "imls", "[", "'imt'", "]", "imls", "=", "numpy", ".", "array", "(", "~", "vfun", ".", "imls", ")", "vf_id", "=", "vfun", "[", "'id'", "]", "if", "vf_id", "in", "vf_ids", ":", "raise", "InvalidFile", "(", "'Duplicated vulnerabilityFunctionID: %s: %s, line %d'", "%", "(", "vf_id", ",", "fname", ",", "vfun", ".", "lineno", ")", ")", "vf_ids", ".", "add", "(", "vf_id", ")", "num_probs", "=", "None", "if", "vfun", "[", "'dist'", "]", "==", "'PM'", ":", "loss_ratios", ",", "probs", "=", "[", "]", ",", "[", "]", "for", "probabilities", "in", "vfun", "[", "1", ":", "]", ":", "loss_ratios", ".", "append", "(", "probabilities", "[", "'lr'", "]", ")", "probs", ".", "append", "(", "valid", ".", "probabilities", "(", "~", "probabilities", ")", ")", "if", "num_probs", "is", "None", ":", "num_probs", "=", "len", "(", "probs", "[", "-", "1", "]", ")", "elif", "len", "(", "probs", "[", "-", "1", "]", ")", "!=", "num_probs", ":", "raise", "ValueError", "(", "'Wrong number of probabilities (expected %d, '", "'got %d) in %s, line %d'", "%", "(", "num_probs", ",", "len", "(", "probs", "[", "-", "1", "]", ")", ",", "fname", ",", "probabilities", ".", "lineno", ")", ")", "all_probs", "=", "numpy", ".", "array", "(", "probs", ")", "assert", "all_probs", ".", "shape", "==", "(", "len", "(", "loss_ratios", ")", ",", "len", "(", "imls", ")", ")", ",", "(", "len", "(", "loss_ratios", ")", ",", "len", "(", "imls", ")", ")", "vmodel", "[", "imt", ",", "vf_id", "]", "=", "(", "scientific", ".", "VulnerabilityFunctionWithPMF", "(", "vf_id", ",", "imt", ",", "imls", ",", "numpy", ".", "array", "(", "loss_ratios", ")", ",", "all_probs", ")", ")", "# the seed will be set by readinput.get_risk_model", "else", ":", "with", "context", "(", "fname", ",", "vfun", ")", ":", "loss_ratios", "=", "~", "vfun", ".", "meanLRs", "coefficients", "=", "~", "vfun", ".", "covLRs", "if", "len", "(", "loss_ratios", ")", "!=", "len", "(", "imls", ")", ":", "raise", "InvalidFile", "(", "'There are %d loss ratios, but %d imls: %s, line %d'", "%", "(", "len", "(", "loss_ratios", ")", ",", "len", "(", "imls", ")", ",", "fname", ",", "vfun", ".", "meanLRs", ".", "lineno", ")", ")", "if", "len", "(", "coefficients", ")", "!=", "len", "(", "imls", ")", ":", "raise", "InvalidFile", "(", "'There are %d coefficients, but %d imls: %s, '", "'line %d'", "%", "(", "len", "(", "coefficients", ")", ",", "len", "(", "imls", ")", ",", "fname", ",", "vfun", ".", "covLRs", ".", "lineno", ")", ")", "with", "context", "(", "fname", ",", "vfun", ")", ":", "vmodel", "[", "imt", ",", "vf_id", "]", "=", "scientific", ".", "VulnerabilityFunction", "(", "vf_id", ",", "imt", ",", "imls", ",", "loss_ratios", ",", "coefficients", ",", "vfun", "[", "'dist'", "]", ")", "return", "vmodel" ]

[ ":", "param", "node", ":", "a", "vulnerabilityModel", "node", ":", "param", "fname", ":", "path", "of", "the", "vulnerability", "filter", ":", "returns", ":", "a", "dictionary", "imt", "vf_id", "-", ">", "vulnerability", "function" ]

[ "def", "ffconvert", "(", "fname", ",", "limit_states", ",", "ff", ",", "min_iml", "=", "1E-10", ")", ":", "with", "context", "(", "fname", ",", "ff", ")", ":", "ffs", "=", "ff", "[", "1", ":", "]", "imls", "=", "ff", ".", "imls", "nodamage", "=", "imls", ".", "attrib", ".", "get", "(", "'noDamageLimit'", ")", "if", "nodamage", "==", "0", ":", "# use a cutoff to avoid log(0) in GMPE.to_distribution_values", "logging", ".", "warning", "(", "'Found a noDamageLimit=0 in %s, line %s, '", "'using %g instead'", ",", "fname", ",", "ff", ".", "lineno", ",", "min_iml", ")", "nodamage", "=", "min_iml", "with", "context", "(", "fname", ",", "imls", ")", ":", "attrs", "=", "dict", "(", "format", "=", "ff", "[", "'format'", "]", ",", "imt", "=", "imls", "[", "'imt'", "]", ",", "id", "=", "ff", "[", "'id'", "]", ",", "nodamage", "=", "nodamage", ")", "LS", "=", "len", "(", "limit_states", ")", "if", "LS", "!=", "len", "(", "ffs", ")", ":", "with", "context", "(", "fname", ",", "ff", ")", ":", "raise", "InvalidFile", "(", "'expected %d limit states, found %d'", "%", "(", "LS", ",", "len", "(", "ffs", ")", ")", ")", "if", "ff", "[", "'format'", "]", "==", "'continuous'", ":", "minIML", "=", "float", "(", "imls", "[", "'minIML'", "]", ")", "if", "minIML", "==", "0", ":", "# use a cutoff to avoid log(0) in GMPE.to_distribution_values", "logging", ".", "warning", "(", "'Found minIML=0 in %s, line %s, using %g instead'", ",", "fname", ",", "imls", ".", "lineno", ",", "min_iml", ")", "minIML", "=", "min_iml", "attrs", "[", "'minIML'", "]", "=", "minIML", "attrs", "[", "'maxIML'", "]", "=", "float", "(", "imls", "[", "'maxIML'", "]", ")", "array", "=", "numpy", ".", "zeros", "(", "LS", ",", "[", "(", "'mean'", ",", "F64", ")", ",", "(", "'stddev'", ",", "F64", ")", "]", ")", "for", "i", ",", "ls", ",", "node", "in", "zip", "(", "range", "(", "LS", ")", ",", "limit_states", ",", "ff", "[", "1", ":", "]", ")", ":", "if", "ls", "!=", "node", "[", "'ls'", "]", ":", "with", "context", "(", "fname", ",", "node", ")", ":", "raise", "InvalidFile", "(", "'expected %s, found'", "%", "(", "ls", ",", "node", "[", "'ls'", "]", ")", ")", "array", "[", "'mean'", "]", "[", "i", "]", "=", "node", "[", "'mean'", "]", "array", "[", "'stddev'", "]", "[", "i", "]", "=", "node", "[", "'stddev'", "]", "elif", "ff", "[", "'format'", "]", "==", "'discrete'", ":", "attrs", "[", "'imls'", "]", "=", "~", "imls", "valid", ".", "check_levels", "(", "attrs", "[", "'imls'", "]", ",", "attrs", "[", "'imt'", "]", ",", "min_iml", ")", "num_poes", "=", "len", "(", "attrs", "[", "'imls'", "]", ")", "array", "=", "numpy", ".", "zeros", "(", "(", "LS", ",", "num_poes", ")", ")", "for", "i", ",", "ls", ",", "node", "in", "zip", "(", "range", "(", "LS", ")", ",", "limit_states", ",", "ff", "[", "1", ":", "]", ")", ":", "with", "context", "(", "fname", ",", "node", ")", ":", "if", "ls", "!=", "node", "[", "'ls'", "]", ":", "raise", "InvalidFile", "(", "'expected %s, found'", "%", "(", "ls", ",", "node", "[", "'ls'", "]", ")", ")", "poes", "=", "(", "~", "node", "if", "isinstance", "(", "~", "node", ",", "list", ")", "else", "valid", ".", "probabilities", "(", "~", "node", ")", ")", "if", "len", "(", "poes", ")", "!=", "num_poes", ":", "raise", "InvalidFile", "(", "'expected %s, found'", "%", "(", "num_poes", ",", "len", "(", "poes", ")", ")", ")", "array", "[", "i", ",", ":", "]", "=", "poes", "# NB: the format is constrained in nrml.FragilityNode to be either", "# discrete or continuous, there is no third option", "return", "array", ",", "attrs" ]

[ "Convert", "a", "fragility", "function", "into", "a", "numpy", "array", "plus", "a", "bunch", "of", "attributes", "." ]

[ "def", "get_fragility_model", "(", "node", ",", "fname", ")", ":", "with", "context", "(", "fname", ",", "node", ")", ":", "fid", "=", "node", "[", "'id'", "]", "asset_category", "=", "node", "[", "'assetCategory'", "]", "loss_type", "=", "node", "[", "'lossCategory'", "]", "description", "=", "~", "node", ".", "description", "limit_states", "=", "~", "node", ".", "limitStates", "ffs", "=", "node", "[", "2", ":", "]", "fmodel", "=", "scientific", ".", "FragilityModel", "(", "fid", ",", "asset_category", ",", "loss_type", ",", "description", ",", "limit_states", ")", "for", "ff", "in", "ffs", ":", "array", ",", "attrs", "=", "ffconvert", "(", "fname", ",", "limit_states", ",", "ff", ")", "attrs", "[", "'id'", "]", "=", "ff", "[", "'id'", "]", "ffl", "=", "scientific", ".", "FragilityFunctionList", "(", "array", ",", "*", "*", "attrs", ")", "fmodel", "[", "ff", ".", "imls", "[", "'imt'", "]", ",", "ff", "[", "'id'", "]", "]", "=", "ffl", "return", "fmodel" ]

[ ":", "param", "node", ":", "a", "vulnerabilityModel", "node", ":", "param", "fname", ":", "path", "to", "the", "vulnerability", "file", ":", "returns", ":", "a", "dictionary", "imt", "ff_id", "-", ">", "fragility", "function", "list" ]

[ "def", "convert_fragility_model_04", "(", "node", ",", "fname", ",", "fmcounter", "=", "itertools", ".", "count", "(", "1", ")", ")", ":", "convert_type", "=", "{", "\"lognormal\"", ":", "\"logncdf\"", "}", "new", "=", "Node", "(", "'fragilityModel'", ",", "dict", "(", "assetCategory", "=", "'building'", ",", "lossCategory", "=", "'structural'", ",", "id", "=", "'fm_%d_converted_from_NRML_04'", "%", "next", "(", "fmcounter", ")", ")", ")", "with", "context", "(", "fname", ",", "node", ")", ":", "fmt", "=", "node", "[", "'format'", "]", "descr", "=", "~", "node", ".", "description", "limit_states", "=", "~", "node", ".", "limitStates", "new", ".", "append", "(", "Node", "(", "'description'", ",", "{", "}", ",", "descr", ")", ")", "new", ".", "append", "(", "(", "Node", "(", "'limitStates'", ",", "{", "}", ",", "' '", ".", "join", "(", "limit_states", ")", ")", ")", ")", "for", "ffs", "in", "node", "[", "2", ":", "]", ":", "IML", "=", "ffs", ".", "IML", "# NB: noDamageLimit = None is different than zero", "nodamage", "=", "ffs", ".", "attrib", ".", "get", "(", "'noDamageLimit'", ")", "ff", "=", "Node", "(", "'fragilityFunction'", ",", "{", "'format'", ":", "fmt", "}", ")", "ff", "[", "'id'", "]", "=", "~", "ffs", ".", "taxonomy", "ff", "[", "'shape'", "]", "=", "convert_type", "[", "ffs", ".", "attrib", ".", "get", "(", "'type'", ",", "'lognormal'", ")", "]", "if", "fmt", "==", "'continuous'", ":", "with", "context", "(", "fname", ",", "IML", ")", ":", "attr", "=", "dict", "(", "imt", "=", "IML", "[", "'IMT'", "]", ",", "minIML", "=", "IML", "[", "'minIML'", "]", ",", "maxIML", "=", "IML", "[", "'maxIML'", "]", ")", "if", "nodamage", "is", "not", "None", ":", "attr", "[", "'noDamageLimit'", "]", "=", "nodamage", "ff", ".", "append", "(", "Node", "(", "'imls'", ",", "attr", ")", ")", "for", "ffc", "in", "ffs", "[", "2", ":", "]", ":", "with", "context", "(", "fname", ",", "ffc", ")", ":", "ls", "=", "ffc", "[", "'ls'", "]", "param", "=", "ffc", ".", "params", "with", "context", "(", "fname", ",", "param", ")", ":", "m", ",", "s", "=", "param", "[", "'mean'", "]", ",", "param", "[", "'stddev'", "]", "ff", ".", "append", "(", "Node", "(", "'params'", ",", "dict", "(", "ls", "=", "ls", ",", "mean", "=", "m", ",", "stddev", "=", "s", ")", ")", ")", "else", ":", "# discrete", "with", "context", "(", "fname", ",", "IML", ")", ":", "imls", "=", "' '", ".", "join", "(", "map", "(", "str", ",", "(", "~", "IML", ")", "[", "1", "]", ")", ")", "attr", "=", "dict", "(", "imt", "=", "IML", "[", "'IMT'", "]", ")", "if", "nodamage", "is", "not", "None", ":", "attr", "[", "'noDamageLimit'", "]", "=", "nodamage", "ff", ".", "append", "(", "Node", "(", "'imls'", ",", "attr", ",", "imls", ")", ")", "for", "ffd", "in", "ffs", "[", "2", ":", "]", ":", "ls", "=", "ffd", "[", "'ls'", "]", "with", "context", "(", "fname", ",", "ffd", ")", ":", "poes", "=", "' '", ".", "join", "(", "map", "(", "str", ",", "~", "ffd", ".", "poEs", ")", ")", "ff", ".", "append", "(", "Node", "(", "'poes'", ",", "dict", "(", "ls", "=", "ls", ")", ",", "poes", ")", ")", "new", ".", "append", "(", "ff", ")", "return", "new" ]

[ ":", "param", "node", ":", "an", ":", "class", ":", "openquake", ".", "commonib", ".", "node", ".", "Node", "in", "NRML", "0", ".", "4", ":", "param", "fname", ":", "path", "of", "the", "fragility", "file", ":", "returns", ":", "an", ":", "class", ":", "openquake", ".", "commonib", ".", "node", ".", "Node", "in", "NRML", "0", ".", "5" ]

[ "def", "get_fragility_model_04", "(", "fmodel", ",", "fname", ")", ":", "logging", ".", "warning", "(", "'Please upgrade %s to NRML 0.5'", ",", "fname", ")", "node05", "=", "convert_fragility_model_04", "(", "fmodel", ",", "fname", ")", "node05", ".", "limitStates", ".", "text", "=", "node05", ".", "limitStates", ".", "text", ".", "split", "(", ")", "return", "get_fragility_model", "(", "node05", ",", "fname", ")" ]

[ ":", "param", "fmodel", ":", "a", "fragilityModel", "node", ":", "param", "fname", ":", "path", "of", "the", "fragility", "file", ":", "returns", ":", "an", ":", "class", ":", "openquake", ".", "risklib", ".", "scientific", ".", "FragilityModel", "instance" ]

[ "def", "taxonomy", "(", "value", ")", ":", "try", ":", "value", ".", "encode", "(", "'ascii'", ")", "except", "UnicodeEncodeError", ":", "raise", "ValueError", "(", "'tag %r is not ASCII'", "%", "value", ")", "if", "re", ".", "search", "(", "r'\\s'", ",", "value", ")", ":", "raise", "ValueError", "(", "'The taxonomy %r contains whitespace chars'", "%", "value", ")", "return", "value" ]

[ "Any", "ASCII", "character", "goes", "into", "a", "taxonomy", "except", "spaces", "." ]

[ "def", "update_validators", "(", ")", ":", "validators", ".", "update", "(", "{", "'fragilityFunction.id'", ":", "valid", ".", "utf8", ",", "# taxonomy", "'vulnerabilityFunction.id'", ":", "valid", ".", "utf8", ",", "# taxonomy", "'consequenceFunction.id'", ":", "valid", ".", "utf8", ",", "# taxonomy", "'asset.id'", ":", "valid", ".", "asset_id", ",", "'costType.name'", ":", "valid", ".", "cost_type", ",", "'costType.type'", ":", "valid", ".", "cost_type_type", ",", "'cost.type'", ":", "valid", ".", "cost_type", ",", "'area.type'", ":", "valid", ".", "name", ",", "'isAbsolute'", ":", "valid", ".", "boolean", ",", "'insuranceLimit'", ":", "valid", ".", "positivefloat", ",", "'deductible'", ":", "valid", ".", "positivefloat", ",", "'occupants'", ":", "valid", ".", "positivefloat", ",", "'value'", ":", "valid", ".", "positivefloat", ",", "'retrofitted'", ":", "valid", ".", "positivefloat", ",", "'number'", ":", "valid", ".", "compose", "(", "valid", ".", "positivefloat", ",", "valid", ".", "nonzero", ")", ",", "'vulnerabilitySetID'", ":", "str", ",", "# any ASCII string is fine", "'vulnerabilityFunctionID'", ":", "str", ",", "# any ASCII string is fine", "'lossCategory'", ":", "valid", ".", "utf8", ",", "# a description field", "'lr'", ":", "valid", ".", "probability", ",", "'lossRatio'", ":", "valid", ".", "positivefloats", ",", "'coefficientsVariation'", ":", "valid", ".", "positivefloats", ",", "'probabilisticDistribution'", ":", "valid", ".", "Choice", "(", "'LN'", ",", "'BT'", ")", ",", "'dist'", ":", "valid", ".", "Choice", "(", "'LN'", ",", "'BT'", ",", "'PM'", ")", ",", "'meanLRs'", ":", "valid", ".", "positivefloats", ",", "'covLRs'", ":", "valid", ".", "positivefloats", ",", "'format'", ":", "valid", ".", "ChoiceCI", "(", "'discrete'", ",", "'continuous'", ")", ",", "'mean'", ":", "valid", ".", "positivefloat", ",", "'stddev'", ":", "valid", ".", "positivefloat", ",", "'minIML'", ":", "valid", ".", "positivefloat", ",", "'maxIML'", ":", "valid", ".", "positivefloat", ",", "'limitStates'", ":", "valid", ".", "namelist", ",", "'noDamageLimit'", ":", "valid", ".", "NoneOr", "(", "valid", ".", "positivefloat", ")", ",", "'loss_type'", ":", "valid_loss_types", ",", "'losses'", ":", "valid", ".", "positivefloats", ",", "'averageLoss'", ":", "valid", ".", "positivefloat", ",", "'stdDevLoss'", ":", "valid", ".", "positivefloat", ",", "'ffs.type'", ":", "valid", ".", "ChoiceCI", "(", "'lognormal'", ")", ",", "'assetLifeExpectancy'", ":", "valid", ".", "positivefloat", ",", "'interestRate'", ":", "valid", ".", "positivefloat", ",", "'lossType'", ":", "valid_loss_types", ",", "'aalOrig'", ":", "valid", ".", "positivefloat", ",", "'aalRetr'", ":", "valid", ".", "positivefloat", ",", "'ratio'", ":", "valid", ".", "positivefloat", ",", "'cf'", ":", "asset_mean_stddev", ",", "'damage'", ":", "damage_triple", ",", "'damageStates'", ":", "valid", ".", "namelist", ",", "'taxonomy'", ":", "taxonomy", ",", "'tagNames'", ":", "valid", ".", "namelist", ",", "}", ")" ]

[ "Call", "this", "to", "updade", "the", "global", "nrml", ".", "validators" ]

[ "def", "get_info", "(", "dstore", ")", ":", "oq", "=", "dstore", "[", "'oqparam'", "]", "stats", "=", "{", "stat", ":", "s", "for", "s", ",", "stat", "in", "enumerate", "(", "oq", ".", "hazard_stats", "(", ")", ")", "}", "loss_types", "=", "{", "lt", ":", "l", "for", "l", ",", "lt", "in", "enumerate", "(", "oq", ".", "loss_dt", "(", ")", ".", "names", ")", "}", "imt", "=", "{", "imt", ":", "i", "for", "i", ",", "imt", "in", "enumerate", "(", "oq", ".", "imtls", ")", "}", "num_rlzs", "=", "dstore", "[", "'csm_info'", "]", ".", "get_num_rlzs", "(", ")", "return", "dict", "(", "stats", "=", "stats", ",", "num_rlzs", "=", "num_rlzs", ",", "loss_types", "=", "loss_types", ",", "imtls", "=", "oq", ".", "imtls", ",", "investigation_time", "=", "oq", ".", "investigation_time", ",", "poes", "=", "oq", ".", "poes", ",", "imt", "=", "imt", ",", "uhs_dt", "=", "oq", ".", "uhs_dt", "(", ")", ")" ]

[ ":", "returns", ":", "{", "stats", ":", "dic", "loss_types", ":", "dic", "num_rlzs", ":", "R", "}" ]

[ "def", "parse", "(", "query_string", ",", "info", "=", "{", "}", ")", ":", "qdic", "=", "parse_qs", "(", "query_string", ")", "loss_types", "=", "info", ".", "get", "(", "'loss_types'", ",", "[", "]", ")", "for", "key", ",", "val", "in", "qdic", ".", "items", "(", ")", ":", "# for instance, convert site_id to an int", "if", "key", "==", "'loss_type'", ":", "qdic", "[", "key", "]", "=", "[", "loss_types", "[", "k", "]", "for", "k", "in", "val", "]", "else", ":", "qdic", "[", "key", "]", "=", "[", "lit_eval", "(", "v", ")", "for", "v", "in", "val", "]", "if", "info", ":", "qdic", "[", "'k'", "]", ",", "qdic", "[", "'kind'", "]", ",", "qdic", "[", "'rlzs'", "]", "=", "_normalize", "(", "qdic", "[", "'kind'", "]", ",", "info", ")", "return", "qdic" ]

[ ":", "returns", ":", "a", "normalized", "query_dict", "as", "in", "the", "following", "examples", ":" ]

[ "def", "barray", "(", "iterlines", ")", ":", "lst", "=", "[", "line", ".", "encode", "(", "'utf-8'", ")", "for", "line", "in", "iterlines", "]", "arr", "=", "numpy", ".", "array", "(", "lst", ")", "return", "arr" ]

[ "Array", "of", "bytes" ]

[ "def", "extract_", "(", "dstore", ",", "dspath", ")", ":", "obj", "=", "dstore", "[", "dspath", "]", "if", "isinstance", "(", "obj", ",", "Dataset", ")", ":", "return", "ArrayWrapper", "(", "obj", ".", "value", ",", "obj", ".", "attrs", ")", "elif", "isinstance", "(", "obj", ",", "Group", ")", ":", "return", "ArrayWrapper", "(", "numpy", ".", "array", "(", "list", "(", "obj", ")", ")", ",", "obj", ".", "attrs", ")", "else", ":", "return", "obj" ]

[ "Extracts", "an", "HDF5", "path", "object", "from", "the", "datastore", "for", "instance", "extract", "(", "dstore", "sitecol", ")", "." ]

[ "def", "extract_realizations", "(", "dstore", ",", "dummy", ")", ":", "rlzs", "=", "dstore", "[", "'csm_info'", "]", ".", "rlzs", "dt", "=", "[", "(", "'ordinal'", ",", "U32", ")", ",", "(", "'weight'", ",", "F32", ")", ",", "(", "'gsims'", ",", "'<S64'", ")", "]", "arr", "=", "numpy", ".", "zeros", "(", "len", "(", "rlzs", ")", ",", "dt", ")", "arr", "[", "'ordinal'", "]", "=", "rlzs", "[", "'ordinal'", "]", "arr", "[", "'weight'", "]", "=", "rlzs", "[", "'weight'", "]", "arr", "[", "'gsims'", "]", "=", "rlzs", "[", "'branch_path'", "]", "# this is used in scenario by QGIS", "return", "arr" ]

[ "Extract", "an", "array", "of", "realizations", ".", "Use", "it", "as", "/", "extract", "/", "realizations" ]

[ "def", "extract_exposure_metadata", "(", "dstore", ",", "what", ")", ":", "dic", "=", "{", "}", "dic1", ",", "dic2", "=", "dstore", "[", "'assetcol/tagcol'", "]", ".", "__toh5__", "(", ")", "dic", ".", "update", "(", "dic1", ")", "dic", ".", "update", "(", "dic2", ")", "if", "'asset_risk'", "in", "dstore", ":", "dic", "[", "'multi_risk'", "]", "=", "sorted", "(", "set", "(", "dstore", "[", "'asset_risk'", "]", ".", "dtype", ".", "names", ")", "-", "set", "(", "dstore", "[", "'assetcol/array'", "]", ".", "dtype", ".", "names", ")", ")", "names", "=", "[", "name", "for", "name", "in", "dstore", "[", "'assetcol/array'", "]", ".", "dtype", ".", "names", "if", "name", ".", "startswith", "(", "(", "'value-'", ",", "'number'", ",", "'occupants_'", ")", ")", "and", "not", "name", ".", "endswith", "(", "'_None'", ")", "]", "return", "ArrayWrapper", "(", "numpy", ".", "array", "(", "names", ")", ",", "dic", ")" ]

[ "Extract", "the", "loss", "categories", "and", "the", "tags", "of", "the", "exposure", ".", "Use", "it", "as", "/", "extract", "/", "exposure_metadata" ]

[ "def", "extract_assets", "(", "dstore", ",", "what", ")", ":", "qdict", "=", "parse", "(", "what", ")", "dic", "=", "{", "}", "dic1", ",", "dic2", "=", "dstore", "[", "'assetcol/tagcol'", "]", ".", "__toh5__", "(", ")", "dic", ".", "update", "(", "dic1", ")", "dic", ".", "update", "(", "dic2", ")", "arr", "=", "dstore", "[", "'assetcol/array'", "]", ".", "value", "for", "tag", ",", "vals", "in", "qdict", ".", "items", "(", ")", ":", "cond", "=", "numpy", ".", "zeros", "(", "len", "(", "arr", ")", ",", "bool", ")", "for", "val", "in", "vals", ":", "tagidx", ",", "=", "numpy", ".", "where", "(", "dic", "[", "tag", "]", "==", "val", ")", "cond", "|=", "arr", "[", "tag", "]", "==", "tagidx", "arr", "=", "arr", "[", "cond", "]", "return", "ArrayWrapper", "(", "arr", ",", "dic", ")" ]

[ "Extract", "an", "array", "of", "assets", "optionally", "filtered", "by", "tag", ".", "Use", "it", "as", "/", "extract", "/", "assets?taxonomy", "=", "RC&taxonomy", "=", "MSBC&occupancy", "=", "RES" ]

[ "def", "extract_asset_values", "(", "dstore", ",", "sid", ")", ":", "if", "sid", ":", "return", "extract", "(", "dstore", ",", "'asset_values'", ")", "[", "int", "(", "sid", ")", "]", "assetcol", "=", "extract", "(", "dstore", ",", "'assetcol'", ")", "asset_refs", "=", "assetcol", ".", "asset_refs", "assets_by_site", "=", "assetcol", ".", "assets_by_site", "(", ")", "lts", "=", "assetcol", ".", "loss_types", "dt", "=", "numpy", ".", "dtype", "(", "[", "(", "'aref'", ",", "asset_refs", ".", "dtype", ")", ",", "(", "'aid'", ",", "numpy", ".", "uint32", ")", "]", "+", "[", "(", "str", "(", "lt", ")", ",", "numpy", ".", "float32", ")", "for", "lt", "in", "lts", "]", ")", "data", "=", "[", "]", "for", "assets", "in", "assets_by_site", ":", "vals", "=", "numpy", ".", "zeros", "(", "len", "(", "assets", ")", ",", "dt", ")", "for", "a", ",", "asset", "in", "enumerate", "(", "assets", ")", ":", "vals", "[", "a", "]", "[", "'aref'", "]", "=", "asset_refs", "[", "a", "]", "vals", "[", "a", "]", "[", "'aid'", "]", "=", "asset", "[", "'ordinal'", "]", "for", "lt", "in", "lts", ":", "vals", "[", "a", "]", "[", "lt", "]", "=", "asset", "[", "'value-'", "+", "lt", "]", "data", ".", "append", "(", "vals", ")", "return", "data" ]

[ "Extract", "an", "array", "of", "asset", "values", "for", "the", "given", "sid", ".", "Use", "it", "as", "/", "extract", "/", "asset_values", "/", "0" ]

[ "def", "extract_asset_tags", "(", "dstore", ",", "tagname", ")", ":", "tagcol", "=", "dstore", "[", "'assetcol/tagcol'", "]", "if", "tagname", ":", "yield", "tagname", ",", "barray", "(", "tagcol", ".", "gen_tags", "(", "tagname", ")", ")", "for", "tagname", "in", "tagcol", ".", "tagnames", ":", "yield", "tagname", ",", "barray", "(", "tagcol", ".", "gen_tags", "(", "tagname", ")", ")" ]

[ "Extract", "an", "array", "of", "asset", "tags", "for", "the", "given", "tagname", ".", "Use", "it", "as", "/", "extract", "/", "asset_tags", "or", "/", "extract", "/", "asset_tags", "/", "taxonomy" ]

[ "def", "get_mesh", "(", "sitecol", ",", "complete", "=", "True", ")", ":", "sc", "=", "sitecol", ".", "complete", "if", "complete", "else", "sitecol", "if", "sc", ".", "at_sea_level", "(", ")", ":", "mesh", "=", "numpy", ".", "zeros", "(", "len", "(", "sc", ")", ",", "[", "(", "'lon'", ",", "F64", ")", ",", "(", "'lat'", ",", "F64", ")", "]", ")", "mesh", "[", "'lon'", "]", "=", "sc", ".", "lons", "mesh", "[", "'lat'", "]", "=", "sc", ".", "lats", "else", ":", "mesh", "=", "numpy", ".", "zeros", "(", "len", "(", "sc", ")", ",", "[", "(", "'lon'", ",", "F64", ")", ",", "(", "'lat'", ",", "F64", ")", ",", "(", "'depth'", ",", "F64", ")", "]", ")", "mesh", "[", "'lon'", "]", "=", "sc", ".", "lons", "mesh", "[", "'lat'", "]", "=", "sc", ".", "lats", "mesh", "[", "'depth'", "]", "=", "sc", ".", "depths", "return", "mesh" ]

[ ":", "returns", ":", "a", "lon", "-", "lat", "or", "lon", "-", "lat", "-", "depth", "array", "depending", "if", "the", "site", "collection", "is", "at", "sea", "level", "or", "not" ]

[ "def", "hazard_items", "(", "dic", ",", "mesh", ",", "*", "extras", ",", "*", "*", "kw", ")", ":", "for", "item", "in", "kw", ".", "items", "(", ")", ":", "yield", "item", "arr", "=", "dic", "[", "next", "(", "iter", "(", "dic", ")", ")", "]", "dtlist", "=", "[", "(", "str", "(", "field", ")", ",", "arr", ".", "dtype", ")", "for", "field", "in", "sorted", "(", "dic", ")", "]", "for", "field", ",", "dtype", ",", "values", "in", "extras", ":", "dtlist", ".", "append", "(", "(", "str", "(", "field", ")", ",", "dtype", ")", ")", "array", "=", "numpy", ".", "zeros", "(", "arr", ".", "shape", ",", "dtlist", ")", "for", "field", "in", "dic", ":", "array", "[", "field", "]", "=", "dic", "[", "field", "]", "for", "field", ",", "dtype", ",", "values", "in", "extras", ":", "array", "[", "field", "]", "=", "values", "yield", "'all'", ",", "util", ".", "compose_arrays", "(", "mesh", ",", "array", ")" ]

[ ":", "param", "dic", ":", "dictionary", "of", "arrays", "of", "the", "same", "shape", ":", "param", "mesh", ":", "a", "mesh", "array", "with", "lon", "lat", "fields", "of", "the", "same", "length", ":", "param", "extras", ":", "optional", "triples", "(", "field", "dtype", "values", ")", ":", "param", "kw", ":", "dictionary", "of", "parameters", "(", "like", "investigation_time", ")", ":", "returns", ":", "a", "list", "of", "pairs", "(", "key", "value", ")", "suitable", "for", "storage", "in", ".", "npz", "format" ]

[ "def", "extract_hcurves", "(", "dstore", ",", "what", ")", ":", "info", "=", "get_info", "(", "dstore", ")", "if", "what", "==", "''", ":", "# npz exports for QGIS", "sitecol", "=", "dstore", "[", "'sitecol'", "]", "mesh", "=", "get_mesh", "(", "sitecol", ",", "complete", "=", "False", ")", "dic", "=", "_get_dict", "(", "dstore", ",", "'hcurves-stats'", ",", "info", "[", "'imtls'", "]", ",", "info", "[", "'stats'", "]", ")", "yield", "from", "hazard_items", "(", "dic", ",", "mesh", ",", "investigation_time", "=", "info", "[", "'investigation_time'", "]", ")", "return", "params", "=", "parse", "(", "what", ",", "info", ")", "if", "'imt'", "in", "params", ":", "[", "imt", "]", "=", "params", "[", "'imt'", "]", "slc", "=", "info", "[", "'imtls'", "]", "(", "imt", ")", "else", ":", "slc", "=", "ALL", "sids", "=", "params", ".", "get", "(", "'site_id'", ",", "ALL", ")", "if", "params", "[", "'rlzs'", "]", ":", "dset", "=", "dstore", "[", "'hcurves-rlzs'", "]", "for", "k", "in", "params", "[", "'k'", "]", ":", "yield", "'rlz-%03d'", "%", "k", ",", "hdf5", ".", "extract", "(", "dset", ",", "sids", ",", "k", ",", "slc", ")", "[", ":", ",", "0", "]", "else", ":", "dset", "=", "dstore", "[", "'hcurves-stats'", "]", "stats", "=", "list", "(", "info", "[", "'stats'", "]", ")", "for", "k", "in", "params", "[", "'k'", "]", ":", "yield", "stats", "[", "k", "]", ",", "hdf5", ".", "extract", "(", "dset", ",", "sids", ",", "k", ",", "slc", ")", "[", ":", ",", "0", "]", "yield", "from", "params", ".", "items", "(", ")" ]

[ "Extracts", "hazard", "curves", ".", "Use", "it", "as", "/", "extract", "/", "hcurves?kind", "=", "mean", "or", "/", "extract", "/", "hcurves?kind", "=", "rlz", "-", "0", "/", "extract", "/", "hcurves?kind", "=", "stats", "/", "extract", "/", "hcurves?kind", "=", "rlzs", "etc" ]

[ "def", "extract_hmaps", "(", "dstore", ",", "what", ")", ":", "info", "=", "get_info", "(", "dstore", ")", "if", "what", "==", "''", ":", "# npz exports for QGIS", "sitecol", "=", "dstore", "[", "'sitecol'", "]", "mesh", "=", "get_mesh", "(", "sitecol", ",", "complete", "=", "False", ")", "dic", "=", "_get_dict", "(", "dstore", ",", "'hmaps-stats'", ",", "{", "imt", ":", "info", "[", "'poes'", "]", "for", "imt", "in", "info", "[", "'imtls'", "]", "}", ",", "info", "[", "'stats'", "]", ")", "yield", "from", "hazard_items", "(", "dic", ",", "mesh", ",", "investigation_time", "=", "info", "[", "'investigation_time'", "]", ")", "return", "params", "=", "parse", "(", "what", ",", "info", ")", "if", "'imt'", "in", "params", ":", "[", "imt", "]", "=", "params", "[", "'imt'", "]", "m", "=", "info", "[", "'imt'", "]", "[", "imt", "]", "s", "=", "slice", "(", "m", ",", "m", "+", "1", ")", "else", ":", "s", "=", "ALL", "if", "params", "[", "'rlzs'", "]", ":", "dset", "=", "dstore", "[", "'hmaps-rlzs'", "]", "for", "k", "in", "params", "[", "'k'", "]", ":", "yield", "'rlz-%03d'", "%", "k", ",", "hdf5", ".", "extract", "(", "dset", ",", "ALL", ",", "k", ",", "s", ",", "ALL", ")", "[", ":", ",", "0", "]", "else", ":", "dset", "=", "dstore", "[", "'hmaps-stats'", "]", "stats", "=", "list", "(", "info", "[", "'stats'", "]", ")", "for", "k", "in", "params", "[", "'k'", "]", ":", "yield", "stats", "[", "k", "]", ",", "hdf5", ".", "extract", "(", "dset", ",", "ALL", ",", "k", ",", "s", ",", "ALL", ")", "[", ":", ",", "0", "]", "yield", "from", "params", ".", "items", "(", ")" ]

[ "Extracts", "hazard", "maps", ".", "Use", "it", "as", "/", "extract", "/", "hmaps?imt", "=", "PGA" ]

[ "def", "extract_uhs", "(", "dstore", ",", "what", ")", ":", "info", "=", "get_info", "(", "dstore", ")", "if", "what", "==", "''", ":", "# npz exports for QGIS", "sitecol", "=", "dstore", "[", "'sitecol'", "]", "mesh", "=", "get_mesh", "(", "sitecol", ",", "complete", "=", "False", ")", "dic", "=", "{", "}", "for", "stat", ",", "s", "in", "info", "[", "'stats'", "]", ".", "items", "(", ")", ":", "hmap", "=", "dstore", "[", "'hmaps-stats'", "]", "[", ":", ",", "s", "]", "dic", "[", "stat", "]", "=", "calc", ".", "make_uhs", "(", "hmap", ",", "info", ")", "yield", "from", "hazard_items", "(", "dic", ",", "mesh", ",", "investigation_time", "=", "info", "[", "'investigation_time'", "]", ")", "return", "params", "=", "parse", "(", "what", ",", "info", ")", "periods", "=", "[", "]", "for", "m", ",", "imt", "in", "enumerate", "(", "info", "[", "'imtls'", "]", ")", ":", "if", "imt", "==", "'PGA'", "or", "imt", ".", "startswith", "(", "'SA'", ")", ":", "periods", ".", "append", "(", "m", ")", "if", "'site_id'", "in", "params", ":", "sids", "=", "params", "[", "'site_id'", "]", "else", ":", "sids", "=", "ALL", "if", "params", "[", "'rlzs'", "]", ":", "dset", "=", "dstore", "[", "'hmaps-rlzs'", "]", "for", "k", "in", "params", "[", "'k'", "]", ":", "yield", "(", "'rlz-%03d'", "%", "k", ",", "hdf5", ".", "extract", "(", "dset", ",", "sids", ",", "k", ",", "periods", ",", "ALL", ")", "[", ":", ",", "0", "]", ")", "else", ":", "dset", "=", "dstore", "[", "'hmaps-stats'", "]", "stats", "=", "list", "(", "info", "[", "'stats'", "]", ")", "for", "k", "in", "params", "[", "'k'", "]", ":", "yield", "stats", "[", "k", "]", ",", "hdf5", ".", "extract", "(", "dset", ",", "sids", ",", "k", ",", "periods", ",", "ALL", ")", "[", ":", ",", "0", "]", "yield", "from", "params", ".", "items", "(", ")" ]

[ "Extracts", "uniform", "hazard", "spectra", ".", "Use", "it", "as", "/", "extract", "/", "uhs?kind", "=", "mean", "or", "/", "extract", "/", "uhs?kind", "=", "rlz", "-", "0", "etc" ]

[ "def", "extract_agg_curves", "(", "dstore", ",", "what", ")", ":", "from", "openquake", ".", "calculators", ".", "export", ".", "loss_curves", "import", "get_loss_builder", "oq", "=", "dstore", "[", "'oqparam'", "]", "loss_type", ",", "tags", "=", "get_loss_type_tags", "(", "what", ")", "if", "'curves-stats'", "in", "dstore", ":", "# event_based_risk", "losses", "=", "_get_curves", "(", "dstore", "[", "'curves-stats'", "]", ",", "oq", ".", "lti", "[", "loss_type", "]", ")", "stats", "=", "dstore", "[", "'curves-stats'", "]", ".", "attrs", "[", "'stats'", "]", "elif", "'curves-rlzs'", "in", "dstore", ":", "# event_based_risk, 1 rlz", "losses", "=", "_get_curves", "(", "dstore", "[", "'curves-rlzs'", "]", ",", "oq", ".", "lti", "[", "loss_type", "]", ")", "assert", "losses", ".", "shape", "[", "1", "]", "==", "1", ",", "'There must be a single realization'", "stats", "=", "[", "b'mean'", "]", "# suitable to be stored as hdf5 attribute", "else", ":", "raise", "KeyError", "(", "'No curves found in %s'", "%", "dstore", ")", "res", "=", "_filter_agg", "(", "dstore", "[", "'assetcol'", "]", ",", "losses", ",", "tags", ",", "stats", ")", "cc", "=", "dstore", "[", "'assetcol/cost_calculator'", "]", "res", ".", "units", "=", "cc", ".", "get_units", "(", "loss_types", "=", "[", "loss_type", "]", ")", "res", ".", "return_periods", "=", "get_loss_builder", "(", "dstore", ")", ".", "return_periods", "return", "res" ]

[ "Aggregate", "loss", "curves", "of", "the", "given", "loss", "type", "and", "tags", "for", "event", "based", "risk", "calculations", ".", "Use", "it", "as", "/", "extract", "/", "agg_curves", "/", "structural?taxonomy", "=", "RC&zipcode", "=", "20126", ":", "returns", ":", "array", "of", "shape", "(", "S", "P", ")", "being", "P", "the", "number", "of", "return", "periods", "and", "S", "the", "number", "of", "statistics" ]

[ "def", "extract_agg_losses", "(", "dstore", ",", "what", ")", ":", "loss_type", ",", "tags", "=", "get_loss_type_tags", "(", "what", ")", "if", "not", "loss_type", ":", "raise", "ValueError", "(", "'loss_type not passed in agg_losses/<loss_type>'", ")", "l", "=", "dstore", "[", "'oqparam'", "]", ".", "lti", "[", "loss_type", "]", "if", "'losses_by_asset'", "in", "dstore", ":", "# scenario_risk", "stats", "=", "None", "losses", "=", "dstore", "[", "'losses_by_asset'", "]", "[", ":", ",", ":", ",", "l", "]", "[", "'mean'", "]", "elif", "'avg_losses-stats'", "in", "dstore", ":", "# event_based_risk, classical_risk", "stats", "=", "dstore", "[", "'avg_losses-stats'", "]", ".", "attrs", "[", "'stats'", "]", "losses", "=", "dstore", "[", "'avg_losses-stats'", "]", "[", ":", ",", ":", ",", "l", "]", "elif", "'avg_losses-rlzs'", "in", "dstore", ":", "# event_based_risk, classical_risk", "stats", "=", "[", "b'mean'", "]", "losses", "=", "dstore", "[", "'avg_losses-rlzs'", "]", "[", ":", ",", ":", ",", "l", "]", "else", ":", "raise", "KeyError", "(", "'No losses found in %s'", "%", "dstore", ")", "return", "_filter_agg", "(", "dstore", "[", "'assetcol'", "]", ",", "losses", ",", "tags", ",", "stats", ")" ]

[ "Aggregate", "losses", "of", "the", "given", "loss", "type", "and", "tags", ".", "Use", "it", "as", "/", "extract", "/", "agg_losses", "/", "structural?taxonomy", "=", "RC&zipcode", "=", "20126", "/", "extract", "/", "agg_losses", "/", "structural?taxonomy", "=", "RC&zipcode", "=", "*" ]

[ "def", "extract_agg_damages", "(", "dstore", ",", "what", ")", ":", "loss_type", ",", "tags", "=", "get_loss_type_tags", "(", "what", ")", "if", "'dmg_by_asset'", "in", "dstore", ":", "# scenario_damage", "lti", "=", "dstore", "[", "'oqparam'", "]", ".", "lti", "[", "loss_type", "]", "losses", "=", "dstore", "[", "'dmg_by_asset'", "]", "[", ":", ",", ":", ",", "lti", ",", "0", "]", "else", ":", "raise", "KeyError", "(", "'No damages found in %s'", "%", "dstore", ")", "return", "_filter_agg", "(", "dstore", "[", "'assetcol'", "]", ",", "losses", ",", "tags", ")" ]

[ "Aggregate", "damages", "of", "the", "given", "loss", "type", "and", "tags", ".", "Use", "it", "as", "/", "extract", "/", "agg_damages", "/", "structural?taxonomy", "=", "RC&zipcode", "=", "20126" ]

[ "def", "extract_aggregate", "(", "dstore", ",", "what", ")", ":", "name", ",", "qstring", "=", "what", ".", "split", "(", "'?'", ",", "1", ")", "info", "=", "get_info", "(", "dstore", ")", "qdic", "=", "parse", "(", "qstring", ",", "info", ")", "suffix", "=", "'-rlzs'", "if", "qdic", "[", "'rlzs'", "]", "else", "'-stats'", "tagnames", "=", "qdic", ".", "get", "(", "'tag'", ",", "[", "]", ")", "assetcol", "=", "dstore", "[", "'assetcol'", "]", "ltypes", "=", "qdic", ".", "get", "(", "'loss_type'", ",", "[", "]", ")", "if", "ltypes", ":", "array", "=", "dstore", "[", "name", "+", "suffix", "]", "[", ":", ",", "qdic", "[", "'k'", "]", "[", "0", "]", ",", "ltypes", "[", "0", "]", "]", "else", ":", "array", "=", "dstore", "[", "name", "+", "suffix", "]", "[", ":", ",", "qdic", "[", "'k'", "]", "[", "0", "]", "]", "aw", "=", "ArrayWrapper", "(", "assetcol", ".", "aggregate_by", "(", "tagnames", ",", "array", ")", ",", "{", "}", ")", "for", "tagname", "in", "tagnames", ":", "setattr", "(", "aw", ",", "tagname", ",", "getattr", "(", "assetcol", ".", "tagcol", ",", "tagname", ")", ")", "aw", ".", "tagnames", "=", "encode", "(", "tagnames", ")", "if", "not", "ltypes", ":", "aw", ".", "extra", "=", "(", "'loss_type'", ",", ")", "+", "tuple", "(", "info", "[", "'loss_types'", "]", ")", "return", "aw" ]

[ "/", "extract", "/", "aggregate", "/", "avg_losses?", "kind", "=", "mean&loss_type", "=", "structural&tag", "=", "taxonomy&tag", "=", "occupancy" ]

[ "def", "build_damage_dt", "(", "dstore", ",", "mean_std", "=", "True", ")", ":", "oq", "=", "dstore", "[", "'oqparam'", "]", "damage_states", "=", "[", "'no_damage'", "]", "+", "list", "(", "dstore", ".", "get_attr", "(", "'risk_model'", ",", "'limit_states'", ")", ")", "dt_list", "=", "[", "]", "for", "ds", "in", "damage_states", ":", "ds", "=", "str", "(", "ds", ")", "if", "mean_std", ":", "dt_list", ".", "append", "(", "(", "'%s_mean'", "%", "ds", ",", "F32", ")", ")", "dt_list", ".", "append", "(", "(", "'%s_stdv'", "%", "ds", ",", "F32", ")", ")", "else", ":", "dt_list", ".", "append", "(", "(", "ds", ",", "F32", ")", ")", "damage_dt", "=", "numpy", ".", "dtype", "(", "dt_list", ")", "loss_types", "=", "oq", ".", "loss_dt", "(", ")", ".", "names", "return", "numpy", ".", "dtype", "(", "[", "(", "lt", ",", "damage_dt", ")", "for", "lt", "in", "loss_types", "]", ")" ]

[ ":", "param", "dstore", ":", "a", "datastore", "instance", ":", "param", "mean_std", ":", "a", "flag", "(", "default", "True", ")", ":", "returns", ":", "a", "composite", "dtype", "loss_type", "-", ">", "(", "mean_ds1", "stdv_ds1", "...", ")", "or", "loss_type", "-", ">", "(", "ds1", "ds2", "...", ")", "depending", "on", "the", "flag", "mean_std" ]

[ "def", "build_damage_array", "(", "data", ",", "damage_dt", ")", ":", "A", ",", "L", ",", "MS", ",", "D", "=", "data", ".", "shape", "dmg", "=", "numpy", ".", "zeros", "(", "A", ",", "damage_dt", ")", "for", "a", "in", "range", "(", "A", ")", ":", "for", "l", ",", "lt", "in", "enumerate", "(", "damage_dt", ".", "names", ")", ":", "std", "=", "any", "(", "f", "for", "f", "in", "damage_dt", "[", "lt", "]", ".", "names", "if", "f", ".", "endswith", "(", "'_stdv'", ")", ")", "if", "MS", "==", "1", "or", "not", "std", ":", "# there is only the mean value", "dmg", "[", "lt", "]", "[", "a", "]", "=", "tuple", "(", "data", "[", "a", ",", "l", ",", "0", "]", ")", "else", ":", "# there are both mean and stddev", "# data[a, l].T has shape (D, 2)", "dmg", "[", "lt", "]", "[", "a", "]", "=", "tuple", "(", "numpy", ".", "concatenate", "(", "data", "[", "a", ",", "l", "]", ".", "T", ")", ")", "return", "dmg" ]

[ ":", "param", "data", ":", "an", "array", "of", "shape", "(", "A", "L", "1", "D", ")", "or", "(", "A", "L", "2", "D", ")", ":", "param", "damage_dt", ":", "a", "damage", "composite", "data", "type", "loss_type", "-", ">", "states", ":", "returns", ":", "a", "composite", "array", "of", "length", "N", "and", "dtype", "damage_dt" ]

[ "def", "extract_mfd", "(", "dstore", ",", "what", ")", ":", "dd", "=", "collections", ".", "defaultdict", "(", "int", ")", "for", "rup", "in", "dstore", "[", "'ruptures'", "]", ".", "value", ":", "dd", "[", "rup", "[", "'mag'", "]", "]", "+=", "1", "dt", "=", "numpy", ".", "dtype", "(", "[", "(", "'mag'", ",", "float", ")", ",", "(", "'freq'", ",", "int", ")", "]", ")", "magfreq", "=", "numpy", ".", "array", "(", "sorted", "(", "dd", ".", "items", "(", ")", ",", "key", "=", "operator", ".", "itemgetter", "(", "0", ")", ")", ",", "dt", ")", "return", "magfreq" ]

[ "Display", "num_ruptures", "by", "magnitude", "for", "event", "based", "calculations", ".", "Example", ":", "http", ":", "//", "127", ".", "0", ".", "0", ".", "1", ":", "8800", "/", "v1", "/", "calc", "/", "30", "/", "extract", "/", "event_based_mfd" ]

[ "def", "extract_src_loss_table", "(", "dstore", ",", "loss_type", ")", ":", "oq", "=", "dstore", "[", "'oqparam'", "]", "li", "=", "oq", ".", "lti", "[", "loss_type", "]", "source_ids", "=", "dstore", "[", "'source_info'", "]", "[", "'source_id'", "]", "idxs", "=", "dstore", "[", "'ruptures'", "]", ".", "value", "[", "[", "'srcidx'", ",", "'grp_id'", "]", "]", "losses", "=", "dstore", "[", "'rup_loss_table'", "]", "[", ":", ",", "li", "]", "slt", "=", "numpy", ".", "zeros", "(", "len", "(", "source_ids", ")", ",", "[", "(", "'grp_id'", ",", "U32", ")", ",", "(", "loss_type", ",", "F32", ")", "]", ")", "for", "loss", ",", "(", "srcidx", ",", "grp_id", ")", "in", "zip", "(", "losses", ",", "idxs", ")", ":", "slt", "[", "srcidx", "]", "[", "loss_type", "]", "+=", "loss", "slt", "[", "srcidx", "]", "[", "'grp_id'", "]", "=", "grp_id", "slt", "=", "util", ".", "compose_arrays", "(", "source_ids", ",", "slt", ",", "'source_id'", ")", "slt", ".", "sort", "(", "order", "=", "loss_type", ")", "return", "slt", "[", ":", ":", "-", "1", "]" ]

[ "Extract", "the", "source", "loss", "table", "for", "a", "give", "loss", "type", "ordered", "in", "decreasing", "order", ".", "Example", ":", "http", ":", "//", "127", ".", "0", ".", "0", ".", "1", ":", "8800", "/", "v1", "/", "calc", "/", "30", "/", "extract", "/", "src_loss_table", "/", "structural" ]

[ "def", "extract_mean_std_curves", "(", "dstore", ",", "what", ")", ":", "getter", "=", "getters", ".", "PmapGetter", "(", "dstore", ")", "arr", "=", "getter", ".", "get_mean", "(", ")", ".", "array", "for", "imt", "in", "getter", ".", "imtls", ":", "yield", "'imls/'", "+", "imt", ",", "getter", ".", "imtls", "[", "imt", "]", "yield", "'poes/'", "+", "imt", ",", "arr", "[", ":", ",", "getter", ".", "imtls", "(", "imt", ")", "]" ]

[ "Yield", "imls", "/", "IMT", "and", "poes", "/", "IMT", "containg", "mean", "and", "stddev", "for", "all", "sites" ]

[ "def", "losses_by_tag", "(", "dstore", ",", "tag", ")", ":", "dt", "=", "[", "(", "tag", ",", "vstr", ")", "]", "+", "dstore", "[", "'oqparam'", "]", ".", "loss_dt_list", "(", ")", "aids", "=", "dstore", "[", "'assetcol/array'", "]", "[", "tag", "]", "dset", ",", "stats", "=", "_get", "(", "dstore", ",", "'avg_losses'", ")", "arr", "=", "dset", ".", "value", "tagvalues", "=", "dstore", "[", "'assetcol/tagcol/'", "+", "tag", "]", "[", "1", ":", "]", "# except tagvalue=\"?\"", "for", "s", ",", "stat", "in", "enumerate", "(", "stats", ")", ":", "out", "=", "numpy", ".", "zeros", "(", "len", "(", "tagvalues", ")", ",", "dt", ")", "for", "li", ",", "(", "lt", ",", "lt_dt", ")", "in", "enumerate", "(", "dt", "[", "1", ":", "]", ")", ":", "for", "i", ",", "tagvalue", "in", "enumerate", "(", "tagvalues", ")", ":", "out", "[", "i", "]", "[", "tag", "]", "=", "tagvalue", "counts", "=", "arr", "[", "aids", "==", "i", "+", "1", ",", "s", ",", "li", "]", ".", "sum", "(", ")", "if", "counts", ":", "out", "[", "i", "]", "[", "lt", "]", "=", "counts", "yield", "stat", ",", "out" ]

[ "Statistical", "average", "losses", "by", "tag", ".", "For", "instance", "call" ]

[ "def", "extract_rupture", "(", "dstore", ",", "serial", ")", ":", "ridx", "=", "list", "(", "dstore", "[", "'ruptures'", "]", "[", "'serial'", "]", ")", ".", "index", "(", "int", "(", "serial", ")", ")", "[", "getter", "]", "=", "getters", ".", "gen_rupture_getters", "(", "dstore", ",", "slice", "(", "ridx", ",", "ridx", "+", "1", ")", ")", "yield", "from", "getter", ".", "get_rupdict", "(", ")", ".", "items", "(", ")" ]

[ "Extract", "information", "about", "the", "given", "event", "index", ".", "Example", ":", "http", ":", "//", "127", ".", "0", ".", "0", ".", "1", ":", "8800", "/", "v1", "/", "calc", "/", "30", "/", "extract", "/", "rupture", "/", "1066" ]

[ "def", "extract_event_info", "(", "dstore", ",", "eidx", ")", ":", "event", "=", "dstore", "[", "'events'", "]", "[", "int", "(", "eidx", ")", "]", "serial", "=", "int", "(", "event", "[", "'eid'", "]", "//", "TWO32", ")", "ridx", "=", "list", "(", "dstore", "[", "'ruptures'", "]", "[", "'serial'", "]", ")", ".", "index", "(", "serial", ")", "[", "getter", "]", "=", "getters", ".", "gen_rupture_getters", "(", "dstore", ",", "slice", "(", "ridx", ",", "ridx", "+", "1", ")", ")", "rupdict", "=", "getter", ".", "get_rupdict", "(", ")", "rlzi", "=", "event", "[", "'rlz'", "]", "rlzs_assoc", "=", "dstore", "[", "'csm_info'", "]", ".", "get_rlzs_assoc", "(", ")", "gsim", "=", "rlzs_assoc", ".", "gsim_by_trt", "[", "rlzi", "]", "[", "rupdict", "[", "'trt'", "]", "]", "for", "key", ",", "val", "in", "rupdict", ".", "items", "(", ")", ":", "yield", "key", ",", "val", "yield", "'rlzi'", ",", "rlzi", "yield", "'gsim'", ",", "repr", "(", "gsim", ")" ]

[ "Extract", "information", "about", "the", "given", "event", "index", ".", "Example", ":", "http", ":", "//", "127", ".", "0", ".", "0", ".", "1", ":", "8800", "/", "v1", "/", "calc", "/", "30", "/", "extract", "/", "event_info", "/", "0" ]

[ "def", "get_ruptures_within", "(", "dstore", ",", "bbox", ")", ":", "minlon", ",", "minlat", ",", "maxlon", ",", "maxlat", "=", "map", "(", "float", ",", "bbox", ".", "split", "(", "','", ")", ")", "hypo", "=", "dstore", "[", "'ruptures'", "]", "[", "'hypo'", "]", ".", "T", "# shape (3, N)", "mask", "=", "(", "(", "minlon", "<=", "hypo", "[", "0", "]", ")", "*", "(", "minlat", "<=", "hypo", "[", "1", "]", ")", "*", "(", "maxlon", ">=", "hypo", "[", "0", "]", ")", "*", "(", "maxlat", ">=", "hypo", "[", "1", "]", ")", ")", "return", "dstore", "[", "'ruptures'", "]", "[", "mask", "]" ]

[ "Extract", "the", "ruptures", "within", "the", "given", "bounding", "box", "a", "string", "minlon", "minlat", "maxlon", "maxlat", ".", "Example", ":", "http", ":", "//", "127", ".", "0", ".", "0", ".", "1", ":", "8800", "/", "v1", "/", "calc", "/", "30", "/", "extract", "/", "ruptures_with", "/", "8", "44", "10", "46" ]

[ "def", "extract_source_geom", "(", "dstore", ",", "srcidxs", ")", ":", "for", "i", "in", "srcidxs", ".", "split", "(", "','", ")", ":", "rec", "=", "dstore", "[", "'source_info'", "]", "[", "int", "(", "i", ")", "]", "geom", "=", "dstore", "[", "'source_geom'", "]", "[", "rec", "[", "'gidx1'", "]", ":", "rec", "[", "'gidx2'", "]", "]", "yield", "rec", "[", "'source_id'", "]", ",", "geom" ]

[ "Extract", "the", "geometry", "of", "a", "given", "sources", "Example", ":", "http", ":", "//", "127", ".", "0", ".", "0", ".", "1", ":", "8800", "/", "v1", "/", "calc", "/", "30", "/", "extract", "/", "source_geom", "/", "1", "2", "3" ]

[ "def", "get", "(", "self", ",", "what", ")", ":", "url", "=", "'%s/v1/calc/%d/extract/%s'", "%", "(", "self", ".", "server", ",", "self", ".", "calc_id", ",", "what", ")", "logging", ".", "info", "(", "'GET %s'", ",", "url", ")", "resp", "=", "self", ".", "sess", ".", "get", "(", "url", ")", "if", "resp", ".", "status_code", "!=", "200", ":", "raise", "WebAPIError", "(", "resp", ".", "text", ")", "npz", "=", "numpy", ".", "load", "(", "io", ".", "BytesIO", "(", "resp", ".", "content", ")", ")", "attrs", "=", "{", "k", ":", "npz", "[", "k", "]", "for", "k", "in", "npz", "if", "k", "!=", "'array'", "}", "try", ":", "arr", "=", "npz", "[", "'array'", "]", "except", "KeyError", ":", "arr", "=", "(", ")", "return", "ArrayWrapper", "(", "arr", ",", "attrs", ")" ]

[ ":", "param", "what", ":", "what", "to", "extract", ":", "returns", ":", "an", "ArrayWrapper", "instance" ]

[ "def", "dump", "(", "self", ",", "fname", ")", ":", "url", "=", "'%s/v1/calc/%d/datastore'", "%", "(", "self", ".", "server", ",", "self", ".", "calc_id", ")", "resp", "=", "self", ".", "sess", ".", "get", "(", "url", ",", "stream", "=", "True", ")", "down", "=", "0", "with", "open", "(", "fname", ",", "'wb'", ")", "as", "f", ":", "logging", ".", "info", "(", "'Saving %s'", ",", "fname", ")", "for", "chunk", "in", "resp", ".", "iter_content", "(", "CHUNKSIZE", ")", ":", "f", ".", "write", "(", "chunk", ")", "down", "+=", "len", "(", "chunk", ")", "println", "(", "'Downloaded {:,} bytes'", ".", "format", "(", "down", ")", ")", "print", "(", ")" ]

[ "Dump", "the", "remote", "datastore", "on", "a", "local", "path", "." ]