def testMisfitOfSameTracesZero(self): y = num.random.random(10000) y -= max(y) * 0.5 t1 = trace.Trace(tmin=0, ydata=y, deltat=0.01) t2 = trace.Trace(tmin=0, ydata=y, deltat=0.01) # ttraces = [t2] fresponse = trace.FrequencyResponse() taper = trace.CosFader(xfade=2.) norms = [1, 2] domains = ['time_domain', 'frequency_domain', 'envelope', 'absolute'] setups = [ trace.MisfitSetup(norm=n, taper=taper, domain=domain, filter=fresponse) for domain in domains for n in norms ] for setup in setups: m, n, tr, tc = t1.misfit(candidate=t2, setup=setup, debug=True) if isinstance(tr, trace.Trace): self.assertEqual(tr.tmin, tc.tmin) self.assertTrue(all(tr.get_ydata() == tc.get_ydata())) else: self.assertTrue(all(tc == tr)) self.assertEqual(m, 0., 'misfit\'s m of equal traces is != 0')
def __init__(self, markers, stations=None): # Targets================================================ store_id = 'castor' if store_id=='local1': phase_ids_start = 'p|P|Pv20p|Pv35p' phase_ids_end = 's|S|Sv20s|Sv35s' if store_id=='very_local': phase_ids_start = 'p|P|Pv3p|Pv8p|Pv20p|Pv35p' phase_ids_end = 's|S|Sv3s|Sv8s|Sv20s|Sv35s' if store_id=='very_local_20Hz': phase_ids_start = 'begin_fallback|p|P|Pv1p|Pv3p|Pv8p|Pv20p|Pv35p' phase_ids_end = 's|S|Sv1s|Sv3s|Sv8s|Sv20s|Sv35s' if store_id=='very_local_20Hz': phase_ids_start = 'begin_fallback|p|P|Pv1p|Pv3p|Pv8p|Pv20p|Pv35p' phase_ids_end = 's|S|Sv1s|Sv3s|Sv8s|Sv20s|Sv35s' if store_id=='castor': # bug?! bei Pv1.5p gibt's bei nahen Entfernungen ein index ot of # bounds phase_ids_start = 'p|P|Pv12.5p|Pv2.5p|Pv18.5p|Pv20p|Pv35p' phase_ids_end= 's|S|Sv12.5s|Sv2.5s|Sv18.5s|Sv20s|Sv35s' # Event================================================== event = filter(lambda x: isinstance(x, gui_util.EventMarker), markers) assert len(event) == 1 event = event[0].get_event() event.magnitude = 4.3 event.moment_tensor = moment_tensor.MomentTensor( m=num.array([[0.0, 0.0, 1.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]])) # generate stations from olat, olon: if not stations: print 'Generating station distribution.' stations = du.station_distribution((event.lat,event.lon), [[10000., 4], [130000., 8]], rotate={3000.:45, 130000.:0}) targets = stations2targets(stations, store_id) derec_home = os.environ["DEREC_HOME"] store_dirs = [derec_home + '/fomostos'] engine = LocalEngine(store_superdirs=store_dirs) model = get_earthmodel_from_engine(engine, store_id) #TESTSOURCES=============================================== offset = 3*km zoffset= 1000. ref_source = event2source(event, 'DC', strike=37.3, dip=30, rake=-3) center_lat = ref_source.lat center_lon = ref_source.lon negative_lat_offset, negative_lon_offset = du.lat_lon_relative_shift( center_lat, center_lon, -offset, -offset) positive_lat_offset, positive_lon_offset = du.lat_lon_relative_shift( center_lat, center_lon, offset, offset) lats=num.linspace(negative_lat_offset, positive_lat_offset, 3) #lats = [ref_source.lat] lons=num.linspace(negative_lon_offset, positive_lon_offset, 3) #lons = [ref_source.lon] depths=num.linspace(ref_source.depth-zoffset, ref_source.depth+zoffset, 3) depths = [ref_source.depth] #strikes = num.linspace(ref_source.strike-90, ref_source.strike+90, 25) strikes = [ref_source.strike] #dips = num.linspace(ref_source.dip-45, ref_source.dip+45, 25) dips = [ref_source.dip] #rakes = num.linspace(ref_source.rake-180, ref_source.rake+180, 25) rakes = [ref_source.rake] print lats, '<- lats' print lons, '<- lons' print depths, '<- depths' print ref_source.lat, '<- event lat' print ref_source.lon, '<- event lon' print ref_source.depth, '<- event depth' print ref_source.strike, ref_source.dip, ref_source.rake, '<- event S D R' location_test_sources = [DCSource(lat=lat, lon=lon, depth=depth, time=event.time, strike=strike, dip=dip, rake=rake, magnitude=event.magnitude) for strike in strikes for dip in dips for rake in rakes for lat in lats for lon in lons for depth in depths] for s in location_test_sources: s.regularize() #========================================================== test_case = TestCase(location_test_sources, targets, engine, store_id, test_parameters={'lat':lats, 'lon':lons, 'depth':depths}) test_case.ref_source = ref_source test_case.request_data() print 'source location: ', test_case.ref_source reference_seismograms = make_reference_trace(test_case.ref_source, test_case.targets, engine) extended_ref_marker = du.chop_ranges(test_case.ref_source, test_case.targets, test_case.store, phase_ids_start, phase_ids_end) print('test data marker....') extended_test_marker = du.chop_ranges(test_case.sources, test_case.targets, test_case.store, phase_ids_start, phase_ids_end) test_case.test_markers = extended_test_marker test_case.ref_markers = extended_ref_marker print('chopping ref....') test_case.references = du.chop_using_markers( reference_seismograms.iter_results(), extended_ref_marker, t_shift_frac=0.1) print('chopping cand....') test_case.seismograms = du.chop_using_markers( test_case.response.iter_results(), extended_test_marker, t_shift_frac=0.1) norm = 2. #taper = trace.CosFader(xfade=4) # Seconds or samples? taper = trace.CosFader(xfrac=0.1) z, p, k = butter(4, (2.*num.pi*2. ,0.4*num.pi*2.) , 'bandpass', analog=True, output='zpk') z = num.array(z, dtype=complex) p = num.array(p, dtype=complex) k = num.complex(k) fresponse = trace.PoleZeroResponse(z,p,k) fresponse.regularize() setup = trace.MisfitSetup(norm=norm, taper=taper, domain='envelope', filter=fresponse) test_case.set_misfit_setup(setup) du.calculate_misfit(test_case) #test_case.yaml_dump() # Display results=================================================== #test_case.plot1d(order, event.lon) #test_case.contourf(xkey='lon', ykey='lat') test_case.check_plot({'lat':ref_source.lat, 'depth':ref_source.depth}) optics = OpticBase(test_case) #optics.plot_1d(fix_parameters={'lat':event.lat, 'lon':event.lon}) optics.gmt_map(stations=True, events=True)
def optimization(*params, **args): counter = params[1] Config = params[2] Wdf = params[3] FilterMeta = params[4] mint = params[5] maxt = params[6] TTTGridMap = params[7] Folder = params[8] Origin = params[9] ntimes = params[10] switch = params[11] ev = params[12] arrayfolder = params[13] syn_in = params[14] data = params[15] evpath = params[16] XDict = params[17] RefDict = params[18] workdepth = params[19] filterindex = params[20] Wdfs = params[21] networks = Config['networks'].split(',') params = num.asarray(params) parameter = num.ndarray.tolist(params) ASL_syn = [] C = config.Config (evpath) Config = C.parseConfig ('config') cfg = ConfigObj (dict=Config) if cfg.pyrocko_download() == True: Meta = C.readpyrockostations()# elif cfg.colesseo_input() == True: scenario = guts.load(filename=cfg.colosseo_scenario_yml()) scenario_path = cfg.colosseo_scenario_yml()[:-12] Meta = C.readcolosseostations(scenario_path) else: Meta = C.readMetaInfoFile() l = 0 for i in networks: arrayname = i arrayfolder = os.path.join (Folder['semb'],arrayname) network = Config[i].split('|') FilterMeta = ttt.filterStations (Meta,Config,Origin,network) if len(FilterMeta) < 3: continue W = XDict[i] refshift = RefDict[i] FilterMeta = cmpFilterMetavsXCORR (W, FilterMeta) Logfile.add ('BOUNDING BOX DIMX: %s DIMY: %s GRIDSPACING: %s \n' % (Config['dimx'],Config['dimy'],Config['gridspacing'])) f = open('../tttgrid/tttgrid_%s_%s_%s.pkl' % (ev.time, arrayname, workdepth), 'rb') TTTGridMap,mint,maxt = pickle.load(f) f.close() switch = filterindex tw = times.calculateTimeWindows (mint,maxt,Config,ev, switch) Wdf = Wdfs[l] semb_syn = doCalc_syn (counter,Config,Wdf,FilterMeta,mint,maxt,TTTGridMap, Folder,Origin,ntimes,switch, ev,arrayfolder, syn_in, parameter[0]) ASL_syn.append(semb_syn) counter += 1 l += 1 sembmax_syn = sembCalc.collectSemb(ASL_syn,Config,Origin,Folder,ntimes,len(networks),switch) misfit_list = [] # init a list for a all the singular misfits norm_list = [] # init a list for a all the singular normalizations taper = trace.CosFader(xfade=2.0) # Cosine taper with fade in and out of 2s. bw_filter = trace.ButterworthResponse(corner=0.000055, # in Hz order=4, type='high') # "low"pass or "high"pass setup = trace.MisfitSetup(description='Misfit Setup', norm=2, # L1 or L2 norm taper=taper, filter=bw_filter, domain='time_domain') nsamples = len(data) tmin = util.str_to_time('2010-02-20 15:15:30.100') tr = trace.Trace(station='TEST', channel='Z', deltat=0.5, tmin=tmin, ydata=data) syn = trace.Trace(station='TEST', channel='Z', deltat=0.5, tmin=tmin, ydata=sembmax_syn) misfit, norm = tr.misfit(candidate=syn, setup=setup) # calculate the misfit of a single observed trace with its synthetics # with the setup from above misfit_list.append(misfit), norm_list.append(norm) # append the misfit into a list global_misfit_normed = num.sqrt(num.nansum((num.asarray(misfit_list))**2) / # sum all the misfits and normalize to get a single minimizable value num.nansum((num.asarray(norm_list))**2)) return global_misfit_normed
def process(self, event, timing, bazi=None, slow=None, restitute=False, *args, **kwargs): ''' :param timing: CakeTiming. Uses the definition without the offset. :param fn_dump_center: filename to where center stations shall be dumped :param fn_beam: filename of beam trace :param model: earthmodel to use(optional) :param earthmodel to use(optional) :param network: network code(optional) :param station: station code(optional) ''' logger.debug('start beam forming') stations = self.stations network_code = kwargs.get('responses', None) network_code = kwargs.get('network', '') station_code = kwargs.get('station', 'STK') c_station_id = (network_code, station_code) t_shifts = [] lat_c, lon_c, z_c = self.c_lat_lon_z self.station_c = Station(lat=float(lat_c), lon=float(lon_c), elevation=float(z_c), depth=0., name='Array Center', network=c_station_id[0], station=c_station_id[1][:5]) fn_dump_center = kwargs.get('fn_dump_center', 'array_center.pf') fn_beam = kwargs.get('fn_beam', 'beam.mseed') if event: mod = cake.load_model(crust2_profile=(event.lat, event.lon)) dist = ortho.distance_accurate50m(event, self.station_c) ray = timing.t(mod, (event.depth, dist), get_ray=True) if ray is None: logger.error( 'None of defined phases available at beam station:\n %s' % self.station_c) return else: b = ortho.azimuth(self.station_c, event) if b >= 0.: self.bazi = b elif b < 0.: self.bazi = 360. + b self.slow = ray.p / (cake.r2d * cake.d2m) else: self.bazi = bazi self.slow = slow logger.info( 'stacking %s with slowness %1.4f s/km at back azimut %1.1f ' 'degrees' % ('.'.join(c_station_id), self.slow * cake.km, self.bazi)) lat0 = num.array([lat_c] * len(stations)) lon0 = num.array([lon_c] * len(stations)) lats = num.array([s.lat for s in stations]) lons = num.array([s.lon for s in stations]) ns, es = ortho.latlon_to_ne_numpy(lat0, lon0, lats, lons) theta = num.float(self.bazi * num.pi / 180.) R = num.array([[num.cos(theta), -num.sin(theta)], [num.sin(theta), num.cos(theta)]]) distances = R.dot(num.vstack((es, ns)))[1] channels = set() self.stacked = {} num_stacked = {} self.t_shifts = {} self.shifted_traces = [] taperer = trace.CosFader(xfrac=0.05) if self.diff_dt_treat == 'downsample': self.traces.sort(key=lambda x: x.deltat) elif self.diff_dt_treat == 'oversample': dts = [t.deltat for t in self.traces] for tr in self.traces: tr.resample(min(dts)) for tr in self.traces: if tr.nslc_id[:2] == c_station_id: continue tr = tr.copy(data=True) tr.ydata = tr.ydata.astype( num.float64) - tr.ydata.mean(dtype=num.float64) tr.taper(taperer) try: stack_trace = self.stacked[tr.channel] num_stacked[tr.channel] += 1 except KeyError: stack_trace = tr.copy(data=True) stack_trace.set_ydata(num.zeros(len(stack_trace.get_ydata()))) stack_trace.set_codes(network=c_station_id[0], station=c_station_id[1], location='', channel=tr.channel) self.stacked[tr.channel] = stack_trace channels.add(tr.channel) num_stacked[tr.channel] = 1 nslc_id = tr.nslc_id try: stats = list( filter( lambda x: util.match_nslc('%s.%s.%s.*' % x.nsl(), nslc_id), stations)) stat = stats[0] except IndexError: break i = stations.index(stat) d = distances[i] t_shift = d * self.slow t_shifts.append(t_shift) tr.shift(t_shift) self.t_shifts[tr.nslc_id[:2]] = t_shift if self.normalize_std: tr.ydata = tr.ydata / tr.ydata.std() if num.abs(tr.deltat - stack_trace.deltat) > 0.000001: if self.diff_dt_treat == 'downsample': stack_trace.downsample_to(tr.deltat) elif self.diff_dt_treat == 'upsample': raise Exception( 'something went wrong with the upsampling, previously') stack_trace.add(tr) self.shifted_traces.append(tr) if self.post_normalize: for ch, tr in self.stacked.items(): tr.set_ydata(tr.get_ydata() / num_stacked[ch]) self.save_station(fn_dump_center) self.checked_nslc([stack_trace]) self.save(stack_trace, fn_beam) return self.shifted_traces, stack_trace, t_shifts
def optimization(*params, **args): counter = params[1] Config = params[2] Wdf = params[3] FilterMeta = params[4] mint = params[5] maxt = params[6] TTTGridMap = params[7] Folder = params[8] Origin = params[9] ntimes = params[10] switch = params[11] ev = params[12] arrayfolder = params[13] syn_in = params[14] data = params[15] params = num.asarray(params) parameter = num.ndarray.tolist(params) # parameter = [val for sublist in parameter for val in sublist] semb_syn = doCalc_syn(counter, Config, Wdf, FilterMeta, mint, maxt, TTTGridMap, Folder, Origin, ntimes, switch, ev, arrayfolder, syn_in, parameter[0]) misfit_list = [] # init a list for a all the singular misfits norm_list = [] # init a list for a all the singular normalizations taper = trace.CosFader( xfade=2.0) # Cosine taper with fade in and out of 2s. bw_filter = trace.ButterworthResponse( corner=0.000055, # in Hz order=4, type='high') # "low"pass or "high"pass setup = trace.MisfitSetup( description='Misfit Setup', norm=2, # L1 or L2 norm taper=taper, filter=bw_filter, domain='time_domain') for t_data, t_syn in zip(data, semb_syn): nsamples = len(t_data) tmin = util.str_to_time('2010-02-20 15:15:30.100') tr = trace.Trace(station='TEST', channel='Z', deltat=0.5, tmin=tmin, ydata=t_data) syn = trace.Trace(station='TEST', channel='Z', deltat=0.5, tmin=tmin, ydata=t_syn) misfit, norm = tr.misfit( candidate=syn, setup=setup ) # calculate the misfit of a single observed trace with its synthetics # with the setup from above misfit_list.append(misfit), norm_list.append( norm) # append the misfit into a list global_misfit_normed = num.sqrt( num.nansum((num.asarray(misfit_list))**2) / # sum all the misfits and normalize to get a single minimizable value num.nansum((num.asarray(norm_list))**2)) print global_misfit_normed return global_misfit_normed
from pyrocko import trace import numpy as num # Let's create three traces: One trace as the reference (rt) and two as test # traces (tt1 and tt2): ydata1 = num.random.random(1000) ydata2 = num.random.random(1000) rt = trace.Trace(station='REF', ydata=ydata1) candidate1 = trace.Trace(station='TT1', ydata=ydata1) candidate2 = trace.Trace(station='TT2', ydata=ydata2) # Define a fader to apply before fft. taper = trace.CosFader(xfade=5) # Define a frequency response to apply before performing the inverse fft. # This can be basically any funtion, as long as it contains a function called # *evaluate*, which evaluates the frequency response function at a given list # of frequencies. # Please refer to the :py:class:`FrequencyResponse` class or its subclasses for # examples. # However, we are going to use a butterworth low-pass filter in this example. bw_filter = trace.ButterworthResponse(corner=2, order=4, type='low') # Combine all information in one misfit setup: setup = trace.MisfitSetup(description='An Example Setup', norm=2, taper=taper, filter=bw_filter, domain='time_domain') # Calculate misfits of each candidate against the reference trace:
# Where is your data stored?: datapath = '/media/usb/webnet/pole_zero/restituted_displacement/2013Mar' data_pile = pile.make_pile(datapath) # And the stations: stations = model.load_stations('/media/usb/webnet/meta/stations.pf') # Station code of the trace you want to scale agains: reference_id = 'NKC' # Frequency band to use: fband = {'order': 4, 'corner_hp': 1.0, 'corner_lp': 4.} # And a taper to avoid filtering artefacts. taper = trace.CosFader(xfrac=0.25) # Define a window to chop traces. In this case a static length of 20 # seconds will be used and the synthetic phase arrival will be in the # center. The relative position can be changed between 0 (phase at t=0) and # 1 (phase at t=tmax). window = autogain.StaticLengthWindow(static_length=20., phase_position=0.5) #candidate_fn = 'candidates2013new.pf' #candidates = [m.get_event() for m in gui_util.Marker.load_markers(candidate_fn)] # If you have a catalog of events that you want to use, load them and make # and event EventCollection from those events: #candidates = model.load_events('events.pf') #event_selector = autogain.EventCollection(events=candidates)
def __init__(self, network, reduction, wdir, event, weight=1., phase='P', component='Z', filter_corner=0.055, filter_order=4, filter_type='low', misfit_norm=2, taper_fade=2.0, base=0, sig_base=0, extension='', dist='Unif'): self.network = network self.reduction = reduction self.wdir = wdir self.event = event self.phase = phase self.component = component self.filter_corner = filter_corner self.filter_order = filter_order self.filter_type = filter_type self.misfit_norm = misfit_norm self.taper_fade = taper_fade self.sigmad = 1. / weight self.base = base self.sig_base = sig_base self.Mbase = 1 self.extension = extension self.dist = dist self.taper = trace.CosFader( xfade=self.taper_fade) # Cosine taper with fade in and out of 2s. self.bw_filter = trace.ButterworthResponse( corner=self.filter_corner, # in Hz order=self.filter_order, type=self.filter_type) # "low"pass or "high"pass self.setup = trace.MisfitSetup( description='Misfit Setup', norm=2, # L1 or L2 norm taper=self.taper, filter=self.bw_filter, domain='time_domain') # Possible domains are: # time_domain, cc_max_norm (correlation) # and frequency_domain self.events = [] self.events.extend(model.load_events(filename=wdir + self.event)) origin = gf.Source(lat=np.float(self.events[0].lat), lon=np.float(self.events[0].lon)) # print util.time_to_str(events[0].time) self.base_source = gf.MTSource.from_pyrocko_event(self.events[0]) self.base_source.set_origin(origin.lat, origin.lon) # print util.time_to_str(self.base_source.time), events[0].lon, events[0].lat # sys.exit() self.type = 'Waveform'
def call(self): self.cleanup() c_station_id = ('_', 'STK') if self.unit == 's/deg': slow_factor = 1. / onedeg elif self.unit == 's/km': slow_factor = 1. / 1000. slow = self.slow * slow_factor if self.stacked_traces is not None: self.add_traces(self.stacked_traces) viewer = self.get_viewer() if self.station_c: viewer.stations.pop(c_station_id) stations = self.get_stations() if len(stations) == 0: self.fail('No station meta information found') traces = list(self.chopper_selected_traces(fallback=True)) traces = [tr for trs in traces for tr in trs] visible_nslcs = [tr.nslc_id for tr in traces] stations = [ x for x in stations if util.match_nslcs("%s.%s.%s.*" % x.nsl(), visible_nslcs) ] if not self.lat_c or not self.lon_c or not self.z_c: self.lat_c, self.lon_c, self.z_c = self.center_lat_lon(stations) self.set_parameter('lat_c', self.lat_c) self.set_parameter('lon_c', self.lon_c) self.station_c = Station(lat=float(self.lat_c), lon=float(self.lon_c), elevation=float(self.z_c), depth=0., name='Array Center', network=c_station_id[0], station=c_station_id[1]) viewer.add_stations([self.station_c]) lat0 = num.array([self.lat_c] * len(stations)) lon0 = num.array([self.lon_c] * len(stations)) lats = num.array([s.lat for s in stations]) lons = num.array([s.lon for s in stations]) ns, es = ortho.latlon_to_ne_numpy(lat0, lon0, lats, lons) theta = num.float(self.bazi * num.pi / 180.) R = num.array([[num.cos(theta), -num.sin(theta)], [num.sin(theta), num.cos(theta)]]) distances = R.dot(num.vstack((es, ns)))[1] channels = set() self.stacked = {} num_stacked = {} self.t_shifts = {} shifted_traces = [] taperer = trace.CosFader(xfrac=0.05) if self.diff_dt_treat == 'downsample': traces.sort(key=lambda x: x.deltat) elif self.diff_dt_treat == 'oversample': dts = [t.deltat for t in traces] for tr in traces: tr.resample(min(dts)) for tr in traces: if tr.nslc_id[:2] == c_station_id: continue tr = tr.copy(data=True) tr.ydata = tr.ydata.astype(num.float64) tr.ydata -= tr.ydata.mean(dtype=num.float64) tr.taper(taperer) try: stack_trace = self.stacked[tr.channel] num_stacked[tr.channel] += 1 except KeyError: stack_trace = tr.copy(data=True) stack_trace.set_ydata(num.zeros(len(stack_trace.get_ydata()))) stack_trace.set_codes(network=c_station_id[0], station=c_station_id[1], location='', channel=tr.channel) self.stacked[tr.channel] = stack_trace channels.add(tr.channel) num_stacked[tr.channel] = 1 nslc_id = tr.nslc_id try: stats = [ x for x in stations if util.match_nslc('%s.%s.%s.*' % x.nsl(), nslc_id) ] stat = stats[0] except IndexError: break i = stations.index(stat) d = distances[i] t_shift = d * slow tr.shift(t_shift) stat = viewer.get_station(tr.nslc_id[:2]) self.t_shifts[stat] = t_shift if self.normalize_std: tr.ydata = tr.ydata / tr.ydata.std() if num.abs(tr.deltat - stack_trace.deltat) > 0.000001: if self.diff_dt_treat == 'downsample': stack_trace.downsample_to(tr.deltat) elif self.diff_dt_treat == 'upsample': print( 'something went wrong with the upsampling, previously') stack_trace.add(tr) if self.add_shifted: tr.set_station('%s_s' % tr.station) shifted_traces.append(tr) if self.post_normalize: for ch, tr in self.stacked.items(): tr.set_ydata(tr.get_ydata() / num_stacked[ch]) self.cleanup() for ch, tr in self.stacked.items(): if num_stacked[ch] > 1: self.add_trace(tr) if self.add_shifted: self.add_traces(shifted_traces)