def read(source, chatty=True):
"""
Convert a NRML file into a validated LiteralNode object. Keeps
the entire tree in memory.
:param source:
a file name or file object open for reading
"""
nrml = xmlparse(source).getroot()
assert striptag(nrml.tag) == 'nrml', nrml.tag
# extract the XML namespace URL ('http://openquake.org/xmlns/nrml/0.5')
xmlns = nrml.tag.split('}')[0][1:]
if xmlns != NRML05 and chatty:
# for the moment NRML04 is still supported, so we hide the warning
logging.debug('%s is at an outdated version: %s', source, xmlns)
subnodes = []
for elem in nrml:
nodecls = nodefactory[striptag(elem.tag)]
try:
subnodes.append(node_from_elem(elem, nodecls))
except ValueError as exc:
raise ValueError('%s of %s' % (exc, source))
return LiteralNode(
'nrml', {'xmlns': xmlns, 'xmlns:gml': GML_NAMESPACE},
nodes=subnodes)
def read(source, chatty=True):
"""
Convert a NRML file into a validated LiteralNode object. Keeps
the entire tree in memory.
:param source:
a file name or file object open for reading
"""
nrml = xmlparse(source).getroot()
assert striptag(nrml.tag) == 'nrml', nrml.tag
# extract the XML namespace URL ('http://openquake.org/xmlns/nrml/0.5')
xmlns = nrml.tag.split('}')[0][1:]
if xmlns != NRML05 and chatty:
# for the moment NRML04 is still supported, so we hide the warning
logging.debug('%s is at an outdated version: %s', source, xmlns)
subnodes = []
for elem in nrml:
nodecls = nodefactory[striptag(elem.tag)]
try:
subnodes.append(node_from_elem(elem, nodecls))
except ValueError as exc:
raise ValueError('%s of %s' % (exc, source))
return LiteralNode(
'nrml', {'xmlns': xmlns, 'xmlns:gml': GML_NAMESPACE},
nodes=subnodes)
def upgrade_file(path):
"""Upgrade to the latest NRML version"""
node0 = nrml.read(path, chatty=False)[0]
shutil.copy(path, path + '.bak') # make a backup of the original file
tag = striptag(node0.tag)
gml = True
if tag == 'vulnerabilityModel':
vf_dict, cat_dict = get_vulnerability_functions_04(path)
# below I am converting into a NRML 0.5 vulnerabilityModel
node0 = Node(
'vulnerabilityModel', cat_dict,
nodes=list(map(riskmodels.obj_to_node, vf_dict.values())))
gml = False
elif tag == 'fragilityModel':
node0 = riskmodels.convert_fragility_model_04(
nrml.read(path)[0], path)
gml = False
elif tag == 'sourceModel':
node0 = nrml.read(path)[0]
dic = groupby(node0.nodes, operator.itemgetter('tectonicRegion'))
node0.nodes = [Node('sourceGroup',
dict(tectonicRegion=trt, name="group %s" % i),
nodes=srcs)
for i, (trt, srcs) in enumerate(dic.items(), 1)]
with open(path, 'w') as f:
nrml.write([node0], f, gml=gml)
def read_lazy(source, lazytags):
"""
Convert a NRML file into a validated LiteralNode object. The
tree is lazy, i.e. you access nodes by iterating on them.
:param source:
a file name or file object open for reading
:param lazytags:
the name of nodes which subnodes must be read lazily
:returns:
a list of nodes; some of them will contain lazy subnodes
"""
nodes = []
try:
for _, el in iterparse(source, remove_comments=True):
tag = striptag(el.tag)
if tag in nodefactory: # NRML tag
nodes.append(node_from_elem(el, nodefactory[tag], lazy=lazytags))
el.clear() # save memory
except:
etype, exc, tb = sys.exc_info()
msg = str(exc)
if str(source) not in msg:
msg = "%s in %s" % (msg, source)
raise_(etype, msg, tb)
return nodes
def set_params(w, src):
"""
Set source parameters.
"""
params = extract_source_params(src)
# this is done because for characteristic sources geometry is in
# 'surface' attribute
params.update(extract_geometry_params(src))
mfd_pars, rate_pars = extract_mfd_params(src)
params.update(mfd_pars)
params.update(rate_pars)
strikes, dips, rakes, np_weights = extract_source_nodal_planes(src)
params.update(strikes)
params.update(dips)
params.update(rakes)
params.update(np_weights)
hds, hdsw = extract_source_hypocentral_depths(src)
params.update(hds)
params.update(hdsw)
pstrikes, pdips = extract_source_planes_strikes_dips(src)
params.update(pstrikes)
params.update(pdips)
params['sourcetype'] = striptag(src.tag)
w.record(**params)
def read_lazy(source, lazytags):
"""
Convert a NRML file into a validated LiteralNode object. The
tree is lazy, i.e. you access nodes by iterating on them.
:param source:
a file name or file object open for reading
:param lazytags:
the name of nodes which subnodes must be read lazily
:returns:
a list of nodes; some of them will contain lazy subnodes
"""
nodes = []
try:
for _, el in iterparse(source, remove_comments=True):
tag = striptag(el.tag)
if tag in nodefactory: # NRML tag
nodes.append(
node_from_elem(el, nodefactory[tag], lazy=lazytags))
el.clear() # save memory
except:
etype, exc, tb = sys.exc_info()
msg = str(exc)
if str(source) not in msg:
msg = '%s in %s' % (msg, source)
raise_(etype, msg, tb)
return nodes
def read(source, chatty=True):
"""
Convert a NRML file into a validated LiteralNode object. Keeps
the entire tree in memory.
:param source:
a file name or file object open for reading
"""
nrml = parse(source).getroot()
assert striptag(nrml.tag) == "nrml", nrml.tag
# extract the XML namespace URL ('http://openquake.org/xmlns/nrml/0.5')
xmlns = nrml.tag.split("}")[0][1:]
if xmlns != NRML05 and chatty:
logging.warn("%s is at an outdated version: %s", source, xmlns)
subnodes = []
for elem in nrml:
nodecls = nodefactory[striptag(elem.tag)]
subnodes.append(node_from_elem(elem, nodecls))
return LiteralNode("nrml", {"xmlns": xmlns, "xmlns:gml": GML_NAMESPACE}, nodes=subnodes)
def read(source):
"""
Convert a NRML file into a validated LiteralNode object. Keeps
the entire tree in memory.
:param source:
a file name or file object open for reading
"""
nrml = parse(source).getroot()
assert striptag(nrml.tag) == 'nrml', nrml.tag
# extract the XML namespace URL ('http://openquake.org/xmlns/nrml/0.5')
xmlns = nrml.tag.split('}')[0][1:]
subnodes = []
for elem in nrml:
nodecls = nodefactory[striptag(elem.tag)]
subnodes.append(node_from_elem(elem, nodecls))
return LiteralNode(
'nrml', {'xmlns': xmlns, 'xmlns:gml': GML_NAMESPACE},
nodes=subnodes)
def convert_node(self, node):
"""
Convert the given node into a hazardlib source, depending
on the node tag.
:param node: a node representing a source
"""
with context(self.fname, node):
convert_source = getattr(self, 'convert_' + striptag(node.tag))
return convert_source(node)
def convert_node(self, node):
"""
Convert the given node into a hazardlib source, depending
on the node tag.
:param node: a node representing a source
"""
with context(self.fname, node):
convert_source = getattr(self, 'convert_' + striptag(node.tag))
return convert_source(node)
def upgrade_file(path):
"""Upgrade to the latest NRML version"""
node0 = nrml.read(path, chatty=False)[0]
shutil.copy(path, path + '.bak') # make a backup of the original file
if striptag(node0.tag) == 'vulnerabilityModel':
vf_dict, cat_dict = get_vulnerability_functions_04(path)
node0 = LiteralNode(
'vulnerabilityModel', cat_dict,
nodes=list(map(riskmodels.obj_to_node, list(vf_dict.values()))))
with open(path, 'w') as f:
nrml.write([node0], f)
def convert_node(self, node):
"""
Convert the given rupture node into a hazardlib rupture, depending
on the node tag.
:param node: a node representing a rupture
"""
with context(self.fname, node):
convert_rupture = getattr(self, 'convert_' + striptag(node.tag))
mag = ~node.magnitude
rake = ~node.rake
hypocenter = ~node.hypocenter
return convert_rupture(node, mag, rake, hypocenter)
def convert_node(self, node):
"""
Convert the given rupture node into a hazardlib rupture, depending
on the node tag.
:param node: a node representing a rupture
"""
with context(self.fname, node):
convert_rupture = getattr(self, 'convert_' + striptag(node.tag))
mag = ~node.magnitude
rake = ~node.rake
h = node.hypocenter
hypocenter = geo.Point(h['lon'], h['lat'], h['depth'])
return convert_rupture(node, mag, rake, hypocenter)
def convert_node(self, node):
"""
Convert the given rupture node into a hazardlib rupture, depending
on the node tag.
:param node: a node representing a rupture
"""
with context(self.fname, node):
convert_rupture = getattr(self, "convert_" + striptag(node.tag))
mag = ~node.magnitude
rake = ~node.rake
h = node.hypocenter
hypocenter = geo.Point(h["lon"], h["lat"], h["depth"])
return convert_rupture(node, mag, rake, hypocenter)
def read(source, chatty=True):
"""
Convert a NRML file into a validated LiteralNode object. Keeps
the entire tree in memory.
:param source:
a file name or file object open for reading
"""
nrml = parse(source).getroot()
assert striptag(nrml.tag) == 'nrml', nrml.tag
# extract the XML namespace URL ('http://openquake.org/xmlns/nrml/0.5')
xmlns = nrml.tag.split('}')[0][1:]
if xmlns != NRML05 and chatty:
logging.warn('%s is at an outdated version: %s', source, xmlns)
subnodes = []
for elem in nrml:
nodecls = nodefactory[striptag(elem.tag)]
subnodes.append(node_from_elem(elem, nodecls))
return LiteralNode('nrml', {
'xmlns': xmlns,
'xmlns:gml': GML_NAMESPACE
},
nodes=subnodes)
def from_node(cls, node):
"""
Return a specialized Converter instance
"""
tag = striptag(node.tag)
name = tag[0].upper() + tag[1:]
clsname = name[:-5] if name.endswith('Model') else name
if 'format' in node.attrib: # for fragility functions
clsname += node['format'].capitalize()
if clsname == 'GmfSet':
clsname = 'GmfCollection'
convertertype = globals()[clsname]
tset = record.TableSet(convertertype)
tset.insert_all(convertertype.node_to_records(node))
return convertertype(tset)
def upgrade_file(path):
"""Upgrade to the latest NRML version"""
node0 = nrml.read(path, chatty=False)[0]
shutil.copy(path, path + '.bak') # make a backup of the original file
tag = striptag(node0.tag)
if tag == 'vulnerabilityModel':
vf_dict, cat_dict = get_vulnerability_functions_04(path)
# below I am converting into a NRML 0.5 vulnerabilityModel
node0 = LiteralNode(
'vulnerabilityModel', cat_dict,
nodes=list(map(riskmodels.obj_to_node, list(vf_dict.values()))))
elif tag == 'fragilityModel':
node0 = riskmodels.convert_fragility_model_04(
nrml.read(path)[0], path)
with open(path, 'w') as f:
nrml.write([node0], f)
def read(source, chatty=True, stop=None):
"""
Convert a NRML file into a validated Node object. Keeps
the entire tree in memory.
:param source:
a file name or file object open for reading
"""
vparser = ValidatingXmlParser(validators, stop)
nrml = vparser.parse_file(source)
assert striptag(nrml.tag) == 'nrml', nrml.tag
# extract the XML namespace URL ('http://openquake.org/xmlns/nrml/0.5')
xmlns = nrml.tag.split('}')[0][1:]
if xmlns != NRML05 and chatty:
# for the moment NRML04 is still supported, so we hide the warning
logging.debug('%s is at an outdated version: %s', source, xmlns)
nrml['xmlns'] = xmlns
nrml['xmlns:gml'] = GML_NAMESPACE
return nrml
def parse_planar_surf(element):
"""
Parse NRML 0.4 'planarSurface' and return class PlanarSurface.
"""
tag_set = [striptag(node.tag) for node in element.nodes]
(top_left, top_right, bottom_left, bottom_right) = tuple(
[element.nodes[tag_set.index(tag)] for tag in PLANAR_TAGS])
# for node in element.nodes:
# if "topLeft" in node.tag:
# top_left = copy(node)
# elif "topRight" in node.tag:
# top_right = copy(node)
# elif "bottomRight" in node.tag:
#
#
# top_left = element.find('%stopLeft' % NRML)
# top_right = element.find('%stopRight' % NRML)
# bottom_left = element.find('%sbottomLeft' % NRML)
# bottom_right = element.find('%sbottomRight' % NRML)
corners_lons = numpy.array(
[float(top_left.attrib['lon']), float(top_right.attrib['lon']),
float(bottom_right.attrib['lon']), float(bottom_left.attrib['lon'])]
)
corners_lats = numpy.array(
[float(top_left.attrib['lat']), float(top_right.attrib['lat']),
float(bottom_right.attrib['lat']), float(bottom_left.attrib['lat'])]
)
corners_depths = numpy.array(
[float(top_left.attrib['depth']), float(top_right.attrib['depth']),
float(bottom_right.attrib['depth']), float(bottom_left.attrib['depth'])]
)
return PlanarSurface(corners_lons, corners_lats, corners_depths)
def parse_planar_surf(element):
"""
Parse NRML 0.4 'planarSurface' and return class PlanarSurface.
"""
tag_set = [striptag(node.tag) for node in element.nodes]
(top_left, top_right, bottom_left, bottom_right) = tuple(
[element.nodes[tag_set.index(tag)] for tag in PLANAR_TAGS])
corners_lons = numpy.array(
[float(top_left.attrib['lon']), float(top_right.attrib['lon']),
float(bottom_right.attrib['lon']), float(bottom_left.attrib['lon'])]
)
corners_lats = numpy.array(
[float(top_left.attrib['lat']), float(top_right.attrib['lat']),
float(bottom_right.attrib['lat']), float(bottom_left.attrib['lat'])]
)
corners_depths = numpy.array(
[float(top_left.attrib['depth']), float(top_right.attrib['depth']),
float(bottom_right.attrib['depth']), float(bottom_left.attrib['depth'])]
)
return PlanarSurface(corners_lons, corners_lats, corners_depths)
def get_taglist(node):
"""
Return a list of tags (with NRML namespace removed) representing the
order of the nodes within a node
"""
return [striptag(subnode.tag) for subnode in node]
