def get_ruptures(self, srcfilter=calc.filters.nofilter, min_mag=0): """ :returns: a list of EBRuptures filtered by bounding box """ ebrs = [] with datastore.read(self.filename) as dstore: rupgeoms = dstore['rupgeoms'] for e0, rec in zip(self.e0, self.rup_array): if rec['mag'] < min_mag: continue if srcfilter.integration_distance: sids = srcfilter.close_sids(rec, self.trt) if len(sids) == 0: # the rupture is far away continue else: sids = None geom = rupgeoms[rec['gidx1']:rec['gidx2']].reshape( rec['sx'], rec['sy']) rupture = get_rupture(rec, geom, self.trt) grp_id = rec['grp_id'] ebr = EBRupture(rupture, rec['srcidx'], grp_id, rec['n_occ'], self.samples) # not implemented: rupture_slip_direction ebr.sids = sids ebr.e0 = 0 if self.e0 is None else e0 ebr.id = rec['id'] # rup_id in the datastore ebrs.append(ebr) return ebrs
def pre_execute(self): """ Read the site collection and initialize GmfComputer and seeds """ oq = self.oqparam cinfo = source.CompositionInfo.fake(readinput.get_gsim_lt(oq)) self.datastore['csm_info'] = cinfo if 'rupture_model' not in oq.inputs: logging.warn('There is no rupture_model, the calculator will just ' 'import data without performing any calculation') super().pre_execute() return self.rup = readinput.get_rupture(oq) self.gsims = readinput.get_gsims(oq) R = len(self.gsims) self.cmaker = ContextMaker(self.gsims, oq.maximum_distance, {'filter_distance': oq.filter_distance}) super().pre_execute() self.datastore['oqparam'] = oq self.rlzs_assoc = cinfo.get_rlzs_assoc() rlzs_by_gsim = self.rlzs_assoc.get_rlzs_by_gsim(0) E = oq.number_of_ground_motion_fields n_occ = numpy.array([E]) ebr = EBRupture(self.rup, 0, 0, self.sitecol.sids, n_occ) events = numpy.zeros(E * R, events_dt) for rlz, eids in ebr.get_eids_by_rlz(rlzs_by_gsim).items(): events[rlz * E:rlz * E + E]['eid'] = eids events[rlz * E:rlz * E + E]['rlz'] = rlz self.datastore['events'] = events rupser = calc.RuptureSerializer(self.datastore) rupser.save(get_rup_array([ebr])) rupser.close() self.computer = GmfComputer(ebr, self.sitecol, oq.imtls, self.cmaker, oq.truncation_level, oq.correl_model)
def build_eb_ruptures(src, rlzs, num_ses, cmaker, s_sites, rup_n_occ=()): """ :param src: a source object :param rlzs: realizations of the source model as numpy.uint16 numbers :param num_ses: number of stochastic event sets :param cmaker: a ContextMaker instance :param s_sites: a (filtered) site collection :param rup_n_occ: (rup, n_occ) pairs [inferred from the source] :returns: a list of EBRuptures """ # NB: s_sites can be None if cmaker.maximum_distance is False, then # the contexts are not computed and the ruptures not filtered ebrs = [] samples = getattr(src, 'samples', 1) nr = len(rlzs) if rup_n_occ == (): rup_n_occ = src.sample_ruptures(samples, num_ses, cmaker.ir_mon) for rup, n_occ in rup_n_occ: if cmaker.maximum_distance: with cmaker.ctx_mon: try: rup.sctx, rup.dctx = cmaker.make_contexts(s_sites, rup) indices = rup.sctx.sids except FarAwayRupture: continue else: indices = () if not hasattr(src, 'samples'): # full enumeration n_occ = fix_shape(n_occ, nr) # creating events with cmaker.evs_mon: occ = n_occ.sum(axis=1) # occurrences by sam_idx E = occ.sum() if E == 0: continue assert E < TWO16, E events = numpy.zeros(E, event_dt) events['grp_id'] = src.src_group_id i = 0 for sam_idx in range(nr): # numpy.ndenumerate would be slower for ses_idx, num_occ in enumerate(n_occ[sam_idx]): for _ in range(num_occ): events[i]['sample'] = sam_idx events[i]['ses'] = ses_idx + 1 i += 1 # setting event IDs based on the rupture serial and the sample ebr = EBRupture(rup, src.id, indices, events) start = 0 for sam_idx, n in enumerate(occ): eids = (U64(TWO32 * ebr.serial + TWO16 * rlzs[sam_idx]) + numpy.arange(n, dtype=U64)) ebr.events[start:start + len(eids)]['eid'] = eids start += len(eids) ebrs.append(ebr) return ebrs
def __iter__(self): self.dstore.open('r') # if needed attrs = self.dstore.get_attrs('ruptures') code2cls = {} # code -> rupture_cls, surface_cls for key, val in attrs.items(): if key.startswith('code_'): code2cls[int(key[5:])] = [classes[v] for v in val.split()] grp_trt = self.dstore['csm_info'].grp_by("trt") events = self.dstore['events'] ruptures = self.dstore['ruptures'][self.mask] rupgeoms = self.dstore['rupgeoms'][self.mask] # NB: ruptures.sort(order='serial') causes sometimes a SystemError: # <ufunc 'greater'> returned a result with an error set # this is way I am sorting with Python and not with numpy below data = sorted( (serial, ridx) for ridx, serial in enumerate(ruptures['serial'])) for serial, ridx in data: rec = ruptures[ridx] evs = events[rec['eidx1']:rec['eidx2']] if self.grp_id is not None and self.grp_id != rec['grp_id']: continue mesh = numpy.zeros((3, rec['sy'], rec['sz']), F32) for i, arr in enumerate(rupgeoms[ridx]): # i = 0, 1, 2 mesh[i] = arr.reshape(rec['sy'], rec['sz']) rupture_cls, surface_cls = code2cls[rec['code']] rupture = object.__new__(rupture_cls) rupture.serial = serial rupture.surface = object.__new__(surface_cls) rupture.mag = rec['mag'] rupture.rake = rec['rake'] rupture.seed = rec['seed'] rupture.hypocenter = geo.Point(*rec['hypo']) rupture.occurrence_rate = rec['occurrence_rate'] rupture.tectonic_region_type = grp_trt[rec['grp_id']] pmfx = rec['pmfx'] if pmfx != -1: rupture.pmf = self.dstore['pmfs'][pmfx] if surface_cls is geo.PlanarSurface: rupture.surface = geo.PlanarSurface.from_array(mesh[:, 0, :]) elif surface_cls is geo.MultiSurface: # mesh has shape (3, n, 4) rupture.surface.__init__([ geo.PlanarSurface.from_array(mesh[:, i, :]) for i in range(mesh.shape[1]) ]) elif surface_cls is geo.GriddedSurface: # fault surface, strike and dip will be computed rupture.surface.strike = rupture.surface.dip = None rupture.surface.mesh = Mesh(*mesh) else: # fault surface, strike and dip will be computed rupture.surface.strike = rupture.surface.dip = None rupture.surface.__init__(RectangularMesh(*mesh)) ebr = EBRupture(rupture, (), evs) ebr.eidx1 = rec['eidx1'] ebr.eidx2 = rec['eidx2'] # not implemented: rupture_slip_direction yield ebr
def _read_scenario_ruptures(self): oq = self.oqparam gsim_lt = readinput.get_gsim_lt(self.oqparam) G = gsim_lt.get_num_paths() if oq.calculation_mode.startswith('scenario'): ngmfs = oq.number_of_ground_motion_fields if oq.inputs['rupture_model'].endswith('.xml'): self.gsims = [gsim_rlz.value[0] for gsim_rlz in gsim_lt] self.cmaker = ContextMaker('*', self.gsims, { 'maximum_distance': oq.maximum_distance, 'imtls': oq.imtls }) rup = readinput.get_rupture(oq) if self.N > oq.max_sites_disagg: # many sites, split rupture ebrs = [ EBRupture(copyobj(rup, rup_id=rup.rup_id + i), 0, 0, G, e0=i * G) for i in range(ngmfs) ] else: # keep a single rupture with a big occupation number ebrs = [EBRupture(rup, 0, 0, G * ngmfs, rup.rup_id)] aw = get_rup_array(ebrs, self.srcfilter) if len(aw) == 0: raise RuntimeError( 'The rupture is too far from the sites! Please check the ' 'maximum_distance and the position of the rupture') elif oq.inputs['rupture_model'].endswith('.csv'): aw = readinput.get_ruptures(oq.inputs['rupture_model']) num_gsims = numpy.array( [len(gsim_lt.values[trt]) for trt in gsim_lt.values], U32) if oq.calculation_mode.startswith('scenario'): # rescale n_occ aw['n_occ'] *= ngmfs * num_gsims[aw['trt_smr']] rup_array = aw.array hdf5.extend(self.datastore['rupgeoms'], aw.geom) if len(rup_array) == 0: raise RuntimeError( 'There are no sites within the maximum_distance' ' of %s km from the rupture' % oq.maximum_distance(rup.tectonic_region_type, rup.mag)) # check the number of branchsets branchsets = len(gsim_lt._ltnode) if len(rup_array) == 1 and branchsets > 1: raise InvalidFile( '%s for a scenario calculation must contain a single ' 'branchset, found %d!' % (oq.inputs['job_ini'], branchsets)) fake = logictree.FullLogicTree.fake(gsim_lt) self.realizations = fake.get_realizations() self.datastore['full_lt'] = fake self.store_rlz_info({}) # store weights self.save_params() imp = calc.RuptureImporter(self.datastore) imp.import_rups_events(rup_array, get_rupture_getters)
def __iter__(self): self.dstore.open() # if needed oq = self.dstore['oqparam'] grp_trt = self.dstore['csm_info'].grp_by("trt") ruptures = self.dstore['ruptures'][self.mask] # NB: ruptures.sort(order='serial') causes sometimes a SystemError: # <ufunc 'greater'> returned a result with an error set # this is way I am sorting with Python and not with numpy below data = sorted((ser, idx) for idx, ser in enumerate(ruptures['serial'])) for serial, ridx in data: rec = ruptures[ridx] evs = self.dstore['events'][rec['eidx1']:rec['eidx2']] if self.grp_id is not None and self.grp_id != rec['grp_id']: continue mesh = rec['points'].reshape(rec['sx'], rec['sy'], rec['sz']) rupture_cls, surface_cls, source_cls = BaseRupture.types[ rec['code']] rupture = object.__new__(rupture_cls) rupture.surface = object.__new__(surface_cls) # MISSING: case complex_fault_mesh_spacing != rupture_mesh_spacing if 'Complex' in surface_cls.__name__: mesh_spacing = oq.complex_fault_mesh_spacing else: mesh_spacing = oq.rupture_mesh_spacing rupture.source_typology = source_cls rupture.mag = rec['mag'] rupture.rake = rec['rake'] rupture.seed = rec['seed'] rupture.hypocenter = geo.Point(*rec['hypo']) rupture.occurrence_rate = rec['occurrence_rate'] rupture.tectonic_region_type = grp_trt[rec['grp_id']] pmfx = rec['pmfx'] # disable check on PlanarSurface to support UCERF ruptures with mock.patch( 'openquake.hazardlib.geo.surface.PlanarSurface.' 'IMPERFECT_RECTANGLE_TOLERANCE', numpy.inf): if pmfx != -1: rupture.pmf = self.dstore['pmfs'][pmfx] if surface_cls is geo.PlanarSurface: rupture.surface = geo.PlanarSurface.from_array( mesh_spacing, rec['points']) elif surface_cls.__name__.endswith('MultiSurface'): rupture.surface.__init__([ geo.PlanarSurface.from_array(mesh_spacing, m1.flatten()) for m1 in mesh ]) else: # fault surface, strike and dip will be computed rupture.surface.strike = rupture.surface.dip = None m = mesh[0] rupture.surface.mesh = RectangularMesh( m['lon'], m['lat'], m['depth']) ebr = EBRupture(rupture, (), evs, serial) ebr.eidx1 = rec['eidx1'] ebr.eidx2 = rec['eidx2'] # not implemented: rupture_slip_direction yield ebr
def get_ruptures(self, srcfilter): """ :returns: a list of EBRuptures filtered by bounding box """ ebrs = [] with datastore.read(self.filename) as dstore: rupgeoms = dstore['rupgeoms'] for e0, rec in zip(self.e0, self.rup_array): if srcfilter.integration_distance: sids = srcfilter.close_sids(rec, self.trt) if len(sids) == 0: # the rupture is far away continue else: sids = None mesh = numpy.zeros((3, rec['sy'], rec['sz']), F32) geom = rupgeoms[rec['gidx1']:rec['gidx2']].reshape( rec['sy'], rec['sz']) mesh[0] = geom['lon'] mesh[1] = geom['lat'] mesh[2] = geom['depth'] rupture_cls, surface_cls = code2cls[rec['code']] rupture = object.__new__(rupture_cls) rupture.rup_id = rec['serial'] rupture.surface = object.__new__(surface_cls) rupture.mag = rec['mag'] rupture.rake = rec['rake'] rupture.hypocenter = geo.Point(*rec['hypo']) rupture.occurrence_rate = rec['occurrence_rate'] rupture.tectonic_region_type = self.trt if surface_cls is geo.PlanarSurface: rupture.surface = geo.PlanarSurface.from_array(mesh[:, 0, :]) elif surface_cls is geo.MultiSurface: # mesh has shape (3, n, 4) rupture.surface.__init__([ geo.PlanarSurface.from_array(mesh[:, i, :]) for i in range(mesh.shape[1]) ]) elif surface_cls is geo.GriddedSurface: # fault surface, strike and dip will be computed rupture.surface.strike = rupture.surface.dip = None rupture.surface.mesh = Mesh(*mesh) else: # fault surface, strike and dip will be computed rupture.surface.strike = rupture.surface.dip = None rupture.surface.__init__(RectangularMesh(*mesh)) grp_id = rec['grp_id'] ebr = EBRupture(rupture, rec['srcidx'], grp_id, rec['n_occ'], self.samples) # not implemented: rupture_slip_direction ebr.sids = sids ebr.ridx = rec['id'] ebr.e0 = 0 if self.e0 is None else e0 ebrs.append(ebr) return ebrs
def _get_ruptures(dstore, events, grp_ids, rup_id): oq = dstore['oqparam'] grp_trt = dstore['csm_info'].grp_trt() for grp_id in grp_ids: trt = grp_trt[grp_id] grp = 'grp-%02d' % grp_id try: recs = dstore['ruptures/' + grp] except KeyError: # no ruptures in grp continue for rec in recs: if rup_id is not None and rup_id != rec['serial']: continue mesh = rec['points'].reshape(rec['sx'], rec['sy'], rec['sz']) rupture_cls, surface_cls, source_cls = BaseRupture.types[ rec['code']] rupture = object.__new__(rupture_cls) rupture.surface = object.__new__(surface_cls) # MISSING: case complex_fault_mesh_spacing != rupture_mesh_spacing if 'Complex' in surface_cls.__name__: mesh_spacing = oq.complex_fault_mesh_spacing else: mesh_spacing = oq.rupture_mesh_spacing rupture.source_typology = source_cls rupture.mag = rec['mag'] rupture.rake = rec['rake'] rupture.seed = rec['seed'] rupture.hypocenter = geo.Point(*rec['hypo']) rupture.occurrence_rate = rec['occurrence_rate'] rupture.tectonic_region_type = trt pmfx = rec['pmfx'] if pmfx != -1: rupture.pmf = dstore['pmfs/' + grp][pmfx] if surface_cls is geo.PlanarSurface: rupture.surface = geo.PlanarSurface.from_array( mesh_spacing, rec['points']) elif surface_cls.__name__.endswith('MultiSurface'): rupture.surface.__init__([ geo.PlanarSurface.from_array(mesh_spacing, m1.flatten()) for m1 in mesh ]) else: # fault surface, strike and dip will be computed rupture.surface.strike = rupture.surface.dip = None m = mesh[0] rupture.surface.mesh = RectangularMesh(m['lon'], m['lat'], m['depth']) sids = dstore['sids'][rec['sidx']] evs = events[rec['eidx1']:rec['eidx2']] ebr = EBRupture(rupture, sids, evs, grp_id, rec['serial']) ebr.eidx1 = rec['eidx1'] ebr.eidx2 = rec['eidx2'] ebr.sidx = rec['sidx'] # not implemented: rupture_slip_direction yield ebr
def get_eid_rlz(self, monitor=None): """ :returns: a composite array with the associations eid->rlz """ eid_rlz = [] for rup in self.rup_array: ebr = EBRupture(mock.Mock(serial=rup['serial']), rup['srcidx'], self.grp_id, rup['n_occ'], self.samples) for rlz, eids in ebr.get_eids_by_rlz(self.rlzs_by_gsim).items(): for eid in eids: eid_rlz.append((eid, rlz)) return numpy.array(eid_rlz, [('eid', U64), ('rlz', U16)])
def get_eid_rlz(self): """ :returns: a composite array with the associations eid->rlz """ eid_rlz = [] for rup in self.proxies: ebr = EBRupture(mock.Mock(rup_id=rup['serial']), rup['source_id'], self.grp_id, rup['n_occ'], self.samples) for rlz_id, eids in ebr.get_eids_by_rlz(self.rlzs_by_gsim).items(): for eid in eids: eid_rlz.append((eid + rup['e0'], rup['id'], rlz_id)) return numpy.array(eid_rlz, events_dt)
def get_eid_rlz(self, monitor=None): """ :returns: a composite array with the associations eid->rlz """ eid_rlz = [] for rup in self.rup_array: ebr = EBRupture(mock.Mock(serial=rup['serial']), rup['srcidx'], self.grp_id, rup['n_occ'], self.samples) for rlz, eids in ebr.get_eids_by_rlz(self.rlzs_by_gsim).items(): for eid in eids: eid_rlz.append((eid, rlz)) return numpy.array(eid_rlz, [('eid', U64), ('rlz', U16)])
def get_ruptures(self, srcfilter=calc.filters.nofilter): """ :returns: a list of EBRuptures filtered by bounding box """ ebrs = [] with datastore.read(self.filename) as dstore: rupgeoms = dstore['rupgeoms'] for rec in self.rup_array: if srcfilter.integration_distance: sids = srcfilter.close_sids(rec, self.trt, rec['mag']) if len(sids) == 0: # the rupture is far away continue else: sids = None mesh = numpy.zeros((3, rec['sy'], rec['sz']), F32) geom = rupgeoms[rec['gidx1']:rec['gidx2']].reshape( rec['sy'], rec['sz']) mesh[0] = geom['lon'] mesh[1] = geom['lat'] mesh[2] = geom['depth'] rupture_cls, surface_cls = self.code2cls[rec['code']] rupture = object.__new__(rupture_cls) rupture.serial = rec['serial'] rupture.surface = object.__new__(surface_cls) rupture.mag = rec['mag'] rupture.rake = rec['rake'] rupture.hypocenter = geo.Point(*rec['hypo']) rupture.occurrence_rate = rec['occurrence_rate'] rupture.tectonic_region_type = self.trt if surface_cls is geo.PlanarSurface: rupture.surface = geo.PlanarSurface.from_array( mesh[:, 0, :]) elif surface_cls is geo.MultiSurface: # mesh has shape (3, n, 4) rupture.surface.__init__([ geo.PlanarSurface.from_array(mesh[:, i, :]) for i in range(mesh.shape[1])]) elif surface_cls is geo.GriddedSurface: # fault surface, strike and dip will be computed rupture.surface.strike = rupture.surface.dip = None rupture.surface.mesh = Mesh(*mesh) else: # fault surface, strike and dip will be computed rupture.surface.strike = rupture.surface.dip = None rupture.surface.__init__(RectangularMesh(*mesh)) grp_id = rec['grp_id'] ebr = EBRupture(rupture, rec['srcidx'], grp_id, rec['n_occ'], self.samples) # not implemented: rupture_slip_direction ebr.sids = sids ebrs.append(ebr) return ebrs
def _read_scenario_ruptures(self): oq = self.oqparam gsim_lt = readinput.get_gsim_lt(self.oqparam) G = gsim_lt.get_num_paths() if oq.inputs['rupture_model'].endswith('.xml'): ngmfs = oq.number_of_ground_motion_fields self.gsims = readinput.get_gsims(oq) self.cmaker = ContextMaker('*', self.gsims, { 'maximum_distance': oq.maximum_distance, 'imtls': oq.imtls }) rup = readinput.get_rupture(oq) mesh = surface_to_array(rup.surface).transpose(1, 2, 0).flatten() if self.N > oq.max_sites_disagg: # many sites, split rupture ebrs = [ EBRupture(copyobj(rup, rup_id=rup.rup_id + i), 0, 0, G, e0=i * G) for i in range(ngmfs) ] meshes = numpy.array([mesh] * ngmfs, object) else: # keep a single rupture with a big occupation number ebrs = [EBRupture(rup, 0, 0, G * ngmfs, rup.rup_id)] meshes = numpy.array([mesh] * ngmfs, object) rup_array = get_rup_array(ebrs, self.srcfilter).array hdf5.extend(self.datastore['rupgeoms'], meshes) elif oq.inputs['rupture_model'].endswith('.csv'): aw = readinput.get_ruptures(oq.inputs['rupture_model']) aw.array['n_occ'] = G rup_array = aw.array hdf5.extend(self.datastore['rupgeoms'], aw.geom) if len(rup_array) == 0: raise RuntimeError( 'There are no sites within the maximum_distance' ' of %s km from the rupture' % oq.maximum_distance(rup.tectonic_region_type, rup.mag)) # check the number of branchsets branchsets = len(gsim_lt._ltnode) if len(rup_array) == 1 and branchsets > 1: raise InvalidFile( '%s for a scenario calculation must contain a single ' 'branchset, found %d!' % (oq.inputs['job_ini'], branchsets)) fake = logictree.FullLogicTree.fake(gsim_lt) self.realizations = fake.get_realizations() self.datastore['full_lt'] = fake self.store_rlz_info({}) # store weights self.save_params() calc.RuptureImporter(self.datastore).import_rups(rup_array)
def get_eid_rlz(self, proxies, rlzs_by_gsim): """ :returns: a composite array with the associations eid->rlz """ eid_rlz = [] for rup in proxies: ebr = EBRupture(Mock(rup_id=rup['seed']), rup['source_id'], rup['trt_smr'], rup['n_occ'], e0=rup['e0']) ebr.scenario = 'scenario' in self.oqparam.calculation_mode for rlz_id, eids in ebr.get_eids_by_rlz(rlzs_by_gsim).items(): for eid in eids: eid_rlz.append((eid, rup['id'], rlz_id)) return numpy.array(eid_rlz, events_dt)
def get_eid_rlz(self): """ :returns: a composite array with the associations eid->rlz """ eid_rlz = [] for e0, rup in zip(self.e0, self.rup_array): rup_id = rup['rup_id'] ebr = EBRupture(mock.Mock(rup_id=rup_id), rup['srcidx'], self.grp_id, rup['n_occ'], self.samples) for rlz_id, eids in ebr.get_eids_by_rlz(self.rlzs_by_gsim).items(): for eid in eids: eid_rlz.append((eid + e0, rup_id, rlz_id)) return numpy.array(eid_rlz, events_dt)
def __iter__(self): self.dstore.open() # if needed oq = self.dstore['oqparam'] grp_trt = self.dstore['csm_info'].grp_trt() recs = self.dstore['ruptures'][self.slice] for rec in recs: if self.rup_id is not None and self.rup_id != rec['serial']: continue evs = self.dstore['events'][rec['eidx1']:rec['eidx2']] grp_id = evs['grp_id'][0] if self.grp_id is not None and self.grp_id != grp_id: continue mesh = rec['points'].reshape(rec['sx'], rec['sy'], rec['sz']) rupture_cls, surface_cls, source_cls = BaseRupture.types[ rec['code']] rupture = object.__new__(rupture_cls) rupture.surface = object.__new__(surface_cls) # MISSING: case complex_fault_mesh_spacing != rupture_mesh_spacing if 'Complex' in surface_cls.__name__: mesh_spacing = oq.complex_fault_mesh_spacing else: mesh_spacing = oq.rupture_mesh_spacing rupture.source_typology = source_cls rupture.mag = rec['mag'] rupture.rake = rec['rake'] rupture.seed = rec['seed'] rupture.hypocenter = geo.Point(*rec['hypo']) rupture.occurrence_rate = rec['occurrence_rate'] rupture.tectonic_region_type = grp_trt[grp_id] pmfx = rec['pmfx'] if pmfx != -1: rupture.pmf = self.dstore['pmfs'][pmfx] if surface_cls is geo.PlanarSurface: rupture.surface = geo.PlanarSurface.from_array( mesh_spacing, rec['points']) elif surface_cls.__name__.endswith('MultiSurface'): rupture.surface.__init__([ geo.PlanarSurface.from_array(mesh_spacing, m1.flatten()) for m1 in mesh ]) else: # fault surface, strike and dip will be computed rupture.surface.strike = rupture.surface.dip = None m = mesh[0] rupture.surface.mesh = RectangularMesh(m['lon'], m['lat'], m['depth']) ebr = EBRupture(rupture, (), evs, rec['serial']) ebr.eidx1 = rec['eidx1'] ebr.eidx2 = rec['eidx2'] # not implemented: rupture_slip_direction yield ebr
def pre_execute(self): """ Read the site collection and initialize GmfComputer and seeds """ oq = self.oqparam cinfo = logictree.FullLogicTree.fake(readinput.get_gsim_lt(oq)) self.realizations = cinfo.get_realizations() self.datastore['full_lt'] = cinfo if 'rupture_model' not in oq.inputs: logging.warning( 'There is no rupture_model, the calculator will just ' 'import data without performing any calculation') super().pre_execute() return self.rup = readinput.get_rupture(oq) self.gsims = readinput.get_gsims(oq) R = len(self.gsims) self.cmaker = ContextMaker( '*', self.gsims, { 'maximum_distance': oq.maximum_distance, 'filter_distance': oq.filter_distance }) super().pre_execute() self.datastore['oqparam'] = oq self.store_rlz_info({}) rlzs_by_gsim = cinfo.get_rlzs_by_gsim(0) E = oq.number_of_ground_motion_fields n_occ = numpy.array([E]) ebr = EBRupture(self.rup, 0, 0, n_occ) ebr.e0 = 0 events = numpy.zeros(E * R, events_dt) for rlz, eids in ebr.get_eids_by_rlz(rlzs_by_gsim).items(): events[rlz * E:rlz * E + E]['id'] = eids events[rlz * E:rlz * E + E]['rlz_id'] = rlz self.datastore['events'] = self.events = events rupser = calc.RuptureSerializer(self.datastore) rup_array = get_rup_array([ebr], self.src_filter()) if len(rup_array) == 0: maxdist = oq.maximum_distance(self.rup.tectonic_region_type, self.rup.mag) raise RuntimeError('There are no sites within the maximum_distance' ' of %s km from the rupture' % maxdist) rupser.save(rup_array) rupser.close() self.computer = GmfComputer(ebr, self.sitecol, oq.imtls, self.cmaker, oq.truncation_level, oq.correl_model, self.amplifier) M32 = (numpy.float32, len(self.oqparam.imtls)) self.sig_eps_dt = [('eid', numpy.uint64), ('sig', M32), ('eps', M32)]
def build_ruptures(sources, src_filter, param, monitor): """ :param sources: a list with a single UCERF source :param param: extra parameters :param monitor: a Monitor instance :returns: an AccumDict grp_id -> EBRuptures """ [src] = sources res = AccumDict() res.calc_times = [] sampl_mon = monitor('sampling ruptures', measuremem=True) res.trt = DEFAULT_TRT background_sids = src.get_background_sids(src_filter) samples = getattr(src, 'samples', 1) n_occ = AccumDict(accum=0) t0 = time.time() with sampl_mon: for sam_idx in range(samples): for ses_idx, ses_seed in param['ses_seeds']: seed = sam_idx * TWO16 + ses_seed rups, occs = generate_event_set(src, background_sids, src_filter, ses_idx, seed) for rup, occ in zip(rups, occs): n_occ[rup] += occ tot_occ = sum(n_occ.values()) dic = {'eff_ruptures': {src.src_group_id: src.num_ruptures}} eb_ruptures = [ EBRupture(rup, src.id, src.src_group_id, n, samples) for rup, n in n_occ.items() ] dic['rup_array'] = stochastic.get_rup_array(eb_ruptures, src_filter) dt = time.time() - t0 n = len(src_filter.sitecol) dic['calc_times'] = {src.id: numpy.array([tot_occ, n, dt], F32)} return dic
def pre_execute(self): """ Read the site collection and initialize GmfComputer and seeds """ oq = self.oqparam cinfo = source.CompositionInfo.fake(readinput.get_gsim_lt(oq)) self.datastore['csm_info'] = cinfo if 'rupture_model' not in oq.inputs: logging.warn('There is no rupture_model, the calculator will just ' 'import data without performing any calculation') super().pre_execute() return self.rup = readinput.get_rupture(oq) self.gsims = readinput.get_gsims(oq) self.cmaker = ContextMaker(self.gsims, oq.maximum_distance, oq.filter_distance) super().pre_execute() self.datastore['oqparam'] = oq self.rlzs_assoc = cinfo.get_rlzs_assoc() E = oq.number_of_ground_motion_fields events = numpy.zeros(E, readinput.stored_event_dt) events['eid'] = numpy.arange(E) ebr = EBRupture(self.rup, self.sitecol.sids, events) self.datastore['events'] = ebr.events rupser = calc.RuptureSerializer(self.datastore) rupser.save([ebr]) rupser.close() self.computer = GmfComputer(ebr, self.sitecol, oq.imtls, self.cmaker, oq.truncation_level, oq.get_correl_model())
def _build_eb_ruptures(src, num_occ_by_rup, cmaker, s_sites, rup_mon): # Filter the ruptures stored in the dictionary num_occ_by_rup and # yield pairs (rupture, <list of associated EBRuptures>). # NB: s_sites can be None if cmaker.maximum_distance is False, then # the contexts are not computed and the ruptures not filtered for rup in sorted(num_occ_by_rup, key=operator.attrgetter('rup_no')): if cmaker.maximum_distance: with rup_mon: try: rup.sctx, rup.dctx = cmaker.make_contexts(s_sites, rup) indices = rup.sctx.sids except FarAwayRupture: # ignore ruptures which are far away del num_occ_by_rup[rup] # save memory continue else: indices = () # creating EBRuptures events = [] for (sam_idx, ses_idx), num_occ in sorted(num_occ_by_rup[rup].items()): for _ in range(num_occ): # NB: the 0 below is a placeholder; the right eid will be # set a bit later, in set_eids events.append((0, src.src_group_id, ses_idx, sam_idx)) if events: yield EBRupture(rup, indices, numpy.array(events, event_dt))
def ruptures_from_erf(sources, srcfilter, param, monitor=Monitor()): """ :param sources: a sequence of sources of the same group :param srcfilter: SourceFilter instance used also for bounding box post filtering :param param: a dictionary of additional parameters including ses_per_logic_tree_path :param monitor: monitor instance :yields: dictionaries with keys rup_array, calc_times """ # AccumDict of arrays with 4 elements num_ruptures, num_sites, calc_time, sources_ids trt = sources[0].tectonic_region_type eb_ruptures = [] eff_ruptures = 0 # AccumDict of arrays with 2 elements weight, calc_time calc_times = AccumDict(accum=numpy.zeros(3, numpy.float32)) for src, _sites in srcfilter(sources): nr = src.num_ruptures eff_ruptures += nr t0 = time.time() if len(eb_ruptures) > MAX_RUPTURES: # yield partial result to avoid running out of memory source_ids = get_source_ids(eb_ruptures, srcfilter) yield AccumDict( dict(rup_array=get_rup_array(eb_ruptures, srcfilter), calc_times={}, eff_ruptures={}, source_ids=source_ids)) eb_ruptures.clear() eb_ruptures = [] for rup, grp_id in src.ruptures_from_erf(): eb_ruptures.append(EBRupture(rup, src.id, grp_id, 1, 1)) dt = time.time() - t0 try: n_sites = len(_sites) except (TypeError, ValueError): # for None or a closed dataset n_sites = 0 calc_times[src.source_id] += numpy.array([nr, n_sites, dt]) rup_array = get_rup_array(eb_ruptures, srcfilter) source_ids = get_source_ids(eb_ruptures, srcfilter) yield AccumDict( dict(rup_array=rup_array, calc_times=calc_times, eff_ruptures={trt: eff_ruptures}, source_ids=source_ids))
def get_rupture_sitecol(oqparam, sitecol): """ Read the `rupture_model` file and by filter the site collection :param oqparam: an :class:`openquake.commonlib.oqvalidation.OqParam` instance :param sitecol: a :class:`openquake.hazardlib.site.SiteCollection` instance :returns: a pair (EBRupture, FilteredSiteCollection) """ rup_model = oqparam.inputs['rupture_model'] [rup_node] = nrml.read(rup_model) conv = sourceconverter.RuptureConverter( oqparam.rupture_mesh_spacing, oqparam.complex_fault_mesh_spacing) rup = conv.convert_node(rup_node) rup.tectonic_region_type = '*' # there is not TRT for scenario ruptures rup.seed = oqparam.random_seed maxdist = oqparam.maximum_distance['default'] sc = calc.filters.filter_sites_by_distance_to_rupture( rup, maxdist, sitecol) if sc is None: raise RuntimeError( 'All sites were filtered out! maximum_distance=%s km' % maxdist) n = oqparam.number_of_ground_motion_fields events = numpy.zeros(n, stored_event_dt) events['eid'] = numpy.arange(n) ebr = EBRupture(rup, sc.sids, events) return ebr, sc
def _build_eb_ruptures(src, num_occ_by_rup, cmaker, s_sites, random_seed, rup_mon): """ Filter the ruptures stored in the dictionary num_occ_by_rup and yield pairs (rupture, <list of associated EBRuptures>) """ for rup in sorted(num_occ_by_rup, key=operator.attrgetter('rup_no')): rup.serial = rup.seed - random_seed + 1 with rup_mon: try: rup.ctx = cmaker.make_contexts(s_sites, rup) indices = rup.ctx[0].sids except FarAwayRupture: # ignore ruptures which are far away del num_occ_by_rup[rup] # save memory continue # creating EBRuptures events = [] for (sam_idx, ses_idx), num_occ in sorted(num_occ_by_rup[rup].items()): for _ in range(num_occ): # NB: the 0 below is a placeholder; the right eid will be # set a bit later, in set_eids events.append((0, src.src_group_id, ses_idx, sam_idx)) if events: yield EBRupture(rup, indices, numpy.array(events, event_dt))
def build_eb_ruptures(src, num_ses, cmaker, s_sites, rup_n_occ=()): """ :param src: a source object :param num_ses: number of stochastic event sets :param cmaker: a ContextMaker instance :param s_sites: a (filtered) site collection :param rup_n_occ: (rup, n_occ) pairs [inferred from the source] :returns: a list of EBRuptures """ # NB: s_sites can be None if cmaker.maximum_distance is False, then # the contexts are not computed and the ruptures not filtered ebrs = [] samples = getattr(src, 'samples', 1) if rup_n_occ == (): # NB: the number of occurrences is very low, << 1, so it is # more efficient to filter only the ruptures that occur, i.e. # to call sample_ruptures *before* the filtering rup_n_occ = src.sample_ruptures(samples, num_ses, cmaker.ir_mon) for rup, n_occ in rup_n_occ: if cmaker.maximum_distance: with cmaker.ctx_mon: try: rup.sctx, rup.dctx = cmaker.make_contexts(s_sites, rup) indices = rup.sctx.sids except FarAwayRupture: continue else: indices = () ebr = EBRupture(rup, src.id, src.src_group_id, indices, n_occ, samples) ebrs.append(ebr) return ebrs
def sample_ruptures(sources, srcfilter, param, monitor=Monitor()): """ :param sources: a sequence of sources of the same group :param srcfilter: SourceFilter instance used also for bounding box post filtering :param param: a dictionary of additional parameters including ses_per_logic_tree_path :param monitor: monitor instance :yields: dictionaries with keys rup_array, calc_times """ # AccumDict of arrays with 3 elements num_ruptures, num_sites, calc_time calc_times = AccumDict(accum=numpy.zeros(3, numpy.float32)) # Compute and save stochastic event sets num_ses = param['ses_per_logic_tree_path'] trt = sources[0].tectonic_region_type # Compute the number of occurrences of the source group. This is used # for cluster groups or groups with mutually exclusive sources. if (getattr(sources, 'atomic', False) and getattr(sources, 'cluster', False)): eb_ruptures, calc_times = sample_cluster(sources, srcfilter, num_ses, param) # Yield ruptures yield AccumDict( dict(rup_array=get_rup_array(eb_ruptures, srcfilter), calc_times=calc_times, eff_ruptures={trt: len(eb_ruptures)})) else: eb_ruptures = [] eff_ruptures = 0 # AccumDict of arrays with 2 elements weight, calc_time calc_times = AccumDict(accum=numpy.zeros(3, numpy.float32)) for src, _ in srcfilter.filter(sources): nr = src.num_ruptures eff_ruptures += nr t0 = time.time() if len(eb_ruptures) > MAX_RUPTURES: # yield partial result to avoid running out of memory yield AccumDict( dict(rup_array=get_rup_array(eb_ruptures, srcfilter), calc_times={}, eff_ruptures={})) eb_ruptures.clear() samples = getattr(src, 'samples', 1) for rup, trt_smrlz, n_occ in src.sample_ruptures( samples * num_ses, param['ses_seed']): ebr = EBRupture(rup, src.source_id, trt_smrlz, n_occ) eb_ruptures.append(ebr) dt = time.time() - t0 calc_times[src.id] += numpy.array([nr, src.nsites, dt]) rup_array = get_rup_array(eb_ruptures, srcfilter) yield AccumDict( dict(rup_array=rup_array, calc_times=calc_times, eff_ruptures={trt: eff_ruptures}))
def sample_ruptures(sources, srcfilter, param, monitor=Monitor()): """ :param sources: a sequence of sources of the same group :param srcfilter: SourceFilter instance used also for bounding box post filtering :param param: a dictionary of additional parameters including ses_per_logic_tree_path :param monitor: monitor instance :yields: dictionaries with keys rup_array, calc_times """ # AccumDict of arrays with 3 elements num_ruptures, num_sites, calc_time calc_times = AccumDict(accum=numpy.zeros(3, numpy.float32)) # Compute and save stochastic event sets num_ses = param['ses_per_logic_tree_path'] [grp_id] = set(src.src_group_id for src in sources) # Compute the number of occurrences of the source group. This is used # for cluster groups or groups with mutually exclusive sources. if (getattr(sources, 'atomic', False) and getattr(sources, 'cluster', False)): eb_ruptures, calc_times = sample_cluster( sources, srcfilter, num_ses, param) # Yield ruptures yield AccumDict(rup_array=get_rup_array(eb_ruptures, srcfilter), calc_times=calc_times, eff_ruptures={grp_id: len(eb_ruptures)}) else: eb_ruptures = [] eff_ruptures = 0 # AccumDict of arrays with 2 elements weight, calc_time calc_times = AccumDict(accum=numpy.zeros(3, numpy.float32)) for src, _sites in srcfilter(sources): eff_ruptures += 1 t0 = time.time() if len(eb_ruptures) > MAX_RUPTURES: # yield partial result to avoid running out of memory yield AccumDict(rup_array=get_rup_array(eb_ruptures, srcfilter), calc_times={}, eff_ruptures={}) eb_ruptures.clear() samples = getattr(src, 'samples', 1) n_occ = 0 for rup, n_occ in src.sample_ruptures(samples * num_ses): ebr = EBRupture(rup, src.id, grp_id, n_occ, samples) eb_ruptures.append(ebr) n_occ += ebr.n_occ dt = time.time() - t0 try: n_sites = len(_sites) except (TypeError, ValueError): # for None or a closed dataset n_sites = 0 calc_times[src.id] += numpy.array([n_occ, n_sites, dt]) rup_array = get_rup_array(eb_ruptures, srcfilter) yield AccumDict(rup_array=rup_array, calc_times=calc_times, eff_ruptures={grp_id: eff_ruptures})
def compute_ruptures(sources, src_filter, gsims, param, monitor): """ :param sources: a list with a single UCERF source :param src_filter: a SourceFilter instance :param gsims: a list of GSIMs :param param: extra parameters :param monitor: a Monitor instance :returns: an AccumDict grp_id -> EBRuptures """ [src] = sources res = AccumDict() res.calc_times = AccumDict() serial = 1 sampl_mon = monitor('sampling ruptures', measuremem=True) filt_mon = monitor('filtering ruptures', measuremem=False) res.trt = DEFAULT_TRT t0 = time.time() ebruptures = [] background_sids = src.get_background_sids(src_filter) sitecol = src_filter.sitecol idist = src_filter.integration_distance for sample in range(param['samples']): for ses_idx, ses_seed in param['ses_seeds']: seed = sample * event_based.TWO16 + ses_seed with sampl_mon: rups, n_occs = src.generate_event_set(background_sids, src_filter, seed) with filt_mon: for rup, n_occ in zip(rups, n_occs): rup.seed = seed try: r_sites, rrup = idist.get_closest(sitecol, rup) except FarAwayRupture: continue indices = (numpy.arange(len(r_sites)) if r_sites.indices is None else r_sites.indices) events = [] for _ in range(n_occ): events.append((0, src.src_group_id, ses_idx, sample)) if events: evs = numpy.array(events, calc.event_dt) ebruptures.append(EBRupture(rup, indices, evs, serial)) serial += 1 res.num_events = event_based.set_eids(ebruptures) res[src.src_group_id] = ebruptures res.calc_times[src.src_group_id] = { src.source_id: numpy.array([src.weight, len(sitecol), time.time() - t0, 1]) } if not param['save_ruptures']: res.events_by_grp = { grp_id: event_based.get_events(res[grp_id]) for grp_id in res } res.eff_ruptures = {src.src_group_id: src.num_ruptures} return res
def compute_hazard(sources, src_filter, rlzs_by_gsim, param, monitor): """ :param sources: a list with a single UCERF source :param src_filter: a SourceFilter instance :param rlzs_by_gsim: a dictionary gsim -> rlzs :param param: extra parameters :param monitor: a Monitor instance :returns: an AccumDict grp_id -> EBRuptures """ [src] = sources res = AccumDict() res.calc_times = [] serial = 1 sampl_mon = monitor('sampling ruptures', measuremem=True) filt_mon = monitor('filtering ruptures', measuremem=False) res.trt = DEFAULT_TRT ebruptures = [] background_sids = src.get_background_sids(src_filter) sitecol = src_filter.sitecol cmaker = ContextMaker(rlzs_by_gsim, src_filter.integration_distance) for sample in range(param['samples']): for ses_idx, ses_seed in param['ses_seeds']: seed = sample * TWO16 + ses_seed with sampl_mon: rups, n_occs = generate_event_set(src, background_sids, src_filter, seed) with filt_mon: for rup, n_occ in zip(rups, n_occs): rup.serial = serial try: rup.sctx, rup.dctx = cmaker.make_contexts(sitecol, rup) indices = rup.sctx.sids except FarAwayRupture: continue events = [] for _ in range(n_occ): events.append((0, src.src_group_id, ses_idx, sample)) if events: evs = numpy.array(events, stochastic.event_dt) ebruptures.append(EBRupture(rup, src.id, indices, evs)) serial += 1 res.num_events = len(stochastic.set_eids(ebruptures)) res['ruptures'] = {src.src_group_id: ebruptures} if param['save_ruptures']: res.ruptures_by_grp = {src.src_group_id: ebruptures} else: res.events_by_grp = { src.src_group_id: event_based.get_events(ebruptures) } res.eff_ruptures = {src.src_group_id: src.num_ruptures} if param.get('gmf'): getter = getters.GmfGetter(rlzs_by_gsim, ebruptures, sitecol, param['oqparam'], param['min_iml'], param['samples']) res.update(getter.compute_gmfs_curves(monitor)) return res
def sample_ruptures(sources, cmaker, sitecol=None, monitor=Monitor()): """ :param sources: a sequence of sources of the same group :param cmaker: a ContextMaker instance with ses_per_logic_tree_path, ses_seed :param sitecol: SiteCollection instance used for filtering (None for no filtering) :param monitor: monitor instance :yields: dictionaries with keys rup_array, calc_times """ srcfilter = SourceFilter(sitecol, cmaker.maximum_distance) # AccumDict of arrays with 3 elements num_ruptures, num_sites, calc_time calc_times = AccumDict(accum=numpy.zeros(3, numpy.float32)) # Compute and save stochastic event sets num_ses = cmaker.ses_per_logic_tree_path grp_id = sources[0].grp_id # Compute the number of occurrences of the source group. This is used # for cluster groups or groups with mutually exclusive sources. if (getattr(sources, 'atomic', False) and getattr(sources, 'cluster', False)): eb_ruptures, calc_times = sample_cluster( sources, srcfilter, num_ses, vars(cmaker)) # Yield ruptures er = sum(src.num_ruptures for src, _ in srcfilter.filter(sources)) yield AccumDict(dict(rup_array=get_rup_array(eb_ruptures, srcfilter), calc_times=calc_times, eff_ruptures={grp_id: er})) else: eb_ruptures = [] eff_ruptures = 0 # AccumDict of arrays with 2 elements weight, calc_time calc_times = AccumDict(accum=numpy.zeros(3, numpy.float32)) for src, _ in srcfilter.filter(sources): nr = src.num_ruptures eff_ruptures += nr t0 = time.time() if len(eb_ruptures) > MAX_RUPTURES: # yield partial result to avoid running out of memory yield AccumDict(dict(rup_array=get_rup_array(eb_ruptures, srcfilter), calc_times={}, eff_ruptures={})) eb_ruptures.clear() samples = getattr(src, 'samples', 1) for rup, trt_smr, n_occ in src.sample_ruptures( samples * num_ses, cmaker.ses_seed): ebr = EBRupture(rup, src.source_id, trt_smr, n_occ) eb_ruptures.append(ebr) dt = time.time() - t0 calc_times[src.id] += numpy.array([nr, src.nsites, dt]) rup_array = get_rup_array(eb_ruptures, srcfilter) yield AccumDict(dict(rup_array=rup_array, calc_times=calc_times, eff_ruptures={grp_id: eff_ruptures}))
def _read_scenario_ruptures(self): oq = self.oqparam if oq.inputs['rupture_model'].endswith(('.xml', '.toml', '.txt')): self.gsims = readinput.get_gsims(oq) self.cmaker = ContextMaker( '*', self.gsims, {'maximum_distance': oq.maximum_distance, 'filter_distance': oq.filter_distance}) n_occ = numpy.array([oq.number_of_ground_motion_fields]) rup = readinput.get_rupture(oq) ebr = EBRupture(rup, 0, 0, n_occ) ebr.e0 = 0 rup_array = get_rup_array([ebr], self.srcfilter).array mesh = surface_to_array(rup.surface).transpose(1, 2, 0).flatten() hdf5.extend(self.datastore['rupgeoms'], numpy.array([mesh], object)) elif oq.inputs['rupture_model'].endswith('.csv'): aw = readinput.get_ruptures(oq.inputs['rupture_model']) rup_array = aw.array hdf5.extend(self.datastore['rupgeoms'], aw.geom) if len(rup_array) == 0: raise RuntimeError( 'There are no sites within the maximum_distance' ' of %s km from the rupture' % oq.maximum_distance( rup.tectonic_region_type, rup.mag)) gsim_lt = readinput.get_gsim_lt(self.oqparam) # check the number of branchsets branchsets = len(gsim_lt._ltnode) if len(rup_array) == 1 and branchsets > 1: raise InvalidFile( '%s for a scenario calculation must contain a single ' 'branchset, found %d!' % (oq.inputs['job_ini'], branchsets)) fake = logictree.FullLogicTree.fake(gsim_lt) self.realizations = fake.get_realizations() self.datastore['full_lt'] = fake self.store_rlz_info({}) # store weights self.save_params() calc.RuptureImporter(self.datastore).import_rups(rup_array)
def compute_ruptures(sources, src_filter, gsims, param, monitor): """ :param sources: a list with a single UCERF source :param src_filter: a SourceFilter instance :param gsims: a list of GSIMs :param param: extra parameters :param monitor: a Monitor instance :returns: an AccumDict grp_id -> EBRuptures """ [src] = sources res = AccumDict() res.calc_times = [] serial = 1 sampl_mon = monitor('sampling ruptures', measuremem=True) filt_mon = monitor('filtering ruptures', measuremem=False) res.trt = DEFAULT_TRT ebruptures = [] background_sids = src.get_background_sids(src_filter) sitecol = src_filter.sitecol cmaker = ContextMaker(gsims, src_filter.integration_distance) for sample in range(param['samples']): for ses_idx, ses_seed in param['ses_seeds']: seed = sample * TWO16 + ses_seed with sampl_mon: rups, n_occs = generate_event_set(src, background_sids, src_filter, seed) with filt_mon: for rup, n_occ in zip(rups, n_occs): rup.serial = serial rup.seed = seed try: rup.sctx, rup.dctx = cmaker.make_contexts(sitecol, rup) indices = rup.sctx.sids except FarAwayRupture: continue events = [] for _ in range(n_occ): events.append((0, src.src_group_id, ses_idx, sample)) if events: evs = numpy.array(events, stochastic.event_dt) ebruptures.append(EBRupture(rup, indices, evs)) serial += 1 res.num_events = len(stochastic.set_eids(ebruptures)) res[src.src_group_id] = ebruptures if not param['save_ruptures']: res.events_by_grp = { grp_id: event_based.get_events(res[grp_id]) for grp_id in res } res.eff_ruptures = {src.src_group_id: src.num_ruptures} return res
def sample_ebruptures(src_groups, cmakerdict): """ Sample independent sources without filtering. :param src_groups: a list of source groups :param cmakerdict: a dictionary TRT -> cmaker :returns: a list of EBRuptures """ ebrs = [] e0 = 0 ordinal = 0 for sg in src_groups: cmaker = cmakerdict[sg.trt] for src in sg: samples = getattr(src, 'samples', 1) for rup, trt_smr, n_occ in src.sample_ruptures( samples * cmaker.ses_per_logic_tree_path, cmaker.ses_seed): ebr = EBRupture(rup, src.source_id, trt_smr, n_occ, e0=e0) ebr.ordinal = ordinal ebrs.append(ebr) e0 += n_occ ordinal += 1 return ebrs