def point_node(self, loc):
"""
:param loc: a location object with attributes x and y
:returns: a `gml:Point` node
"""
return Node('gml:Point',
nodes=[Node('gml:pos', text='%s %s' % (loc.x, loc.y))])
def dd_node_taxo(self, taxonomy, means, stddevs):
"""
:param taxonomy: taxonomy string
:param means: array of means, one per damage state
:param stddevs: array of stddevs, one per damage state
:returns: a `DDNode` node
"""
taxonomy = Node('taxonomy', text=taxonomy)
dd = Node('DDNode',
nodes=[taxonomy] + self.damage_nodes(means, stddevs))
return dd
def cm_node(self, loc, asset_refs, means, stddevs):
"""
:param loc: a location object with attributes x and y
:param asset_refs: asset reference strings
:param means: array of means, one per asset
:param stddevs: array of stddevs, one per asset
:returns: a `CMNode` node
"""
cm = Node('CMNode', nodes=[self.point_node(loc)])
for asset_ref, mean, stddev in zip(asset_refs, means, stddevs):
cf = Node('cf', dict(assetRef=asset_ref, mean=mean, stdDev=stddev))
cm.append(cf)
return cm
def dmg_dist_total_node(self, data):
"""
:param data: a sequence of records with attributes .dmg_state,
.mean and .stddev
:returns: a `totalDmgDist` node
"""
total = Node('totalDmgDist', nodes=[self.dmg_states])
for row in sorted(data, key=lambda r: r.dmg_state.lsi):
damage = Node('damage',
dict(ds=row.dmg_state.dmg_state, mean=row.mean,
stddev=row.stddev))
total.append(damage)
return total
def dmg_dist_per_asset_node(self, data):
"""
:param data: a sequence of records with attributes .exposure_data,
.mean and .stddev
:returns: a `dmgDistPerAsset` node
"""
node = Node('dmgDistPerAsset', nodes=[self.dmg_states])
data_by_location = groupby(data, lambda r: r.exposure_data.site)
for loc in data_by_location:
dd = Node('DDNode', nodes=[self.point_node(loc)])
data_by_asset = groupby(
data_by_location[loc], lambda r: r.exposure_data.asset_ref,
lambda rows: [(r.mean, r.stddev) for r in rows])
for asset_ref, data in data_by_asset.items():
means, stddevs = zip(*data)
dd.append(self.asset_node(asset_ref, means, stddevs))
node.append(dd)
return node
def asset_node(self, asset_ref, means, stddevs):
"""
:param asset_ref: asset reference string
:param means: array of means, one per damage state
:param stddevs: array of stddevs, one per damage state
:returns: an `asset` node
"""
return Node('asset', dict(assetRef=asset_ref),
nodes=self.damage_nodes(means, stddevs))
def damage_nodes(self, means, stddevs):
"""
:param means: array of means, one per damage state
:param stddevs: array of stddevs, one per damage state
:returns: a list of `damage` nodes
"""
nodes = []
for dmg_state, mean, stddev in zip(self.damage_states, means, stddevs):
nodes.append(
Node('damage',
dict(ds=dmg_state.dmg_state, mean=mean, stddev=stddev)))
return nodes
def dmg_dist_per_taxonomy_node(self, data):
"""
:param data: a sequence of records with attributes .taxonomy,
.mean and .stddev
:returns: a `dmgDistPerTaxonomy` node
"""
node = Node('dmgDistPerTaxonomy', nodes=[self.dmg_states])
data_by_taxo = groupby(data, operator.attrgetter('taxonomy'))
for taxonomy in data_by_taxo:
means = [row.mean for row in data_by_taxo[taxonomy]]
stddevs = [row.stddev for row in data_by_taxo[taxonomy]]
node.append(self.dd_node_taxo(taxonomy, means, stddevs))
return node
def write(nodes, output=sys.stdout, fmt='%8.4E'):
"""
Convert nodes into a NRML file. output must be a file
object open in write mode. If you want to perform a
consistency check, open it in read-write mode, then it will
be read after creation and validated.
:params nodes: an iterable over Node objects
:params output: a file-like object in write or read-write mode
"""
root = Node('nrml', nodes=nodes)
with writers.floatformat(fmt):
node_to_xml(root, output, {NRML05: '', GML_NAMESPACE: 'gml:'})
if hasattr(output, 'mode') and '+' in output.mode: # read-write mode
output.seek(0)
read(output) # validate the written file
def collapse_map_node(self, data):
"""
:param data: a sequence of records with attributes .exposure_data,
.mean and .stddev
:returns: a `dmgDistPerAsset` node
"""
node = Node('collapseMap')
data_by_location = groupby(data, lambda r: r.exposure_data.site)
for loc in data_by_location:
asset_refs = []
means = []
stddevs = []
for row in sorted(data_by_location[loc],
key=lambda r: r.exposure_data.asset_ref):
asset_refs.append(row.exposure_data.asset_ref)
means.append(row.mean)
stddevs.append(row.stddev)
node.append(self.cm_node(loc, asset_refs, means, stddevs))
return node
def __init__(self, damage_states):
self.damage_states = damage_states
self.dmg_states = Node('damageStates',
text=' '.join(ds.dmg_state
for ds in damage_states))
