From cdcd226c8742106d6074f5636895ffe621037102 Mon Sep 17 00:00:00 2001 From: Marcel Date: Wed, 24 Jul 2024 14:07:13 +0200 Subject: [PATCH 01/17] [initial] adding files from correlation picker --- pylot/correlation/parameters_adriaarray.yaml | 90 + .../pick_correlation_correction.py | 1861 +++++++++++++++++ .../submit_pick_corr_correction.sh | 40 + pylot/correlation/submit_to_grid_engine.py | 23 + 4 files changed, 2014 insertions(+) create mode 100644 pylot/correlation/parameters_adriaarray.yaml create mode 100644 pylot/correlation/pick_correlation_correction.py create mode 100755 pylot/correlation/submit_pick_corr_correction.sh create mode 100755 pylot/correlation/submit_to_grid_engine.py diff --git a/pylot/correlation/parameters_adriaarray.yaml b/pylot/correlation/parameters_adriaarray.yaml new file mode 100644 index 00000000..d49ca014 --- /dev/null +++ b/pylot/correlation/parameters_adriaarray.yaml @@ -0,0 +1,90 @@ +############################# correlation parameters ##################################### +# min_corr_stacking: minimum correlation coefficient for building beam trace +# min_corr_export: minimum correlation coefficient for pick export +# min_stack: minimum number of stations for building beam trace +# t_before: correlation window before pick +# t_after: correlation window after pick# +# cc_maxlag: maximum shift for initial correlation +# cc_maxlag2: maximum shift for second (final) correlation (also for calculating pick uncertainty) +# initial_pick_outlier_threshold: (hopefully) threshold for excluding large outliers of initial (AIC) picks +# export_threshold: automatically exclude all onsets which deviate more than this threshold from corrected taup onsets +# min_picks_export: minimum number of correlated picks for export +# min_picks_autopylot: minimum number of reference autopicks picks to continue with event +# check_RMS: do RMS check to search for restitution errors (very experimental) +# use_taupy_onsets: use taupy onsets as reference picks instead of external picks +# station_list: use the following stations as reference for stacking +# use_stacked_trace: use existing stacked trace if found (spare re-computation) +# data_dir: obspyDMT data subdirectory (e.g. 'raw', 'processed') +# pickfile_extension: use quakeML files (PyLoT output) with the following extension, e.g. '_autopylot' for pickfiles +# such as 'PyLoT_20170501_141822_autopylot.xml' + +logging: info +pick_phases: ['P', 'S'] + +# P-phase +P: + min_corr_stacking: 0.8 + min_corr_export: 0.6 + min_stack: 20 + t_before: 30. + t_after: 50. + cc_maxlag: 50. + cc_maxlag2: 5. + initial_pick_outlier_threshold: 30. + export_threshold: 2.5 + min_picks_export: 100 + min_picks_autopylot: 50 + check_RMS: True + use_taupy_onsets: False + station_list: ['HU.MORH', 'HU.TIH', 'OX.FUSE', 'OX.BAD'] + use_stacked_trace: False + data_dir: 'processed' + pickfile_extension: '_autopylot' + dt_stacking: [250, 250] + + # filter for first correlation (rough) + filter_options: + freqmax: 0.5 + freqmin: 0.03 + # filter for second correlation (fine) + filter_options_final: + freqmax: 0.5 + freqmin: 0.03 + + filter_type: bandpass + sampfreq: 20.0 + +# S-phase +S: + min_corr_stacking: 0.7 + min_corr_export: 0.6 + min_stack: 20 + t_before: 60. + t_after: 60. + cc_maxlag: 100. + cc_maxlag2: 25. + initial_pick_outlier_threshold: 30. + export_threshold: 5.0 + min_picks_export: 200 + min_picks_autopylot: 50 + check_RMS: True + use_taupy_onsets: False + station_list: ['HU.MORH','HU.TIH', 'OX.FUSE', 'OX.BAD'] + use_stacked_trace: False + data_dir: 'processed' + pickfile_extension: '_autopylot' + dt_stacking: [250, 250] + + # filter for first correlation (rough) + filter_options: + freqmax: 0.1 + freqmin: 0.01 + + # filter for second correlation (fine) + filter_options_final: + freqmax: 0.2 + freqmin: 0.01 + + filter_type: bandpass + sampfreq: 20.0 + diff --git a/pylot/correlation/pick_correlation_correction.py b/pylot/correlation/pick_correlation_correction.py new file mode 100644 index 00000000..ce8d3d00 --- /dev/null +++ b/pylot/correlation/pick_correlation_correction.py @@ -0,0 +1,1861 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- + +import sys +import argparse +import copy +import logging +import random +import traceback + +import matplotlib.pyplot as plt +import yaml +from code_base.fmtomo_tools.fmtomo_teleseismic_utils import * +from code_base.util.utils import get_metadata +from joblib import Parallel, delayed +from obspy import read, Stream +from obspy.core.event.base import WaveformStreamID, ResourceIdentifier +from obspy.core.event.origin import Pick +from obspy.signal.cross_correlation import correlate, xcorr_max +from pylot.core.io.inputs import PylotParameter +from pylot.core.io.phases import picks_from_picksdict +from pylot.core.pick.autopick import autopickstation +from pylot.core.util.utils import check4rotated +from pylot.core.util.utils import identifyPhaseID +from pylot.core.util.event import Event as PylotEvent + +class CorrelationParameters(object): + """ + :param filter_type: filter type for data (e.g. bandpass) + :param filter_options: filter options (min/max_freq etc.) + :param filter_options_final: filter options for second iteration, final pick (min/max_freq etc.) + :param freq: resampling frequence (IMPORTANT for correlation) + :param station_list: list of stations used as possible reference stations + :param min_corr_stacking: minimum correlation coefficient for stacking (between 0 and 1) + :param min_corr_export: minimum correlation coefficient for export (between 0 and 1) + :param min_stack: minimum number of stacks for exporting of picks + :param t_before: time before initial pick taken into account + :param t_after: time after initial pick taken into account + :param initial_pick_outlier_threshold: remove initial picks that differ more than x seconds from median corrected + taupy onset + :param export_threshold: remove final correlated picks that differ more than x seconds from (newly calculated) + median corrected taupy onsets + :param cc_maxlag: cross correlation shift + :param plot: plot results + :param plot_detailed: make detailed plots (of every trace) + :param save_fig: save figures + :param use_taupy_onsets: use taupy theoretical onsets instead of initial picks from folders (bool) + :param ncores: number of processed spawned for correlation (multiprocessing) + :param use_stacked_trace: use existing trace of previous correlation (e.g. when adding more data to an already + evaluated event) + :param data_dir: obspy_dmt data dir (processed/raw) + """ + + def __init__(self, **kwargs): + self.__parameter = {} + self.add_parameters(**kwargs) + + # String representation of the object + def __repr__(self): + return "CorrelationParameters " + + # Boolean test + def __nonzero__(self): + return bool(self.__parameter) + + def __getitem__(self, key): + return self.__parameter.get(key) + + def __setitem__(self, key, value): + self.__parameter[key] = value + + def __delitem__(self, key): + del self.__parameter[key] + + def __iter__(self): + return iter(self.__parameter) + + def __len__(self): + return len(self.__parameter.keys()) + + def add_parameters(self, **kwargs): + for key, value in kwargs.items(): + self.__parameter[key] = value + + +class Xcorr_pick_correction: + def __init__(self, pick1, trace1, pick2, trace2, t_before, t_after, cc_maxlag, frac_max=0.5): + """ + MP MP : Modified version of obspy xcorr_pick_correction + + Calculate the correction for the differential pick time determined by cross + correlation of the waveforms in narrow windows around the pick times. + For details on the fitting procedure refer to [Deichmann1992]_. + + The parameters depend on the epicentral distance and magnitude range. For + small local earthquakes (Ml ~0-2, distance ~3-10 km) with consistent manual + picks the following can be tried:: + + t_before=0.05, t_after=0.2, cc_maxlag=0.10, + + The appropriate parameter sets can and should be determined/verified + visually using the option `plot=True` on a representative set of picks. + + To get the corrected differential pick time calculate: ``((pick2 + + pick2_corr) - pick1)``. To get a corrected differential travel time using + origin times for both events calculate: ``((pick2 + pick2_corr - ot2) - + (pick1 - ot1))`` + + :type pick1: :class:`~obspy.core.utcdatetime.UTCDateTime` + :param pick1: Time of pick for `trace1`. + :type trace1: :class:`~obspy.core.trace.Trace` + :param trace1: Waveform data for `pick1`. Add some time at front/back. + The appropriate part of the trace is used automatically. + :type pick2: :class:`~obspy.core.utcdatetime.UTCDateTime` + :param pick2: Time of pick for `trace2`. + :type trace2: :class:`~obspy.core.trace.Trace` + :param trace2: Waveform data for `pick2`. Add some time at front/back. + The appropriate part of the trace is used automatically. + :type t_before: float + :param t_before: Time to start cross correlation window before pick times + in seconds. + :type t_after: float + :param t_after: Time to end cross correlation window after pick times in + seconds. + :type cc_maxlag: float + :param cc_maxlag: Maximum lag/shift time tested during cross correlation in + seconds. + :rtype: (float, float) + :returns: Correction time `pick2_corr` for `pick2` pick time as a float and + corresponding correlation coefficient. + """ + + self.trace1 = trace1 + self.trace2 = trace2 + + self.pick1 = pick1 + self.pick2 = pick2 + + self.cc_maxlag = cc_maxlag + self.t_before = t_before + self.t_after = t_after + self.frac_max = frac_max + + self.samp_rate = 0 + + # perform some checks on the traces + self.check_traces() + + # check data and take correct slice of traces + self.tr1_slice = self.slice_trace(self.trace1, self.pick1) + self.tr2_slice = self.slice_trace(self.trace2, self.pick2) + + def check_traces(self): + if self.trace1.stats.sampling_rate != self.trace2.stats.sampling_rate: + msg = "Sampling rates do not match: %s != %s" % ( + self.trace1.stats.sampling_rate, self.trace2.stats.sampling_rate) + raise Exception(msg) + self.samp_rate = self.trace1.stats.sampling_rate + + def slice_trace(self, tr, pick): + start = pick - self.t_before - (self.cc_maxlag / 2.0) + end = pick + self.t_after + (self.cc_maxlag / 2.0) + # check if necessary time spans are present in data + if tr.stats.starttime > start: + msg = f"Trace {tr.id} starts too late." + raise Exception(msg) + if tr.stats.endtime < end: + msg = f"Trace {tr.id} ends too early." + raise Exception(msg) + # apply signal processing and take correct slice of data + return tr.slice(start, end) + + def cross_correlation(self, plot, fig_dir, plot_name, min_corr=None): + + def get_timeaxis(trace): + return np.linspace(0,trace.stats.endtime -trace.stats.starttime, trace.stats.npts) + + def plot_cc(fig_dir, plot_name): + if fig_dir and os.path.isdir(fig_dir): + filename = os.path.join(fig_dir, 'corr_{}_{}.svg'.format(self.trace2.id, plot_name)) + else: + filename = None + # with MatplotlibBackend(filename and "AGG" or None, sloppy=True): + + fig = plt.figure(figsize=(16, 9)) + ax1 = fig.add_subplot(211) + tmp_t1 = get_timeaxis(self.tr1_slice) + tmp_t2 = get_timeaxis(self.tr2_slice) + # MP MP normalize slices (not only by positive maximum! + tr1_slice_norm = self.tr1_slice.copy().normalize() + tr2_slice_norm = self.tr2_slice.copy().normalize() + ax1.plot(tmp_t1, tr1_slice_norm.data, "b", label="Trace 1 (reference)", lw=0.75) + ax1.plot(tmp_t2, tr2_slice_norm.data, "g--", label="Trace 2 (pick shifted)", lw=0.75) + ax1.plot(tmp_t2 - dt, tr2_slice_norm.data, "k", label="Trace 2 (correlation shifted)", lw=1.) + delta_pick_ref = (self.pick1 - self.tr1_slice.stats.starttime) + # correct pick time shift in traces for trace1 + ax1.axvline(delta_pick_ref, color='k', linestyle='dashed', label='Pick', lw=0.5) + ylims = ax1.get_ylim() + ax1.fill_between([delta_pick_ref - uncert, delta_pick_ref + uncert], ylims[0], ylims[1], alpha=.25, + color='g', label='pick uncertainty)'.format(self.frac_max)) + ax1.legend(loc="lower right", prop={'size': "small"}) + ax1.set_title("Correlated {} with {}".format(self.tr2_slice.id, self.tr1_slice.id)) + ax1.set_xlabel("time [s]") + ax1.set_ylabel("norm. amplitude") + ax2 = fig.add_subplot(212) + ax2.plot(cc_t, cc_convex, ls="", marker=".", color="k", label="xcorr (convex)") + ax2.plot(cc_t, cc_concave, ls="", marker=".", color="0.7", label="xcorr (concave)") + ax2.plot(cc_t[first_sample:last_sample + 1], cc[first_sample:last_sample + 1], "b.", + label="used for fitting") + tmp_t = np.linspace(cc_t[first_sample], cc_t[last_sample], num_samples * 10) + ax2.plot(tmp_t, np.polyval(coeffs, tmp_t), "b", label="fit") + ax2.axvline(-dt, color="g", label="vertex") + ax2.axhline(coeff, color="g") + ax2.hlines(self.frac_max * fmax, -dt - 0.5 * fwfm, -dt + 0.5 * fwfm, color='r', label='FWFM') + fill_color = 'r' if min_corr and coeff < min_corr else 'c' + ax2.fill_between([-dt - 0.5 * fwfm, -dt + 0.5 * fwfm], coeff, 1, alpha=.25, color=fill_color, + label='pick error') + ax2.set_xlabel("%.2f at %.3f s correction. Pickerror: %.2f s" % (coeff, -dt, uncert)) + ax2.set_ylabel("correlation coefficient") + ax2.set_ylim(-1, 1) + ax2.set_xlim(cc_t[0], cc_t[-1]) + ax2.legend(loc="lower right", prop={'size': "x-small"}) + # plt.legend(loc="lower left") + if filename: + fig.savefig(filename) + else: + plt.show() + + plt.close(fig) + + # start of cross correlation method + shift_len = int(self.cc_maxlag * self.samp_rate) + cc = correlate(self.tr1_slice.data, self.tr2_slice.data, shift_len, demean=False) + _cc_shift, cc_max = xcorr_max(cc) + cc_curvature = np.concatenate((np.zeros(1), np.diff(cc, 2), np.zeros(1))) + cc_convex = np.ma.masked_where(np.sign(cc_curvature) >= 0, cc) + cc_concave = np.ma.masked_where(np.sign(cc_curvature) < 0, cc) + + # check results of cross correlation + if cc_max < 0: + msg = "Trace: {} Absolute maximum is negative: {:.3}. Set cc_max to 0" + logging.debug(msg.format(self.trace2.id, cc_max)) + cc_max = 0 + + # make array with time shifts in seconds corresponding to cc function + cc_t = np.linspace(-self.cc_maxlag, self.cc_maxlag, len(cc)) + # take the subportion of the cross correlation around the maximum that is + # convex and fit a parabola. + # use vertex as subsample resolution best cc fit. + peak_index = cc.argmax() + first_sample = peak_index + # XXX this could be improved.. + while first_sample > 0 and cc_curvature[first_sample - 1] <= 0: + first_sample -= 1 + last_sample = peak_index + while last_sample < len(cc) - 1 and cc_curvature[last_sample + 1] <= 0: + last_sample += 1 + if first_sample == 0 or last_sample == len(cc) - 1: + msg = "Fitting at maximum lag. Maximum lag time should be increased." + logging.debug(msg) + + # work on subarrays + num_samples = last_sample - first_sample + 1 + if num_samples < 3: + msg = "Less than 3 samples selected for fit to cross " + "correlation: %s" % num_samples + raise Exception(msg) + if num_samples < 5: + msg = "Less than 5 samples selected for fit to cross " + "correlation: %s" % num_samples + logging.debug(msg) + + # quadratic fit for small subwindow + coeffs, cov_mat = np.polyfit(cc_t[first_sample:last_sample + 1], cc[first_sample:last_sample + 1], deg=2, + full=False, cov=True)[:2] + + a, b, c = coeffs + + # check results of fit + if a >= 0: + msg = "Fitted parabola opens upwards!" + logging.debug(msg) + + # LON coordinate of vertex of parabola gives time shift to correct + # differential pick time. LAT coordinate gives maximum correlation + # coefficient. + dt = -b / 2.0 / a + coeff = (4 * a * c - b ** 2) / (4 * a) + + # this is the shift to apply on the time axis of `trace2` to align the + # traces. Actually we do not want to shift the trace to align it but we + # want to correct the time of `pick2` so that the traces align without + # shifting. This is the negative of the cross correlation shift. + # MP MP calculate full width at half maximum + fmax = coeff + fwfm = 2 * (np.sqrt((b / (2 * a)) ** 2 + (self.frac_max * fmax - c) / a)) + + # # calculated error using a and ccc + # if a < 0: + # asqrtcc = np.sqrt(-1. / a) * (1. - coeff) + # else: + # # warning already printed above + # asqrtcc = np.nan + + # uncertainty is half of two times the fwhm scaled by 1 - maxcc + uncert = fwfm * (1. - coeff) + if uncert < 0: + logging.warning('negative uncertainty. Check Parabola fit!!') + dt = -dt + pick2_corr = dt + + # set coeff to 0 if cc_max was negative + if cc_max == 0.: + coeff = 0. + + if plot: + try: + plot_cc(fig_dir, plot_name) + except Exception as e: + logging.error(f'{e}: {traceback.format_exc()}') + + return pick2_corr, coeff, uncert, fwfm + + +def correlation_main(database_path_dmt, pylot_infile_path, params, channel_config, istart=0, istop=1e9, update=False, + event_blacklist=None): + ''' + Main function of this program, correlates waveforms around theoretical, or other initial (e.g. automatic cf) picks + on one or more reference stations. + All stations with a correlation higher "min_corr_stacking" are stacked onto the station with the highest mean + correlation. The stacked seismogram will be re-picked using parameters set in "pylot_infile_path". + Finally, all other stations will be correlated with the re-picked, stacked seismogram around their theoretical (or + initial) onsets and the shifted pick time of the stacked seismogram will be assigned as their new pick time. + + :param database_path_dmt: obspy_dmt databse directory + :param pylot_infile_path: path containing input file for autoPyLoT (automatic picking parameters) + :param params: dictionary with parameter class objects + + :return: + ''' + assert os.path.isdir(database_path_dmt), 'Unrecognized directory {}'.format(database_path_dmt) + + tstart = datetime.now() + logging.info(50 * '#') + logging.info('Starting pick correlation script at {}'.format(tstart)) + logging.info('Eventindices selected: {} - {}'.format(istart, istop)) + logging.info(50 * '#') + + for phase_type in params.keys(): + if params[phase_type]['plot_detailed']: params[phase_type]['plot'] = True + + eventdirs = glob.glob(os.path.join(database_path_dmt, '*.?')) + + pylot_parameter = PylotParameter(pylot_infile_path) + + if event_blacklist: + with open(event_blacklist, 'r') as infile: + event_blacklist = [line.split('\n')[0] for line in infile.readlines()] + + # iterate over all events in "database_path_dmt" + for eventindex, eventdir in enumerate(eventdirs): + if not istart <= eventindex < istop: + continue + + # MP MP testing +++ + # ids_filter = ['20181229_033914.a'] + # if not os.path.split(eventdir)[-1] in ids_filter: + # continue + # MP MP testing --- + + logging.info('\n' + 100 * '#') + logging.info('Working on event {} ({}/{})'.format(eventdir, eventindex + 1, len(eventdirs))) + if event_blacklist and get_event_id(eventdir) in event_blacklist: + logging.info('Event on blacklist. Continue') + + correlate_event(eventdir, pylot_parameter, params=params, channel_config=channel_config, update=update) + + logging.info('Finished script after {} at {}'.format(datetime.now() - tstart, datetime.now())) + + +def get_estimated_inclination(stations_dict, origin, phases, model='ak135'): + ''' calculate a mean inclination angle for all stations for seismometer rotation to spare computation time''' + model = TauPyModel(model) + phases = [*phases.split(',')] + avg_lat = np.median([item['latitude'] for item in stations_dict.values()]) + avg_lon = np.median([item['longitude'] for item in stations_dict.values()]) + arrivals = model.get_ray_paths_geo(origin.depth, origin.latitude, origin.longitude, avg_lat, avg_lon, + phase_list=phases) + if len(arrivals) > 0: + return arrivals[0].incident_angle + + +def modify_horizontal_name(wfdata): + ''' This function only renames (does not rotate!) numeric channel IDs to be able to rotate them to LQT. It is + therefore not accurate and only used for picking with correlation. Returns a copy of the original stream. ''' + # wfdata = wfdata.copy() + stations = np.unique([tr.stats.station for tr in wfdata]) + for station in stations: + st = wfdata.select(station=station) + locations = np.unique([tr.stats.location for tr in st]) + for location in locations: + st = wfdata.select(station=station, location=location) + channels = [tr.stats.channel for tr in st] + check_numeric = [channel[-1].isnumeric() for channel in channels] + check_nonnumeric = [not (cn) for cn in check_numeric] + if not any(check_numeric): + continue + numeric_channels = np.array(channels)[check_numeric].tolist() + nonnumeric_channels = np.array(channels)[check_nonnumeric].tolist() + if not 'Z' in [nc[-1] for nc in nonnumeric_channels]: + logging.warning('Modify_horizontal_name failed: Only implemented for existing Z component! Return original data.') + return wfdata + numeric_characters = sorted([nc[-1] for nc in numeric_channels]) + if numeric_characters == ['1', '2']: + channel_dict = {'1': 'N', '2': 'E'} + elif numeric_characters == ['2', '3']: + channel_dict = {'2': 'N', '3': 'E'} + else: + logging.warning('Modify_horizontal_name failed: Channel order not implemented/unknown. Return original data.') + return wfdata + for tr in st: + channel = tr.stats.channel + for ch_key in channel_dict.keys(): + if channel[-1] == ch_key: + channel = channel[:-1] + channel_dict[ch_key] + tr.stats.channel = channel + + return wfdata + + +def cut_stream_to_same_length(wfdata): + def remove(wfdata, st): + for tr in st: + wfdata.remove(tr) + + stations = np.unique([tr.stats.station for tr in wfdata]) + for station in stations: + st = wfdata.select(station=station) + tstart = max([tr.stats.starttime for tr in st]) + tend = min([tr.stats.endtime for tr in st]) + if tstart > tend: + logging.info('Starttime > Endtime, remove stream from dataset:', str(st)) + remove(wfdata, st) + continue + st.trim(tstart, tend, pad=True, fill_value=0.) + # check for stream length + if len(st) < 3: + logging.info('Not enough traces in stream, remove it from dataset:', str(st)) + remove(wfdata, st) + continue + if st[0].stats.starttime != st[1].stats.starttime or st[1].stats.starttime != st[2].stats.starttime: + # in this case, tstart and tend have also changed + tstart = max([tr.stats.starttime for tr in st]) + tend = min([tr.stats.endtime for tr in st]) + sampling_rate = st[0].stats.sampling_rate + st.interpolate(sampling_rate=sampling_rate, method='linear', starttime=tstart) + st.trim(tstart, tend, pad=True, fill_value=0.) + + +def get_unique_phase(picks, rename_phases=None): + phases = [pick.phase_hint for pick in picks] + if rename_phases: + phases = [rename_phases[phase] if phase in rename_phases else phase for phase in phases] + + if len(set(phases)) == 1: + return phases[0] + + return False + + +def correlate_event(eventdir, pylot_parameter, params, channel_config, update): + rename_phases = {'Pdiff': 'P'} + + # create ObsPy event from .pkl file in dmt eventdir + event = get_event_obspy_dmt(eventdir) + # catch event id + event_id = get_event_id(eventdir) + if len(event.origins) > 1: + raise Exception('Ambiguous number of origins for event {}'.format(event)) + origin = event.origins[0] + # get metadata for current event from dmt_database + metadata = get_metadata(eventdir) + # get a dictionary containing coordinates for all sources + stations_dict = metadata.get_all_coordinates() + + # read processed (restituted) data (assume P and S are the same...) + wfdata_raw = get_data(eventdir, params['P']['data_dir'], headonly=False) + + # create dictionaries for final export of P and S phases together + # ps_correlation_dict = {} + # ps_taup_picks = {} + # ps_picks = {} + correlations_dict_stacked = {} + + # iterate over P and S to create one model each + for phase_type in params.keys(): + ncores = params[phase_type]['ncores'] + filter_type = params[phase_type]['filter_type'] + filter_options = params[phase_type]['filter_options'] + filter_options_final = params[phase_type]['filter_options_final'] + + logging.info('\n' + 100 * '#') + logging.info(f'Working on {phase_type} picks.') + logging.info('RMS check set to: {}'.format(params[phase_type]['check_RMS'])) + logging.info('Use TauPy onsets instead of picks: {}'.format(params[phase_type]['use_taupy_onsets'])) + logging.info('Use previously generated stacked trace: {}'.format(params[phase_type]['use_stacked_trace'])) + logging.info('Data directory: {}'.format(params[phase_type]['data_dir'])) + logging.info('Pick file extension: {}'.format(params[phase_type]['pickfile_extension'])) + + taupypicks_orig = get_taupy_picks(origin, stations_dict, pylot_parameter, phase_type=phase_type, + ncores=params[phase_type]['ncores']) + if not taupypicks_orig: + logging.info('No tau-p picks for event {} found.'.format(eventdir)) + continue + + # rename phase to actual phase from tau-p calculation if unique + true_phase_type = get_unique_phase(taupypicks_orig, rename_phases) + if not true_phase_type: + logging.info(f'Ambiguous phase information found in taupy-picks for event {event}. Continue with next one') + continue + + if update: + pickfile_path = os.path.join(eventdir, + get_pickfile_name_correlated(event_id, filter_options_final, true_phase_type)) + if os.path.isfile(pickfile_path): + logging.info( + f'Option "update" selected. Found file {pickfile_path}. Skipping phase {phase_type} for this event') + continue + + wfdata = wfdata_raw.copy() + # resample and filter + if params[phase_type]['sampfreq']: + wfdata = resample_parallel(wfdata, params[phase_type]['sampfreq'], ncores=params[phase_type]['ncores']) + else: + logging.warning('Resampling deactivated! ' + 'Make sure that the sampling rate of all input waveforms is identical') + + # pick-file-extension (file naming) + pfe = params[phase_type]['pickfile_extension'] + # get picks or taupy onsets + if params[phase_type]['use_taupy_onsets']: + method = 'taupy' + picks = taupypicks_orig + else: + method = 'auto' + # get all picks from PyLoT *.xml file + if not pfe.startswith('_'): pfe = '_' + pfe + picks = get_picks(eventdir, extension=pfe) + # take picks of selected phase only + picks = [pick for pick in picks if pick.phase_hint == phase_type] + # exclude quality 4 picks (invalid, mostly just beginning of trace) + picks = remove_invalid_picks(picks) + if not picks: + logging.info('No picks for event {} found.'.format(eventdir)) + continue + if len(picks) < params[phase_type]['min_picks_autopylot']: + logging.info('Not enough automatic picks for correlation. Continue!') + continue + # calculate corrected taupy picks and remove strong outliers + taupypicks_corr_initial, median_diff = get_corrected_taupy_picks(picks, taupypicks_orig) + picks = remove_outliers(picks, taupypicks_corr_initial, + params[phase_type]['initial_pick_outlier_threshold']) + + # # MP MP TEST # taupypicks, time_shift = get_corrected_taupy_picks(picks, taupypicks_orig, all_available=True) # # picks = copy.deepcopy(taupypicks) # for pick in picks: # pick.method_id.id = 'auto' # # MP MP + + if phase_type == 'S': + # check whether rotation to ZNE is possible (to get rid of horizontal channel 1,2,3) + # the two rotations here (first to ZNE then LQT) could, however, be optimised into one + wfdata = check4rotated(wfdata, metadata) + # if not, try to rename horizontal channels to allow rotation to LQT (however, less accurate) + wfdata = modify_horizontal_name(wfdata) + # get an average (one ray path calculation only to spare time) inclination angle + inclination = get_estimated_inclination(stations_dict, origin, phases=pylot_parameter['taup_phases'], + model='ak135') + # rotate ZNE -> LQT (also cut to same length) + wfdata = rotate_stream(wfdata, metadata=metadata, origin=origin, stations_dict=stations_dict, + channels=channels[phase_type], inclination=inclination, ncores=ncores) + + # make copies before filtering + wfdata_lowf = wfdata.copy() + wfdata_highf = wfdata.copy() + + if filter_type and filter_options: + wfdata_lowf.filter(type=filter_type, **filter_options) + wfdata_highf.filter(type=filter_type, **filter_options_final) + + channels_list = channel_config[phase_type] + + # make directory for correlation output + correlation_out_dir = create_correlation_output_dir(eventdir, filter_options_final, true_phase_type) + fig_dir = create_correlation_figure_dir(correlation_out_dir) if params[phase_type]['save_fig'] == True else '' + + if not params[phase_type]['use_stacked_trace']: + # first stack mastertrace by using stations with high correlation on that station in station list with the + # highest correlation coefficient + stack_result = stack_mastertrace(wfdata_lowf, wfdata_highf, wfdata, picks, params=params[phase_type], + channels=channels_list, method=method, fig_dir=fig_dir) + else: + stack_result = load_stacked_trace(eventdir, params[phase_type]['min_corr_stacking']) + + if not stack_result: + logging.info('No stack result. Continue.') + continue + + ############################################# + # NOW DO THE FINAL CORRELATION + # extract stack result + correlations_dict, nwst_id, trace_master, nstack = stack_result + + if params[phase_type]['plot']: + # plot correlations of traces used to generate stacked trace + plot_mastertrace_corr(nwst_id, correlations_dict, wfdata_lowf, stations_dict, picks, trace_master, method, + min_corr=params[phase_type]['min_corr_stacking'], title=eventdir + '_before_stacking', + fig_dir=fig_dir) + + # continue if there is not enough traces for stacking + if nstack < params[phase_type]['min_stack']: + logging.warning('Not enough traces to stack: {} (min_stack = {}). Skip this event'.format(nstack, + params[phase_type][ + 'min_stack'])) + continue + + # write unfiltered trace + trace_master.write(os.path.join(correlation_out_dir, '{}_stacked.mseed'.format(trace_master.id))) + + # now pick stacked trace with PyLoT for a more precise pick (use raw trace, gets filtered by autoPyLoT) + pick_stacked = repick_mastertrace(wfdata_lowf, trace_master, pylot_parameter, event, event_id, metadata, + phase_type, correlation_out_dir) + if not pick_stacked: + continue + + # correlate stations with repicked and stacked master trace + fig_dir_traces = make_figure_dirs(fig_dir, trace_master.id) + + # filter master trace which was stacked unfiltered + trace_master_highf = trace_master.copy() + trace_master_lowf = trace_master.copy() + if filter_type and filter_options: + trace_master_lowf.filter(filter_type, **filter_options) + trace_master_highf.filter(filter_type, **filter_options_final) + + input_list = prepare_correlation_input(wfdata_lowf, picks, channels_list, trace_master_lowf, pick_stacked, + params=params[phase_type], plot=params[phase_type]['plot'], + fig_dir=fig_dir_traces, ncorr=2, wfdata_highf=wfdata_highf, + trace_master_highf=trace_master_highf) + + if (params[phase_type]['plot_detailed'] and not fig_dir_traces) or ncores == 1: + correlations_dict_stacked = correlate_serial(input_list, plot=params[phase_type]['plot_detailed']) + else: + correlations_dict_stacked = correlate_parallel(input_list, ncores=ncores) + + # write output to correlation output directory + write_correlation_output(correlation_out_dir, correlations_dict, correlations_dict_stacked) + + # export picks to obspy_dmt directories + export_picks(eventdir=eventdir, + correlations_dict=get_stations_min_corr(correlations_dict_stacked, + params[phase_type]['min_corr_export']), + params=params[phase_type], picks=picks, taupypicks=taupypicks_orig, phase_type=true_phase_type, + pf_extension=pfe) + + # plot results + if params[phase_type]['plot']: + # some random stations for comparison + coords_master = stations_dict[nwst_id] + # stations2compare = get_random_stations(coords_master, stations_dict, 60) + # stations2compare = stations_dict + stations2compare = get_stations_min_corr(correlations_dict_stacked, + min_corr=params[phase_type]['min_corr_export']) + + if not stations2compare: + continue + + fig, axes = plot_stations(stations_dict, stations2compare, coords_master, correlations_dict_stacked, + trace_master, pick_stacked, window_title=eventdir) + if axes is not None: + # Note: method changed to 'auto' for exporting picks + plot_section(wfdata_lowf, trace_master, pick_stacked, picks, stations2compare, channels_list, + correlations_dict_stacked, method='auto', axes=axes) + if fig_dir: + fig.savefig(os.path.join(fig_dir, 'correlation_result.svg'), dpi=400) + try: + fig_stack = plot_stacked_trace_pick(trace_master, pick_stacked, pylot_parameter) + fig_stack.savefig(os.path.join(fig_dir, '{}.svg'.format(trace_master.id)), dpi=400) + plt.close(fig_stack) + except Exception as e: + logging.error('Could not plot stacked trace: {}'.format(e)) + else: + plt.show() + + plt.close(fig) + + if len(correlations_dict_stacked) > 0: + return True + + +def remove_outliers(picks, corrected_taupy_picks, threshold): + ''' delete a pick if difference to corrected taupy pick is larger than threshold''' + + n_picks = len(picks) + n_outl = 0 + n_no_ref = 0 + for index, pick in list(reversed(list(enumerate(picks)))): + taup_pick = get_pick4station(corrected_taupy_picks, network_code=pick.waveform_id.network_code, + station_code=pick.waveform_id.station_code, method='taupy') + if not taup_pick: + deleted = picks.pop(index) + logging.debug('Deleted pick as there is no taup reference pick found: {}'.format(deleted.waveform_id)) + n_no_ref += 1 + continue + diff = pick.time - taup_pick.time + if abs(diff) > threshold: + deleted = picks.pop(index) + logging.debug('Deleted pick outlier ({} seconds): {}'.format(diff, deleted.waveform_id)) + n_outl += 1 + + if n_outl: + logging.info(f'Remove_outliers: Removed {n_outl}/{n_picks} picks with over {threshold} ' + f'seconds difference to corrected theoretical onset.\n') + if n_no_ref: + logging.info(f'Remove_outliers: Removed {n_no_ref} picks because of missing reference theoretical onset.') + + return picks + + +def remove_invalid_picks(picks): + ''' Remove picks without uncertainty (invalid PyLoT picks)''' + count = 0 + deleted_picks_ids = [] + for index, pick in list(reversed(list(enumerate(picks)))): + uncert = pick.time_errors.uncertainty + if not uncert: + deleted = picks.pop(index) + deleted_picks_ids.append(deleted.waveform_id) + logging.debug('Removed invalid pick: {}'.format(deleted.waveform_id)) + count += 1 + logging.info('Removed {} invalid picks'.format(count)) + return picks + + +def get_picks_median(picks): + return UTCDateTime(int(np.median([pick.time.timestamp for pick in picks if pick.time]))) + + +def get_picks_mean(picks): + return UTCDateTime(np.mean([pick.time.timestamp for pick in picks if pick.time])) + + +def get_corrected_taupy_picks(picks, taupypicks, all_available=False): + ''' get mean/median from picks taupy picks, correct latter for the difference ''' + + def nwst_id_from_wfid(wfid): + return '{}.{}'.format(wfid.network_code if wfid.network_code else '', + wfid.station_code if wfid.station_code else '') + + taupypicks = copy.deepcopy(taupypicks) + # get taupypicks from same stations as there are picks to calculate median/mean of differences + picks_wf_ids = set([nwst_id_from_wfid(pick.waveform_id) for pick in picks]) + taupypicks_new = [pick for pick in taupypicks if nwst_id_from_wfid(pick.waveform_id) in picks_wf_ids] + + # calculate median and mean of differences + picks_median = get_picks_median(picks) + taupy_median = get_picks_median(taupypicks_new) + median_diff = taupy_median - picks_median + + picks_mean = get_picks_mean(picks) + taupy_mean = get_picks_mean(taupypicks_new) + mean_diff = taupy_mean - picks_mean + + logging.info(f'Calculated {len(taupypicks_new)} TauPy theoretical picks.') + logging.info('Calculated median difference from TauPy theoretical picks of {} seconds. (mean: {})'.format(median_diff, + mean_diff)) + + # return all available taupypicks corrected for median difference to autopicks + if all_available: + logging.info('Correcting and returning all available taupy-picks!') + taupypicks_new = copy.deepcopy(taupypicks) + + for pick in taupypicks_new: + pick.time -= median_diff + + return taupypicks_new, median_diff + + +def load_stacked_trace(eventdir, min_corr_stack): + # load stacked stream (miniseed) + str_stack_fpaths = glob.glob(os.path.join(eventdir, 'correlation', '*_stacked.mseed')) + if not len(str_stack_fpaths) == 1: + logging.warning('No stacked trace for event {} found!'.format(eventdir)) + return + str_stack_fpath = str_stack_fpaths[0] + + # load dictionary with correlations for stacking (json) + corr_dict_fpath = os.path.join(eventdir, 'correlation', 'correlations_for_stacking.json') + if not os.path.isfile(corr_dict_fpath): + logging.warning('No correlations_for_stacking dict found for event {}!'.format(eventdir)) + return + corr_dict = json.load(corr_dict_fpath) # TODO: Check this line + + # get stations for stacking and nstack + stations4stack = get_stations_min_corr(corr_dict, min_corr_stack) + nstack = len(stations4stack) + + stacked_stream = read(str_stack_fpath) + if len(stacked_stream) != 1: + raise Exception('N_traces!=1 in Stream') + stacked_trace = stacked_stream[0] + nwst_id = '{}.{}'.format(stacked_trace.stats.network, stacked_trace.stats.station) + + return corr_dict, nwst_id, stacked_trace, nstack + + +def repick_mastertrace(wfdata, trace_master, pylot_parameter, event, event_id, metadata, phase_type, corr_out_dir): + rename_LQT = phase_type == 'S' + # create an 'artificial' stream object which can be used as input for PyLoT + stream_master = modify_master_trace4pick(trace_master.copy(), wfdata, rename_LQT=rename_LQT) + stream_master.write(os.path.join(corr_out_dir, 'stacked_master_trace_pylot.mseed'.format(trace_master.id))) + try: + picksdict = autopickstation(stream_master, pylot_parameter, verbose=True, metadata=metadata, + origin=event.origins, iplot=0) + except Exception as e: + logging.error('Exception in autopickstation for event {}: {}'.format(event_id, str(e))) + logging.error(traceback.format_exc()) + return + + # modify input for picks_from_picksdict + picksdict = {trace_master.stats.station: picksdict[0]} + # transform to obspy pick + stacked_picks = picks_from_picksdict(picksdict) + # only this phase + stacked_picks = [pick for pick in stacked_picks if pick.phase_hint == phase_type] + # get pick from stacked picks + pick_stacked = get_pick4station(stacked_picks, network_code=trace_master.stats.network, + station_code=trace_master.stats.station, method='auto') + if not pick_stacked: + raise ValueError('Could not pick stacked trace of event {}. Abort'.format(event_id)) + + return pick_stacked + + +def create_correlation_output_dir(eventdir, fopts, phase_type): + folder = 'correlation' + folder = add_fpath_extension(folder, fopts, phase_type) + export_path = os.path.join(eventdir, folder) + if not os.path.isdir(export_path): + os.mkdir(export_path) + return export_path + + +def create_correlation_figure_dir(correlation_out_dir): + export_path = os.path.join(correlation_out_dir, 'figures') + if not os.path.isdir(export_path): + os.mkdir(export_path) + return export_path + + +def add_fpath_extension(fpath, fopts, phase): + if fopts: + freqmin, freqmax = fopts['freqmin'], fopts['freqmax'] + if freqmin: + fpath += f'_{freqmin}' + if freqmax: + fpath += f'-{freqmax}' + if phase: + fpath += f'_{phase}' + return fpath + + +def write_correlation_output(export_path, correlations_dict, correlations_dict_stacked): + write_json(correlations_dict, os.path.join(export_path, 'correlations_for_stacking.json')) + write_json(correlations_dict_stacked, os.path.join(export_path, 'correlation_results.json')) + + +def modify_master_trace4pick(trace_master, wfdata, rename_LQT=True): + ''' + Create an artificial Stream with master trace instead of the trace of its corresponding channel. + This is done to find metadata for correct station metadata which were modified when stacking (e.g. loc=ST) + USE THIS ONLY FOR PICKING! + ''' + # fake ZNE coordinates for autopylot + lqt_zne = {'L': 'Z', 'Q': 'N', 'T': 'E'} + + stream_master = Stream() + # select stream of master-trace station (includes master trace) + stream = wfdata.select(network=trace_master.stats.network, station=trace_master.stats.station) + # remove master trace from stream + for trace in stream.select(location='99'): + stream.remove(trace) + # iterate over all traces (except for master trace with location 99:) + for trace in stream: + # if trace should be overwritten with master-trace (same channel) + if trace.stats.channel == trace_master.stats.channel: + # take location from old trace and overwrite + trace_master.stats.location = trace.stats.location + trace = trace_master + if rename_LQT: + channel = trace.stats.channel + component_new = lqt_zne.get(channel[-1]) + if not component_new: + logging.warning('Could not rename LQT.') + continue + trace.stats.channel = channel[:-1] + component_new + # append to new stream + stream_master += trace + stream_master.trim(starttime=trace_master.stats.starttime, endtime=trace_master.stats.endtime) + stream_master.normalize() + return stream_master + + +def export_picks(eventdir, correlations_dict, picks, taupypicks, params, phase_type, pf_extension): + threshold = params['export_threshold'] + min_picks_export = params['min_picks_export'] + # make copy so that modified picks are not exported + new_picks = copy.deepcopy(picks) + # get current event + event_id = get_event_id(eventdir) + + event = get_event_pylot(eventdir, extension=pf_extension) + if not event: + event = PylotEvent(eventdir) + + # make safety copy of old picks + fname = get_pickfile_name(event_id, 'pre-correlated') + fpath_copy = write_event(event, eventdir, fname) + logging.info('Made safety copy of old pickfile: {}'.format(fpath_copy)) + + # iterate over picks and remove picks where correlation failed + for index, pick in reversed(list(enumerate(new_picks))): + network = pick.waveform_id.network_code + station = pick.waveform_id.station_code + nwst_id = '{}.{}'.format(network, station) + if nwst_id in correlations_dict: + dpick = correlations_dict[nwst_id]['dpick'] + ccc = correlations_dict[nwst_id]['ccc'] + uncertainty = correlations_dict[nwst_id]['uncertainty'] + # in case dpick and ccc exist, change pick attributes and go to next pick + if not np.isnan(dpick) and not np.isnan(ccc) and uncertainty > 0: + pick.time -= dpick + # modify resource id and phase hint for pylot + pick.method_id = ResourceIdentifier('auto') + pick.phase_hint = phase_type + # just a little error estimation for testing + pick.time_errors.uncertainty = uncertainty + pick.time_errors.lower_uncertainty = uncertainty + pick.time_errors.upper_uncertainty = uncertainty + continue + # in case pick is not in correlations dict or np.nan + new_picks.pop(index) + + if not new_picks: + logging.info('No picks left to export! Return.') + return + if len(new_picks) < min_picks_export: + logging.info('Not enough picks to export: {} (min: {}). Return'.format(len(new_picks), min_picks_export)) + return + + fopts = params['filter_options_final'] + + # correct taupypicks for new, correlated picks + taupypicks, time_shift = get_corrected_taupy_picks(new_picks, taupypicks, all_available=True) + + # save taupy picks to file + write_taupy_picks(event, eventdir, taupypicks, time_shift, + extension=add_fpath_extension('corrected_taup_times', fopts, phase_type)) + + # remove outliers (more than threshold [s] from corrected taupypicks) + new_picks = remove_outliers(new_picks, taupypicks, threshold) + + if len(new_picks) < min_picks_export: + logging.info( + 'Not enough picks to export after removing outliers: {} (min: {}). Return'.format(len(new_picks), + min_picks_export)) + return + + event.picks = new_picks + fname = get_pickfile_name_correlated(event_id, fopts, phase_type) + fpath = write_event(event, eventdir, fname) + + logging.info('Wrote {} correlated picks to file {}'.format(len(event.picks), fpath)) + + +def write_taupy_picks(event, eventdir, taupypicks, time_shift, extension='corrected_taup_times'): + # make copies because both objects are being modified + event = copy.deepcopy(event) + taupypicks = copy.deepcopy(taupypicks) + + # get eventname + eventname = os.path.split(eventdir)[-1] + + # save timeshift to file + with open(os.path.join(eventdir, 'taup_timeshift.txt'), 'w') as outfile: + outfile.write('{}\n'.format(time_shift)) + + # set method id to 'auto' for PyLoT + for pick in taupypicks: + pick.method_id = 'auto' + # artificial uncertainty + pick.time_errors.uncertainty = 0.0001 + event.picks = taupypicks + fname = get_pickfile_name(eventname, extension) + write_event(event, eventdir, fname) + + +def write_event(event, eventdir, fname): + fpath = os.path.join(eventdir, fname) + event.write(fpath, format='QUAKEML') + return fpath + + +def get_pickfile_name(event_id, fname_extension): + return 'PyLoT_{}_{}.xml'.format(event_id, fname_extension) + + +def get_pickfile_name_correlated(event_id, fopts, phase_type): + fname_extension = add_fpath_extension('correlated', fopts, phase_type) + return get_pickfile_name(event_id, fname_extension) + + +# def prepare_trace(wfdata, network_code, station_code, channels, freq): +# # get trace of this station +# for channel in channels: +# st_this = wfdata.select(network=network_code, station=station_code, channel=channel) +# if st_this: +# break +# if not st_this: +# return +# trace_this = st_this[0] +# +# # resample and filter trace +# trace_this.resample(freq) +# trace_this.filter('bandpass', freqmin=0.03, freqmax=0.5) +# return trace_this + + +def prepare_correlation_input(wfdata, picks, channels, trace_master, pick_master, params, plot=None, fig_dir=None, + ncorr=1, wfdata_highf=None, trace_master_highf=None): + # prepare input for multiprocessing worker for all 'other' picks to correlate with current master-trace + input_list = [] + + assert (ncorr in [1, 2]), 'ncorr has to be 1 or 2' + + for pick_other in picks: + trace_other_highf = None + network_other = pick_other.waveform_id.network_code + station_other = pick_other.waveform_id.station_code + nwst_id_other = '{nw}.{st}'.format(nw=network_other, st=station_other) + if not pick_other.time: + logging.debug('No pick for station {nwst}!'.format(nwst=nwst_id_other)) + continue + for channel in channels: + stream_other = wfdata.select(network=network_other, station=station_other, channel=channel) + if ncorr == 2: + stream_other_highf = wfdata_highf.select(network=network_other, station=station_other, channel=channel) + if stream_other: + break + if not stream_other: + logging.debug('No waveform data for station {nwst}!'.format(nwst=nwst_id_other)) + continue + trace_other = stream_other[0] + if ncorr == 2: + trace_other_highf = stream_other_highf[0] + if trace_other == stream_other: + continue + + input_dict = {'nwst_id': nwst_id_other, 'trace1': trace_master, 'pick1': pick_master, 'trace2': trace_other, + 'pick2': pick_other, 'channel': channel, 't_before': params['t_before'], + 't_after': params['t_after'], 'cc_maxlag': params['cc_maxlag'], + 'cc_maxlag2': params['cc_maxlag2'], 'plot': plot, 'fig_dir': fig_dir, 'ncorr': ncorr, + 'trace1_highf': trace_master_highf, 'trace2_highf': trace_other_highf, + 'min_corr': params['min_corr_export']} + input_list.append(input_dict) + + return input_list + + +def stack_mastertrace(wfdata_lowf, wfdata_highf, wfdata_raw, picks, params, channels, method, fig_dir): + ''' + Correlate all stations with the first available station given in station_list, a list containing central, + permanent, long operating, low noise stations with descending priority. + A master trace will be created by stacking well correlating traces onto this station. + ''' + + def get_best_station4stack(station_results): + ''' return station with maximum mean_ccc''' + ccc_means = {nwst_id: value['mean_ccc'] for nwst_id, value in station_results.items() if + not np.isnan(value['mean_ccc'])} + if len(ccc_means) < 1: + logging.warning('No valid station found for stacking! Return.') + return + best_station_id = max(ccc_means, key=ccc_means.get) + logging.info('Found highest mean correlation for station {} ({})'.format(best_station_id, max(ccc_means.values()))) + return best_station_id + + station_results = iterate_correlation(wfdata_lowf, wfdata_highf, channels, picks, method, params, fig_dir=fig_dir) + nwst_id_master = get_best_station4stack(station_results) + + # in case no stream with a valid pick is found + if not nwst_id_master: + logging.info('No mastertrace found! Will skip this event.') + return False + + trace_master = station_results[nwst_id_master]['trace'] + stations4stack = station_results[nwst_id_master]['stations4stack'] + correlations_dict = station_results[nwst_id_master]['correlations_dict'] + + wfdata_highf += trace_master + + dt_pre, dt_post = params['dt_stacking'] + trace_master, nstack = apply_stacking(trace_master, stations4stack, wfdata_raw, picks, method=method, + check_RMS=params['check_RMS'], plot=params['plot'], fig_dir=fig_dir, + dt_pre=dt_pre, dt_post=dt_post) + + return correlations_dict, nwst_id_master, trace_master, nstack + + +def iterate_correlation(wfdata_lowf, wfdata_highf, channels, picks, method, params, fig_dir=None): + '''iterate over possible stations for master-trace store them and return a dictionary''' + + station_results = {nwst_id: {'mean_ccc': np.nan, 'correlations_dict': None, 'stations4stack': None, 'trace': None} + for nwst_id in params['station_list']} + + for nwst_id_master in params['station_list']: + logging.info(20 * '#') + logging.info('Starting correlation for station: {}'.format(nwst_id_master)) + nw, st = nwst_id_master.split('.') + for channel in channels: + stream_master_lowf = wfdata_lowf.select(network=nw, station=st, channel=channel) + stream_master_highf = wfdata_highf.select(network=nw, station=st, channel=channel) + # TODO: Account for Q and T + if stream_master_lowf and stream_master_highf: + break + if not stream_master_lowf and not stream_master_highf: + continue + pick_master = get_pick4station(picks, nw, st, method) + if not pick_master or not pick_master.time: + continue + + # prepare master-trace + trace_master_lowf = stream_master_lowf[0] + trace_master_highf = stream_master_highf[0] + + # make new trace with artificial location ID + trace_master_lowf = trace_master_lowf.copy() + trace_master_highf = trace_master_highf.copy() + trace_master_highf.stats.location = '99' + + # trace_master.resample(freq) + # trace_master.filter(filter_type, **filter_options) + + fig_dir_traces = '' + if fig_dir and os.path.isdir(fig_dir): + fig_dir_traces = os.path.join(fig_dir, 'corr_with_{}'.format(trace_master_highf.id)) + if not os.path.isdir(fig_dir_traces): + os.mkdir(fig_dir_traces) + + input_list = prepare_correlation_input(wfdata_lowf, picks, channels, trace_master_lowf, pick_master, + trace_master_highf=trace_master_highf, wfdata_highf=wfdata_highf, + params=params, plot=params['plot_detailed'], fig_dir=fig_dir_traces, + ncorr=2) + + if params['plot_detailed'] and not fig_dir_traces: + # serial + correlations_dict = correlate_serial(input_list, plot=True) + else: + # parallel + correlations_dict = correlate_parallel(input_list, ncores=params['ncores']) + + stations4stack = get_stations_min_corr(correlations_dict, min_corr=params['min_corr_stacking']) + + station_results[nwst_id_master]['mean_ccc'] = np.nanmean([item['ccc'] for item in correlations_dict.values()]) + station_results[nwst_id_master]['correlations_dict'] = correlations_dict + station_results[nwst_id_master]['stations4stack'] = stations4stack + station_results[nwst_id_master]['trace'] = trace_master_lowf + + return station_results + + +def apply_stacking(trace_master, stations4stack, wfdata, picks, method, check_RMS, dt_pre=250., dt_post=250., + plot=False, fig_dir=None): + def check_trace_length_and_cut(trace, correlated_midtime, dt_pre, dt_post): + starttime = correlated_midtime - dt_pre + endtime = correlated_midtime + dt_post + + if trace.stats.starttime > starttime or trace.stats.endtime < endtime: + raise ValueError('Trace too short for safe cutting. Would create inconsistent stacking. Abort!') + + trace.trim(starttime=starttime, endtime=endtime) + + traces4stack = [] + + pick = get_pick4station(picks, trace_master.stats.network, trace_master.stats.station, method) + + trace_master = trace_master.copy() + trace_master.stats.location = 'ST' + check_trace_length_and_cut(trace_master, pick.time, dt_pre=dt_pre, dt_post=dt_post) + + # empty trace so that it does not stack twice + trace_master.data = np.zeros(len(trace_master.data)) + + count = 0 + for nwst_id, corr_result in stations4stack.items(): + nw, st = nwst_id.split('.') + pick_other = get_pick4station(picks, nw, st, method) + dpick = corr_result['dpick'] + channel = corr_result['channel'] + stream_other = wfdata.select(network=nw, station=st, channel=channel) + correlated_midtime = pick_other.time - dpick + trace_other = stream_other[0].copy() + check_trace_length_and_cut(trace_other, correlated_midtime, dt_pre=dt_pre, dt_post=dt_post) + + if not len(trace_other) == len(trace_master): + logging.warning('Can not stack trace on master trace because of different lengths: {}. Continue'.format(nwst_id)) + continue + + traces4stack.append(trace_other) + + if check_RMS: + traces4stack = checkRMS(traces4stack, plot=plot, fig_dir=fig_dir) + + if plot: + fig = plt.figure(figsize=(16, 9)) + ax1 = fig.add_subplot(211) + ax2 = fig.add_subplot(212) + + for trace_other in traces4stack: + # stack on mastertrace + trace_normalized = trace_other.copy().normalize() + trace_master.data += trace_normalized.data + count += 1 + if plot: + ax1.plot(trace_master.data, label=count) + ax2.plot(trace_normalized.data, color='k', alpha=0.1) + + if plot: + if fig_dir: + fig.savefig(os.path.join(fig_dir, 'traces_stacked.svg'), dpi=300.) + else: + fig.show() + + plt.close(fig) + + logging.info('Successfully stacked {} traces onto master trace.'.format(count)) + + return trace_master, count + + +def checkRMS(traces4stack, plot=False, fig_dir=None, max_it=10, ntimes_std=5.): + rms_list = [] + trace_names = [] + + traces4stack = sorted(traces4stack, key=lambda x: x.id) + + for trace in traces4stack: + rms_list.append(RMS(trace.data)) + trace_names.append(trace.id) + + # iterative elimination of RMS outliers + iterate = True + count = 0 + while iterate: + count += 1 + if count >= max_it: + logging.debug('Maximum iterations ({}) of checkRMS function reached.'.format(max_it)) + break + std = np.std(rms_list) + mean = np.mean(rms_list) + + iterate = False + for index, tr_rms in list(reversed(list(enumerate(zip(traces4stack, rms_list))))): + trace, rms = tr_rms + if not mean - ntimes_std * std <= rms <= mean + ntimes_std * std: + logging.debug('Removing trace {}.{} because of strong RMS deviation.'.format(trace.stats.network, + trace.stats.station)) + if plot: + plot_rms(rms_list, trace_names, mean, std, fig_dir, count, ntimes_std) + + traces4stack.remove(trace) + rms_list.pop(index) + trace_names.pop(index) + iterate = True + + if plot: + plot_rms(rms_list, trace_names, mean, std, fig_dir, count, ntimes_std) + + return traces4stack + + +def plot_rms(rms_list, trace_names, mean, std, fig_dir, count, ntimes_std): + fig = plt.figure(figsize=(16, 9)) + ax = fig.add_subplot(111) + ax.semilogy(rms_list, 'b.') + ax.axhline(mean, color='k', linestyle='-') + ax.axhline(mean + ntimes_std * std, color='k', linestyle='--') + ax.axhline(mean - ntimes_std * std, color='k', linestyle='--') + ax.set_ylabel('RMS [m/s]') + ax.set_xticks(list(range(len(trace_names)))) + ax.set_xticklabels(trace_names, rotation=90, fontsize=2) + if fig_dir: + fig.savefig(os.path.join(fig_dir, 'RMS_check_{:02}.svg'.format(count)), dpi=400.) + else: + plt.show() + + plt.close(fig) + + +def RMS(X): + """ + Returns root mean square of a given array LON + """ + return np.sqrt(np.sum(np.power(X, 2)) / len(X)) + + +def resample_parallel(stream, freq, ncores): + input_list = [{'trace': trace, 'freq': freq} for trace in stream.traces] + + parallel = Parallel(n_jobs=ncores) + + logging.info('Resample_parallel: Generated {} parallel jobs.'.format(ncores)) + output_list = parallel(delayed(resample_worker)(item) for item in input_list) + + logging.info('Parallel execution finished.') + + stream.traces = output_list + return stream + + +def rotate_stream(stream, metadata, origin, stations_dict, channels, inclination, ncores): + ''' Rotate stream to LQT. To do this all traces have to be cut to equal lenths''' + input_list = [] + cut_stream_to_same_length(stream) + new_stream = Stream() + # nwst_ids = np.unique([f'{tr.stats.network}.{tr.stats.station}' for tr in stream]) + # for nwst_id in nwst_ids: + # if not nwst_id in stations_dict.keys(): + # logging.info(f'{nwst_id} not found') + for nwst_id, rec_coords in stations_dict.items(): + if not rec_coords: continue + nw, sta = nwst_id.split('.') + st = stream.select(network=nw, station=sta) + if not st: + logging.debug(f'No stream for {nwst_id}') + continue + locations = np.unique([tr.stats.location for tr in st]) + # TODO: Take other locations into account? Excluded here due to possible ambiguity with usage of nwst_id + for location in locations: + st = stream.select(network=nw, station=sta, location=location) + dic = {'stream': st, 'src_lat': origin.get('latitude'), 'src_lon': origin.get('longitude'), + 'rec_lat': rec_coords.get('latitude'), 'rec_lon': rec_coords.get('longitude'), + 'inclination': inclination} + + rotation_worker(dic) + new_stream += st # input_list.append(dic) + + logging.info(50 * '#') + logging.info(f'LENGTH NEW STREAM: {len(new_stream)}, LENGTH OLD STREAM: {len(stream)}') + logging.info(50 * '#') + + return new_stream + + pool = multiprocessing.Pool(ncores, maxtasksperchild=100) + logging.info('Resample_parallel: Generated multiprocessing pool with {} cores.'.format(ncores)) + output_list = pool.map(rotation_worker, input_list, chunksize=10) + pool.close() + logging.info('Closed multiprocessing pool.') + pool.join() + del (pool) + stream.traces = [tr for tr in output_list if tr is not None] + return stream + + +def correlate_parallel(input_list, ncores): + parallel = Parallel(n_jobs=ncores) + + logging.info('Correlate_parallel: Generated {} parallel jobs.'.format(ncores)) + correlation_result = parallel(delayed(correlation_worker)(item) for item in input_list) + + logging.info('Parallel execution finished.') + + return unpack_result(correlation_result) + + +def correlate_serial(input_list, plot=False): + correlation_result = [] + for input_dict in input_list: + input_dict['plot'] = plot + correlation_result.append(correlation_worker(input_dict)) + return unpack_result(correlation_result) + + +def taupy_parallel(input_list, ncores): + parallel = Parallel(n_jobs=ncores) + + logging.info('Taupy_parallel: Generated {} parallel jobs.'.format(ncores)) + taupy_results = parallel(delayed(taupy_worker)(item) for item in input_list) + + logging.info('Parallel execution finished.') + + return unpack_result(taupy_results) + + +def unpack_result(result): + result_dict = {item['nwst_id']: {key: item[key] for key in item.keys()} for item in result} + nerr = 0 + for item in result_dict.values(): + if item['err']: + logging.debug(item['err']) + nerr += 1 + logging.info('Unpack results: Found {} errors after multiprocessing'.format(nerr)) + return result_dict + + +def get_taupy_picks(origin, stations_dict, pylot_parameter, phase_type, ncores=None): + input_list = [] + + taup_phases = pylot_parameter['taup_phases'].split(',') + taup_model = pylot_parameter['taup_model'] + taup_phases = [phase for phase in taup_phases if identifyPhaseID(phase) == phase_type] + + model = TauPyModel(taup_model) + + src_depth = origin.depth + src_lat = origin.latitude + src_lon = origin.longitude + for nwst_id, coords in stations_dict.items(): + rec_lat = coords['latitude'] + rec_lon = coords['longitude'] + taupy_input = {'source_depth_in_km': src_depth, 'source_latitude_in_deg': src_lat, + 'source_longitude_in_deg': src_lon, 'receiver_latitude_in_deg': rec_lat, + 'receiver_longitude_in_deg': rec_lon, 'phase_list': taup_phases, } + input_dict = {'nwst_id': nwst_id, 'taupy_input': taupy_input, 'model': model, 'source_time': origin.time, } + input_list.append(input_dict) + + taupy_result = taupy_parallel(input_list, ncores=ncores) + check_taupy_phases(taupy_result) + + taupy_picks = create_artificial_picks(taupy_result) + return taupy_picks + + +def create_artificial_picks(taupy_result): + artificial_picks = [] + for nwst_id, taupy_dict in taupy_result.items(): + nw, st = nwst_id.split('.') + waveform_id = WaveformStreamID(network_code=nw, station_code=st) + method = ResourceIdentifier('taupy') + pick = Pick(force_resource_id=True, waveform_id=waveform_id, time=taupy_dict['phase_time'], method_id=method, + phase_hint=taupy_dict['phase_name']) + artificial_picks.append(pick) + return artificial_picks + + +def check_taupy_phases(taupy_result): + test_phase_name = list(taupy_result.values())[0]['phase_name'] + phase_names_equal = [item['phase_name'] == test_phase_name for item in taupy_result.values()] + if not all(phase_names_equal): + logging.info('Different first arriving phases detected in TauPy phases for this event.') + + +def taupy_worker(input_dict): + model = input_dict['model'] + taupy_input = input_dict['taupy_input'] + source_time = input_dict['source_time'] + + try: + arrivals = model.get_travel_times_geo(**taupy_input) + first_arrival = arrivals[0] + output_dict = dict(nwst_id=input_dict['nwst_id'], phase_name=first_arrival.name, + phase_time=source_time + first_arrival.time, phase_dist=first_arrival.distance, err=None, ) + except Exception as e: + output_dict = dict(nwst_id=input_dict['nwst_id'], phase_name=None, phase_time=None, err=str(e)) + return output_dict + + +def resample_worker(input_dict): + trace = input_dict['trace'] + freq = input_dict['freq'] + if freq == trace.stats.sampling_rate: + return trace + else: + return trace.resample(freq, no_filter=False) + + +def rotation_worker(input_dict): + stream = input_dict['stream'] + tstart = max([tr.stats.starttime for tr in stream]) + tend = min([tr.stats.endtime for tr in stream]) + if not tstart or not tend: + logging.debug('Could not cut stream {} for rotation'.format(stream[0].id)) + return + stream.trim(tstart, tend, nearest_sample=False) + dist, az, baz = gps2dist_azimuth(input_dict.get('src_lat'), input_dict.get('src_lon'), input_dict.get('rec_lat'), + input_dict.get('rec_lon')) + try: + stream.rotate('ZNE->LQT', back_azimuth=baz, inclination=input_dict.get('inclination')) + except ValueError as e: + logging.error(f'Could not rotate Stream to LQT: {e}') + return stream + + +def correlation_worker(input_dict): + '''worker function for multiprocessing''' + + # unpack input dictionary + nwst_id = input_dict['nwst_id'] + pick_this = input_dict['pick1'] + other_pick = input_dict['pick2'] + channel = input_dict['channel'] + plot = input_dict['plot'] + fig_dir = input_dict['fig_dir'] + t_before = input_dict['t_before'] + t_after = input_dict['t_after'] + cc_maxlag = input_dict['cc_maxlag'] + cc_maxlag2 = input_dict['cc_maxlag2'] + + # apply correlation and pick correction + # Note: Do correlation twice, once to get rough time shift (lower freq), + # second time to get more precise error for shifted pick. + # Therefore, traces have to be cut to same length around pick and correlated again + + try: + logging.debug(f'Starting Pick correction for {nwst_id}') + xcpc = Xcorr_pick_correction(pick_this.time, input_dict['trace1'], other_pick.time, input_dict['trace2'], + t_before=t_before, t_after=t_after, cc_maxlag=cc_maxlag) + + dpick, ccc, uncert, fwm = xcpc.cross_correlation(plot, fig_dir, plot_name='dpick') + logging.debug(f'dpick of first correlation: {dpick}') + + if input_dict['ncorr'] > 1: # and not ccc <= 0: + xcpc2 = Xcorr_pick_correction(pick_this.time, input_dict['trace1_highf'], other_pick.time + dpick, + input_dict['trace2_highf'], t_before=1., t_after=40., cc_maxlag=cc_maxlag2) + + dpick2, ccc, uncert, fwm = xcpc2.cross_correlation(plot=plot, fig_dir=fig_dir, plot_name='error', + min_corr=input_dict['min_corr']) + + logging.debug(f'dpick of second correlation: {dpick2}') + + # if there is a new shift from the second correlation, apply this shift as well (?) + dpick += dpick2 + + err = None + except Exception as e: + dpick = np.nan + ccc = np.nan + err = str(e) + fwm = np.nan + uncert = np.nan + + if err != None: + err = str(err) + + return {'nwst_id': nwst_id, 'dpick': -1 * dpick, 'ccc': ccc, 'fwm': fwm, 'uncertainty': uncert, 'err': err, + 'channel': channel, } + + +def get_pick4station(picks, network_code, station_code, method='auto'): + for pick in picks: + if pick.waveform_id.network_code == network_code: + if pick.waveform_id.station_code == station_code: + if pick.method_id.id.endswith(method): + return pick + + +def get_stations_min_corr(corr_results, min_corr): + corr_results = {nwst_id: result for nwst_id, result in corr_results.items() if result['ccc'] > min_corr} + return corr_results + + +def plot_mastertrace_corr(nwst_id, corr_results, wfdata, stations_dict, picks, trace_master, method, min_corr, title, + fig_dir=None): + nw, st = nwst_id.split('.') + coords_master = stations_dict[nwst_id] + pick_master = get_pick4station(picks, nw, st, method) + stations2plot = get_stations_min_corr(corr_results, min_corr=min_corr) + # wfdata.select(network=trace_master.stats.network, station=trace_master.stats.station, + # channel=trace_master.stats.channel).plot(automerge=False) + fig, axes = plot_stations(stations_dict, stations2plot, coords_master, corr_results, trace_master, pick_master, + window_title=title) + if fig_dir: + fig.savefig(os.path.join(fig_dir, 'correlation_all4stack.svg'), dpi=300.) + fig, axes = plot_stations(stations_dict, stations_dict, coords_master, corr_results, trace_master, pick_master, + window_title=title) + if fig_dir: + fig.savefig(os.path.join(fig_dir, 'correlation_4stack_threshold.svg'), dpi=300.) + + # stacked_trace = stack_traces(wfdata, trace_master, pick_master, picks, stations_dict, trace_master.stats.channel, + # corr_results, plot_section=True, axes=axes) + + if not fig_dir: + plt.show() + + +def make_figure_dirs(fig_dir, trace_master_id): + fig_dir_traces = '' + if fig_dir and os.path.isdir(fig_dir): + fig_dir_traces = os.path.join(fig_dir, 'corr_with_{}'.format(trace_master_id)) + if not os.path.isdir(fig_dir_traces): + os.mkdir(fig_dir_traces) + return fig_dir_traces + + +def plot_section(wfdata, trace_this, pick_this, picks, stations2compare, channels, corr_results, method, dt_pre=20., + dt_post=50, axes=None, max_stations=50.): + '''Plot a section with all stations used for correlation on ax''' + ylabels = [] + yticks = [] + + trace_this = trace_this.copy() + trace_this.trim(starttime=pick_this.time - dt_pre, endtime=pick_this.time + dt_post) + + # iterate over all closest stations ("other" stations) + for index, nwst_id in enumerate(stations2compare.keys()): + if index >= max_stations: + break + nw, st = nwst_id.split('.') + + if not nwst_id in corr_results: + logging.info('No correlation result for station {}'.format(nwst_id)) + continue + + # get correlation results form dictionary + ccc = corr_results[nwst_id]['ccc'] + dpick = corr_results[nwst_id]['dpick'] + + # station names as y labels + yticks.append(index) + ylabels.append('{id}({ccc:1.2}/{dpick:1.2} s)'.format(id=nwst_id, ccc=ccc, dpick=dpick)) + + ax_sec = axes['section'] + + # plot reference trace (trace_this) with pick + ax_sec.plot(0.5 * trace_this.data / max(abs(trace_this.data)) + index, 'k--', alpha=0.7, linewidth=0.5) + ax_sec.vlines((pick_this.time - trace_this.stats.starttime) / trace_this.stats.delta, index - 0.5, index + 0.5, + color='k', linestyles='--', alpha=0.7, lw=0.5) + + # get pick of other station + pick_other = get_pick4station(picks, station_code=st, network_code=nw, method=method) + + # continue if no pick or no pick difference given for other station + if np.isnan(dpick) or not pick_other or not pick_other.time: + continue + + # continue if there are no data for station for whatever reason + for channel in channels: + stream = wfdata.select(station=st, network=nw, channel=channel) + if stream: + break + if not stream: + continue + + # plot all stations around correlated time (shift traces onto reference trace) + correlated_midtime = pick_other.time - dpick + trace_other = stream[0].copy() + trace_other.trim(starttime=correlated_midtime - dt_pre, endtime=correlated_midtime + dt_post) + + ax_sec.plot(0.5 * trace_other.data / max(abs(trace_other.data)) + index, color='k', linewidth=0.5) + ax_sec.vlines((pick_other.time - trace_other.stats.starttime) / trace_other.stats.delta, index - 0.5, + index + 0.5, color='r', lw=0.5) + + # Plot desciption + ax_sec.set_yticks(yticks) + ax_sec.set_yticklabels(ylabels) + ax_sec.set_title('Section with corresponding picks.') + ax_sec.set_xlabel('Samples. Traces are shifted in time.') + + +def plot_stacked_trace_pick(trace, pick, pylot_parameter): + trace_filt = trace.copy() + if pylot_parameter['filter_type'] and pylot_parameter['filter_options']: + ftype = pylot_parameter['filter_type'][0] + forder = pylot_parameter['filter_order'][0] + freqmin, freqmax = pylot_parameter['bpz2'] + trace_filt.detrend('linear') + trace_filt.taper(0.05, type='cosine') + trace_filt.filter(type=ftype, corners=forder, freqmin=freqmin, freqmax=freqmax) + fig = plt.figure(figsize=(16, 9)) + ax_unf = fig.add_subplot(211) + ax_filt = fig.add_subplot(212) + time_ax = np.linspace(0, trace.stats.endtime - trace.stats.starttime, trace.stats.npts) + ax_unf.plot(time_ax, trace.data) + ax_filt.plot(time_ax, trace_filt.data) + ax_filt.axvline((pick.time - trace.stats.starttime), c='r', linestyle='-') + # ax.axvline((pick.time + mean_dpick - trace.stats.starttime), c='r') + ax_unf.set_title(trace.id) + ax_filt.set_xlabel('Seconds since {}'.format(trace.stats.starttime)) + return fig + + +def plot_stations(stations_dict, stations2compare, coords_this, corr_result, trace, pick, window_title=None): + ''' Plot routine to check proximity algorithm. ''' + + title = trace.id + + # create array of longitudes (first column) and latitude (second column) for all stations (row) + coords_all = np.array([[station['longitude'], station['latitude']] for station in stations_dict.values()]) + # get coords of stations in vicinity of "this" station + coords_selected = np.array([[stations_dict[station]['longitude'], stations_dict[station]['latitude']] for station in + stations2compare.keys()]) + + # create arrays with cross correlation coefficient and cc-pick difference as color representation in scatter + cccs = np.array([corr_result[station]['ccc'] if station in corr_result.keys() else np.nan for station in + stations2compare.keys()]) + dpicks = np.array([corr_result[station]['dpick'] if station in corr_result.keys() else np.nan for station in + stations2compare.keys()]) + + mean_dpick = np.nanmean(dpicks) + + title += ' | mean ccc: {:1.3}'.format(np.nanmean(cccs)) + title += ' | mean dpick: {:2.3} [s]'.format(mean_dpick) + + try: + abs_max = np.nanmax(np.abs(np.array(dpicks))) + except ValueError as e: + logging.error(str(e)) + return + + gs = plt.GridSpec(3, 3, height_ratios=[1, 1, 4], width_ratios=[1, 1, 1]) + fig = plt.figure(figsize=(16, 9)) + fig.canvas.manager.set_window_title(window_title) + ax_sec = fig.add_subplot(gs[0:, 0]) + ax_trace = fig.add_subplot(gs[0, 1:]) + ax_cc = fig.add_subplot(gs[1, 1]) + ax_dp = fig.add_subplot(gs[1, 2]) + ax_map = fig.add_subplot(gs[2, 1:]) + + axes = {'section': ax_sec, 'trace': ax_trace, 'ccc': ax_cc, 'dpick': ax_dp, 'map': ax_map} + + trace = trace.copy() + trace.trim(starttime=pick.time - 200, endtime=pick.time + 200) + + time_ax = np.linspace(0, trace.stats.endtime - trace.stats.starttime, trace.stats.npts) + ax_trace.plot(time_ax, trace.data) + ax_trace.axvline((pick.time - trace.stats.starttime), c='k', linestyle='--') + ax_trace.axvline((pick.time + mean_dpick - trace.stats.starttime), c='r') + ax_trace.set_title(title) + ax_trace.set_xlabel('Seconds since {}'.format(trace.stats.starttime)) + + ax_map.scatter(coords_all[:, 0], coords_all[:, 1], c='k', s=3) + ax_map.set_xlabel('Longitude [$^\circ$]') + ax_map.set_ylabel('Latitude [$^\circ$]') + + sc = ax_map.scatter(coords_selected[:, 0], coords_selected[:, 1], c=dpicks, s=40 * cccs, + cmap=plt.get_cmap('seismic'), edgecolors='grey', vmin=-abs_max, vmax=abs_max, linewidths=0.5) + # sc.set_facecolor('none') + plt.colorbar(sc, label='Color codes dpicks [s]. Size codes cross correlation coefficient [0-1]') + ax_map.scatter(coords_this['longitude'], coords_this['latitude'], marker='*', s=40, c='g') + ax_cc.hist(cccs, bins=50) + ax_cc.set_xlabel('Cross Correlation Coefficient') + ax_dp.hist(dpicks, bins=50) + ax_dp.set_xlabel('Pick difference distribution [s]') + + return fig, axes + + +def get_data(eventdir, data_dir, headonly=False): + ''' Read and return waveformdata read from eventdir/data_dir. ''' + wfdata_path = os.path.join(eventdir, data_dir) + wfdata = read(os.path.join(wfdata_path, '*'), headonly=headonly) + return wfdata + + +def get_closest_stations(coords, stations_dict, n): + ''' Calculate distances and return n closest stations in stations_dict for station at coords. ''' + distances = {} + for station_id, st_coords in stations_dict.items(): + dist = gps2dist_azimuth(coords['latitude'], coords['longitude'], st_coords['latitude'], st_coords['longitude'], + a=6.371e6, f=0)[0] + # exclude same coordinate (self or other instrument at same location) + if dist == 0: + continue + distances[dist] = station_id + + closest_distances = sorted(list(distances.keys()))[:n + 1] + closest_stations = {station: dist for dist, station in distances.items() if dist in closest_distances} + return closest_stations + + +def get_random_stations(coords, stations_dict, n): + ''' Calculate distances and return n randomly selected stations in stations_dict for station at coords. ''' + random_keys = random.sample(list(stations_dict.keys()), n) + distances = {} + for station_id, st_coords in stations_dict.items(): + dist = gps2dist_azimuth(coords['latitude'], coords['longitude'], st_coords['latitude'], st_coords['longitude'], + a=6.371e6, f=0)[0] + # exclude same coordinate (self or other instrument at same location) + if dist == 0: + continue + distances[dist] = station_id + + random_stations = {station: dist for dist, station in distances.items() if station in random_keys} + return random_stations + + +# Notes: if use_master_trace is set True, traces above a specified ccc threshold will be stacked onto one 'ideal' +# station into a master-trace. This trace will be picked and used again for cross correlation with all other stations +# to find a pick for these stations. + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description='Correlate picks from PyLoT.') + parser.add_argument('dmt_path', help='path containing dmt_database with PyLoT picks') + parser.add_argument('pylot_infile', help='path to autoPyLoT inputfile (pylot.in)') + parser.add_argument('--params', help='path to correlation input parameter file (parameters.yaml)', + default='parameters.yaml') + parser.add_argument('-p', dest='plot', action='store_true', default=False, help='Generate plots') + parser.add_argument('--show', dest='show_fig', action='store_true', default=False, + help='Show plots instead of saving them to directory') + parser.add_argument('--no_rms_check', dest='no_rms_check', action='store_true', default=False, + help='Do not check for RMS outliers.') + parser.add_argument('--reuse_stacked', dest='use_stacked_trace', action='store_true', default=False, + help='Re-use stacked trace of prior correlation. Make sure there is only one stacked trace in' + 'correlation directory!!!') + parser.add_argument('--data_dir', default='processed', help='Data subdirectory (e.g. processed or raw)') + parser.add_argument('--event_blacklist', dest='blacklist', default=None, + help='Skip event_ids specified in textfile.') + parser.add_argument('-pd', dest='plot_detailed', action='store_true', default=False, help='Generate detailed plots') + parser.add_argument('-u', dest='update', action='store_true', default=False, + help='Update picks. Skip events if pickfile exists.') + parser.add_argument('-pe', dest='pickfile_ext', default='_autopylot', + help='Pickfile extension (if taupy is not used), default: _autopylot') + parser.add_argument('-n', dest='ncores', default=None, help='number of cores for multiprocessing') + parser.add_argument('-istart', default=0, help='first event index') + parser.add_argument('-istop', default=1e9, help='last event index') + + args = parser.parse_args() + + # PARAMETER DEFINITIONS ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + # plot options + plot_dict = dict(plot=args.plot, plot_detailed=args.plot_detailed, save_fig=not (args.show_fig)) + + # alparray configuration: ZNE ~ 123 + channels = {'P': ['*Z', '*1'], 'S': ['*Q', '*T']} # '*N', '*E', '*2', '*3', + debug_levels = {'debug': logging.DEBUG, + 'info': logging.INFO, + 'warn': logging.WARNING, + 'error': logging.ERROR, + 'critical': logging.CRITICAL} + + + if args.ncores is not None: + _ncores = int(args.ncores) + else: + _ncores = None + + with open(args.params) as infile: + parameters_dict = yaml.safe_load(infile) + + params = {phase: None for phase in parameters_dict['pick_phases']} + + logger = logging.getLogger() + logger.setLevel(debug_levels.get(parameters_dict['logging'])) + handler = logging.StreamHandler(sys.stdout) + fhandler = logging.FileHandler('pick_corr.out') + logger.addHandler(handler) + logger.addHandler(fhandler) + + for phase in params.keys(): + params_phase = CorrelationParameters(ncores=_ncores) + params_phase.add_parameters(**plot_dict) + params_phase.add_parameters(**parameters_dict[phase]) + params[phase] = params_phase + + correlation_main(args.dmt_path, args.pylot_infile, params=params, istart=int(args.istart), istop=int(args.istop), + channel_config=channels, update=args.update, event_blacklist=args.blacklist) diff --git a/pylot/correlation/submit_pick_corr_correction.sh b/pylot/correlation/submit_pick_corr_correction.sh new file mode 100755 index 00000000..1531f801 --- /dev/null +++ b/pylot/correlation/submit_pick_corr_correction.sh @@ -0,0 +1,40 @@ +#!/bin/bash + +#ulimit -s 8192 +#ulimit -v $(ulimit -v | awk '{printf("%d",$1*0.95)}') +#ulimit -v + +#655360 + +source /opt/anaconda3/etc/profile.d/conda.sh +conda activate pylot_311 +NSLOTS=20 + +#qsub -l low -cwd -l "os=*stretch" -pe smp 40 submit_pick_corr_correction.sh +#$ -l low +#$ -l h_vmem=6G +#$ -cwd +#$ -pe smp 20 +#$ -N corr_pick + + +export PYTHONPATH="$PYTHONPATH:/home/marcel/git/pylot_tools/" +export PYTHONPATH="$PYTHONPATH:/home/marcel/git/" +export PYTHONPATH="$PYTHONPATH:/home/marcel/git/pylot/" + +#export MKL_NUM_THREADS=${NSLOTS:=1} +#export NUMEXPR_NUM_THREADS=${NSLOTS:=1} +#export OMP_NUM_THREADS=${NSLOTS:=1} + +#python pick_correlation_correction.py '/data/AlpArray_Data/dmt_database_mantle_M5.8-6.0' '/home/marcel/.pylot/pylot_alparray_mantle_corr_stack_0.03-0.5.in' -pd -n ${NSLOTS:=1} -istart 0 -istop 100 +#python pick_correlation_correction.py '/data/AlpArray_Data/dmt_database_mantle_M5.8-6.0' '/home/marcel/.pylot/pylot_alparray_mantle_corr_stack_0.03-0.5.in' -pd -n ${NSLOTS:=1} -istart 100 -istop 200 +#python pick_correlation_correction.py '/data/AlpArray_Data/dmt_database_mantle_M6.0-6.5' '/home/marcel/.pylot/pylot_alparray_mantle_corr_stack_0.03-0.5.in' -pd -n ${NSLOTS:=1} -istart 0 -istop 100 +#python pick_correlation_correction.py '/data/AlpArray_Data/dmt_database_mantle_M5.8-6.0' '/home/marcel/.pylot/pylot_alparray_mantle_corr_stack_0.03-0.5.in' -pd -n ${NSLOTS:=1} -istart 100 -istop 200 +#python pick_correlation_correction.py 'H:\sciebo\dmt_database' 'H:\Sciebo\dmt_database\pylot_alparray_mantle_corr_S_0.01-0.2.in' -pd -n 4 -t + +pylot_infile='/home/marcel/.pylot/pylot_alparray_syn_fwi_mk6_it3.in' +#pylot_infile='/home/marcel/.pylot/pylot_adriaarray_corr_P_and_S.in' + +# THIS SCRIPT SHOLD BE CALLED BY "submit_to_grid_engine.py" using the following line: +python pick_correlation_correction.py $1 $pylot_infile -pd -n ${NSLOTS:=1} -istart $2 --params 'parameters_fwi_mk6_it3.yaml' +#--event_blacklist eventlist.txt diff --git a/pylot/correlation/submit_to_grid_engine.py b/pylot/correlation/submit_to_grid_engine.py new file mode 100755 index 00000000..a5410d07 --- /dev/null +++ b/pylot/correlation/submit_to_grid_engine.py @@ -0,0 +1,23 @@ +#!/usr/bin/env python + +import subprocess + +fnames = [ + ('/data/AlpArray_Data/dmt_database_synth_model_mk6_it3_no_rotation', 0), + ] + +#fnames = [('/data/AlpArray_Data/dmt_database_mantle_0.01-0.2_SKS-phase', 0), +# ('/data/AlpArray_Data/dmt_database_mantle_0.01-0.2_S-phase', 0),] + +#### +script_location = '/home/marcel/VersionCtrl/git/code_base/correlation_picker/submit_pick_corr_correction.sh' +#### + +for fnin, istart in fnames: + input_cmds = f'qsub -q low.q@minos15,low.q@minos14,low.q@minos13,low.q@minos12,low.q@minos11 {script_location} {fnin} {istart}' + + print(input_cmds) + print(subprocess.check_output(input_cmds.split())) + + + From 0f29d0e20d7ad49ca62e105b95d1995d676e893e Mon Sep 17 00:00:00 2001 From: Marcel Date: Thu, 25 Jul 2024 14:50:40 +0200 Subject: [PATCH 02/17] [minor] small modifications (naming conventions) --- pylot/correlation/pick_correlation_correction.py | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/pylot/correlation/pick_correlation_correction.py b/pylot/correlation/pick_correlation_correction.py index ce8d3d00..6c9b5063 100644 --- a/pylot/correlation/pick_correlation_correction.py +++ b/pylot/correlation/pick_correlation_correction.py @@ -10,6 +10,7 @@ import traceback import matplotlib.pyplot as plt import yaml + from code_base.fmtomo_tools.fmtomo_teleseismic_utils import * from code_base.util.utils import get_metadata from joblib import Parallel, delayed @@ -17,6 +18,7 @@ from obspy import read, Stream from obspy.core.event.base import WaveformStreamID, ResourceIdentifier from obspy.core.event.origin import Pick from obspy.signal.cross_correlation import correlate, xcorr_max + from pylot.core.io.inputs import PylotParameter from pylot.core.io.phases import picks_from_picksdict from pylot.core.pick.autopick import autopickstation @@ -24,6 +26,7 @@ from pylot.core.util.utils import check4rotated from pylot.core.util.utils import identifyPhaseID from pylot.core.util.event import Event as PylotEvent + class CorrelationParameters(object): """ :param filter_type: filter type for data (e.g. bandpass) @@ -83,7 +86,7 @@ class CorrelationParameters(object): self.__parameter[key] = value -class Xcorr_pick_correction: +class XcorrPickCorrection: def __init__(self, pick1, trace1, pick2, trace2, t_before, t_after, cc_maxlag, frac_max=0.5): """ MP MP : Modified version of obspy xcorr_pick_correction @@ -559,8 +562,6 @@ def correlate_event(eventdir, pylot_parameter, params, channel_config, update): picks = remove_outliers(picks, taupypicks_corr_initial, params[phase_type]['initial_pick_outlier_threshold']) - # # MP MP TEST # taupypicks, time_shift = get_corrected_taupy_picks(picks, taupypicks_orig, all_available=True) # # picks = copy.deepcopy(taupypicks) # for pick in picks: # pick.method_id.id = 'auto' # # MP MP - if phase_type == 'S': # check whether rotation to ZNE is possible (to get rid of horizontal channel 1,2,3) # the two rotations here (first to ZNE then LQT) could, however, be optimised into one @@ -1517,15 +1518,15 @@ def correlation_worker(input_dict): try: logging.debug(f'Starting Pick correction for {nwst_id}') - xcpc = Xcorr_pick_correction(pick_this.time, input_dict['trace1'], other_pick.time, input_dict['trace2'], - t_before=t_before, t_after=t_after, cc_maxlag=cc_maxlag) + xcpc = XcorrPickCorrection(pick_this.time, input_dict['trace1'], other_pick.time, input_dict['trace2'], + t_before=t_before, t_after=t_after, cc_maxlag=cc_maxlag) dpick, ccc, uncert, fwm = xcpc.cross_correlation(plot, fig_dir, plot_name='dpick') logging.debug(f'dpick of first correlation: {dpick}') if input_dict['ncorr'] > 1: # and not ccc <= 0: - xcpc2 = Xcorr_pick_correction(pick_this.time, input_dict['trace1_highf'], other_pick.time + dpick, - input_dict['trace2_highf'], t_before=1., t_after=40., cc_maxlag=cc_maxlag2) + xcpc2 = XcorrPickCorrection(pick_this.time, input_dict['trace1_highf'], other_pick.time + dpick, + input_dict['trace2_highf'], t_before=1., t_after=40., cc_maxlag=cc_maxlag2) dpick2, ccc, uncert, fwm = xcpc2.cross_correlation(plot=plot, fig_dir=fig_dir, plot_name='error', min_corr=input_dict['min_corr']) From ce71c549ca4ef66763a3392de4de20133db3bac3 Mon Sep 17 00:00:00 2001 From: Marcel Date: Tue, 6 Aug 2024 16:03:16 +0200 Subject: [PATCH 03/17] [bugfix] removed parameter that was re-introduced accidentally from manual merge --- PyLoT.py | 4 ++-- pylot/core/io/default_parameters.py | 2 +- pylot/core/util/array_map.py | 1 - pylot/core/util/widgets.py | 7 ++++--- 4 files changed, 7 insertions(+), 7 deletions(-) diff --git a/PyLoT.py b/PyLoT.py index ae46d860..9cb3cd67 100755 --- a/PyLoT.py +++ b/PyLoT.py @@ -2197,7 +2197,8 @@ class MainWindow(QMainWindow): if event.pylot_autopicks: self.drawPicks(picktype='auto') if event.pylot_picks or event.pylot_autopicks: - self.locateEventAction.setEnabled(True) + if not self._inputs.get('extent') == 'global': + self.locateEventAction.setEnabled(True) self.qualities_action.setEnabled(True) self.eventlist_xml_action.setEnabled(True) @@ -2632,7 +2633,6 @@ class MainWindow(QMainWindow): picks=self.getPicksOnStation(station, 'manual'), autopicks=self.getPicksOnStation(station, 'auto'), metadata=self.metadata, event=event, - model=self.inputs.get('taup_model'), filteroptions=self.filteroptions, wftype=wftype, show_comp_data=self.dataPlot.comp_checkbox.isChecked()) if self.filterActionP.isChecked(): diff --git a/pylot/core/io/default_parameters.py b/pylot/core/io/default_parameters.py index 6e216939..b9a63adb 100644 --- a/pylot/core/io/default_parameters.py +++ b/pylot/core/io/default_parameters.py @@ -511,7 +511,7 @@ defaults = {'rootpath': {'type': str, 'taup_model': {'type': str, 'tooltip': 'Define TauPy model for traveltime estimation. Possible values: 1066a, 1066b, ak135, ak135f, herrin, iasp91, jb, prem, pwdk, sp6', - 'value': None, + 'value': 'iasp91', 'namestring': 'TauPy model'}, 'taup_phases': {'type': str, diff --git a/pylot/core/util/array_map.py b/pylot/core/util/array_map.py index d749739e..90259c44 100644 --- a/pylot/core/util/array_map.py +++ b/pylot/core/util/array_map.py @@ -490,7 +490,6 @@ class Array_map(QtWidgets.QWidget): picks=self._parent.get_current_event().getPick(station), autopicks=self._parent.get_current_event().getAutopick(station), filteroptions=self._parent.filteroptions, metadata=self.metadata, - model=self.parameter.get('taup_model'), event=pyl_mw.get_current_event()) except Exception as e: message = 'Could not generate Plot for station {st}.\n {er}'.format(st=station, er=e) diff --git a/pylot/core/util/widgets.py b/pylot/core/util/widgets.py index 438f7d0d..81761323 100644 --- a/pylot/core/util/widgets.py +++ b/pylot/core/util/widgets.py @@ -1870,13 +1870,14 @@ class PickDlg(QDialog): def __init__(self, parent=None, data=None, data_compare=None, station=None, network=None, location=None, picks=None, autopicks=None, rotate=False, parameter=None, embedded=False, metadata=None, show_comp_data=False, - event=None, filteroptions=None, model=None, wftype=None): + event=None, filteroptions=None, wftype=None): super(PickDlg, self).__init__(parent, Qt.Window) self.orig_parent = parent self.setAttribute(Qt.WA_DeleteOnClose) # initialize attributes self.parameter = parameter + model = self.parameter.get('taup_model') self._embedded = embedded self.showCompData = show_comp_data self.station = station @@ -2269,8 +2270,8 @@ class PickDlg(QDialog): arrivals = func[plot](source_origin.depth, source_origin.latitude, source_origin.longitude, - station_coords['latitude'], - station_coords['longitude'], + station_coords.get('latitude'), + station_coords.get('longitude'), phases) self.arrivals = arrivals From 1b074d14ffdae583a6a797ece1d39ec940ea87b2 Mon Sep 17 00:00:00 2001 From: Marcel Date: Tue, 6 Aug 2024 16:03:50 +0200 Subject: [PATCH 04/17] [update] WIP: Adding type hints, docstrings etc. --- .../pick_correlation_correction.py | 162 ++++++++++++------ 1 file changed, 110 insertions(+), 52 deletions(-) diff --git a/pylot/correlation/pick_correlation_correction.py b/pylot/correlation/pick_correlation_correction.py index 6c9b5063..c6762b59 100644 --- a/pylot/correlation/pick_correlation_correction.py +++ b/pylot/correlation/pick_correlation_correction.py @@ -7,6 +7,7 @@ import copy import logging import random import traceback +from typing import Any import matplotlib.pyplot as plt import yaml @@ -14,7 +15,7 @@ import yaml from code_base.fmtomo_tools.fmtomo_teleseismic_utils import * from code_base.util.utils import get_metadata from joblib import Parallel, delayed -from obspy import read, Stream +from obspy import read, Stream, Trace from obspy.core.event.base import WaveformStreamID, ResourceIdentifier from obspy.core.event.origin import Pick from obspy.signal.cross_correlation import correlate, xcorr_max @@ -27,8 +28,10 @@ from pylot.core.util.utils import identifyPhaseID from pylot.core.util.event import Event as PylotEvent -class CorrelationParameters(object): +class CorrelationParameters: """ + Class to read, store and access correlation parameters from yaml file. + :param filter_type: filter type for data (e.g. bandpass) :param filter_options: filter options (min/max_freq etc.) :param filter_options_final: filter options for second iteration, final pick (min/max_freq etc.) @@ -59,35 +62,36 @@ class CorrelationParameters(object): self.add_parameters(**kwargs) # String representation of the object - def __repr__(self): - return "CorrelationParameters " + def __repr__(self) -> str: + return 'CorrelationParameters ' # Boolean test - def __nonzero__(self): + def __nonzero__(self) -> bool: return bool(self.__parameter) - def __getitem__(self, key): + def __getitem__(self, key: str) -> Any: return self.__parameter.get(key) - def __setitem__(self, key, value): + def __setitem__(self, key: str, value: Any) -> None: self.__parameter[key] = value - def __delitem__(self, key): + def __delitem__(self, key: str): del self.__parameter[key] - def __iter__(self): + def __iter__(self) -> Any: return iter(self.__parameter) - def __len__(self): + def __len__(self) -> int: return len(self.__parameter.keys()) - def add_parameters(self, **kwargs): + def add_parameters(self, **kwargs) -> None: for key, value in kwargs.items(): self.__parameter[key] = value class XcorrPickCorrection: - def __init__(self, pick1, trace1, pick2, trace2, t_before, t_after, cc_maxlag, frac_max=0.5): + def __init__(self, pick1: UTCDateTime, trace1: Trace, pick2: UTCDateTime, trace2: Trace, + t_before: float, t_after: float, cc_maxlag: float, frac_max: float = 0.5): """ MP MP : Modified version of obspy xcorr_pick_correction @@ -95,20 +99,6 @@ class XcorrPickCorrection: correlation of the waveforms in narrow windows around the pick times. For details on the fitting procedure refer to [Deichmann1992]_. - The parameters depend on the epicentral distance and magnitude range. For - small local earthquakes (Ml ~0-2, distance ~3-10 km) with consistent manual - picks the following can be tried:: - - t_before=0.05, t_after=0.2, cc_maxlag=0.10, - - The appropriate parameter sets can and should be determined/verified - visually using the option `plot=True` on a representative set of picks. - - To get the corrected differential pick time calculate: ``((pick2 + - pick2_corr) - pick1)``. To get a corrected differential travel time using - origin times for both events calculate: ``((pick2 + pick2_corr - ot2) - - (pick1 - ot1))`` - :type pick1: :class:`~obspy.core.utcdatetime.UTCDateTime` :param pick1: Time of pick for `trace1`. :type trace1: :class:`~obspy.core.trace.Trace` @@ -128,9 +118,6 @@ class XcorrPickCorrection: :type cc_maxlag: float :param cc_maxlag: Maximum lag/shift time tested during cross correlation in seconds. - :rtype: (float, float) - :returns: Correction time `pick2_corr` for `pick2` pick time as a float and - corresponding correlation coefficient. """ self.trace1 = trace1 @@ -153,58 +140,123 @@ class XcorrPickCorrection: self.tr1_slice = self.slice_trace(self.trace1, self.pick1) self.tr2_slice = self.slice_trace(self.trace2, self.pick2) - def check_traces(self): + def check_traces(self) -> None: + """ + Check if the sampling rates of two traces match, raise an exception if they don't. + Raise an exception if any of the traces is empty. Set the sampling rate attribute. + """ if self.trace1.stats.sampling_rate != self.trace2.stats.sampling_rate: - msg = "Sampling rates do not match: %s != %s" % ( - self.trace1.stats.sampling_rate, self.trace2.stats.sampling_rate) + msg = f'Sampling rates do not match: {self.trace1.stats.sampling_rate} != {self.trace2.stats.sampling_rate}' raise Exception(msg) + for trace in (self.trace1, self.trace2): + if len(trace) == 0: + raise Exception(f'Trace {trace} is empty') self.samp_rate = self.trace1.stats.sampling_rate - def slice_trace(self, tr, pick): + def slice_trace(self, tr, pick) -> Trace: + """ + Method to slice a given trace around a specified pick time. + + Parameters: + - tr: Trace object representing the seismic data + - pick: The pick time around which to slice the trace + + Returns: + - Trace sliced around the specified pick time + """ start = pick - self.t_before - (self.cc_maxlag / 2.0) end = pick + self.t_after + (self.cc_maxlag / 2.0) # check if necessary time spans are present in data if tr.stats.starttime > start: - msg = f"Trace {tr.id} starts too late." + msg = f"Trace {tr.id} starts too late. Decrease t_before or cc_maxlag." + logging.debug(f'start: {start}, t_before: {self.t_before}, cc_maxlag: {self.cc_maxlag},' + f'pick: {pick}') raise Exception(msg) if tr.stats.endtime < end: - msg = f"Trace {tr.id} ends too early." + msg = f"Trace {tr.id} ends too early. Deacrease t_after or cc_maxlag." + logging.debug(f'end: {end}, t_after: {self.t_after}, cc_maxlag: {self.cc_maxlag},' + f'pick: {pick}') raise Exception(msg) # apply signal processing and take correct slice of data return tr.slice(start, end) - def cross_correlation(self, plot, fig_dir, plot_name, min_corr=None): + def cross_correlation(self, plot: bool, fig_dir: str, plot_name: str, min_corr: float = None): + """ + Calculate the cross correlation between two traces (self.trace1 and self.trace2) and return + the corrected pick time, correlation coefficient, uncertainty, and full width at half maximum. - def get_timeaxis(trace): + Parameters: + plot (bool): A boolean indicating whether to generate a plot or not. + fig_dir (str): The directory to save the plot. + plot_name (str): The name to use for the plot. + min_corr (float, optional): The minimum correlation coefficient allowed. + + Returns: + tuple: A tuple containing the corrected pick time, correlation coefficient, uncertainty + and full width at half maximum. + """ + + def get_timeaxis(trace: Trace) -> np.ndarray: + """ + Generate a time axis array based on the given trace object. + + Parameters: + trace (object): The trace object to generate the time axis from. + + Returns: + array: A numpy array representing the time axis. + """ return np.linspace(0,trace.stats.endtime -trace.stats.starttime, trace.stats.npts) - def plot_cc(fig_dir, plot_name): - if fig_dir and os.path.isdir(fig_dir): - filename = os.path.join(fig_dir, 'corr_{}_{}.svg'.format(self.trace2.id, plot_name)) + def plot_cc(figure_output_dir: str, plot_filename: str) -> None: + """ + Generate a plot for the correlation of two traces and save it to a specified file if the directory exists. + + Parameters: + - figure_output_dir: str, the directory where the plot will be saved + - plot_filename: str, the name of the plot file + + Returns: + - None + """ + if figure_output_dir and os.path.isdir(figure_output_dir): + filename = os.path.join(figure_output_dir, 'corr_{}_{}.svg'.format(self.trace2.id, plot_filename)) else: filename = None - # with MatplotlibBackend(filename and "AGG" or None, sloppy=True): + # Create figure object, first subplot axis and timeaxis for both traces fig = plt.figure(figsize=(16, 9)) ax1 = fig.add_subplot(211) tmp_t1 = get_timeaxis(self.tr1_slice) tmp_t2 = get_timeaxis(self.tr2_slice) - # MP MP normalize slices (not only by positive maximum! + + # MP MP normalize slices (not only by positive maximum!) tr1_slice_norm = self.tr1_slice.copy().normalize() tr2_slice_norm = self.tr2_slice.copy().normalize() + + # Plot normalized traces to first subplot: Trace to correct, reference trace + # and trace shifted by correlation maximum ax1.plot(tmp_t1, tr1_slice_norm.data, "b", label="Trace 1 (reference)", lw=0.75) ax1.plot(tmp_t2, tr2_slice_norm.data, "g--", label="Trace 2 (pick shifted)", lw=0.75) ax1.plot(tmp_t2 - dt, tr2_slice_norm.data, "k", label="Trace 2 (correlation shifted)", lw=1.) + + # get relative pick time from trace 1 (reference trace) for plotting which is the same for all three + # traces in the plot which are aligned by their pick times for comparison delta_pick_ref = (self.pick1 - self.tr1_slice.stats.starttime) - # correct pick time shift in traces for trace1 ax1.axvline(delta_pick_ref, color='k', linestyle='dashed', label='Pick', lw=0.5) + + # plot uncertainty around pick ylims = ax1.get_ylim() ax1.fill_between([delta_pick_ref - uncert, delta_pick_ref + uncert], ylims[0], ylims[1], alpha=.25, color='g', label='pick uncertainty)'.format(self.frac_max)) + + # add legend, title, labels ax1.legend(loc="lower right", prop={'size': "small"}) ax1.set_title("Correlated {} with {}".format(self.tr2_slice.id, self.tr1_slice.id)) ax1.set_xlabel("time [s]") ax1.set_ylabel("norm. amplitude") + + # Plot cross correlation to second subplot ax2 = fig.add_subplot(212) ax2.plot(cc_t, cc_convex, ls="", marker=".", color="k", label="xcorr (convex)") ax2.plot(cc_t, cc_concave, ls="", marker=".", color="0.7", label="xcorr (concave)") @@ -270,6 +322,7 @@ class XcorrPickCorrection: if num_samples < 5: msg = "Less than 5 samples selected for fit to cross " + "correlation: %s" % num_samples logging.debug(msg) + logging.info('Not enough samples for polyfit. Consider increasing sampling frequency.') # quadratic fit for small subwindow coeffs, cov_mat = np.polyfit(cc_t[first_sample:last_sample + 1], cc[first_sample:last_sample + 1], deg=2, @@ -484,9 +537,6 @@ def correlate_event(eventdir, pylot_parameter, params, channel_config, update): # get a dictionary containing coordinates for all sources stations_dict = metadata.get_all_coordinates() - # read processed (restituted) data (assume P and S are the same...) - wfdata_raw = get_data(eventdir, params['P']['data_dir'], headonly=False) - # create dictionaries for final export of P and S phases together # ps_correlation_dict = {} # ps_taup_picks = {} @@ -495,6 +545,9 @@ def correlate_event(eventdir, pylot_parameter, params, channel_config, update): # iterate over P and S to create one model each for phase_type in params.keys(): + # read processed (restituted) data + wfdata_raw = get_data(eventdir, params[phase_type]['data_dir'], headonly=False) + ncores = params[phase_type]['ncores'] filter_type = params[phase_type]['filter_type'] filter_options = params[phase_type]['filter_options'] @@ -1392,7 +1445,7 @@ def taupy_parallel(input_list, ncores): logging.info('Taupy_parallel: Generated {} parallel jobs.'.format(ncores)) taupy_results = parallel(delayed(taupy_worker)(item) for item in input_list) - logging.info('Parallel execution finished.') + logging.info('Parallel execution finished. Unpacking results...') return unpack_result(taupy_results) @@ -1402,7 +1455,8 @@ def unpack_result(result): nerr = 0 for item in result_dict.values(): if item['err']: - logging.debug(item['err']) + logging.debug(f'Found error for {item["nwst_id"]}: {item["err"]}.') + #logging.debug(f'Detailed traceback: {item["exc"]}') nerr += 1 logging.info('Unpack results: Found {} errors after multiprocessing'.format(nerr)) return result_dict @@ -1462,11 +1516,16 @@ def taupy_worker(input_dict): try: arrivals = model.get_travel_times_geo(**taupy_input) + if len(arrivals) == 0: + raise Exception(f'No arrivals found for phase {taupy_input["phase_list"]}. Source time: {source_time} -' + f' Input: {taupy_input}') first_arrival = arrivals[0] output_dict = dict(nwst_id=input_dict['nwst_id'], phase_name=first_arrival.name, - phase_time=source_time + first_arrival.time, phase_dist=first_arrival.distance, err=None, ) + phase_time=source_time + first_arrival.time, phase_dist=first_arrival.distance, err=None, + exc=None,) except Exception as e: - output_dict = dict(nwst_id=input_dict['nwst_id'], phase_name=None, phase_time=None, err=str(e)) + exc = traceback.format_exc() + output_dict = dict(nwst_id=input_dict['nwst_id'], phase_name=None, phase_time=None, err=str(e), exc=exc,) return output_dict @@ -1475,8 +1534,7 @@ def resample_worker(input_dict): freq = input_dict['freq'] if freq == trace.stats.sampling_rate: return trace - else: - return trace.resample(freq, no_filter=False) + return trace.resample(freq, no_filter=freq > trace.stats.sampling_rate) def rotation_worker(input_dict): From d5817adc46c1c557770152025cf6e68e7f73a8b9 Mon Sep 17 00:00:00 2001 From: Marcel Office Desktop Date: Wed, 7 Aug 2024 10:17:35 +0200 Subject: [PATCH 05/17] [merge] changes to correlation picker from different machines that were not committed --- pylot.yml | 4 +- pylot/__init__.py | 2 +- pylot/correlation/__init__.py | 2 + .../pick_correlation_correction.py | 13 +++- pylot/correlation/utils.py | 61 +++++++++++++++++++ requirements.txt | 4 +- 6 files changed, 80 insertions(+), 6 deletions(-) create mode 100644 pylot/correlation/__init__.py create mode 100644 pylot/correlation/utils.py diff --git a/pylot.yml b/pylot.yml index c0d83959..c8c7120a 100644 --- a/pylot.yml +++ b/pylot.yml @@ -11,4 +11,6 @@ dependencies: - pyside2>=5.13.2 - python=3.8.12 - qt>=5.12.9 - - scipy=1.8.0 \ No newline at end of file + - scipy=1.8.0 + - pyaml=6.0.1 + - joblib=1.4.2 \ No newline at end of file diff --git a/pylot/__init__.py b/pylot/__init__.py index e0981d72..f19df0a8 100644 --- a/pylot/__init__.py +++ b/pylot/__init__.py @@ -9,7 +9,7 @@ PyLoT - the Python picking and Localization Tool This python library contains a graphical user interfaces for picking seismic phases. This software needs ObsPy (http://github.com/obspy/obspy/wiki) -and the Qt4 libraries to be installed first. +and the Qt libraries to be installed first. PILOT has been developed in Mathworks' MatLab. In order to distribute PILOT without facing portability problems, it has been decided to re- diff --git a/pylot/correlation/__init__.py b/pylot/correlation/__init__.py new file mode 100644 index 00000000..ec51c5a2 --- /dev/null +++ b/pylot/correlation/__init__.py @@ -0,0 +1,2 @@ +# -*- coding: utf-8 -*- +# diff --git a/pylot/correlation/pick_correlation_correction.py b/pylot/correlation/pick_correlation_correction.py index c6762b59..737c3745 100644 --- a/pylot/correlation/pick_correlation_correction.py +++ b/pylot/correlation/pick_correlation_correction.py @@ -2,22 +2,27 @@ # -*- coding: utf-8 -*- import sys +import os import argparse import copy import logging import random import traceback +import glob +import json +from datetime import datetime from typing import Any +import numpy as np import matplotlib.pyplot as plt import yaml -from code_base.fmtomo_tools.fmtomo_teleseismic_utils import * -from code_base.util.utils import get_metadata from joblib import Parallel, delayed -from obspy import read, Stream, Trace +from obspy import read, Stream, UTCDateTime, Trace +from obspy.taup import TauPyModel from obspy.core.event.base import WaveformStreamID, ResourceIdentifier from obspy.core.event.origin import Pick +from obspy.geodetics.base import gps2dist_azimuth from obspy.signal.cross_correlation import correlate, xcorr_max from pylot.core.io.inputs import PylotParameter @@ -26,6 +31,8 @@ from pylot.core.pick.autopick import autopickstation from pylot.core.util.utils import check4rotated from pylot.core.util.utils import identifyPhaseID from pylot.core.util.event import Event as PylotEvent +from pylot.correlation.utils import (get_event_id, get_event_pylot, get_event_obspy_dmt, get_picks, write_json, + get_metadata) class CorrelationParameters: diff --git a/pylot/correlation/utils.py b/pylot/correlation/utils.py new file mode 100644 index 00000000..9a9c01d8 --- /dev/null +++ b/pylot/correlation/utils.py @@ -0,0 +1,61 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +import os +import glob +import json + +from obspy import read_events + +from pylot.core.util.dataprocessing import Metadata +from pylot.core.util.obspyDMT_interface import qml_from_obspyDMT + + +def get_event_obspy_dmt(eventdir): + event_pkl_file = os.path.join(eventdir, 'info', 'event.pkl') + if not os.path.exists(event_pkl_file): + raise IOError('Could not find event path for event: {}'.format(eventdir)) + event = qml_from_obspyDMT(event_pkl_file) + return event + + +def get_event_pylot(eventdir, extension=''): + event_id = get_event_id(eventdir) + filename = os.path.join(eventdir, 'PyLoT_{}{}.xml'.format(event_id, extension)) + if not os.path.isfile(filename): + return + cat = read_events(filename) + return cat[0] + + +def get_event_id(eventdir): + event_id = os.path.split(eventdir)[-1] + return event_id + + +def get_picks(eventdir, extension=''): + event_id = get_event_id(eventdir) + filename = 'PyLoT_{}{}.xml' + filename = filename.format(event_id, extension) + fpath = os.path.join(eventdir, filename) + fpaths = glob.glob(fpath) + if len(fpaths) == 1: + cat = read_events(fpaths[0]) + picks = cat[0].picks + return picks + elif len(fpaths) == 0: + print('get_picks: File not found: {}'.format(fpath)) + return + print(f'WARNING: Ambiguous pick file specification. Found the following pick files {fpaths}\nFilemask: {fpath}') + return + + +def write_json(object, fname): + with open(fname, 'w') as outfile: + json.dump(object, outfile, sort_keys=True, indent=4) + + +def get_metadata(eventdir): + metadata_path = os.path.join(eventdir, 'resp') + metadata = Metadata(inventory=metadata_path, verbosity=0) + return metadata diff --git a/requirements.txt b/requirements.txt index b5e3fe81..5105d418 100644 --- a/requirements.txt +++ b/requirements.txt @@ -9,4 +9,6 @@ pyqtgraph=0.12.4 pyside2=5.13.2 python=3.8.12 qt=5.12.9 -scipy=1.8.0 \ No newline at end of file +scipy=1.8.0 +pyaml=6.0.1 +joblib=1.4.2 \ No newline at end of file From 8e7bd8771111974a993108ba09d6cdaee10a4f1f Mon Sep 17 00:00:00 2001 From: Marcel Office Desktop Date: Wed, 7 Aug 2024 17:11:27 +0200 Subject: [PATCH 06/17] [new] added some unit tests for correlation picker (WIP) --- .../pick_correlation_correction.py | 51 ++++++------- pylot/tests/__init__.py | 0 .../tests/test_pick_correlation_correction.py | 76 +++++++++++++++++++ 3 files changed, 100 insertions(+), 27 deletions(-) create mode 100644 pylot/tests/__init__.py create mode 100644 pylot/tests/test_pick_correlation_correction.py diff --git a/pylot/correlation/pick_correlation_correction.py b/pylot/correlation/pick_correlation_correction.py index 737c3745..847cfe1c 100644 --- a/pylot/correlation/pick_correlation_correction.py +++ b/pylot/correlation/pick_correlation_correction.py @@ -96,7 +96,7 @@ class CorrelationParameters: self.__parameter[key] = value -class XcorrPickCorrection: +class XCorrPickCorrection: def __init__(self, pick1: UTCDateTime, trace1: Trace, pick2: UTCDateTime, trace2: Trace, t_before: float, t_after: float, cc_maxlag: float, frac_max: float = 0.5): """ @@ -130,6 +130,9 @@ class XcorrPickCorrection: self.trace1 = trace1 self.trace2 = trace2 + self.tr1_slice = None + self.tr2_slice = None + self.pick1 = pick1 self.pick2 = pick2 @@ -140,13 +143,6 @@ class XcorrPickCorrection: self.samp_rate = 0 - # perform some checks on the traces - self.check_traces() - - # check data and take correct slice of traces - self.tr1_slice = self.slice_trace(self.trace1, self.pick1) - self.tr2_slice = self.slice_trace(self.trace2, self.pick2) - def check_traces(self) -> None: """ Check if the sampling rates of two traces match, raise an exception if they don't. @@ -184,6 +180,7 @@ class XcorrPickCorrection: logging.debug(f'end: {end}, t_after: {self.t_after}, cc_maxlag: {self.cc_maxlag},' f'pick: {pick}') raise Exception(msg) + # apply signal processing and take correct slice of data return tr.slice(start, end) @@ -290,6 +287,13 @@ class XcorrPickCorrection: plt.close(fig) + # perform some checks on the traces + self.check_traces() + + # check data and take correct slice of traces + self.tr1_slice = self.slice_trace(self.trace1, self.pick1) + self.tr2_slice = self.slice_trace(self.trace2, self.pick2) + # start of cross correlation method shift_len = int(self.cc_maxlag * self.samp_rate) cc = correlate(self.tr1_slice.data, self.tr2_slice.data, shift_len, demean=False) @@ -352,17 +356,10 @@ class XcorrPickCorrection: # traces. Actually we do not want to shift the trace to align it but we # want to correct the time of `pick2` so that the traces align without # shifting. This is the negative of the cross correlation shift. - # MP MP calculate full width at half maximum + # MP MP calculate full width at (first by fraction of, now always using) half maximum fmax = coeff fwfm = 2 * (np.sqrt((b / (2 * a)) ** 2 + (self.frac_max * fmax - c) / a)) - # # calculated error using a and ccc - # if a < 0: - # asqrtcc = np.sqrt(-1. / a) * (1. - coeff) - # else: - # # warning already printed above - # asqrtcc = np.nan - # uncertainty is half of two times the fwhm scaled by 1 - maxcc uncert = fwfm * (1. - coeff) if uncert < 0: @@ -1416,15 +1413,15 @@ def rotate_stream(stream, metadata, origin, stations_dict, channels, inclination return new_stream - pool = multiprocessing.Pool(ncores, maxtasksperchild=100) - logging.info('Resample_parallel: Generated multiprocessing pool with {} cores.'.format(ncores)) - output_list = pool.map(rotation_worker, input_list, chunksize=10) - pool.close() - logging.info('Closed multiprocessing pool.') - pool.join() - del (pool) - stream.traces = [tr for tr in output_list if tr is not None] - return stream + # pool = multiprocessing.Pool(ncores, maxtasksperchild=100) + # logging.info('Resample_parallel: Generated multiprocessing pool with {} cores.'.format(ncores)) + # output_list = pool.map(rotation_worker, input_list, chunksize=10) + # pool.close() + # logging.info('Closed multiprocessing pool.') + # pool.join() + # del (pool) + # stream.traces = [tr for tr in output_list if tr is not None] + # return stream def correlate_parallel(input_list, ncores): @@ -1583,14 +1580,14 @@ def correlation_worker(input_dict): try: logging.debug(f'Starting Pick correction for {nwst_id}') - xcpc = XcorrPickCorrection(pick_this.time, input_dict['trace1'], other_pick.time, input_dict['trace2'], + xcpc = XCorrPickCorrection(pick_this.time, input_dict['trace1'], other_pick.time, input_dict['trace2'], t_before=t_before, t_after=t_after, cc_maxlag=cc_maxlag) dpick, ccc, uncert, fwm = xcpc.cross_correlation(plot, fig_dir, plot_name='dpick') logging.debug(f'dpick of first correlation: {dpick}') if input_dict['ncorr'] > 1: # and not ccc <= 0: - xcpc2 = XcorrPickCorrection(pick_this.time, input_dict['trace1_highf'], other_pick.time + dpick, + xcpc2 = XCorrPickCorrection(pick_this.time, input_dict['trace1_highf'], other_pick.time + dpick, input_dict['trace2_highf'], t_before=1., t_after=40., cc_maxlag=cc_maxlag2) dpick2, ccc, uncert, fwm = xcpc2.cross_correlation(plot=plot, fig_dir=fig_dir, plot_name='error', diff --git a/pylot/tests/__init__.py b/pylot/tests/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/pylot/tests/test_pick_correlation_correction.py b/pylot/tests/test_pick_correlation_correction.py new file mode 100644 index 00000000..f7f98bc5 --- /dev/null +++ b/pylot/tests/test_pick_correlation_correction.py @@ -0,0 +1,76 @@ +import pytest +from obspy import read, Trace, UTCDateTime + +from pylot.correlation.pick_correlation_correction import XCorrPickCorrection + + +class TestXCorrPickCorrection(): + def setup(self): + self.make_test_traces() + self.make_test_picks() + self.t_before = 2. + self.t_after = 2. + self.cc_maxlag = 0.5 + + def make_test_traces(self): + # take first trace of test Stream from obspy + tr1 = read()[0] + # filter trace + tr1.filter('bandpass', freqmin=1, freqmax=20) + # make a copy and shift the copy by 0.1 s + tr2 = tr1.copy() + tr2.stats.starttime += 0.1 + + self.trace1 = tr1 + self.trace2 = tr2 + + def make_test_picks(self): + # create an artificial reference pick on reference trace (trace1) and another one on the 0.1 s shifted trace + self.tpick1 = UTCDateTime('2009-08-24T00:20:07.7') + # shift the second pick by 0.2 s, the correction should be around 0.1 s now + self.tpick2 = self.tpick1 + 0.2 + + def test_slice_trace_okay(self): + + self.setup() + xcpc = XCorrPickCorrection(UTCDateTime(), Trace(), UTCDateTime(), Trace(), + t_before=self.t_before, t_after=self.t_after, cc_maxlag=self.cc_maxlag) + + test_trace = self.trace1 + pick_time = self.tpick2 + + sliced_trace = xcpc.slice_trace(test_trace, pick_time) + assert ((sliced_trace.stats.starttime == pick_time - self.t_before - self.cc_maxlag / 2) + and (sliced_trace.stats.endtime == pick_time + self.t_after + self.cc_maxlag / 2)) + + def test_slice_trace_fails(self): + self.setup() + + test_trace = self.trace1 + pick_time = self.tpick1 + + with pytest.raises(Exception): + xcpc = XCorrPickCorrection(UTCDateTime(), Trace(), UTCDateTime(), Trace(), + t_before=self.t_before - 20, t_after=self.t_after, cc_maxlag=self.cc_maxlag) + xcpc.slice_trace(test_trace, pick_time) + + with pytest.raises(Exception): + xcpc = XCorrPickCorrection(UTCDateTime(), Trace(), UTCDateTime(), Trace(), + t_before=self.t_before, t_after=self.t_after + 50, cc_maxlag=self.cc_maxlag) + xcpc.slice_trace(test_trace, pick_time) + + def test_cross_correlation(self): + self.setup() + + # create XCorrPickCorrection object + xcpc = XCorrPickCorrection(self.tpick1, self.trace1, self.tpick2, self.trace2, t_before=self.t_before, + t_after=self.t_after, cc_maxlag=self.cc_maxlag) + + # execute correlation + correction, cc_max, uncert, fwfm = xcpc.cross_correlation(False, '', '') + + # define awaited test result + test_result = (-0.09983091718314982, 0.9578431835689154, 0.0015285160561610929, 0.03625786256084631) + + # check results + assert (correction, cc_max, uncert, fwfm) == test_result \ No newline at end of file From c3a2ef502245076ed9e97326aefa5611284cc398 Mon Sep 17 00:00:00 2001 From: Marcel Date: Thu, 8 Aug 2024 09:46:20 +0200 Subject: [PATCH 07/17] [minor] changed test to be approximately equal to test result on different machine --- pylot/tests/test_pick_correlation_correction.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pylot/tests/test_pick_correlation_correction.py b/pylot/tests/test_pick_correlation_correction.py index f7f98bc5..b7289de3 100644 --- a/pylot/tests/test_pick_correlation_correction.py +++ b/pylot/tests/test_pick_correlation_correction.py @@ -73,4 +73,4 @@ class TestXCorrPickCorrection(): test_result = (-0.09983091718314982, 0.9578431835689154, 0.0015285160561610929, 0.03625786256084631) # check results - assert (correction, cc_max, uncert, fwfm) == test_result \ No newline at end of file + assert pytest.approx(test_result, rel=1e-6) == (correction, cc_max, uncert, fwfm) \ No newline at end of file From 452f2a2e1848f710243b56e8d488af44214e9131 Mon Sep 17 00:00:00 2001 From: Marcel Date: Thu, 8 Aug 2024 14:41:16 +0200 Subject: [PATCH 08/17] [bugfix] test raised different Exception than planned --- pylot/correlation/pick_correlation_correction.py | 4 ++-- pylot/tests/test_pick_correlation_correction.py | 6 +++--- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/pylot/correlation/pick_correlation_correction.py b/pylot/correlation/pick_correlation_correction.py index 847cfe1c..8719ad75 100644 --- a/pylot/correlation/pick_correlation_correction.py +++ b/pylot/correlation/pick_correlation_correction.py @@ -174,12 +174,12 @@ class XCorrPickCorrection: msg = f"Trace {tr.id} starts too late. Decrease t_before or cc_maxlag." logging.debug(f'start: {start}, t_before: {self.t_before}, cc_maxlag: {self.cc_maxlag},' f'pick: {pick}') - raise Exception(msg) + raise ValueError(msg) if tr.stats.endtime < end: msg = f"Trace {tr.id} ends too early. Deacrease t_after or cc_maxlag." logging.debug(f'end: {end}, t_after: {self.t_after}, cc_maxlag: {self.cc_maxlag},' f'pick: {pick}') - raise Exception(msg) + raise ValueError(msg) # apply signal processing and take correct slice of data return tr.slice(start, end) diff --git a/pylot/tests/test_pick_correlation_correction.py b/pylot/tests/test_pick_correlation_correction.py index b7289de3..fb9311e5 100644 --- a/pylot/tests/test_pick_correlation_correction.py +++ b/pylot/tests/test_pick_correlation_correction.py @@ -49,12 +49,12 @@ class TestXCorrPickCorrection(): test_trace = self.trace1 pick_time = self.tpick1 - with pytest.raises(Exception): + with pytest.raises(ValueError): xcpc = XCorrPickCorrection(UTCDateTime(), Trace(), UTCDateTime(), Trace(), - t_before=self.t_before - 20, t_after=self.t_after, cc_maxlag=self.cc_maxlag) + t_before=self.t_before + 20, t_after=self.t_after, cc_maxlag=self.cc_maxlag) xcpc.slice_trace(test_trace, pick_time) - with pytest.raises(Exception): + with pytest.raises(ValueError): xcpc = XCorrPickCorrection(UTCDateTime(), Trace(), UTCDateTime(), Trace(), t_before=self.t_before, t_after=self.t_after + 50, cc_maxlag=self.cc_maxlag) xcpc.slice_trace(test_trace, pick_time) From a068bb84577c10d9af592f16f5b3e61448cf6f10 Mon Sep 17 00:00:00 2001 From: Marcel Date: Thu, 8 Aug 2024 16:49:15 +0200 Subject: [PATCH 09/17] [update] refactoring, added type hints --- .../pick_correlation_correction.py | 384 ++++++++++-------- 1 file changed, 219 insertions(+), 165 deletions(-) diff --git a/pylot/correlation/pick_correlation_correction.py b/pylot/correlation/pick_correlation_correction.py index 8719ad75..737e2853 100644 --- a/pylot/correlation/pick_correlation_correction.py +++ b/pylot/correlation/pick_correlation_correction.py @@ -21,7 +21,7 @@ from joblib import Parallel, delayed from obspy import read, Stream, UTCDateTime, Trace from obspy.taup import TauPyModel from obspy.core.event.base import WaveformStreamID, ResourceIdentifier -from obspy.core.event.origin import Pick +from obspy.core.event.origin import Pick, Origin from obspy.geodetics.base import gps2dist_azimuth from obspy.signal.cross_correlation import correlate, xcorr_max @@ -34,6 +34,12 @@ from pylot.core.util.event import Event as PylotEvent from pylot.correlation.utils import (get_event_id, get_event_pylot, get_event_obspy_dmt, get_picks, write_json, get_metadata) +DEBUG_LEVELS = {'debug': logging.DEBUG, + 'info': logging.INFO, + 'warn': logging.WARNING, + 'error': logging.ERROR, + 'critical': logging.CRITICAL} + class CorrelationParameters: """ @@ -210,7 +216,7 @@ class XCorrPickCorrection: Returns: array: A numpy array representing the time axis. """ - return np.linspace(0,trace.stats.endtime -trace.stats.starttime, trace.stats.npts) + return np.linspace(0, trace.stats.endtime - trace.stats.starttime, trace.stats.npts) def plot_cc(figure_output_dir: str, plot_filename: str) -> None: """ @@ -316,7 +322,7 @@ class XCorrPickCorrection: peak_index = cc.argmax() first_sample = peak_index # XXX this could be improved.. - while first_sample > 0 and cc_curvature[first_sample - 1] <= 0: + while first_sample > 0 >= cc_curvature[first_sample - 1]: first_sample -= 1 last_sample = peak_index while last_sample < len(cc) - 1 and cc_curvature[last_sample + 1] <= 0: @@ -337,7 +343,7 @@ class XCorrPickCorrection: # quadratic fit for small subwindow coeffs, cov_mat = np.polyfit(cc_t[first_sample:last_sample + 1], cc[first_sample:last_sample + 1], deg=2, - full=False, cov=True)[:2] + full=False, cov=True)[:2] a, b, c = coeffs @@ -380,9 +386,10 @@ class XCorrPickCorrection: return pick2_corr, coeff, uncert, fwfm -def correlation_main(database_path_dmt, pylot_infile_path, params, channel_config, istart=0, istop=1e9, update=False, - event_blacklist=None): - ''' +def correlation_main(database_path_dmt: str, pylot_infile_path: str, params: dict, channel_config: dict, + istart: int = 0, istop: int = 1e9, update: bool = False, + event_blacklist: str = None, select_events: list = None) -> None: + """ Main function of this program, correlates waveforms around theoretical, or other initial (e.g. automatic cf) picks on one or more reference stations. All stations with a correlation higher "min_corr_stacking" are stacked onto the station with the highest mean @@ -390,12 +397,21 @@ def correlation_main(database_path_dmt, pylot_infile_path, params, channel_confi Finally, all other stations will be correlated with the re-picked, stacked seismogram around their theoretical (or initial) onsets and the shifted pick time of the stacked seismogram will be assigned as their new pick time. - :param database_path_dmt: obspy_dmt databse directory - :param pylot_infile_path: path containing input file for autoPyLoT (automatic picking parameters) - :param params: dictionary with parameter class objects + Args: + database_path_dmt (str): The path to the obspydmt database. + pylot_infile_path (str): The path to the Pylot infile for autoPyLoT (automatic picking parameters). + params (dict): Parameters for the correlation script. + channel_config (dict): Configuration for channels. + istart (int, optional): The starting index for events. Defaults to 0. + istop (float, optional): The stopping index for events. Defaults to 1e9. + update (bool, optional): Whether to update. Defaults to False. + event_blacklist (str, optional): Path to the event blacklist file. Defaults to None. + select_events (list, optional): List of selected events. Defaults to None. + Returns: + None :return: - ''' + """ assert os.path.isdir(database_path_dmt), 'Unrecognized directory {}'.format(database_path_dmt) tstart = datetime.now() @@ -405,39 +421,38 @@ def correlation_main(database_path_dmt, pylot_infile_path, params, channel_confi logging.info(50 * '#') for phase_type in params.keys(): - if params[phase_type]['plot_detailed']: params[phase_type]['plot'] = True + if params[phase_type]['plot_detailed']: + params[phase_type]['plot'] = True eventdirs = glob.glob(os.path.join(database_path_dmt, '*.?')) pylot_parameter = PylotParameter(pylot_infile_path) if event_blacklist: - with open(event_blacklist, 'r') as infile: - event_blacklist = [line.split('\n')[0] for line in infile.readlines()] + with open(event_blacklist, 'r') as fid: + event_blacklist = [line.split('\n')[0] for line in fid.readlines()] # iterate over all events in "database_path_dmt" for eventindex, eventdir in enumerate(eventdirs): if not istart <= eventindex < istop: continue - # MP MP testing +++ - # ids_filter = ['20181229_033914.a'] - # if not os.path.split(eventdir)[-1] in ids_filter: - # continue - # MP MP testing --- + if select_events and not os.path.split(eventdir)[-1] in select_events: + continue logging.info('\n' + 100 * '#') logging.info('Working on event {} ({}/{})'.format(eventdir, eventindex + 1, len(eventdirs))) if event_blacklist and get_event_id(eventdir) in event_blacklist: logging.info('Event on blacklist. Continue') - correlate_event(eventdir, pylot_parameter, params=params, channel_config=channel_config, update=update) + correlate_event(eventdir, pylot_parameter, params=params, channel_config=channel_config, + update=update) logging.info('Finished script after {} at {}'.format(datetime.now() - tstart, datetime.now())) -def get_estimated_inclination(stations_dict, origin, phases, model='ak135'): - ''' calculate a mean inclination angle for all stations for seismometer rotation to spare computation time''' +def get_estimated_inclination(stations_dict: dict, origin: Origin, phases: str, model: str = 'ak135') -> float: + """ calculate a mean inclination angle for all stations for seismometer rotation to spare computation time""" model = TauPyModel(model) phases = [*phases.split(',')] avg_lat = np.median([item['latitude'] for item in stations_dict.values()]) @@ -448,9 +463,9 @@ def get_estimated_inclination(stations_dict, origin, phases, model='ak135'): return arrivals[0].incident_angle -def modify_horizontal_name(wfdata): - ''' This function only renames (does not rotate!) numeric channel IDs to be able to rotate them to LQT. It is - therefore not accurate and only used for picking with correlation. Returns a copy of the original stream. ''' +def modify_horizontal_name(wfdata: Stream) -> Stream: + """ This function only renames (does not rotate!) numeric channel IDs to be able to rotate them to LQT. It is + therefore not accurate and only used for picking with correlation. Returns a copy of the original stream. """ # wfdata = wfdata.copy() stations = np.unique([tr.stats.station for tr in wfdata]) for station in stations: @@ -460,13 +475,14 @@ def modify_horizontal_name(wfdata): st = wfdata.select(station=station, location=location) channels = [tr.stats.channel for tr in st] check_numeric = [channel[-1].isnumeric() for channel in channels] - check_nonnumeric = [not (cn) for cn in check_numeric] + check_nonnumeric = [not cn for cn in check_numeric] if not any(check_numeric): continue numeric_channels = np.array(channels)[check_numeric].tolist() nonnumeric_channels = np.array(channels)[check_nonnumeric].tolist() - if not 'Z' in [nc[-1] for nc in nonnumeric_channels]: - logging.warning('Modify_horizontal_name failed: Only implemented for existing Z component! Return original data.') + if 'Z' not in [nc[-1] for nc in nonnumeric_channels]: + logging.warning( + 'Modify_horizontal_name failed: Only implemented for existing Z component! Return original data.') return wfdata numeric_characters = sorted([nc[-1] for nc in numeric_channels]) if numeric_characters == ['1', '2']: @@ -474,7 +490,8 @@ def modify_horizontal_name(wfdata): elif numeric_characters == ['2', '3']: channel_dict = {'2': 'N', '3': 'E'} else: - logging.warning('Modify_horizontal_name failed: Channel order not implemented/unknown. Return original data.') + logging.warning( + 'Modify_horizontal_name failed: Channel order not implemented/unknown. Return original data.') return wfdata for tr in st: channel = tr.stats.channel @@ -486,10 +503,10 @@ def modify_horizontal_name(wfdata): return wfdata -def cut_stream_to_same_length(wfdata): - def remove(wfdata, st): - for tr in st: - wfdata.remove(tr) +def cut_stream_to_same_length(wfdata: Stream) -> None: + def remove(data, stream): + for tr in stream: + data.remove(tr) stations = np.unique([tr.stats.station for tr in wfdata]) for station in stations: @@ -515,7 +532,7 @@ def cut_stream_to_same_length(wfdata): st.trim(tstart, tend, pad=True, fill_value=0.) -def get_unique_phase(picks, rename_phases=None): +def get_unique_phase(picks: list, rename_phases: dict = None) -> str: phases = [pick.phase_hint for pick in picks] if rename_phases: phases = [rename_phases[phase] if phase in rename_phases else phase for phase in phases] @@ -523,10 +540,10 @@ def get_unique_phase(picks, rename_phases=None): if len(set(phases)) == 1: return phases[0] - return False - -def correlate_event(eventdir, pylot_parameter, params, channel_config, update): +# TODO: simplify this function +def correlate_event(eventdir: str, pylot_parameter: PylotParameter, params: dict, channel_config: dict, + update: bool) -> bool: rename_phases = {'Pdiff': 'P'} # create ObsPy event from .pkl file in dmt eventdir @@ -588,7 +605,8 @@ def correlate_event(eventdir, pylot_parameter, params, channel_config, update): wfdata = wfdata_raw.copy() # resample and filter if params[phase_type]['sampfreq']: - wfdata = resample_parallel(wfdata, params[phase_type]['sampfreq'], ncores=params[phase_type]['ncores']) + wfdata = resample_parallel(wfdata, params[phase_type]['sampfreq'], + ncores=params[phase_type]['ncores']) else: logging.warning('Resampling deactivated! ' 'Make sure that the sampling rate of all input waveforms is identical') @@ -602,7 +620,8 @@ def correlate_event(eventdir, pylot_parameter, params, channel_config, update): else: method = 'auto' # get all picks from PyLoT *.xml file - if not pfe.startswith('_'): pfe = '_' + pfe + if not pfe.startswith('_'): + pfe = '_' + pfe picks = get_picks(eventdir, extension=pfe) # take picks of selected phase only picks = [pick for pick in picks if pick.phase_hint == phase_type] @@ -630,7 +649,7 @@ def correlate_event(eventdir, pylot_parameter, params, channel_config, update): model='ak135') # rotate ZNE -> LQT (also cut to same length) wfdata = rotate_stream(wfdata, metadata=metadata, origin=origin, stations_dict=stations_dict, - channels=channels[phase_type], inclination=inclination, ncores=ncores) + channels=CHANNELS[phase_type], inclination=inclination, ncores=ncores) # make copies before filtering wfdata_lowf = wfdata.copy() @@ -644,7 +663,8 @@ def correlate_event(eventdir, pylot_parameter, params, channel_config, update): # make directory for correlation output correlation_out_dir = create_correlation_output_dir(eventdir, filter_options_final, true_phase_type) - fig_dir = create_correlation_figure_dir(correlation_out_dir) if params[phase_type]['save_fig'] == True else '' + fig_dir = create_correlation_figure_dir(correlation_out_dir) \ + if params[phase_type]['save_fig'] is True else '' if not params[phase_type]['use_stacked_trace']: # first stack mastertrace by using stations with high correlation on that station in station list with the @@ -666,13 +686,14 @@ def correlate_event(eventdir, pylot_parameter, params, channel_config, update): if params[phase_type]['plot']: # plot correlations of traces used to generate stacked trace plot_mastertrace_corr(nwst_id, correlations_dict, wfdata_lowf, stations_dict, picks, trace_master, method, - min_corr=params[phase_type]['min_corr_stacking'], title=eventdir + '_before_stacking', - fig_dir=fig_dir) + min_corr=params[phase_type]['min_corr_stacking'], + title=eventdir + '_before_stacking', fig_dir=fig_dir) # continue if there is not enough traces for stacking if nstack < params[phase_type]['min_stack']: logging.warning('Not enough traces to stack: {} (min_stack = {}). Skip this event'.format(nstack, - params[phase_type][ + params[ + phase_type][ 'min_stack'])) continue @@ -680,8 +701,8 @@ def correlate_event(eventdir, pylot_parameter, params, channel_config, update): trace_master.write(os.path.join(correlation_out_dir, '{}_stacked.mseed'.format(trace_master.id))) # now pick stacked trace with PyLoT for a more precise pick (use raw trace, gets filtered by autoPyLoT) - pick_stacked = repick_mastertrace(wfdata_lowf, trace_master, pylot_parameter, event, event_id, metadata, - phase_type, correlation_out_dir) + pick_stacked = repick_master_trace(wfdata_lowf, trace_master, pylot_parameter, event, event_id, metadata, + phase_type, correlation_out_dir) if not pick_stacked: continue @@ -696,7 +717,7 @@ def correlate_event(eventdir, pylot_parameter, params, channel_config, update): trace_master_highf.filter(filter_type, **filter_options_final) input_list = prepare_correlation_input(wfdata_lowf, picks, channels_list, trace_master_lowf, pick_stacked, - params=params[phase_type], plot=params[phase_type]['plot'], + phase_params=params[phase_type], plot=params[phase_type]['plot'], fig_dir=fig_dir_traces, ncorr=2, wfdata_highf=wfdata_highf, trace_master_highf=trace_master_highf) @@ -712,8 +733,8 @@ def correlate_event(eventdir, pylot_parameter, params, channel_config, update): export_picks(eventdir=eventdir, correlations_dict=get_stations_min_corr(correlations_dict_stacked, params[phase_type]['min_corr_export']), - params=params[phase_type], picks=picks, taupypicks=taupypicks_orig, phase_type=true_phase_type, - pf_extension=pfe) + params=params[phase_type], picks=picks, taupypicks=taupypicks_orig, + phase_type=true_phase_type, pf_extension=pfe) # plot results if params[phase_type]['plot']: @@ -748,10 +769,12 @@ def correlate_event(eventdir, pylot_parameter, params, channel_config, update): if len(correlations_dict_stacked) > 0: return True + else: + return False def remove_outliers(picks, corrected_taupy_picks, threshold): - ''' delete a pick if difference to corrected taupy pick is larger than threshold''' + """ delete a pick if difference to corrected taupy pick is larger than threshold""" n_picks = len(picks) n_outl = 0 @@ -780,7 +803,7 @@ def remove_outliers(picks, corrected_taupy_picks, threshold): def remove_invalid_picks(picks): - ''' Remove picks without uncertainty (invalid PyLoT picks)''' + """ Remove picks without uncertainty (invalid PyLoT picks)""" count = 0 deleted_picks_ids = [] for index, pick in list(reversed(list(enumerate(picks)))): @@ -803,7 +826,7 @@ def get_picks_mean(picks): def get_corrected_taupy_picks(picks, taupypicks, all_available=False): - ''' get mean/median from picks taupy picks, correct latter for the difference ''' + """ get mean/median from picks taupy picks, correct latter for the difference """ def nwst_id_from_wfid(wfid): return '{}.{}'.format(wfid.network_code if wfid.network_code else '', @@ -824,8 +847,9 @@ def get_corrected_taupy_picks(picks, taupypicks, all_available=False): mean_diff = taupy_mean - picks_mean logging.info(f'Calculated {len(taupypicks_new)} TauPy theoretical picks.') - logging.info('Calculated median difference from TauPy theoretical picks of {} seconds. (mean: {})'.format(median_diff, - mean_diff)) + logging.info( + 'Calculated median difference from TauPy theoretical picks of {} seconds. (mean: {})'.format(median_diff, + mean_diff)) # return all available taupypicks corrected for median difference to autopicks if all_available: @@ -851,7 +875,8 @@ def load_stacked_trace(eventdir, min_corr_stack): if not os.path.isfile(corr_dict_fpath): logging.warning('No correlations_for_stacking dict found for event {}!'.format(eventdir)) return - corr_dict = json.load(corr_dict_fpath) # TODO: Check this line + with open(corr_dict_fpath) as fid: + corr_dict = json.load(fid) # get stations for stacking and nstack stations4stack = get_stations_min_corr(corr_dict, min_corr_stack) @@ -866,10 +891,10 @@ def load_stacked_trace(eventdir, min_corr_stack): return corr_dict, nwst_id, stacked_trace, nstack -def repick_mastertrace(wfdata, trace_master, pylot_parameter, event, event_id, metadata, phase_type, corr_out_dir): - rename_LQT = phase_type == 'S' +def repick_master_trace(wfdata, trace_master, pylot_parameter, event, event_id, metadata, phase_type, corr_out_dir): + rename_lqt = phase_type == 'S' # create an 'artificial' stream object which can be used as input for PyLoT - stream_master = modify_master_trace4pick(trace_master.copy(), wfdata, rename_LQT=rename_LQT) + stream_master = modify_master_trace4pick(trace_master.copy(), wfdata, rename_lqt=rename_lqt) stream_master.write(os.path.join(corr_out_dir, 'stacked_master_trace_pylot.mseed'.format(trace_master.id))) try: picksdict = autopickstation(stream_master, pylot_parameter, verbose=True, metadata=metadata, @@ -894,10 +919,10 @@ def repick_mastertrace(wfdata, trace_master, pylot_parameter, event, event_id, m return pick_stacked -def create_correlation_output_dir(eventdir, fopts, phase_type): +def create_correlation_output_dir(eventdir: str, fopts: dict, phase_type: str) -> str: folder = 'correlation' folder = add_fpath_extension(folder, fopts, phase_type) - export_path = os.path.join(eventdir, folder) + export_path = str(os.path.join(eventdir, folder)) if not os.path.isdir(export_path): os.mkdir(export_path) return export_path @@ -927,12 +952,12 @@ def write_correlation_output(export_path, correlations_dict, correlations_dict_s write_json(correlations_dict_stacked, os.path.join(export_path, 'correlation_results.json')) -def modify_master_trace4pick(trace_master, wfdata, rename_LQT=True): - ''' +def modify_master_trace4pick(trace_master, wfdata, rename_lqt=True): + """ Create an artificial Stream with master trace instead of the trace of its corresponding channel. This is done to find metadata for correct station metadata which were modified when stacking (e.g. loc=ST) USE THIS ONLY FOR PICKING! - ''' + """ # fake ZNE coordinates for autopylot lqt_zne = {'L': 'Z', 'Q': 'N', 'T': 'E'} @@ -949,7 +974,7 @@ def modify_master_trace4pick(trace_master, wfdata, rename_LQT=True): # take location from old trace and overwrite trace_master.stats.location = trace.stats.location trace = trace_master - if rename_LQT: + if rename_lqt: channel = trace.stats.channel component_new = lqt_zne.get(channel[-1]) if not component_new: @@ -1088,7 +1113,7 @@ def get_pickfile_name_correlated(event_id, fopts, phase_type): # return trace_this -def prepare_correlation_input(wfdata, picks, channels, trace_master, pick_master, params, plot=None, fig_dir=None, +def prepare_correlation_input(wfdata, picks, channels, trace_master, pick_master, phase_params, plot=None, fig_dir=None, ncorr=1, wfdata_highf=None, trace_master_highf=None): # prepare input for multiprocessing worker for all 'other' picks to correlate with current master-trace input_list = [] @@ -1096,7 +1121,7 @@ def prepare_correlation_input(wfdata, picks, channels, trace_master, pick_master assert (ncorr in [1, 2]), 'ncorr has to be 1 or 2' for pick_other in picks: - trace_other_highf = None + stream_other = stream_other_high_f = trace_other_high_f = channel = None network_other = pick_other.waveform_id.network_code station_other = pick_other.waveform_id.station_code nwst_id_other = '{nw}.{st}'.format(nw=network_other, st=station_other) @@ -1106,7 +1131,7 @@ def prepare_correlation_input(wfdata, picks, channels, trace_master, pick_master for channel in channels: stream_other = wfdata.select(network=network_other, station=station_other, channel=channel) if ncorr == 2: - stream_other_highf = wfdata_highf.select(network=network_other, station=station_other, channel=channel) + stream_other_high_f = wfdata_highf.select(network=network_other, station=station_other, channel=channel) if stream_other: break if not stream_other: @@ -1114,37 +1139,39 @@ def prepare_correlation_input(wfdata, picks, channels, trace_master, pick_master continue trace_other = stream_other[0] if ncorr == 2: - trace_other_highf = stream_other_highf[0] + trace_other_high_f = stream_other_high_f[0] if trace_other == stream_other: continue input_dict = {'nwst_id': nwst_id_other, 'trace1': trace_master, 'pick1': pick_master, 'trace2': trace_other, - 'pick2': pick_other, 'channel': channel, 't_before': params['t_before'], - 't_after': params['t_after'], 'cc_maxlag': params['cc_maxlag'], - 'cc_maxlag2': params['cc_maxlag2'], 'plot': plot, 'fig_dir': fig_dir, 'ncorr': ncorr, - 'trace1_highf': trace_master_highf, 'trace2_highf': trace_other_highf, - 'min_corr': params['min_corr_export']} + 'pick2': pick_other, 'channel': channel, 't_before': phase_params['t_before'], + 't_after': phase_params['t_after'], 'cc_maxlag': phase_params['cc_maxlag'], + 'cc_maxlag2': phase_params['cc_maxlag2'], 'plot': plot, 'fig_dir': fig_dir, 'ncorr': ncorr, + 'trace1_highf': trace_master_highf, 'trace2_highf': trace_other_high_f, + 'min_corr': phase_params['min_corr_export']} input_list.append(input_dict) return input_list -def stack_mastertrace(wfdata_lowf, wfdata_highf, wfdata_raw, picks, params, channels, method, fig_dir): - ''' +def stack_mastertrace(wfdata_lowf: Stream, wfdata_highf: Stream, wfdata_raw: Stream, picks: list, params: dict, + channels: list, method: str, fig_dir: str): + """ Correlate all stations with the first available station given in station_list, a list containing central, permanent, long operating, low noise stations with descending priority. A master trace will be created by stacking well correlating traces onto this station. - ''' + """ - def get_best_station4stack(station_results): - ''' return station with maximum mean_ccc''' - ccc_means = {nwst_id: value['mean_ccc'] for nwst_id, value in station_results.items() if + def get_best_station4stack(sta_result): + """ return station with maximum mean_ccc""" + ccc_means = {nwst_id: value['mean_ccc'] for nwst_id, value in sta_result.items() if not np.isnan(value['mean_ccc'])} if len(ccc_means) < 1: logging.warning('No valid station found for stacking! Return.') return best_station_id = max(ccc_means, key=ccc_means.get) - logging.info('Found highest mean correlation for station {} ({})'.format(best_station_id, max(ccc_means.values()))) + logging.info( + 'Found highest mean correlation for station {} ({})'.format(best_station_id, max(ccc_means.values()))) return best_station_id station_results = iterate_correlation(wfdata_lowf, wfdata_highf, channels, picks, method, params, fig_dir=fig_dir) @@ -1153,7 +1180,7 @@ def stack_mastertrace(wfdata_lowf, wfdata_highf, wfdata_raw, picks, params, chan # in case no stream with a valid pick is found if not nwst_id_master: logging.info('No mastertrace found! Will skip this event.') - return False + return None trace_master = station_results[nwst_id_master]['trace'] stations4stack = station_results[nwst_id_master]['stations4stack'] @@ -1163,22 +1190,27 @@ def stack_mastertrace(wfdata_lowf, wfdata_highf, wfdata_raw, picks, params, chan dt_pre, dt_post = params['dt_stacking'] trace_master, nstack = apply_stacking(trace_master, stations4stack, wfdata_raw, picks, method=method, - check_RMS=params['check_RMS'], plot=params['plot'], fig_dir=fig_dir, + check_rms=params['check_RMS'], plot=params['plot'], fig_dir=fig_dir, dt_pre=dt_pre, dt_post=dt_post) return correlations_dict, nwst_id_master, trace_master, nstack -def iterate_correlation(wfdata_lowf, wfdata_highf, channels, picks, method, params, fig_dir=None): - '''iterate over possible stations for master-trace store them and return a dictionary''' +def iterate_correlation(wfdata_lowf: Stream, wfdata_highf: Stream, channels: list, picks: list, method: str, + params: dict, fig_dir: str = None) -> dict: + """iterate over possible stations for master-trace store them and return a dictionary""" - station_results = {nwst_id: {'mean_ccc': np.nan, 'correlations_dict': None, 'stations4stack': None, 'trace': None} + station_results = {nwst_id: {'mean_ccc': np.nan, 'correlations_dict': dict(), 'stations4stack': dict(), + 'trace': None} for nwst_id in params['station_list']} for nwst_id_master in params['station_list']: logging.info(20 * '#') logging.info('Starting correlation for station: {}'.format(nwst_id_master)) nw, st = nwst_id_master.split('.') + + # get master-trace + stream_master_lowf = stream_master_highf = None for channel in channels: stream_master_lowf = wfdata_lowf.select(network=nw, station=st, channel=channel) stream_master_highf = wfdata_highf.select(network=nw, station=st, channel=channel) @@ -1211,8 +1243,8 @@ def iterate_correlation(wfdata_lowf, wfdata_highf, channels, picks, method, para input_list = prepare_correlation_input(wfdata_lowf, picks, channels, trace_master_lowf, pick_master, trace_master_highf=trace_master_highf, wfdata_highf=wfdata_highf, - params=params, plot=params['plot_detailed'], fig_dir=fig_dir_traces, - ncorr=2) + phase_params=params, plot=params['plot_detailed'], + fig_dir=fig_dir_traces, ncorr=2) if params['plot_detailed'] and not fig_dir_traces: # serial @@ -1231,9 +1263,11 @@ def iterate_correlation(wfdata_lowf, wfdata_highf, channels, picks, method, para return station_results -def apply_stacking(trace_master, stations4stack, wfdata, picks, method, check_RMS, dt_pre=250., dt_post=250., - plot=False, fig_dir=None): - def check_trace_length_and_cut(trace, correlated_midtime, dt_pre, dt_post): +def apply_stacking(trace_master: Trace, stations4stack: dict, wfdata: Stream, picks: list, method: str, + check_rms: bool, dt_pre: float = 250., dt_post: float = 250., plot: bool = False, + fig_dir: str = None) -> tuple: + + def check_trace_length_and_cut(trace: Trace): starttime = correlated_midtime - dt_pre endtime = correlated_midtime + dt_post @@ -1248,7 +1282,7 @@ def apply_stacking(trace_master, stations4stack, wfdata, picks, method, check_RM trace_master = trace_master.copy() trace_master.stats.location = 'ST' - check_trace_length_and_cut(trace_master, pick.time, dt_pre=dt_pre, dt_post=dt_post) + check_trace_length_and_cut(trace_master) # empty trace so that it does not stack twice trace_master.data = np.zeros(len(trace_master.data)) @@ -1262,15 +1296,16 @@ def apply_stacking(trace_master, stations4stack, wfdata, picks, method, check_RM stream_other = wfdata.select(network=nw, station=st, channel=channel) correlated_midtime = pick_other.time - dpick trace_other = stream_other[0].copy() - check_trace_length_and_cut(trace_other, correlated_midtime, dt_pre=dt_pre, dt_post=dt_post) + check_trace_length_and_cut(trace_other) if not len(trace_other) == len(trace_master): - logging.warning('Can not stack trace on master trace because of different lengths: {}. Continue'.format(nwst_id)) + logging.warning( + 'Can not stack trace on master trace because of different lengths: {}. Continue'.format(nwst_id)) continue traces4stack.append(trace_other) - if check_RMS: + if check_rms: traces4stack = checkRMS(traces4stack, plot=plot, fig_dir=fig_dir) if plot: @@ -1307,12 +1342,14 @@ def checkRMS(traces4stack, plot=False, fig_dir=None, max_it=10, ntimes_std=5.): traces4stack = sorted(traces4stack, key=lambda x: x.id) for trace in traces4stack: - rms_list.append(RMS(trace.data)) + rms_list.append(calc_rms(trace.data)) trace_names.append(trace.id) # iterative elimination of RMS outliers iterate = True count = 0 + std = 0 + mean = 0 while iterate: count += 1 if count >= max_it: @@ -1341,7 +1378,8 @@ def checkRMS(traces4stack, plot=False, fig_dir=None, max_it=10, ntimes_std=5.): return traces4stack -def plot_rms(rms_list, trace_names, mean, std, fig_dir, count, ntimes_std): +def plot_rms(rms_list: list, trace_names: list, mean: float, std: float, fig_dir: str, count: int, + ntimes_std: float) -> None: fig = plt.figure(figsize=(16, 9)) ax = fig.add_subplot(111) ax.semilogy(rms_list, 'b.') @@ -1359,7 +1397,7 @@ def plot_rms(rms_list, trace_names, mean, std, fig_dir, count, ntimes_std): plt.close(fig) -def RMS(X): +def calc_rms(X): """ Returns root mean square of a given array LON """ @@ -1381,7 +1419,7 @@ def resample_parallel(stream, freq, ncores): def rotate_stream(stream, metadata, origin, stations_dict, channels, inclination, ncores): - ''' Rotate stream to LQT. To do this all traces have to be cut to equal lenths''' + """ Rotate stream to LQT. To do this all traces have to be cut to equal lenths""" input_list = [] cut_stream_to_same_length(stream) new_stream = Stream() @@ -1424,7 +1462,7 @@ def rotate_stream(stream, metadata, origin, stations_dict, channels, inclination # return stream -def correlate_parallel(input_list, ncores): +def correlate_parallel(input_list: list, ncores: int) -> dict: parallel = Parallel(n_jobs=ncores) logging.info('Correlate_parallel: Generated {} parallel jobs.'.format(ncores)) @@ -1435,7 +1473,7 @@ def correlate_parallel(input_list, ncores): return unpack_result(correlation_result) -def correlate_serial(input_list, plot=False): +def correlate_serial(input_list: list, plot: bool = False) -> dict: correlation_result = [] for input_dict in input_list: input_dict['plot'] = plot @@ -1443,7 +1481,7 @@ def correlate_serial(input_list, plot=False): return unpack_result(correlation_result) -def taupy_parallel(input_list, ncores): +def taupy_parallel(input_list: list, ncores: int) -> dict: parallel = Parallel(n_jobs=ncores) logging.info('Taupy_parallel: Generated {} parallel jobs.'.format(ncores)) @@ -1454,19 +1492,19 @@ def taupy_parallel(input_list, ncores): return unpack_result(taupy_results) -def unpack_result(result): +def unpack_result(result: list) -> dict: result_dict = {item['nwst_id']: {key: item[key] for key in item.keys()} for item in result} nerr = 0 for item in result_dict.values(): if item['err']: logging.debug(f'Found error for {item["nwst_id"]}: {item["err"]}.') - #logging.debug(f'Detailed traceback: {item["exc"]}') + # logging.debug(f'Detailed traceback: {item["exc"]}') nerr += 1 logging.info('Unpack results: Found {} errors after multiprocessing'.format(nerr)) return result_dict -def get_taupy_picks(origin, stations_dict, pylot_parameter, phase_type, ncores=None): +def get_taupy_picks(origin: Origin, stations_dict, pylot_parameter, phase_type, ncores=None): input_list = [] taup_phases = pylot_parameter['taup_phases'].split(',') @@ -1526,10 +1564,10 @@ def taupy_worker(input_dict): first_arrival = arrivals[0] output_dict = dict(nwst_id=input_dict['nwst_id'], phase_name=first_arrival.name, phase_time=source_time + first_arrival.time, phase_dist=first_arrival.distance, err=None, - exc=None,) + exc=None, ) except Exception as e: exc = traceback.format_exc() - output_dict = dict(nwst_id=input_dict['nwst_id'], phase_name=None, phase_time=None, err=str(e), exc=exc,) + output_dict = dict(nwst_id=input_dict['nwst_id'], phase_name=None, phase_time=None, err=str(e), exc=exc, ) return output_dict @@ -1559,7 +1597,7 @@ def rotation_worker(input_dict): def correlation_worker(input_dict): - '''worker function for multiprocessing''' + """worker function for multiprocessing""" # unpack input dictionary nwst_id = input_dict['nwst_id'] @@ -1613,7 +1651,7 @@ def correlation_worker(input_dict): 'channel': channel, } -def get_pick4station(picks, network_code, station_code, method='auto'): +def get_pick4station(picks: list, network_code: str, station_code: str, method: str = 'auto') -> Pick: for pick in picks: if pick.waveform_id.network_code == network_code: if pick.waveform_id.station_code == station_code: @@ -1621,13 +1659,14 @@ def get_pick4station(picks, network_code, station_code, method='auto'): return pick -def get_stations_min_corr(corr_results, min_corr): +def get_stations_min_corr(corr_results: dict, min_corr: float) -> dict: corr_results = {nwst_id: result for nwst_id, result in corr_results.items() if result['ccc'] > min_corr} return corr_results -def plot_mastertrace_corr(nwst_id, corr_results, wfdata, stations_dict, picks, trace_master, method, min_corr, title, - fig_dir=None): +def plot_mastertrace_corr(nwst_id: str, corr_results: dict, wfdata: Stream, stations_dict: dict, picks: list, + trace_master: Trace, method: str, min_corr: float, title: str, + fig_dir: str = None) -> None: nw, st = nwst_id.split('.') coords_master = stations_dict[nwst_id] pick_master = get_pick4station(picks, nw, st, method) @@ -1650,7 +1689,7 @@ def plot_mastertrace_corr(nwst_id, corr_results, wfdata, stations_dict, picks, t plt.show() -def make_figure_dirs(fig_dir, trace_master_id): +def make_figure_dirs(fig_dir: str, trace_master_id: str) -> str: fig_dir_traces = '' if fig_dir and os.path.isdir(fig_dir): fig_dir_traces = os.path.join(fig_dir, 'corr_with_{}'.format(trace_master_id)) @@ -1659,15 +1698,18 @@ def make_figure_dirs(fig_dir, trace_master_id): return fig_dir_traces -def plot_section(wfdata, trace_this, pick_this, picks, stations2compare, channels, corr_results, method, dt_pre=20., - dt_post=50, axes=None, max_stations=50.): - '''Plot a section with all stations used for correlation on ax''' +def plot_section(wfdata: Stream, trace_this: Trace, pick_this: Pick, picks: list, stations2compare: dict, + channels: list, corr_results: dict, method: str, dt_pre: float = 20., dt_post: float = 50., + axes: dict = None, max_stations: int = 50) -> None: + """Plot a section with all stations used for correlation on ax""" ylabels = [] yticks = [] trace_this = trace_this.copy() trace_this.trim(starttime=pick_this.time - dt_pre, endtime=pick_this.time + dt_post) + ax_sec = None + # iterate over all closest stations ("other" stations) for index, nwst_id in enumerate(stations2compare.keys()): if index >= max_stations: @@ -1700,6 +1742,8 @@ def plot_section(wfdata, trace_this, pick_this, picks, stations2compare, channel if np.isnan(dpick) or not pick_other or not pick_other.time: continue + stream = None + # continue if there are no data for station for whatever reason for channel in channels: stream = wfdata.select(station=st, network=nw, channel=channel) @@ -1718,13 +1762,14 @@ def plot_section(wfdata, trace_this, pick_this, picks, stations2compare, channel index + 0.5, color='r', lw=0.5) # Plot desciption - ax_sec.set_yticks(yticks) - ax_sec.set_yticklabels(ylabels) - ax_sec.set_title('Section with corresponding picks.') - ax_sec.set_xlabel('Samples. Traces are shifted in time.') + if ax_sec: + ax_sec.set_yticks(yticks) + ax_sec.set_yticklabels(ylabels) + ax_sec.set_title('Section with corresponding picks.') + ax_sec.set_xlabel('Samples. Traces are shifted in time.') -def plot_stacked_trace_pick(trace, pick, pylot_parameter): +def plot_stacked_trace_pick(trace: Trace, pick: Pick, pylot_parameter: PylotParameter) -> plt.Figure: trace_filt = trace.copy() if pylot_parameter['filter_type'] and pylot_parameter['filter_options']: ftype = pylot_parameter['filter_type'][0] @@ -1746,8 +1791,9 @@ def plot_stacked_trace_pick(trace, pick, pylot_parameter): return fig -def plot_stations(stations_dict, stations2compare, coords_this, corr_result, trace, pick, window_title=None): - ''' Plot routine to check proximity algorithm. ''' +def plot_stations(stations_dict: dict, stations2compare: dict, coords_this: dict, corr_result: dict, trace: Trace, + pick: Pick, window_title: str = None): + """ Plot routine to check proximity algorithm. """ title = trace.id @@ -1812,15 +1858,15 @@ def plot_stations(stations_dict, stations2compare, coords_this, corr_result, tra return fig, axes -def get_data(eventdir, data_dir, headonly=False): - ''' Read and return waveformdata read from eventdir/data_dir. ''' +def get_data(eventdir: str, data_dir: str, headonly: bool = False) -> Stream: + """ Read and return waveformdata read from eventdir/data_dir. """ wfdata_path = os.path.join(eventdir, data_dir) wfdata = read(os.path.join(wfdata_path, '*'), headonly=headonly) return wfdata def get_closest_stations(coords, stations_dict, n): - ''' Calculate distances and return n closest stations in stations_dict for station at coords. ''' + """ Calculate distances and return n closest stations in stations_dict for station at coords. """ distances = {} for station_id, st_coords in stations_dict.items(): dist = gps2dist_azimuth(coords['latitude'], coords['longitude'], st_coords['latitude'], st_coords['longitude'], @@ -1836,7 +1882,7 @@ def get_closest_stations(coords, stations_dict, n): def get_random_stations(coords, stations_dict, n): - ''' Calculate distances and return n randomly selected stations in stations_dict for station at coords. ''' + """ Calculate distances and return n randomly selected stations in stations_dict for station at coords. """ random_keys = random.sample(list(stations_dict.keys()), n) distances = {} for station_id, st_coords in stations_dict.items(): @@ -1851,11 +1897,41 @@ def get_random_stations(coords, stations_dict, n): return random_stations -# Notes: if use_master_trace is set True, traces above a specified ccc threshold will be stacked onto one 'ideal' -# station into a master-trace. This trace will be picked and used again for cross correlation with all other stations -# to find a pick for these stations. +def prepare_corr_params(parse_args, logger): + with open(parse_args.params) as infile: + parameters_dict = yaml.safe_load(infile) -if __name__ == "__main__": + # logging + logger.setLevel(DEBUG_LEVELS.get(parameters_dict['logging'])) + + # number of cores + if parse_args.ncores is not None: + ncores = int(parse_args.ncores) + else: + ncores = None + + # plot options + plot_dict = dict(plot=parse_args.plot, plot_detailed=parse_args.plot_detailed, + save_fig=not parse_args.show_fig) + + corr_params = {phase: CorrelationParameters(ncores=ncores) for phase in parameters_dict['pick_phases']} + for phase, params_phase in corr_params.items(): + params_phase.add_parameters(**plot_dict) + params_phase.add_parameters(**parameters_dict[phase]) + + return corr_params + + +def init_logger(): + logger = logging.getLogger() + handler = logging.StreamHandler(sys.stdout) + fhandler = logging.FileHandler('pick_corr.out') + logger.addHandler(handler) + logger.addHandler(fhandler) + return logger + + +def setup_parser(): parser = argparse.ArgumentParser(description='Correlate picks from PyLoT.') parser.add_argument('dmt_path', help='path containing dmt_database with PyLoT picks') parser.add_argument('pylot_infile', help='path to autoPyLoT inputfile (pylot.in)') @@ -1881,44 +1957,22 @@ if __name__ == "__main__": parser.add_argument('-istart', default=0, help='first event index') parser.add_argument('-istop', default=1e9, help='last event index') - args = parser.parse_args() + return parser.parse_args() - # PARAMETER DEFINITIONS ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - # plot options - plot_dict = dict(plot=args.plot, plot_detailed=args.plot_detailed, save_fig=not (args.show_fig)) +if __name__ == "__main__": + ARGS = setup_parser() + + # initialize logging + LOGGER = init_logger() # alparray configuration: ZNE ~ 123 - channels = {'P': ['*Z', '*1'], 'S': ['*Q', '*T']} # '*N', '*E', '*2', '*3', - debug_levels = {'debug': logging.DEBUG, - 'info': logging.INFO, - 'warn': logging.WARNING, - 'error': logging.ERROR, - 'critical': logging.CRITICAL} + CHANNELS = {'P': ['*Z', '*1'], 'S': ['*Q', '*T']} # '*N', '*E', '*2', '*3', + # initialize parameters from yaml, set logging level + CORR_PARAMS = prepare_corr_params(ARGS, LOGGER) - if args.ncores is not None: - _ncores = int(args.ncores) - else: - _ncores = None - - with open(args.params) as infile: - parameters_dict = yaml.safe_load(infile) - - params = {phase: None for phase in parameters_dict['pick_phases']} - - logger = logging.getLogger() - logger.setLevel(debug_levels.get(parameters_dict['logging'])) - handler = logging.StreamHandler(sys.stdout) - fhandler = logging.FileHandler('pick_corr.out') - logger.addHandler(handler) - logger.addHandler(fhandler) - - for phase in params.keys(): - params_phase = CorrelationParameters(ncores=_ncores) - params_phase.add_parameters(**plot_dict) - params_phase.add_parameters(**parameters_dict[phase]) - params[phase] = params_phase - - correlation_main(args.dmt_path, args.pylot_infile, params=params, istart=int(args.istart), istop=int(args.istop), - channel_config=channels, update=args.update, event_blacklist=args.blacklist) + # MAIN +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + correlation_main(ARGS.dmt_path, ARGS.pylot_infile, params=CORR_PARAMS, istart=int(ARGS.istart), + istop=int(ARGS.istop), + channel_config=CHANNELS, update=ARGS.update, event_blacklist=ARGS.blacklist) From f4f48a930f2eebe4f37152b6a3fa8a31da912619 Mon Sep 17 00:00:00 2001 From: Marcel Office Desktop Date: Fri, 9 Aug 2024 15:03:55 +0200 Subject: [PATCH 10/17] [refactor] moved unittest to existing test folder --- .../test_pick_correlation_correction.py | 76 +++++++++++++++++++ 1 file changed, 76 insertions(+) create mode 100644 tests/test_pick_correlation_correction/test_pick_correlation_correction.py diff --git a/tests/test_pick_correlation_correction/test_pick_correlation_correction.py b/tests/test_pick_correlation_correction/test_pick_correlation_correction.py new file mode 100644 index 00000000..fb9311e5 --- /dev/null +++ b/tests/test_pick_correlation_correction/test_pick_correlation_correction.py @@ -0,0 +1,76 @@ +import pytest +from obspy import read, Trace, UTCDateTime + +from pylot.correlation.pick_correlation_correction import XCorrPickCorrection + + +class TestXCorrPickCorrection(): + def setup(self): + self.make_test_traces() + self.make_test_picks() + self.t_before = 2. + self.t_after = 2. + self.cc_maxlag = 0.5 + + def make_test_traces(self): + # take first trace of test Stream from obspy + tr1 = read()[0] + # filter trace + tr1.filter('bandpass', freqmin=1, freqmax=20) + # make a copy and shift the copy by 0.1 s + tr2 = tr1.copy() + tr2.stats.starttime += 0.1 + + self.trace1 = tr1 + self.trace2 = tr2 + + def make_test_picks(self): + # create an artificial reference pick on reference trace (trace1) and another one on the 0.1 s shifted trace + self.tpick1 = UTCDateTime('2009-08-24T00:20:07.7') + # shift the second pick by 0.2 s, the correction should be around 0.1 s now + self.tpick2 = self.tpick1 + 0.2 + + def test_slice_trace_okay(self): + + self.setup() + xcpc = XCorrPickCorrection(UTCDateTime(), Trace(), UTCDateTime(), Trace(), + t_before=self.t_before, t_after=self.t_after, cc_maxlag=self.cc_maxlag) + + test_trace = self.trace1 + pick_time = self.tpick2 + + sliced_trace = xcpc.slice_trace(test_trace, pick_time) + assert ((sliced_trace.stats.starttime == pick_time - self.t_before - self.cc_maxlag / 2) + and (sliced_trace.stats.endtime == pick_time + self.t_after + self.cc_maxlag / 2)) + + def test_slice_trace_fails(self): + self.setup() + + test_trace = self.trace1 + pick_time = self.tpick1 + + with pytest.raises(ValueError): + xcpc = XCorrPickCorrection(UTCDateTime(), Trace(), UTCDateTime(), Trace(), + t_before=self.t_before + 20, t_after=self.t_after, cc_maxlag=self.cc_maxlag) + xcpc.slice_trace(test_trace, pick_time) + + with pytest.raises(ValueError): + xcpc = XCorrPickCorrection(UTCDateTime(), Trace(), UTCDateTime(), Trace(), + t_before=self.t_before, t_after=self.t_after + 50, cc_maxlag=self.cc_maxlag) + xcpc.slice_trace(test_trace, pick_time) + + def test_cross_correlation(self): + self.setup() + + # create XCorrPickCorrection object + xcpc = XCorrPickCorrection(self.tpick1, self.trace1, self.tpick2, self.trace2, t_before=self.t_before, + t_after=self.t_after, cc_maxlag=self.cc_maxlag) + + # execute correlation + correction, cc_max, uncert, fwfm = xcpc.cross_correlation(False, '', '') + + # define awaited test result + test_result = (-0.09983091718314982, 0.9578431835689154, 0.0015285160561610929, 0.03625786256084631) + + # check results + assert pytest.approx(test_result, rel=1e-6) == (correction, cc_max, uncert, fwfm) \ No newline at end of file From 759e7bb848c323369e54a69e687111c30680320b Mon Sep 17 00:00:00 2001 From: Marcel Office Desktop Date: Fri, 9 Aug 2024 16:24:40 +0200 Subject: [PATCH 11/17] [bugfix] partially reverted signature of an inner function with shadowed variable name [refactor] minor --- .../pick_correlation_correction.py | 33 +++++++++---------- 1 file changed, 16 insertions(+), 17 deletions(-) diff --git a/pylot/correlation/pick_correlation_correction.py b/pylot/correlation/pick_correlation_correction.py index 737e2853..b0d926e0 100644 --- a/pylot/correlation/pick_correlation_correction.py +++ b/pylot/correlation/pick_correlation_correction.py @@ -691,10 +691,8 @@ def correlate_event(eventdir: str, pylot_parameter: PylotParameter, params: dict # continue if there is not enough traces for stacking if nstack < params[phase_type]['min_stack']: - logging.warning('Not enough traces to stack: {} (min_stack = {}). Skip this event'.format(nstack, - params[ - phase_type][ - 'min_stack'])) + logging.warning(f"Not enough traces to stack: {nstack} " + f"(min_stack = {params[phase_type]['min_stack']}). Skip this event") continue # write unfiltered trace @@ -847,9 +845,8 @@ def get_corrected_taupy_picks(picks, taupypicks, all_available=False): mean_diff = taupy_mean - picks_mean logging.info(f'Calculated {len(taupypicks_new)} TauPy theoretical picks.') - logging.info( - 'Calculated median difference from TauPy theoretical picks of {} seconds. (mean: {})'.format(median_diff, - mean_diff)) + logging.info(f'Calculated median difference from TauPy ' + f'theoretical picks of {median_diff} seconds. (mean: {mean_diff})') # return all available taupypicks corrected for median difference to autopicks if all_available: @@ -1267,9 +1264,9 @@ def apply_stacking(trace_master: Trace, stations4stack: dict, wfdata: Stream, pi check_rms: bool, dt_pre: float = 250., dt_post: float = 250., plot: bool = False, fig_dir: str = None) -> tuple: - def check_trace_length_and_cut(trace: Trace): - starttime = correlated_midtime - dt_pre - endtime = correlated_midtime + dt_post + def check_trace_length_and_cut(trace: Trace, pick_time: UTCDateTime = None): + starttime = pick_time - dt_pre + endtime = pick_time + dt_post if trace.stats.starttime > starttime or trace.stats.endtime < endtime: raise ValueError('Trace too short for safe cutting. Would create inconsistent stacking. Abort!') @@ -1282,7 +1279,7 @@ def apply_stacking(trace_master: Trace, stations4stack: dict, wfdata: Stream, pi trace_master = trace_master.copy() trace_master.stats.location = 'ST' - check_trace_length_and_cut(trace_master) + check_trace_length_and_cut(trace_master, pick.time) # empty trace so that it does not stack twice trace_master.data = np.zeros(len(trace_master.data)) @@ -1296,7 +1293,7 @@ def apply_stacking(trace_master: Trace, stations4stack: dict, wfdata: Stream, pi stream_other = wfdata.select(network=nw, station=st, channel=channel) correlated_midtime = pick_other.time - dpick trace_other = stream_other[0].copy() - check_trace_length_and_cut(trace_other) + check_trace_length_and_cut(trace_other, correlated_midtime) if not len(trace_other) == len(trace_master): logging.warning( @@ -1306,23 +1303,25 @@ def apply_stacking(trace_master: Trace, stations4stack: dict, wfdata: Stream, pi traces4stack.append(trace_other) if check_rms: - traces4stack = checkRMS(traces4stack, plot=plot, fig_dir=fig_dir) + traces4stack = check_rms(traces4stack, plot=plot, fig_dir=fig_dir) if plot: fig = plt.figure(figsize=(16, 9)) ax1 = fig.add_subplot(211) ax2 = fig.add_subplot(212) + else: + fig = ax1 = ax2 = None for trace_other in traces4stack: # stack on mastertrace trace_normalized = trace_other.copy().normalize() trace_master.data += trace_normalized.data count += 1 - if plot: + if plot and ax1 and ax2: ax1.plot(trace_master.data, label=count) ax2.plot(trace_normalized.data, color='k', alpha=0.1) - if plot: + if plot and fig: if fig_dir: fig.savefig(os.path.join(fig_dir, 'traces_stacked.svg'), dpi=300.) else: @@ -1335,7 +1334,7 @@ def apply_stacking(trace_master: Trace, stations4stack: dict, wfdata: Stream, pi return trace_master, count -def checkRMS(traces4stack, plot=False, fig_dir=None, max_it=10, ntimes_std=5.): +def check_rms(traces4stack, plot=False, fig_dir=None, max_it=10, ntimes_std=5.): rms_list = [] trace_names = [] @@ -1353,7 +1352,7 @@ def checkRMS(traces4stack, plot=False, fig_dir=None, max_it=10, ntimes_std=5.): while iterate: count += 1 if count >= max_it: - logging.debug('Maximum iterations ({}) of checkRMS function reached.'.format(max_it)) + logging.debug('Maximum iterations ({}) of check_rms function reached.'.format(max_it)) break std = np.std(rms_list) mean = np.mean(rms_list) From 176e93d833dd3e49719ab8e2b6420fd3bb2dcb65 Mon Sep 17 00:00:00 2001 From: Marcel Office Desktop Date: Fri, 9 Aug 2024 16:52:32 +0200 Subject: [PATCH 12/17] [refactor] finished annotations (type hints) --- .../pick_correlation_correction.py | 104 ++++++++++-------- 1 file changed, 56 insertions(+), 48 deletions(-) diff --git a/pylot/correlation/pick_correlation_correction.py b/pylot/correlation/pick_correlation_correction.py index b0d926e0..714d190b 100644 --- a/pylot/correlation/pick_correlation_correction.py +++ b/pylot/correlation/pick_correlation_correction.py @@ -11,7 +11,7 @@ import traceback import glob import json from datetime import datetime -from typing import Any +from typing import Any, Optional import numpy as np import matplotlib.pyplot as plt @@ -19,6 +19,7 @@ import yaml from joblib import Parallel, delayed from obspy import read, Stream, UTCDateTime, Trace +from obspy.core.event import Event from obspy.taup import TauPyModel from obspy.core.event.base import WaveformStreamID, ResourceIdentifier from obspy.core.event.origin import Pick, Origin @@ -28,6 +29,7 @@ from obspy.signal.cross_correlation import correlate, xcorr_max from pylot.core.io.inputs import PylotParameter from pylot.core.io.phases import picks_from_picksdict from pylot.core.pick.autopick import autopickstation +from pylot.core.util.dataprocessing import Metadata from pylot.core.util.utils import check4rotated from pylot.core.util.utils import identifyPhaseID from pylot.core.util.event import Event as PylotEvent @@ -771,7 +773,7 @@ def correlate_event(eventdir: str, pylot_parameter: PylotParameter, params: dict return False -def remove_outliers(picks, corrected_taupy_picks, threshold): +def remove_outliers(picks: list, corrected_taupy_picks: list, threshold: float) -> list: """ delete a pick if difference to corrected taupy pick is larger than threshold""" n_picks = len(picks) @@ -800,7 +802,7 @@ def remove_outliers(picks, corrected_taupy_picks, threshold): return picks -def remove_invalid_picks(picks): +def remove_invalid_picks(picks: list) -> list: """ Remove picks without uncertainty (invalid PyLoT picks)""" count = 0 deleted_picks_ids = [] @@ -815,15 +817,15 @@ def remove_invalid_picks(picks): return picks -def get_picks_median(picks): +def get_picks_median(picks: list) -> UTCDateTime: return UTCDateTime(int(np.median([pick.time.timestamp for pick in picks if pick.time]))) -def get_picks_mean(picks): +def get_picks_mean(picks: list) -> UTCDateTime: return UTCDateTime(np.mean([pick.time.timestamp for pick in picks if pick.time])) -def get_corrected_taupy_picks(picks, taupypicks, all_available=False): +def get_corrected_taupy_picks(picks: list, taupypicks: list, all_available: bool = False) -> tuple: """ get mean/median from picks taupy picks, correct latter for the difference """ def nwst_id_from_wfid(wfid): @@ -859,7 +861,7 @@ def get_corrected_taupy_picks(picks, taupypicks, all_available=False): return taupypicks_new, median_diff -def load_stacked_trace(eventdir, min_corr_stack): +def load_stacked_trace(eventdir: str, min_corr_stack: float) -> Optional[tuple]: # load stacked stream (miniseed) str_stack_fpaths = glob.glob(os.path.join(eventdir, 'correlation', '*_stacked.mseed')) if not len(str_stack_fpaths) == 1: @@ -888,7 +890,8 @@ def load_stacked_trace(eventdir, min_corr_stack): return corr_dict, nwst_id, stacked_trace, nstack -def repick_master_trace(wfdata, trace_master, pylot_parameter, event, event_id, metadata, phase_type, corr_out_dir): +def repick_master_trace(wfdata: Stream, trace_master: Trace, pylot_parameter: PylotParameter, event: Event, + event_id: str, metadata: Metadata, phase_type: str, corr_out_dir: str) -> Optional[Pick]: rename_lqt = phase_type == 'S' # create an 'artificial' stream object which can be used as input for PyLoT stream_master = modify_master_trace4pick(trace_master.copy(), wfdata, rename_lqt=rename_lqt) @@ -925,14 +928,14 @@ def create_correlation_output_dir(eventdir: str, fopts: dict, phase_type: str) - return export_path -def create_correlation_figure_dir(correlation_out_dir): +def create_correlation_figure_dir(correlation_out_dir: str) -> str: export_path = os.path.join(correlation_out_dir, 'figures') if not os.path.isdir(export_path): os.mkdir(export_path) return export_path -def add_fpath_extension(fpath, fopts, phase): +def add_fpath_extension(fpath: str, fopts: dict, phase: str) -> str: if fopts: freqmin, freqmax = fopts['freqmin'], fopts['freqmax'] if freqmin: @@ -944,12 +947,12 @@ def add_fpath_extension(fpath, fopts, phase): return fpath -def write_correlation_output(export_path, correlations_dict, correlations_dict_stacked): +def write_correlation_output(export_path: str, correlations_dict: dict, correlations_dict_stacked: dict) -> None: write_json(correlations_dict, os.path.join(export_path, 'correlations_for_stacking.json')) write_json(correlations_dict_stacked, os.path.join(export_path, 'correlation_results.json')) -def modify_master_trace4pick(trace_master, wfdata, rename_lqt=True): +def modify_master_trace4pick(trace_master: Trace, wfdata: Stream, rename_lqt: bool = True) -> Stream: """ Create an artificial Stream with master trace instead of the trace of its corresponding channel. This is done to find metadata for correct station metadata which were modified when stacking (e.g. loc=ST) @@ -985,7 +988,8 @@ def modify_master_trace4pick(trace_master, wfdata, rename_lqt=True): return stream_master -def export_picks(eventdir, correlations_dict, picks, taupypicks, params, phase_type, pf_extension): +def export_picks(eventdir: str, correlations_dict: dict, picks: list, taupypicks: list, params: dict, + phase_type: str, pf_extension: str) -> None: threshold = params['export_threshold'] min_picks_export = params['min_picks_export'] # make copy so that modified picks are not exported @@ -1057,7 +1061,8 @@ def export_picks(eventdir, correlations_dict, picks, taupypicks, params, phase_t logging.info('Wrote {} correlated picks to file {}'.format(len(event.picks), fpath)) -def write_taupy_picks(event, eventdir, taupypicks, time_shift, extension='corrected_taup_times'): +def write_taupy_picks(event: Event, eventdir: str, taupypicks: list, time_shift: float, + extension: str = 'corrected_taup_times') -> None: # make copies because both objects are being modified event = copy.deepcopy(event) taupypicks = copy.deepcopy(taupypicks) @@ -1079,17 +1084,17 @@ def write_taupy_picks(event, eventdir, taupypicks, time_shift, extension='correc write_event(event, eventdir, fname) -def write_event(event, eventdir, fname): +def write_event(event: Event, eventdir: str, fname: str) -> str: fpath = os.path.join(eventdir, fname) event.write(fpath, format='QUAKEML') return fpath -def get_pickfile_name(event_id, fname_extension): +def get_pickfile_name(event_id: str, fname_extension: str) -> str: return 'PyLoT_{}_{}.xml'.format(event_id, fname_extension) -def get_pickfile_name_correlated(event_id, fopts, phase_type): +def get_pickfile_name_correlated(event_id: str, fopts: dict, phase_type: str) -> str: fname_extension = add_fpath_extension('correlated', fopts, phase_type) return get_pickfile_name(event_id, fname_extension) @@ -1110,8 +1115,9 @@ def get_pickfile_name_correlated(event_id, fopts, phase_type): # return trace_this -def prepare_correlation_input(wfdata, picks, channels, trace_master, pick_master, phase_params, plot=None, fig_dir=None, - ncorr=1, wfdata_highf=None, trace_master_highf=None): +def prepare_correlation_input(wfdata: Stream, picks: list, channels: list, trace_master: Trace, pick_master: Pick, + phase_params: dict, plot: bool = None, fig_dir: str = None, + ncorr: int = 1, wfdata_highf: Stream = None, trace_master_highf: Stream = None) -> list: # prepare input for multiprocessing worker for all 'other' picks to correlate with current master-trace input_list = [] @@ -1152,7 +1158,7 @@ def prepare_correlation_input(wfdata, picks, channels, trace_master, pick_master def stack_mastertrace(wfdata_lowf: Stream, wfdata_highf: Stream, wfdata_raw: Stream, picks: list, params: dict, - channels: list, method: str, fig_dir: str): + channels: list, method: str, fig_dir: str) -> Optional[tuple]: """ Correlate all stations with the first available station given in station_list, a list containing central, permanent, long operating, low noise stations with descending priority. @@ -1187,7 +1193,7 @@ def stack_mastertrace(wfdata_lowf: Stream, wfdata_highf: Stream, wfdata_raw: Str dt_pre, dt_post = params['dt_stacking'] trace_master, nstack = apply_stacking(trace_master, stations4stack, wfdata_raw, picks, method=method, - check_rms=params['check_RMS'], plot=params['plot'], fig_dir=fig_dir, + do_rms_check=params['check_RMS'], plot=params['plot'], fig_dir=fig_dir, dt_pre=dt_pre, dt_post=dt_post) return correlations_dict, nwst_id_master, trace_master, nstack @@ -1261,7 +1267,7 @@ def iterate_correlation(wfdata_lowf: Stream, wfdata_highf: Stream, channels: lis def apply_stacking(trace_master: Trace, stations4stack: dict, wfdata: Stream, picks: list, method: str, - check_rms: bool, dt_pre: float = 250., dt_post: float = 250., plot: bool = False, + do_rms_check: bool, dt_pre: float = 250., dt_post: float = 250., plot: bool = False, fig_dir: str = None) -> tuple: def check_trace_length_and_cut(trace: Trace, pick_time: UTCDateTime = None): @@ -1334,7 +1340,8 @@ def apply_stacking(trace_master: Trace, stations4stack: dict, wfdata: Stream, pi return trace_master, count -def check_rms(traces4stack, plot=False, fig_dir=None, max_it=10, ntimes_std=5.): +def check_rms(traces4stack: list, plot: bool = False, fig_dir: str = None, max_it: int = 10, + ntimes_std: float = 5.) -> list: rms_list = [] trace_names = [] @@ -1396,14 +1403,14 @@ def plot_rms(rms_list: list, trace_names: list, mean: float, std: float, fig_dir plt.close(fig) -def calc_rms(X): +def calc_rms(array: np.ndarray) -> float: """ Returns root mean square of a given array LON """ - return np.sqrt(np.sum(np.power(X, 2)) / len(X)) + return np.sqrt(np.sum(np.power(array, 2)) / len(array)) -def resample_parallel(stream, freq, ncores): +def resample_parallel(stream: Stream, freq: float, ncores: int) -> Stream: input_list = [{'trace': trace, 'freq': freq} for trace in stream.traces] parallel = Parallel(n_jobs=ncores) @@ -1417,7 +1424,8 @@ def resample_parallel(stream, freq, ncores): return stream -def rotate_stream(stream, metadata, origin, stations_dict, channels, inclination, ncores): +def rotate_stream(stream: Stream, metadata: Metadata, origin: Origin, stations_dict: dict, channels: list, + inclination: float, ncores: int) -> Stream: """ Rotate stream to LQT. To do this all traces have to be cut to equal lenths""" input_list = [] cut_stream_to_same_length(stream) @@ -1503,7 +1511,8 @@ def unpack_result(result: list) -> dict: return result_dict -def get_taupy_picks(origin: Origin, stations_dict, pylot_parameter, phase_type, ncores=None): +def get_taupy_picks(origin: Origin, stations_dict: dict, pylot_parameter: PylotParameter, phase_type: str, + ncores: int = None) -> list: input_list = [] taup_phases = pylot_parameter['taup_phases'].split(',') @@ -1531,7 +1540,7 @@ def get_taupy_picks(origin: Origin, stations_dict, pylot_parameter, phase_type, return taupy_picks -def create_artificial_picks(taupy_result): +def create_artificial_picks(taupy_result: dict) -> list: artificial_picks = [] for nwst_id, taupy_dict in taupy_result.items(): nw, st = nwst_id.split('.') @@ -1543,14 +1552,14 @@ def create_artificial_picks(taupy_result): return artificial_picks -def check_taupy_phases(taupy_result): +def check_taupy_phases(taupy_result: dict) -> None: test_phase_name = list(taupy_result.values())[0]['phase_name'] phase_names_equal = [item['phase_name'] == test_phase_name for item in taupy_result.values()] if not all(phase_names_equal): logging.info('Different first arriving phases detected in TauPy phases for this event.') -def taupy_worker(input_dict): +def taupy_worker(input_dict: dict) -> dict: model = input_dict['model'] taupy_input = input_dict['taupy_input'] source_time = input_dict['source_time'] @@ -1570,7 +1579,7 @@ def taupy_worker(input_dict): return output_dict -def resample_worker(input_dict): +def resample_worker(input_dict: dict) -> Trace: trace = input_dict['trace'] freq = input_dict['freq'] if freq == trace.stats.sampling_rate: @@ -1578,7 +1587,7 @@ def resample_worker(input_dict): return trace.resample(freq, no_filter=freq > trace.stats.sampling_rate) -def rotation_worker(input_dict): +def rotation_worker(input_dict: dict) -> Optional[Stream]: stream = input_dict['stream'] tstart = max([tr.stats.starttime for tr in stream]) tend = min([tr.stats.endtime for tr in stream]) @@ -1595,7 +1604,7 @@ def rotation_worker(input_dict): return stream -def correlation_worker(input_dict): +def correlation_worker(input_dict: dict) -> dict: """worker function for multiprocessing""" # unpack input dictionary @@ -1791,7 +1800,7 @@ def plot_stacked_trace_pick(trace: Trace, pick: Pick, pylot_parameter: PylotPara def plot_stations(stations_dict: dict, stations2compare: dict, coords_this: dict, corr_result: dict, trace: Trace, - pick: Pick, window_title: str = None): + pick: Pick, window_title: str = None) -> Optional[tuple]: """ Plot routine to check proximity algorithm. """ title = trace.id @@ -1864,8 +1873,7 @@ def get_data(eventdir: str, data_dir: str, headonly: bool = False) -> Stream: return wfdata -def get_closest_stations(coords, stations_dict, n): - """ Calculate distances and return n closest stations in stations_dict for station at coords. """ +def get_station_distances(stations_dict: dict, coords: dict) -> dict: distances = {} for station_id, st_coords in stations_dict.items(): dist = gps2dist_azimuth(coords['latitude'], coords['longitude'], st_coords['latitude'], st_coords['longitude'], @@ -1875,28 +1883,28 @@ def get_closest_stations(coords, stations_dict, n): continue distances[dist] = station_id + return distances + + +def get_closest_stations(coords: dict, stations_dict: dict, n: int) -> dict: + """ Calculate distances and return the n closest stations in stations_dict for station at coords. """ + distances = get_station_distances(stations_dict, coords) + closest_distances = sorted(list(distances.keys()))[:n + 1] closest_stations = {station: dist for dist, station in distances.items() if dist in closest_distances} return closest_stations -def get_random_stations(coords, stations_dict, n): +def get_random_stations(coords: dict, stations_dict: dict, n: int) -> dict: """ Calculate distances and return n randomly selected stations in stations_dict for station at coords. """ random_keys = random.sample(list(stations_dict.keys()), n) - distances = {} - for station_id, st_coords in stations_dict.items(): - dist = gps2dist_azimuth(coords['latitude'], coords['longitude'], st_coords['latitude'], st_coords['longitude'], - a=6.371e6, f=0)[0] - # exclude same coordinate (self or other instrument at same location) - if dist == 0: - continue - distances[dist] = station_id + distances = get_station_distances(stations_dict, coords) random_stations = {station: dist for dist, station in distances.items() if station in random_keys} return random_stations -def prepare_corr_params(parse_args, logger): +def prepare_corr_params(parse_args: argparse, logger: logging.Logger) -> dict: with open(parse_args.params) as infile: parameters_dict = yaml.safe_load(infile) @@ -1921,7 +1929,7 @@ def prepare_corr_params(parse_args, logger): return corr_params -def init_logger(): +def init_logger() -> logging.Logger: logger = logging.getLogger() handler = logging.StreamHandler(sys.stdout) fhandler = logging.FileHandler('pick_corr.out') From b59232d77bb73dc4774c51805cfece4f41283423 Mon Sep 17 00:00:00 2001 From: Marcel Office Desktop Date: Fri, 9 Aug 2024 16:52:57 +0200 Subject: [PATCH 13/17] [bugfix] function name accidentally overwritten on parameter renaming --- pylot/correlation/pick_correlation_correction.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pylot/correlation/pick_correlation_correction.py b/pylot/correlation/pick_correlation_correction.py index 714d190b..235b51eb 100644 --- a/pylot/correlation/pick_correlation_correction.py +++ b/pylot/correlation/pick_correlation_correction.py @@ -1308,7 +1308,7 @@ def apply_stacking(trace_master: Trace, stations4stack: dict, wfdata: Stream, pi traces4stack.append(trace_other) - if check_rms: + if do_rms_check: traces4stack = check_rms(traces4stack, plot=plot, fig_dir=fig_dir) if plot: From db11e125c04fca82515d721970f3214c5b50f4a7 Mon Sep 17 00:00:00 2001 From: Marcel Office Desktop Date: Fri, 9 Aug 2024 16:53:21 +0200 Subject: [PATCH 14/17] [todos] add todos --- pylot/correlation/pick_correlation_correction.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/pylot/correlation/pick_correlation_correction.py b/pylot/correlation/pick_correlation_correction.py index 235b51eb..61358b3b 100644 --- a/pylot/correlation/pick_correlation_correction.py +++ b/pylot/correlation/pick_correlation_correction.py @@ -1423,6 +1423,7 @@ def resample_parallel(stream: Stream, freq: float, ncores: int) -> Stream: stream.traces = output_list return stream +# TODO: Check why metadata, channels and ncores are not used def rotate_stream(stream: Stream, metadata: Metadata, origin: Origin, stations_dict: dict, channels: list, inclination: float, ncores: int) -> Stream: @@ -1672,6 +1673,7 @@ def get_stations_min_corr(corr_results: dict, min_corr: float) -> dict: return corr_results +# TODO check if wfdata is needed def plot_mastertrace_corr(nwst_id: str, corr_results: dict, wfdata: Stream, stations_dict: dict, picks: list, trace_master: Trace, method: str, min_corr: float, title: str, fig_dir: str = None) -> None: From 29107ee40c71743935e4cf4d7f92032ced3777bf Mon Sep 17 00:00:00 2001 From: Marcel Date: Mon, 26 Aug 2024 17:18:41 +0200 Subject: [PATCH 15/17] [update] WIP: adding tests for autopylot (global) --- pylot/tests/__init__.py | 0 .../tests/test_pick_correlation_correction.py | 76 ------------- ...lot_alparray_mantle_corr_stack_0.03-0.5.in | 101 ++++++++++++++++++ tests/test_autopicker/test_autopylot.py | 27 +++++ 4 files changed, 128 insertions(+), 76 deletions(-) delete mode 100644 pylot/tests/__init__.py delete mode 100644 pylot/tests/test_pick_correlation_correction.py create mode 100644 tests/test_autopicker/pylot_alparray_mantle_corr_stack_0.03-0.5.in create mode 100644 tests/test_autopicker/test_autopylot.py diff --git a/pylot/tests/__init__.py b/pylot/tests/__init__.py deleted file mode 100644 index e69de29b..00000000 diff --git a/pylot/tests/test_pick_correlation_correction.py b/pylot/tests/test_pick_correlation_correction.py deleted file mode 100644 index fb9311e5..00000000 --- a/pylot/tests/test_pick_correlation_correction.py +++ /dev/null @@ -1,76 +0,0 @@ -import pytest -from obspy import read, Trace, UTCDateTime - -from pylot.correlation.pick_correlation_correction import XCorrPickCorrection - - -class TestXCorrPickCorrection(): - def setup(self): - self.make_test_traces() - self.make_test_picks() - self.t_before = 2. - self.t_after = 2. - self.cc_maxlag = 0.5 - - def make_test_traces(self): - # take first trace of test Stream from obspy - tr1 = read()[0] - # filter trace - tr1.filter('bandpass', freqmin=1, freqmax=20) - # make a copy and shift the copy by 0.1 s - tr2 = tr1.copy() - tr2.stats.starttime += 0.1 - - self.trace1 = tr1 - self.trace2 = tr2 - - def make_test_picks(self): - # create an artificial reference pick on reference trace (trace1) and another one on the 0.1 s shifted trace - self.tpick1 = UTCDateTime('2009-08-24T00:20:07.7') - # shift the second pick by 0.2 s, the correction should be around 0.1 s now - self.tpick2 = self.tpick1 + 0.2 - - def test_slice_trace_okay(self): - - self.setup() - xcpc = XCorrPickCorrection(UTCDateTime(), Trace(), UTCDateTime(), Trace(), - t_before=self.t_before, t_after=self.t_after, cc_maxlag=self.cc_maxlag) - - test_trace = self.trace1 - pick_time = self.tpick2 - - sliced_trace = xcpc.slice_trace(test_trace, pick_time) - assert ((sliced_trace.stats.starttime == pick_time - self.t_before - self.cc_maxlag / 2) - and (sliced_trace.stats.endtime == pick_time + self.t_after + self.cc_maxlag / 2)) - - def test_slice_trace_fails(self): - self.setup() - - test_trace = self.trace1 - pick_time = self.tpick1 - - with pytest.raises(ValueError): - xcpc = XCorrPickCorrection(UTCDateTime(), Trace(), UTCDateTime(), Trace(), - t_before=self.t_before + 20, t_after=self.t_after, cc_maxlag=self.cc_maxlag) - xcpc.slice_trace(test_trace, pick_time) - - with pytest.raises(ValueError): - xcpc = XCorrPickCorrection(UTCDateTime(), Trace(), UTCDateTime(), Trace(), - t_before=self.t_before, t_after=self.t_after + 50, cc_maxlag=self.cc_maxlag) - xcpc.slice_trace(test_trace, pick_time) - - def test_cross_correlation(self): - self.setup() - - # create XCorrPickCorrection object - xcpc = XCorrPickCorrection(self.tpick1, self.trace1, self.tpick2, self.trace2, t_before=self.t_before, - t_after=self.t_after, cc_maxlag=self.cc_maxlag) - - # execute correlation - correction, cc_max, uncert, fwfm = xcpc.cross_correlation(False, '', '') - - # define awaited test result - test_result = (-0.09983091718314982, 0.9578431835689154, 0.0015285160561610929, 0.03625786256084631) - - # check results - assert pytest.approx(test_result, rel=1e-6) == (correction, cc_max, uncert, fwfm) \ No newline at end of file diff --git a/tests/test_autopicker/pylot_alparray_mantle_corr_stack_0.03-0.5.in b/tests/test_autopicker/pylot_alparray_mantle_corr_stack_0.03-0.5.in new file mode 100644 index 00000000..d3dcd918 --- /dev/null +++ b/tests/test_autopicker/pylot_alparray_mantle_corr_stack_0.03-0.5.in @@ -0,0 +1,101 @@ +%This is a parameter input file for PyLoT/autoPyLoT. +%All main and special settings regarding data handling +%and picking are to be set here! +%Parameters are optimized for %extent data sets! +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +#main settings# + #rootpath# %project path + #datapath# %data path + #database# %name of data base +20171010_063224.a #eventID# %event ID for single event processing (* for all events found in database) + #invdir# %full path to inventory or dataless-seed file +PILOT #datastructure# %choose data structure +True #apverbose# %choose 'True' or 'False' for terminal output +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +#NLLoc settings# +None #nllocbin# %path to NLLoc executable +None #nllocroot# %root of NLLoc-processing directory +None #phasefile# %name of autoPyLoT-output phase file for NLLoc +None #ctrfile# %name of autoPyLoT-output control file for NLLoc +ttime #ttpatter# %pattern of NLLoc ttimes from grid +AUTOLOC_nlloc #outpatter# %pattern of NLLoc-output file +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +#parameters for seismic moment estimation# +3530.0 #vp# %average P-wave velocity +2500.0 #rho# %average rock density [kg/m^3] +300.0 0.8 #Qp# %quality factor for P waves (Qp*f^a); list(Qp, a) +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +#settings local magnitude# +1.0 1.0 1.0 #WAscaling# %Scaling relation (log(Ao)+Alog(r)+Br+C) of Wood-Anderson amplitude Ao [nm] If zeros are set, original Richter magnitude is calculated! +1.0 1.0 #magscaling# %Scaling relation for derived local magnitude [a*Ml+b]. If zeros are set, no scaling of network magnitude is applied! +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +#filter settings# +0.03 0.03 #minfreq# %Lower filter frequency [P, S] +0.5 0.5 #maxfreq# %Upper filter frequency [P, S] +4 4 #filter_order# %filter order [P, S] +bandpass bandpass #filter_type# %filter type (bandpass, bandstop, lowpass, highpass) [P, S] +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +#common settings picker# +global #extent# %extent of array ("local", "regional" or "global") +-100.0 #pstart# %start time [s] for calculating CF for P-picking (if TauPy: seconds relative to estimated onset) +50.0 #pstop# %end time [s] for calculating CF for P-picking (if TauPy: seconds relative to estimated onset) +-50.0 #sstart# %start time [s] relative to P-onset for calculating CF for S-picking +50.0 #sstop# %end time [s] after P-onset for calculating CF for S-picking +True #use_taup# %use estimated traveltimes from TauPy for calculating windows for CF +ak135 #taup_model# %Define TauPy model for traveltime estimation. Possible values: 1066a, 1066b, ak135, ak135f, herrin, iasp91, jb, prem, pwdk, sp6 +P,Pdiff,S,SKS #taup_phases# %Specify possible phases for TauPy (comma separated). See Obspy TauPy documentation for possible values. +0.03 0.5 #bpz1# %lower/upper corner freq. of first band pass filter Z-comp. [Hz] +0.01 0.5 #bpz2# %lower/upper corner freq. of second band pass filter Z-comp. [Hz] +0.03 0.5 #bph1# %lower/upper corner freq. of first band pass filter H-comp. [Hz] +0.01 0.5 #bph2# %lower/upper corner freq. of second band pass filter z-comp. [Hz] +#special settings for calculating CF# +%!!Edit the following only if you know what you are doing!!% +#Z-component# +HOS #algoP# %choose algorithm for P-onset determination (HOS, ARZ, or AR3) +300.0 #tlta# %for HOS-/AR-AIC-picker, length of LTA window [s] +4 #hosorder# %for HOS-picker, order of Higher Order Statistics +2 #Parorder# %for AR-picker, order of AR process of Z-component +16.0 #tdet1z# %for AR-picker, length of AR determination window [s] for Z-component, 1st pick +10.0 #tpred1z# %for AR-picker, length of AR prediction window [s] for Z-component, 1st pick +12.0 #tdet2z# %for AR-picker, length of AR determination window [s] for Z-component, 2nd pick +6.0 #tpred2z# %for AR-picker, length of AR prediction window [s] for Z-component, 2nd pick +0.001 #addnoise# %add noise to seismogram for stable AR prediction +60.0 5.0 20.0 12.0 #tsnrz# %for HOS/AR, window lengths for SNR-and slope estimation [tnoise, tsafetey, tsignal, tslope] [s] +50.0 #pickwinP# %for initial AIC pick, length of P-pick window [s] +30.0 #Precalcwin# %for HOS/AR, window length [s] for recalculation of CF (relative to 1st pick) +2.0 #aictsmooth# %for HOS/AR, take average of samples for smoothing of AIC-function [s] +2.0 #tsmoothP# %for HOS/AR, take average of samples in this time window for smoothing CF [s] +0.006 #ausP# %for HOS/AR, artificial uplift of samples (aus) of CF (P) +2.0 #nfacP# %for HOS/AR, noise factor for noise level determination (P) +#H-components# +ARH #algoS# %choose algorithm for S-onset determination (ARH or AR3) +12.0 #tdet1h# %for HOS/AR, length of AR-determination window [s], H-components, 1st pick +6.0 #tpred1h# %for HOS/AR, length of AR-prediction window [s], H-components, 1st pick +8.0 #tdet2h# %for HOS/AR, length of AR-determinaton window [s], H-components, 2nd pick +4.0 #tpred2h# %for HOS/AR, length of AR-prediction window [s], H-components, 2nd pick +4 #Sarorder# %for AR-picker, order of AR process of H-components +100.0 #Srecalcwin# %for AR-picker, window length [s] for recalculation of CF (2nd pick) (H) +195.0 #pickwinS# %for initial AIC pick, length of S-pick window [s] +60.0 10.0 30.0 12.0 #tsnrh# %for ARH/AR3, window lengths for SNR-and slope estimation [tnoise, tsafetey, tsignal, tslope] [s] +22.0 #aictsmoothS# %for AIC-picker, take average of samples in this time window for smoothing of AIC-function [s] +20.0 #tsmoothS# %for AR-picker, take average of samples for smoothing CF [s] (S) +0.001 #ausS# %for HOS/AR, artificial uplift of samples (aus) of CF (S) +2.0 #nfacS# %for AR-picker, noise factor for noise level determination (S) +#first-motion picker# +1 #minfmweight# %minimum required P weight for first-motion determination +3.0 #minFMSNR# %miniumum required SNR for first-motion determination +10.0 #fmpickwin# %pick window [s] around P onset for calculating zero crossings +#quality assessment# +0.1 0.2 0.4 0.8 #timeerrorsP# %discrete time errors [s] corresponding to picking weights [0 1 2 3] for P +4.0 8.0 16.0 32.0 #timeerrorsS# %discrete time errors [s] corresponding to picking weights [0 1 2 3] for S +0.005 #minAICPslope# %below this slope [counts/s] the initial P pick is rejected +1.1 #minAICPSNR# %below this SNR the initial P pick is rejected +0.002 #minAICSslope# %below this slope [counts/s] the initial S pick is rejected +1.3 #minAICSSNR# %below this SNR the initial S pick is rejected +20.0 #minsiglength# %length of signal part for which amplitudes must exceed noiselevel [s] +1.0 #noisefactor# %noiselevel*noisefactor=threshold +10.0 #minpercent# %required percentage of amplitudes exceeding threshold +0.1 #zfac# %P-amplitude must exceed at least zfac times RMS-S amplitude +100.0 #mdttolerance# %maximum allowed deviation of P picks from median [s] +50.0 #wdttolerance# %maximum allowed deviation from Wadati-diagram +25.0 #jackfactor# %pick is removed if the variance of the subgroup with the pick removed is larger than the mean variance of all subgroups times safety factor diff --git a/tests/test_autopicker/test_autopylot.py b/tests/test_autopicker/test_autopylot.py new file mode 100644 index 00000000..a5dd0af7 --- /dev/null +++ b/tests/test_autopicker/test_autopylot.py @@ -0,0 +1,27 @@ +import os +import pytest + +from autoPyLoT import autoPyLoT + + +class TestAutopickerGlobal(): + def init(self): + self.params_infile = 'pylot_alparray_mantle_corr_stack_0.03-0.5.in' + self.test_event_dir = 'dmt_database_test' + + if not os.path.isfile(self.params_infile): + print(f'Test input file {os.path.abspath(self.params_infile)} not found.') + return False + + if not os.path.exists(self.test_event_dir): + print( + f'Test event directory not found at location "{os.path.abspath(self.test_event_dir)}". ' + f'Make sure to load it from the website first.' + ) + return False + + return True + + def test_autopicker(self): + assert self.init(), 'Initialization failed due to missing input files.' + #autoPyLoT(inputfile=self.params_infile, eventid='20171010_063224.a') From 466f19eb2e2faaa1532711f43f8fd1bbd35478a2 Mon Sep 17 00:00:00 2001 From: Marcel Office Desktop Date: Wed, 28 Aug 2024 18:01:03 +0200 Subject: [PATCH 16/17] [bugfix] fixed import for tukey in newer scipy versions --- pylot/core/pick/charfuns.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/pylot/core/pick/charfuns.py b/pylot/core/pick/charfuns.py index d5e0bee8..7cbfcc36 100644 --- a/pylot/core/pick/charfuns.py +++ b/pylot/core/pick/charfuns.py @@ -17,7 +17,11 @@ autoregressive prediction: application ot local and regional distances, Geophys. :author: MAGS2 EP3 working group """ import numpy as np -from scipy import signal +try: + from scipy.signal import tukey +except ImportError: + from scipy.signal.windows import tukey + from obspy.core import Stream from pylot.core.pick.utils import PickingFailedException From 2cea10088deeecacc93f9d7df61582fc3cf975ce Mon Sep 17 00:00:00 2001 From: Marcel Office Desktop Date: Thu, 29 Aug 2024 16:35:04 +0200 Subject: [PATCH 17/17] [update] added test for AutoPyLoT, added test files for correlation picker as well --- PyLoT.py | 29 +- autoPyLoT.py | 15 +- .../PyLoT_20171010_063224.a_autopylot.xml | 18672 ++++++++++++++++ ...24.a_corrected_taup_times_0.01-0.2_SKS.xml | 6688 ++++++ ...3224.a_corrected_taup_times_0.03-0.5_P.xml | 6688 ++++++ ...71010_063224.a_correlated_0.01-0.2_SKS.xml | 6419 ++++++ ...0171010_063224.a_correlated_0.03-0.5_P.xml | 8595 +++++++ ...PyLoT_20171010_063224.a_saved_from_GUI.xml | 18672 ++++++++++++++++ ...lot_alparray_mantle_corr_stack_0.03-0.5.in | 99 + tests/test_autopicker/test_autopylot.py | 67 + 10 files changed, 65924 insertions(+), 20 deletions(-) create mode 100644 tests/test_autopicker/PyLoT_20171010_063224.a_autopylot.xml create mode 100644 tests/test_autopicker/PyLoT_20171010_063224.a_corrected_taup_times_0.01-0.2_SKS.xml create mode 100644 tests/test_autopicker/PyLoT_20171010_063224.a_corrected_taup_times_0.03-0.5_P.xml create mode 100644 tests/test_autopicker/PyLoT_20171010_063224.a_correlated_0.01-0.2_SKS.xml create mode 100644 tests/test_autopicker/PyLoT_20171010_063224.a_correlated_0.03-0.5_P.xml create mode 100644 tests/test_autopicker/PyLoT_20171010_063224.a_saved_from_GUI.xml create mode 100644 tests/test_autopicker/pylot_alparray_mantle_corr_stack_0.03-0.5.in create mode 100644 tests/test_autopicker/test_autopylot.py diff --git a/PyLoT.py b/PyLoT.py index c5c10899..9f5ed406 100755 --- a/PyLoT.py +++ b/PyLoT.py @@ -1031,22 +1031,23 @@ class MainWindow(QMainWindow): if not fname: return - qmb = QMessageBox(self, icon=QMessageBox.Question, - text='Do you want to overwrite this data?',) - overwrite_button = qmb.addButton('Overwrite', QMessageBox.YesRole) - merge_button = qmb.addButton('Merge', QMessageBox.NoRole) - - qmb.exec_() - - if qmb.clickedButton() == overwrite_button: - merge_strategy = 'Overwrite' - elif qmb.clickedButton() == merge_button: - merge_strategy = 'Merge' - else: - return - if not event: event = self.get_current_event() + + if event.picks: + qmb = QMessageBox(self, icon=QMessageBox.Question, + text='Do you want to overwrite the data?',) + overwrite_button = qmb.addButton('Overwrite', QMessageBox.YesRole) + merge_button = qmb.addButton('Merge', QMessageBox.NoRole) + qmb.exec_() + + if qmb.clickedButton() == overwrite_button: + merge_strategy = 'Overwrite' + elif qmb.clickedButton() == merge_button: + merge_strategy = 'Merge' + else: + return + data = Data(self, event) try: data_new = Data(self, evtdata=str(fname)) diff --git a/autoPyLoT.py b/autoPyLoT.py index 4746c963..b501217f 100755 --- a/autoPyLoT.py +++ b/autoPyLoT.py @@ -184,15 +184,15 @@ def autoPyLoT(input_dict=None, parameter=None, inputfile=None, fnames=None, even if not input_dict: # started in production mode datapath = datastructure.expandDataPath() - if fnames == 'None' and parameter['eventID'] == '*': + if fnames in [None, 'None'] and parameter['eventID'] == '*': # multiple event processing # read each event in database events = [event for event in glob.glob(os.path.join(datapath, '*')) if (os.path.isdir(event) and not event.endswith('EVENTS-INFO'))] - elif fnames == 'None' and parameter['eventID'] != '*' and not type(parameter['eventID']) == list: + elif fnames in [None, 'None'] and parameter['eventID'] != '*' and not type(parameter['eventID']) == list: # single event processing events = glob.glob(os.path.join(datapath, parameter['eventID'])) - elif fnames == 'None' and type(parameter['eventID']) == list: + elif fnames in [None, 'None'] and type(parameter['eventID']) == list: # multiple event processing events = [] for eventID in parameter['eventID']: @@ -234,12 +234,15 @@ def autoPyLoT(input_dict=None, parameter=None, inputfile=None, fnames=None, even data.get_evt_data().path = eventpath print('Reading event data from filename {}...'.format(filename)) except Exception as e: - print('Could not read event from file {}: {}'.format(filename, e)) + if type(e) == FileNotFoundError: + print('Creating new event file.') + else: + print('Could not read event from file {}: {}'.format(filename, e)) data = Data() pylot_event = Event(eventpath) # event should be path to event directory data.setEvtData(pylot_event) - if fnames == 'None': - data.setWFData(glob.glob(os.path.join(datapath, event_datapath, '*'))) + if fnames in [None, 'None']: + data.setWFData(glob.glob(os.path.join(event_datapath, '*'))) # the following is necessary because within # multiple event processing no event ID is provided # in autopylot.in diff --git a/tests/test_autopicker/PyLoT_20171010_063224.a_autopylot.xml b/tests/test_autopicker/PyLoT_20171010_063224.a_autopylot.xml new file mode 100644 index 00000000..244b29a4 --- /dev/null +++ b/tests/test_autopicker/PyLoT_20171010_063224.a_autopylot.xml @@ -0,0 +1,18672 @@ + + + + + + + + -18.58 + + + -69.86 + + + 106.4 + + + + + 6.27 + + Mwc + smi:local/ndk/C201710100632A/origin#cmtorigin + + + + + smi:local/bd98e0d3-7e37-4a5e-9b81-9a6f0800d7f6 + smi:local/auto + P + undecidable + + + + + smi:local/e6952e1c-3078-4bd7-b340-574e58b25d9e + smi:local/auto + S + undecidable + + + + + smi:local/b5e94fdc-6bc7-4c40-8354-763c0a3cdf87 + smi:local/auto + P + undecidable + + + + + smi:local/1c679d6b-c46c-4abe-8ee2-eb554f06af39 + smi:local/auto + S + undecidable + + + + + smi:local/bab4a9c1-591b-4f69-afde-1f18e336bf8b + smi:local/auto + P + undecidable + + + + + smi:local/96c789e1-a579-40be-9325-f080681100c9 + smi:local/auto + S + undecidable + + + + + smi:local/b79a7cc0-43e7-42c5-a4ea-f0e51c791116 + smi:local/auto + P + undecidable + + + + + smi:local/06ac59da-ee57-420f-8eb1-bb433db4c4b8 + smi:local/auto + S + undecidable + + + + + smi:local/690ec204-3e69-4fea-9665-65aa774e3266 + smi:local/auto + P + undecidable + + + + + smi:local/cc9bc39a-7c05-41f1-bf50-33fcec3c151b + smi:local/auto + S + undecidable + + + + + smi:local/78e197f9-62c2-489d-9c91-f35324356a32 + smi:local/auto + P + undecidable + + + + + smi:local/abda48f5-b3a1-40b2-9758-6f681e59d5d7 + smi:local/auto + S + undecidable + + + + + smi:local/3b3ffd4a-7cbf-4b36-a274-cefda1c3e846 + smi:local/auto + P + undecidable + + + + + smi:local/e14b2768-9081-442c-92e9-cd02359e1851 + smi:local/auto + S + undecidable + + + + + smi:local/44d7d45d-ad3f-4836-a172-4a25603f8897 + smi:local/auto + P + undecidable + + + + + smi:local/ad044314-79eb-47dc-80fb-76b1c5d7fe13 + smi:local/auto + S + undecidable + + + + + smi:local/435a8d64-7bf6-41a1-8209-1b1dce1c5729 + smi:local/auto + P + undecidable + + + + + smi:local/817fce7b-36b3-4176-b81b-4d8a22140e4c + smi:local/auto + S + undecidable + + + + + smi:local/fc2f5bb6-c25f-4475-b4ac-ad312a38fb68 + smi:local/auto + P + undecidable + + + + + smi:local/78d73070-5dac-44ff-ae30-a7dc14334cd2 + smi:local/auto + S + undecidable + + + + + smi:local/deabdfd6-4b64-4fea-a308-27c7f46e020f + smi:local/auto + P + undecidable + + + + + smi:local/f7f20478-5662-47f6-ab54-c985983840d0 + smi:local/auto + S + undecidable + + + + + smi:local/468b6a0a-db94-470b-8253-598f9d7e2b81 + smi:local/auto + P + undecidable + + + + + smi:local/971815d1-a358-445f-b33f-51c20e28ef16 + smi:local/auto + S + undecidable + + + + + smi:local/3fc395e4-2ee6-440c-8a61-c4557d8ec2b4 + smi:local/auto + P + undecidable + + + + + smi:local/2f56cb3a-d5ca-42ea-8511-734640a83333 + smi:local/auto + S + undecidable + + + + + smi:local/0ac1e00c-8c25-4f4a-a49b-6ac3db7d5d06 + smi:local/auto + P + undecidable + + + + + smi:local/17d20001-2f06-4d9d-a772-e9d822e1d3c2 + smi:local/auto + S + undecidable + + + + + smi:local/284f768a-4143-44a2-9023-fdde108ecb5a + smi:local/auto + P + undecidable + + + + + smi:local/951f4497-239f-4d10-89ac-e05d3b445c24 + smi:local/auto + S + undecidable + + + + + smi:local/4acfe0b1-9948-4d1a-bfd9-88e6771a6682 + smi:local/auto + P + undecidable + + + + + smi:local/97b6cf8e-f5bb-4512-a68f-b74e967723a3 + smi:local/auto + S + undecidable + + + + + smi:local/bc8d31de-5bac-4d3c-83a9-916c8d0d4ccc + smi:local/auto + P + undecidable + + + + + smi:local/983632d1-8674-44c8-9b72-15f124cca60d + smi:local/auto + S + undecidable + + + + + smi:local/1e016003-85a0-41c0-a915-2385ecd4b527 + smi:local/auto + P + undecidable + + + + + smi:local/bf8386a8-1946-4346-801d-63d15586f3fc + smi:local/auto + S + undecidable + + + + + smi:local/36c63861-d4aa-40c1-ba29-b6984206e49e + smi:local/auto + P + undecidable + + + + + smi:local/e67c3f2e-7f70-4248-b013-387c92d56315 + smi:local/auto + S + undecidable + + + + + smi:local/9062e4e1-0098-43f0-8920-bec8a02702cf + smi:local/auto + P + undecidable + + + + + smi:local/10ec8a28-77d7-4eaa-bc34-b354f8282813 + smi:local/auto + S + undecidable + + + + + smi:local/5c3388f2-21ed-4f20-be59-29d43462019c + smi:local/auto + P + undecidable + + + + + smi:local/2fe2a7f7-4870-467e-8405-6d2a6a96e39b + smi:local/auto + S + undecidable + + + + + smi:local/4a51ef16-518a-4bbe-bb2c-ef0d2ecd9185 + smi:local/auto + P + undecidable + + + + + smi:local/18e059c2-5fa9-40c8-9a20-2a0d960d46a7 + smi:local/auto + S + undecidable + + + + + smi:local/bded4356-5707-4cef-a111-68c02cb17721 + smi:local/auto + P + undecidable + + + + + smi:local/5c686a6f-c168-45d7-9155-b186fb0d0640 + smi:local/auto + S + undecidable + + + + + smi:local/5e2b5f25-485a-4737-ada3-da50140d68b9 + smi:local/auto + P + undecidable + + + + + smi:local/2d324883-2abf-4552-8a8c-5e9f87cb8e49 + smi:local/auto + S + undecidable + + + + + smi:local/dc163271-758d-45f9-a970-a3a7fa125da5 + smi:local/auto + P + undecidable + + + + + smi:local/ab805e46-efe6-4fc2-bcf0-2b67970d78d1 + smi:local/auto + S + undecidable + + + + + smi:local/2f54d291-69bb-4732-9089-bb8baeb1d2b4 + smi:local/auto + P + undecidable + + + + + smi:local/2b01efe3-f8ae-47fe-826a-49a4cb51d56b + smi:local/auto + S + undecidable + + + + + smi:local/400242c5-9a73-45dc-8522-db5679f9e6fb + smi:local/auto + P + undecidable + + + + + smi:local/93be4ee1-099b-4041-b259-b6a7430e5d4d + smi:local/auto + S + undecidable + + + + + smi:local/2e89450e-f24e-4797-aa52-97dac7e2c12e + smi:local/auto + P + undecidable + + + + + smi:local/cccbbd17-1724-4382-a6ea-99332c8603fb + smi:local/auto + S + undecidable + + + + + smi:local/c17eb24f-36c0-43a6-bde1-d701e130cb76 + smi:local/auto + P + undecidable + + + + + smi:local/5516c19b-0f91-4a54-b353-90744c18c323 + smi:local/auto + S + undecidable + + + + + smi:local/0b6f55ba-4104-4342-98d9-71fa88c83cb1 + smi:local/auto + P + undecidable + + + + + smi:local/e7a3e0d1-7c75-4076-b458-08a9bd8e99ba + smi:local/auto + S + undecidable + + + + + smi:local/e0419ac4-d854-42ab-9d08-3ba3ac1ff3cb + smi:local/auto + P + undecidable + + + + + smi:local/4005ca48-a16c-41c9-82bd-7aac5f712fd0 + smi:local/auto + S + undecidable + + + + + smi:local/7d61b94e-54a3-4571-879c-0e03a28e9372 + smi:local/auto + P + undecidable + + + + + smi:local/994f63c9-bfce-419c-843e-832ece4987d0 + smi:local/auto + S + undecidable + + + + + smi:local/b8cf80cb-58ad-424a-ac14-42096e4acec4 + smi:local/auto + P + undecidable + + + + + smi:local/8597c288-0df2-4f3f-80ba-cb8220c3d528 + smi:local/auto + S + undecidable + + + + + smi:local/7c29060d-482a-443c-862d-d53d92610865 + smi:local/auto + P + undecidable + + + + + smi:local/38d93986-a56a-4ced-90bd-7267326aa537 + smi:local/auto + S + undecidable + + + + + smi:local/74f25eb7-4350-416d-b26d-314fa5eef5d4 + smi:local/auto + P + undecidable + + + + + smi:local/912fcd1c-b7dc-4314-b0ec-5b1da92afc64 + smi:local/auto + S + undecidable + + + + + smi:local/f04d6700-f077-400b-aa13-aa3e005b4978 + smi:local/auto + P + undecidable + + + + + smi:local/46f8807a-fd84-4dfe-b20f-c8bc31017959 + smi:local/auto + S + undecidable + + + + + smi:local/41739010-fdbc-4857-8e7d-6fa46ad816ad + smi:local/auto + P + undecidable + + + + + smi:local/a0305734-2f7b-472c-b7f3-0740927fdce7 + smi:local/auto + S + undecidable + + + + + smi:local/c3550349-cb04-45fc-9de8-2effe0b1b387 + smi:local/auto + P + undecidable + + + + + smi:local/a5e16389-95ca-4927-96bb-d0ef96b344d4 + smi:local/auto + S + undecidable + + + + + smi:local/4874d136-5453-45fc-aebf-0f2c92125e9c + smi:local/auto + P + undecidable + + + + + smi:local/0d2510be-8d16-468a-8cbf-6abc2f996b81 + smi:local/auto + S + undecidable + + + + + smi:local/adb0ffd0-1e0e-4853-8244-4fcc00ac1b6a + smi:local/auto + P + undecidable + + + + + smi:local/a75bf220-7cd3-4485-bad0-c593882299f0 + smi:local/auto + S + undecidable + + + + + smi:local/94acc53c-5ae5-4a0b-bf6c-b41af6f6f709 + smi:local/auto + P + undecidable + + + + + smi:local/9be0a21f-7807-4d26-beaa-8bb93419d441 + smi:local/auto + S + undecidable + + + + + smi:local/b8d3f7b0-f90f-4b75-8d29-9809fa4d1c80 + smi:local/auto + P + undecidable + + + + + smi:local/f88b6b43-54a1-4bb5-a3df-ed66e2edca2d + smi:local/auto + S + undecidable + + + + + smi:local/16b5460e-5c69-477e-bd4e-c0a7b29c4c2e + smi:local/auto + P + undecidable + + + + + smi:local/02fdadb9-2b2e-43c7-94cd-5a09e966ca3f + smi:local/auto + S + undecidable + + + + + smi:local/6f4ab8a1-f806-4475-88ff-109c73a4bacd + smi:local/auto + P + undecidable + + + + + smi:local/92343eff-4659-4a2a-8375-0af35f5b0884 + smi:local/auto + S + undecidable + + + + + smi:local/8ac7aeb7-b60c-43b9-a4ef-e3965e4d6e22 + smi:local/auto + P + undecidable + + + + + smi:local/537d7838-caa5-4c59-a1b5-092f2415a846 + smi:local/auto + S + undecidable + + + + + smi:local/91fa45ba-904e-4886-9035-8495c7613cc7 + smi:local/auto + P + undecidable + + + + + smi:local/accbd4b7-f5fd-43a7-980e-f0bd4f40a28c + smi:local/auto + S + undecidable + + + + + smi:local/3bc5bc24-4a7f-4b84-8172-ad8fe4c37552 + smi:local/auto + P + undecidable + + + + + smi:local/806352cd-0fb6-41be-b331-3f123f1ecd25 + smi:local/auto + S + undecidable + + + + + smi:local/2b1e7aa1-75fa-4cb3-8e12-882ebf742dd7 + smi:local/auto + P + undecidable + + + + + smi:local/caa00820-5ccb-4705-bf3f-7f9b1ffaee94 + smi:local/auto + S + undecidable + + + + + smi:local/80cb530d-3da7-41b2-9c3f-33f7ed805c59 + smi:local/auto + P + undecidable + + + + + smi:local/8ab94969-d5e3-4207-b24a-046989357604 + smi:local/auto + S + undecidable + + + + + smi:local/a3a3c496-e7c4-47e3-b9a5-5d94e0eed62c + smi:local/auto + P + undecidable + + + + + smi:local/2c39c714-8b3c-4b41-b6c6-ee22f3bca042 + smi:local/auto + S + undecidable + + + + + smi:local/03589fcc-de79-436e-8f9b-c34beafcdf70 + smi:local/auto + P + undecidable + + + + + smi:local/5a258e1f-1118-4456-b531-1dc828f88ff6 + smi:local/auto + S + undecidable + + + + + smi:local/d7b55b04-1934-414c-897d-4b1f37960b6a + smi:local/auto + P + undecidable + + + + + smi:local/56cd7f47-6c27-4f04-90f0-ccbf358efc98 + smi:local/auto + S + undecidable + + + + + smi:local/a60f97e9-350c-4fe6-b0cb-c8cecfe99da3 + smi:local/auto + P + undecidable + + + + + smi:local/db67e35c-481d-4cdd-9419-3407300ff8d8 + smi:local/auto + S + undecidable + + + + + smi:local/36ef9e30-6462-435b-b5da-64df8364e11e + smi:local/auto + P + undecidable + + + + + smi:local/47905a31-e78e-48e5-bf65-2426ac7dddb7 + smi:local/auto + S + undecidable + + + + + smi:local/d98452a1-0c9b-475c-9307-fa1959ed3aa8 + smi:local/auto + P + undecidable + + + + + smi:local/6b139e2f-37b7-4310-8137-cfec8ed409d2 + smi:local/auto + S + undecidable + + + + + smi:local/b09d2ae3-853a-4bb3-9d30-820e3ecdaf54 + smi:local/auto + P + undecidable + + + + + smi:local/d459b55f-2dd8-4cc9-98d6-6f4d6464e3ae + smi:local/auto + S + undecidable + + + + + smi:local/bf3cf9db-2b9e-4a00-9635-d0ffe35bf25d + smi:local/auto + P + undecidable + + + + + smi:local/c4cc7f22-6896-4935-9a1a-fdae714fa8ba + smi:local/auto + S + undecidable + + + + + smi:local/99a1e527-e07b-4a84-b540-2f5831501883 + smi:local/auto + P + undecidable + + + + + smi:local/11156c69-870d-4d20-aac9-39fc8ee60463 + smi:local/auto + S + undecidable + + + + + smi:local/836f330e-67c1-4853-8622-145fbc805583 + smi:local/auto + P + undecidable + + + + + smi:local/5344d2c1-49d3-4bfe-aeb1-d407b6397f55 + smi:local/auto + S + undecidable + + + + + smi:local/1bcb24c5-12ab-4715-956b-7e0e01b62c79 + smi:local/auto + P + undecidable + + + + + smi:local/b1a6afdf-f997-4c6e-9ac6-eec4d291c18a + smi:local/auto + S + undecidable + + + + + smi:local/e73ce0eb-af25-4b2d-bce7-d2064670fa33 + smi:local/auto + P + undecidable + + + + + smi:local/b03dd437-2f7b-42f7-aebd-b99794189b54 + smi:local/auto + S + undecidable + + + + + smi:local/d79fb221-fcdc-4861-a7ed-2764ed508fb3 + smi:local/auto + P + undecidable + + + + + smi:local/cd0252da-9196-46fe-9850-f322bd34c23b + smi:local/auto + S + undecidable + + + + + smi:local/824d36e9-00fa-4085-bda8-24e109c2edb5 + smi:local/auto + P + undecidable + + + + + smi:local/995e9f53-9b17-4a2a-adcf-fd542d64ff90 + smi:local/auto + S + undecidable + + + + + smi:local/cc42db67-7ff3-4648-b6f9-2a58f9025a9a + smi:local/auto + P + undecidable + + + + + smi:local/843868b8-3a5c-4f0e-81bf-c0229aa7214d + smi:local/auto + S + undecidable + + + + + smi:local/dd6ccf38-0f2b-4a85-835f-ec276423ee6b + smi:local/auto + P + undecidable + + + + + smi:local/c622855a-adb0-4729-8268-b77fd7c10bc5 + smi:local/auto + S + undecidable + + + + + smi:local/c0422f5b-6806-4b5e-97dc-f143c5fe4b38 + smi:local/auto + P + undecidable + + + + + smi:local/a17d13bb-8fa1-4d95-8d3e-1a0e57121be9 + smi:local/auto + S + undecidable + + + + + smi:local/d20413b5-df00-41a3-869f-3e76ac8131bd + smi:local/auto + P + undecidable + + + + + smi:local/a61b54ac-97ec-406c-9ee5-f9d1e1ac907b + smi:local/auto + S + undecidable + + + + + smi:local/85782ccd-db39-4dc3-b184-051ba876d654 + smi:local/auto + P + undecidable + + + + + smi:local/b39fad7d-dd06-4797-8f11-08cb44b1b6d4 + smi:local/auto + S + undecidable + + + + + smi:local/d83d783f-aa69-4cab-99f8-ce17076bb1d2 + smi:local/auto + P + undecidable + + + + + smi:local/7cd2e077-c2e9-4ccd-95fc-4089a07c0d0e + smi:local/auto + S + undecidable + + + + + smi:local/a2a7be8b-7d1b-437a-aba6-e89af690fc06 + smi:local/auto + P + undecidable + + + + + smi:local/95117d5c-a3b3-441a-bc68-d8e32979cfb5 + smi:local/auto + S + undecidable + + + + + smi:local/07148129-0f4f-4a96-8893-ce6d19487bb8 + smi:local/auto + P + undecidable + + + + + smi:local/cb28f418-a9ba-4a1e-84e3-9c7a2d2a1487 + smi:local/auto + S + undecidable + + + + + smi:local/9378a0d4-e95e-49b3-b4bc-4c6edd4586e5 + smi:local/auto + P + undecidable + + + + + smi:local/305d7d08-1fe5-4ed5-897c-89fe044ee7a9 + smi:local/auto + S + undecidable + + + + + smi:local/0c21814a-2340-440f-a72d-21178eb46396 + smi:local/auto + P + undecidable + + + + + smi:local/102fdbf8-b7ee-4058-b386-f8b94a999be6 + smi:local/auto + S + undecidable + + + + + smi:local/f102223e-6c3d-405c-b6c5-28d1093f655a + smi:local/auto + P + undecidable + + + + + smi:local/9c797711-f268-4e4c-97d7-5d1b178aed12 + smi:local/auto + S + undecidable + + + + + smi:local/beb58f4f-5b98-4d72-bdb2-a677579e4bb1 + smi:local/auto + P + undecidable + + + + + smi:local/208f723a-674c-4b9e-ab1b-befc078238d1 + smi:local/auto + S + undecidable + + + + + smi:local/c4b07ef4-dfd0-4452-8121-eed116d2cf49 + smi:local/auto + P + undecidable + + + + + smi:local/1ea46c3f-dfbd-41d5-ac6d-a7ff7555ea8e + smi:local/auto + S + undecidable + + + + + smi:local/c0ccb8dd-a145-4d34-b55f-3d4a94b7422c + smi:local/auto + P + undecidable + + + + + smi:local/43808b32-4bcd-4c04-8582-423c3f6b3d0c + smi:local/auto + S + undecidable + + + + + smi:local/d0a813a1-c5ca-4a67-896a-2e68380c6a22 + smi:local/auto + P + undecidable + + + + + smi:local/f794dba8-e030-4d27-b87e-7e344eb5b1fb + smi:local/auto + S + undecidable + + + + + smi:local/3abe6274-29d1-4d8c-9500-f7c593014dff + smi:local/auto + P + undecidable + + + + + smi:local/eda63eb5-22c9-4d39-99e4-eaeed0e822a3 + smi:local/auto + S + undecidable + + + + + smi:local/a67a3ce0-c247-4ca1-8a5a-77a731c88ef1 + smi:local/auto + P + undecidable + + + + + smi:local/3c7016d2-d322-417a-9776-da79b8464a49 + smi:local/auto + S + undecidable + + + + + smi:local/9fef12bf-30c8-4d6b-8157-d0e3cd3a364a + smi:local/auto + P + undecidable + + + + + smi:local/9f71bb70-30fc-41a8-938c-bd79d5456c12 + smi:local/auto + S + undecidable + + + + + smi:local/1271e473-2302-4ad1-85d3-5aa2b697d5f5 + smi:local/auto + P + undecidable + + + + + + + smi:local/b2d16397-8a44-4500-85db-ecc861506660 + smi:local/auto + P + undecidable + + + + + smi:local/a3c468ef-923a-4cb2-b336-b8d5131ae0f0 + smi:local/auto + S + undecidable + + + + + smi:local/e772d913-34b0-45c8-b271-1d27581f92fd + smi:local/auto + P + undecidable + + + + + smi:local/9128a9f2-0d93-4ab9-b51d-e1f7fb3921d1 + smi:local/auto + S + undecidable + + + + + smi:local/4e30871b-b579-43e8-8a3c-d5005431f984 + smi:local/auto + P + undecidable + + + + + smi:local/2cae49db-3049-4e2b-8e43-9f3f8efa6502 + smi:local/auto + S + undecidable + + + + + smi:local/2fd78257-1cc6-41bb-9352-c0ce62621562 + smi:local/auto + P + undecidable + + + + + smi:local/d5627bd7-bf3c-4493-b41e-42dab90cc229 + smi:local/auto + S + undecidable + + + + + smi:local/6483427a-c4b6-48ff-8a72-c12b5a9deebc + smi:local/auto + P + undecidable + + + + + smi:local/2925d0a4-32ca-4028-95a3-496d04f0e0ea + smi:local/auto + S + undecidable + + + + + smi:local/d436790b-3884-4e47-8161-b61720b61b7a + smi:local/auto + P + undecidable + + + + + smi:local/c426eb5f-f997-4ec7-8137-7fcd50ac40b5 + smi:local/auto + S + undecidable + + + + + smi:local/b09d28d2-a526-40b6-8bcb-ff1bfb8efd0e + smi:local/auto + P + undecidable + + + + + smi:local/3482b46a-e8ac-400a-a847-81ff3a914cbe + smi:local/auto + S + undecidable + + + + + smi:local/9a3608bb-ec53-4279-8ea5-1e176e0112a3 + smi:local/auto + P + undecidable + + + + + smi:local/2007b33a-d3d0-4033-9bf8-330b21b55f32 + smi:local/auto + S + undecidable + + + + + smi:local/979e22c1-cb93-4565-a074-afe5e2df9449 + smi:local/auto + P + undecidable + + + + + smi:local/c09a29ea-a2cc-445b-8dfa-25678dc0a0a3 + smi:local/auto + S + undecidable + + + + + smi:local/e58bdd9a-7e7f-4918-8290-bf2caf2ae9f2 + smi:local/auto + P + undecidable + + + + + smi:local/dbd60f70-fe83-451d-9308-d70079585e5a + smi:local/auto + S + undecidable + + + + + smi:local/f7b84ece-cb49-4a05-a953-6d1be2061f46 + smi:local/auto + P + undecidable + + + + + smi:local/41f74755-b8e0-46e6-b9df-7e3a2517ce62 + smi:local/auto + S + undecidable + + + + + smi:local/11b93d28-1d55-4ac7-bb3c-cdd477326e50 + smi:local/auto + P + undecidable + + + + + smi:local/8ad1c879-8c0c-49eb-b74b-c54cb7785fe3 + smi:local/auto + S + undecidable + + + + + smi:local/06df691a-650e-4bf0-956f-0295300a8101 + smi:local/auto + P + undecidable + + + + + smi:local/01aaf546-891b-4efe-a582-4a7606eceb26 + smi:local/auto + S + undecidable + + + + + smi:local/f4c48959-e99b-4af1-8bf8-aa21e25bf767 + smi:local/auto + P + undecidable + + + + + smi:local/30d1dbc9-38cd-47f3-9ed1-9cfe1e017e96 + smi:local/auto + S + undecidable + + + + + smi:local/9583a7df-7444-4633-948a-35c226c1ca4a + smi:local/auto + P + undecidable + + + + + smi:local/cb64eaa5-04a0-4dc5-acab-46e5c7985900 + smi:local/auto + S + undecidable + + + + + smi:local/45524cae-34a7-4564-91bd-8c34b378f692 + smi:local/auto + P + undecidable + + + + + smi:local/f99728fd-7b17-4210-9184-869e2fca68b4 + smi:local/auto + S + undecidable + + + + + smi:local/a4c44633-819c-459c-8c04-480b774aa72f + smi:local/auto + P + undecidable + + + + + smi:local/75367c79-2d99-41fc-a7b8-92a28df5aff1 + smi:local/auto + S + undecidable + + + + + smi:local/faefafb7-3847-4e73-a6a4-0cf39df5f03e + smi:local/auto + P + undecidable + + + + + smi:local/7efb1bb3-4889-4bfe-9001-5e5fe8262ce3 + smi:local/auto + S + undecidable + + + + + smi:local/80348e6a-c226-473e-8bc2-f9559979225f + smi:local/auto + P + undecidable + + + + + smi:local/0cf88897-9f16-4132-ad88-42eb1ccb576e + smi:local/auto + S + undecidable + + + + + smi:local/18bab704-1717-4597-9172-6ab81eafa2cc + smi:local/auto + P + undecidable + + + + + smi:local/228cb9ab-968d-4cdd-923e-e14225e919ae + smi:local/auto + S + undecidable + + + + + smi:local/8ed2808f-8aae-45b4-8123-c88b67c3f2bf + smi:local/auto + P + undecidable + + + + + smi:local/8ace85ea-6a45-4c5c-898e-d0263b2e207f + smi:local/auto + S + undecidable + + + + + smi:local/8a112940-e65c-44dd-b2b9-5cb74b4c2aea + smi:local/auto + P + undecidable + + + + + smi:local/c0532009-be6e-44f3-a9b7-8c59db8f1c71 + smi:local/auto + S + undecidable + + + + + smi:local/b8aecf37-d610-4807-a9a9-01d8914b7691 + smi:local/auto + P + undecidable + + + + + smi:local/d4596edc-3ee2-477c-acda-bd8075f3a083 + smi:local/auto + S + undecidable + + + + + smi:local/f2fd80c3-0625-4676-a13a-e236f2445367 + smi:local/auto + P + undecidable + + + + + smi:local/0dbdebce-738c-45fd-b867-3ab9faeccd31 + smi:local/auto + S + undecidable + + + + + smi:local/b8decdde-2bee-4938-a9f7-a031dd5e6b08 + smi:local/auto + P + undecidable + + + + + smi:local/a6c5170b-d3ab-420b-9e53-397d947348a0 + smi:local/auto + S + undecidable + + + + + smi:local/4feee886-0636-4b9b-bec7-b24cc0b61aac + smi:local/auto + P + undecidable + + + + + smi:local/95ccb926-6a9a-4712-8adb-91c22b0f04fe + smi:local/auto + S + undecidable + + + + + smi:local/dce57e3c-468f-4b9d-94d6-6047644fa9a3 + smi:local/auto + P + undecidable + + + + + smi:local/0a6173c7-14a2-4499-93a0-5651b7d9c353 + smi:local/auto + S + undecidable + + + + + smi:local/586b2246-5a90-4a39-a6b1-6285754b2d9d + smi:local/auto + P + undecidable + + + + + smi:local/ad1581f5-8303-4fd9-a077-b19ed217e405 + smi:local/auto + S + undecidable + + + + + smi:local/371eb985-49dd-4853-8732-046eb081a395 + smi:local/auto + P + undecidable + + + + + smi:local/0c114499-0570-4ae5-b540-7b988edb7e1f + smi:local/auto + S + undecidable + + + + + smi:local/8691fcb3-2b14-46ed-a688-7ec0925a2b0a + smi:local/auto + P + undecidable + + + + + smi:local/162b684c-fd6b-4255-b9bf-832e3abb701b + smi:local/auto + S + undecidable + + + + + smi:local/ffecda7e-2a61-4994-b023-b530e7bb7ace + smi:local/auto + P + undecidable + + + + + smi:local/f17170f4-60aa-4112-9522-e0959a6fb1ae + smi:local/auto + S + undecidable + + + + + smi:local/f0df7c8b-6f62-409a-96ba-0e86c190a247 + smi:local/auto + P + undecidable + + + + + smi:local/281d6d43-8454-4a2f-bf0f-86fc57145b70 + smi:local/auto + S + undecidable + + + + + smi:local/4f203eb7-5a20-48f1-ba4f-53e6f8c155c4 + smi:local/auto + P + undecidable + + + + + smi:local/ad76ffb1-45ed-49ee-a7a3-ca92d0369d41 + smi:local/auto + S + undecidable + + + + + smi:local/61acddec-cb39-4ec6-9d20-31f441e7efbd + smi:local/auto + P + undecidable + + + + + smi:local/eeabb751-a093-4f31-9fc7-89d8e4be7020 + smi:local/auto + S + undecidable + + + + + smi:local/755d530a-29cf-4062-bb3d-d1071cf32440 + smi:local/auto + P + undecidable + + + + + smi:local/7819f7df-e37c-4eb2-aee2-344baeeb3c0b + smi:local/auto + S + undecidable + + + + + smi:local/3ed5104b-bdbc-42c6-9415-131f7c9a9f71 + smi:local/auto + P + undecidable + + + + + smi:local/2ef5f44d-8275-4813-927d-a53c26b2bf09 + smi:local/auto + S + undecidable + + + + + smi:local/4268c68f-2030-4de5-914a-5c33c015e0f9 + smi:local/auto + P + undecidable + + + + + smi:local/50aec889-bc90-4ec3-be95-f32c72cf4065 + smi:local/auto + S + undecidable + + + + + smi:local/ef3fd8ed-a88e-4dff-b359-fb4e107d165b + smi:local/auto + P + undecidable + + + + + smi:local/2a0d8785-c3a6-4942-88f4-897446c49fcc + smi:local/auto + S + undecidable + + + + + smi:local/43102f15-00c9-4f63-9dbc-531e6138dadb + smi:local/auto + P + undecidable + + + + + smi:local/d5b33d83-ad23-40d9-9004-df74e1faa6df + smi:local/auto + S + undecidable + + + + + smi:local/37da5349-2a9a-4e09-afa7-7a12bbf07489 + smi:local/auto + P + undecidable + + + + + smi:local/3656fbcd-6861-4312-b67d-16c57b365d84 + smi:local/auto + S + undecidable + + + + + smi:local/be2c8ff5-4a4e-4364-bb86-974efa0e389b + smi:local/auto + P + undecidable + + + + + smi:local/7e2a1bac-c050-490c-bd6d-0e3f284f7087 + smi:local/auto + S + undecidable + + + + + smi:local/c98685b5-80a4-4379-9d8a-004bb749be05 + smi:local/auto + P + undecidable + + + + + smi:local/d57fc5a5-8117-4809-920a-030bda06f9a8 + smi:local/auto + S + undecidable + + + + + smi:local/5443bce2-acbd-4dcf-9edd-c4fe499e206c + smi:local/auto + P + undecidable + + + + + smi:local/d7cd38b8-14c4-48a1-9be4-7bba3b58b5d9 + smi:local/auto + S + undecidable + + + + + smi:local/690d0d41-a572-41ef-ba93-3938e2135d42 + smi:local/auto + P + undecidable + + + + + smi:local/daf34a64-42ff-4f4c-bdff-8a946a414f0c + smi:local/auto + S + undecidable + + + + + smi:local/c600f769-93c4-41d0-8bee-6af8d83a6061 + smi:local/auto + P + undecidable + + + + + smi:local/031f349a-a9d7-4ccd-a888-5ad6dd1ff964 + smi:local/auto + S + undecidable + + + + + smi:local/f7c274bd-f60d-4f02-8e81-c010fbcb7e89 + smi:local/auto + P + undecidable + + + + + smi:local/58818af9-c11f-4d64-b8e9-46336dac83a3 + smi:local/auto + S + undecidable + + + + + smi:local/ead985f6-f10c-4e04-8e0b-7679a55f2324 + smi:local/auto + P + undecidable + + + + + smi:local/a2fde095-ea1d-41d8-a142-a68c513eeebe + smi:local/auto + S + undecidable + + + + + smi:local/354cb2f0-47e6-46d4-a9e1-94ac661cfa2c + smi:local/auto + P + undecidable + + + + + smi:local/cbe8eaa8-1307-4510-a916-efecd2dde4e9 + smi:local/auto + S + undecidable + + + + + smi:local/12a667bb-9fac-4cbc-bb72-3a90838f210f + smi:local/auto + P + undecidable + + + + + smi:local/a23b3a98-abe6-4e99-af2c-553138af25c1 + smi:local/auto + S + undecidable + + + + + smi:local/614bd1d8-7ad2-4b82-9038-b1920b218627 + smi:local/auto + P + undecidable + + + + + smi:local/03e8bbab-81d9-4aff-8837-1a56b8334b50 + smi:local/auto + S + undecidable + + + + + smi:local/a296bbcd-9506-4050-b408-169f1e007733 + smi:local/auto + P + undecidable + + + + + smi:local/dab58e14-156d-4991-8a2a-60b7e8af0136 + smi:local/auto + S + undecidable + + + + + smi:local/59c62d82-dfa4-4f67-8ba3-d795337be6ad + smi:local/auto + P + undecidable + + + + + smi:local/a70ae4a5-caf2-4211-9953-55c0739b6b29 + smi:local/auto + S + undecidable + + + + + smi:local/f2b14c8a-da0d-4583-9ff2-2a177fb6d8e2 + smi:local/auto + P + undecidable + + + + + smi:local/ca813855-2c85-423f-aa48-8ee918bf58b1 + smi:local/auto + S + undecidable + + + + + smi:local/2441393b-e7f0-4468-860c-845033cef3bd + smi:local/auto + P + undecidable + + + + + smi:local/5b3a5137-9272-4283-803b-e681b2fd9a66 + smi:local/auto + S + undecidable + + + + + smi:local/917672bf-fea9-4cff-ac3d-700f95c0598b + smi:local/auto + P + undecidable + + + + + smi:local/892984fb-1788-45dc-8210-d1eb155b5f73 + smi:local/auto + S + undecidable + + + + + smi:local/7469abf5-c1cf-47e2-bf85-6758ff68be84 + smi:local/auto + P + undecidable + + + + + smi:local/28d0591d-4844-431b-985b-7e7c7ff519e0 + smi:local/auto + S + undecidable + + + + + smi:local/b3e3602e-6bd2-4e3e-be1a-af189bf88fff + smi:local/auto + P + undecidable + + + + + smi:local/63c92a34-fc93-4579-bb12-e43f01866223 + smi:local/auto + S + undecidable + + + + + smi:local/abe14fdc-d98e-42a3-a520-ae56a2f58127 + smi:local/auto + P + undecidable + + + + + smi:local/00cdd634-0584-43f5-b348-ced6d70f83b0 + smi:local/auto + S + undecidable + + + + + smi:local/8136c317-cd64-4678-8d61-fe6a335d9736 + smi:local/auto + P + undecidable + + + + + smi:local/6117170d-0266-4a86-bb0c-701106e1103f + smi:local/auto + S + undecidable + + + + + smi:local/a3ede2e9-dfe9-48bb-add9-c29ca2336bd5 + smi:local/auto + P + undecidable + + + + + smi:local/bd782c29-3135-49d8-965a-39b3e0c12754 + smi:local/auto + S + undecidable + + + + + smi:local/6f2c9fc3-8032-4d87-a495-5d7dbeb6ee78 + smi:local/auto + P + undecidable + + + + + smi:local/35f307ce-007a-4dda-802a-6deccd2182c7 + smi:local/auto + S + undecidable + + + + + smi:local/ff7e0587-cd86-4afa-9ee9-22a9f87349ab + smi:local/auto + P + undecidable + + + + + smi:local/f5e5c043-cfe4-453b-aad4-0282d31d8bf0 + smi:local/auto + S + undecidable + + + + + smi:local/01f72ad4-7831-47f1-966f-8e77c232abea + smi:local/auto + P + undecidable + + + + + smi:local/9ba556a1-3afd-4de2-8935-734626d316c2 + smi:local/auto + S + undecidable + + + + + smi:local/1e078f89-b7bf-4711-baf9-7d5b8efb9df7 + smi:local/auto + P + undecidable + + + + + smi:local/252fb56a-6b73-477d-a3d1-ff4f99f12acb + smi:local/auto + S + undecidable + + + + + smi:local/d8f1b96c-ef10-4a8f-9cfb-640084214906 + smi:local/auto + P + undecidable + + + + + smi:local/2277c2bf-5cf5-4d12-a51c-a6dea8336383 + smi:local/auto + S + undecidable + + + + + smi:local/0e9483e2-7aa6-4c57-b860-0e291738099b + smi:local/auto + P + undecidable + + + + + smi:local/21ede10e-3b8c-4111-854e-12512c89dfbe + smi:local/auto + S + undecidable + + + + + smi:local/48f57ea0-f1c2-4afb-aea1-346ecb0a1396 + smi:local/auto + P + undecidable + + + + + smi:local/45c97fea-bb4b-4659-8738-1b5ee4217952 + smi:local/auto + S + undecidable + + + + + smi:local/2985397d-97ae-4036-b5f3-e29e2fedd530 + smi:local/auto + P + undecidable + + + + + smi:local/05c1d0bd-a4ff-4d4f-b23a-d7f6b3808d4f + smi:local/auto + S + undecidable + + + + + smi:local/485ae756-5471-4237-ac55-64561002ea82 + smi:local/auto + P + undecidable + + + + + smi:local/cc541e54-5ba6-4e7c-8c39-599ed08f5b7d + smi:local/auto + S + undecidable + + + + + smi:local/6f46c31f-4325-4ef8-8b7f-3d63e4dd4b7d + smi:local/auto + P + undecidable + + + + + smi:local/2ab388a5-c453-4376-bd05-2771e8240597 + smi:local/auto + S + undecidable + + + + + smi:local/11c93f4a-a470-4987-bb70-49af380b4698 + smi:local/auto + P + undecidable + + + + + smi:local/9576f4d8-7d90-4045-8973-3fce5f01dda6 + smi:local/auto + S + undecidable + + + + + smi:local/ae55f94d-cc1a-4454-9bf0-aa1a5fde8829 + smi:local/auto + P + undecidable + + + + + smi:local/5433b10a-5e27-4905-84d7-b9fa88aae9b9 + smi:local/auto + S + undecidable + + + + + smi:local/13572e81-a2a2-4d97-925a-19cb22f2ba99 + smi:local/auto + P + undecidable + + + + + smi:local/338d47fe-31f5-44c7-8a56-c651626731aa + smi:local/auto + S + undecidable + + + + + smi:local/f2d174d3-fdeb-45a7-8869-7543dc91b44b + smi:local/auto + P + undecidable + + + + + smi:local/929a6b05-fb63-47ee-b51a-2d2929098783 + smi:local/auto + S + undecidable + + + + + smi:local/ee56d197-0ab8-4e5b-aef7-cb6fb5596e4a + smi:local/auto + P + undecidable + + + + + smi:local/9c7860d9-26f3-4c45-afab-a60e9e479c96 + smi:local/auto + S + undecidable + + + + + smi:local/7842c49e-5c42-481a-92c8-13ae59358887 + smi:local/auto + P + undecidable + + + + + smi:local/d89a0823-c2bf-46ce-a663-fd91c1055e8e + smi:local/auto + S + undecidable + + + + + smi:local/e2931c6a-977d-4979-b40a-e6d5760293f5 + smi:local/auto + P + undecidable + + + + + smi:local/4de2161a-c847-4382-9500-eca00a408672 + smi:local/auto + S + undecidable + + + + + smi:local/541d386b-be68-4ff9-ab91-313b50460651 + smi:local/auto + P + undecidable + + + + + smi:local/d66124ff-6bf5-47a0-ae68-c25dbcef36f5 + smi:local/auto + S + undecidable + + + + + smi:local/78fa1877-bba4-4bd4-9699-fbaf1acee600 + smi:local/auto + P + undecidable + + + + + smi:local/20d345d1-688e-4eae-a62a-db75d26e6624 + smi:local/auto + S + undecidable + + + + + smi:local/f3828e41-ffe9-49a6-9557-47ca5f77d4e1 + smi:local/auto + P + undecidable + + + + + smi:local/a3facb31-cc2d-49a0-a230-b745026798ad + smi:local/auto + S + undecidable + + + + + smi:local/b4f6e0df-0925-481c-813c-c78b5cc4b36b + smi:local/auto + P + undecidable + + + + + smi:local/f55fd068-a29c-47b5-b371-643fcaadb380 + smi:local/auto + S + undecidable + + + + + smi:local/4ed46762-e5db-4569-a17d-c7fae8fe075d + smi:local/auto + P + undecidable + + + + + smi:local/b7ce2d7c-57e2-4664-bd47-cc1e2e90831f + smi:local/auto + S + undecidable + + + + + smi:local/24f7fc96-786c-4070-9489-2e66bf6c2cad + smi:local/auto + P + undecidable + + + + + smi:local/48669787-77f0-48fe-9f76-dc79a3fae9b8 + smi:local/auto + S + undecidable + + + + + smi:local/de417670-7670-4299-85f8-f6a9130d9f5f + smi:local/auto + P + undecidable + + + + + smi:local/928219ae-f210-4829-ab46-fec1f1dbc7ef + smi:local/auto + S + undecidable + + + + + smi:local/3fc6d12f-5b08-44c2-842a-0a7fa7582afe + smi:local/auto + P + undecidable + + + + + smi:local/64ba5aa1-667c-4ef8-b315-c35720d24a6c + smi:local/auto + S + undecidable + + + + + smi:local/a2e37216-2bb9-4548-ac55-8a0f16f116b1 + smi:local/auto + P + undecidable + + + + + smi:local/f2d8417e-b582-4b5b-987e-c0e111527c7d + smi:local/auto + S + undecidable + + + + + smi:local/7db07a9f-8c26-4680-9ac9-7b5804370ef2 + smi:local/auto + P + undecidable + + + + + smi:local/30dab55c-c13d-472d-8d88-4b293243afd9 + smi:local/auto + S + undecidable + + + + + smi:local/bb2edde4-26a6-4ba9-b53d-8952dedfaf4d + smi:local/auto + P + undecidable + + + + + smi:local/4201b8ef-03cd-41a7-9d5a-05dadc80f571 + smi:local/auto + S + undecidable + + + + + smi:local/abd0380b-660a-40ea-aab5-2fa290352143 + smi:local/auto + P + undecidable + + + + + smi:local/10a72d19-6351-4bf4-b44f-9a03cd108754 + smi:local/auto + S + undecidable + + + + + smi:local/6046c32d-78e1-4550-ae39-9fe5b451c3fc + smi:local/auto + P + undecidable + + + + + smi:local/dffaaab8-8879-4334-bee0-b003fe891fe9 + smi:local/auto + S + undecidable + + + + + smi:local/7b325d55-1e18-4c8b-803e-e69f7d34d7b2 + smi:local/auto + P + undecidable + + + + + smi:local/c3921274-3dba-48fd-829e-f46776e773d4 + smi:local/auto + S + undecidable + + + + + smi:local/bba5e27a-78db-4dca-8179-cb24939f0ea5 + smi:local/auto + P + undecidable + + + + + smi:local/353a4da0-62f4-4227-9d77-b2a25a96a27f + smi:local/auto + S + undecidable + + + + + smi:local/7d0b6a8e-463d-427c-b7d0-9f23d64a3218 + smi:local/auto + P + undecidable + + + + + smi:local/40fc722b-8047-41db-b8c0-de3b5f3c51a5 + smi:local/auto + S + undecidable + + + + + smi:local/03c4bc68-21e8-4788-bc9b-47508097b610 + smi:local/auto + P + undecidable + + + + + smi:local/35aa82e3-ea43-4765-83fa-58b67e64f6d3 + smi:local/auto + S + undecidable + + + + + smi:local/c4d7bf26-c7ac-4438-aa12-2a7541a802e5 + smi:local/auto + P + undecidable + + + + + smi:local/b4d5f26c-a0e8-462b-a89b-de420a892944 + smi:local/auto + S + undecidable + + + + + smi:local/eaefa9d2-d200-496c-bff1-93a78b1e8f80 + smi:local/auto + P + undecidable + + + + + smi:local/83303639-65e2-4447-b975-a8a1a7d37a44 + smi:local/auto + S + undecidable + + + + + smi:local/a0ac3ec1-b878-4f72-9d39-d079c5d62468 + smi:local/auto + P + undecidable + + + + + smi:local/c6b9ae4c-2e24-41ba-98fd-dd1d74960688 + smi:local/auto + S + undecidable + + + + + smi:local/7da6bb60-4562-4194-9d14-75ae73a031fd + smi:local/auto + P + undecidable + + + + + smi:local/b5cd2d03-8b59-49d6-b86a-684e24dc2e96 + smi:local/auto + S + undecidable + + + + + smi:local/6b55758b-cef6-46cb-9f8e-6b4552e806da + smi:local/auto + P + undecidable + + + + + smi:local/ffe6c8de-e002-48c2-b2d3-e7d947b10b61 + smi:local/auto + S + undecidable + + + + + smi:local/471a6e1c-baca-47b8-88f9-6e1c35bb704d + smi:local/auto + P + undecidable + + + + + smi:local/2744ac06-c11c-4187-95ee-2d93a52a8af9 + smi:local/auto + S + undecidable + + + + + smi:local/82938247-4efe-4086-a9a8-cecde1ee59fa + smi:local/auto + P + undecidable + + + + + smi:local/6956d7c1-406f-4f9f-ae8c-03718bd52103 + smi:local/auto + S + undecidable + + + + + smi:local/d90a3ce5-465f-4fbc-98c9-2cd768483d1f + smi:local/auto + P + undecidable + + + + + smi:local/921b3642-fcad-419c-9f18-31a7a92ac462 + smi:local/auto + S + undecidable + + + + + smi:local/8a14e1c3-6798-4247-bf48-21664462b17b + smi:local/auto + P + undecidable + + + + + smi:local/c63419db-6876-41e0-92f9-c943a03ea09c + smi:local/auto + S + undecidable + + + + + smi:local/05afe4f2-a3b2-4345-92c4-586fc1dcc108 + smi:local/auto + P + undecidable + + + + + smi:local/cc9a7be6-6b6b-430e-b80e-704762df0abc + smi:local/auto + S + undecidable + + + + + smi:local/5412d45b-e859-45a7-8a6f-e40be6865dc3 + smi:local/auto + P + undecidable + + + + + smi:local/b4ea1009-5cbe-4d4e-91a4-18bacaa79657 + smi:local/auto + S + undecidable + + + + + smi:local/9ce1f4e3-c46c-4111-81cc-c044a3c82c46 + smi:local/auto + P + undecidable + + + + + smi:local/a7cc5cb8-032d-4189-b502-ddaa04a9b3ed + smi:local/auto + S + undecidable + + + + + smi:local/dc7cf1b1-7ed8-495c-ab44-386d24b1bf1e + smi:local/auto + P + undecidable + + + + + smi:local/0a075cd1-445c-43cc-9c82-7ebac4808b06 + smi:local/auto + S + undecidable + + + + + smi:local/3004e4a9-c04d-450a-a19c-b5e47c3a8e3e + smi:local/auto + P + undecidable + + + + + smi:local/850bd83d-dcec-4a03-b64c-9cd42dc2b024 + smi:local/auto + S + undecidable + + + + + smi:local/020378e6-112f-4d3d-b1e7-1684a4a7f818 + smi:local/auto + P + undecidable + + + + + smi:local/aff38ed6-1bce-4abb-a8b2-733c17e72daf + smi:local/auto + S + undecidable + + + + + smi:local/31e0e8db-b99d-496d-9a0c-c4877b0f94e9 + smi:local/auto + P + undecidable + + + + + smi:local/2f234823-7a7d-4fdd-a7c1-66792e5d3c21 + smi:local/auto + S + undecidable + + + + + smi:local/ad526a09-9b2b-42f9-b409-949d847bf425 + smi:local/auto + P + undecidable + + + + + smi:local/e4cf059e-ba7b-438a-9f8a-8a6bf1587c49 + smi:local/auto + S + undecidable + + + + + smi:local/2d794c67-5855-4df9-a6e1-24c9a3e3eeb3 + smi:local/auto + P + undecidable + + + + + smi:local/b87ab82b-7343-4439-8470-e01eef573404 + smi:local/auto + S + undecidable + + + + + smi:local/3940840a-4532-4928-b257-acb57c4b33de + smi:local/auto + P + undecidable + + + + + smi:local/e1d274a9-1271-4946-95e2-4c52c21ca268 + smi:local/auto + S + undecidable + + + + + smi:local/8cca89d1-517a-4e2e-806b-2291b9ea5a26 + smi:local/auto + P + undecidable + + + + + smi:local/e7245fff-a3a6-4108-a44b-cd1a554af026 + smi:local/auto + S + undecidable + + + + + smi:local/90f1f92b-2614-48cf-a581-dfab27c93227 + smi:local/auto + P + undecidable + + + + + smi:local/860fcfca-3202-4424-9d22-7c97bea453e8 + smi:local/auto + S + undecidable + + + + + smi:local/0eb5c2b2-3b8f-4eee-b9ef-870ee40f9e23 + smi:local/auto + P + undecidable + + + + + smi:local/37ac8ad6-4155-4dbb-8008-0d5e0f2638e5 + smi:local/auto + S + undecidable + + + + + smi:local/6e1dc8aa-3784-4a6e-9337-da2bf7de5eed + smi:local/auto + P + undecidable + + + + + smi:local/1dd1d8a2-4c8c-4b36-ba9b-6f810e19e2f0 + smi:local/auto + S + undecidable + + + + + smi:local/7f26e5f4-383e-429c-bd6b-98e586c83965 + smi:local/auto + P + undecidable + + + + + smi:local/310bbbf8-2519-4983-b05d-1bbcea2eb1cf + smi:local/auto + S + undecidable + + + + + smi:local/4b66134d-8c08-49d5-8eab-baf9bd74cbf1 + smi:local/auto + P + undecidable + + + + + smi:local/90d38a19-5a00-447e-9602-9a218fd82706 + smi:local/auto + S + undecidable + + + + + smi:local/c4db455e-ba0a-4129-ab66-637487332e53 + smi:local/auto + P + undecidable + + + + + smi:local/965ad8c2-be0b-49ef-b58a-f0d4540ca785 + smi:local/auto + S + undecidable + + + + + smi:local/20569f23-2dea-47b3-b99f-0df0dd10b70e + smi:local/auto + P + undecidable + + + + + smi:local/df9c095f-ceb1-4ba4-b0c9-5740837e3378 + smi:local/auto + S + undecidable + + + + + smi:local/4089762d-d56b-43a8-a374-d0ff5909f74d + smi:local/auto + P + undecidable + + + + + + + smi:local/d11ec983-142e-4f2c-81db-69af4efb964a + smi:local/auto + P + undecidable + + + + + smi:local/d287860c-cf52-4384-894e-d0bf68da7afc + smi:local/auto + S + undecidable + + + + + smi:local/8224501d-70e7-4c36-9278-4ca6b98cc4a5 + smi:local/auto + P + undecidable + + + + + smi:local/19df664b-98bb-471e-a36e-8a2a44701d72 + smi:local/auto + S + undecidable + + + + + smi:local/26beb03b-e496-40e1-9e28-de3003b7c1b1 + smi:local/auto + P + undecidable + + + + + smi:local/9375bf82-8503-4649-9341-60f479751d29 + smi:local/auto + S + undecidable + + + + + smi:local/0002de8d-e3a4-4eb7-829f-f50e90a570f1 + smi:local/auto + P + undecidable + + + + + smi:local/71fcc975-0338-4cfa-8360-49aa4c0c0c34 + smi:local/auto + S + undecidable + + + + + smi:local/a341992e-97fa-464e-970a-c88d50e8ecaf + smi:local/auto + P + undecidable + + + + + smi:local/48f5ba67-dc2e-4d60-8008-e57896b7a08b + smi:local/auto + S + undecidable + + + + + smi:local/8163bead-ec1d-4a1b-b34f-44e3c7299cbe + smi:local/auto + P + undecidable + + + + + smi:local/b11debca-3ca8-47b1-bdbe-1ba3a185a49c + smi:local/auto + S + undecidable + + + + + smi:local/5cf5bd57-8753-48ca-9694-b257b107415e + smi:local/auto + P + undecidable + + + + + smi:local/0c51c200-0fa4-4115-a435-f52834e76112 + smi:local/auto + S + undecidable + + + + + smi:local/2b1082de-2778-48d0-9889-f0a800d2f244 + smi:local/auto + P + undecidable + + + + + smi:local/0a5792ae-2f32-414a-a9c9-29ac30ced25d + smi:local/auto + S + undecidable + + + + + smi:local/d24e8376-c587-417a-b454-919eb8a3b69f + smi:local/auto + P + undecidable + + + + + smi:local/e7518800-6abe-4e2b-801f-19cfbea51309 + smi:local/auto + S + undecidable + + + + + smi:local/64b27cdb-c4ec-44ac-8ec6-6f08a7c234ce + smi:local/auto + P + undecidable + + + + + smi:local/f24c36da-c901-4604-b854-3b0ebcfabd4f + smi:local/auto + S + undecidable + + + + + smi:local/8cbe47a0-8ea0-4493-bb6a-71d04c44f48d + smi:local/auto + P + undecidable + + + + + smi:local/ff6ab24f-9652-491b-a996-4b03de543474 + smi:local/auto + S + undecidable + + + + + smi:local/3d2d9727-8c2d-49c3-b02e-ff47106507a6 + smi:local/auto + P + undecidable + + + + + smi:local/79cec681-73ff-489e-876b-ec46694de18f + smi:local/auto + S + undecidable + + + + + smi:local/9fda741f-3374-4141-9184-37decc34d0e0 + smi:local/auto + P + undecidable + + + + + smi:local/9c9e4b79-de0b-4426-9e37-a32be3565564 + smi:local/auto + S + undecidable + + + + + smi:local/89953aca-b217-4edd-9cb8-ba06a5f974e9 + smi:local/auto + P + undecidable + + + + + smi:local/2b0d5367-45ef-4cdb-be4f-4b2a67d4b8c9 + smi:local/auto + S + undecidable + + + + + smi:local/461aa392-fca3-4217-a91f-741b3ab20a21 + smi:local/auto + P + undecidable + + + + + smi:local/6a9b16a9-edef-4121-b1f3-9f6319f49fc6 + smi:local/auto + S + undecidable + + + + + smi:local/0527e583-9c81-43eb-84ed-c25500b2a821 + smi:local/auto + P + undecidable + + + + + smi:local/29a4d3e6-71aa-4e06-8d7f-81c63cf07add + smi:local/auto + S + undecidable + + + + + smi:local/1a0d5743-aa66-4eb8-8f1a-d42fd60926ae + smi:local/auto + P + undecidable + + + + + smi:local/84adde62-b12e-4fc3-85fe-0b8f965875b9 + smi:local/auto + S + undecidable + + + + + smi:local/c0ef287f-a7b9-4d82-8625-0a7aee8f6532 + smi:local/auto + P + undecidable + + + + + smi:local/5ae29d72-22da-4c55-8b49-bf1f0626b358 + smi:local/auto + S + undecidable + + + + + smi:local/27271e2d-a965-4e54-9058-976e0ee0010a + smi:local/auto + P + undecidable + + + + + smi:local/3cc87b7f-a9ac-4e27-a9ad-25adf8a8b7e8 + smi:local/auto + S + undecidable + + + + + smi:local/cca4a94d-6d1a-4146-b704-d259366d6a29 + smi:local/auto + P + undecidable + + + + + smi:local/1aec75bd-490b-4587-b24c-c7865e361f9b + smi:local/auto + S + undecidable + + + + + smi:local/882bbd41-4e81-4d36-b7df-a66977ae117b + smi:local/auto + P + undecidable + + + + + smi:local/66d79554-f456-4245-950f-6886a8997d18 + smi:local/auto + S + undecidable + + + + + smi:local/25e00e1a-b515-4b6f-8991-8290f7fe841c + smi:local/auto + P + undecidable + + + + + smi:local/1f45d7d4-5333-485c-9a5a-5d5ee3fa3ccc + smi:local/auto + S + undecidable + + + + + smi:local/f4df09cf-cdd0-4d0b-b3b7-8f46991223bb + smi:local/auto + P + undecidable + + + + + smi:local/f243d911-e22c-4eda-a40a-91d3ed10a93e + smi:local/auto + S + undecidable + + + + + smi:local/df6c0a03-4ac5-4759-8957-9ef2f1ade1cd + smi:local/auto + P + undecidable + + + + + smi:local/7e60ffd7-0234-4f40-9e05-8e86bf3fc1d6 + smi:local/auto + S + undecidable + + + + + smi:local/0f982755-3a67-47f6-8086-677e6eaf8c42 + smi:local/auto + P + undecidable + + + + + smi:local/6e66d4ff-850c-438d-b912-6bce55db5735 + smi:local/auto + S + undecidable + + + + + smi:local/9f52a9ca-8d68-4b3b-9752-e59e4c114987 + smi:local/auto + P + undecidable + + + + + smi:local/8ed555d8-72c4-4441-881a-87e0613d8938 + smi:local/auto + S + undecidable + + + + + smi:local/49b784fc-4a19-4705-81b2-50f513975b54 + smi:local/auto + P + undecidable + + + + + smi:local/52a462bd-0377-40b5-8aaa-a67906eecbad + smi:local/auto + S + undecidable + + + + + smi:local/7a0bdab2-52e5-4dde-a006-174a2868908e + smi:local/auto + P + undecidable + + + + + smi:local/7bacf889-de7b-43d8-9c53-9bca075d31a9 + smi:local/auto + S + undecidable + + + + + smi:local/bbb28a23-889b-4f4d-8bde-39c5c86d5043 + smi:local/auto + P + undecidable + + + + + smi:local/ea0b6eaf-30ca-414e-9380-8c4a6d93582d + smi:local/auto + S + undecidable + + + + + smi:local/d89e0981-b607-47b7-9872-bbb2f1ae4872 + smi:local/auto + P + undecidable + + + + + smi:local/81e30f0b-b010-485d-9c09-1775fa025a1a + smi:local/auto + S + undecidable + + + + + smi:local/1ea3bd6f-7cbc-4007-9dce-4e66c3a42d8f + smi:local/auto + P + undecidable + + + + + smi:local/87fcddcb-6dc1-4b03-9af0-39036d775755 + smi:local/auto + S + undecidable + + + + + smi:local/1802634d-b379-42bb-a1b6-6a381146a684 + smi:local/auto + P + undecidable + + + + + smi:local/13b2f6ef-7ecd-4890-8e03-c7e3354c5330 + smi:local/auto + S + undecidable + + + + + smi:local/3072ce92-cf7b-4405-a319-aac482edeb69 + smi:local/auto + P + undecidable + + + + + smi:local/785374b0-4c4f-48ca-a16c-5d5e66a87147 + smi:local/auto + S + undecidable + + + + + smi:local/a1318fcf-f182-4cd1-bf99-1feab5ecd62d + smi:local/auto + P + undecidable + + + + + smi:local/60c098f2-6aee-495c-bfd7-0bb873c5510a + smi:local/auto + S + undecidable + + + + + smi:local/0a65667a-9be2-486e-bdeb-fc5e181b5e30 + smi:local/auto + P + undecidable + + + + + smi:local/7e260cce-5e43-4983-878a-1a5bd097ce86 + smi:local/auto + S + undecidable + + + + + smi:local/0a31a92e-08c7-43de-a13a-c7acfd32916b + smi:local/auto + P + undecidable + + + + + smi:local/dd7f439d-93ce-4e0d-9fdc-835386852a26 + smi:local/auto + S + undecidable + + + + + smi:local/2a253626-0a7a-4783-b4a6-05ebfc04b09e + smi:local/auto + P + undecidable + + + + + smi:local/d7460779-bd4d-48bd-aed4-c38d3fb39f04 + smi:local/auto + S + undecidable + + + + + smi:local/ea4fa005-c1f0-4a1b-b0bc-12b1725db7ca + smi:local/auto + P + undecidable + + + + + smi:local/b6aee4b6-853a-4ebb-bf94-39d3f620bc95 + smi:local/auto + S + undecidable + + + + + smi:local/fc790648-d01b-4667-9db3-6a16011cd653 + smi:local/auto + P + undecidable + + + + + smi:local/3f7ead07-9023-4186-8c43-b30a52de31bb + smi:local/auto + S + undecidable + + + + + smi:local/dab6057e-4258-4a6d-a2ae-0ac1b598f9ed + smi:local/auto + P + undecidable + + + + + smi:local/1869f5dc-ddc1-427d-88d1-f1ba6f8427ad + smi:local/auto + S + undecidable + + + + + smi:local/3bd34a4f-d74c-4880-84dd-aec6a4cdc9bf + smi:local/auto + P + undecidable + + + + + smi:local/6832ce59-3d3a-41f9-9cd8-f53851f99853 + smi:local/auto + S + undecidable + + + + + smi:local/09f6ca28-ae8e-4486-af35-f6b10b4930bd + smi:local/auto + P + undecidable + + + + + smi:local/97796cda-538b-4af6-bd28-83cc5307fa09 + smi:local/auto + S + undecidable + + + + + smi:local/04e287a5-43b8-4579-81df-e756789ac0bd + smi:local/auto + P + undecidable + + + + + smi:local/31fe4d69-5283-46e1-bf5a-dff16b91401e + smi:local/auto + S + undecidable + + + + + smi:local/580663ac-2d83-41f2-95a6-0c9baa5c282b + smi:local/auto + P + undecidable + + + + + smi:local/9f39a274-45d9-444d-958d-aaef96f0f325 + smi:local/auto + S + undecidable + + + + + smi:local/71531854-b9d1-4061-a9c4-22dfe302a079 + smi:local/auto + P + undecidable + + + + + smi:local/5d4d40e9-0900-45e8-9967-a9c5d7bbe4db + smi:local/auto + S + undecidable + + + + + smi:local/d52c0f51-5314-4a0f-9374-84f5c94bc05b + smi:local/auto + P + undecidable + + + + + smi:local/edaac9ac-c4ae-4550-99cb-4bbe4c86a040 + smi:local/auto + S + undecidable + + + + + smi:local/31d352ac-76ab-405b-9d70-eb7704363742 + smi:local/auto + P + undecidable + + + + + smi:local/05a780ed-11d0-4e51-8924-24dd076fdc0a + smi:local/auto + S + undecidable + + + + + smi:local/d93e74db-39ee-4a45-b880-30b2b68491f9 + smi:local/auto + P + undecidable + + + + + smi:local/983721d7-a4c8-4610-a998-fc25402a9307 + smi:local/auto + S + undecidable + + + + + smi:local/934a03db-10d6-47ab-a12a-2188a554575c + smi:local/auto + P + undecidable + + + + + smi:local/3c999fe5-91e9-4a1d-bb24-5650a334ac58 + smi:local/auto + S + undecidable + + + + + smi:local/861d0d9b-d0c6-4b4b-b207-8803fe45a046 + smi:local/auto + P + undecidable + + + + + smi:local/255fc9d9-1341-4f2b-95c8-eb298646be62 + smi:local/auto + S + undecidable + + + + + smi:local/0f49a8cb-f398-4405-a366-5cc2967f83e3 + smi:local/auto + P + undecidable + + + + + smi:local/d29e137c-8a35-4fe4-ba28-3f52f24896be + smi:local/auto + S + undecidable + + + + + smi:local/914e1d59-174d-41ef-9704-330df46270cf + smi:local/auto + P + undecidable + + + + + smi:local/f525422b-3515-4449-b43d-10282fdec3d5 + smi:local/auto + S + undecidable + + + + + smi:local/8f59854f-ce4a-4bda-8fe3-01bd3dc303f0 + smi:local/auto + P + undecidable + + + + + smi:local/14df61d5-9b04-4357-8b46-4814601e0587 + smi:local/auto + S + undecidable + + + + + smi:local/e184cb05-9e99-4508-8b32-9407236456d3 + smi:local/auto + P + undecidable + + + + + smi:local/4d7c9558-9113-4f65-a573-70a7343cebc5 + smi:local/auto + S + undecidable + + + + + smi:local/e8473307-376f-4eb6-86c2-a5c8967d4dc0 + smi:local/auto + P + undecidable + + + + + smi:local/b039d8a1-8bef-48f3-94db-bad5576100a9 + smi:local/auto + S + undecidable + + + + + smi:local/cf05ecb7-dd36-442e-ab85-7d9655e81593 + smi:local/auto + P + undecidable + + + + + smi:local/4dc919f9-52b6-42f8-955a-e2fb8267514b + smi:local/auto + S + undecidable + + + + + smi:local/484f7bbd-b10c-4c87-9516-c69e6833fce9 + smi:local/auto + P + undecidable + + + + + smi:local/3abaf01c-f16c-4e33-9d4b-9a65be09c6ae + smi:local/auto + S + undecidable + + + + + smi:local/7766ee26-767d-47af-80da-00e43256f6df + smi:local/auto + P + undecidable + + + + + smi:local/f825dd1d-0ba0-4ccb-9f58-d4b0c3aa8a03 + smi:local/auto + S + undecidable + + + + + smi:local/373ff417-0f63-4341-9fa9-a49126848371 + smi:local/auto + P + undecidable + + + + + smi:local/2b6dd799-cab9-4c8a-90c6-cc865511e016 + smi:local/auto + S + undecidable + + + + + smi:local/2e9ed08f-9f3c-4fef-9638-306b9be03269 + smi:local/auto + P + undecidable + + + + + smi:local/06004867-92b1-491e-a00b-1d9af11f1548 + smi:local/auto + S + undecidable + + + + + smi:local/800e8dff-5297-4ca8-96ce-8d4b356965eb + smi:local/auto + P + undecidable + + + + + smi:local/4cb1dc84-e4c8-403f-9419-076df44d986f + smi:local/auto + S + undecidable + + + + + smi:local/4109294a-7d3d-40f5-b004-9c6c28d8983f + smi:local/auto + P + undecidable + + + + + smi:local/68e3351d-20b1-46db-b5a2-e785ef36530b + smi:local/auto + S + undecidable + + + + + smi:local/c54ec0d2-866a-42bf-8176-318caf6fdde7 + smi:local/auto + P + undecidable + + + + + smi:local/7b79190c-4e0b-4dc8-8842-e0c5f6b1883c + smi:local/auto + S + undecidable + + + + + smi:local/1255983d-581d-4f7b-9620-3a2a9ba32343 + smi:local/auto + P + undecidable + + + + + smi:local/32d1cc64-2bdd-4f19-bd60-1b8435e17cf7 + smi:local/auto + S + undecidable + + + + + smi:local/922d6379-ab52-4774-bc55-11a4205a1390 + smi:local/auto + P + undecidable + + + + + smi:local/8e8ec4cb-3a57-4321-83bc-3aa6880fd227 + smi:local/auto + S + undecidable + + + + + smi:local/16a1a020-f82c-4662-ad72-01dc23a97ab0 + smi:local/auto + P + undecidable + + + + + smi:local/a095a7c8-5b6a-4e04-9a2e-208b2ec4ee53 + smi:local/auto + S + undecidable + + + + + smi:local/893f72cc-a326-4d77-9801-e9549d53461d + smi:local/auto + P + undecidable + + + + + smi:local/66cb0c95-881b-403f-bd04-ff011d6d31bc + smi:local/auto + S + undecidable + + + + + smi:local/fb2c40be-5f48-4cd5-af43-af5bb5d2ddeb + smi:local/auto + P + undecidable + + + + + smi:local/5364d05f-db02-4ed8-a8bf-def6559292b2 + smi:local/auto + S + undecidable + + + + + smi:local/79ca36f7-2076-48bf-99e2-636dfbacd611 + smi:local/auto + P + undecidable + + + + + smi:local/70d0d644-abb3-45d7-84a3-a8b8cb3419c7 + smi:local/auto + S + undecidable + + + + + smi:local/da3345af-8a9e-47b5-b88f-c6b3f8ac08c8 + smi:local/auto + P + undecidable + + + + + smi:local/ba97100e-11ad-4e99-bf0d-89835c17a590 + smi:local/auto + S + undecidable + + + + + smi:local/c171b864-8f7d-428c-89a9-23e221d4bcce + smi:local/auto + P + undecidable + + + + + smi:local/b6ba8912-5412-459b-9ad2-6c2c966e14cf + smi:local/auto + S + undecidable + + + + + smi:local/fb1f2ef5-02d1-4f93-8e7f-462500b60b62 + smi:local/auto + P + undecidable + + + + + smi:local/93342a5b-b796-4077-9221-71014915dd79 + smi:local/auto + S + undecidable + + + + + smi:local/9733fe2b-d961-4cf2-b489-e18bcc0e6ab8 + smi:local/auto + P + undecidable + + + + + smi:local/88b33531-6350-4eef-b521-a56ff31d08f0 + smi:local/auto + S + undecidable + + + + + smi:local/25dc6887-2bba-45a6-9b7e-c625554af59a + smi:local/auto + P + undecidable + + + + + smi:local/2ae2681e-e752-4bdc-8847-901b91fda74e + smi:local/auto + S + undecidable + + + + + smi:local/e9b3f70c-4546-4288-b646-42f0cca84fdd + smi:local/auto + P + undecidable + + + + + smi:local/daa06289-18f2-4590-a8a2-366530d1c818 + smi:local/auto + S + undecidable + + + + + smi:local/3040225e-9540-4ea2-9e11-cf121484ccd5 + smi:local/auto + P + undecidable + + + + + smi:local/c107053d-3f05-487d-a576-2b645e639cc1 + smi:local/auto + S + undecidable + + + + + smi:local/e4128634-e660-448a-8dff-f34da2c56014 + smi:local/auto + P + undecidable + + + + + smi:local/eaed8a9c-8146-4048-b6fa-e01a4aed0ac0 + smi:local/auto + S + undecidable + + + + + smi:local/b8bf46cb-f27d-48a0-89e5-7e6f70f8e4e3 + smi:local/auto + P + undecidable + + + + + smi:local/206149a4-a1c0-497e-930a-f67178797a7a + smi:local/auto + S + undecidable + + + + + smi:local/eb8bb863-3382-4db9-adcf-f76e1f8ca1f6 + smi:local/auto + P + undecidable + + + + + smi:local/304df8f5-456c-43ed-af50-aefc65ae7062 + smi:local/auto + S + undecidable + + + + + smi:local/4ebdff19-9414-460b-8420-ed1ef0aced73 + smi:local/auto + P + undecidable + + + + + smi:local/07df5888-402a-4bd8-b31a-8307aca052ad + smi:local/auto + S + undecidable + + + + + smi:local/f06d2d75-5c87-40ac-9019-a8c02b2f8289 + smi:local/auto + P + undecidable + + + + + smi:local/93234a17-1174-497f-bb9f-67c096f0ac09 + smi:local/auto + S + undecidable + + + + + smi:local/d0cc1cd5-0b85-4e21-b6ef-9386488cd76a + smi:local/auto + P + undecidable + + + + + smi:local/04d8e5f5-6ffd-43a5-bb39-9784e3889799 + smi:local/auto + S + undecidable + + + + + smi:local/a66517de-9638-40da-a32d-f6c788ca483d + smi:local/auto + P + undecidable + + + + + smi:local/c69a708f-0932-49e4-9e35-3e83402aac3b + smi:local/auto + S + undecidable + + + + + smi:local/ec2e5629-2fc5-4b39-a0db-b324afd507f2 + smi:local/auto + P + undecidable + + + + + smi:local/ba6bcc6a-495c-4b40-a262-419ce8002958 + smi:local/auto + S + undecidable + + + + + smi:local/ba4e5afc-d66f-4002-9ae0-fadfda93a640 + smi:local/auto + P + undecidable + + + + + smi:local/79f1837f-4d9d-4824-a2c5-d4bfc56bb6bd + smi:local/auto + S + undecidable + + + + + smi:local/08bc855c-720e-47e3-90fd-3ab07496b01f + smi:local/auto + P + undecidable + + + + + smi:local/5f36c64e-c08c-4a33-9185-e61c1480a1d3 + smi:local/auto + S + undecidable + + + + + smi:local/e559aeba-261c-47df-91f3-2ec9b720dc79 + smi:local/auto + P + undecidable + + + + + smi:local/81f6d113-869d-4fe6-a845-e1916dfae41d + smi:local/auto + S + undecidable + + + + + smi:local/94cac01b-254e-4851-a19e-22e4f4488e59 + smi:local/auto + P + undecidable + + + + + smi:local/c598213e-f166-4c1a-ae12-06b304a45afb + smi:local/auto + S + undecidable + + + + + smi:local/9e511b89-4d00-4ebc-8809-b3f1f4599234 + smi:local/auto + P + undecidable + + + + + smi:local/93deaf88-5d42-41a8-8889-5d9ac2de0282 + smi:local/auto + S + undecidable + + + + + smi:local/f3f78447-83c6-4433-9bae-27ad77d8ffd0 + smi:local/auto + P + undecidable + + + + + smi:local/cde411f5-cf70-472e-82dc-40b07f88d62e + smi:local/auto + S + undecidable + + + + + smi:local/28779526-3f53-4a75-9150-5d21a1115ae1 + smi:local/auto + P + undecidable + + + + + smi:local/9093e856-ae8e-4973-95b0-021af9e5b157 + smi:local/auto + S + undecidable + + + + + smi:local/1f302109-a352-4cff-8f36-829229cde9e5 + smi:local/auto + P + undecidable + + + + + smi:local/12c51410-f7d0-4401-84ee-6f1cc9041166 + smi:local/auto + S + undecidable + + + + + smi:local/29b4f3cd-098b-410d-b74d-cd22ea6d97d2 + smi:local/auto + P + undecidable + + + + + smi:local/50f35d1a-d6fe-49b4-8e51-477e870675c8 + smi:local/auto + S + undecidable + + + + + smi:local/a937c863-0000-47aa-8a1a-bbaf4d2beb76 + smi:local/auto + P + undecidable + + + + + smi:local/94b9829c-b45e-41e0-94c6-501fc170c17b + smi:local/auto + S + undecidable + + + + + smi:local/d3ad78e4-e181-4101-8432-2bf6f07bb26e + smi:local/auto + P + undecidable + + + + + smi:local/9a7a2691-e378-45c7-b267-b9e09ec993ad + smi:local/auto + S + undecidable + + + + + smi:local/34d2b890-405f-4aab-8be6-033c6c240f59 + smi:local/auto + P + undecidable + + + + + smi:local/d0f2dd96-5667-46ef-bc81-f1e087055c29 + smi:local/auto + S + undecidable + + + + + smi:local/3a06a541-838c-4d47-bac6-ad644dead24d + smi:local/auto + P + undecidable + + + + + smi:local/2e28e6ac-6995-4ba6-a6ac-d7cb492ba88f + smi:local/auto + S + undecidable + + + + + smi:local/b527069f-3c58-46a0-998a-249868913f87 + smi:local/auto + P + undecidable + + + + + smi:local/5852f069-c7f1-42be-984e-c0fc58c7ea9d + smi:local/auto + S + undecidable + + + + + smi:local/b2cf776a-9ae2-43a3-8d25-4a204ef5e1ae + smi:local/auto + P + undecidable + + + + + smi:local/61a39007-45ef-4010-9ee1-854e3dd60560 + smi:local/auto + S + undecidable + + + + + smi:local/053cd9bf-230e-4d39-863c-35272a4534dd + smi:local/auto + P + undecidable + + + + + smi:local/f4c5d668-e2a3-4c4d-9f3a-92f823d44da2 + smi:local/auto + S + undecidable + + + + + smi:local/5fe28135-d49a-409a-ab73-bfd1ea3c9603 + smi:local/auto + P + undecidable + + + + + smi:local/72f4a141-634a-4976-803f-e7ba56f4b944 + smi:local/auto + S + undecidable + + + + + smi:local/2057fdfe-79b7-4b8e-9b4c-ee3f98283b80 + smi:local/auto + P + undecidable + + + + + smi:local/97383d9c-5f4c-4ffb-9bd3-bc210966bdba + smi:local/auto + S + undecidable + + + + + smi:local/b604f0d5-a9f0-4bd0-b3bd-23964aca8831 + smi:local/auto + P + undecidable + + + + + smi:local/7d678ebd-797c-46ab-9f05-29c502e574d4 + smi:local/auto + S + undecidable + + + + + smi:local/f915563e-a5bb-4eec-9136-16b7a45cd9a3 + smi:local/auto + P + undecidable + + + + + smi:local/3e621521-ba7e-4611-aa75-e2236ada42aa + smi:local/auto + S + undecidable + + + + + smi:local/f7f2ca5a-b3e7-4dcd-8267-8585a2b40b64 + smi:local/auto + P + undecidable + + + + + smi:local/366b9167-ad06-4ee7-a4d8-559f18b8c4b5 + smi:local/auto + S + undecidable + + + + + smi:local/3be33ee0-3d5b-4534-bfb3-262cf7f2eabb + smi:local/auto + P + undecidable + + + + + smi:local/10ae9ec0-c5df-43af-a232-b95439681dd6 + smi:local/auto + S + undecidable + + + + + smi:local/cd9aa875-772a-4814-aaf6-be80f9af0a2e + smi:local/auto + P + undecidable + + + + + smi:local/c37e82c7-8379-40a1-b142-755b9e1facda + smi:local/auto + S + undecidable + + + + + smi:local/8cd9ee0e-5846-41eb-922f-6ff0d6302110 + smi:local/auto + P + undecidable + + + + + smi:local/5e8240fd-6fe7-409a-8243-fbb51bdc3f0f + smi:local/auto + S + undecidable + + + + + smi:local/665a9c9e-6378-41f4-bb56-be86b08d6fa4 + smi:local/auto + P + undecidable + + + + + smi:local/d7aabaee-e705-4579-9c39-d005623fac01 + smi:local/auto + S + undecidable + + + + + smi:local/01a27915-53ae-4ac4-9500-a335f25e350f + smi:local/auto + P + undecidable + + + + + smi:local/6926a0e4-0c9a-4740-b21f-bf44dfe75b40 + smi:local/auto + S + undecidable + + + + + smi:local/bd4dde18-3e6c-4363-9a84-0c02ce09c7a6 + smi:local/auto + P + undecidable + + + + + smi:local/2854c7df-2824-4479-a92b-eff9c3e6f1e8 + smi:local/auto + S + undecidable + + + + + smi:local/faa05b5b-d037-4f2e-b3cf-574d1fc73c01 + smi:local/auto + P + undecidable + + + + + smi:local/4f16a36f-bf80-46c3-a45e-d7940cce82af + smi:local/auto + S + undecidable + + + + + smi:local/83d206e8-4b73-45d7-8225-6ebbc9989416 + smi:local/auto + P + undecidable + + + + + smi:local/22582175-d83b-4895-8a29-0867ca78d552 + smi:local/auto + S + undecidable + + + + + smi:local/484a3e94-c1d2-41df-be16-d6d39eee172c + smi:local/auto + P + undecidable + + + + + smi:local/2d3dcf8b-9847-4162-adf4-5e784a151a56 + smi:local/auto + S + undecidable + + + + + smi:local/26574f3c-73e2-485e-8252-91c17fda599e + smi:local/auto + P + undecidable + + + + + smi:local/aabf138d-f0a2-4594-8393-08606bf28355 + smi:local/auto + S + undecidable + + + + + smi:local/5e6d25d1-4e7b-46c8-84ab-e99989c84f22 + smi:local/auto + P + undecidable + + + + + smi:local/f7fd5557-1b41-4933-b510-8c96b8d8d6d8 + smi:local/auto + S + undecidable + + + + + smi:local/4f9d2d42-ffb8-4df9-83f0-5866b6aa2647 + smi:local/auto + P + undecidable + + + + + smi:local/b9342171-3a1b-41fe-8a62-92c427e4426b + smi:local/auto + S + undecidable + + + + + smi:local/a603043b-a820-4970-93f6-30079058dd8a + smi:local/auto + P + undecidable + + + + + smi:local/ec7dc25f-fba1-4975-ab90-192c0f831a5f + smi:local/auto + S + undecidable + + + + + smi:local/88218807-2c5c-4f33-9cb8-1148276ad4c8 + smi:local/auto + P + undecidable + + + + + smi:local/6a043bf9-1d27-4afa-a322-53d34edff733 + smi:local/auto + S + undecidable + + + + + smi:local/25a2e071-cfd9-4974-b901-0cfced4d0470 + smi:local/auto + P + undecidable + + + + + smi:local/be9d71cc-3cfd-4ef1-9907-2b842e82379c + smi:local/auto + S + undecidable + + + + + smi:local/8f36456b-c233-48f1-8b1a-543449f67fdd + smi:local/auto + P + undecidable + + + + + smi:local/057f08ca-0dc5-4e83-bebf-f4e72dc59c07 + smi:local/auto + S + undecidable + + + + + smi:local/bf1fa2cd-5351-45fa-83e8-8a244650bc34 + smi:local/auto + P + undecidable + + + + + smi:local/910d3fdd-7c16-4b54-b9fe-c4c1a11ba070 + smi:local/auto + S + undecidable + + + + + smi:local/d12168d3-2bf8-425f-ae07-65155264ea9f + smi:local/auto + P + undecidable + + + + + smi:local/031d5354-8efb-4dbf-8418-faacdc169e17 + smi:local/auto + S + undecidable + + + + + smi:local/9b58b6f6-4575-48ba-b4de-5bd280d085ca + smi:local/auto + P + undecidable + + + + + smi:local/aec1dfcb-429b-4a9c-8172-27be665802c0 + smi:local/auto + S + undecidable + + + + + smi:local/f25c0a77-53c1-4823-9e7f-b2e189818658 + smi:local/auto + P + undecidable + + + + + smi:local/7054b359-4504-49f9-8aa9-09980cf93dcb + smi:local/auto + S + undecidable + + + + + smi:local/b5e09688-61ea-4d33-b7c8-8391e8341c2d + smi:local/auto + P + undecidable + + + + + smi:local/dc0e6ded-92da-46ce-9941-5d43a8b883f2 + smi:local/auto + S + undecidable + + + + + smi:local/33587154-85e2-422e-8971-dba9e3472d62 + smi:local/auto + P + undecidable + + + + + smi:local/8cc6e330-fe0b-4813-9cf8-49dcf562b112 + smi:local/auto + S + undecidable + + + + + smi:local/19679f71-b7d1-479d-8ad8-aae4ebb76e8b + smi:local/auto + P + undecidable + + + + + smi:local/8db6852f-9ac4-4bd7-8be1-aabb4552e3f0 + smi:local/auto + S + undecidable + + + + + smi:local/3b7f7871-c635-4226-98df-accbaf8205f3 + smi:local/auto + P + undecidable + + + + + smi:local/bc1572e6-521a-4a8b-a053-2defe6cfeb2f + smi:local/auto + S + undecidable + + + + + smi:local/9c191c5b-d79a-4418-99df-d73fce95e76d + smi:local/auto + P + undecidable + + + + + smi:local/ba6c5462-8daf-42c0-988b-994d1c4ee3c6 + smi:local/auto + S + undecidable + + + + + smi:local/6490dfd0-b859-42ea-bffb-f93e730ac1a4 + smi:local/auto + P + undecidable + + + + + smi:local/6738bd0d-5462-4d9a-a1b6-d83adcdc4da3 + smi:local/auto + S + undecidable + + + + + smi:local/bb5c3f55-7002-4b60-9d74-9311c4ca0dfa + smi:local/auto + P + undecidable + + + + + smi:local/17ff6144-f2ed-457e-b305-dd05b6e2149b + smi:local/auto + S + undecidable + + + + + smi:local/f83a5b7c-67a2-4ebf-80db-21fde1e49e81 + smi:local/auto + P + undecidable + + + + + smi:local/3add348c-a257-48f9-82b4-dd9820d1a1c3 + smi:local/auto + S + undecidable + + + + + smi:local/2440ca99-362e-4bf9-9fd4-01261c7c0852 + smi:local/auto + P + undecidable + + + + + smi:local/33388f0f-7179-4852-a699-6f5c16cbfc49 + smi:local/auto + S + undecidable + + + + + smi:local/061bb353-5e00-4860-acc2-9deef1e7ec86 + smi:local/auto + P + undecidable + + + + + smi:local/6ea39a29-e944-48bf-92b3-47919a67242d + smi:local/auto + S + undecidable + + + + + smi:local/2b67f574-e298-4c2e-850e-c26ede938c9d + smi:local/auto + P + undecidable + + + + + smi:local/c028c0c6-8bce-4d86-9a9c-e5a0963ffaf3 + smi:local/auto + S + undecidable + + + + + smi:local/e656a0ac-86d6-4808-8172-5bd37db0c584 + smi:local/auto + P + undecidable + + + + + smi:local/2f6d5100-9649-4d68-9afa-a7999ecba5ab + smi:local/auto + S + undecidable + + + + + smi:local/1f91898f-b101-4db4-a222-9332f10ea56c + smi:local/auto + P + undecidable + + + + + smi:local/0d3a5031-5c6b-46bc-aa42-4f9ec4677a1c + smi:local/auto + S + undecidable + + + + + smi:local/9c2d9fb0-7c94-47b3-bd89-281bf8736518 + smi:local/auto + P + undecidable + + + + + smi:local/dc6bf04b-2618-4ac3-a42a-fbe084ffa17f + smi:local/auto + S + undecidable + + + + + smi:local/a599d62e-ed07-4cc6-b420-35637e3081b8 + smi:local/auto + P + undecidable + + + + + smi:local/65c40817-d795-4b79-826c-aa00f76a3fec + smi:local/auto + S + undecidable + + + + + smi:local/38119306-50e5-4c28-9208-b070aebf423f + smi:local/auto + P + undecidable + + + + + smi:local/e30eead1-572f-4b2a-a358-78cb9ac23186 + smi:local/auto + S + undecidable + + + + + smi:local/83624ed7-4725-4aab-9f19-b307648f0945 + smi:local/auto + P + undecidable + + + + + smi:local/14351384-f6fa-48e1-bc9a-ca6e5dbe669a + smi:local/auto + S + undecidable + + + + + smi:local/3b2c2efa-15b0-4e98-83ae-55ad842cc569 + smi:local/auto + P + undecidable + + + + + smi:local/e9aa1bb8-41ec-49a0-88a0-48c5c1664b2f + smi:local/auto + S + undecidable + + + + + smi:local/05294f28-ded3-4edb-aa6e-789590fd42b5 + smi:local/auto + P + undecidable + + + + + smi:local/a389ed2f-920b-4e45-8123-e8de25a59c3c + smi:local/auto + S + undecidable + + + + + smi:local/c1c14e6a-6e0d-42f4-b077-cb6eb291e6a8 + smi:local/auto + P + undecidable + + + + + smi:local/8a9c3a15-1210-4402-92a6-4303b7cd6a83 + smi:local/auto + S + undecidable + + + + + smi:local/9addf62f-adbc-4348-b6c3-7b04e77cbef1 + smi:local/auto + P + undecidable + + + + + smi:local/b6848257-631f-4bb3-b8ac-9e4328d73dcf + smi:local/auto + S + undecidable + + + + + smi:local/99a825ae-8aec-49ef-ba40-11ac71cd35b0 + smi:local/auto + P + undecidable + + + + + smi:local/7b7f6455-d0e0-4280-9625-e33c866073ee + smi:local/auto + S + undecidable + + + + + smi:local/bc53a146-2fc9-4508-a569-8ff4c1ef2094 + smi:local/auto + P + undecidable + + + + + smi:local/dba616e5-a02f-441d-8ac1-c420c5b4a6cc + smi:local/auto + S + undecidable + + + + + smi:local/f76e5635-2e6a-49a8-abe2-102c2d82d76a + smi:local/auto + P + undecidable + + + + + smi:local/8fc4f39f-93ce-46d1-b5da-ee7faa7a4dc3 + smi:local/auto + S + undecidable + + + + + smi:local/2fd7b9c7-48cc-4cfb-bb76-f03c2d0dc4d7 + smi:local/auto + P + undecidable + + + + + smi:local/f1130f39-3b37-45bd-b4ab-b0b31a2e680d + smi:local/auto + S + undecidable + + + + + smi:local/1f06f21a-f192-447d-bf33-af3b4c1bd560 + smi:local/auto + P + undecidable + + + + + smi:local/5abd042f-0a00-4c94-ae35-90a5a16a7a7e + smi:local/auto + S + undecidable + + + + + smi:local/8e86b125-5388-40c7-b4df-98adee9256de + smi:local/auto + P + undecidable + + + + + smi:local/25405484-0c17-4227-b1d0-172dd5712dd1 + smi:local/auto + S + undecidable + + + + + smi:local/edf46bbf-28c7-46f9-8063-0d43a7b1a518 + smi:local/auto + P + undecidable + + + + + smi:local/aba2c46e-c45a-489c-a0c0-a442e25abc65 + smi:local/auto + S + undecidable + + + + + smi:local/b3033587-fa87-439a-8d65-9fdb3e901cfd + smi:local/auto + P + undecidable + + + + + smi:local/ceb1eca1-8964-4ec7-996e-78937fbe010b + smi:local/auto + S + undecidable + + + + + smi:local/08635348-046f-41e6-aafe-2d7c2daca805 + smi:local/auto + P + undecidable + + + + + smi:local/0b593029-9a34-4200-a3a2-e18d979ef12b + smi:local/auto + S + undecidable + + + + + smi:local/8b8c39cb-d91b-41f4-8919-76639faa91c3 + smi:local/auto + P + undecidable + + + + + smi:local/9fa2de75-1099-470f-9495-2d968a5f7c4b + smi:local/auto + S + undecidable + + + + + smi:local/5df3f0b3-ff1b-47af-b59f-14e5f94271cf + smi:local/auto + P + undecidable + + + + + smi:local/a19fdbe3-7db4-4e6f-a7d2-1471b0552b78 + smi:local/auto + S + undecidable + + + + + smi:local/16a82868-af97-48c1-bf2d-a22ca0f23bae + smi:local/auto + P + undecidable + + + + + smi:local/6702aba1-ef71-4563-8e08-1159031ecd8e + smi:local/auto + S + undecidable + + + + + smi:local/8566730a-012d-42b9-962b-dc12a9667457 + smi:local/auto + P + undecidable + + + + + smi:local/0a5af15c-2c95-48d1-8b4c-014dffd44c3d + smi:local/auto + S + undecidable + + + + + smi:local/b535466e-dd65-4860-9714-8817bc8f333e + smi:local/auto + P + undecidable + + + + + smi:local/4770cfb9-8bb5-4f95-9177-1aefdf77f803 + smi:local/auto + S + undecidable + + + + + smi:local/8549d92d-07e6-4584-8165-e5b55fd7dca0 + smi:local/auto + P + undecidable + + + + + smi:local/8a975882-8f69-43ba-aab8-52ad5d0f1c9f + smi:local/auto + S + undecidable + + + + + smi:local/e464d8f0-b32f-43fe-af1f-eaad2fb73ab8 + smi:local/auto + P + undecidable + + + + + smi:local/5694b194-2670-400e-9ee4-96d1d8018f34 + smi:local/auto + S + undecidable + + + + + smi:local/c58996fa-24af-4914-acee-835ed5f92de6 + smi:local/auto + P + undecidable + + + + + smi:local/acb336f2-1bc6-4958-b13f-56cecebf5a76 + smi:local/auto + S + undecidable + + + + + smi:local/ed22c6ca-1149-4933-b5e1-ebafd7540d1f + smi:local/auto + P + undecidable + + + + + smi:local/995b2928-b5f6-42e7-8711-15910b5ed276 + smi:local/auto + S + undecidable + + + + + smi:local/1e02fe56-e2ec-49fb-8bf8-1cbee84ff4d5 + smi:local/auto + P + undecidable + + + + + smi:local/c14870e1-03f4-4dad-a45e-d5d1d86255c1 + smi:local/auto + S + undecidable + + + + + smi:local/d0bd00cb-f0a2-46be-964b-4f2ed03560a9 + smi:local/auto + P + undecidable + + + + + smi:local/c268f156-dc72-4ce0-ab96-f7f0022f4280 + smi:local/auto + S + undecidable + + + + + smi:local/9b5ef937-b8ba-4a06-bd61-159fbaec001f + smi:local/auto + P + undecidable + + + + + smi:local/f5f04a42-c36d-4641-a2c4-f0e46d4704cb + smi:local/auto + S + undecidable + + + + + smi:local/1a3de2b2-c4f2-40ee-9082-de69f750703d + smi:local/auto + P + undecidable + + + + + smi:local/7d3148e4-99c5-4b93-84a0-25031164efbe + smi:local/auto + S + undecidable + + + + + smi:local/47b0d298-8af1-4d69-b82f-5c8b5a25e467 + smi:local/auto + P + undecidable + + + + + smi:local/2e7572fc-0267-45bf-bf42-e32ec90ab134 + smi:local/auto + S + undecidable + + + + + smi:local/878c4364-e788-4c82-be0b-a0501e6515c9 + smi:local/auto + P + undecidable + + + + + smi:local/7aecba83-0f9a-4c2c-8a01-f9cd0b4b0909 + smi:local/auto + S + undecidable + + + + + smi:local/2aaa7e9c-9593-496a-9794-3cec3baee586 + smi:local/auto + P + undecidable + + + + + smi:local/46842441-47e9-47cf-9000-7470d4724eb2 + smi:local/auto + S + undecidable + + + + + smi:local/87aa5c96-a92e-45e0-af9c-a22db540ecae + smi:local/auto + P + undecidable + + + + + smi:local/dc4b5c34-e414-4529-8dba-221c9ab1b6c8 + smi:local/auto + S + undecidable + + + + + smi:local/d7596563-8df4-4d6f-b5a9-38e4ebfe6a4a + smi:local/auto + P + undecidable + + + + + smi:local/8120e3b1-afa3-466b-a2cc-d501acb1ac85 + smi:local/auto + S + undecidable + + + + + smi:local/3f22f432-9ca2-46ea-ab2b-3fd5ee6eb1f0 + smi:local/auto + P + undecidable + + + + + + + smi:local/5e2d3c5e-4f6d-4911-a478-6311ea6ccb0a + smi:local/auto + P + undecidable + + + + + smi:local/ad33bd14-01b3-4ceb-962f-452a373c2c85 + smi:local/auto + S + undecidable + + + + + smi:local/6ec0cb15-b3a8-4580-9210-999e406b9fca + smi:local/auto + P + undecidable + + + + + smi:local/0b36577d-0bb7-4b07-bcba-104b8458fc5e + smi:local/auto + S + undecidable + + + + + smi:local/d4cdc81f-fdfa-481a-be37-794e36d92c36 + smi:local/auto + P + undecidable + + + + + smi:local/e7210d36-91e1-49f8-b7dd-16fd794d049d + smi:local/auto + S + undecidable + + + + + smi:local/96e165c3-1f0f-4062-99e1-1e52e8dc4982 + smi:local/auto + P + undecidable + + + + + smi:local/88ca20cf-b960-4af1-8d92-9cf0e42a5549 + smi:local/auto + S + undecidable + + + + + smi:local/eec4a948-9b01-40c3-96ce-ba2bba093c3a + smi:local/auto + P + undecidable + + + + + smi:local/0da2a1a5-c550-43d2-86d6-955915076b56 + smi:local/auto + S + undecidable + + + + + smi:local/d4680aed-0aad-4ade-af54-d3c96b0337e3 + smi:local/auto + P + undecidable + + + + + smi:local/a80da4fd-38ed-4d8c-811c-cde3fd4f11d8 + smi:local/auto + S + undecidable + + + + + smi:local/b425db5f-6f90-4ef2-9101-daa60254a53e + smi:local/auto + P + undecidable + + + + + smi:local/b5f6529f-5517-4d65-aee6-1b2fa774accf + smi:local/auto + S + undecidable + + + + + smi:local/4d91ee49-1c45-4a81-9f8c-c516ae7cddac + smi:local/auto + P + undecidable + + + + + smi:local/deb4d199-f189-4d69-8dd3-ed0f54781575 + smi:local/auto + S + undecidable + + + + + smi:local/26ab43b6-48bf-4958-848d-921c36dcdd78 + smi:local/auto + P + undecidable + + + + + smi:local/3af3e621-7926-4845-b8cd-0cd39538c7dc + smi:local/auto + S + undecidable + + + + + smi:local/9110aa10-450c-4941-8933-a21cd588dc19 + smi:local/auto + P + undecidable + + + + + smi:local/499fcc9b-48bf-4e5d-bbf7-9621f909502f + smi:local/auto + S + undecidable + + + + + smi:local/ef3922a4-a3bb-4d26-8df1-0ad8f161fcb3 + smi:local/auto + P + undecidable + + + + + smi:local/6edaab67-aa95-4d8b-b25b-39496a4a1f91 + smi:local/auto + S + undecidable + + + + + smi:local/99b49556-3512-40e8-9b4e-b125001e7e42 + smi:local/auto + P + undecidable + + + + + smi:local/de8fde68-cfc3-4a5c-9eb4-ae9c69ad6b20 + smi:local/auto + S + undecidable + + + + + smi:local/4a9a7ba2-cb3b-4088-99ca-5bea8fa49280 + smi:local/auto + P + undecidable + + + + + smi:local/43906793-16a8-4fa7-a10e-f51733ad3711 + smi:local/auto + S + undecidable + + + + + smi:local/5d911963-3f3c-4bfe-9f25-c3be81641df5 + smi:local/auto + P + undecidable + + + + + smi:local/cacb5c24-c542-412a-863e-58ca00f86761 + smi:local/auto + S + undecidable + + + + + smi:local/10d0a2ca-5303-49bb-9c9c-d788bfedc8f4 + smi:local/auto + P + undecidable + + + + + smi:local/96234502-883e-44ad-a542-290fd45e9f5b + smi:local/auto + S + undecidable + + + + + smi:local/acb7dfba-53f8-4468-be3a-fd86d405bb51 + smi:local/auto + P + undecidable + + + + + smi:local/e187a76a-4c6e-4bf9-b4fd-a177f51d064e + smi:local/auto + S + undecidable + + + + + smi:local/98a63984-d6b7-4913-bd98-db3bc75f8d80 + smi:local/auto + P + undecidable + + + + + smi:local/d442167f-4a2d-407b-9385-00656aed98bf + smi:local/auto + S + undecidable + + + + + smi:local/5e312a05-572a-467d-9670-3379a662c83a + smi:local/auto + P + undecidable + + + + + smi:local/f2703763-3e59-4293-ad63-80669eb3fe6c + smi:local/auto + S + undecidable + + + + + smi:local/dbc95055-b2f7-4425-8475-54f4a8dd8ecf + smi:local/auto + P + undecidable + + + + + smi:local/70c1654b-595f-42f8-a041-6b73a64c31c0 + smi:local/auto + S + undecidable + + + + + smi:local/eb6e179e-c300-4155-991e-f3eeba9af273 + smi:local/auto + P + undecidable + + + + + smi:local/43300050-8648-4719-a493-7fdb0192d33a + smi:local/auto + S + undecidable + + + + + smi:local/56ba57dd-610c-4acc-95e9-505543995127 + smi:local/auto + P + undecidable + + + + + smi:local/94a75841-79e7-4ce2-bd83-c881883bce9d + smi:local/auto + S + undecidable + + + + + smi:local/0107f6a8-248a-4241-b3de-74527c010e58 + smi:local/auto + P + undecidable + + + + + smi:local/276327cf-7535-4716-9ad5-8b05e0fc1a72 + smi:local/auto + S + undecidable + + + + + smi:local/934c7ede-afda-4393-a767-59529a9bed9a + smi:local/auto + P + undecidable + + + + + smi:local/18ed445b-8c84-4a6a-a7c7-7282c26cbdc7 + smi:local/auto + S + undecidable + + + + + smi:local/6c75c02f-2437-4a19-b799-99568a3d5112 + smi:local/auto + P + undecidable + + + + + smi:local/6bce208f-b204-471a-8d9c-26909811fd58 + smi:local/auto + S + undecidable + + + + + smi:local/d1adabb5-cd5f-4224-b0b3-22c78ddf10af + smi:local/auto + P + undecidable + + + + + smi:local/082b3bb5-dda2-4ccb-8408-968e30a1f5b1 + smi:local/auto + S + undecidable + + + + + smi:local/4056c465-9626-45f2-92c0-4e923f370ad8 + smi:local/auto + P + undecidable + + + + + smi:local/4c1f307c-18d3-4e67-8cd0-2a2c51e0ad14 + smi:local/auto + S + undecidable + + + + + smi:local/1449c047-7890-4d5e-bbb1-729adf14732f + smi:local/auto + P + undecidable + + + + + smi:local/5f7ec075-6e3f-439c-9f7f-57bb1cb28c82 + smi:local/auto + S + undecidable + + + + + smi:local/c78333f0-f5ec-4239-b2aa-2f1f8c6af475 + smi:local/auto + P + undecidable + + + + + smi:local/9905f53a-dff4-46bc-bf73-36887fd8b1ef + smi:local/auto + S + undecidable + + + + + smi:local/881d537e-cfa2-4910-b532-7b145a3757ae + smi:local/auto + P + undecidable + + + + + smi:local/4e84d0d0-023e-4dc9-8362-5c3667a345af + smi:local/auto + S + undecidable + + + + + smi:local/bac98397-f160-40d0-8e64-65843ed716fa + smi:local/auto + P + undecidable + + + + + smi:local/a299b9ab-fb53-4b2f-a0c1-81a66aa560e3 + smi:local/auto + S + undecidable + + + + + smi:local/a3bf6641-6ea2-42d3-8387-bbb12b3520ae + smi:local/auto + P + undecidable + + + + + smi:local/c1e02097-7118-4d44-908b-39b5bbe85385 + smi:local/auto + S + undecidable + + + + + smi:local/5fc140e7-7c24-4dc7-981d-6abcde824a67 + smi:local/auto + P + undecidable + + + + + smi:local/b1d6f5b5-5cd7-46c6-b113-c958718b988d + smi:local/auto + S + undecidable + + + + + smi:local/ebfa8ab7-d134-4507-9d93-1d04f1730585 + smi:local/auto + P + undecidable + + + + + smi:local/e560691d-5383-41db-9ab2-6b54e8d4f955 + smi:local/auto + S + undecidable + + + + + smi:local/dfda4b94-cc05-46bb-aea7-032d876de823 + smi:local/auto + P + undecidable + + + + + smi:local/0f64af0a-8ee9-42bc-92b8-8fc859b58ced + smi:local/auto + S + undecidable + + + + + smi:local/80f56c29-8789-4f77-a9a5-047b37f5f347 + smi:local/auto + P + undecidable + + + + + smi:local/21c0cca4-21b0-4c87-b173-647f4dab4fbd + smi:local/auto + S + undecidable + + + + + smi:local/cb1483ab-3c68-490e-8e3f-4aa856f5abd5 + smi:local/auto + P + undecidable + + + + + smi:local/26734f40-7936-4910-81de-768be59b124e + smi:local/auto + S + undecidable + + + + + smi:local/e2fc07ff-30b7-452e-93bc-a1e53df71617 + smi:local/auto + P + undecidable + + + + + smi:local/4b7fd856-9508-488e-b9a4-deeb04c8db0a + smi:local/auto + S + undecidable + + + + + smi:local/fa21cc36-3929-46b6-aa5d-471297fc4614 + smi:local/auto + P + undecidable + + + + + smi:local/e2fab296-1ea2-47cd-82ce-37e4305a93e7 + smi:local/auto + S + undecidable + + + + + smi:local/37650676-93eb-4a71-91cc-bfb16b7d8036 + smi:local/auto + P + undecidable + + + + + smi:local/abff7d7d-c918-4dee-a4ab-79e37ed7b2a1 + smi:local/auto + S + undecidable + + + + + smi:local/963d8e90-0151-4b2d-81bf-058c1e4d03bc + smi:local/auto + P + undecidable + + + + + smi:local/ef7c8c89-4a34-4428-9a97-f63c7890fc0e + smi:local/auto + S + undecidable + + + + + smi:local/22ae12c8-f2d5-4468-901a-7a46cdfbf911 + smi:local/auto + P + undecidable + + + + + smi:local/d7e2e438-0d31-4f0d-834d-539b532def9b + smi:local/auto + S + undecidable + + + + + smi:local/38f1d716-eb37-43ba-bee8-72b6aeec4906 + smi:local/auto + P + undecidable + + + + + smi:local/bc027a83-225f-44ee-9508-ff5873fa8632 + smi:local/auto + S + undecidable + + + + + smi:local/eb3fc4ae-35a2-4b0a-afa1-325ddcfdc748 + smi:local/auto + P + undecidable + + + + + smi:local/b34cf7ab-dfbf-49d8-a74e-fffc885b35e0 + smi:local/auto + S + undecidable + + + + + smi:local/2dae71b8-e679-4f19-a672-30039718f9e3 + smi:local/auto + P + undecidable + + + + + smi:local/49580121-1d02-409c-b73e-aad2df80af71 + smi:local/auto + S + undecidable + + + + + smi:local/804f3a8c-b0c2-40b9-9768-2ab06e8a997c + smi:local/auto + P + undecidable + + + + + smi:local/030b49e3-d262-49bc-b8b6-0aea92895d26 + smi:local/auto + S + undecidable + + + + + smi:local/0e853518-58b2-48f4-a3ec-334f67d44a7f + smi:local/auto + P + undecidable + + + + + smi:local/8d230d84-a037-47d7-868f-577af3212c8a + smi:local/auto + S + undecidable + + + + + smi:local/c554ea9e-ec3c-48cf-8255-c980db534386 + smi:local/auto + P + undecidable + + + + + smi:local/af253484-97f7-4c4a-ae6f-e0d1648f6535 + smi:local/auto + S + undecidable + + + + + smi:local/f71f1736-ff63-4d1c-a49e-b1d7b742c1d2 + smi:local/auto + P + undecidable + + + + + smi:local/a90a972e-dbc3-4192-8e27-6d2f7bd5a2ab + smi:local/auto + S + undecidable + + + + + smi:local/f74d81f3-5697-4116-b6fc-4298fd525a67 + smi:local/auto + P + undecidable + + + + + smi:local/f1e6af43-5e86-4c61-9dcb-c92e458dbbd2 + smi:local/auto + S + undecidable + + + + + smi:local/7cd040dc-c553-4856-b8ca-df5393006d74 + smi:local/auto + P + undecidable + + + + + smi:local/839d4a7c-6d14-4eec-b31b-2a6d9031af80 + smi:local/auto + S + undecidable + + + + + smi:local/4799e2bb-a06d-4550-a8be-26ae50578c7b + smi:local/auto + P + undecidable + + + + + smi:local/5e000115-1606-4de9-ac7f-c7f41446619d + smi:local/auto + S + undecidable + + + + + smi:local/a51db7a1-0629-45f0-8c86-0f270dc6b2bb + smi:local/auto + P + undecidable + + + + + smi:local/d3382378-b425-4ef1-a978-f386a6230220 + smi:local/auto + S + undecidable + + + + + smi:local/5ddb39a2-095e-4464-b1d8-3821d2648fbb + smi:local/auto + P + undecidable + + + + + smi:local/fe5a8100-5a5f-4fee-854d-4ece9edefe8c + smi:local/auto + S + undecidable + + + + + smi:local/8e4bbca4-c027-435b-83c9-767f85b7b745 + smi:local/auto + P + undecidable + + + + + smi:local/bb2c6b42-2387-419b-8d35-f3199728022d + smi:local/auto + S + undecidable + + + + + smi:local/846a13df-6aae-405b-93a2-0eeed595e79b + smi:local/auto + P + undecidable + + + + + smi:local/01e29e13-3855-4e2f-b0ed-57c4723530cf + smi:local/auto + S + undecidable + + + + + smi:local/e3899950-4131-484c-9701-82f8ab5515fb + smi:local/auto + P + undecidable + + + + + smi:local/f161063e-2a03-4ba8-88af-a95595ec91dd + smi:local/auto + S + undecidable + + + + + smi:local/c0e37219-6211-4a44-877c-23c5f1f670e4 + smi:local/auto + P + undecidable + + + + + smi:local/cd4ea466-17c8-4c81-9f31-c12007955a3c + smi:local/auto + S + undecidable + + + + + smi:local/13c24fe9-16fc-4afe-8cb8-b119d17b656b + smi:local/auto + P + undecidable + + + + + smi:local/f4a3efbc-7601-424f-9b98-20cd59262f5d + smi:local/auto + S + undecidable + + + + + smi:local/b686fbe0-69ad-456b-a42e-94bab5c842aa + smi:local/auto + P + undecidable + + + + + smi:local/d0f010cc-a358-4afe-8399-c439b436af3c + smi:local/auto + S + undecidable + + + + + smi:local/3ed7477c-aa64-4105-a340-156187b681f9 + smi:local/auto + P + undecidable + + + + + smi:local/d74f2237-e6b6-4324-85dc-1afcf26bc207 + smi:local/auto + S + undecidable + + + + + smi:local/fe0c3456-1d8e-47f8-8397-9832799b609e + smi:local/auto + P + undecidable + + + + + smi:local/127e9b8e-1575-4cfc-a459-f9e2ef5d2c80 + smi:local/auto + S + undecidable + + + + + smi:local/c83e6a91-f4bd-418f-aad7-b583bb444c39 + smi:local/auto + P + undecidable + + + + + smi:local/164a20dc-878a-405e-b7f6-99a0b66cbcd2 + smi:local/auto + S + undecidable + + + + + smi:local/aa6832d4-c5ca-47c2-8439-269922e106f8 + smi:local/auto + P + undecidable + + + + + smi:local/70017345-eff7-4b65-8bc0-ebea6acaff1f + smi:local/auto + S + undecidable + + + + + smi:local/20bb5d52-80e1-43ff-b559-0570cd06c4e5 + smi:local/auto + P + undecidable + + + + + smi:local/91167170-7145-4aa3-9b73-b42cffa96c64 + smi:local/auto + S + undecidable + + + + + smi:local/1cdd0a93-d00e-4c20-9730-3e9d08d9f62d + smi:local/auto + P + undecidable + + + + + smi:local/d7975660-324b-44b6-916b-5e7543bde97d + smi:local/auto + S + undecidable + + + + + smi:local/08b11ce1-dc5f-40b0-ab6e-ad066008ec7d + smi:local/auto + P + undecidable + + + + + smi:local/62b29ae2-f990-490f-a8f8-b4a327aa0a94 + smi:local/auto + S + undecidable + + + + + smi:local/d673a80a-ce02-4f30-b067-8d0447aa77c0 + smi:local/auto + P + undecidable + + + + + smi:local/ca004f03-43e2-48ce-b446-1c19571dd3eb + smi:local/auto + S + undecidable + + + + + smi:local/953e6f90-1690-4986-8104-691db1d56bc4 + smi:local/auto + P + undecidable + + + + + smi:local/d410f0b3-04a1-43b8-ba2b-6bfbe1dba531 + smi:local/auto + S + undecidable + + + + + smi:local/4d5b042a-14e0-44a6-a2cc-1326b259ad3a + smi:local/auto + P + undecidable + + + + + smi:local/827a5dc2-98ad-44f0-beca-b3d9a2e474eb + smi:local/auto + S + undecidable + + + + + smi:local/bab385c4-71c7-42b9-b76f-c1117970ce65 + smi:local/auto + P + undecidable + + + + + smi:local/60cdc66c-820f-4029-b918-9fd86b96435b + smi:local/auto + S + undecidable + + + + + smi:local/f8de2ed7-f4e4-4778-b0a7-b970aad8adec + smi:local/auto + P + undecidable + + + + + smi:local/c54f93c6-0ff6-43b1-a884-2aadb0d2b5f0 + smi:local/auto + S + undecidable + + + + + smi:local/0ddcbce5-04d0-40db-a05d-a95da3fb0340 + smi:local/auto + P + undecidable + + + + + smi:local/f5200547-42fa-4d48-85fc-ef73a0a5987a + smi:local/auto + S + undecidable + + + + + smi:local/fe38d7e0-c09f-4253-b8f6-4312bccc28ef + smi:local/auto + P + undecidable + + + + + smi:local/a3e06721-4237-4ed0-9e2e-78f784105a7a + smi:local/auto + S + undecidable + + + + + smi:local/8d918226-2b8c-4536-bb38-d4f69baa5aa9 + smi:local/auto + P + undecidable + + + + + smi:local/c4605c48-10f7-4cbd-956d-2f26afed56c7 + smi:local/auto + S + undecidable + + + + + smi:local/ff618844-6754-404c-a64b-2e377bc84e2e + smi:local/auto + P + undecidable + + + + + smi:local/66da2e59-281f-4586-91b1-3d5744c88fc2 + smi:local/auto + S + undecidable + + + + + smi:local/a17d977f-0942-4929-9d2f-16790e2287e7 + smi:local/auto + P + undecidable + + + + + smi:local/10e2fc85-6209-4c0a-8893-de84e025b183 + smi:local/auto + S + undecidable + + + + + smi:local/3e58138a-9dbe-4dfe-a1d8-d50b5f160703 + smi:local/auto + P + undecidable + + + + + smi:local/6bc32664-acbc-4d6e-828c-ee4d88aee05c + smi:local/auto + S + undecidable + + + + + smi:local/c816d453-d211-4a37-be4a-8e8fb7515532 + smi:local/auto + P + undecidable + + + + + smi:local/50bd34a8-28d3-49f4-8e96-ec998cc2f1f4 + smi:local/auto + S + undecidable + + + + + smi:local/7c1a5cb7-cc23-4f47-b9f2-cf08e95bac1e + smi:local/auto + P + undecidable + + + + + smi:local/0fe8e892-b8cd-481d-aea8-68c5431d8ca8 + smi:local/auto + S + undecidable + + + + + smi:local/910e23a6-0f6b-47d4-9cc5-b5b0885f9dd3 + smi:local/auto + P + undecidable + + + + + smi:local/90fb8b3c-7f27-4f3a-901b-2e63b2bc4b18 + smi:local/auto + S + undecidable + + + + + smi:local/c791b086-738f-43e2-a762-5c8d01d6a584 + smi:local/auto + P + undecidable + + + + + smi:local/1975e303-cc58-4558-b9fc-0835504a5c5b + smi:local/auto + S + undecidable + + + + + smi:local/adccd277-cbe3-47e6-9671-142ecf566ebc + smi:local/auto + P + undecidable + + + + + smi:local/3e300ec2-5b2f-4933-9830-a2ef1a3f457a + smi:local/auto + S + undecidable + + + + + smi:local/4b44ebc5-c099-402f-bcf9-7f0fcf7cdec1 + smi:local/auto + P + undecidable + + + + + smi:local/3a20dcea-fc36-4f75-816d-acff3c11419d + smi:local/auto + S + undecidable + + + + + smi:local/a890e6aa-3a94-4318-a48a-c04e57c280a2 + smi:local/auto + P + undecidable + + + + + smi:local/12ec7893-3721-4ec2-9ecb-bdbcfd3415cf + smi:local/auto + S + undecidable + + + + + smi:local/492fbd91-0d7b-40a2-894a-bd2d961a168f + smi:local/auto + P + undecidable + + + + + smi:local/26ab8ad8-8f0e-4946-9405-b7e0deef9d9a + smi:local/auto + S + undecidable + + + + + smi:local/8c9410c9-3bb1-4b46-9cb5-cb153544e900 + smi:local/auto + P + undecidable + + + + + smi:local/a031ca5a-c3b8-44fa-8c86-9086cb433f7b + smi:local/auto + S + undecidable + + + + + smi:local/3c36b4a0-009a-44ac-8728-79189fee435c + smi:local/auto + P + undecidable + + + + + smi:local/e56f0b6c-c854-4e58-b48a-88ee36baccf2 + smi:local/auto + S + undecidable + + + + + smi:local/d3c408d2-8c01-47aa-9412-1f6c1fe559a0 + smi:local/auto + P + undecidable + + + + + smi:local/620093d4-c50f-4cf0-90de-71c9490a1d76 + smi:local/auto + S + undecidable + + + + + smi:local/2c1f6a9c-8450-4a75-8ff1-ad8ab4483043 + smi:local/auto + P + undecidable + + + + + smi:local/e5ba1357-6443-4377-a96b-444687214ff9 + smi:local/auto + S + undecidable + + + + + smi:local/9ecf08d3-c7a0-44cc-aec1-bd31b36e44f7 + smi:local/auto + P + undecidable + + + + + smi:local/b4a0a0cb-d2e7-4508-b3d7-0ffd3e14e87d + smi:local/auto + S + undecidable + + + + + smi:local/77616019-a287-4bae-b862-db8f525e3380 + smi:local/auto + P + undecidable + + + + + smi:local/1f3b4ce7-42b8-4537-9d66-98f293edda9a + smi:local/auto + S + undecidable + + + + + smi:local/93474a64-431d-4b72-96d3-9d7bdb0b684a + smi:local/auto + P + undecidable + + + + + smi:local/6fa2f8ec-633e-4aa7-bd61-835d1ffa9ec3 + smi:local/auto + S + undecidable + + + + + smi:local/a94e41ad-8aa4-40a7-9e45-e5d0310e3e96 + smi:local/auto + P + undecidable + + + + + smi:local/e5b1c16b-ab6b-4e8a-a0d8-83ee61a46620 + smi:local/auto + S + undecidable + + + + + smi:local/944d0a24-a735-4737-8fd4-35c6168f3541 + smi:local/auto + P + undecidable + + + + + smi:local/44741199-3cc5-465c-9d4b-713c9037e508 + smi:local/auto + S + undecidable + + + + + smi:local/c016f5a3-bfdb-4d59-8b3d-1bac5b3567aa + smi:local/auto + P + undecidable + + + + + smi:local/181949fc-16d0-4d38-9f6a-142ba644412b + smi:local/auto + S + undecidable + + + + + smi:local/359020cf-6d92-4964-9a2b-27708a29119d + smi:local/auto + P + undecidable + + + + + smi:local/58683b2c-21be-4249-bd25-f64734d6cbfe + smi:local/auto + S + undecidable + + + + + smi:local/3e24a91d-fa60-4ba5-893f-ca937d355cbd + smi:local/auto + P + undecidable + + + + + smi:local/692a5949-886d-44b1-ae01-d61ababbdb87 + smi:local/auto + S + undecidable + + + + + smi:local/d5c9b2a1-8906-40e3-b612-218cbbcab392 + smi:local/auto + P + undecidable + + + + + smi:local/61ad09e7-3e45-4139-b71c-81eeb464232f + smi:local/auto + S + undecidable + + + + + smi:local/a69bb9f0-1787-4efe-8bfc-407779e6e14c + smi:local/auto + P + undecidable + + + + + smi:local/a6c25970-6031-4948-b186-6d7e675cc447 + smi:local/auto + S + undecidable + + + + + smi:local/571b475c-5ca0-4a8a-b52b-1f826ad5d87e + smi:local/auto + P + undecidable + + + + + smi:local/80af1a3e-ff88-4920-a574-73df84d4efc0 + smi:local/auto + S + undecidable + + + + + smi:local/d2f6c3fa-164e-4bc6-ae6d-bad274ff066b + smi:local/auto + P + undecidable + + + + + smi:local/392bc269-060c-487d-8089-4e7a49645df7 + smi:local/auto + S + undecidable + + + + + smi:local/ed48935f-277b-4406-b0e9-d2e1211040d3 + smi:local/auto + P + undecidable + + + + + smi:local/732a781b-95f3-43a0-a064-b6d53ae39728 + smi:local/auto + S + undecidable + + + + + smi:local/8d7cc294-2e33-488c-9972-28285e44dded + smi:local/auto + P + undecidable + + + + + smi:local/d2094007-43c0-430e-8b92-52c8784abe50 + smi:local/auto + S + undecidable + + + + + smi:local/3afababd-7f6b-4f7f-80b4-5c51a8dc8e9f + smi:local/auto + P + undecidable + + + + + smi:local/142f8f50-15f0-4921-a327-f7d5ce62d794 + smi:local/auto + S + undecidable + + + + + smi:local/c6d22dc4-b8f4-4d80-a30f-78e64a9d0c45 + smi:local/auto + P + undecidable + + + + + smi:local/c4806cb3-d67c-4b3e-8202-6cbd8f8e6e8c + smi:local/auto + S + undecidable + + + + + smi:local/bc53b61d-6a32-4054-9ea5-cafb3e735009 + smi:local/auto + P + undecidable + + + + + smi:local/a4c0a2b2-49cf-410d-bc63-6aef7f33cd29 + smi:local/auto + S + undecidable + + + + + smi:local/dda0f7d6-e605-4fba-abfc-10fac9b10d28 + smi:local/auto + P + undecidable + + + + + smi:local/9cc8d0d4-059c-4398-aaa6-f8bd5909a03b + smi:local/auto + S + undecidable + + + + + smi:local/a1faea25-9348-424e-9c35-410a941ef75c + smi:local/auto + P + undecidable + + + + + smi:local/14d00f52-437c-40a8-84e3-961f9d34f151 + smi:local/auto + S + undecidable + + + + + smi:local/b9ab1f78-e449-4aaa-93b9-3646e2441942 + smi:local/auto + P + undecidable + + + + + smi:local/117b83dc-6f46-4ff1-84eb-107f4a624f94 + smi:local/auto + S + undecidable + + + + + smi:local/3d1967c6-4c3e-48be-aa4e-15770b45e350 + smi:local/auto + P + undecidable + + + + + smi:local/4053b59f-ff8e-41f9-bb7a-70e17ceb64dc + smi:local/auto + S + undecidable + + + + + smi:local/64849bfd-1af3-47c2-a34e-dc23c5c4be16 + smi:local/auto + P + undecidable + + + + + smi:local/d06c3115-900e-4585-bfdf-75339ac8bcb0 + smi:local/auto + S + undecidable + + + + + smi:local/632fdfe0-8400-457e-ab44-ee4f31cd768a + smi:local/auto + P + undecidable + + + + + smi:local/9bd97573-415c-44dc-b113-e4dc57b03a28 + smi:local/auto + S + undecidable + + + + + smi:local/370ff0e0-8054-41bf-b304-502fac28881d + smi:local/auto + P + undecidable + + + + + + + smi:local/2539f57e-3fe9-4bbe-8f46-2a757b70b251 + smi:local/auto + P + undecidable + + + + + smi:local/eb919ab2-c108-4b95-bfc9-72bb4788d705 + smi:local/auto + S + undecidable + + + + + smi:local/ce2f86e5-323d-4a08-bc6b-54fd43a4ef4d + smi:local/auto + P + undecidable + + + + + smi:local/6b7ab95b-1d8a-4138-88a8-402a0e70c942 + smi:local/auto + S + undecidable + + + + + smi:local/2b9137d5-1547-4b63-8cf2-158346c41550 + smi:local/auto + P + undecidable + + + + + smi:local/92fac525-3bfd-45a5-96c2-261702d3b517 + smi:local/auto + S + undecidable + + + + + smi:local/fa768264-33bf-46fd-b575-8024e17b8ed6 + smi:local/auto + P + undecidable + + + + + smi:local/65f6c154-5c21-4f83-ae0d-e1e3adbc5bb6 + smi:local/auto + S + undecidable + + + + + smi:local/1d3b96ee-6c3a-45e7-b3a9-9838f053503f + smi:local/auto + P + undecidable + + + + + smi:local/fcaac6b5-df24-4bb1-a43e-3616eb8b428e + smi:local/auto + S + undecidable + + + + + smi:local/93d41077-3b30-4598-8d3c-5abcc882db9d + smi:local/auto + P + undecidable + + + + + smi:local/013f4fde-69f3-4cb4-a7e8-3931504fef1c + smi:local/auto + S + undecidable + + + + + smi:local/54b713b6-b23b-4ee7-9e6e-d5636edd986f + smi:local/auto + P + undecidable + + + + + smi:local/5a8c90df-9642-401a-9da2-9c19088907b0 + smi:local/auto + S + undecidable + + + + + smi:local/4baccc73-5823-46ba-82fb-1d4e5b1cc744 + smi:local/auto + P + undecidable + + + + + smi:local/ef455b60-9e84-45f4-b87a-1ced42b8715d + smi:local/auto + S + undecidable + + + + + smi:local/31d35c19-f0a8-473e-bc88-34f01c491b41 + smi:local/auto + P + undecidable + + + + + smi:local/a953b210-81f4-4d80-96f3-13b4b25a9562 + smi:local/auto + S + undecidable + + + + + smi:local/b1bd3ea2-25ad-41c8-8f15-31471ea37c20 + smi:local/auto + P + undecidable + + + + + smi:local/a7c6d2cc-83a1-41e2-9833-16f8009318ea + smi:local/auto + S + undecidable + + + + + smi:local/67d7e39f-18c5-497c-ab12-13ba22987ff3 + smi:local/auto + P + undecidable + + + + + smi:local/85e6df4e-5985-4686-b2e9-a32f256c579f + smi:local/auto + S + undecidable + + + + + smi:local/2c75ed7f-0da4-4e76-ad93-0b267bc1561b + smi:local/auto + P + undecidable + + + + + smi:local/870b827a-dace-4630-8c50-627a59e47faa + smi:local/auto + S + undecidable + + + + + smi:local/e96bbaea-4c57-475a-ac77-103c1502bb2d + smi:local/auto + P + undecidable + + + + + smi:local/085bcdce-7973-4f5c-bd34-4de43bd53aab + smi:local/auto + S + undecidable + + + + + smi:local/9468d644-6ae4-476e-ac2c-98118be0bee0 + smi:local/auto + P + undecidable + + + + + smi:local/29a09990-1116-4127-857a-8e0bc4f0e29d + smi:local/auto + S + undecidable + + + + + smi:local/e2c16a9f-ab7e-4dfb-99d1-67fa7d11360c + smi:local/auto + P + undecidable + + + + + smi:local/0ebe98dd-f649-4d77-a5ab-02bb77a57ade + smi:local/auto + S + undecidable + + + + + smi:local/9052d374-02d1-42ed-b913-2dc92f64e0fc + smi:local/auto + P + undecidable + + + + + smi:local/b1c263e2-94ad-4947-90ed-d4159a947984 + smi:local/auto + S + undecidable + + + + + smi:local/1c4eb4b9-e8da-486f-b6a3-6bdf9464eed8 + smi:local/auto + P + undecidable + + + + + smi:local/8f365083-2c6a-4868-a7d8-841203908063 + smi:local/auto + S + undecidable + + + + + smi:local/010448b9-87f3-4443-a3df-b45acc74ff2a + smi:local/auto + P + undecidable + + + + + smi:local/ab01f577-2fd9-4361-9c51-253abd453455 + smi:local/auto + S + undecidable + + + + + smi:local/e32eb78f-a442-4a8a-944e-e56c57dab5a3 + smi:local/auto + P + undecidable + + + + + smi:local/0a650e0c-bcb3-4101-8e4e-258f242b8a08 + smi:local/auto + S + undecidable + + + + + smi:local/c2b1f993-eda5-4ca0-8e12-b7ccbcdd9d28 + smi:local/auto + P + undecidable + + + + + smi:local/303b04ab-ca72-4b7a-bc4a-4f3fa9649b24 + smi:local/auto + S + undecidable + + + + + smi:local/b9c245ff-b2b1-440a-a0bf-1a8b3c199afe + smi:local/auto + P + undecidable + + + + + smi:local/b70ee478-6a22-46ac-b9df-7777c297dfd7 + smi:local/auto + S + undecidable + + + + + smi:local/68673670-68b8-40ae-9a7f-b70e5cfd42a8 + smi:local/auto + P + undecidable + + + + + smi:local/6059e1bc-2431-4e9b-a048-258b1d8f363b + smi:local/auto + S + undecidable + + + + + smi:local/30c9096e-5672-4912-80fa-49c9c1907348 + smi:local/auto + P + undecidable + + + + + smi:local/557bfcad-3d4c-4586-9f20-f8104097db9a + smi:local/auto + S + undecidable + + + + + smi:local/92371831-b8f2-4fd1-b87e-e71ef9b9fd34 + smi:local/auto + P + undecidable + + + + + smi:local/0b97927a-fd0f-4b1f-8da5-da51918f762c + smi:local/auto + S + undecidable + + + + + smi:local/d03f87a8-0f5f-46da-89ee-0a19b6806c60 + smi:local/auto + P + undecidable + + + + + smi:local/d1152b6e-f664-4b96-b490-5dd43efa045c + smi:local/auto + S + undecidable + + + + + smi:local/0b7b8403-321e-4b68-9e1f-0b3146a5d763 + smi:local/auto + P + undecidable + + + + + smi:local/b3585caf-c388-48ca-8acb-393457649ff0 + smi:local/auto + S + undecidable + + + + + smi:local/60b8a6c7-6caf-4c3b-9cf9-f02ec9a66130 + smi:local/auto + P + undecidable + + + + + smi:local/ba84a088-a29d-4192-96ea-44c365b687f8 + smi:local/auto + S + undecidable + + + + + smi:local/1fd3caae-efc0-42cd-82c0-8e1ec19b3a0a + smi:local/auto + P + undecidable + + + + + smi:local/0e728ccd-8210-4cc5-8ebb-ab0ea469830d + smi:local/auto + S + undecidable + + + + + smi:local/c0853da0-8b0b-4868-96ec-7210acd1f0aa + smi:local/auto + P + undecidable + + + + + smi:local/7af950a1-0906-4245-b2c5-fa4caea0d038 + smi:local/auto + S + undecidable + + + + + smi:local/99f82cca-5a3f-4199-b09b-7d49d73560b7 + smi:local/auto + P + undecidable + + + + + smi:local/972490fe-047a-4d75-9f18-f70b824462a2 + smi:local/auto + S + undecidable + + + + + smi:local/dc248319-374b-491d-8485-fdc7ecc836fe + smi:local/auto + P + undecidable + + + + + smi:local/ffba9475-c43f-45b0-b8c2-09c807014109 + smi:local/auto + S + undecidable + + + + + smi:local/dd19b464-26f6-42e2-963b-1d75f5053e9f + smi:local/auto + P + undecidable + + + + + smi:local/dbfd4101-4a7c-4fd6-a14a-4dc701a71c85 + smi:local/auto + S + undecidable + + + + + smi:local/fca1cd28-a5bd-4101-9f71-1e24e065f80c + smi:local/auto + P + undecidable + + + + + smi:local/3961d6ec-7fe0-4dc8-9d42-2b80315210ec + smi:local/auto + S + undecidable + + + + + smi:local/087372fc-3d7a-4e73-99b7-ba27f91fd1e8 + smi:local/auto + P + undecidable + + + + + smi:local/bda3ccaa-f560-4a89-b18e-c5c7ce523e9d + smi:local/auto + S + undecidable + + + + + smi:local/a498e5b2-282f-44fd-a9fe-356d6de37335 + smi:local/auto + P + undecidable + + + + + smi:local/376f44ff-543e-4a0f-bbfd-ae59891ca907 + smi:local/auto + S + undecidable + + + + + smi:local/def21f5f-5487-47c9-8864-7477ad84202a + smi:local/auto + P + undecidable + + + + + smi:local/fabcdea2-3366-4eb7-9f87-2f36237341df + smi:local/auto + S + undecidable + + + + + smi:local/ca844469-03dc-4854-97de-9312c319ad7d + smi:local/auto + P + undecidable + + + + + smi:local/b5c00d7b-bb28-4366-ac86-e737847321ff + smi:local/auto + S + undecidable + + + + + smi:local/233ad8f0-3184-49d4-b856-f1d6308b166f + smi:local/auto + P + undecidable + + + + + smi:local/3d99e2df-9323-4a2d-95ce-f96b1632cef8 + smi:local/auto + S + undecidable + + + + + smi:local/ce892a7c-c22b-4e2f-b6e3-bd8d8570f534 + smi:local/auto + P + undecidable + + + + + smi:local/3e435132-05b0-49ff-89b4-a525ed927576 + smi:local/auto + S + undecidable + + + + + smi:local/685f7452-d87c-4fc4-9a6f-c51ed701c75c + smi:local/auto + P + undecidable + + + + + smi:local/947c5cf1-35be-41c3-bcad-4fdb456f865f + smi:local/auto + S + undecidable + + + + + smi:local/8b1c88d5-1312-431b-827f-87c4981c2665 + smi:local/auto + P + undecidable + + + + + smi:local/97c49821-9e39-447c-b3ba-00002f4472c8 + smi:local/auto + S + undecidable + + + + + smi:local/ceaac0df-d9e4-4822-a4c8-23acb1e47802 + smi:local/auto + P + undecidable + + + + + smi:local/25c2c132-f23b-468e-9abb-259924dc32c7 + smi:local/auto + S + undecidable + + + + + smi:local/586d3316-a177-4636-b68d-64339e601066 + smi:local/auto + P + undecidable + + + + + smi:local/6a6d3e17-a6a1-489c-9a17-efd2353a8d37 + smi:local/auto + S + undecidable + + + + + smi:local/fcdb9909-4214-4a41-b2b6-3b3eb7ac980d + smi:local/auto + P + undecidable + + + + + smi:local/04c5ab5c-fcca-4093-b631-bebf802f6f1d + smi:local/auto + S + undecidable + + + + + smi:local/91e3631f-31af-4f0f-ac9b-81f8034813ac + smi:local/auto + P + undecidable + + + + + smi:local/5cf0ea0b-cd1a-4181-9cf6-faec1f67b7e3 + smi:local/auto + S + undecidable + + + + + smi:local/b596c10c-532a-4f39-9581-d2555a90c92a + smi:local/auto + P + undecidable + + + + + smi:local/8d6910ec-a1ca-4986-8910-70dfd3599061 + smi:local/auto + S + undecidable + + + + + smi:local/33bcba59-d3d5-45aa-8f8c-a95a5cc071df + smi:local/auto + P + undecidable + + + + + smi:local/08653fe6-f8f9-4174-a4ae-0c9d5e6c09ff + smi:local/auto + S + undecidable + + + + + smi:local/389bc37b-67c3-46ff-a7a7-b2af5dfded98 + smi:local/auto + P + undecidable + + + + + smi:local/dfec16f2-4eef-4d22-87e2-f300170fb843 + smi:local/auto + S + undecidable + + + + + smi:local/c4336efe-2bcc-4692-896b-7917b78b979b + smi:local/auto + P + undecidable + + + + + smi:local/f8ebef8c-7639-4dfd-81d2-99f5ebff57af + smi:local/auto + S + undecidable + + + + + smi:local/b3548911-6227-4d9c-9593-1935282a9d32 + smi:local/auto + P + undecidable + + + + + smi:local/0307b213-3019-4091-9bb5-0461cf4e7f15 + smi:local/auto + S + undecidable + + + + + smi:local/5ad760cd-ae24-4690-ad06-1c2ac25946fd + smi:local/auto + P + undecidable + + + + + smi:local/91223370-d185-4c6b-bf97-f46040fc6be8 + smi:local/auto + S + undecidable + + + + + smi:local/b39a401c-08e4-49d2-8b49-9efa6377c22d + smi:local/auto + P + undecidable + + + + + smi:local/5bb1e798-a0e1-4407-bdc5-a3decb1bf1cb + smi:local/auto + S + undecidable + + + + + smi:local/d5e3a6fa-71bc-4005-ad63-886f4e2216b2 + smi:local/auto + P + undecidable + + + + + smi:local/300893f9-1a52-47f7-a04f-9e5c03653c16 + smi:local/auto + S + undecidable + + + + + smi:local/88384d05-a5cd-4a9b-80a7-8e4ccbf32fb9 + smi:local/auto + P + undecidable + + + + + smi:local/5cad9a4f-e788-4caf-8359-c033ca6c4c0a + smi:local/auto + S + undecidable + + + + + smi:local/96c07071-bba2-4c88-8a09-49018eba4764 + smi:local/auto + P + undecidable + + + + + smi:local/e67aef05-f5e1-4ff0-8299-db049569685b + smi:local/auto + S + undecidable + + + + + smi:local/a16bed08-a60e-4351-aef5-7a589ff29c33 + smi:local/auto + P + undecidable + + + + + smi:local/1e22c1ea-6618-43ed-ba26-61aae5ec775c + smi:local/auto + S + undecidable + + + + + smi:local/8733162c-c44c-4fe8-802a-f30176fc00e3 + smi:local/auto + P + undecidable + + + + + smi:local/e06b27e8-c070-4181-b80c-91e98f493437 + smi:local/auto + S + undecidable + + + + + smi:local/00be3b94-ff9e-40d3-b660-f23f2a10567e + smi:local/auto + P + undecidable + + + + + smi:local/c5aa2750-0e09-4f72-aa69-c248ed800e58 + smi:local/auto + S + undecidable + + + + + smi:local/ea83e045-463d-4f64-ab65-fb3d118e674c + smi:local/auto + P + undecidable + + + + + smi:local/6a6a8077-b0fd-40d6-b746-96ec302a558c + smi:local/auto + S + undecidable + + + + + smi:local/90a62fd4-2f0f-45b9-b0b3-c111d01d13db + smi:local/auto + P + undecidable + + + + + smi:local/5079e163-8054-4ee4-ae43-19da4481a4f5 + smi:local/auto + S + undecidable + + + + + smi:local/b7bac492-08ad-4615-a493-fe73c97b6fa1 + smi:local/auto + P + undecidable + + + + + smi:local/6eb620a7-0060-4fef-99c3-fb325a39900f + smi:local/auto + S + undecidable + + + + + smi:local/f5280da7-411e-4c6e-ac51-84bd828a1241 + smi:local/auto + P + undecidable + + + + + smi:local/2d7cfb25-1cbe-462b-a36b-b3960df4f97a + smi:local/auto + S + undecidable + + + + + smi:local/5a982ad5-307d-43d3-88da-5d235200b91b + smi:local/auto + P + undecidable + + + + + smi:local/71ccc225-d150-4995-b4c2-b3488cbade07 + smi:local/auto + S + undecidable + + + + + smi:local/c0601eb1-7fcd-4dbf-a50d-80a27b413057 + smi:local/auto + P + undecidable + + + + + smi:local/0b8825dd-d251-46dc-aa27-3ca98ce87d61 + smi:local/auto + S + undecidable + + + + + smi:local/cfddad0a-628f-4a3d-b09b-41f5a1a7a83d + smi:local/auto + P + undecidable + + + + + smi:local/7ed94216-2b71-4918-a8b1-aec8427003a5 + smi:local/auto + S + undecidable + + + + + smi:local/3add12f0-0588-44b8-aef3-2f73b2f16205 + smi:local/auto + P + undecidable + + + + + smi:local/730c249a-2851-4dbd-82f1-d9896fbb70cc + smi:local/auto + S + undecidable + + + + + smi:local/50d896c2-a1bc-42bf-80f3-6ad80cb7d93c + smi:local/auto + P + undecidable + + + + + smi:local/c0e36183-912d-4856-b66c-da30dbedf60d + smi:local/auto + S + undecidable + + + + + smi:local/abd93360-d41d-4d5a-85e9-c29c974375c9 + smi:local/auto + P + undecidable + + + + + smi:local/052b2787-b03d-469a-aa4c-8fe90b18b8dd + smi:local/auto + S + undecidable + + + + + smi:local/b0a6acf8-f41e-48cc-a7e4-d321e8a8360f + smi:local/auto + P + undecidable + + + + + smi:local/a4a04bd3-ee98-463c-adfc-c1a7dff3ce25 + smi:local/auto + S + undecidable + + + + + smi:local/ded6b9d4-b123-4c4f-b1d4-ab03727fd024 + smi:local/auto + P + undecidable + + + + + smi:local/ee02e0b7-96f0-4d70-a5ea-10ee2fcd20d5 + smi:local/auto + S + undecidable + + + + + smi:local/855a555a-ad1b-475e-b867-091e99f9138d + smi:local/auto + P + undecidable + + + + + smi:local/677aa5ff-9524-4fba-b08d-a2c2c43686f2 + smi:local/auto + S + undecidable + + + + + smi:local/e6e1594d-12da-43d7-bbe8-c867a385eaa0 + smi:local/auto + P + undecidable + + + + + smi:local/a668e79a-cf46-49cf-a375-6a897feeab4f + smi:local/auto + S + undecidable + + + + + smi:local/6a762f9a-f4df-4d89-9bcf-58d548a38236 + smi:local/auto + P + undecidable + + + + + smi:local/de090161-429c-4c33-af83-7ac062160f39 + smi:local/auto + S + undecidable + + + + + smi:local/de9937a1-ffca-4814-9551-82e20728dfa5 + smi:local/auto + P + undecidable + + + + + smi:local/7da1728d-0da4-4c88-8b4d-aaa4c72290d0 + smi:local/auto + S + undecidable + + + + + smi:local/ebd46604-358d-4701-84ba-10b05706d947 + smi:local/auto + P + undecidable + + + + + smi:local/c247cc80-6d7e-48e3-85d4-66b5e04b8f6c + smi:local/auto + S + undecidable + + + + + smi:local/e4f17cde-81e8-4a21-8128-fc582d0c9db5 + smi:local/auto + P + undecidable + + + + + smi:local/dd258c26-8d7c-4ac0-bfae-676d74aaafe3 + smi:local/auto + S + undecidable + + + + + smi:local/228e9f1e-ede2-4293-9e3e-e0491f8f7a9a + smi:local/auto + P + undecidable + + + + + smi:local/58498c1f-3369-4ed4-a53a-d659f5c48939 + smi:local/auto + S + undecidable + + + + + smi:local/979ffff3-b5da-4f05-bb06-e38708bce964 + smi:local/auto + P + undecidable + + + + + smi:local/b362dfe7-a308-47a7-b1fc-5e2c75650842 + smi:local/auto + S + undecidable + + + + + smi:local/14f0cc84-6965-4bcf-b039-90e2496e6a36 + smi:local/auto + P + undecidable + + + + + smi:local/2b5c23b1-7da5-4a1b-99a1-1f0eedf1ac3e + smi:local/auto + S + undecidable + + + + + smi:local/f5994976-d1da-4d87-a479-a7f3099bb08d + smi:local/auto + P + undecidable + + + + + smi:local/27e7422d-eadd-43dd-a14c-628dec85ee23 + smi:local/auto + S + undecidable + + + + + smi:local/f949e7fd-848f-4114-abb9-7f495bdd6f57 + smi:local/auto + P + undecidable + + + + + smi:local/773d40f1-fe73-48de-92d8-0080ea797915 + smi:local/auto + S + undecidable + + + + + smi:local/ae100aff-f8b4-4694-b520-26dfef5670bd + smi:local/auto + P + undecidable + + + + + smi:local/469c52d0-f7e7-4544-a70b-c3555a61cd31 + smi:local/auto + S + undecidable + + + + + smi:local/7beed4f2-9b77-49df-89da-7a9b139f8254 + smi:local/auto + P + undecidable + + + + + smi:local/0a542e38-106f-44bd-a26f-cf10faea0317 + smi:local/auto + S + undecidable + + + + + smi:local/cafd90b3-2f45-4afa-8630-4855d4ec1d02 + smi:local/auto + P + undecidable + + + + + smi:local/2d5e017b-f8ae-4b7d-9a44-02d73b1d2077 + smi:local/auto + S + undecidable + + + + + smi:local/0e0128fe-31a5-48dc-be37-41a03bb9e8b0 + smi:local/auto + P + undecidable + + + + + smi:local/e8b21c87-8b49-49bc-8624-80fc4804f290 + smi:local/auto + S + undecidable + + + + + smi:local/87c06075-d02b-403e-9941-28102075bc59 + smi:local/auto + P + undecidable + + + + + smi:local/2604d838-6656-42df-81bf-5213cc29c994 + smi:local/auto + S + undecidable + + + + + smi:local/81adc5fa-f9f8-4f37-a282-a11c639e7dee + smi:local/auto + P + undecidable + + + + + smi:local/488dbf26-d4e0-41a8-b006-b4872dd4ed05 + smi:local/auto + S + undecidable + + + + + smi:local/f7d25c88-0e0e-4841-a2fb-78c0bad61acd + smi:local/auto + P + undecidable + + + + + smi:local/2190ac08-25d2-4ec2-9e02-7cc279f97015 + smi:local/auto + S + undecidable + + + + + smi:local/fd723584-7678-4254-a948-081b98d3069a + smi:local/auto + P + undecidable + + + + + smi:local/36d8027e-e50a-40c4-b8b1-7792abcfe092 + smi:local/auto + S + undecidable + + + + + smi:local/9cfb6d0f-cc2a-45a2-b93e-48b10b77a35a + smi:local/auto + P + undecidable + + + + + smi:local/bb4d0a2b-60f5-4db0-99d5-ff5c75695ebb + smi:local/auto + S + undecidable + + + + + smi:local/11ab4416-0aed-43db-9588-c5854e5f15af + smi:local/auto + P + undecidable + + + + + smi:local/7afaaaa6-399f-42f2-acfc-4c2ed680cf60 + smi:local/auto + S + undecidable + + + + + smi:local/44635c4f-2565-43b5-b582-929c3e73b77c + smi:local/auto + P + undecidable + + + + + smi:local/e7612e29-1a50-4aa5-a27e-1894e709fae4 + smi:local/auto + S + undecidable + + + + + smi:local/e51cb224-9407-4270-ae8a-0108fae678a0 + smi:local/auto + P + undecidable + + + + + smi:local/9f0b55a4-10cf-4d1a-b562-bdc1ce6ecc2b + smi:local/auto + S + undecidable + + + + + smi:local/eb3a99af-d497-48b8-af8c-0f0f97071708 + smi:local/auto + P + undecidable + + + + + + + smi:local/8e0e7e62-2a0c-4512-b6d4-39dfd2a49eba + smi:local/auto + P + undecidable + + + + + smi:local/bab57589-00fe-468d-909a-87ba3c839833 + smi:local/auto + S + undecidable + + + + + smi:local/3fec6a3e-2310-4c5f-8fdc-2fe628b30267 + smi:local/auto + P + undecidable + + + + + smi:local/536830e4-4312-4fa0-8483-4bbe43a84a07 + smi:local/auto + S + undecidable + + + + + smi:local/daf65427-d17d-4649-b080-69eaf8e600de + smi:local/auto + P + undecidable + + + + + smi:local/5a0e872d-a672-47e2-91da-7e15789211ea + smi:local/auto + S + undecidable + + + + + smi:local/b4f29374-aaaf-41d8-9f93-08d7d1cb4606 + smi:local/auto + P + undecidable + + + + + smi:local/474a8848-8935-47ad-8829-434604ef3f57 + smi:local/auto + S + undecidable + + + + + smi:local/09e8f77b-0f62-449b-929e-c4f0cd6cbcb4 + smi:local/auto + P + undecidable + + + + + smi:local/d97460a1-4caf-453a-a7dd-9a70fa4bb6ad + smi:local/auto + S + undecidable + + + + + smi:local/104c0bb9-f53c-4def-8477-2e8dd57e7e33 + smi:local/auto + P + undecidable + + + + + smi:local/e17bb6f7-0a2b-4eed-a0bf-08657a5db319 + smi:local/auto + S + undecidable + + + + + smi:local/e896a296-e574-4d43-93fa-1a8c4052d3c2 + smi:local/auto + P + undecidable + + + + + smi:local/f54d00b5-4579-4717-ae9c-194837198cfc + smi:local/auto + S + undecidable + + + + + smi:local/98d96c03-63a5-46c5-8da4-741284e6a916 + smi:local/auto + P + undecidable + + + + + smi:local/c04a283d-dd7e-4ee4-a32a-548db74739ae + smi:local/auto + S + undecidable + + + + + smi:local/d2df1473-7549-4aa3-8b53-d947cd1e0a02 + smi:local/auto + P + undecidable + + + + + smi:local/dcad0ec6-a232-4681-bf1d-2b35ea0c87fa + smi:local/auto + S + undecidable + + + + + smi:local/33848a00-1347-4602-b130-9c5304ef4a2a + smi:local/auto + P + undecidable + + + + + smi:local/868d0666-681b-478e-bc7a-a44532da62d8 + smi:local/auto + S + undecidable + + + + + smi:local/784e3e43-ba55-4c65-b2c9-248080e4b608 + smi:local/auto + P + undecidable + + + + + smi:local/fff94911-0985-4ae1-8e0b-653a5d0cd0f7 + smi:local/auto + S + undecidable + + + + + smi:local/a40d7f1a-6cf6-442e-8048-b6667dc2a8a5 + smi:local/auto + P + undecidable + + + + + smi:local/67f39ec8-8189-4889-a3e4-9b051952dbeb + smi:local/auto + S + undecidable + + + + + smi:local/6ae5918c-1290-4b28-a5d6-6c9e2a15f304 + smi:local/auto + P + undecidable + + + + + smi:local/985fc9d0-e8ce-4052-a59e-df648897add2 + smi:local/auto + S + undecidable + + + + + smi:local/d568dc13-356b-42f5-8a66-2019f7c54e8c + smi:local/auto + P + undecidable + + + + + smi:local/2e82929e-2d54-476e-8fd2-a3556f3c81f5 + smi:local/auto + S + undecidable + + + + + smi:local/30b11812-5134-4b06-8454-5e0536bbe432 + smi:local/auto + P + undecidable + + + + + smi:local/98d4b490-23b0-400c-9b45-3f554aa227a5 + smi:local/auto + S + undecidable + + + + + smi:local/cfb6b1de-874b-4109-b833-1fac5690f805 + smi:local/auto + P + undecidable + + + + + smi:local/25bb1763-2a80-459f-a30d-d843d5f0f3b7 + smi:local/auto + S + undecidable + + + + + smi:local/53704593-f9d5-4a71-9d35-c11bbaa628de + smi:local/auto + P + undecidable + + + + + smi:local/40dcbf84-e62b-4c5b-a1cd-f58658d0f293 + smi:local/auto + S + undecidable + + + + + smi:local/9b862b6f-b7bc-4b3f-9106-c3e736426a5f + smi:local/auto + P + undecidable + + + + + smi:local/d266f9bd-f7ca-40eb-8db1-21a855170887 + smi:local/auto + S + undecidable + + + + + smi:local/2785063d-40fc-4fd7-891f-587288fe5b28 + smi:local/auto + P + undecidable + + + + + smi:local/9ede158d-1f2e-4d1e-a925-48b552223c68 + smi:local/auto + S + undecidable + + + + + smi:local/540e67ad-d9d3-4c36-a886-b2a0375f5c0e + smi:local/auto + P + undecidable + + + + + smi:local/6fe37b36-7bdf-45b1-b221-48c0a0779632 + smi:local/auto + S + undecidable + + + + + smi:local/f4fdb431-b7b9-4656-9d9b-a472ab0fc010 + smi:local/auto + P + undecidable + + + + + smi:local/89e29840-41c5-4c00-a2a2-e94a2fc7caaf + smi:local/auto + S + undecidable + + + + + smi:local/3580d5e8-4b4f-474c-b50c-c6bfe1d15181 + smi:local/auto + P + undecidable + + + + + smi:local/d2ba4842-ed9d-40a0-aea0-6d2a1b5ce036 + smi:local/auto + S + undecidable + + + + + smi:local/ab3ecddf-7431-4efc-836a-e27b553f90e7 + smi:local/auto + P + undecidable + + + + + smi:local/5d916c8b-a31b-4282-bb7c-dee0ef2ea4fe + smi:local/auto + S + undecidable + + + + + smi:local/d5dc0ebc-8687-4c3a-b487-e2378203c6cb + smi:local/auto + P + undecidable + + + + + smi:local/90ba17ff-77f7-470c-b0ae-4dfcc332a2b2 + smi:local/auto + S + undecidable + + + + + smi:local/e1f46052-6427-406b-be71-d8b408bbf8a6 + smi:local/auto + P + undecidable + + + + + smi:local/9d50f04e-7f24-4ad5-810f-8412887091ba + smi:local/auto + S + undecidable + + + + + smi:local/f7fb2758-ccb1-4605-86cb-c322f91217f8 + smi:local/auto + P + undecidable + + + + + smi:local/e590e707-c6f4-41af-9c60-58a58a559f06 + smi:local/auto + S + undecidable + + + + + smi:local/3d66816b-84f3-445a-90bb-542e1374f764 + smi:local/auto + P + undecidable + + + + + smi:local/dd4864e2-c7ad-46b3-9bd4-6d2b0c1086a8 + smi:local/auto + S + undecidable + + + + + smi:local/995e9752-5f4f-4287-b577-28a1e4c69db1 + smi:local/auto + P + undecidable + + + + + smi:local/662ec00f-1db3-40d4-ac01-8f87c943f5e4 + smi:local/auto + S + undecidable + + + + + smi:local/c6ca671b-ca42-4a0a-8709-75363e8ee560 + smi:local/auto + P + undecidable + + + + + smi:local/9131cce2-3670-43a9-a825-6cda8e4b94ff + smi:local/auto + S + undecidable + + + + + smi:local/74025906-fea0-4138-977f-00f7a1f6d808 + smi:local/auto + P + undecidable + + + + + smi:local/2b6ba31e-cb0f-4004-b130-3a035a8f157c + smi:local/auto + S + undecidable + + + + + smi:local/3b06b567-2ef7-4fb7-a855-6133023304ac + smi:local/auto + P + undecidable + + + + + smi:local/43650820-d104-40c3-9a34-87255d616f54 + smi:local/auto + S + undecidable + + + + + smi:local/551ce44b-63c3-4a69-ad5d-327844629a57 + smi:local/auto + P + undecidable + + + + + smi:local/a09bb723-16ec-429a-94a9-d1950c86c14b + smi:local/auto + S + undecidable + + + + + smi:local/cb2409d2-f80f-44c4-a46c-4b13ac2c281d + smi:local/auto + P + undecidable + + + + + smi:local/f66e7f6f-708f-4ad4-ab5d-fd1710bdf080 + smi:local/auto + S + undecidable + + + + + smi:local/e942039f-98fd-46e3-a5d8-58749124dbd2 + smi:local/auto + P + undecidable + + + + + smi:local/a23e92c6-48d9-4db4-81f8-7301351f1cd6 + smi:local/auto + S + undecidable + + + + + smi:local/87d97cad-3ce1-46cd-b01d-5732c0060ff9 + smi:local/auto + P + undecidable + + + + + smi:local/8cdf3d25-471c-4de3-bf30-9ca3f8ecac84 + smi:local/auto + S + undecidable + + + + + smi:local/40ffac85-5051-4891-b4a8-0669c1e7e09c + smi:local/auto + P + undecidable + + + + + smi:local/4f2d88bf-4c39-41ba-bded-f60792506818 + smi:local/auto + S + undecidable + + + + + smi:local/af90dd01-03d8-4064-b2fd-34ebe9962ce3 + smi:local/auto + P + undecidable + + + + + smi:local/a42a181b-1b8d-4d80-8502-80621926ddf7 + smi:local/auto + S + undecidable + + + + + smi:local/4a2fd521-d255-48a8-bc2e-73f81174d544 + smi:local/auto + P + undecidable + + + + + smi:local/76d49e91-17ff-4d75-924f-ad87383de67b + smi:local/auto + S + undecidable + + + + + smi:local/d6d2c011-dcd9-4dd8-9128-147c45be52db + smi:local/auto + P + undecidable + + + + + smi:local/a442c300-b7f1-472f-b5c5-22c51a176fd0 + smi:local/auto + S + undecidable + + + + + smi:local/16e5ac4f-d72b-4129-9b4c-fb34483310c4 + smi:local/auto + P + undecidable + + + + + smi:local/6612d93a-54ee-431d-941c-ee5f8025ec52 + smi:local/auto + S + undecidable + + + + + smi:local/b5c2638c-0420-4833-8362-2dda94fbf87a + smi:local/auto + P + undecidable + + + + + smi:local/09ea67ae-276f-49fe-903d-56e7b50a569a + smi:local/auto + S + undecidable + + + + + smi:local/4a4d4979-eab6-4d49-a903-d1454df27fb1 + smi:local/auto + P + undecidable + + + + + smi:local/96180139-4407-4d6d-a2b4-e525539b0a30 + smi:local/auto + S + undecidable + + + + + smi:local/9e3ae025-2375-4441-bc87-cf8c25eff4e7 + smi:local/auto + P + undecidable + + + + + smi:local/180549ee-9180-45dd-b8b2-06b76f704ee9 + smi:local/auto + S + undecidable + + + + + smi:local/83dd06ee-a530-431e-938a-52f345a20651 + smi:local/auto + P + undecidable + + + + + smi:local/afdd2047-5dd0-4f51-b7e4-1a307c83e03e + smi:local/auto + S + undecidable + + + + + smi:local/c968ac92-0a66-4b3b-8ef2-6858fad46d0d + smi:local/auto + P + undecidable + + + + + smi:local/d465520e-ec1b-41bb-a63c-3a286e8359f7 + smi:local/auto + S + undecidable + + + + + smi:local/22c9dedd-f1de-4873-97e2-52c78483e013 + smi:local/auto + P + undecidable + + + + + smi:local/bfaa1391-7d6e-4a6c-8ccc-eaeb2c1b37f8 + smi:local/auto + S + undecidable + + + + + smi:local/ace31e96-391f-4b55-a8d4-6a53b1751a06 + smi:local/auto + P + undecidable + + + + + smi:local/ed421108-8745-4bec-9fd9-aa97d898d391 + smi:local/auto + S + undecidable + + + + + smi:local/1f2f6ccd-069e-4e29-a9e8-ebb9f6af71ad + smi:local/auto + P + undecidable + + + + + smi:local/e09ec722-eb9f-4ab6-afc6-3013ad456d5c + smi:local/auto + S + undecidable + + + + + smi:local/9bb1a482-923a-48db-8971-c05e605b7e8e + smi:local/auto + P + undecidable + + + + + smi:local/f13bc8f3-6c1d-4b4c-8a0e-5af8d0c632b5 + smi:local/auto + S + undecidable + + + + + smi:local/54607845-239e-4e7c-ba41-5a8872c65390 + smi:local/auto + P + undecidable + + + + + smi:local/bd50f508-3406-47cf-87d7-735768cdae6e + smi:local/auto + S + undecidable + + + + + smi:local/6ed8417a-a348-428f-b29c-b79528b6e696 + smi:local/auto + P + undecidable + + + + + smi:local/4fc0e56d-98a9-4a36-b9d1-be661b487cba + smi:local/auto + S + undecidable + + + + + smi:local/f4e7bd88-e6f2-4876-9687-c11e89bd59fe + smi:local/auto + P + undecidable + + + + + smi:local/7bf260e7-a0c5-485e-9c91-4f410fe994bc + smi:local/auto + S + undecidable + + + + + smi:local/56bd6abf-0455-42ce-8d93-58c351f749eb + smi:local/auto + P + undecidable + + + + + smi:local/f493ac69-3915-497c-a0ef-ad454715f873 + smi:local/auto + S + undecidable + + + + + smi:local/d884b68e-e4b6-4ad0-8205-ee2e24250cb0 + smi:local/auto + P + undecidable + + + + + smi:local/56b10cf9-e76f-4b3f-a484-ec58363322c1 + smi:local/auto + S + undecidable + + + + + smi:local/e36844f3-ba41-458a-a473-c5020c376ef9 + smi:local/auto + P + undecidable + + + + + smi:local/9c9ed1e4-8a61-4f0d-9bad-9f098cd6d82f + smi:local/auto + S + undecidable + + + + + smi:local/7ce84652-a3ad-4313-be83-147189c0912d + smi:local/auto + P + undecidable + + + + + smi:local/208dc869-694f-4b9c-9cee-e4cbb8859259 + smi:local/auto + S + undecidable + + + + + smi:local/6cb7b476-c2df-454f-9928-fdd0633b24bb + smi:local/auto + P + undecidable + + + + + smi:local/9adb3005-24e1-4abd-95a7-763a26931626 + smi:local/auto + S + undecidable + + + + + smi:local/7234e687-2afd-4936-9344-7cc2465ebf42 + smi:local/auto + P + undecidable + + + + + smi:local/662aeae9-4685-4f2b-86a9-b534185ccede + smi:local/auto + S + undecidable + + + + + smi:local/8dba811f-65dd-47dd-89cc-601b59b7e31f + smi:local/auto + P + undecidable + + + + + smi:local/fa7cf33c-8805-42e2-9517-8197101f6f2b + smi:local/auto + S + undecidable + + + + + smi:local/56aa22ab-e80b-4f49-9839-435c49d2b3b9 + smi:local/auto + P + undecidable + + + + + smi:local/bebdec67-91d2-4b69-a2cc-f5e2cd435a1c + smi:local/auto + S + undecidable + + + + + smi:local/39aecb95-3c85-4663-a908-fe23500af5a9 + smi:local/auto + P + undecidable + + + + + smi:local/df494548-5cd3-4be7-b3b3-08f8c4866e5f + smi:local/auto + S + undecidable + + + + + smi:local/2be5906f-00c6-4b45-bd3e-cd24a6d4bfbc + smi:local/auto + P + undecidable + + + + + smi:local/c0119d47-013c-4577-8d02-63c26de0db5a + smi:local/auto + S + undecidable + + + + + smi:local/7c825c3e-3c87-43a8-85d5-40fd86ca54fe + smi:local/auto + P + undecidable + + + + + smi:local/e86d40d6-d962-4d36-8b2e-37ae7a5b17ee + smi:local/auto + S + undecidable + + + + + smi:local/1dd063f9-8915-4c58-9e78-ddf7323c5a78 + smi:local/auto + P + undecidable + + + + + smi:local/6399ffcc-77d1-43db-8d69-991d5936b816 + smi:local/auto + S + undecidable + + + + + smi:local/06e4aa4d-d185-41ba-80dc-fff694d5537c + smi:local/auto + P + undecidable + + + + + smi:local/81b27c71-3492-42ef-ab6e-23940224db42 + smi:local/auto + S + undecidable + + + + + smi:local/ea96c08d-ddfe-41a3-a1e9-2aeb8c329a19 + smi:local/auto + P + undecidable + + + + + smi:local/80e4403e-43d7-463d-b488-6c8fa13b84a4 + smi:local/auto + S + undecidable + + + + + smi:local/c5adbc1e-a637-41a9-9a27-436f36461384 + smi:local/auto + P + undecidable + + + + + smi:local/0c3634c3-e547-493f-88df-eac18220ea8a + smi:local/auto + S + undecidable + + + + + smi:local/9b17afe0-d8a4-4cf1-b531-fc40f96898fb + smi:local/auto + P + undecidable + + + + + smi:local/9ad19e06-ee86-4139-ad7c-ca423fcfd285 + smi:local/auto + S + undecidable + + + + + smi:local/7950a8c8-5eca-4552-aff4-05bc0fbd4213 + smi:local/auto + P + undecidable + + + + + smi:local/07eacba2-22ca-4b51-9545-5e53f76669e2 + smi:local/auto + S + undecidable + + + + + smi:local/da62b738-934e-433e-a29f-b7c47e2d4b89 + smi:local/auto + P + undecidable + + + + + smi:local/28290101-717d-444c-8f9b-8107952d79c4 + smi:local/auto + S + undecidable + + + + + smi:local/07b977b3-581f-431c-8a9f-600151b3d72b + smi:local/auto + P + undecidable + + + + + smi:local/234ac26b-1b2c-42d1-8d7a-e11599c5edbb + smi:local/auto + S + undecidable + + + + + smi:local/9c312efd-bce1-47c0-83d4-ca71a8205490 + smi:local/auto + P + undecidable + + + + + smi:local/8dcd1363-96ff-4426-99f1-24a01b1bf570 + smi:local/auto + S + undecidable + + + + + smi:local/02e83af4-259a-4159-9cd8-cfbffbacaee5 + smi:local/auto + P + undecidable + + + + + smi:local/4108ed7d-72a4-4c9f-8efe-9cda8cba933c + smi:local/auto + S + undecidable + + + + + smi:local/d0deb4df-8998-4324-a798-bcad3753010d + smi:local/auto + P + undecidable + + + + + smi:local/21122970-ee77-4858-981f-5656622b8de6 + smi:local/auto + S + undecidable + + + + + smi:local/d277ed30-37f1-4176-bcd3-ea3774eb241a + smi:local/auto + P + undecidable + + + + + smi:local/ad5daa40-fe19-4cca-8de7-d47c4faee2e8 + smi:local/auto + S + undecidable + + + + + smi:local/d949f0f7-bc78-4a91-96cc-e3fc07561d9f + smi:local/auto + P + undecidable + + + + + smi:local/ad0c3cd0-2a39-477c-95db-b97641b9fcef + smi:local/auto + S + undecidable + + + + + smi:local/b2695d9e-762d-42ea-8988-a0cf330a8ffb + smi:local/auto + P + undecidable + + + + + smi:local/4c9d02c0-5988-47fd-aaf3-63969d7d87ad + smi:local/auto + S + undecidable + + + + + smi:local/12e92da9-f41e-4d6e-8e1b-7f0b8fad2382 + smi:local/auto + P + undecidable + + + + + smi:local/dc554d13-8a6c-4c58-9490-3b5d5388dc49 + smi:local/auto + S + undecidable + + + + + smi:local/4b5953df-eef2-4a11-9ece-f9fe819c659a + smi:local/auto + P + undecidable + + + + + smi:local/6c73f334-2fcc-41de-a6d4-ca78a10a7bbd + smi:local/auto + S + undecidable + + + + + smi:local/cc02c8ba-9f83-44b1-b98b-8a7a1ded3f94 + smi:local/auto + P + undecidable + + + + + smi:local/521cc0ee-5e9d-4b8d-930a-d3c6f16db301 + smi:local/auto + S + undecidable + + + + + smi:local/a3b8dd38-f855-4141-a933-572eeafde562 + smi:local/auto + P + undecidable + + + + + smi:local/805e3fa7-bf14-4c2f-b295-c55db5818c1c + smi:local/auto + S + undecidable + + + + + smi:local/838a6b43-26ba-4ba7-b590-8c69fde46358 + smi:local/auto + P + undecidable + + + + + smi:local/755b8c20-5add-4186-aaa7-58397a57c35f + smi:local/auto + S + undecidable + + + + + smi:local/86d407e9-13ac-4f0c-9d91-dd2aa0f11e25 + smi:local/auto + P + undecidable + + + + + smi:local/351dfa42-b0bc-48dd-b459-97a7bb53d257 + smi:local/auto + S + undecidable + + + + + smi:local/953853ee-ea7f-4885-b21b-965da20eac93 + smi:local/auto + P + undecidable + + + + + smi:local/9a10c4d7-21f7-4ac7-9842-7cb013dd10cd + smi:local/auto + S + undecidable + + + + + smi:local/7dd5deb4-22c8-4f82-bd67-1596ad2e5713 + smi:local/auto + P + undecidable + + + + + smi:local/936755da-bb6c-4514-91cc-f242ee74bc4a + smi:local/auto + S + undecidable + + + + + smi:local/47bb5c3e-609f-4338-9654-6e5e3bd766a6 + smi:local/auto + P + undecidable + + + + + smi:local/638d989f-ab4d-4812-80f0-99bd733cc803 + smi:local/auto + S + undecidable + + + + + smi:local/27b35d51-9ddc-43db-8cfe-14c3e481a0e2 + smi:local/auto + P + undecidable + + + + + smi:local/1e02661f-670b-432d-8c5a-f746eb8f03ad + smi:local/auto + S + undecidable + + + + + smi:local/4302d05e-333b-42d9-8d62-b277cae539ed + smi:local/auto + P + undecidable + + + + + smi:local/a015b935-139d-4dd1-8410-b9583c59aca6 + smi:local/auto + S + undecidable + + + + + smi:local/63bb86c5-aaa5-4e02-9b27-44a2e96af33c + smi:local/auto + P + undecidable + + + + + smi:local/e6edebac-fdd8-42f7-99b9-b755c49ab940 + smi:local/auto + S + undecidable + + + + + smi:local/f53f15f3-7160-4e29-8eea-bb43824f08f5 + smi:local/auto + P + undecidable + + + + + smi:local/fb50c128-ade7-4050-bf2c-f2acfbf85555 + smi:local/auto + S + undecidable + + + + + smi:local/8d1ac11e-bf9f-4cda-a1ec-340845d9d362 + smi:local/auto + P + undecidable + + + + + smi:local/bcc6d461-df08-4ae2-9fde-1e5f6b2ab08e + smi:local/auto + S + undecidable + + + + + smi:local/4511a037-6ac3-4f1f-873e-623cd9ccc268 + smi:local/auto + P + undecidable + + + + + smi:local/a75e93e8-e1f0-4ac9-a9b8-344b23a6ff0f + smi:local/auto + S + undecidable + + + + + smi:local/d072ea3b-943f-44c0-b53c-eb909c401aa1 + smi:local/auto + P + undecidable + + + + + smi:local/53e7447c-790b-41da-9a4a-374b121a9e63 + smi:local/auto + S + undecidable + + + + + smi:local/f3b819c8-278d-4e03-8a38-ccedd382973c + smi:local/auto + P + undecidable + + + + + smi:local/5fc076b5-77df-4d47-aded-ff5ebd7182e8 + smi:local/auto + S + undecidable + + + + + smi:local/f0effe7a-77ef-4346-a1fd-c17501b86ee1 + smi:local/auto + P + undecidable + + + + + smi:local/56e36b95-ddb1-4f5d-9d49-79805f7305f6 + smi:local/auto + S + undecidable + + + + + smi:local/ac5a2e1c-1805-40a8-ae62-50b2ad5dd0a3 + smi:local/auto + P + undecidable + + + + + smi:local/1c325170-980b-404b-b2d0-65ce986dacec + smi:local/auto + S + undecidable + + + + + smi:local/e462a255-ab08-4b6b-a070-1cdcc93fe6be + smi:local/auto + P + undecidable + + + + + smi:local/29e82040-9e84-4c3f-849f-3de72f94eb22 + smi:local/auto + S + undecidable + + + + + smi:local/13839c4a-653d-4abd-805f-bc303c2b3921 + smi:local/auto + P + undecidable + + + + + smi:local/cc1b1253-e28e-43d3-a10f-ee7ea4eb6244 + smi:local/auto + S + undecidable + + + + + smi:local/9c177bab-69b4-4dc3-8179-5a068ce10ffc + smi:local/auto + P + undecidable + + + + + smi:local/80eb0fe4-02fa-4bb4-93ae-728c911323af + smi:local/auto + S + undecidable + + + + + smi:local/3d6c41ed-5fa0-4cab-811c-a74990aac93c + smi:local/auto + P + undecidable + + + + + smi:local/7f610755-611b-4a5a-8749-3ad63c2ac9ef + smi:local/auto + S + undecidable + + + + + smi:local/733bfa55-feee-45a4-ad4b-01fbe85bced4 + smi:local/auto + P + undecidable + + + + + smi:local/f51773f9-e00c-43a6-a6b8-fd6f409940d9 + smi:local/auto + S + undecidable + + + + + smi:local/511b9cf8-d808-4308-8f33-44f24d03c00f + smi:local/auto + P + undecidable + + + + + smi:local/e3ddf172-3500-4ee8-a355-7a0a8cf113ed + smi:local/auto + S + undecidable + + + + + smi:local/398efebb-36e2-41bc-92b1-be148376c239 + smi:local/auto + P + undecidable + + + + + smi:local/4d4fc296-a4e8-4751-9d49-f247e0035c53 + smi:local/auto + S + undecidable + + + + + smi:local/9028836b-dcc2-4b4a-8ea9-44bb63afe5d0 + smi:local/auto + P + undecidable + + + + + smi:local/1fc6efdd-3b5d-4f44-a40e-44c188f1eba8 + smi:local/auto + S + undecidable + + + + + smi:local/95262861-010c-4147-9ab4-296b0b61ec4e + smi:local/auto + P + undecidable + + + + + smi:local/c93da8a2-dc65-465e-8d34-c8d814341092 + smi:local/auto + S + undecidable + + + + + smi:local/62ee857f-6a92-480d-92e7-9cfbfeb8ed74 + smi:local/auto + P + undecidable + + + + + smi:local/d31c5cd5-42d3-400b-b926-3bc8a3d73d55 + smi:local/auto + S + undecidable + + + + + smi:local/174511c7-98ef-43c0-a45a-c740d8bd0845 + smi:local/auto + P + undecidable + + + + + smi:local/7d06d89d-a44a-4c3d-832f-a1cff06e8a9d + smi:local/auto + S + undecidable + + + + + smi:local/83752ed9-00a8-4eb0-b380-8bbe6bf33146 + smi:local/auto + P + undecidable + + + + + smi:local/14cc4571-34b8-4225-90e0-f72468790f7f + smi:local/auto + S + undecidable + + + + + smi:local/ea253ee3-ec66-406b-850d-23e4e332ade8 + smi:local/auto + P + undecidable + + + + + smi:local/3886d80d-86d8-450c-9923-fbd0da894ad1 + smi:local/auto + S + undecidable + + + + + smi:local/c1be7c0e-cf9e-4c7b-b0ee-69a264608c8a + smi:local/auto + P + undecidable + + + + + smi:local/00496a3e-6a73-45c0-972e-65136427b248 + smi:local/auto + S + undecidable + + + + + smi:local/1aec9c5a-007c-4147-9f14-9ddfc4e006fc + smi:local/auto + P + undecidable + + + + + smi:local/8703b534-22ac-4f65-81cb-23940f2e8fa6 + smi:local/auto + S + undecidable + + + + + smi:local/1de584eb-84bf-4d26-88f8-85cb7ae2aa50 + smi:local/auto + P + undecidable + + + + + smi:local/f79699b6-7446-41e9-a33c-122f07d9fd74 + smi:local/auto + S + undecidable + + + + + smi:local/7eb6517e-1b58-44ae-8591-37d7936deb43 + smi:local/auto + P + undecidable + + + + + smi:local/8eb75fa8-b96a-4382-b010-39250a785c25 + smi:local/auto + S + undecidable + + + + + smi:local/f43b4def-3886-4e66-8de6-135b0d55a761 + smi:local/auto + P + undecidable + + + + + smi:local/ab357bc2-df2e-4ed4-ae49-b6351d39eddb + smi:local/auto + S + undecidable + + + + + smi:local/b223d8d4-3f2f-48f2-bfee-34cdcc58e465 + smi:local/auto + P + undecidable + + + + + smi:local/a521465c-4b58-4474-9a99-1930f03b4f1c + smi:local/auto + S + undecidable + + + + + smi:local/a17281e2-2a9a-408b-a937-3ded7943f207 + smi:local/auto + P + undecidable + + + + + smi:local/5a50f603-ad3d-4f20-96a3-a3e03fe278e4 + smi:local/auto + S + undecidable + + + + + smi:local/5a1990f9-3d8f-4664-a89e-b4098899b745 + smi:local/auto + P + undecidable + + + + + smi:local/2bb2ceef-1407-4725-82a1-685e105c2269 + smi:local/auto + S + undecidable + + + + + smi:local/ce427d59-9556-427f-99df-3e4e818be75d + smi:local/auto + P + undecidable + + + + + smi:local/5f882d63-64e4-4a6d-a6ee-4b07f104ee1b + smi:local/auto + S + undecidable + + + + + smi:local/ff287896-cae4-4689-980e-7773af973555 + smi:local/auto + P + undecidable + + + + + smi:local/3255865c-1b6b-452f-8eb3-0b7f1870e518 + smi:local/auto + S + undecidable + + + + + smi:local/99d03c21-4f3c-4171-99aa-81d05110996a + smi:local/auto + P + undecidable + + + + + smi:local/8eb57a9c-c16a-4fa0-9ce1-46745943785b + smi:local/auto + S + undecidable + + + + + smi:local/b40a654a-4144-4d51-9c86-5317eee65ae7 + smi:local/auto + P + undecidable + + + + + smi:local/1182e6d0-d9d6-4bcd-a674-faaa74154afa + smi:local/auto + S + undecidable + + + + + smi:local/6ec97345-e1ce-41da-8335-635194b0218f + smi:local/auto + P + undecidable + + + + + smi:local/f4cc38f4-f289-40fb-8a45-e58ff605e8eb + smi:local/auto + S + undecidable + + + + + smi:local/5bc2ebd4-9f89-4132-a4f8-c56dcec92813 + smi:local/auto + P + undecidable + + + + + smi:local/03dcd52a-5514-4d73-9490-42ea149f721b + smi:local/auto + S + undecidable + + + + + smi:local/bf85adbe-93ee-4ed9-9ed5-b61d4b4dd715 + smi:local/auto + P + undecidable + + + + + smi:local/af8dd6a6-3586-4045-bc9f-678a9e6d1caa + smi:local/auto + S + undecidable + + + + + smi:local/a865305d-daad-4d2f-abc9-21a5bb85bea3 + smi:local/auto + P + undecidable + + + + + smi:local/4840c6ec-2797-4df1-9e74-5f3578561acd + smi:local/auto + S + undecidable + + + + + smi:local/a02a97c5-debc-43d0-bed3-98cab1c644b9 + smi:local/auto + P + undecidable + + + + + smi:local/f84b10ba-aa48-46cb-9a9f-f678ed533206 + smi:local/auto + S + undecidable + + + + + smi:local/0bb33d40-2126-4d31-a925-5281aaf342fe + smi:local/auto + P + undecidable + + + + + smi:local/39bbe1d2-f930-4b3a-a3dc-f87100635627 + smi:local/auto + S + undecidable + + + + + smi:local/1d139442-b80a-42e3-a3f8-9b07103aa7bd + smi:local/auto + P + undecidable + + + + + smi:local/f243caa3-6343-46f2-87b3-962ee584f992 + smi:local/auto + S + undecidable + + + + + smi:local/ddc48458-bc58-4841-8a64-2a89299eb3ab + smi:local/auto + P + undecidable + + + + + smi:local/02e7e7c6-6b07-4d7b-8b47-12d2d50d6f9f + smi:local/auto + S + undecidable + + + + + smi:local/11ed80dc-30e1-4bf0-923e-ab0c70b1c6cc + smi:local/auto + P + undecidable + + + + + smi:local/c6669607-2e88-4633-a405-3e8098d8b7eb + smi:local/auto + S + undecidable + + + + + smi:local/53dd5bd5-938f-4a86-9aec-4cc235e259c3 + smi:local/auto + P + undecidable + + + + + smi:local/7ca1fec7-a072-491a-ad39-aa0b028d68d0 + smi:local/auto + S + undecidable + + + + + smi:local/65dbc4a0-ca05-49d7-9875-1313a622dcdc + smi:local/auto + P + undecidable + + + + + smi:local/214ce366-ae3b-4613-831d-a0c17d8b2221 + smi:local/auto + S + undecidable + + + + + smi:local/d111fb87-5f34-45dd-82e4-100a2db61459 + smi:local/auto + P + undecidable + + + + + smi:local/1a162855-823c-4fc4-a23d-55c231f8133e + smi:local/auto + S + undecidable + + + + + smi:local/794b33e4-3c60-481c-ab90-21fed6812a5d + smi:local/auto + P + undecidable + + + + + smi:local/887bf317-f330-46ad-ba8a-3428380fcebf + smi:local/auto + S + undecidable + + + + + smi:local/42c951e8-c9b4-4fa7-919a-4b612218bdd7 + smi:local/auto + P + undecidable + + + + + smi:local/3a6fff24-b55b-47f5-9f5f-fc8ce0cdb12c + smi:local/auto + S + undecidable + + + + + smi:local/5dc41f22-6577-4f53-87f2-3f0899fd38ce + smi:local/auto + P + undecidable + + + + + smi:local/4ccafa1b-11c7-430f-8093-3fe9d8460655 + smi:local/auto + S + undecidable + + + + + smi:local/8b2809b0-26de-41d0-bb1e-86f465a93362 + smi:local/auto + P + undecidable + + + + + smi:local/0bb303fd-ae3b-4aaa-aabf-c48d230473d2 + smi:local/auto + S + undecidable + + + + diff --git a/tests/test_autopicker/PyLoT_20171010_063224.a_corrected_taup_times_0.01-0.2_SKS.xml b/tests/test_autopicker/PyLoT_20171010_063224.a_corrected_taup_times_0.01-0.2_SKS.xml new file mode 100644 index 00000000..71142a24 --- /dev/null +++ b/tests/test_autopicker/PyLoT_20171010_063224.a_corrected_taup_times_0.01-0.2_SKS.xml @@ -0,0 +1,6688 @@ + + + + + + + + -18.58 + + + -69.86 + + + 106.4 + + + + + 6.27 + + Mwc + smi:local/ndk/C201710100632A/origin#cmtorigin + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + diff --git a/tests/test_autopicker/PyLoT_20171010_063224.a_corrected_taup_times_0.03-0.5_P.xml b/tests/test_autopicker/PyLoT_20171010_063224.a_corrected_taup_times_0.03-0.5_P.xml new file mode 100644 index 00000000..ba32487a --- /dev/null +++ b/tests/test_autopicker/PyLoT_20171010_063224.a_corrected_taup_times_0.03-0.5_P.xml @@ -0,0 +1,6688 @@ + + + + + + + + -18.58 + + + -69.86 + + + 106.4 + + + + + 6.27 + + Mwc + smi:local/ndk/C201710100632A/origin#cmtorigin + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + P + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + P + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + P + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + P + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + P + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + Pdiff + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + + smi:local/auto + P + + + + diff --git a/tests/test_autopicker/PyLoT_20171010_063224.a_correlated_0.01-0.2_SKS.xml b/tests/test_autopicker/PyLoT_20171010_063224.a_correlated_0.01-0.2_SKS.xml new file mode 100644 index 00000000..8faff2d7 --- /dev/null +++ b/tests/test_autopicker/PyLoT_20171010_063224.a_correlated_0.01-0.2_SKS.xml @@ -0,0 +1,6419 @@ + + + + + + + + -18.58 + + + -69.86 + + + 106.4 + + + + + 6.27 + + Mwc + smi:local/ndk/C201710100632A/origin#cmtorigin + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + + smi:local/auto + SKS + + + + diff --git a/tests/test_autopicker/PyLoT_20171010_063224.a_correlated_0.03-0.5_P.xml b/tests/test_autopicker/PyLoT_20171010_063224.a_correlated_0.03-0.5_P.xml new file mode 100644 index 00000000..165f74a4 --- /dev/null +++ b/tests/test_autopicker/PyLoT_20171010_063224.a_correlated_0.03-0.5_P.xml @@ -0,0 +1,8595 @@ + + + + + + + + -18.58 + + + -69.86 + + + 106.4 + + + + + 6.27 + + Mwc + smi:local/ndk/C201710100632A/origin#cmtorigin + + + + + smi:local/b0766b7a-0bbd-43ae-98e7-f354b87490d3 + smi:local/auto + P + positive + + + + + smi:local/f9cc9d15-325a-4c5b-aafd-c5393276a71b + smi:local/auto + P + positive + + + + + smi:local/d140635b-671b-4a4d-b30f-a433ddf36192 + smi:local/auto + P + positive + + + + + smi:local/6969dc27-977e-4182-a256-dd49370ab96c + smi:local/auto + P + positive + + + + + smi:local/c303805b-4537-4057-bfe5-e49fbb6bd4bd + smi:local/auto + P + positive + + + + + smi:local/61a52d2e-b5cd-4442-b1aa-ab2b7d27815b + smi:local/auto + P + positive + + + + + smi:local/66148875-caed-4de1-b187-023de1b56347 + smi:local/auto + P + positive + + + + + smi:local/a0175c5e-d7a9-4b4d-a1d8-c19dd27b79d3 + smi:local/auto + P + positive + + + + + smi:local/58d06ac5-bb76-4ceb-bca2-c3a3a3a86e3e + smi:local/auto + P + positive + + + + + smi:local/180e8f9b-30b7-4070-ad32-17e4b12984ce + smi:local/auto + P + positive + + + + + smi:local/5faa02d8-4fce-44f8-a193-5dc535624988 + smi:local/auto + P + positive + + + + + smi:local/2122a729-5052-4289-b4cd-d089b2389087 + smi:local/auto + P + positive + + + + + smi:local/513c1fa6-699c-4616-9d18-702db71a4c6d + smi:local/auto + P + positive + + + + + smi:local/8a20433a-f3a2-4db8-98d2-9eb421dd3e3f + smi:local/auto + P + positive + + + + + smi:local/e47f3965-b1dc-4c57-bf98-0c6bb93485a8 + smi:local/auto + P + positive + + + + + smi:local/1f9e0ce5-1db0-4b25-a4fd-77868394d19a + smi:local/auto + P + positive + + + + + smi:local/294df35d-c687-4ee7-aa18-69377f14fab2 + smi:local/auto + P + positive + + + + + smi:local/b7609fa8-fa7e-4841-8e4c-64401c67b8d5 + smi:local/auto + P + positive + + + + + smi:local/bf412b88-58ba-48e9-8571-6cb6965b70cb + smi:local/auto + P + positive + + + + + smi:local/c3dfa698-a941-4778-9fbe-09cec641c9f1 + smi:local/auto + P + positive + + + + + smi:local/dd6cd7ee-3329-411f-bc28-e7f5ed8163b1 + smi:local/auto + P + positive + + + + + smi:local/457e9e40-1116-4fba-a3c1-db39a33d20dc + smi:local/auto + P + positive + + + + + smi:local/94a74b9d-c0e6-4458-bfe8-465c6279e0e5 + smi:local/auto + P + positive + + + + + smi:local/a4d75fb3-810c-4c60-b0ee-4c72d719f2e9 + smi:local/auto + P + positive + + + + + smi:local/3660a736-3571-46e4-9a6d-aaf5d671e0b8 + smi:local/auto + P + positive + + + + + smi:local/bf9aff02-805c-45ab-95bd-449d9396d851 + smi:local/auto + P + positive + + + + + smi:local/200a0731-8ac2-441e-9197-5d9c01324cf8 + smi:local/auto + P + positive + + + + + smi:local/96e5862a-9efb-490d-89dd-019cacb688b9 + smi:local/auto + P + positive + + + + + smi:local/358bc0b7-d88c-4465-9d2b-707f7cfc74c6 + smi:local/auto + P + positive + + + + + smi:local/6b6b27af-e461-454c-9b00-6bedf7da5b64 + smi:local/auto + P + positive + + + + + smi:local/ea72f4e1-f4d3-48c4-a01f-bd85385e70b7 + smi:local/auto + P + positive + + + + + smi:local/0ddd6fb7-c7b1-406a-87c7-aa6418a911b2 + smi:local/auto + P + positive + + + + + smi:local/b212e321-bab9-4ae2-9d6a-6c6fb564d899 + smi:local/auto + P + positive + + + + + smi:local/59dee804-12aa-4425-b40f-0ecf5582eb19 + smi:local/auto + P + positive + + + + + smi:local/d9dd451d-daf5-4c7c-9789-752c7a5d5540 + smi:local/auto + P + positive + + + + + smi:local/c31ee9a3-2f30-4d91-8920-b03e435d58bd + smi:local/auto + P + positive + + + + + smi:local/57ae5927-424e-4a8d-976c-732d91cbe11f + smi:local/auto + P + positive + + + + + smi:local/1f814514-7591-44ac-b960-ec65634c91f6 + smi:local/auto + P + positive + + + + + smi:local/2cca416e-a0a5-469b-a12b-ed615c8ee32c + smi:local/auto + P + positive + + + + + smi:local/86954a2a-1431-4b8a-927b-77e675760553 + smi:local/auto + P + positive + + + + + smi:local/4d7e19ef-3f10-48b6-a2f0-dd95617e3b8a + smi:local/auto + P + positive + + + + + smi:local/c98400cd-e721-454a-b69f-50aedf11cefb + smi:local/auto + P + positive + + + + + smi:local/702d0dfd-b1be-4933-8215-d40a584434aa + smi:local/auto + P + positive + + + + + smi:local/01bfd166-e8c9-4c2d-adfd-d0b4859bbe22 + smi:local/auto + P + positive + + + + + smi:local/eabb7155-623e-472a-84eb-a8dae885e939 + smi:local/auto + P + positive + + + + + smi:local/df722a14-5ffb-447b-a997-67eb5e85d52d + smi:local/auto + P + positive + + + + + smi:local/203bf1b1-574a-475e-96a7-bd66819efb2e + smi:local/auto + P + positive + + + + + smi:local/2cd3bb3b-1b76-4499-a996-a53bea0de796 + smi:local/auto + P + positive + + + + + smi:local/2fc3d200-35c5-49a8-bb68-a29fd3f2ece9 + smi:local/auto + P + positive + + + + + smi:local/92e17861-0795-443d-b2d4-1c6d23a59e46 + smi:local/auto + P + positive + + + + + smi:local/a7212e0e-7b84-47d6-b790-b8aa6230b19a + smi:local/auto + P + positive + + + + + smi:local/50b1f5fc-0820-49e5-88ca-feb3a8efd2e8 + smi:local/auto + P + positive + + + + + smi:local/bd4e044f-b436-4bb1-bc2c-4519fea81f48 + smi:local/auto + P + positive + + + + + smi:local/6474a766-9932-4b3b-914f-af88abc63b12 + smi:local/auto + P + positive + + + + + smi:local/00cc775e-36f9-4456-859d-02346266e85b + smi:local/auto + P + positive + + + + + smi:local/b4814279-25dc-41dd-adaa-8650818df45e + smi:local/auto + P + positive + + + + + smi:local/6aae2b33-7638-4b15-b4b3-f295562473ec + smi:local/auto + P + positive + + + + + smi:local/a0efe872-ec23-440d-8591-e38d69149b2f + smi:local/auto + P + positive + + + + + smi:local/029f3183-b72b-467a-b851-406f6aea7c66 + smi:local/auto + P + positive + + + + + smi:local/0a49bb6c-2ed5-413e-bfc2-a25882a941a7 + smi:local/auto + P + positive + + + + + smi:local/dd53238c-7648-4f78-a52e-602409d18791 + smi:local/auto + P + positive + + + + + smi:local/f089ed52-3588-466d-8713-6dc1415f0979 + smi:local/auto + P + positive + + + + + smi:local/13ad73e8-2344-4b36-b0a1-6f1427a7af3a + smi:local/auto + P + positive + + + + + smi:local/a2525ea8-bd83-490a-84c2-dd285bd5e7f0 + smi:local/auto + P + positive + + + + + smi:local/63bbeeec-42c8-4690-8917-1d78214f1c9e + smi:local/auto + P + positive + + + + + smi:local/35e5b7f2-5e1c-40a9-bab5-ded5f0ddb945 + smi:local/auto + P + positive + + + + + smi:local/0c9c448c-c224-40e9-b1d3-a85231e75f68 + smi:local/auto + P + positive + + + + + smi:local/e9265088-fd70-4284-a340-659ae6971711 + smi:local/auto + P + positive + + + + + smi:local/cd037330-95a8-4bb4-b032-adc2b8e8d3c4 + smi:local/auto + P + positive + + + + + smi:local/e6aa7600-4047-44ad-b3ee-c116301f724e + smi:local/auto + P + positive + + + + + smi:local/811ea3b0-ada5-4553-b0b6-ee12bd6447f6 + smi:local/auto + P + positive + + + + + smi:local/fc14207d-825e-4bfc-aadf-07953079a3fc + smi:local/auto + P + positive + + + + + smi:local/c147095e-c9b3-405e-b7d2-22934342b976 + smi:local/auto + P + positive + + + + + smi:local/66039d85-4277-45aa-87ce-a576716b49f8 + smi:local/auto + P + positive + + + + + smi:local/caa4f9b4-c661-4d7d-8a5e-3e5fee486d27 + smi:local/auto + P + positive + + + + + smi:local/8d66cef0-b996-45cd-80c0-0d4204f72204 + smi:local/auto + P + positive + + + + + smi:local/c8e92473-a835-40b4-b6cb-494c0a9f3cf3 + smi:local/auto + P + positive + + + + + smi:local/27e3fa84-ed81-4943-96df-9f3bff216aec + smi:local/auto + P + positive + + + + + smi:local/20fc86d9-ce39-49cf-832d-644f20c2dc56 + smi:local/auto + P + positive + + + + + smi:local/8b549792-ac58-45db-9965-267b219a6bd3 + smi:local/auto + P + positive + + + + + smi:local/27b22ef0-08a1-4647-b368-1c4997a6aa9f + smi:local/auto + P + positive + + + + + smi:local/3c7bbb70-6e1c-46d0-957d-5d1e1c93bf9e + smi:local/auto + P + positive + + + + + smi:local/43953353-c63d-4d81-872f-8ba2e318b68a + smi:local/auto + P + positive + + + + + smi:local/7c6e9b5f-a342-46d7-8723-ebdbf5980c7e + smi:local/auto + P + positive + + + + + smi:local/0460aa2c-24a6-4171-89d8-628e607930d5 + smi:local/auto + P + positive + + + + + smi:local/de7431c1-fab5-4ec7-b2d4-06ff6331664b + smi:local/auto + P + positive + + + + + smi:local/737e1f44-c7a2-454c-9f67-5dc7df041587 + smi:local/auto + P + positive + + + + + smi:local/b6e00ec0-412a-4748-8d5b-645878b056f7 + smi:local/auto + P + positive + + + + + smi:local/7d8c63f2-4343-4cfe-8952-c26790a98d5b + smi:local/auto + P + positive + + + + + smi:local/d3cae8fe-bd11-4dd1-89df-bbaf33482b0c + smi:local/auto + P + positive + + + + + smi:local/b94b4d28-bd1f-4a7e-80cc-c062513bf480 + smi:local/auto + P + positive + + + + + smi:local/1c489d8c-0344-4e1e-a06e-42f5c8ceeaec + smi:local/auto + P + positive + + + + + smi:local/610d7972-401d-4b62-860e-6d4aac1b8db4 + smi:local/auto + P + positive + + + + + smi:local/c2e1d87c-9bbd-44af-840f-9a24ae2c1b5a + smi:local/auto + P + positive + + + + + smi:local/c67b84ed-7d81-4f19-95e5-d5bf0b479d2e + smi:local/auto + P + positive + + + + + smi:local/29c133cd-166e-4ac5-819b-78a5a1588518 + smi:local/auto + P + positive + + + + + smi:local/c60f5ad2-60b2-499f-8c3c-b9d8df8c5330 + smi:local/auto + P + positive + + + + + smi:local/a28efd15-934a-44ca-8d46-cb4a58b2737c + smi:local/auto + P + positive + + + + + smi:local/4bc77cda-538d-4d8e-acc6-09b777edb023 + smi:local/auto + P + positive + + + + + smi:local/6fa3b058-4381-4ba3-afc3-98889def21ae + smi:local/auto + P + positive + + + + + smi:local/4575c1c4-8f7a-43f4-8536-5d9b0aec4c7e + smi:local/auto + P + positive + + + + + smi:local/5b3089a9-86af-409f-b78d-d215cf80f488 + smi:local/auto + P + positive + + + + + smi:local/da50a613-4c30-4a28-aeb6-64dc60dc02e7 + smi:local/auto + P + positive + + + + + smi:local/b53adbfd-25e0-4a2d-8349-dd1234d2f6ab + smi:local/auto + P + positive + + + + + smi:local/21a60b42-1ef3-4aa8-850e-d7188c2c8a03 + smi:local/auto + P + positive + + + + + smi:local/297a34fb-043d-4b26-81e4-ec43fb8697fd + smi:local/auto + P + positive + + + + + smi:local/6001105c-40c9-45b8-a0c8-9077abeb2754 + smi:local/auto + P + positive + + + + + smi:local/bf09bb2a-70e4-461f-8e17-2c2848e05f7e + smi:local/auto + P + positive + + + + + smi:local/a9090e92-30a7-4cb8-8314-17bfc5998f20 + smi:local/auto + P + positive + + + + + smi:local/fe7ac163-5435-431f-94a1-a4673cd99214 + smi:local/auto + P + positive + + + + + smi:local/437d67b3-3463-4911-b524-e9474a024f18 + smi:local/auto + P + positive + + + + + smi:local/7534cb4e-0d59-473c-8b5c-82ae37ad0520 + smi:local/auto + P + positive + + + + + smi:local/ad7c6fa7-9107-4d96-bf0e-fb750cbb916a + smi:local/auto + P + positive + + + + + smi:local/52708dbd-60eb-47db-bb33-d3471a24f7b4 + smi:local/auto + P + positive + + + + + smi:local/9cad642e-7786-4274-be04-297e7b88da5d + smi:local/auto + P + positive + + + + + smi:local/d1bd0fb4-ebdd-47d6-9553-60e2a2360613 + smi:local/auto + P + positive + + + + + smi:local/74e3b80b-e39c-476d-894a-5078c06bed69 + smi:local/auto + P + positive + + + + + smi:local/5345c244-e0b4-49c8-b30e-c124c4e202a5 + smi:local/auto + P + positive + + + + + smi:local/d6207a4e-2349-40e4-8e50-15ce2e70f3de + smi:local/auto + P + positive + + + + + smi:local/e6645c3b-dd98-4f19-9765-c5fda388c0f1 + smi:local/auto + P + positive + + + + + smi:local/fcd2eec7-3d0f-4711-9caf-9d215b913230 + smi:local/auto + P + positive + + + + + smi:local/03e929e2-5f97-4977-b0a4-ae63814a4799 + smi:local/auto + P + positive + + + + + smi:local/2b67c51e-0ddf-456c-9b61-e672491dba24 + smi:local/auto + P + positive + + + + + smi:local/f85739d6-1b0a-4a72-996e-9b2906bef300 + smi:local/auto + P + positive + + + + + smi:local/0d6d82e5-5015-41c0-9e53-c39884197d14 + smi:local/auto + P + positive + + + + + smi:local/8198bd63-be50-4782-809e-8cf51118c165 + smi:local/auto + P + positive + + + + + smi:local/5649a547-1adb-4ee7-b1d3-f546d9bf1330 + smi:local/auto + P + positive + + + + + smi:local/de3a579f-6b5a-4aae-a17d-3a8046ef51db + smi:local/auto + P + positive + + + + + smi:local/48fc9a3d-9fd6-4d7e-ac10-1247af798141 + smi:local/auto + P + positive + + + + + smi:local/b08d2da2-5076-4469-96fa-ead8539ee245 + smi:local/auto + P + positive + + + + + smi:local/07441d78-c89e-4d03-9082-eb6d2770e281 + smi:local/auto + P + positive + + + + + smi:local/d7374fc2-b343-4b31-aae4-67d30cc3ef5d + smi:local/auto + P + positive + + + + + smi:local/2abfdb38-2189-4de9-8986-d0b87c72a485 + smi:local/auto + P + positive + + + + + smi:local/c119614b-9ae8-4d8e-8aa5-a0f9edb51881 + smi:local/auto + P + positive + + + + + smi:local/fb2228e8-47af-483b-a586-6098de008339 + smi:local/auto + P + positive + + + + + smi:local/ad6872bc-d643-405e-86b5-2c44bb44e0a4 + smi:local/auto + P + positive + + + + + smi:local/6230185e-9532-4b32-ba5b-18f82be88187 + smi:local/auto + P + positive + + + + + smi:local/d41fa7e6-ba3d-4c2c-af53-7184f2237fab + smi:local/auto + P + positive + + + + + smi:local/a9a58fa7-dbe4-48b1-8ebc-87c8b4ff1704 + smi:local/auto + P + positive + + + + + smi:local/bbc718b2-342e-4887-ac5d-3ddc8c8b05c6 + smi:local/auto + P + positive + + + + + smi:local/76808e73-c620-4de1-ab14-bfa05fe7309d + smi:local/auto + P + positive + + + + + smi:local/649fd9f9-92d1-459c-ba80-9e0752249044 + smi:local/auto + P + positive + + + + + smi:local/1857eb5c-915f-486e-9ba3-510e6cd41825 + smi:local/auto + P + positive + + + + + smi:local/d78ba228-f4b5-470e-9433-3cddf3f2f1e2 + smi:local/auto + P + positive + + + + + smi:local/91bbb2be-c03a-4704-a409-7d0fbd6b2088 + smi:local/auto + P + positive + + + + + smi:local/3904441c-bd3c-4a63-9cdc-e72bd7285311 + smi:local/auto + P + positive + + + + + smi:local/53e4ec90-850d-490c-8cd4-f55d7feb699a + smi:local/auto + P + positive + + + + + smi:local/7e2325b1-b930-4de5-87f3-efcedecc5a34 + smi:local/auto + P + positive + + + + + smi:local/b29d4bd6-c02e-4e8e-badd-ac96d39ef119 + smi:local/auto + P + positive + + + + + smi:local/b011a9e2-b212-4068-9189-4016a882eb43 + smi:local/auto + P + positive + + + + + smi:local/ed432bc9-8b3a-4c51-a53d-3bec21d79957 + smi:local/auto + P + positive + + + + + smi:local/071679b8-e914-44d1-8507-f915a42ddfef + smi:local/auto + P + positive + + + + + smi:local/c1c993af-4f6b-4ba3-9144-e60c98eccaae + smi:local/auto + P + positive + + + + + smi:local/78bbea91-45b6-4979-8fda-22c9e2feb941 + smi:local/auto + P + positive + + + + + smi:local/e8365fea-a0ee-4b87-a42e-c35eb7b38c55 + smi:local/auto + P + positive + + + + + smi:local/1a89507e-568e-476a-9fea-91010842c1ea + smi:local/auto + P + positive + + + + + smi:local/afe897e0-321a-4f50-836f-abe0246c7f3f + smi:local/auto + P + positive + + + + + smi:local/60abc3b2-8d3d-42eb-a888-a3841066f8d5 + smi:local/auto + P + positive + + + + + smi:local/e6fe463a-8916-4989-a5ce-b2f4d0fb86b6 + smi:local/auto + P + positive + + + + + smi:local/a21f8128-4ac9-478c-bf08-799b406db1f8 + smi:local/auto + P + positive + + + + + smi:local/6b966f7f-bf35-4b5a-af25-ec2894f8ae91 + smi:local/auto + P + positive + + + + + smi:local/5b2f01f6-12d6-47c3-9cd3-ba557a9855fd + smi:local/auto + P + positive + + + + + smi:local/c9510860-49db-4e31-9d9e-e74fcb49db08 + smi:local/auto + P + positive + + + + + smi:local/2dcb1d50-11cf-4c57-ac7c-50cd1b999e28 + smi:local/auto + P + positive + + + + + smi:local/ae28101d-93bb-4ebd-85b7-f3f086bd3028 + smi:local/auto + P + positive + + + + + smi:local/f57a7663-fe01-45a9-a128-3a2f25417659 + smi:local/auto + P + positive + + + + + smi:local/e297cd53-da69-4b64-9b5c-5d60ae9c2acb + smi:local/auto + P + positive + + + + + smi:local/9072704a-0d41-43c1-a267-bd6f9306efc3 + smi:local/auto + P + positive + + + + + smi:local/123d7378-c7e2-4e58-bf6b-85688a63e4d6 + smi:local/auto + P + positive + + + + + smi:local/d0d9d0c9-de3b-49e6-b757-7c21ab614baa + smi:local/auto + P + positive + + + + + smi:local/7012c490-6638-46af-b189-9a54ed7a5637 + smi:local/auto + P + positive + + + + + smi:local/545741b2-3783-49f6-a1e5-12150e28a742 + smi:local/auto + P + positive + + + + + smi:local/0c0a672c-a843-4dfb-a6dc-2ad50c6eaa5e + smi:local/auto + P + positive + + + + + smi:local/7ba6f0fe-2976-4b25-ba32-2908fbf3831f + smi:local/auto + P + positive + + + + + smi:local/a5ed51c7-9d21-4675-8d6f-8e7c274d3928 + smi:local/auto + P + positive + + + + + smi:local/34262dc1-1f25-40e0-bbc5-f0b5ff20085c + smi:local/auto + P + positive + + + + + smi:local/35fda087-47c1-4050-8f22-caccbd33fc08 + smi:local/auto + P + positive + + + + + smi:local/b343dc80-41dc-4ae9-8868-e5de5a020d81 + smi:local/auto + P + positive + + + + + smi:local/d51d2803-c674-4552-a4d7-ea97c7172bbb + smi:local/auto + P + positive + + + + + smi:local/183087be-8c93-4104-85c2-69d4696e856d + smi:local/auto + P + positive + + + + + smi:local/39e95734-424a-461a-9dd0-7b27b671664c + smi:local/auto + P + positive + + + + + smi:local/ee4607f8-0c41-4ce7-80a2-f59093339806 + smi:local/auto + P + positive + + + + + smi:local/f7172034-b641-40d2-a0fc-eccae2bb26b4 + smi:local/auto + P + positive + + + + + smi:local/2d46bad8-6b3b-465f-9047-ca4eccda2a6d + smi:local/auto + P + positive + + + + + smi:local/ab07a48c-e33b-4d0e-a8ef-73bebaf927dd + smi:local/auto + P + positive + + + + + smi:local/6e8a8b75-e284-4b4c-966d-1cc644147dbc + smi:local/auto + P + positive + + + + + smi:local/1074b3f2-4103-412e-a14c-4eb6471976e3 + smi:local/auto + P + positive + + + + + smi:local/341ceb97-f10b-41de-be8d-7b29718bcf86 + smi:local/auto + P + positive + + + + + smi:local/f8764891-259b-4b0e-ad05-88573a3691b6 + smi:local/auto + P + positive + + + + + smi:local/3b7c593b-cbd5-49fe-bb21-0d56e215c457 + smi:local/auto + P + positive + + + + + smi:local/d10d0634-4657-4e43-9fa8-59c836651c6a + smi:local/auto + P + positive + + + + + smi:local/45fa8813-b60a-4b02-8f58-53c5c8b8dfbe + smi:local/auto + P + positive + + + + + smi:local/199d98c2-1088-4342-8a57-0e1d3abd12fb + smi:local/auto + P + positive + + + + + smi:local/997595d7-4547-4e18-9681-6dee7151c804 + smi:local/auto + P + positive + + + + + smi:local/a3371c6e-ca31-4924-82c3-9393aff40c57 + smi:local/auto + P + positive + + + + + smi:local/52c0b81d-ab70-465a-8850-e942c366e98f + smi:local/auto + P + positive + + + + + smi:local/e2728da9-1864-4c0f-8c4b-cf15b15458d1 + smi:local/auto + P + positive + + + + + smi:local/711bcfd4-f90e-4d3a-ad07-cf5d0f184d56 + smi:local/auto + P + positive + + + + + smi:local/a0ec6235-3c13-4ec6-9676-8827d1b29e0f + smi:local/auto + P + positive + + + + + smi:local/4f9e399c-3ee1-4a1c-9c18-bc6b6bf8aa77 + smi:local/auto + P + positive + + + + + smi:local/4d2a90eb-006b-4ad2-b240-f5cddb99739c + smi:local/auto + P + positive + + + + + smi:local/4dcea778-edcb-4e0f-bf83-6af2909669d1 + smi:local/auto + P + positive + + + + + smi:local/b430c599-65ea-46ff-8a05-623d18e6a7dd + smi:local/auto + P + positive + + + + + smi:local/55e92dea-dbb8-407e-9480-4f975f8caeb8 + smi:local/auto + P + positive + + + + + smi:local/d77eb623-5654-4fad-8b69-b41642f9c0c9 + smi:local/auto + P + positive + + + + + smi:local/6f915f85-3e79-468a-8533-3ca1521f819c + smi:local/auto + P + positive + + + + + smi:local/5fa8cf88-3050-4980-9eab-1cf82cbad6e1 + smi:local/auto + P + positive + + + + + smi:local/b882de68-e6b3-4866-bf73-131d5562b0ee + smi:local/auto + P + positive + + + + + smi:local/56a357cd-ed93-4597-9bcb-37109474db63 + smi:local/auto + P + positive + + + + + smi:local/6954dcfb-6be6-4b11-ba98-71b5cdbf2bbf + smi:local/auto + P + positive + + + + + smi:local/8334188d-9bf2-406b-ae8d-4292df7ebb03 + smi:local/auto + P + positive + + + + + smi:local/306ec5f3-aa10-4c36-9eaf-e58bf6b8dccd + smi:local/auto + P + positive + + + + + smi:local/d9fbd7a7-68b6-4c12-9b70-5ff76e7ed700 + smi:local/auto + P + positive + + + + + smi:local/4f7faa90-5006-406f-b54b-27fd7a1319ed + smi:local/auto + P + positive + + + + + smi:local/18b80f17-fdf4-479e-8226-41d007eb1777 + smi:local/auto + P + positive + + + + + smi:local/3d81e879-9079-4073-994c-7cfb6117132e + smi:local/auto + P + positive + + + + + smi:local/b09afaf0-39c2-4de7-8e67-821dd300a469 + smi:local/auto + P + positive + + + + + smi:local/4e706cc2-d31e-4492-b194-eb75312a4135 + smi:local/auto + P + positive + + + + + smi:local/14b3a8c5-9fd9-4e52-ac69-bae2a8f54621 + smi:local/auto + P + positive + + + + + smi:local/027ba6c5-8947-4c16-8cb6-640b93aea7f7 + smi:local/auto + P + positive + + + + + smi:local/d008461e-3231-43a8-b47b-830ff90d8f0e + smi:local/auto + P + positive + + + + + smi:local/281e6615-4de9-4e38-9318-4e5efa7f2e7e + smi:local/auto + P + positive + + + + + smi:local/58fab071-ff5c-4242-adc9-3f70760426f7 + smi:local/auto + P + positive + + + + + smi:local/e9b1ed46-ea96-4aae-83ae-9704176a2d72 + smi:local/auto + P + positive + + + + + smi:local/385ad27e-6403-4358-85d7-96e8cab4968e + smi:local/auto + P + positive + + + + + smi:local/f55bd4e1-9030-4669-bb6d-8212e118dd45 + smi:local/auto + P + positive + + + + + smi:local/b40d6ee8-86e4-456b-bf12-02f0e8f0d157 + smi:local/auto + P + positive + + + + + smi:local/0888ac01-405a-474a-bc9e-483552a91711 + smi:local/auto + P + positive + + + + + smi:local/870ca1a0-340d-401a-993e-2f4f5b23c54d + smi:local/auto + P + positive + + + + + smi:local/6dba21aa-494a-4bb9-a7df-829715ace923 + smi:local/auto + P + positive + + + + + smi:local/64b6a960-6dc2-4563-9e94-db8f83e737b6 + smi:local/auto + P + positive + + + + + smi:local/1ca26310-22f8-46ac-9750-4b64dd592aab + smi:local/auto + P + positive + + + + + smi:local/fb6846f6-a94b-47aa-806f-450cec3f17b3 + smi:local/auto + P + positive + + + + + smi:local/a3a14ca8-7c43-49ca-96fe-d171bd0ef280 + smi:local/auto + P + positive + + + + + smi:local/9e2a6c6c-4142-4069-9b02-69e3c14b330f + smi:local/auto + P + positive + + + + + smi:local/846d853b-c709-4bd5-a177-2f553ec63ff8 + smi:local/auto + P + positive + + + + + smi:local/8e4a23cb-efb1-4045-b784-f3b72fd93b14 + smi:local/auto + P + positive + + + + + smi:local/1f38c83d-b2b6-419b-b965-405410efa883 + smi:local/auto + P + positive + + + + + smi:local/400b9024-6793-476a-a735-87180a03bc95 + smi:local/auto + P + positive + + + + + smi:local/f64ab527-73d2-4a77-b8f8-4e58e9f9dc36 + smi:local/auto + P + positive + + + + + smi:local/b337a517-b09c-4ade-b0c0-9ad5a529307f + smi:local/auto + P + positive + + + + + smi:local/4ded52fb-c06b-437f-8b72-666c268904cc + smi:local/auto + P + positive + + + + + smi:local/cc008a27-b542-46ba-8c05-044de4392885 + smi:local/auto + P + positive + + + + + smi:local/dc104493-94a6-498b-b600-b3db9da0a31f + smi:local/auto + P + positive + + + + + smi:local/bc24befb-4abe-47e1-ab81-30aa707dd7c1 + smi:local/auto + P + positive + + + + + smi:local/d7c68463-7c13-4147-ad3e-f19860943c0e + smi:local/auto + P + positive + + + + + smi:local/611cb518-ca2a-4c24-ae99-c5186ab89375 + smi:local/auto + P + positive + + + + + smi:local/feb94750-494b-4834-ada2-5dabca294bce + smi:local/auto + P + positive + + + + + smi:local/77a5dfb3-5f88-4c27-914a-8eb97df217b2 + smi:local/auto + P + positive + + + + + smi:local/d3e87081-6402-477b-b320-44b63033bb7f + smi:local/auto + P + positive + + + + + smi:local/a7df407c-e3fd-4a54-8bc1-cc3ff362f202 + smi:local/auto + P + positive + + + + + smi:local/d3870653-dfad-4682-ba81-12cd09031ee0 + smi:local/auto + P + positive + + + + + smi:local/66c43519-158f-49f1-b525-3bc589445e12 + smi:local/auto + P + positive + + + + + smi:local/02bbb8ba-1737-4b7b-9593-e75537ef1e05 + smi:local/auto + P + positive + + + + + smi:local/8de85f44-bca0-449b-a1d0-299652cd1e87 + smi:local/auto + P + positive + + + + + smi:local/c04df920-f967-45a9-b657-82a7e84abb8d + smi:local/auto + P + positive + + + + + smi:local/f36074d3-68e6-4371-a40d-52928b692404 + smi:local/auto + P + positive + + + + + smi:local/0082652f-684a-4601-a2f5-3f827ff588cb + smi:local/auto + P + positive + + + + + smi:local/e8bb23cb-a279-4250-852a-c14e3c220643 + smi:local/auto + P + positive + + + + + smi:local/bd97a2c5-b4cb-41dc-8a2b-7577bb1e936c + smi:local/auto + P + positive + + + + + smi:local/e3543a08-53bf-4b3e-9f1a-f441d5d1cd2e + smi:local/auto + P + positive + + + + + smi:local/6922431c-3161-4a50-b5bc-13ec1b9f41fc + smi:local/auto + P + positive + + + + + smi:local/b15002a2-0bd3-45e4-9b7d-bdfa5e26e31c + smi:local/auto + P + positive + + + + + smi:local/dd866ccf-0aca-447b-b374-01bf60c81b9e + smi:local/auto + P + positive + + + + + smi:local/cf95d583-cb40-4973-b9cd-0adbbae772fb + smi:local/auto + P + positive + + + + + smi:local/6aefcefb-0978-46b6-b01f-80d95fa790ed + smi:local/auto + P + positive + + + + + smi:local/39451eb8-6e3c-4ca8-b355-15bc00f1b091 + smi:local/auto + P + positive + + + + + smi:local/6fdd16e1-3b0a-4ee3-af40-e404ce9e371e + smi:local/auto + P + positive + + + + + smi:local/f63c00f7-2ae9-4dec-9f75-318903c26749 + smi:local/auto + P + positive + + + + + smi:local/f7e8b468-2dc0-4605-8680-8c22823801bf + smi:local/auto + P + positive + + + + + smi:local/a25c3d0d-bb3e-438b-a7aa-a50faa3272ab + smi:local/auto + P + positive + + + + + smi:local/1877d5db-326d-4b1c-9a6f-d25f67163b27 + smi:local/auto + P + positive + + + + + smi:local/10cfa175-ee36-490d-8bbc-d64aaf8e90f2 + smi:local/auto + P + positive + + + + + smi:local/283fa750-9d1c-4435-8b10-57c3b5acf0d2 + smi:local/auto + P + positive + + + + + smi:local/2f685963-f561-4383-81c7-0833f73004f1 + smi:local/auto + P + positive + + + + + smi:local/f244a800-6902-419e-8bbc-f290dcca04a6 + smi:local/auto + P + positive + + + + + smi:local/7b713941-66c7-4af5-bc9a-ea70f2da3eaa + smi:local/auto + P + positive + + + + + smi:local/494300e4-18d6-4a7b-8b57-14d44edbb8fa + smi:local/auto + P + positive + + + + + smi:local/d0f3a5d6-862d-464e-b99b-b817d5ab08e9 + smi:local/auto + P + positive + + + + + smi:local/4ab62a8e-c947-45bc-91d2-cc52b2f7092c + smi:local/auto + P + positive + + + + + smi:local/b4063c7b-6cbd-4411-a8a8-fe42a411f52a + smi:local/auto + P + positive + + + + + smi:local/a05f8283-d0b2-4934-a0ec-97861393b5fc + smi:local/auto + P + positive + + + + + smi:local/5ce2b68c-aa2d-411c-bf55-422b93016d96 + smi:local/auto + P + positive + + + + + smi:local/a6233409-e2e4-4680-9f42-21fd16e3a9eb + smi:local/auto + P + positive + + + + + smi:local/d9a56176-12bd-4fdc-8f00-f09161fa4d46 + smi:local/auto + P + positive + + + + + smi:local/4a598df8-b3e0-428c-9541-5ff136462022 + smi:local/auto + P + positive + + + + + smi:local/3979cf5a-8c90-419f-b103-ddce6a46394c + smi:local/auto + P + positive + + + + + smi:local/96dd8096-1bee-4cd8-a3aa-532389a32063 + smi:local/auto + P + positive + + + + + smi:local/6c3f2cdc-f3b0-469b-9a07-0d234525b62d + smi:local/auto + P + positive + + + + + smi:local/bb9eac19-0ece-4528-b5e7-7756fc1ea374 + smi:local/auto + P + positive + + + + + smi:local/e2f9dc0c-8d11-42d7-9871-82d1aadcdadf + smi:local/auto + P + positive + + + + + smi:local/3c958e58-4459-4112-bfe4-7317c35e3ba1 + smi:local/auto + P + positive + + + + + smi:local/ab3b1042-c130-4764-81c8-4609990ca516 + smi:local/auto + P + positive + + + + + smi:local/c4c0da7c-2317-4926-b490-08eb5f934254 + smi:local/auto + P + positive + + + + + smi:local/c17a0170-fb37-46e1-ac8e-a9630176a7fb + smi:local/auto + P + positive + + + + + smi:local/bec6d3ea-c453-40e9-8ab7-d1bc7c3b6a8f + smi:local/auto + P + positive + + + + + smi:local/377597a1-2524-4753-89e3-fbc16e792e9c + smi:local/auto + P + positive + + + + + smi:local/e9d81fd2-bff5-4b65-88ae-aba6152d78d9 + smi:local/auto + P + positive + + + + + smi:local/91969e87-1768-4953-99c3-b17df95bbc67 + smi:local/auto + P + positive + + + + + smi:local/4c54ea38-fca7-482d-b1eb-0d24e9d8e7fd + smi:local/auto + P + positive + + + + + smi:local/cf01b4eb-ee11-4a76-a1ab-34e8a9e5f64b + smi:local/auto + P + positive + + + + + smi:local/9c74b373-98e4-494e-9a51-0aaa3a4c8af0 + smi:local/auto + P + positive + + + + + smi:local/d5033735-fe3b-4670-8c46-9d21eb80950c + smi:local/auto + P + positive + + + + + smi:local/1fcba689-492e-4089-bf08-f97d4e82d82b + smi:local/auto + P + positive + + + + + smi:local/9190a759-8ecb-48e2-a910-84ab88ee33e5 + smi:local/auto + P + positive + + + + + smi:local/ef0b5f2d-25f1-4cc4-86fe-1b9b13f16044 + smi:local/auto + P + positive + + + + + smi:local/56a75e16-c750-456a-bfe7-fe4280baa56f + smi:local/auto + P + positive + + + + + smi:local/f1f8a3d4-271d-473b-8411-2fcb451aa65e + smi:local/auto + P + positive + + + + + smi:local/1d39327f-e718-4005-b757-cc0725a06bed + smi:local/auto + P + positive + + + + + smi:local/6d34862d-1a73-4d2c-8586-4258a4b71e88 + smi:local/auto + P + positive + + + + + smi:local/a3537160-c7ac-4104-9a08-15c2254755ae + smi:local/auto + P + positive + + + + + smi:local/c6308e08-b597-4734-8219-d1a17a25666d + smi:local/auto + P + positive + + + + + smi:local/1b451215-3aad-47e8-889f-8233288c2187 + smi:local/auto + P + positive + + + + + smi:local/48e598f7-8e74-41e2-a9cc-2ad2240c2a2a + smi:local/auto + P + positive + + + + + smi:local/aa63ee82-55c9-4838-8d2b-41bf396bfec1 + smi:local/auto + P + positive + + + + + smi:local/8616be32-381b-49eb-b012-a05c4da6aa1d + smi:local/auto + P + positive + + + + + smi:local/0f380e65-5707-4492-bdcb-6d0c868aa9e8 + smi:local/auto + P + positive + + + + + smi:local/e8e77b5d-68ee-40bb-a9ea-b942bf3aa4de + smi:local/auto + P + positive + + + + + smi:local/a9896389-b71b-489f-b458-27893bdba217 + smi:local/auto + P + positive + + + + + smi:local/baee6c9d-03e3-4009-8f2f-d587442feb45 + smi:local/auto + P + positive + + + + + smi:local/9ccd7cbf-4d55-4dc4-8886-c0c79e4f1f7f + smi:local/auto + P + positive + + + + + smi:local/149ee7e0-d71d-49c7-9783-25cea311144d + smi:local/auto + P + positive + + + + + smi:local/f0f135fc-62e7-4d2d-a276-cf76058086a3 + smi:local/auto + P + positive + + + + + smi:local/7c233300-03f7-45dd-9749-5b14bde3fff3 + smi:local/auto + P + positive + + + + + smi:local/c94387d9-5867-42e8-9573-7d5664764d10 + smi:local/auto + P + positive + + + + + smi:local/d0517e78-cf1b-4560-bdab-3f39aea12b5c + smi:local/auto + P + positive + + + + + smi:local/edda300f-3b21-44c0-af5a-4e5dfca69fda + smi:local/auto + P + positive + + + + + smi:local/4d096e80-5ce5-4aee-8732-327516ca33b3 + smi:local/auto + P + positive + + + + + smi:local/3065d459-cffc-444c-b9a9-c38414e850c9 + smi:local/auto + P + positive + + + + + smi:local/13752bc9-fc4d-43d7-b686-1e9c94d34d47 + smi:local/auto + P + positive + + + + + smi:local/0417be3b-8eba-4b55-9ada-56ac532719e3 + smi:local/auto + P + positive + + + + + smi:local/4334cb50-9f39-4152-b3ce-019f15bcfa65 + smi:local/auto + P + positive + + + + + smi:local/33b05ef3-1f8b-462c-b8f5-e27fcda23431 + smi:local/auto + P + positive + + + + + smi:local/bf442409-3268-4d5f-a82e-2055fb4d217f + smi:local/auto + P + positive + + + + + smi:local/17ed3b79-58ab-4e9b-96fb-7902214f4779 + smi:local/auto + P + positive + + + + + smi:local/10df8643-60bf-414d-82d8-a9506441b52d + smi:local/auto + P + positive + + + + + smi:local/f47a7ddd-2d3a-4f78-ac96-c7de87e72126 + smi:local/auto + P + positive + + + + + smi:local/ec9920a2-acf6-4f27-8e9d-16ed19e0d2af + smi:local/auto + P + positive + + + + + smi:local/893e5f36-d13d-409a-9f79-4f2550fe6c0f + smi:local/auto + P + positive + + + + + smi:local/8b213d55-f49b-4473-a299-7e23f93c1fb4 + smi:local/auto + P + positive + + + + + smi:local/d23cb1bc-cb2f-416b-a9b8-ee720fb1a318 + smi:local/auto + P + positive + + + + + smi:local/125d8cf9-ea04-42ca-ad96-94fce4f5275c + smi:local/auto + P + positive + + + + + smi:local/a609d6d2-afc4-4051-b680-423996894750 + smi:local/auto + P + positive + + + + + smi:local/b08f9fa5-df00-4664-b648-19187c0e8c47 + smi:local/auto + P + positive + + + + + smi:local/9e50f5fe-4ad0-4a44-b88e-b0f5d32c5748 + smi:local/auto + P + positive + + + + + smi:local/b037bf1f-6280-4bac-862b-4af8073e0173 + smi:local/auto + P + positive + + + + + smi:local/73c3e973-5f7b-4931-a46c-dcb3eba19051 + smi:local/auto + P + positive + + + + + smi:local/dd0b3ce4-0ef4-40a3-835b-994481b78379 + smi:local/auto + P + positive + + + + + smi:local/0bec725a-8058-431c-81f2-c174f76b2d04 + smi:local/auto + P + positive + + + + + smi:local/295c52b9-b489-4aea-a5c4-a8157dbd529b + smi:local/auto + P + positive + + + + + smi:local/7ea1aeed-2853-48e5-b868-5d990f22dbd7 + smi:local/auto + P + positive + + + + + smi:local/d28f2024-0c83-4fac-9380-4e8784e5fbf9 + smi:local/auto + P + positive + + + + + smi:local/51aaf204-c0b4-43ce-be60-2afb8eeda3ac + smi:local/auto + P + positive + + + + + smi:local/9389c689-dcbd-4b1d-b8a7-36aefebd2957 + smi:local/auto + P + positive + + + + + smi:local/a4869198-052d-4292-ae3b-9bdc3d0368ff + smi:local/auto + P + positive + + + + + smi:local/b0480680-3614-493d-9d4c-895c2e72421e + smi:local/auto + P + positive + + + + + smi:local/e5f09cc4-869b-4720-bddc-91747bc4cd32 + smi:local/auto + P + positive + + + + + smi:local/faf9009b-2e20-45c7-922c-319c3d01e7cf + smi:local/auto + P + positive + + + + + smi:local/4a970621-b25f-4cbf-a278-bad26e0b4b99 + smi:local/auto + P + positive + + + + + smi:local/be019834-0df6-4e26-a6d0-e7ba5a88ad67 + smi:local/auto + P + positive + + + + + smi:local/d6af2c8b-dbbb-4f2c-a88d-34f718900e99 + smi:local/auto + P + positive + + + + + smi:local/ddb4717b-bde7-4d7e-ac95-630846140891 + smi:local/auto + P + positive + + + + + smi:local/58b1440c-d094-4328-abeb-71979216d2ed + smi:local/auto + P + positive + + + + + smi:local/7ba182dd-bdf6-4976-872b-0c5917798eaa + smi:local/auto + P + positive + + + + + smi:local/1b8046b8-84b4-4f52-89e3-c159fac46e7d + smi:local/auto + P + positive + + + + + smi:local/da9edb0d-daa6-428c-8ae1-deee8aa98a4d + smi:local/auto + P + positive + + + + + smi:local/e06f6942-3dd7-4d83-a413-cb7ee3ca69f9 + smi:local/auto + P + positive + + + + + smi:local/71214fcd-a39c-43a5-8566-070da6ecc6b9 + smi:local/auto + P + positive + + + + + smi:local/113f1235-1b72-4c71-87e9-19da06d1d8d0 + smi:local/auto + P + positive + + + + + smi:local/0c0a4908-f355-44f3-9e4f-d89330c44e12 + smi:local/auto + P + positive + + + + + smi:local/07441ea6-17e4-4c29-ae54-295c97ecb84d + smi:local/auto + P + positive + + + + + smi:local/60fa553f-8333-40aa-94fb-ecda4a23877e + smi:local/auto + P + positive + + + + + smi:local/4e585e50-42a8-4b9f-809a-3880c97e9146 + smi:local/auto + P + positive + + + + + smi:local/34fabca6-0ddd-4b50-8c22-02744d8bc71d + smi:local/auto + P + positive + + + + + smi:local/18902d8b-704e-4b45-9257-10589d5e294a + smi:local/auto + P + positive + + + + + smi:local/891a0dfe-45d6-444b-9998-aab08d1c0a7f + smi:local/auto + P + positive + + + + + smi:local/ec4cbbec-4194-4123-b1ba-7612e64614f6 + smi:local/auto + P + positive + + + + + smi:local/34110c71-ab00-42ed-9c3a-2e6c111543ef + smi:local/auto + P + positive + + + + + smi:local/8e3f948c-c3ee-4b23-8e96-b434f2b17485 + smi:local/auto + P + positive + + + + + smi:local/b151fa10-efbf-4d0f-8d81-45b2a026d5c3 + smi:local/auto + P + positive + + + + + smi:local/4054c53f-420c-4e6c-8967-aa657e99afca + smi:local/auto + P + positive + + + + + smi:local/8ac31b96-0fb3-43fc-a180-f0854f238dad + smi:local/auto + P + positive + + + + + smi:local/1a563293-1b72-4467-b83b-da01f4dfa310 + smi:local/auto + P + positive + + + + + smi:local/88146b9c-1e3a-406a-84d1-fe72cf4efdb0 + smi:local/auto + P + positive + + + + + smi:local/0b7309de-2178-4caf-932c-8d684488c57b + smi:local/auto + P + positive + + + + + smi:local/177e8dcc-2e73-4cdf-887a-f340bbb447c7 + smi:local/auto + P + positive + + + + + smi:local/979e5940-5e9e-4912-b1d8-a262516d0220 + smi:local/auto + P + positive + + + + + smi:local/e1e856ff-42af-442d-a034-67a26a064ff0 + smi:local/auto + P + positive + + + + + smi:local/1f48e22c-cafa-4391-857e-5a9496d6884c + smi:local/auto + P + positive + + + + + smi:local/435815fb-8012-4a02-ad03-b0555ae6b087 + smi:local/auto + P + positive + + + + + smi:local/e949869a-4f6a-4d7c-9152-0f2e95f3476c + smi:local/auto + P + positive + + + + + smi:local/ecbddbf5-0f33-4ab2-9bc4-ed7c76751f7c + smi:local/auto + P + positive + + + + + smi:local/d260f99c-bc96-4d06-95e8-85e5c39fcef9 + smi:local/auto + P + positive + + + + + smi:local/a7ed951c-70ea-4c4c-b60b-92ecd7de9af5 + smi:local/auto + P + positive + + + + + smi:local/a9b28b7a-1ab8-4d88-8be3-8b0ecfaac19f + smi:local/auto + P + positive + + + + + smi:local/c426f3cf-a22b-412b-ad0b-12869f3c18b7 + smi:local/auto + P + positive + + + + + smi:local/d0aa3bb3-4a3e-4c30-b62e-cae801b1a73f + smi:local/auto + P + positive + + + + + smi:local/e332b063-38c6-4042-83db-34d8bd20bae5 + smi:local/auto + P + positive + + + + + smi:local/62fa7d1b-7e83-4040-a958-2bec82da7ec8 + smi:local/auto + P + positive + + + + + smi:local/b7b12797-4e62-436e-8fdb-3b9bb421fee8 + smi:local/auto + P + positive + + + + + smi:local/a2531ad5-fe44-40d3-9dca-e0cfa36cb188 + smi:local/auto + P + positive + + + + + smi:local/f8122ee0-5429-401a-b6d6-6fd17ab75f57 + smi:local/auto + P + positive + + + + + smi:local/1da226f4-1a73-48aa-ba26-394be2103c11 + smi:local/auto + P + positive + + + + + smi:local/8004c91c-7c7e-4b24-8784-5ddf86a2493b + smi:local/auto + P + positive + + + + + smi:local/15dad8f2-7515-4653-b799-1dcf53b73ba7 + smi:local/auto + P + positive + + + + + smi:local/a7e3cf90-4d34-4c9d-b51f-72c0ae095249 + smi:local/auto + P + positive + + + + + smi:local/993720ad-51ee-4c9b-be83-0c16e8aca962 + smi:local/auto + P + positive + + + + + smi:local/7f6fca4a-757c-4884-a98a-f24cbfd1c9a3 + smi:local/auto + P + positive + + + + + smi:local/3cd254bb-9655-4cdc-9299-f0f9c9275a14 + smi:local/auto + P + positive + + + + + smi:local/e9c6a6e1-6c36-4dce-8fdc-7a877abd543b + smi:local/auto + P + positive + + + + + smi:local/b6bbe3b2-199c-4be3-a4c7-c8d02ed1b3b8 + smi:local/auto + P + positive + + + + + smi:local/ccd348d7-6981-49ee-94f4-c469db528d21 + smi:local/auto + P + positive + + + + + smi:local/e6c0cf41-940b-4498-a1cc-6eb00d1ed96e + smi:local/auto + P + positive + + + + + smi:local/9ad7f261-4353-4704-ad0d-43f0b06d2837 + smi:local/auto + P + positive + + + + + smi:local/aff2a313-d447-400b-90d9-9cde5e957206 + smi:local/auto + P + positive + + + + + smi:local/61b397f3-f654-49ae-812d-8c6ec65a04d7 + smi:local/auto + P + positive + + + + + smi:local/fd49c53c-a0c1-43d2-ab73-e73307fb95b1 + smi:local/auto + P + positive + + + + + smi:local/037894cd-8a12-460a-acbf-cb548a8325c3 + smi:local/auto + P + positive + + + + + smi:local/f0460cd8-6f95-4ab2-ac77-6089c31b7899 + smi:local/auto + P + positive + + + + + smi:local/c4790572-f275-4bfb-afaf-4f8d36331ea1 + smi:local/auto + P + positive + + + + + smi:local/b6156373-efb5-4984-b957-1c26d64242fe + smi:local/auto + P + positive + + + + + smi:local/c74a872d-5fd4-4f25-9fd4-f51e6cb63b18 + smi:local/auto + P + positive + + + + + smi:local/ef3b4be1-8a08-40d4-9b20-962b0ba2e163 + smi:local/auto + P + positive + + + + + smi:local/5f50b4a2-2e5f-4a05-931d-f51fd68b0ff4 + smi:local/auto + P + positive + + + + + smi:local/0f8444dc-9433-4f63-b49a-c3a197b967ff + smi:local/auto + P + positive + + + + + smi:local/11a20774-f15e-4d3d-8fc4-149921cb9546 + smi:local/auto + P + positive + + + + + smi:local/b39a1b9e-48ca-473c-91dc-16ec10a69a2f + smi:local/auto + P + positive + + + + + smi:local/bee34c63-81bc-434c-9876-0ba1d5775eaf + smi:local/auto + P + positive + + + + + smi:local/e2b07e79-cc9c-411d-81a4-f9811943507b + smi:local/auto + P + positive + + + + + smi:local/1fb48dde-04f4-4d46-8c0b-91f7405ca8e8 + smi:local/auto + P + positive + + + + + smi:local/36ecd606-49f4-4745-972b-edc71417a95a + smi:local/auto + P + positive + + + + + smi:local/1e1f8f44-b39a-48ec-8569-260fec946e7f + smi:local/auto + P + positive + + + + + smi:local/95372fe9-0cef-448d-8051-1cffb6e239bc + smi:local/auto + P + positive + + + + + smi:local/09f0276d-137f-4f12-a724-9dbc43f6ec7f + smi:local/auto + P + positive + + + + + smi:local/64f97130-7bc0-4580-9507-ddffb64bfb43 + smi:local/auto + P + positive + + + + + smi:local/62fc3be2-8b48-4ec0-ac0e-a56a96de2a1c + smi:local/auto + P + positive + + + + + smi:local/9da804b9-2c19-46f3-86af-5654af8dfad0 + smi:local/auto + P + positive + + + + + smi:local/24a9a4ea-4e5e-4ea5-86a7-c6e00a1ff45d + smi:local/auto + P + positive + + + + + smi:local/82d92302-b934-44d5-b916-c7080400778b + smi:local/auto + P + positive + + + + + smi:local/3a21a201-0fe8-48c0-94c6-053d6555b219 + smi:local/auto + P + positive + + + + + smi:local/06a77280-7255-4c9f-92d7-2b1d581d505a + smi:local/auto + P + positive + + + + + smi:local/6a2fac2c-272c-4220-b49d-d0226a035782 + smi:local/auto + P + positive + + + + + smi:local/4febe898-37dd-44e0-a36a-b42a89ecf0d1 + smi:local/auto + P + positive + + + + + smi:local/aea34179-57ca-4853-b7e8-d467ef75b4f8 + smi:local/auto + P + positive + + + + + smi:local/6bfb1030-da66-4c85-b01f-6987e866d3bc + smi:local/auto + P + positive + + + + + smi:local/54928179-8c98-4b5f-ac67-25af7ef13969 + smi:local/auto + P + positive + + + + + smi:local/0b1139a2-2e51-4c7b-b5ee-fd3dfec68e75 + smi:local/auto + P + positive + + + + + smi:local/ad829567-5627-4146-93c4-203ba57d9055 + smi:local/auto + P + positive + + + + + smi:local/ef53e6f4-1801-4142-b68b-4c82d320f783 + smi:local/auto + P + positive + + + + + smi:local/044088cf-3212-49b9-ae22-b68cea6b2ca6 + smi:local/auto + P + positive + + + + + smi:local/e5859291-a9a5-4c3f-8608-49225a7b93cb + smi:local/auto + P + positive + + + + + smi:local/bf8bd4b5-f210-4a32-bdec-91f8924608ec + smi:local/auto + P + positive + + + + + smi:local/fc1e917f-7824-4c7a-9c18-c35139f088d6 + smi:local/auto + P + positive + + + + + smi:local/c9fd1511-71c5-40a6-8d10-14701f8a92cd + smi:local/auto + P + positive + + + + + smi:local/af679aa8-c543-4a07-bf0b-e0521a8da211 + smi:local/auto + P + positive + + + + + smi:local/388f242e-94f1-44f6-834e-cddb79e69f2b + smi:local/auto + P + positive + + + + + smi:local/c28c8c3a-508e-40b8-ad87-6cfacafdef08 + smi:local/auto + P + positive + + + + + smi:local/98fef6fa-0a0a-42cd-a4f6-8e7da8b3802e + smi:local/auto + P + positive + + + + + smi:local/6089f072-46b5-4f8f-b076-bec6107202fd + smi:local/auto + P + positive + + + + + smi:local/2312e2a0-6e6a-4617-9389-8c7aeaa64c89 + smi:local/auto + P + positive + + + + + smi:local/3cb6bf84-67fd-4a48-b3a5-0242bc201301 + smi:local/auto + P + positive + + + + + smi:local/651a5f76-6d69-4165-b89f-781f8e9f851c + smi:local/auto + P + positive + + + + + smi:local/57be37d7-718c-4965-86d8-93f102f32c3b + smi:local/auto + P + positive + + + + + smi:local/657ef4fc-54b8-40b2-b72e-6bfbfeec9b4e + smi:local/auto + P + positive + + + + + smi:local/12d65edb-7e87-4953-80e6-fbeeefc28764 + smi:local/auto + P + positive + + + + + smi:local/56a611c0-f501-4cbc-ba35-8fb227ce92fd + smi:local/auto + P + positive + + + + + smi:local/a92050e2-0b55-4095-972c-f8599f981cd3 + smi:local/auto + P + positive + + + + + smi:local/13e6aab4-17b0-48f3-8fb1-9c321981199f + smi:local/auto + P + positive + + + + + smi:local/1f31f896-c884-4423-aa38-c83404a3936f + smi:local/auto + P + positive + + + + + smi:local/35998bfc-2024-4047-958c-684dcdc2c8cc + smi:local/auto + P + positive + + + + + smi:local/ff4b79c5-c2fd-4d8a-9e2e-435632f3c270 + smi:local/auto + P + positive + + + + + smi:local/cd47c590-c7b7-4db9-b35d-9646a43151fb + smi:local/auto + P + positive + + + + + smi:local/dfd0f05f-15f8-43b9-897a-9305306ba5af + smi:local/auto + P + positive + + + + + smi:local/a91ab5bc-95b5-4a5a-9ee6-cc82d7ac3109 + smi:local/auto + P + positive + + + + + smi:local/bb783c96-1731-4d30-aaeb-a26251a91717 + smi:local/auto + P + positive + + + + + smi:local/d488bf7c-8e7b-4a38-aab7-a85ee46613d2 + smi:local/auto + P + positive + + + + + smi:local/bad21d4b-c467-4092-8df0-c59b6c32ea4b + smi:local/auto + P + positive + + + + + smi:local/9c31cfe7-007a-4de8-8912-9ec167c03e52 + smi:local/auto + P + positive + + + + + smi:local/af250861-842a-413e-a3eb-27d2c523ab9b + smi:local/auto + P + positive + + + + + smi:local/56953f94-52f7-4421-bd96-ba804135646e + smi:local/auto + P + positive + + + + + smi:local/df17f104-41ed-4d3d-97ef-6e4abee2d6fe + smi:local/auto + P + positive + + + + + smi:local/40ea5867-89aa-4c96-a47c-3d6ffb65a2bc + smi:local/auto + P + positive + + + + + smi:local/953ab139-46f8-43cc-9c00-266522434773 + smi:local/auto + P + positive + + + + + smi:local/3b42278f-afba-40be-ba0b-a2c3471151cf + smi:local/auto + P + positive + + + + + smi:local/beb122fe-fcf7-4f58-87fc-f0f060eb0f04 + smi:local/auto + P + positive + + + + + smi:local/b515d95f-d2c5-483a-b2f0-95a701396300 + smi:local/auto + P + positive + + + + + smi:local/bc1cb607-6fa8-4f4b-8380-e9963bb4f41f + smi:local/auto + P + positive + + + + + smi:local/ddf8c806-931a-4823-9641-b3291cb2ddf9 + smi:local/auto + P + positive + + + + + smi:local/f9632201-eee9-41ba-88d0-2346d40c29e7 + smi:local/auto + P + positive + + + + + smi:local/33345e52-2c63-4ef6-b5f5-6e0120d4c77d + smi:local/auto + P + positive + + + + + smi:local/e6b39a71-7a6a-43f9-9ed3-34cfbdff19bf + smi:local/auto + P + positive + + + + + smi:local/d8dbeb80-b095-42c9-a8e3-5ca8ec47ccc8 + smi:local/auto + P + positive + + + + + smi:local/82b1a43f-2284-4c4c-afde-c4c3992e0851 + smi:local/auto + P + positive + + + + + smi:local/dbdf244c-a032-4083-91a7-5c8415da8453 + smi:local/auto + P + positive + + + + + smi:local/f108df77-6a1c-4f2b-8c27-8077d94054b5 + smi:local/auto + P + positive + + + + + smi:local/9fbf6027-4e6a-495c-90d8-309fe8e3657e + smi:local/auto + P + positive + + + + + smi:local/adc575d6-0261-4c77-b363-cd99debec9ac + smi:local/auto + P + positive + + + + + smi:local/90687ef8-6c71-45e8-8679-0b93a9d9acf9 + smi:local/auto + P + positive + + + + + smi:local/6918f77b-9655-43ba-994f-7561f42a8950 + smi:local/auto + P + positive + + + + + smi:local/f33247e5-59f2-40a2-a20b-c008b523ad5c + smi:local/auto + P + positive + + + + + smi:local/9b6c4ed9-5e2a-407c-87f2-592a1521409a + smi:local/auto + P + positive + + + + + smi:local/3d071fed-12ba-495f-8bc9-d922c1243008 + smi:local/auto + P + positive + + + + + smi:local/478c0560-2086-48a3-b8ab-1b762055d317 + smi:local/auto + P + positive + + + + + smi:local/3e51b67a-21fb-4df9-9d9c-95f8fccde3a1 + smi:local/auto + P + positive + + + + + smi:local/a5e1bae1-5d64-4316-acb5-a7516029b992 + smi:local/auto + P + positive + + + + + smi:local/df9df663-b1b0-43c3-9f4a-726daf387713 + smi:local/auto + P + positive + + + + + smi:local/a5556c86-64af-4b9b-a860-c7420ef74cdc + smi:local/auto + P + positive + + + + + smi:local/20628dbc-d400-4eab-b42b-6f6c047e5f4e + smi:local/auto + P + positive + + + + + smi:local/6aa7d876-34c2-4356-b828-0b7bee6668da + smi:local/auto + P + positive + + + + + smi:local/0dc7e86e-2e34-442a-a2fa-cff233465e6a + smi:local/auto + P + positive + + + + + smi:local/bdb2943d-b9f6-4bbb-b6b8-4698db00d207 + smi:local/auto + P + positive + + + + + smi:local/856e6d44-b5eb-403c-b0fd-eaafaeebfb26 + smi:local/auto + P + positive + + + + + smi:local/64c48e15-30c1-4c39-8e8d-59a2ca2c513e + smi:local/auto + P + positive + + + + + smi:local/1e757932-d991-4394-ab87-c0e39a29e67c + smi:local/auto + P + positive + + + + + smi:local/bb92398f-5335-42ed-a473-468f2d6e008e + smi:local/auto + P + positive + + + + + smi:local/5bc00223-0072-495b-a499-a4e07d136259 + smi:local/auto + P + positive + + + + + smi:local/3618a138-4d08-4f33-8695-e6fdbf49e705 + smi:local/auto + P + positive + + + + + smi:local/9282dc9e-8086-4527-a688-621ef144f769 + smi:local/auto + P + positive + + + + + smi:local/ca9b8f75-84b5-4875-8a8c-4bd31a0ce670 + smi:local/auto + P + positive + + + + + smi:local/50756220-cb7a-4a66-b814-8bcbe6b9dea6 + smi:local/auto + P + positive + + + + + smi:local/83136058-d80b-4e93-9970-820c411f814b + smi:local/auto + P + positive + + + + + smi:local/6560b1ed-54a8-47f5-9971-bdcf9f991ccf + smi:local/auto + P + positive + + + + + smi:local/d92914b1-8055-4ab2-8ff9-5bd39dbdafd4 + smi:local/auto + P + positive + + + + + smi:local/69eb309e-5967-4785-8c74-8c528b7b9a99 + smi:local/auto + P + positive + + + + + smi:local/16dacded-5065-450e-9d5c-f238c483ba90 + smi:local/auto + P + positive + + + + + smi:local/988302e7-3b97-45a4-a45e-703211cdd040 + smi:local/auto + P + positive + + + + + smi:local/d2307460-fad6-4d0f-a0c2-a9e7bb69902a + smi:local/auto + P + positive + + + + + smi:local/d9034483-ac30-4175-9ba6-acc97f2f3cd3 + smi:local/auto + P + positive + + + + + smi:local/88ae43eb-eea7-468a-badc-79be654b5a6f + smi:local/auto + P + positive + + + + + smi:local/5b2c46a8-24fc-45f7-813f-29bc7cf75f1a + smi:local/auto + P + positive + + + + + smi:local/b8459ef3-d7bc-4fb3-a8af-25e4385571f5 + smi:local/auto + P + positive + + + + + smi:local/c649eecd-9f6a-473d-8737-1fb367c438fd + smi:local/auto + P + positive + + + + + smi:local/83fd7537-ec44-4382-bc6a-c778d91dc432 + smi:local/auto + P + positive + + + + + smi:local/99c9149a-320c-456d-8851-b6031573da21 + smi:local/auto + P + positive + + + + + smi:local/2d6a4c90-25b6-4fe9-8e39-5d3bc277136a + smi:local/auto + P + positive + + + + + smi:local/0bd12c7b-c3e5-4e65-ba36-b49de10fbd83 + smi:local/auto + P + positive + + + + + smi:local/7d032949-7546-4fe0-95cd-f3c94226c695 + smi:local/auto + P + positive + + + + + smi:local/4e943c22-c0d8-47ee-bb1f-2e3e7fe6fe18 + smi:local/auto + P + positive + + + + + smi:local/f6ae073d-a076-4f56-ae20-e709ce1c1adc + smi:local/auto + P + positive + + + + + smi:local/763d7b55-22e8-4d23-805f-13987e34905c + smi:local/auto + P + positive + + + + + smi:local/648a275e-c650-4917-97a2-0f0345335584 + smi:local/auto + P + positive + + + + + smi:local/253ba215-c8fd-466b-9f06-2cb6a4f92e8b + smi:local/auto + P + positive + + + + + smi:local/de16a9d9-4b36-4557-8695-17344bae9f76 + smi:local/auto + P + positive + + + + + smi:local/671743a1-e915-4ca4-98f3-a69cffdedbe6 + smi:local/auto + P + positive + + + + + smi:local/33093136-0c34-4732-870f-96892a9afb13 + smi:local/auto + P + positive + + + + + smi:local/37e690e4-a2e4-43b8-826b-d9ab7d056f2a + smi:local/auto + P + positive + + + + + smi:local/eda3d89f-a316-4979-b4fb-7ff2af9385ca + smi:local/auto + P + positive + + + + + smi:local/ac66978b-f85c-49c1-9b05-a339ae458044 + smi:local/auto + P + positive + + + + + smi:local/2172020d-61ec-4fc9-bd47-cdbcc3d8a31d + smi:local/auto + P + positive + + + + + smi:local/61eacf5b-492c-43fe-99a6-61528944c5b2 + smi:local/auto + P + positive + + + + + smi:local/8afa6cf7-7990-4549-a119-98763ba8a378 + smi:local/auto + P + positive + + + + + smi:local/ad368501-7354-41bc-b90c-34f7f52ead85 + smi:local/auto + P + positive + + + + + smi:local/c228b926-0ca7-42d8-857f-aca052f92459 + smi:local/auto + P + positive + + + + + smi:local/1e35a1a1-6462-4451-93a6-d3b839691555 + smi:local/auto + P + positive + + + + + smi:local/25130e29-107a-4763-9ca3-47dac4cbb380 + smi:local/auto + P + positive + + + + + smi:local/f4ec3047-3869-44ae-925d-56685d6f92e7 + smi:local/auto + P + positive + + + + + smi:local/6f4df8b5-4b01-4a66-9ab7-24bb8393f0d6 + smi:local/auto + P + positive + + + + + smi:local/56d1087d-9480-4b83-9a16-d67d478b5af9 + smi:local/auto + P + positive + + + + + smi:local/28cf27ce-5262-4d5e-a278-a75770d440ae + smi:local/auto + P + positive + + + + + smi:local/fa4dacfa-d4cc-4051-9c5c-807ecb4599fb + smi:local/auto + P + positive + + + + + smi:local/517ca2c8-825b-4356-b465-02ad27dcf795 + smi:local/auto + P + positive + + + + + smi:local/0237dacd-b845-4172-a55d-c186249b9850 + smi:local/auto + P + positive + + + + + smi:local/b43f4c3d-c7bf-498e-b3c6-9ffdd109c1dc + smi:local/auto + P + positive + + + + + smi:local/78308856-ca2a-43a2-9d0d-eb5c776bc67f + smi:local/auto + P + positive + + + + + smi:local/61b5232a-db33-4979-a087-79a2943adb9e + smi:local/auto + P + positive + + + + + smi:local/962d7dea-42a5-4d0f-ade3-f1c004a54603 + smi:local/auto + P + positive + + + + + smi:local/05b68cec-c3bb-498f-bad4-7b712af1f950 + smi:local/auto + P + positive + + + + + smi:local/5dddcee2-1b06-4853-8d65-ae4813121aaa + smi:local/auto + P + positive + + + + + smi:local/e59ca40a-b715-4473-b8af-370a8956ff1f + smi:local/auto + P + positive + + + + + smi:local/3e877e5e-5519-46f4-939f-491b2cb2df19 + smi:local/auto + P + positive + + + + + smi:local/bd78c13d-b24a-47b7-ac60-24de95560ded + smi:local/auto + P + positive + + + + + smi:local/3448e6ea-73d9-4f55-b32c-2c685d7cd6c9 + smi:local/auto + P + positive + + + + + smi:local/0116780d-88f3-4882-a6b0-766005789f08 + smi:local/auto + P + positive + + + + + smi:local/368bae44-4591-4c9c-be78-bcf0c18f701f + smi:local/auto + P + positive + + + + + smi:local/83270f00-f70c-4f15-ae56-f09b013bc810 + smi:local/auto + P + positive + + + + + smi:local/6024a26a-4f4e-4a5c-87ff-89b4d7db9679 + smi:local/auto + P + positive + + + + + smi:local/8556ca0d-6735-40cb-98b8-2e79f875b650 + smi:local/auto + P + positive + + + + + smi:local/6ba049ed-aea7-4133-955a-6871c0315373 + smi:local/auto + P + positive + + + + + smi:local/ed702d88-f1a2-4568-a592-c778e4d28027 + smi:local/auto + P + positive + + + + + smi:local/1e35d2cd-265c-430e-b4ca-5261a49383a7 + smi:local/auto + P + positive + + + + + smi:local/acd7f7ca-ce9c-4159-a930-6e19b9a6d711 + smi:local/auto + P + positive + + + + + smi:local/7d96f438-77fb-47eb-b0a4-7f62a050828d + smi:local/auto + P + positive + + + + + smi:local/02ccc315-7298-4d95-9a97-51eb5db15e2d + smi:local/auto + P + positive + + + + + smi:local/b543d7cc-6acd-49ed-951c-48fb51dee255 + smi:local/auto + P + positive + + + + + smi:local/57c00349-4afb-40ba-83cf-ee5279496e4b + smi:local/auto + P + positive + + + + + smi:local/d1ad4e9c-95f7-4e04-98c3-0b9c7327654f + smi:local/auto + P + positive + + + + + smi:local/b4190a4f-2029-4043-bec1-bbd43861b44b + smi:local/auto + P + positive + + + + + smi:local/9bf47225-600d-4cc3-96da-e5d925ce3de9 + smi:local/auto + P + positive + + + + + smi:local/9990e4b7-2a22-4158-8875-042c385a382f + smi:local/auto + P + positive + + + + + smi:local/84febd43-2ac2-4c1a-a983-4ee7ef221517 + smi:local/auto + P + positive + + + + + smi:local/eaa632f8-fbd0-4b35-9fb7-9968ff40167a + smi:local/auto + P + positive + + + + + smi:local/01bd646f-844d-4751-8729-cec32c6bc715 + smi:local/auto + P + positive + + + + + smi:local/735074c9-6097-43a4-8920-82d6a4368c31 + smi:local/auto + P + positive + + + + + smi:local/6d124d41-c601-45cf-89a9-ee451a0b1cf6 + smi:local/auto + P + positive + + + + + smi:local/24753d47-d643-44ce-9fdc-c9226d4f6556 + smi:local/auto + P + positive + + + + + smi:local/e364eb5d-75d3-4bda-af92-2abfee49d469 + smi:local/auto + P + positive + + + + + smi:local/0174b35d-58f4-4d16-9339-7c6f85f6d52b + smi:local/auto + P + positive + + + + + smi:local/91c24476-a7f6-4725-86dd-a19ee9c90b83 + smi:local/auto + P + positive + + + + + smi:local/41d7c3cd-02d0-46c8-8e47-2fbd0790352e + smi:local/auto + P + positive + + + + + smi:local/3eeb1b6f-82c9-4e7b-a67d-7330233d8b29 + smi:local/auto + P + positive + + + + + smi:local/cced5a68-0401-48f2-bba9-d95e15f9a7b7 + smi:local/auto + P + positive + + + + + smi:local/822bf956-780e-42c2-8f01-f62bfa620277 + smi:local/auto + P + positive + + + + + smi:local/4b05bb71-175c-43a1-9a0b-fb04499e6fd4 + smi:local/auto + P + positive + + + + + smi:local/b05b2ecc-053c-4a7b-a70b-ea158c23b662 + smi:local/auto + P + positive + + + + + smi:local/d37c2be8-e110-4bd7-a731-468714ebb8ec + smi:local/auto + P + positive + + + + + smi:local/4b437b82-5d8b-4ba9-93d6-d765023e5844 + smi:local/auto + P + positive + + + + + smi:local/e633efdf-293a-458c-9368-d29086056ec5 + smi:local/auto + P + positive + + + + + smi:local/7d29a196-ed97-443a-98be-6c999fea831a + smi:local/auto + P + positive + + + + + smi:local/31e7843d-5ea6-44a3-945a-dcbd9a0872ff + smi:local/auto + P + positive + + + + + smi:local/73de1897-8926-44e0-84ba-785f3e80cff4 + smi:local/auto + P + positive + + + + + smi:local/eb04ef1a-07b7-4595-bb04-ad4ace9ec635 + smi:local/auto + P + positive + + + + + smi:local/532701e1-c193-4494-997e-dbe17425f8df + smi:local/auto + P + positive + + + + + smi:local/9dbd8542-b4bf-4f75-ba85-6276790979b1 + smi:local/auto + P + positive + + + + + smi:local/a0278670-4e81-4e17-9d27-8d386b56f67a + smi:local/auto + P + positive + + + + + smi:local/2ca95aa5-607d-4de2-a2d0-a6242db1cf7b + smi:local/auto + P + positive + + + + + smi:local/e565f008-01a7-4f8e-9450-080b00cb3147 + smi:local/auto + P + positive + + + + + smi:local/0dfa8493-e81d-4dad-b62d-5e6d83b9d9ba + smi:local/auto + P + positive + + + + + smi:local/659ffff6-dc8f-4848-b0a7-328b9864b13d + smi:local/auto + P + positive + + + + + smi:local/5e1ba00f-1d6e-4e26-aef1-53bb3639a736 + smi:local/auto + P + positive + + + + + smi:local/73695832-7c29-42ef-85c7-d955a2123804 + smi:local/auto + P + positive + + + + + smi:local/e07c66b8-e08e-49c0-8735-5ac76d3392c2 + smi:local/auto + P + positive + + + + + smi:local/84b987a5-6a95-4bd0-9d03-f5fe23324ae6 + smi:local/auto + P + positive + + + + + smi:local/a8bb814e-89a6-44c3-bc45-a31a2a4c9756 + smi:local/auto + P + positive + + + + + smi:local/e2c4e506-c803-44b2-b895-f73a8ec99114 + smi:local/auto + P + positive + + + + + smi:local/70833f9f-5537-4f28-aeef-d04500ae59b0 + smi:local/auto + P + positive + + + + + smi:local/d6e7d22e-201e-4fa3-ab5f-467f624b55f3 + smi:local/auto + P + positive + + + + + smi:local/2bd17790-4385-4ef9-b17b-a84b0aa7084f + smi:local/auto + P + positive + + + + + smi:local/8caee36e-65d9-4ee1-82c7-39f5517658d6 + smi:local/auto + P + positive + + + + + smi:local/6fd29b98-bcb0-424c-bf92-dea7a39c2be1 + smi:local/auto + P + positive + + + + + smi:local/6e455da2-a1b4-46f7-b133-66852eb82e15 + smi:local/auto + P + positive + + + + + smi:local/b5579d59-92d1-44b3-92f1-b5d781dd6cd2 + smi:local/auto + P + positive + + + + + smi:local/3f94229e-0586-46ef-aa89-96f3ba64b179 + smi:local/auto + P + positive + + + + + smi:local/5ffca42d-e945-4513-8954-d85e8397bd73 + smi:local/auto + P + positive + + + + + smi:local/55070268-3a53-47ad-a906-31e532c7a443 + smi:local/auto + P + positive + + + + + smi:local/2d4487d6-d685-4067-9b34-cd4a8350aabc + smi:local/auto + P + positive + + + + + smi:local/75b5cf63-9b91-4948-8cc9-6433713408e5 + smi:local/auto + P + positive + + + + + smi:local/6a728048-151b-4236-b70e-c1661857100a + smi:local/auto + P + positive + + + + + smi:local/725aa48b-4102-4a94-8f44-4c0ec5d8b55b + smi:local/auto + P + positive + + + + + smi:local/70106d55-c89c-427b-b3b3-c1a392e08847 + smi:local/auto + P + positive + + + + + smi:local/d45e89ff-8905-4ffb-a663-650ce5c45525 + smi:local/auto + P + positive + + + + + smi:local/d26d917c-6db2-41d3-834e-114feeebbd80 + smi:local/auto + P + positive + + + + + smi:local/95278c6c-ac62-4ec8-8f2a-adbe8e827ba3 + smi:local/auto + P + positive + + + + + smi:local/0e8fc90c-2791-48d6-8e32-5d512a189345 + smi:local/auto + P + positive + + + + + smi:local/fefbfe61-e400-4f87-a6fe-e818ab44bba2 + smi:local/auto + P + positive + + + + + smi:local/e01b6b4d-7eaf-465d-9eca-f0d6d8aba112 + smi:local/auto + P + positive + + + + + smi:local/3bf47870-d5dd-4e4b-8410-811ba4475a0f + smi:local/auto + P + positive + + + + + smi:local/194e6312-c432-42f4-a449-4767af22a6ef + smi:local/auto + P + positive + + + + + smi:local/70eb2ea0-fd54-48ad-b38b-ec62ccb5a6f9 + smi:local/auto + P + positive + + + + + smi:local/e695009c-df60-45ca-850e-41efe11b6936 + smi:local/auto + P + positive + + + + + smi:local/1108c1fa-b1fb-4296-80d6-43fb4883ffc1 + smi:local/auto + P + positive + + + + + smi:local/0c620dc6-fcf0-4ed5-8935-97c3d9baf1d0 + smi:local/auto + P + positive + + + + + smi:local/fe356c8f-7d68-49c3-917c-62d2d06b2df6 + smi:local/auto + P + positive + + + + + smi:local/6e40830b-b812-4560-b538-bb6b6efb5189 + smi:local/auto + P + positive + + + + + smi:local/5ca9bc5b-8a1c-4cf7-ad7b-6446d5329073 + smi:local/auto + P + positive + + + + + smi:local/165df953-9e03-412f-975b-710aed752687 + smi:local/auto + P + positive + + + + + smi:local/48d70b91-c324-41de-854b-f1b2875ab0a2 + smi:local/auto + P + positive + + + + + smi:local/863d857a-7509-4ebe-8711-30f3985a251b + smi:local/auto + P + positive + + + + + smi:local/4368e038-0ae5-42fa-8c7d-82db7b32cef0 + smi:local/auto + P + positive + + + + + smi:local/258742c5-a7c8-435c-a8e3-7597aaa7f125 + smi:local/auto + P + positive + + + + diff --git a/tests/test_autopicker/PyLoT_20171010_063224.a_saved_from_GUI.xml b/tests/test_autopicker/PyLoT_20171010_063224.a_saved_from_GUI.xml new file mode 100644 index 00000000..8260e679 --- /dev/null +++ b/tests/test_autopicker/PyLoT_20171010_063224.a_saved_from_GUI.xml @@ -0,0 +1,18672 @@ + + + + + + + + -18.58 + + + -69.86 + + + 106.4 + + + + + 6.27 + + Mwc + smi:local/ndk/C201710100632A/origin#cmtorigin + + + + + smi:local/a040f378-2517-484f-8f69-af162b015920 + smi:local/auto + P + undecidable + + + + + smi:local/886828e6-9811-4701-b19d-8b33b9b547ac + smi:local/auto + S + undecidable + + + + + smi:local/92bc9516-cf25-44bb-8fae-c5163f544034 + smi:local/auto + P + undecidable + + + + + smi:local/73e6b7ae-3f3a-4167-8d59-bfceab2a52fa + smi:local/auto + S + undecidable + + + + + smi:local/da64152e-63cf-4065-a49d-d82fedc9d406 + smi:local/auto + P + undecidable + + + + + smi:local/4b055598-e7e0-4177-bbcc-accc302f00e6 + smi:local/auto + S + undecidable + + + + + smi:local/6f64ef1d-c768-41a6-9924-3e127c66c0d3 + smi:local/auto + P + undecidable + + + + + smi:local/1923a064-a3c8-4d5f-ba0e-6d745bb1656b + smi:local/auto + S + undecidable + + + + + smi:local/f9194b75-b0cb-41a7-8bf5-fac25ff5b3d3 + smi:local/auto + P + undecidable + + + + + smi:local/4a8c4282-9cc4-414b-8241-d722546fb492 + smi:local/auto + S + undecidable + + + + + smi:local/2c561cce-84ad-4211-a338-b18d7730b1c4 + smi:local/auto + P + undecidable + + + + + smi:local/c1bcf81c-f09d-42f2-b14b-35b789c0583e + smi:local/auto + S + undecidable + + + + + smi:local/1756034c-e9cb-4029-ae05-bd06b2718fa4 + smi:local/auto + P + undecidable + + + + + smi:local/ff36a1fe-9c72-497a-9164-52ebe273d523 + smi:local/auto + S + undecidable + + + + + smi:local/e765e8ce-d6b4-4587-bdd7-f33876b6bf08 + smi:local/auto + P + undecidable + + + + + smi:local/a1b88e5f-caa5-43e6-8846-fc240a432083 + smi:local/auto + S + undecidable + + + + + smi:local/db157a37-85e7-4229-b176-3dbe2ec62b70 + smi:local/auto + P + undecidable + + + + + smi:local/c2d6baab-fc4f-43b4-b668-d1a59b03df1b + smi:local/auto + S + undecidable + + + + + smi:local/75ad284c-e85a-46f6-9884-98c4ad6981fe + smi:local/auto + P + undecidable + + + + + smi:local/9cfdac55-bcbb-42ab-8617-da62cd57f24a + smi:local/auto + S + undecidable + + + + + smi:local/30855452-fbd9-4697-9845-bc23c4d2b971 + smi:local/auto + P + undecidable + + + + + smi:local/5cd989ee-b04c-453e-9926-c022af1fbc31 + smi:local/auto + S + undecidable + + + + + smi:local/73e41f37-ecc1-4785-acd4-e1dd1d4b59c8 + smi:local/auto + P + undecidable + + + + + smi:local/255132d2-ede3-4823-87e1-be9e4e5be8b3 + smi:local/auto + S + undecidable + + + + + smi:local/c0b3dc8e-d9e8-45e0-9f35-610eaa703ade + smi:local/auto + P + undecidable + + + + + smi:local/610d50e5-fe17-426e-a916-a211ab430fd5 + smi:local/auto + S + undecidable + + + + + smi:local/0e35da45-2a94-457c-90f4-a1d7ed00e8f3 + smi:local/auto + P + undecidable + + + + + smi:local/9aa27382-aaaf-467d-bbf7-954ac4245246 + smi:local/auto + S + undecidable + + + + + smi:local/3144eacb-72de-4b19-864e-551280b9d801 + smi:local/auto + P + undecidable + + + + + smi:local/4f8f951d-fa5e-4197-a138-9643a61242d3 + smi:local/auto + S + undecidable + + + + + smi:local/27aa59f5-1a26-4146-8ad8-c75b73217f3b + smi:local/auto + P + undecidable + + + + + smi:local/a35675f8-5b8a-420d-bef4-35c06532b7a1 + smi:local/auto + S + undecidable + + + + + smi:local/59650172-a2df-4f3b-b165-cbf4063638cb + smi:local/auto + P + undecidable + + + + + smi:local/baec148c-7e30-4f48-a8a5-44552b0473d2 + smi:local/auto + S + undecidable + + + + + smi:local/41c2f9f3-9a65-48a0-9f87-026086e7416b + smi:local/auto + P + undecidable + + + + + smi:local/5e1873c4-96ab-4d05-b509-bf475d7c5fe1 + smi:local/auto + S + undecidable + + + + + smi:local/6969f72e-74e0-46c2-8781-22980e8144b9 + smi:local/auto + P + undecidable + + + + + smi:local/73b6c33b-5a2d-4a63-a248-0f370eee8f38 + smi:local/auto + S + undecidable + + + + + smi:local/0c2c60f1-18ed-43c2-9ed2-ad1e90924b8a + smi:local/auto + P + undecidable + + + + + smi:local/e3e1b74e-bd7f-42c4-9ed7-52ea39909975 + smi:local/auto + S + undecidable + + + + + smi:local/7c98d075-6454-4ccf-968f-87801f994f76 + smi:local/auto + P + undecidable + + + + + smi:local/d4af9ec8-627c-43d4-ba72-7086c0fe9f70 + smi:local/auto + S + undecidable + + + + + smi:local/91b224c4-5526-46ee-b0da-cc5981cbf9e3 + smi:local/auto + P + undecidable + + + + + smi:local/99d9fce2-7350-495d-8ba3-fb426ae46a68 + smi:local/auto + S + undecidable + + + + + smi:local/10716b25-087b-471f-8995-db6f0e0421a2 + smi:local/auto + P + undecidable + + + + + smi:local/338576c8-7d74-4e34-882a-822a599116ab + smi:local/auto + S + undecidable + + + + + smi:local/b13504b3-11bc-43c3-9030-910b7b152853 + smi:local/auto + P + undecidable + + + + + smi:local/faa74ee5-d5c1-4271-8b59-60da74264bfe + smi:local/auto + S + undecidable + + + + + smi:local/c13ac895-d7e0-41de-9f2e-250ed64abd0a + smi:local/auto + P + undecidable + + + + + smi:local/2134eb47-ca11-4001-81df-2f409cfe2b18 + smi:local/auto + S + undecidable + + + + + smi:local/cba08732-9b17-4013-871e-9e684d0e2e68 + smi:local/auto + P + undecidable + + + + + smi:local/33332df8-866a-4b87-a0ce-17c2ffb1e9b0 + smi:local/auto + S + undecidable + + + + + smi:local/47775691-5de0-4b60-b013-8b44ca6cad1c + smi:local/auto + P + undecidable + + + + + smi:local/d0d4d0c0-9174-4212-a30b-2722414305d0 + smi:local/auto + S + undecidable + + + + + smi:local/4b370440-e926-4e6d-b1fb-2558be199c57 + smi:local/auto + P + undecidable + + + + + smi:local/776df7ed-d8f4-467e-bb82-0a1cc2e3d823 + smi:local/auto + S + undecidable + + + + + smi:local/e6fafb0d-70e8-4401-bad2-baa1afe63b7b + smi:local/auto + P + undecidable + + + + + smi:local/b79cc433-e57c-4dea-92f4-5312429e925e + smi:local/auto + S + undecidable + + + + + smi:local/a3854b84-d090-41ca-bca0-6c44e4eae354 + smi:local/auto + P + undecidable + + + + + smi:local/fdea2852-3ae0-44c6-8df6-1907c7237d6f + smi:local/auto + S + undecidable + + + + + smi:local/bac970e1-f6f2-46a2-a9ae-0a56d662cc21 + smi:local/auto + P + undecidable + + + + + smi:local/ad373e5c-b763-49c7-a856-96c4d1326569 + smi:local/auto + S + undecidable + + + + + smi:local/9cc6db3f-22b3-4564-915f-860fd07401cb + smi:local/auto + P + undecidable + + + + + smi:local/6f7ee18f-33fe-4f21-8760-421e82ee8ce9 + smi:local/auto + S + undecidable + + + + + smi:local/ea8605fa-416c-4a4d-9c21-995c57859a38 + smi:local/auto + P + undecidable + + + + + smi:local/1525a00c-9de2-41e0-9838-ebfed3509430 + smi:local/auto + S + undecidable + + + + + smi:local/55478c3f-838c-4019-90ef-728a565e1e94 + smi:local/auto + P + undecidable + + + + + smi:local/3716e958-caf8-4bfb-a16a-6e50ac7f4d57 + smi:local/auto + S + undecidable + + + + + smi:local/4c31050b-66ac-43e5-94d9-59bbe91f8e13 + smi:local/auto + P + undecidable + + + + + smi:local/cb1521eb-a299-44ea-a69d-4b216808b7e0 + smi:local/auto + S + undecidable + + + + + smi:local/b736500e-b511-44b4-9734-f2b39b10ccde + smi:local/auto + P + undecidable + + + + + smi:local/0200a624-6925-4ae5-8500-db8a21568707 + smi:local/auto + S + undecidable + + + + + smi:local/b180daa1-ec77-45ea-ad0c-caa6e5b8a230 + smi:local/auto + P + undecidable + + + + + smi:local/00c7c033-19f9-42a0-a20c-847e541d2fbe + smi:local/auto + S + undecidable + + + + + smi:local/71dc6038-b69e-4c19-aae1-c986ef25b614 + smi:local/auto + P + undecidable + + + + + smi:local/42957893-1dfb-4252-9e84-ac6cce3932af + smi:local/auto + S + undecidable + + + + + smi:local/eafb5d79-905c-409b-bde3-08797cb88c75 + smi:local/auto + P + undecidable + + + + + smi:local/2af1c0e9-1f0e-4a4f-a694-8f4dab032eab + smi:local/auto + S + undecidable + + + + + smi:local/3d1cc3c5-fdf1-4b7e-9cdb-a2e4379d5252 + smi:local/auto + P + undecidable + + + + + smi:local/5b790ca9-d6af-4623-8578-129f01214a73 + smi:local/auto + S + undecidable + + + + + smi:local/d452ebf3-67c1-4470-b5d9-7e145360d8a7 + smi:local/auto + P + undecidable + + + + + smi:local/49b236ba-2863-44e3-9c63-a95e4695e651 + smi:local/auto + S + undecidable + + + + + smi:local/ec5ff835-b11a-43fb-987d-766624284b12 + smi:local/auto + P + undecidable + + + + + smi:local/c158364a-b74f-410a-bccd-3f9e2470a7bb + smi:local/auto + S + undecidable + + + + + smi:local/b816945e-beb5-440b-b7d6-ceb555df2548 + smi:local/auto + P + undecidable + + + + + smi:local/2916aa81-b44c-476f-8e9d-6b006c49b552 + smi:local/auto + S + undecidable + + + + + smi:local/a5684ca6-5682-4d0f-b7c2-31c57e50e6c8 + smi:local/auto + P + undecidable + + + + + smi:local/fec10b03-daa3-4ec5-81f6-b9b03b8f2145 + smi:local/auto + S + undecidable + + + + + smi:local/4761fe75-23b1-4bd2-beca-b61f2bade7cb + smi:local/auto + P + undecidable + + + + + smi:local/8547200c-1c44-4f40-9dc4-46c6db9b7684 + smi:local/auto + S + undecidable + + + + + smi:local/c3d0d771-6ff5-4c9f-a548-7279c12cadc6 + smi:local/auto + P + undecidable + + + + + smi:local/03c0c41f-d63c-43ba-9d87-74f90049bdc1 + smi:local/auto + S + undecidable + + + + + smi:local/a1c10481-1c3f-4e3a-a42e-edbbfe68f045 + smi:local/auto + P + undecidable + + + + + smi:local/34ba770b-b5bd-4643-9cb7-c47ee8d39251 + smi:local/auto + S + undecidable + + + + + smi:local/198fec9a-3092-4866-a4ad-fc4ba025c7e2 + smi:local/auto + P + undecidable + + + + + smi:local/81e32a96-979b-4532-8e48-d1edf2adaed7 + smi:local/auto + S + undecidable + + + + + smi:local/1aca482d-0bba-4024-917d-421e5101cd76 + smi:local/auto + P + undecidable + + + + + smi:local/b605f64a-7884-449f-a19e-184e2ad89e80 + smi:local/auto + S + undecidable + + + + + smi:local/780d160a-7909-4e09-ac15-aa1164b5d7f6 + smi:local/auto + P + undecidable + + + + + smi:local/aaa8ef72-0046-4600-b256-df855f9fc957 + smi:local/auto + S + undecidable + + + + + smi:local/6742131d-a6c6-4b59-a951-f87eaae5463f + smi:local/auto + P + undecidable + + + + + smi:local/047cd037-df81-4112-8036-08651d4fb691 + smi:local/auto + S + undecidable + + + + + smi:local/d942f983-d6e0-44cc-92f9-1e6946f68c7d + smi:local/auto + P + undecidable + + + + + smi:local/6a270e7e-d506-4164-aa72-32c7da827988 + smi:local/auto + S + undecidable + + + + + smi:local/22347151-ed11-4134-bc76-f66e7b8b54c0 + smi:local/auto + P + undecidable + + + + + smi:local/8f0d5199-0bc3-4055-81ef-1bdb4b39a4cd + smi:local/auto + S + undecidable + + + + + smi:local/22315a17-b28f-470b-9439-9964b44db880 + smi:local/auto + P + undecidable + + + + + smi:local/28599fed-d964-4232-91ac-374f3b829955 + smi:local/auto + S + undecidable + + + + + smi:local/3e7efb09-c52f-4686-9eb4-643025421e79 + smi:local/auto + P + undecidable + + + + + smi:local/31263317-b09c-4c27-83cc-f37805d5d0e3 + smi:local/auto + S + undecidable + + + + + smi:local/4ba2d87f-7d87-4c1a-b481-d1fef7cce1de + smi:local/auto + P + undecidable + + + + + smi:local/3a0a4eb0-e74d-4910-96f6-abcb8dfcc2db + smi:local/auto + S + undecidable + + + + + smi:local/8c32f20f-6c2c-4e1d-8f16-5118776f92a6 + smi:local/auto + P + undecidable + + + + + smi:local/1020459c-e253-4776-a2ff-c8fdbd22e45c + smi:local/auto + S + undecidable + + + + + smi:local/f814c003-dc74-4421-b1cc-6793b412f528 + smi:local/auto + P + undecidable + + + + + smi:local/1b5af8f6-cded-4191-a085-60f1c12cf515 + smi:local/auto + S + undecidable + + + + + smi:local/cb12f916-203a-4d9f-9b0a-b3f9e9540a72 + smi:local/auto + P + undecidable + + + + + smi:local/f105200d-ec3e-4cda-917f-6370c567e104 + smi:local/auto + S + undecidable + + + + + smi:local/d58464db-678a-41bf-8683-20c7df217a7a + smi:local/auto + P + undecidable + + + + + smi:local/8fd3dda8-d147-40a7-bc4d-37838d6d45e8 + smi:local/auto + S + undecidable + + + + + smi:local/fc3b22b4-f98f-434e-89f0-f64a7b99e70f + smi:local/auto + P + undecidable + + + + + smi:local/072fa0e3-1393-49eb-a2d6-9761ce71e203 + smi:local/auto + S + undecidable + + + + + smi:local/37a563fe-e8e9-41ba-8fc6-d4a78320c837 + smi:local/auto + P + undecidable + + + + + smi:local/5d43b20f-d55a-44c7-98b4-502c90c22eeb + smi:local/auto + S + undecidable + + + + + smi:local/2be5ec58-4057-4017-ab59-6d1e8aefdc99 + smi:local/auto + P + undecidable + + + + + smi:local/fe69472c-b3ac-4ef2-943b-6ed61d7c8ac2 + smi:local/auto + S + undecidable + + + + + smi:local/bec5ee71-f305-4713-bdc4-efd3ad4d537e + smi:local/auto + P + undecidable + + + + + smi:local/8e846d5a-c7c9-4ada-9e69-71eb089b9e3e + smi:local/auto + S + undecidable + + + + + smi:local/ef5b950d-8c13-4cba-aaaa-545a91756c88 + smi:local/auto + P + undecidable + + + + + smi:local/3c5d528e-7062-4264-8dd1-9320918e827c + smi:local/auto + S + undecidable + + + + + smi:local/faf62be3-e24c-4bef-a8b5-2177c12c40b6 + smi:local/auto + P + undecidable + + + + + smi:local/a2518913-5b49-4ab9-b01b-df668779ef38 + smi:local/auto + S + undecidable + + + + + smi:local/e4153d58-ea3c-4c1c-9b6b-b98941d87c41 + smi:local/auto + P + undecidable + + + + + smi:local/a0fc3b7a-228a-464a-8bcf-1f0305681405 + smi:local/auto + S + undecidable + + + + + smi:local/8df05c14-3f3f-4392-93af-a94ac38e7475 + smi:local/auto + P + undecidable + + + + + smi:local/a2caf2e8-c032-480f-8f7f-3d6536af9906 + smi:local/auto + S + undecidable + + + + + smi:local/a17ed6e5-ab47-4ad5-8878-4597e06d7919 + smi:local/auto + P + undecidable + + + + + smi:local/62f469d8-254b-4d8e-beac-a57e92cf41fa + smi:local/auto + S + undecidable + + + + + smi:local/a754aef5-1006-40ca-bf6c-1538a52d8d5b + smi:local/auto + P + undecidable + + + + + smi:local/dab873cb-ffdc-455f-827a-73deb7118dde + smi:local/auto + S + undecidable + + + + + smi:local/b3d51143-ec3e-475d-9536-262fe31d2e43 + smi:local/auto + P + undecidable + + + + + smi:local/44cf9fe7-8711-4a4b-ad45-1b9280ed1922 + smi:local/auto + S + undecidable + + + + + smi:local/f9317bb8-cdec-4824-b801-71b74c89cf5e + smi:local/auto + P + undecidable + + + + + smi:local/5a202f9e-28d1-4eba-9ddf-247200630018 + smi:local/auto + S + undecidable + + + + + smi:local/0ab2adeb-f993-46c6-aead-eb4fce420cf0 + smi:local/auto + P + undecidable + + + + + smi:local/fa0aa3ec-8292-417e-a07d-d4351f0aabd3 + smi:local/auto + S + undecidable + + + + + smi:local/90df64b3-9953-4679-9f9c-f51a21b57998 + smi:local/auto + P + undecidable + + + + + smi:local/2d16675a-c2c1-4f62-b8d0-15662d633526 + smi:local/auto + S + undecidable + + + + + smi:local/c709f833-e217-4eb3-896e-802cb058869b + smi:local/auto + P + undecidable + + + + + smi:local/c113014b-9829-4225-b2b3-2ce65c849e66 + smi:local/auto + S + undecidable + + + + + smi:local/0cc7a8b9-d804-484e-8e14-3383bd3320a5 + smi:local/auto + P + undecidable + + + + + smi:local/42a9c942-b9f8-429e-acc4-5d042c3a758b + smi:local/auto + S + undecidable + + + + + smi:local/35a47004-2c18-4163-a07a-c5d7dec533d8 + smi:local/auto + P + undecidable + + + + + smi:local/4a567ac6-4a38-4c88-a1ce-fb05c79cb713 + smi:local/auto + S + undecidable + + + + + smi:local/57143f8c-d23f-4fc2-b633-346c544ddae7 + smi:local/auto + P + undecidable + + + + + smi:local/8fe993c3-4d90-4aef-9cf1-177217ff009e + smi:local/auto + S + undecidable + + + + + smi:local/902335d1-4671-4347-b341-013c70f44e90 + smi:local/auto + P + undecidable + + + + + smi:local/5c2bbffb-0c78-461b-8e0d-4ffc950728e9 + smi:local/auto + S + undecidable + + + + + smi:local/d860ea00-9752-4734-908a-3675fdf8362b + smi:local/auto + P + undecidable + + + + + smi:local/404d82c6-46da-4fdb-acb3-298697c08b15 + smi:local/auto + S + undecidable + + + + + smi:local/348efcb8-b15a-41d7-b990-37a75a0f0b1e + smi:local/auto + P + undecidable + + + + + smi:local/196df3a7-7867-4cd0-88e2-c6b8aeaf8c73 + smi:local/auto + S + undecidable + + + + + smi:local/3f15ae95-92bd-406b-baa6-72aab48c35a3 + smi:local/auto + P + undecidable + + + + + smi:local/1d1c2c50-b55a-4bc3-9b9c-61f8a20b883b + smi:local/auto + S + undecidable + + + + + smi:local/15eca129-7e1d-4336-aeac-133860cfb488 + smi:local/auto + P + undecidable + + + + + + + smi:local/990bb3c7-a260-4395-88d6-a6fc8ea02112 + smi:local/auto + P + undecidable + + + + + smi:local/1e2b16d0-0757-4768-963b-2c9e71588737 + smi:local/auto + S + undecidable + + + + + smi:local/9826fbb0-5b8b-4bea-bcfb-69ca05d872c8 + smi:local/auto + P + undecidable + + + + + smi:local/05413161-db67-4c59-adb9-ab6b2bce11fb + smi:local/auto + S + undecidable + + + + + smi:local/68e0f376-cb4f-43dc-b56b-acc19316a813 + smi:local/auto + P + undecidable + + + + + smi:local/b19a6f4f-9dba-4ded-b447-cba97105e35c + smi:local/auto + S + undecidable + + + + + smi:local/3ed62c18-439f-46e7-9fd8-0fdfe926fd6e + smi:local/auto + P + undecidable + + + + + smi:local/2c7bfb30-b35c-46fa-b8db-aea5a5fead89 + smi:local/auto + S + undecidable + + + + + smi:local/79fd7c25-9998-4ab6-ae67-614be43c10d3 + smi:local/auto + P + undecidable + + + + + smi:local/42193acb-4b82-481b-8774-4c993820eb10 + smi:local/auto + S + undecidable + + + + + smi:local/895abe16-167a-4fed-bbcd-cacee110f283 + smi:local/auto + P + undecidable + + + + + smi:local/e1122838-bfa4-44dd-85b9-062ce75ec171 + smi:local/auto + S + undecidable + + + + + smi:local/2631ab73-c777-4318-b414-758a89ad6e4f + smi:local/auto + P + undecidable + + + + + smi:local/81967207-aff9-4c80-b90e-2a09e8f04370 + smi:local/auto + S + undecidable + + + + + smi:local/1a03316d-8b34-450e-b3ff-15901a941f5c + smi:local/auto + P + undecidable + + + + + smi:local/fb1ce6c9-5af2-4cc5-9b94-cd3dbdc87ddd + smi:local/auto + S + undecidable + + + + + smi:local/50304868-a29c-4120-8013-684b95813d29 + smi:local/auto + P + undecidable + + + + + smi:local/df8ee8be-cb57-48ad-b17c-addb8f7e3a60 + smi:local/auto + S + undecidable + + + + + smi:local/5e14032b-7f50-45ad-8f9d-ceeb18aa8e70 + smi:local/auto + P + undecidable + + + + + smi:local/96a1c18f-70c7-4022-9f8d-8c82ba35cf90 + smi:local/auto + S + undecidable + + + + + smi:local/ac34ba85-591e-4ccf-a16b-8566712905c9 + smi:local/auto + P + undecidable + + + + + smi:local/6fda9b75-3f31-4271-804e-55f91c5969a5 + smi:local/auto + S + undecidable + + + + + smi:local/a4dc3e5d-db31-49af-88f8-a6b8f94d4592 + smi:local/auto + P + undecidable + + + + + smi:local/ff0512e5-7213-484d-a269-771a47947815 + smi:local/auto + S + undecidable + + + + + smi:local/c501ef0d-8113-4a3e-98bb-f645797c4464 + smi:local/auto + P + undecidable + + + + + smi:local/6137d7cb-173f-44f5-bbf8-e63f62b2e9a5 + smi:local/auto + S + undecidable + + + + + smi:local/e2f93aef-f429-4526-986e-0c2c6aa24bde + smi:local/auto + P + undecidable + + + + + smi:local/771f97eb-0710-4e73-9b3e-c7a9db5f7a3b + smi:local/auto + S + undecidable + + + + + smi:local/f63a31d8-712b-44ea-9599-a3e67bd0553a + smi:local/auto + P + undecidable + + + + + smi:local/9a8b62de-7e0d-4a06-b76c-86687c83842e + smi:local/auto + S + undecidable + + + + + smi:local/e52eb66b-56a1-4ee4-bd44-8b20ed3d7339 + smi:local/auto + P + undecidable + + + + + smi:local/41168576-ba00-48f0-8301-6570f2a238d3 + smi:local/auto + S + undecidable + + + + + smi:local/e11c476d-9785-4c36-820f-45e0788a5b6a + smi:local/auto + P + undecidable + + + + + smi:local/4770aebd-534d-40ba-8c3a-3b71010c4c1d + smi:local/auto + S + undecidable + + + + + smi:local/3de8924c-eed2-4b7b-942d-2c41e6587954 + smi:local/auto + P + undecidable + + + + + smi:local/cea27d7a-4d19-49c4-9a0a-997be2372fe3 + smi:local/auto + S + undecidable + + + + + smi:local/d7b787e4-57c3-4498-a0cb-15cb90c64c5a + smi:local/auto + P + undecidable + + + + + smi:local/91542ff8-751d-4841-b33c-ed80d5c01cc5 + smi:local/auto + S + undecidable + + + + + smi:local/c99837ef-ae3a-449e-932f-2ad1c030a316 + smi:local/auto + P + undecidable + + + + + smi:local/3e151157-3d40-46a9-b84c-ae71055357dd + smi:local/auto + S + undecidable + + + + + smi:local/d34e70f6-a483-4778-b578-8826aba53f5e + smi:local/auto + P + undecidable + + + + + smi:local/8fbe6c0a-6d0d-4e76-aa02-0e4392e1fdac + smi:local/auto + S + undecidable + + + + + smi:local/b1fe00c3-b9a1-47c4-acab-cec16adcb0e9 + smi:local/auto + P + undecidable + + + + + smi:local/8eb304b3-c525-4e62-a0e8-d6fd0024aee2 + smi:local/auto + S + undecidable + + + + + smi:local/a4cc7491-3d48-4b30-b0de-3655e9653ab9 + smi:local/auto + P + undecidable + + + + + smi:local/24b7814e-aa66-4250-8480-cf4919e28ead + smi:local/auto + S + undecidable + + + + + smi:local/bcb78d9d-3504-40fb-9b45-c6d6b80df5ff + smi:local/auto + P + undecidable + + + + + smi:local/9e94e120-f9af-4a15-a724-120a5be896c0 + smi:local/auto + S + undecidable + + + + + smi:local/2fd07b5f-088c-45c9-87fc-bd9bff9a2c91 + smi:local/auto + P + undecidable + + + + + smi:local/f28cfe97-e7b4-4f65-ada6-bfe887438147 + smi:local/auto + S + undecidable + + + + + smi:local/fcf14ba8-8a56-4d6e-9121-84f361e266a0 + smi:local/auto + P + undecidable + + + + + smi:local/eb0ce124-9054-4d53-99cd-4d55105b106a + smi:local/auto + S + undecidable + + + + + smi:local/8c215a03-9341-4362-b38d-e930825bc94c + smi:local/auto + P + undecidable + + + + + smi:local/14cd021e-a719-4e5d-adb1-901ad94418d1 + smi:local/auto + S + undecidable + + + + + smi:local/bbf03ada-d81f-46c0-9d6c-49e850b44db9 + smi:local/auto + P + undecidable + + + + + smi:local/fcf99525-8080-4291-919d-56136b019a43 + smi:local/auto + S + undecidable + + + + + smi:local/8f71022a-e07f-4bd8-b4a6-9dd384dcf5c7 + smi:local/auto + P + undecidable + + + + + smi:local/d14ec564-0c2b-401b-a0c9-1c53139ea4eb + smi:local/auto + S + undecidable + + + + + smi:local/a23c8cc5-fa4f-4ff9-9dcd-e9af62e236d2 + smi:local/auto + P + undecidable + + + + + smi:local/89dd0b48-094a-46eb-bf3a-40a40ea7e25f + smi:local/auto + S + undecidable + + + + + smi:local/ac5c98e0-e4f6-4509-bcc1-9e31221c04ab + smi:local/auto + P + undecidable + + + + + smi:local/14c37f91-3bf0-401f-923f-de6d5d03aeb6 + smi:local/auto + S + undecidable + + + + + smi:local/cb982042-78e5-4e71-8678-7e2ad05b0292 + smi:local/auto + P + undecidable + + + + + smi:local/202037b9-3933-4614-a902-6026fc544558 + smi:local/auto + S + undecidable + + + + + smi:local/0193cb6c-317d-4fc2-8340-065337fa6a9c + smi:local/auto + P + undecidable + + + + + smi:local/29b6dab9-f3f5-4791-ac33-ee46b3f129fc + smi:local/auto + S + undecidable + + + + + smi:local/16ef8efe-ba63-4793-aa6a-ef4d0557a458 + smi:local/auto + P + undecidable + + + + + smi:local/50f63197-e0a1-4c34-955b-3aa190c6278c + smi:local/auto + S + undecidable + + + + + smi:local/e50de659-be5b-4661-93fd-e0a936315913 + smi:local/auto + P + undecidable + + + + + smi:local/3b30d6d8-6360-417f-91c9-4cf79b988c3e + smi:local/auto + S + undecidable + + + + + smi:local/5860d1b1-597d-4ab9-ac9a-309b6ea32703 + smi:local/auto + P + undecidable + + + + + smi:local/817a3db2-4bfc-43d1-be63-3e1e905cfc41 + smi:local/auto + S + undecidable + + + + + smi:local/5e7f17c0-50ea-4203-a2eb-88b1937f02fe + smi:local/auto + P + undecidable + + + + + smi:local/b8227023-7a4e-47a6-aa83-d1c2ee298aa8 + smi:local/auto + S + undecidable + + + + + smi:local/46da9688-7f33-4841-b904-bf312219b46a + smi:local/auto + P + undecidable + + + + + smi:local/330cdb14-753e-4db5-b8c6-7ebcb2a040e0 + smi:local/auto + S + undecidable + + + + + smi:local/717ec22e-ff19-4ffc-ad02-12bd499fc316 + smi:local/auto + P + undecidable + + + + + smi:local/9c3a9e28-1a2d-4063-a9db-f39e5185e4cf + smi:local/auto + S + undecidable + + + + + smi:local/c8655ad6-0ff0-4da8-8d78-6ad74c8e30fe + smi:local/auto + P + undecidable + + + + + smi:local/0cba2e6d-3ac6-4ef8-b759-7ba53ecfb7c9 + smi:local/auto + S + undecidable + + + + + smi:local/14de1c8d-ae11-40c2-acf0-c9d21e95251f + smi:local/auto + P + undecidable + + + + + smi:local/758916dd-e2d1-425c-82f5-5856e4c06a82 + smi:local/auto + S + undecidable + + + + + smi:local/91ee8cf6-b550-4215-aa57-50cfd6d428ac + smi:local/auto + P + undecidable + + + + + smi:local/e4c61c10-d3be-493d-a99a-f91deb88e38d + smi:local/auto + S + undecidable + + + + + smi:local/c2a54f73-515e-4b00-a033-a4eda956d315 + smi:local/auto + P + undecidable + + + + + smi:local/fbd59dbe-264b-418d-bd5a-ebb4b988097f + smi:local/auto + S + undecidable + + + + + smi:local/2cbd4e76-3db7-4846-bb1b-2a943bb043e6 + smi:local/auto + P + undecidable + + + + + smi:local/b18e5274-b220-4ead-9f74-2fcf49319bda + smi:local/auto + S + undecidable + + + + + smi:local/708e24b1-2855-4afb-8e01-9b4e2742ede9 + smi:local/auto + P + undecidable + + + + + smi:local/1d172d41-98a4-46dd-96e8-ebe99ffe6cd7 + smi:local/auto + S + undecidable + + + + + smi:local/e618ae7c-6c93-4da6-9430-4a1d15e19b70 + smi:local/auto + P + undecidable + + + + + smi:local/4a2d0707-3aeb-4181-8a19-d9560214574c + smi:local/auto + S + undecidable + + + + + smi:local/d0f782ba-77b9-466c-8eb1-4ed637cbe650 + smi:local/auto + P + undecidable + + + + + smi:local/3b0c3d17-fc99-4919-80c1-0b87b68d299f + smi:local/auto + S + undecidable + + + + + smi:local/ffa41ccf-5d42-4035-a78f-8ad33801638a + smi:local/auto + P + undecidable + + + + + smi:local/aaa1f8c4-c199-478d-8fe7-fa7bf8d6d3be + smi:local/auto + S + undecidable + + + + + smi:local/09f803a8-013d-4796-8914-089bac266e55 + smi:local/auto + P + undecidable + + + + + smi:local/a109978f-f49b-49cd-8871-6d47588bf08c + smi:local/auto + S + undecidable + + + + + smi:local/0c311dbd-ae68-4f44-b4a2-d2c9b47b89f5 + smi:local/auto + P + undecidable + + + + + smi:local/9ba4b2ae-9a81-4b53-99f0-2e21eff4bb4d + smi:local/auto + S + undecidable + + + + + smi:local/b25fab7a-4940-45bf-a4a6-a66485001db2 + smi:local/auto + P + undecidable + + + + + smi:local/5671e8e0-5cb4-4b61-89b4-17427b7c0ece + smi:local/auto + S + undecidable + + + + + smi:local/6bcc36e5-2391-4e7c-8854-76d94f4b05d2 + smi:local/auto + P + undecidable + + + + + smi:local/59e0e243-1e6d-4114-a673-f2e31c169d0a + smi:local/auto + S + undecidable + + + + + smi:local/151bf450-3bd0-454d-840d-0dcd908badf2 + smi:local/auto + P + undecidable + + + + + smi:local/e10487ac-66bb-4b46-834d-52cf209bebb3 + smi:local/auto + S + undecidable + + + + + smi:local/e66f8c62-4927-49b4-abd4-c9248b8944b3 + smi:local/auto + P + undecidable + + + + + smi:local/41926161-5c6f-43ba-b6cc-d444aeadc016 + smi:local/auto + S + undecidable + + + + + smi:local/20c14b61-ba9f-4351-be6c-57288a9a2bf3 + smi:local/auto + P + undecidable + + + + + smi:local/c139dae6-35fd-48f2-b552-09db98825ebf + smi:local/auto + S + undecidable + + + + + smi:local/26b63889-d009-444e-b1da-43029d4d0d24 + smi:local/auto + P + undecidable + + + + + smi:local/9657f61a-7e56-4e0c-9bad-e7038e433b55 + smi:local/auto + S + undecidable + + + + + smi:local/83fdec4c-c4d7-44b7-b759-80e4aa35cd2e + smi:local/auto + P + undecidable + + + + + smi:local/78001cf7-ec36-4d2b-a487-d008867d9904 + smi:local/auto + S + undecidable + + + + + smi:local/7b712cea-537f-4fa1-9039-5cd11d8ebbea + smi:local/auto + P + undecidable + + + + + smi:local/15f12b49-afb4-4bf4-a382-f93df5801e9a + smi:local/auto + S + undecidable + + + + + smi:local/7c344bda-f4a6-46ae-bc33-35eb184f1add + smi:local/auto + P + undecidable + + + + + smi:local/b6ccbc55-9b8d-4277-9d92-574f38d1fe82 + smi:local/auto + S + undecidable + + + + + smi:local/6cf1b50d-fdee-4f8c-9ca7-58208ffd21d5 + smi:local/auto + P + undecidable + + + + + smi:local/4e806ff3-915b-46dd-ab86-223b85bbd01d + smi:local/auto + S + undecidable + + + + + smi:local/f646b40e-a9d0-4615-b30c-304a707d6fd6 + smi:local/auto + P + undecidable + + + + + smi:local/68b8ba57-e564-4556-b4ee-95754d5aa3c6 + smi:local/auto + S + undecidable + + + + + smi:local/bab67919-63a0-44a3-be6c-79b4f89e09e8 + smi:local/auto + P + undecidable + + + + + smi:local/5f60b2d3-ad29-4cbb-a0f0-44938e31eb8c + smi:local/auto + S + undecidable + + + + + smi:local/dbd5fe29-2683-426d-ac03-959676b3b41a + smi:local/auto + P + undecidable + + + + + smi:local/25da7001-27ef-460a-8fb5-ddccd1686d35 + smi:local/auto + S + undecidable + + + + + smi:local/d5b6d766-f50f-4f3f-8220-af75a6c52a87 + smi:local/auto + P + undecidable + + + + + smi:local/8e1029d1-d8b3-4d7f-8bd5-ff4b7a638548 + smi:local/auto + S + undecidable + + + + + smi:local/b71a960f-e316-4e47-841f-5901d8fff263 + smi:local/auto + P + undecidable + + + + + smi:local/52a84dce-58eb-4398-8d27-ca7922c389c2 + smi:local/auto + S + undecidable + + + + + smi:local/e8b3fa93-644d-4bc9-b325-403b79f837e7 + smi:local/auto + P + undecidable + + + + + smi:local/6e063a4d-11a0-4b01-bf35-d01ca7bac99c + smi:local/auto + S + undecidable + + + + + smi:local/2c96be58-85d5-43c9-82f3-f3f48d14147b + smi:local/auto + P + undecidable + + + + + smi:local/1aa45744-6bfd-45fd-99d3-9c246948b683 + smi:local/auto + S + undecidable + + + + + smi:local/55e9d15a-c99e-433a-a35f-885e5caff286 + smi:local/auto + P + undecidable + + + + + smi:local/fdb7be51-e502-4dd7-9179-30e1426885ac + smi:local/auto + S + undecidable + + + + + smi:local/bffd6dff-01ca-433e-94a8-8cf781078675 + smi:local/auto + P + undecidable + + + + + smi:local/04028758-6452-4bfe-9642-ee71dad84c55 + smi:local/auto + S + undecidable + + + + + smi:local/4bc3ad6b-ddb5-4b32-9954-9fe06f252d02 + smi:local/auto + P + undecidable + + + + + smi:local/0fd13004-ce8b-4a0e-9a37-b4f5bb64240d + smi:local/auto + S + undecidable + + + + + smi:local/c140d33c-2cfb-49bc-8ad0-b8ec879397f3 + smi:local/auto + P + undecidable + + + + + smi:local/78c2a9d1-7dde-4657-89e7-a5e1edf47fe8 + smi:local/auto + S + undecidable + + + + + smi:local/863e116c-f48b-4ab8-9585-2be87a13b044 + smi:local/auto + P + undecidable + + + + + smi:local/c94c33de-17a5-46c0-a4b7-416a61e0b44e + smi:local/auto + S + undecidable + + + + + smi:local/76946fe8-b0e2-4c56-8da6-eb2f4a7093f5 + smi:local/auto + P + undecidable + + + + + smi:local/4495e2d5-bab4-497a-b01d-952e491dbe0f + smi:local/auto + S + undecidable + + + + + smi:local/85c145d9-02ff-4911-9422-7c60e85585e6 + smi:local/auto + P + undecidable + + + + + smi:local/bc5bb2a5-b870-40db-8176-60903ec79015 + smi:local/auto + S + undecidable + + + + + smi:local/27da092d-6fbe-45ce-840e-c43b029b808d + smi:local/auto + P + undecidable + + + + + smi:local/3188ca05-bfbd-4318-a26f-7a1cc9166bd2 + smi:local/auto + S + undecidable + + + + + smi:local/17fe783f-0fff-4878-8556-3f36d415777b + smi:local/auto + P + undecidable + + + + + smi:local/cef9dba7-962a-4e37-be1c-d712c97bc269 + smi:local/auto + S + undecidable + + + + + smi:local/c61953e9-075a-45ee-982a-64247cf14d7e + smi:local/auto + P + undecidable + + + + + smi:local/94b90be9-8e87-4d88-90a4-bbd11d536890 + smi:local/auto + S + undecidable + + + + + smi:local/5807589b-3bab-4495-ae9a-83016c59a180 + smi:local/auto + P + undecidable + + + + + smi:local/e961f138-6364-4248-a6fd-c50c3bea6946 + smi:local/auto + S + undecidable + + + + + smi:local/c88332e4-257e-4597-98df-f86589ee9704 + smi:local/auto + P + undecidable + + + + + smi:local/70f05f08-2ea3-44f2-8e0c-aaa831a868ba + smi:local/auto + S + undecidable + + + + + smi:local/39bd3cb7-f080-4aed-8953-b951b0811219 + smi:local/auto + P + undecidable + + + + + smi:local/bbff253b-aa47-42b3-b2e2-7bfe00525834 + smi:local/auto + S + undecidable + + + + + smi:local/139b37c9-4a78-4cc0-98a9-b4ef18f6ca81 + smi:local/auto + P + undecidable + + + + + smi:local/a1dbf88a-49ad-4a22-90d5-d5b53c80de77 + smi:local/auto + S + undecidable + + + + + smi:local/b49566f4-aa25-42dc-b209-5eb5b7aea9ff + smi:local/auto + P + undecidable + + + + + smi:local/ca9690f1-0009-40b9-9658-23152947b292 + smi:local/auto + S + undecidable + + + + + smi:local/7b2670ef-b22b-40cd-b343-e91e37955521 + smi:local/auto + P + undecidable + + + + + smi:local/1867a038-c5f2-4637-9f39-a7a4401b9088 + smi:local/auto + S + undecidable + + + + + smi:local/0b6b825a-68af-4766-a4e8-fbbe1273fc24 + smi:local/auto + P + undecidable + + + + + smi:local/2ef93f14-e40c-4d3c-8901-36caecea7413 + smi:local/auto + S + undecidable + + + + + smi:local/905970f1-1ab3-4388-96a3-9f1d3cf55bae + smi:local/auto + P + undecidable + + + + + smi:local/bb36dd67-6b9b-4711-9d3b-3a640d15ca9a + smi:local/auto + S + undecidable + + + + + smi:local/794da5a4-a72e-4de3-8b69-5caefaa2a94f + smi:local/auto + P + undecidable + + + + + smi:local/cc035ad6-1526-4648-8f2c-2da54d6e1489 + smi:local/auto + S + undecidable + + + + + smi:local/9617ad6c-b130-495a-b525-ff61c79eddfc + smi:local/auto + P + undecidable + + + + + smi:local/ca1a77e0-394c-49db-8be9-f15de6f486bb + smi:local/auto + S + undecidable + + + + + smi:local/147da067-817e-4e1e-83f9-07936cee522e + smi:local/auto + P + undecidable + + + + + smi:local/a4fece60-36c3-4feb-bc54-7926c0a254c3 + smi:local/auto + S + undecidable + + + + + smi:local/2e8cb042-0eab-47e4-bbde-debcb3c18e4c + smi:local/auto + P + undecidable + + + + + smi:local/7f1a354b-311f-4949-8ac8-2cbac5f95db1 + smi:local/auto + S + undecidable + + + + + smi:local/865b7397-f2b4-486b-9611-4b65575fbe1a + smi:local/auto + P + undecidable + + + + + smi:local/3374abc4-a3fe-44f5-af6a-2fe214f1cee8 + smi:local/auto + S + undecidable + + + + + smi:local/09e9977b-2350-404b-b3bd-07258f3122d8 + smi:local/auto + P + undecidable + + + + + smi:local/261c7c78-0d17-45e0-9eb8-7ab805c602cd + smi:local/auto + S + undecidable + + + + + smi:local/119dd095-cb11-425d-975e-3632a59f802b + smi:local/auto + P + undecidable + + + + + smi:local/a2faa4d0-11fc-4ffe-9072-61e705707f29 + smi:local/auto + S + undecidable + + + + + smi:local/0c34d5a7-0c1f-4c7e-9499-23f1469ba894 + smi:local/auto + P + undecidable + + + + + smi:local/4181f64e-4355-4ceb-9070-11ba0e43682b + smi:local/auto + S + undecidable + + + + + smi:local/e83ea2b6-9c7f-4220-9929-cff110551b72 + smi:local/auto + P + undecidable + + + + + smi:local/a7c41738-06da-46c0-9937-49f275a778da + smi:local/auto + S + undecidable + + + + + smi:local/559a3744-9ecc-4b36-b7c4-e2465a838c9b + smi:local/auto + P + undecidable + + + + + smi:local/2e5cb0bf-6a3d-4970-9056-141fe60cfa8b + smi:local/auto + S + undecidable + + + + + smi:local/e65d1cad-8195-453b-8787-dc4481bab2dc + smi:local/auto + P + undecidable + + + + + smi:local/e0f785da-9331-4713-b43a-4d904699afa5 + smi:local/auto + S + undecidable + + + + + smi:local/215bcd32-22b9-4787-9910-84ef3ba1e6d3 + smi:local/auto + P + undecidable + + + + + smi:local/d7e2e841-ddd5-4034-9d49-db4ac1c01f8c + smi:local/auto + S + undecidable + + + + + smi:local/7715b1a4-9ea0-4942-b58f-ee7eb5f083ec + smi:local/auto + P + undecidable + + + + + smi:local/5edfa45e-0965-4222-b700-8e5590ad62e2 + smi:local/auto + S + undecidable + + + + + smi:local/b0ee68fb-e96c-4db9-95c3-0572fd19f709 + smi:local/auto + P + undecidable + + + + + smi:local/a54a8cc5-7305-4980-81f1-5435a52ea665 + smi:local/auto + S + undecidable + + + + + smi:local/365541d6-1de7-4d16-8e76-fbcc576c2095 + smi:local/auto + P + undecidable + + + + + smi:local/797c1c25-28a7-461f-8a13-89f442824593 + smi:local/auto + S + undecidable + + + + + smi:local/c1db0573-dea9-4bea-9316-320b5c6c2320 + smi:local/auto + P + undecidable + + + + + smi:local/d519c6ac-6330-4908-9fd5-b5ba8b7f8e90 + smi:local/auto + S + undecidable + + + + + smi:local/7930b73f-a993-42b8-b234-eea826f91ce9 + smi:local/auto + P + undecidable + + + + + smi:local/931ec41c-4ca1-4797-b122-de3953ecb699 + smi:local/auto + S + undecidable + + + + + smi:local/c9a5d173-0a33-4091-87f2-fdcf4a76bf81 + smi:local/auto + P + undecidable + + + + + smi:local/50b44422-bdb8-4165-b3c2-116dc807180d + smi:local/auto + S + undecidable + + + + + smi:local/a7f6e169-826b-4443-9207-234d559789ae + smi:local/auto + P + undecidable + + + + + smi:local/b6e113ea-6089-4f42-95bb-0f5a1cdc4b61 + smi:local/auto + S + undecidable + + + + + smi:local/165c4055-d8fc-4e68-b63b-fac5febe6c97 + smi:local/auto + P + undecidable + + + + + smi:local/f9f4a289-5877-4738-ad2a-fd261a73fb4b + smi:local/auto + S + undecidable + + + + + smi:local/35d511b0-4aad-4d6e-87f8-16ccc906f847 + smi:local/auto + P + undecidable + + + + + smi:local/b135177d-c7cd-4812-acb2-4dff6c289219 + smi:local/auto + S + undecidable + + + + + smi:local/247c8adb-cad2-4759-ac9f-ba31fa1d0845 + smi:local/auto + P + undecidable + + + + + smi:local/23a634ab-ed97-4b72-a663-68415666c21c + smi:local/auto + S + undecidable + + + + + smi:local/5be7f149-29c5-45f0-ac34-1d2d7906e1f2 + smi:local/auto + P + undecidable + + + + + smi:local/c00424c4-b3e0-4764-b56d-97c76694a0cf + smi:local/auto + S + undecidable + + + + + smi:local/1a4605d9-a1fd-4b3d-9db3-fa910baa81aa + smi:local/auto + P + undecidable + + + + + smi:local/19c3d68a-c86c-4afa-91a4-0abb36f8ac8c + smi:local/auto + S + undecidable + + + + + smi:local/98449bef-9194-4ae1-add4-01f9bea84468 + smi:local/auto + P + undecidable + + + + + smi:local/26d8c4e7-39a2-407f-81f0-c409270877c8 + smi:local/auto + S + undecidable + + + + + smi:local/1a78cb0b-e327-46dd-baeb-a57c167f8d82 + smi:local/auto + P + undecidable + + + + + smi:local/41ec238e-b413-4c4f-9e58-78c61e3fdb59 + smi:local/auto + S + undecidable + + + + + smi:local/554a599b-9f03-43a0-96ec-8de40ad119e0 + smi:local/auto + P + undecidable + + + + + smi:local/7403d827-bae1-49bc-81c4-553b97ef30ea + smi:local/auto + S + undecidable + + + + + smi:local/18779818-44fb-4393-9f02-66ad3f8f23d8 + smi:local/auto + P + undecidable + + + + + smi:local/a739b080-406c-4846-a95f-b2268ead15c9 + smi:local/auto + S + undecidable + + + + + smi:local/ae89e0ec-598c-44ba-bb2b-83980d80062e + smi:local/auto + P + undecidable + + + + + smi:local/7410d95c-48f3-44e2-b8ff-3472b7cfa524 + smi:local/auto + S + undecidable + + + + + smi:local/29257b15-dcc3-4158-b7c0-5ffc71f9c3a4 + smi:local/auto + P + undecidable + + + + + smi:local/39bee6d6-905d-48bb-bb92-6deae86d5ac8 + smi:local/auto + S + undecidable + + + + + smi:local/9cf5ee42-cafe-4414-98ab-0efa46819b96 + smi:local/auto + P + undecidable + + + + + smi:local/6ffd13aa-38a2-4600-9258-dd621b31fd62 + smi:local/auto + S + undecidable + + + + + smi:local/b09c9421-ca6f-4257-b805-8623a7ee0d82 + smi:local/auto + P + undecidable + + + + + smi:local/fda540e3-ff23-4308-9922-37a8fc5ee0aa + smi:local/auto + S + undecidable + + + + + smi:local/31ecfa05-e6ad-4c07-9ec7-8513247cb6e6 + smi:local/auto + P + undecidable + + + + + smi:local/ed0172c3-622b-489f-8da3-d2f276a74891 + smi:local/auto + S + undecidable + + + + + smi:local/87c8cfe4-3339-4e8f-937c-65b9d7084e3e + smi:local/auto + P + undecidable + + + + + smi:local/b6ed9621-2a65-45b3-879c-762efc444d35 + smi:local/auto + S + undecidable + + + + + smi:local/54983aeb-7885-44f2-ac70-3694014c41dc + smi:local/auto + P + undecidable + + + + + smi:local/d18bf8b1-af35-4e02-a30f-895dfd059e2d + smi:local/auto + S + undecidable + + + + + smi:local/66e29bd2-813f-41ca-934b-03f36a91efaf + smi:local/auto + P + undecidable + + + + + + + smi:local/37e1ae99-2e68-4444-895d-78e151b677a1 + smi:local/auto + P + undecidable + + + + + smi:local/fb957297-c87e-4c79-b86b-f6a65811d36b + smi:local/auto + S + undecidable + + + + + smi:local/f2ecc626-6347-4f58-b924-c6bef5c6813f + smi:local/auto + P + undecidable + + + + + smi:local/25492222-73be-4e8f-82d0-6ad4fbe6c86c + smi:local/auto + S + undecidable + + + + + smi:local/030730be-8460-480e-94f6-4ef63cafe487 + smi:local/auto + P + undecidable + + + + + smi:local/afa9d8ef-72b3-4abd-ac5f-a746b76937e2 + smi:local/auto + S + undecidable + + + + + smi:local/660fe512-8952-49e9-a829-854f8a369dd9 + smi:local/auto + P + undecidable + + + + + smi:local/ea260531-9478-47a7-ab26-878873a8acdd + smi:local/auto + S + undecidable + + + + + smi:local/b86e3115-da15-4e59-8b7e-572b5ea839aa + smi:local/auto + P + undecidable + + + + + smi:local/e00c2fc2-ca94-4b97-a06e-ceb73639bfb9 + smi:local/auto + S + undecidable + + + + + smi:local/e1644b59-2ba4-4187-bf92-243c315cce07 + smi:local/auto + P + undecidable + + + + + smi:local/f89f6d77-10ac-416e-9d46-b0288755918d + smi:local/auto + S + undecidable + + + + + smi:local/dcf23b97-869c-4f3d-b5fd-870082940f94 + smi:local/auto + P + undecidable + + + + + smi:local/cb845304-6825-48a9-9d36-8f3cab1f6ac0 + smi:local/auto + S + undecidable + + + + + smi:local/82b9d9b6-2a49-432d-8e0e-db0b430bc89c + smi:local/auto + P + undecidable + + + + + smi:local/13d97902-e146-4a64-b3a0-5a2f9a754f57 + smi:local/auto + S + undecidable + + + + + smi:local/6db86472-38ac-4dd9-a98c-a8ef85799dc7 + smi:local/auto + P + undecidable + + + + + smi:local/00e1aaf2-6068-4e48-87b3-4dd594e0e16c + smi:local/auto + S + undecidable + + + + + smi:local/4ac47a33-e711-424a-ac1b-6e1f67fab0fb + smi:local/auto + P + undecidable + + + + + smi:local/4239a961-e9d3-4795-9d3d-2f41f0636def + smi:local/auto + S + undecidable + + + + + smi:local/27c6426c-6d02-4ea9-96f7-d45b31fc79a1 + smi:local/auto + P + undecidable + + + + + smi:local/14c34946-2451-4251-bd8f-0ff1f77e057f + smi:local/auto + S + undecidable + + + + + smi:local/757e1b49-18b7-469f-bc42-1413f42d926c + smi:local/auto + P + undecidable + + + + + smi:local/f42d3c64-cbe0-4bce-ab35-6b0e2afee61c + smi:local/auto + S + undecidable + + + + + smi:local/89487795-c9e0-4a0d-89a2-87fee33f9e48 + smi:local/auto + P + undecidable + + + + + smi:local/e7474bec-3266-470b-bfb7-54cad2e673ba + smi:local/auto + S + undecidable + + + + + smi:local/5a53ce76-d55b-43a1-9e60-ac3a4fee6296 + smi:local/auto + P + undecidable + + + + + smi:local/79c01ba2-442f-4a0a-bf36-dd23447a1067 + smi:local/auto + S + undecidable + + + + + smi:local/eba2fc08-0649-4874-a461-5b8fd32bf1f8 + smi:local/auto + P + undecidable + + + + + smi:local/abfe95dd-59e2-41c4-ba74-b082a6880c89 + smi:local/auto + S + undecidable + + + + + smi:local/f218c43e-ca76-4913-ae68-f3e670fe19b7 + smi:local/auto + P + undecidable + + + + + smi:local/6a9d3226-6d92-4fac-9fa4-d601018267ee + smi:local/auto + S + undecidable + + + + + smi:local/1f207089-792c-4f04-a9d2-194501a8684d + smi:local/auto + P + undecidable + + + + + smi:local/5c6c5513-fd4f-4d2e-af9f-4278244e363f + smi:local/auto + S + undecidable + + + + + smi:local/a58ad581-ae62-452a-b286-ded1ec47b1e4 + smi:local/auto + P + undecidable + + + + + smi:local/8e7055bd-8560-43f9-9a58-63b8a9517d41 + smi:local/auto + S + undecidable + + + + + smi:local/d41001a5-53b1-4eeb-8d9e-2d75527cebd6 + smi:local/auto + P + undecidable + + + + + smi:local/fc15b663-2452-4a5c-b9fb-3fd5bdd35d77 + smi:local/auto + S + undecidable + + + + + smi:local/a305090f-afee-4967-8526-4fecf6c93b39 + smi:local/auto + P + undecidable + + + + + smi:local/77bd989d-0cd6-4792-a65a-c6199983119c + smi:local/auto + S + undecidable + + + + + smi:local/cca8573d-cdf8-4d98-a258-a012e93e2629 + smi:local/auto + P + undecidable + + + + + smi:local/bb28e55e-6e37-44c1-8156-b3b3b012a04a + smi:local/auto + S + undecidable + + + + + smi:local/aea0c0cc-ef44-49c6-8d91-d82644da80cd + smi:local/auto + P + undecidable + + + + + smi:local/ec376526-ac9d-4480-9135-610bfd0a585a + smi:local/auto + S + undecidable + + + + + smi:local/9763da32-cd59-43fe-a6f3-e1b9833f7e21 + smi:local/auto + P + undecidable + + + + + smi:local/da06bbac-6a87-4294-97b1-c832a57f98af + smi:local/auto + S + undecidable + + + + + smi:local/ab288e2c-74fd-44ad-8bb8-063927649077 + smi:local/auto + P + undecidable + + + + + smi:local/b9fa50f7-6c6c-4936-8f85-653b65137798 + smi:local/auto + S + undecidable + + + + + smi:local/0c55c809-2cbf-4322-8349-a4077173b066 + smi:local/auto + P + undecidable + + + + + smi:local/2bad4d7f-b630-4f8d-a627-d3b341abfe5a + smi:local/auto + S + undecidable + + + + + smi:local/40059900-52f9-488e-b560-1d44bc5f20e7 + smi:local/auto + P + undecidable + + + + + smi:local/6f88f8c5-c396-4d94-981c-bbc0fc05c84c + smi:local/auto + S + undecidable + + + + + smi:local/a3e80752-d85f-4be0-9c29-53cd3906d9fc + smi:local/auto + P + undecidable + + + + + smi:local/7a399816-7784-4412-aba4-defef5a89c22 + smi:local/auto + S + undecidable + + + + + smi:local/7b8bff5e-413e-4109-9e80-62a31646e150 + smi:local/auto + P + undecidable + + + + + smi:local/fbbefb6e-454a-46d5-a717-92d31d70d24a + smi:local/auto + S + undecidable + + + + + smi:local/68aee14f-c7e4-42c1-8595-79c083f3c3d2 + smi:local/auto + P + undecidable + + + + + smi:local/793bb47a-47e1-4b01-8f9f-3d12514d0403 + smi:local/auto + S + undecidable + + + + + smi:local/cd04a4fb-a6c1-435c-9bdb-76cce381b4a4 + smi:local/auto + P + undecidable + + + + + smi:local/b2129096-8e34-472b-bd42-83fdbcf97a2f + smi:local/auto + S + undecidable + + + + + smi:local/04a8b909-0f5a-402c-9a42-58f06804759d + smi:local/auto + P + undecidable + + + + + smi:local/b8445ac8-f1f4-43ad-8985-fbf09c1a7e14 + smi:local/auto + S + undecidable + + + + + smi:local/dcfd6197-ba3b-4d72-b2d1-18bb5c9a567f + smi:local/auto + P + undecidable + + + + + smi:local/087d5ce9-6405-4441-aad5-4f77bc504a85 + smi:local/auto + S + undecidable + + + + + smi:local/6d13ca6a-950a-4b49-98e9-131a0d46b83e + smi:local/auto + P + undecidable + + + + + smi:local/f314bb47-a738-4924-9e1c-fd97f327bccc + smi:local/auto + S + undecidable + + + + + smi:local/37f17378-4f4b-4256-a326-d980e474e652 + smi:local/auto + P + undecidable + + + + + smi:local/41fb756b-dd01-4605-bf3a-9c77b3901dc8 + smi:local/auto + S + undecidable + + + + + smi:local/88a10b12-850b-4751-ad78-20ebf594876c + smi:local/auto + P + undecidable + + + + + smi:local/eaa79cb6-94f5-447f-bfdf-4ab0ca1b8747 + smi:local/auto + S + undecidable + + + + + smi:local/03977809-6ca2-4f34-977b-68dac817d80b + smi:local/auto + P + undecidable + + + + + smi:local/7832e8fd-2987-4317-88f6-c9b989050f5c + smi:local/auto + S + undecidable + + + + + smi:local/51d83631-f5c5-4b06-996d-f3559481dea4 + smi:local/auto + P + undecidable + + + + + smi:local/77d5c973-0122-4f5e-8aa6-35a80213424a + smi:local/auto + S + undecidable + + + + + smi:local/fe535ffc-ccbb-485e-b67d-e9dd5d7ac48b + smi:local/auto + P + undecidable + + + + + smi:local/6038e47c-5645-4dd6-bc1c-6bdeba0c56fb + smi:local/auto + S + undecidable + + + + + smi:local/431021ed-6523-436c-8ac7-08ce1fc84f01 + smi:local/auto + P + undecidable + + + + + smi:local/511f7cd1-e83f-4985-a05c-cfa5b56c520e + smi:local/auto + S + undecidable + + + + + smi:local/be4a1a89-21e4-4ac2-bbed-368553b77348 + smi:local/auto + P + undecidable + + + + + smi:local/840361eb-d831-4b6c-bfa7-266fa30fe7af + smi:local/auto + S + undecidable + + + + + smi:local/20aca152-566d-4c4f-af0b-ee4a89936755 + smi:local/auto + P + undecidable + + + + + smi:local/7308441b-70c9-4c94-a2f5-9714906d614d + smi:local/auto + S + undecidable + + + + + smi:local/7206f24c-5934-47d8-aa7e-008d04ac63c0 + smi:local/auto + P + undecidable + + + + + smi:local/16c0bdc4-c735-46c1-9af9-1d00f9e32969 + smi:local/auto + S + undecidable + + + + + smi:local/94133439-901d-4b75-b52f-389fa833c6e1 + smi:local/auto + P + undecidable + + + + + smi:local/616978e2-0ede-423f-87e3-aed63fa8164d + smi:local/auto + S + undecidable + + + + + smi:local/3be7c30d-f3a4-4c7a-b0e3-e963c7274601 + smi:local/auto + P + undecidable + + + + + smi:local/358c0df9-223b-4c31-9038-8322b857ffef + smi:local/auto + S + undecidable + + + + + smi:local/a2e3860e-f3ac-414d-ae9b-ba79602c00a1 + smi:local/auto + P + undecidable + + + + + smi:local/4ce44031-817c-4044-9383-87c49e3da519 + smi:local/auto + S + undecidable + + + + + smi:local/4ddf8332-9a31-4695-b0bf-b361003298be + smi:local/auto + P + undecidable + + + + + smi:local/c0d2c00f-58b1-4936-9cda-8e52b2e1f4cc + smi:local/auto + S + undecidable + + + + + smi:local/73ffc9e3-d40b-45d3-9201-6cdad8ec6c70 + smi:local/auto + P + undecidable + + + + + smi:local/cc4f74d1-1581-469b-ab81-5f5838b2f0d5 + smi:local/auto + S + undecidable + + + + + smi:local/7ec8f144-0586-4a67-9b9b-7143efa76901 + smi:local/auto + P + undecidable + + + + + smi:local/f468d150-6328-4c26-9744-6ff278a959bf + smi:local/auto + S + undecidable + + + + + smi:local/e854b2f2-6a57-42c9-89b6-c435e7de8ea8 + smi:local/auto + P + undecidable + + + + + smi:local/710837d1-f85a-4245-8c57-d8a2deb335bc + smi:local/auto + S + undecidable + + + + + smi:local/3ebac2b9-01c2-4c09-b0ce-ef1f4cf5c3b4 + smi:local/auto + P + undecidable + + + + + smi:local/9aeeb860-f19d-46f7-abcb-afdcbb096c77 + smi:local/auto + S + undecidable + + + + + smi:local/1637dd30-94b9-4c53-84be-d2db1b7befdd + smi:local/auto + P + undecidable + + + + + smi:local/2614b724-e806-4296-afff-3aba697ca449 + smi:local/auto + S + undecidable + + + + + smi:local/26d3f6a5-0bcc-4a85-8447-6367c47dffd8 + smi:local/auto + P + undecidable + + + + + smi:local/e064a54d-025b-4d98-854e-7c27d7b6946c + smi:local/auto + S + undecidable + + + + + smi:local/37b3a597-82e7-49ad-a777-f2df3930a745 + smi:local/auto + P + undecidable + + + + + smi:local/c69526cc-365e-4852-954d-c3571936fe24 + smi:local/auto + S + undecidable + + + + + smi:local/4c32d5e0-10ce-4e73-b566-47aa8e13c35c + smi:local/auto + P + undecidable + + + + + smi:local/f94bf983-8c8a-45fe-9e03-fd5969df09ac + smi:local/auto + S + undecidable + + + + + smi:local/3a2ee851-f916-4e2f-b99f-d0b79f7637ea + smi:local/auto + P + undecidable + + + + + smi:local/f1173b73-b635-4a2c-a6e2-c9d36b1f5519 + smi:local/auto + S + undecidable + + + + + smi:local/fda7b5e8-11b2-4561-a72f-a0fdb437c63e + smi:local/auto + P + undecidable + + + + + smi:local/835683dd-9678-4178-8a15-fb48d2633395 + smi:local/auto + S + undecidable + + + + + smi:local/dec502c9-cd08-4ab8-8aae-849efa5b2191 + smi:local/auto + P + undecidable + + + + + smi:local/7f4affa4-e80e-4a8c-b878-5217a03e5ee4 + smi:local/auto + S + undecidable + + + + + smi:local/e2eb2de9-634c-4d1a-b070-53df497b4622 + smi:local/auto + P + undecidable + + + + + smi:local/34fb0c64-45c5-46ce-a364-6451fec8ecb0 + smi:local/auto + S + undecidable + + + + + smi:local/a99ebc7a-1cc9-4c17-88f2-aec5d7f982a1 + smi:local/auto + P + undecidable + + + + + smi:local/f80da66b-3865-4c42-8aa5-281df2cc37e4 + smi:local/auto + S + undecidable + + + + + smi:local/06fd6ee2-9640-4c1c-96e2-d2ac3ffdd7b1 + smi:local/auto + P + undecidable + + + + + smi:local/a64af9cb-f64d-482b-8e7e-cd1ff9d37aba + smi:local/auto + S + undecidable + + + + + smi:local/ad72bbd9-f77f-4ddd-8532-5525827b3d87 + smi:local/auto + P + undecidable + + + + + smi:local/82cf75e2-6e42-4236-b893-ee5d774a1622 + smi:local/auto + S + undecidable + + + + + smi:local/c0213777-269c-463f-a1d1-66c546a50bf6 + smi:local/auto + P + undecidable + + + + + smi:local/8497c239-ba2c-4487-8c93-3d8f19b85ecd + smi:local/auto + S + undecidable + + + + + smi:local/337e2197-e12c-4e8f-9af7-ccbf72927ef5 + smi:local/auto + P + undecidable + + + + + smi:local/f7f90608-1ec5-4abc-bdd3-82c85b50e6f0 + smi:local/auto + S + undecidable + + + + + smi:local/ca7fe342-6203-4c96-a238-8e6bddc3fa0e + smi:local/auto + P + undecidable + + + + + smi:local/f0f8d563-09bf-4e1b-af98-bea012afc3d7 + smi:local/auto + S + undecidable + + + + + smi:local/d5f6c4e0-1e30-4359-93f7-f2b5a4f77ea4 + smi:local/auto + P + undecidable + + + + + smi:local/3b52b7dd-35f7-4121-9e31-a64e1accd7eb + smi:local/auto + S + undecidable + + + + + smi:local/809f541c-252c-4f93-afda-eabf7ee5e8b1 + smi:local/auto + P + undecidable + + + + + smi:local/cc775fb0-f269-4e69-9e6d-eff3240ad10b + smi:local/auto + S + undecidable + + + + + smi:local/56872a76-0247-4db5-9106-bc1b7bfa9e92 + smi:local/auto + P + undecidable + + + + + smi:local/85de495e-f154-4a36-b52b-9ea0acb25baa + smi:local/auto + S + undecidable + + + + + smi:local/75faa3eb-1bd9-4e4f-a589-41b790e2021b + smi:local/auto + P + undecidable + + + + + smi:local/2d149ac7-a9db-4df6-be97-3f5d76867c69 + smi:local/auto + S + undecidable + + + + + smi:local/0ed4c382-b259-4d1f-850d-f78d824f9967 + smi:local/auto + P + undecidable + + + + + smi:local/86413b52-383c-4831-88fe-3722d8a61e1c + smi:local/auto + S + undecidable + + + + + smi:local/39a4ad76-620b-44e7-a92a-4c3f00f2440e + smi:local/auto + P + undecidable + + + + + smi:local/e0dee8d6-f77b-4ba2-aee7-b676dcab7cc7 + smi:local/auto + S + undecidable + + + + + smi:local/51074786-ac3e-4ef8-95e2-29db5f22afbf + smi:local/auto + P + undecidable + + + + + smi:local/fe327be9-61ec-49be-97b9-5748a912c90c + smi:local/auto + S + undecidable + + + + + smi:local/7c293b69-471a-4eb8-b823-b5c28f009261 + smi:local/auto + P + undecidable + + + + + smi:local/715f7415-ea0e-43db-a45e-4b17e34d1240 + smi:local/auto + S + undecidable + + + + + smi:local/340a6152-4c03-4886-9fab-d605d16fb3a2 + smi:local/auto + P + undecidable + + + + + smi:local/42c636dc-4e5d-4c44-a9d6-e317a008fc83 + smi:local/auto + S + undecidable + + + + + smi:local/a787fc00-2fc6-4fab-b0fb-19683cc3fcb4 + smi:local/auto + P + undecidable + + + + + smi:local/26c3d24a-2ce6-4ddc-9f0d-24bc9fc2fc27 + smi:local/auto + S + undecidable + + + + + smi:local/97178b38-fe9e-46fb-bbb4-370b88f80ec7 + smi:local/auto + P + undecidable + + + + + smi:local/726ccd18-d7c0-4a5a-b07b-03a8ba19d8d5 + smi:local/auto + S + undecidable + + + + + smi:local/50c75346-ee4b-4a62-b6a6-80fcf7e6bb7e + smi:local/auto + P + undecidable + + + + + smi:local/b33a31af-582c-48e8-9751-e046b0d56390 + smi:local/auto + S + undecidable + + + + + smi:local/1ffcab9f-87c1-4d3a-9091-d78ba3349db3 + smi:local/auto + P + undecidable + + + + + smi:local/fb224d99-ee9c-495f-913f-7836e20b460c + smi:local/auto + S + undecidable + + + + + smi:local/f1cc3019-95fb-4b77-b182-5eb77fc270f4 + smi:local/auto + P + undecidable + + + + + smi:local/3dad721f-8aa4-4a68-bfa1-eaded651b9f0 + smi:local/auto + S + undecidable + + + + + smi:local/3ef27008-86d5-4b50-bb43-06d20cfedc15 + smi:local/auto + P + undecidable + + + + + smi:local/337e5bf1-424f-415b-b5a2-d4336c6d9817 + smi:local/auto + S + undecidable + + + + + smi:local/809a9acd-bb04-460c-b450-b436b3d4ee44 + smi:local/auto + P + undecidable + + + + + smi:local/c7217e5e-36bf-4862-a6f2-a0d78bf12d15 + smi:local/auto + S + undecidable + + + + + smi:local/8bd0c3c7-d3b7-4017-8291-6a28e8afabc4 + smi:local/auto + P + undecidable + + + + + smi:local/61fe09e6-9d62-43d2-9d67-92d2802ee4d1 + smi:local/auto + S + undecidable + + + + + smi:local/016748bc-1c13-46dd-a06e-86120b10e55e + smi:local/auto + P + undecidable + + + + + smi:local/c473d028-685e-4d89-ad5f-1340a74f9bbf + smi:local/auto + S + undecidable + + + + + smi:local/7fcf863a-b2e6-4ff9-8a68-71dc45b5fb10 + smi:local/auto + P + undecidable + + + + + smi:local/76a8c1ed-811c-41f8-a023-7ab75af75383 + smi:local/auto + S + undecidable + + + + + smi:local/522839e2-041b-44d9-bbcb-1d9769daab42 + smi:local/auto + P + undecidable + + + + + smi:local/64e1edf3-3664-4101-a5e4-b178da4cd3bf + smi:local/auto + S + undecidable + + + + + smi:local/ed4ef5e1-ea61-4c46-be04-89bcbd9598fe + smi:local/auto + P + undecidable + + + + + smi:local/4b76941a-e79d-41d0-a6e7-7b7a3714aa1c + smi:local/auto + S + undecidable + + + + + smi:local/e692565f-509b-47f5-995a-8926835da65c + smi:local/auto + P + undecidable + + + + + smi:local/cbaeb0f6-87b6-45c5-ba4f-a1b19b06e2f8 + smi:local/auto + S + undecidable + + + + + smi:local/a50c40b3-64bb-472c-aeb6-a7cb0e1473a3 + smi:local/auto + P + undecidable + + + + + smi:local/6a38f803-ee5b-41bb-b62d-4c4cb315eeb9 + smi:local/auto + S + undecidable + + + + + smi:local/4a0891b6-7b67-4d52-b99a-40aa37c15d82 + smi:local/auto + P + undecidable + + + + + smi:local/6d3080bf-a77b-4689-a513-9d203940ef26 + smi:local/auto + S + undecidable + + + + + smi:local/f1793fe5-29ca-4d71-ae47-cc884ba0f9fc + smi:local/auto + P + undecidable + + + + + smi:local/c411c40f-87a2-4eb4-ba30-b46103e0bc19 + smi:local/auto + S + undecidable + + + + + smi:local/addd5cfa-707f-44ba-9d64-27cc77b4097c + smi:local/auto + P + undecidable + + + + + smi:local/30ea25e7-ee80-4284-98ee-20ef188bd57e + smi:local/auto + S + undecidable + + + + + smi:local/be2d3344-2c12-4fb0-9ee5-0f7ac09def2b + smi:local/auto + P + undecidable + + + + + smi:local/b60b1bc1-4189-4934-bc38-5b698a6d330e + smi:local/auto + S + undecidable + + + + + smi:local/980b55b4-6115-4f95-ac75-bbe6d157258d + smi:local/auto + P + undecidable + + + + + smi:local/6286aae6-5eab-4597-9632-1184ab76d32a + smi:local/auto + S + undecidable + + + + + smi:local/fe0f4319-71f4-4a38-bb77-0e57a3b04a33 + smi:local/auto + P + undecidable + + + + + smi:local/c35ff6b4-5a7b-42dc-abcb-f5641a7c9533 + smi:local/auto + S + undecidable + + + + + smi:local/1fb3f429-e367-4c77-bb64-3083ea36ca15 + smi:local/auto + P + undecidable + + + + + smi:local/6a49f5ba-a95f-4afd-b2ed-770a3632efbb + smi:local/auto + S + undecidable + + + + + smi:local/3393ab92-2cdf-4b65-b278-0f1512242af8 + smi:local/auto + P + undecidable + + + + + smi:local/87ade36f-4e3a-453b-a18f-662be6a9cc81 + smi:local/auto + S + undecidable + + + + + smi:local/40cc60ee-36fa-4e2c-8606-e5a98034059b + smi:local/auto + P + undecidable + + + + + smi:local/f779aa5f-667c-4620-b51c-ee08bde0c332 + smi:local/auto + S + undecidable + + + + + smi:local/b392057b-e8c3-41e3-bccf-612473a5c02b + smi:local/auto + P + undecidable + + + + + smi:local/f6204559-97e1-4f84-b547-a77c81049a32 + smi:local/auto + S + undecidable + + + + + smi:local/370de6ff-7be6-4ccc-895c-91cfbfe4c279 + smi:local/auto + P + undecidable + + + + + smi:local/e882233f-918b-4eb3-be3a-191e7876cefe + smi:local/auto + S + undecidable + + + + + smi:local/35e2d4d1-a795-44cf-ba9b-b79ae2c8bab7 + smi:local/auto + P + undecidable + + + + + smi:local/2276e608-dc07-4c18-98d0-d185c7e3f6f1 + smi:local/auto + S + undecidable + + + + + smi:local/66ebdd6d-55d4-4fb8-bd33-71699ae16bd7 + smi:local/auto + P + undecidable + + + + + smi:local/d06f2a5a-698e-4feb-a04d-9838f52951fd + smi:local/auto + S + undecidable + + + + + smi:local/377c91a3-0401-4e02-be71-9ed562dd2d93 + smi:local/auto + P + undecidable + + + + + smi:local/e0329085-c934-4f84-8898-6c0705c288b4 + smi:local/auto + S + undecidable + + + + + smi:local/099ae00e-4944-4f87-a452-e078967343a5 + smi:local/auto + P + undecidable + + + + + smi:local/733e033d-4cfd-41a7-be7b-6f06b44afa23 + smi:local/auto + S + undecidable + + + + + smi:local/03e6c36f-808a-4217-ad8b-97b5a46028bd + smi:local/auto + P + undecidable + + + + + smi:local/58dbefb2-f16d-4389-b3a6-be621a491521 + smi:local/auto + S + undecidable + + + + + smi:local/94b6fa80-37df-4437-abe7-72d02673a5eb + smi:local/auto + P + undecidable + + + + + smi:local/f7bd75fc-4031-4410-b35b-b52cd81a6d48 + smi:local/auto + S + undecidable + + + + + smi:local/b30993cb-9e8f-4706-9e6e-80e83634567e + smi:local/auto + P + undecidable + + + + + smi:local/4094e882-d7db-4468-bec4-d97d1412ddfe + smi:local/auto + S + undecidable + + + + + smi:local/c214d7a0-4c0a-45ca-a765-f1658bb684a8 + smi:local/auto + P + undecidable + + + + + smi:local/bdf76042-fe22-47fc-9ccc-c91ac325bf44 + smi:local/auto + S + undecidable + + + + + smi:local/c09c0437-c823-418c-be5c-400623cde552 + smi:local/auto + P + undecidable + + + + + smi:local/b09fba47-ba3e-4fd1-ac3f-9472fe183cf1 + smi:local/auto + S + undecidable + + + + + smi:local/20672fad-8463-407a-b33c-c545604b0166 + smi:local/auto + P + undecidable + + + + + smi:local/b7ed1c75-ee7d-4c48-bdd9-81df418b137c + smi:local/auto + S + undecidable + + + + + smi:local/89bc5eca-4003-4a03-892c-9d7136b8ce60 + smi:local/auto + P + undecidable + + + + + smi:local/287ab425-bd58-4cbc-ab7e-536116b9809f + smi:local/auto + S + undecidable + + + + + smi:local/9a9e5db6-39e8-4bb0-aa4b-6d9684c0c9df + smi:local/auto + P + undecidable + + + + + smi:local/2428003e-bfda-43ab-ae45-e2ce20c2c85d + smi:local/auto + S + undecidable + + + + + smi:local/1f7f09ba-1a17-4182-87f0-7543cd0f2339 + smi:local/auto + P + undecidable + + + + + smi:local/d0015463-2c78-409e-845e-a0e6d09eab9b + smi:local/auto + S + undecidable + + + + + smi:local/ac504a70-2789-459b-abe6-d747e11faa96 + smi:local/auto + P + undecidable + + + + + smi:local/510aeb18-6ad3-409b-aa25-e401e5e0ec2f + smi:local/auto + S + undecidable + + + + + smi:local/004d1ac0-bf5e-4141-b334-94ec9d5ced47 + smi:local/auto + P + undecidable + + + + + smi:local/35406d25-f03a-40ef-9ea6-c167d50ca250 + smi:local/auto + S + undecidable + + + + + smi:local/53ddf3dc-5ef9-4d67-a173-5dcbe5f9039f + smi:local/auto + P + undecidable + + + + + smi:local/2ed73dd0-3142-42b5-a861-c0a11c1e9b84 + smi:local/auto + S + undecidable + + + + + smi:local/736ccd62-5453-4bbc-b5bf-a1f61d9ba003 + smi:local/auto + P + undecidable + + + + + smi:local/6b173277-1c42-4d6d-ad36-034629bcdd42 + smi:local/auto + S + undecidable + + + + + smi:local/d568e1b4-9af6-4852-b764-a0349bd47e73 + smi:local/auto + P + undecidable + + + + + smi:local/84125e65-40e1-41bb-aee6-95fbd031b26c + smi:local/auto + S + undecidable + + + + + smi:local/7c03bba4-4edd-4d6c-9472-6a6713cdd868 + smi:local/auto + P + undecidable + + + + + smi:local/9c65edce-3046-4830-ab1c-e0b99c4a3303 + smi:local/auto + S + undecidable + + + + + smi:local/258b6481-7331-40ca-bc54-87b7418216c0 + smi:local/auto + P + undecidable + + + + + smi:local/ae126d1a-f9b2-4963-af5a-36221bc5e2bf + smi:local/auto + S + undecidable + + + + + smi:local/d9263d70-256a-48a9-8b1f-1fba68bccd61 + smi:local/auto + P + undecidable + + + + + smi:local/e4b77619-43f2-4188-804d-3885b9c1846f + smi:local/auto + S + undecidable + + + + + smi:local/6d5ea429-5bc6-4dcd-9656-3d0fec624bbf + smi:local/auto + P + undecidable + + + + + smi:local/af56fa4b-5062-44bd-ae44-2de0b3eb32bb + smi:local/auto + S + undecidable + + + + + smi:local/dd33ef72-97cb-409c-af8b-bf3b4b7162af + smi:local/auto + P + undecidable + + + + + smi:local/c27c97a5-9c12-495e-8939-822aec708c80 + smi:local/auto + S + undecidable + + + + + smi:local/e3804504-0b75-402e-b960-bfcfa16c299d + smi:local/auto + P + undecidable + + + + + smi:local/8f6ba4f8-d814-4575-8568-8bd896d1061e + smi:local/auto + S + undecidable + + + + + smi:local/83cff4ac-2332-4ad9-9599-98a63788edaf + smi:local/auto + P + undecidable + + + + + smi:local/38dbcea8-4186-4c8d-8bac-488c3cca8156 + smi:local/auto + S + undecidable + + + + + smi:local/b1a78b69-8274-4514-b6ff-7848c80bd255 + smi:local/auto + P + undecidable + + + + + smi:local/cd2e1254-2849-4bcf-bde8-c689c96304a5 + smi:local/auto + S + undecidable + + + + + smi:local/2792708e-3cb2-4e12-89c0-98de64a02f04 + smi:local/auto + P + undecidable + + + + + smi:local/87153d5b-e8b5-4782-9d4c-dfc9c95f7e9f + smi:local/auto + S + undecidable + + + + + smi:local/d5faec23-9075-4edd-8703-dd43bcebf224 + smi:local/auto + P + undecidable + + + + + smi:local/94fd36c6-073b-484e-aca1-3dbe2ffc5973 + smi:local/auto + S + undecidable + + + + + smi:local/7da34dba-660c-490f-a25c-2cf3b76ccd89 + smi:local/auto + P + undecidable + + + + + smi:local/4d6dc3b5-9751-4c50-9877-e3636b16bf6b + smi:local/auto + S + undecidable + + + + + smi:local/35676149-4559-4d48-914d-41ac27179ec1 + smi:local/auto + P + undecidable + + + + + smi:local/07438091-ef8c-4abe-a3df-81cae2c369f9 + smi:local/auto + S + undecidable + + + + + smi:local/1ccc6f91-1fb8-493d-a440-5b012da8e89e + smi:local/auto + P + undecidable + + + + + smi:local/1014c334-29eb-4d04-b762-b50c854fa705 + smi:local/auto + S + undecidable + + + + + smi:local/6abf6757-a9f4-4262-a115-7be004beda3a + smi:local/auto + P + undecidable + + + + + smi:local/f6b9e7fb-10b6-4b74-a091-02ccdc7d263b + smi:local/auto + S + undecidable + + + + + smi:local/8a927499-2490-4206-8ca7-f32e8cba1781 + smi:local/auto + P + undecidable + + + + + smi:local/80493fb4-ce78-4fe4-916b-917f6f3426ff + smi:local/auto + S + undecidable + + + + + smi:local/fafc7eb7-ff08-4a36-a86b-036ecc590682 + smi:local/auto + P + undecidable + + + + + smi:local/f6d23003-903b-4c8d-b3a3-acbf00cf2c0f + smi:local/auto + S + undecidable + + + + + smi:local/167098b1-5e1f-4b6a-aaa5-be0381e53f11 + smi:local/auto + P + undecidable + + + + + smi:local/f7c62d26-610b-427c-89ef-acc96feaf9b6 + smi:local/auto + S + undecidable + + + + + smi:local/6ca024c0-1845-4318-a1fa-51fc61e77946 + smi:local/auto + P + undecidable + + + + + smi:local/f80a6916-ebf8-40cf-aa4c-93811f53d610 + smi:local/auto + S + undecidable + + + + + smi:local/28f940b6-2177-49f6-bd12-6d05d28f2f2a + smi:local/auto + P + undecidable + + + + + smi:local/5e24d04b-9d10-40aa-96d7-4ad08258c90f + smi:local/auto + S + undecidable + + + + + smi:local/592f5063-2625-4874-b4e2-09044ad931a9 + smi:local/auto + P + undecidable + + + + + smi:local/225283be-24de-4570-9604-11c0968fa19a + smi:local/auto + S + undecidable + + + + + smi:local/e4f673da-4318-4c6e-9c0b-dc12b338353f + smi:local/auto + P + undecidable + + + + + smi:local/a5346f1f-200c-43f9-8e27-09c303a5805c + smi:local/auto + S + undecidable + + + + + smi:local/b19617f6-20d1-48b2-ba8e-316adefb384a + smi:local/auto + P + undecidable + + + + + smi:local/8ac1178c-9e64-4c2d-b0c1-5ea3ca86da38 + smi:local/auto + S + undecidable + + + + + smi:local/b6820848-5b96-44a1-b982-5c4da0ea8e12 + smi:local/auto + P + undecidable + + + + + smi:local/e6ad1062-8792-4109-be17-057d685fabac + smi:local/auto + S + undecidable + + + + + smi:local/52e9a138-fdfe-402f-9d26-b989672f660d + smi:local/auto + P + undecidable + + + + + smi:local/04e663ec-89d2-4998-b158-9d47b68ba51b + smi:local/auto + S + undecidable + + + + + smi:local/11201073-b081-40c0-a59e-592de794ce96 + smi:local/auto + P + undecidable + + + + + smi:local/f7be496b-e00b-49b6-aa30-8639ec462719 + smi:local/auto + S + undecidable + + + + + smi:local/093cf2a0-111f-479d-b182-6bdee0f47ff0 + smi:local/auto + P + undecidable + + + + + smi:local/5a82e714-c710-4339-8274-d0be4194f55e + smi:local/auto + S + undecidable + + + + + smi:local/bbdfdae4-5726-4e76-a100-12128dd37977 + smi:local/auto + P + undecidable + + + + + smi:local/1384f974-86b8-4c47-a252-4f0dab648c3f + smi:local/auto + S + undecidable + + + + + smi:local/0d37144f-1e8b-4f67-946e-5ce19fea0632 + smi:local/auto + P + undecidable + + + + + smi:local/b159348f-959c-44ff-87dd-9d1d7ff03c48 + smi:local/auto + S + undecidable + + + + + smi:local/e37a5436-ac6d-40fa-8bbd-dc1407e60e10 + smi:local/auto + P + undecidable + + + + + smi:local/b746b4d0-2995-48e5-a541-d931e57e121b + smi:local/auto + S + undecidable + + + + + smi:local/bf9e0e1a-0e36-4a09-8f2a-8170da346f5f + smi:local/auto + P + undecidable + + + + + smi:local/12cbca4b-a4e2-4497-906f-dbe21f229420 + smi:local/auto + S + undecidable + + + + + smi:local/426611a0-df70-409c-8141-e8e4d048c74b + smi:local/auto + P + undecidable + + + + + smi:local/590faef4-30c5-463d-b15d-7e9bd7bbdc75 + smi:local/auto + S + undecidable + + + + + smi:local/0511789f-48f6-4d52-8612-05eaffa1cb7c + smi:local/auto + P + undecidable + + + + + smi:local/4dbe7006-cd6a-4fdd-a06e-6ff9fecf9ace + smi:local/auto + S + undecidable + + + + + smi:local/220b99e3-cb96-4b01-ba92-2a78180b7190 + smi:local/auto + P + undecidable + + + + + smi:local/048e5711-7ef6-4e01-a994-1ef744105389 + smi:local/auto + S + undecidable + + + + + smi:local/ee92af2c-8f68-4281-935f-4de83562cbb1 + smi:local/auto + P + undecidable + + + + + smi:local/43303d07-9d9c-490b-94f6-9ce65ea5356a + smi:local/auto + S + undecidable + + + + + smi:local/7b3d20cb-528d-4655-85e9-7da153c28d98 + smi:local/auto + P + undecidable + + + + + smi:local/9cf09088-4eaa-4ebb-8b94-62cd3e3bd108 + smi:local/auto + S + undecidable + + + + + smi:local/78a724d8-8409-4c73-8cb8-a099c1331194 + smi:local/auto + P + undecidable + + + + + smi:local/7e7e2009-a05b-4bb6-b769-23c4db2999d6 + smi:local/auto + S + undecidable + + + + + smi:local/8da8aa23-2377-4c59-a2a6-6caf71ecb9a1 + smi:local/auto + P + undecidable + + + + + smi:local/5fe5f314-e2c3-4dcc-bac4-f46936f3173d + smi:local/auto + S + undecidable + + + + + smi:local/a8721c47-b028-4065-a744-8e17bcfca12a + smi:local/auto + P + undecidable + + + + + smi:local/8295d6d5-6015-4624-a315-e2ee40a5d9db + smi:local/auto + S + undecidable + + + + + smi:local/1e9ad943-950d-4d21-a9fc-033d310f3895 + smi:local/auto + P + undecidable + + + + + smi:local/2ae885f3-876a-4635-8b4e-97cd539432ac + smi:local/auto + S + undecidable + + + + + smi:local/5c07d70a-76e3-4688-8064-22fdf621bf03 + smi:local/auto + P + undecidable + + + + + smi:local/6d9bfd88-48bd-4793-9711-3bdf86a52b7f + smi:local/auto + S + undecidable + + + + + smi:local/2e3f7688-7add-43ad-a779-f3bbc69e97c9 + smi:local/auto + P + undecidable + + + + + smi:local/42de0108-3171-43aa-8371-ce7d8db19a5e + smi:local/auto + S + undecidable + + + + + smi:local/81327f66-16e8-40da-a9c6-3246e869f56d + smi:local/auto + P + undecidable + + + + + smi:local/dac362f4-38de-4c40-a55d-3dc121e88ce4 + smi:local/auto + S + undecidable + + + + + smi:local/2fc82211-fc36-4c62-901f-2b84eca96a35 + smi:local/auto + P + undecidable + + + + + smi:local/970fbe39-0758-49e5-8a47-ded2a2e5e355 + smi:local/auto + S + undecidable + + + + + smi:local/b3be922f-202c-44bf-8917-6ddaa38817c0 + smi:local/auto + P + undecidable + + + + + smi:local/0dbed5ff-58b1-4379-8337-464251ecc85c + smi:local/auto + S + undecidable + + + + + smi:local/8727cd42-8f85-4210-836d-23636c884e4a + smi:local/auto + P + undecidable + + + + + smi:local/4fbf98d7-28fd-4f53-8975-c8a616cc36a4 + smi:local/auto + S + undecidable + + + + + smi:local/3cb8fcee-2b4f-4f1f-9ce7-7bfbe25a90d5 + smi:local/auto + P + undecidable + + + + + smi:local/6d53b817-cddc-4cdc-8fdd-5c02f5b16342 + smi:local/auto + S + undecidable + + + + + smi:local/87d884e5-ac0a-4bdd-b637-c328ece0d8dd + smi:local/auto + P + undecidable + + + + + smi:local/4b1dd809-1fae-44b1-9aea-8bcb4fc3cd05 + smi:local/auto + S + undecidable + + + + + smi:local/8849eb41-02eb-4ec0-8442-30e15e69d016 + smi:local/auto + P + undecidable + + + + + smi:local/b25ef575-f8c4-4e6b-8fc3-1a7e190786b4 + smi:local/auto + S + undecidable + + + + + smi:local/e2775a22-8210-4381-84b2-4345209b0dc3 + smi:local/auto + P + undecidable + + + + + smi:local/34f5983e-47e8-41f9-a9af-119630b13824 + smi:local/auto + S + undecidable + + + + + smi:local/3c8b353b-dd2f-4b52-96c8-dcf8ebe653ba + smi:local/auto + P + undecidable + + + + + smi:local/67056470-8807-43b9-9d2d-3285f01c4f53 + smi:local/auto + S + undecidable + + + + + smi:local/6219cab5-95aa-49a9-8639-37defae259d4 + smi:local/auto + P + undecidable + + + + + smi:local/373af361-3fe1-4dca-ab61-04c0739931b3 + smi:local/auto + S + undecidable + + + + + smi:local/5049011b-fe5a-4c16-a592-afe320c53893 + smi:local/auto + P + undecidable + + + + + smi:local/95423275-7300-4381-9126-98c9ae8c8898 + smi:local/auto + S + undecidable + + + + + smi:local/881c363f-91f3-4a77-9a64-e86aa76159c7 + smi:local/auto + P + undecidable + + + + + smi:local/963fc6b5-d7d9-4d41-9ed6-1eaf6ff1ad70 + smi:local/auto + S + undecidable + + + + + smi:local/11c2ccde-b9a9-4955-bb61-deeb55c23cc5 + smi:local/auto + P + undecidable + + + + + smi:local/7a54d7f3-8371-477f-bf99-62cc7c876a1d + smi:local/auto + S + undecidable + + + + + smi:local/65a5bb58-a981-44f2-be8a-35abb2d35192 + smi:local/auto + P + undecidable + + + + + smi:local/9775a110-24cb-4e26-a7d8-bd5e062c6b04 + smi:local/auto + S + undecidable + + + + + smi:local/d5648ede-0d17-40d4-9098-e9814a5c034b + smi:local/auto + P + undecidable + + + + + smi:local/2c0cf7da-b1c4-4497-908e-7a97555500e3 + smi:local/auto + S + undecidable + + + + + smi:local/e11e9468-2ab8-4906-95fb-ca90cf204d5b + smi:local/auto + P + undecidable + + + + + + + smi:local/c868e5bc-1da5-4428-bb7d-151cd66c97d8 + smi:local/auto + P + undecidable + + + + + smi:local/4e55e364-c7d9-404d-a80f-560f7674579a + smi:local/auto + S + undecidable + + + + + smi:local/20a06e69-838d-41a9-b391-8109ed9d0bff + smi:local/auto + P + undecidable + + + + + smi:local/8975b343-3471-4a21-9a89-e371b5350eea + smi:local/auto + S + undecidable + + + + + smi:local/c74419aa-cb29-4bc1-9a49-3f7c47411054 + smi:local/auto + P + undecidable + + + + + smi:local/2243252b-7a15-4b74-8fdc-086c33b500ca + smi:local/auto + S + undecidable + + + + + smi:local/294a01d8-e6e4-42d6-9ccc-10e1baa3fb35 + smi:local/auto + P + undecidable + + + + + smi:local/a1806340-bfd8-43dc-b397-3763d76dbb1f + smi:local/auto + S + undecidable + + + + + smi:local/f5836a6b-9d45-48d6-8174-c17d28207fee + smi:local/auto + P + undecidable + + + + + smi:local/72f32b6d-9af3-4f3c-9efe-c000bc2d50cd + smi:local/auto + S + undecidable + + + + + smi:local/e36d72e0-e048-422c-bb90-a66f53abec76 + smi:local/auto + P + undecidable + + + + + smi:local/0df73d5b-7f59-467f-a0ba-17d31c4f3691 + smi:local/auto + S + undecidable + + + + + smi:local/bedd51a9-9d98-428b-8506-c3f008898daa + smi:local/auto + P + undecidable + + + + + smi:local/7f523e3b-f0ec-4f96-9c95-e346ca675c9e + smi:local/auto + S + undecidable + + + + + smi:local/9241cf63-4351-49f2-8ccd-3cbaffd3c8c7 + smi:local/auto + P + undecidable + + + + + smi:local/70fd3759-5492-42ba-b21e-84bf4b9e645a + smi:local/auto + S + undecidable + + + + + smi:local/299c2bb2-0e8a-4ccc-8464-b9f96b6e8ee8 + smi:local/auto + P + undecidable + + + + + smi:local/b90c16fb-8e27-47c4-88a9-3d6e83d3a641 + smi:local/auto + S + undecidable + + + + + smi:local/398a9448-bc04-4f7b-bf4a-59371e1c52fa + smi:local/auto + P + undecidable + + + + + smi:local/f24f3ba0-3e2f-4e1e-87ab-edc7a5d446d6 + smi:local/auto + S + undecidable + + + + + smi:local/1c9b270b-3c35-4334-98d1-6cb245313c7b + smi:local/auto + P + undecidable + + + + + smi:local/8a0c3d82-fcf8-4050-89e8-4d4bd4b9b6ff + smi:local/auto + S + undecidable + + + + + smi:local/05c076fa-cefd-4ac0-a983-d720eb42d72e + smi:local/auto + P + undecidable + + + + + smi:local/ab57476f-440b-4bc5-b5eb-5ad7032fa2a3 + smi:local/auto + S + undecidable + + + + + smi:local/2008b526-3b7d-4429-bb66-7ef3cf77de9f + smi:local/auto + P + undecidable + + + + + smi:local/1d12e8b4-0f57-4790-bfd6-3af7992ba07c + smi:local/auto + S + undecidable + + + + + smi:local/60ff9442-7426-470a-9259-90e7ee6bb85f + smi:local/auto + P + undecidable + + + + + smi:local/e4335237-eb2f-48fc-9c1f-7501a35549f8 + smi:local/auto + S + undecidable + + + + + smi:local/70ff4939-7a24-400d-9867-0f9d7c69ab65 + smi:local/auto + P + undecidable + + + + + smi:local/2632510c-5db6-4b5c-820b-b8e393be8337 + smi:local/auto + S + undecidable + + + + + smi:local/e7215b71-ae47-4b38-8711-d957792a483d + smi:local/auto + P + undecidable + + + + + smi:local/c1266188-2611-4df6-8f26-8ea2f1cdb9b6 + smi:local/auto + S + undecidable + + + + + smi:local/4e0b7c66-c446-4ba4-9696-aff057028eb0 + smi:local/auto + P + undecidable + + + + + smi:local/af5f6627-97b2-49c6-b1f5-bf626ba39195 + smi:local/auto + S + undecidable + + + + + smi:local/c0463dfa-e521-4119-8e32-d3f2f3790d26 + smi:local/auto + P + undecidable + + + + + smi:local/20e22f92-e806-41ce-b78b-5e791f1fc596 + smi:local/auto + S + undecidable + + + + + smi:local/2035230e-fe90-4c51-9333-e7ba5b72f40a + smi:local/auto + P + undecidable + + + + + smi:local/82622da8-7d77-4d51-9846-7a9b2e4eb818 + smi:local/auto + S + undecidable + + + + + smi:local/e7090022-858a-4860-8148-e7a4bdc51bd9 + smi:local/auto + P + undecidable + + + + + smi:local/a8ce861f-7b64-434a-b770-0bb293d81d40 + smi:local/auto + S + undecidable + + + + + smi:local/f2e22af6-3785-4495-9c31-83f5d7f1d25e + smi:local/auto + P + undecidable + + + + + smi:local/8f7f42fa-679f-4c90-b5fe-af31d45f57da + smi:local/auto + S + undecidable + + + + + smi:local/34e2caa0-f4aa-43e3-ab76-0de97b2da399 + smi:local/auto + P + undecidable + + + + + smi:local/218cc7ee-5b32-4c49-b1b4-8819fc7888d0 + smi:local/auto + S + undecidable + + + + + smi:local/09b0c1f5-4505-4f22-b91e-2ce43365f88e + smi:local/auto + P + undecidable + + + + + smi:local/47b8d6db-8a9e-4ce4-803b-095675db5225 + smi:local/auto + S + undecidable + + + + + smi:local/307d9b36-2ae8-4cae-99c1-46a444b62c26 + smi:local/auto + P + undecidable + + + + + smi:local/bdbc3ae0-8092-4b1e-8eed-533214c88c29 + smi:local/auto + S + undecidable + + + + + smi:local/7270397c-1359-48df-a656-e780ffe2381e + smi:local/auto + P + undecidable + + + + + smi:local/99310051-da77-4504-9890-f2a21544ad39 + smi:local/auto + S + undecidable + + + + + smi:local/c420758c-d539-42a4-9b92-ab42ec598f64 + smi:local/auto + P + undecidable + + + + + smi:local/7badc93d-cae6-43f1-a8d4-ba31bcef24ac + smi:local/auto + S + undecidable + + + + + smi:local/3731a44a-b0c5-4b8a-904e-c706c848fd3a + smi:local/auto + P + undecidable + + + + + smi:local/41c0fbb8-8886-4288-a542-fd6786bdee33 + smi:local/auto + S + undecidable + + + + + smi:local/4bbe22cf-dfcf-4be0-9ac4-c7382ab3ebe0 + smi:local/auto + P + undecidable + + + + + smi:local/c2fdff1c-6958-4af6-9705-9e992a328899 + smi:local/auto + S + undecidable + + + + + smi:local/18e49839-4e87-410d-b23a-f0372e8fc8aa + smi:local/auto + P + undecidable + + + + + smi:local/ca0a407a-e88e-43e6-a30d-0ba429f3fac1 + smi:local/auto + S + undecidable + + + + + smi:local/fba4f1cc-96d6-4ac0-a381-ddf5b39d7be2 + smi:local/auto + P + undecidable + + + + + smi:local/93f209ff-85fb-496a-8fd4-0a0853489531 + smi:local/auto + S + undecidable + + + + + smi:local/7fbd2a9b-4d03-413c-a88a-4704d2301df4 + smi:local/auto + P + undecidable + + + + + smi:local/1e4aa4ac-1b85-4f88-b109-8639442be82c + smi:local/auto + S + undecidable + + + + + smi:local/0dda89eb-08a7-4d43-b1a8-d60e74b282f4 + smi:local/auto + P + undecidable + + + + + smi:local/0a19e589-53a4-4a30-b9a9-2e0612d3670a + smi:local/auto + S + undecidable + + + + + smi:local/77e3395c-e849-407b-ab8b-411015c2ad46 + smi:local/auto + P + undecidable + + + + + smi:local/6300e025-c4f1-4a06-955d-d6f7b433ac0e + smi:local/auto + S + undecidable + + + + + smi:local/fd4a874a-d9c8-46b5-95ea-e72249d084ee + smi:local/auto + P + undecidable + + + + + smi:local/1edffe31-0f9c-4e18-8003-8973a64d7c43 + smi:local/auto + S + undecidable + + + + + smi:local/4361e5e9-1f76-48d9-8f7f-dd380bcf27a5 + smi:local/auto + P + undecidable + + + + + smi:local/a393fc42-f5f3-4ede-838e-244b8a1ad830 + smi:local/auto + S + undecidable + + + + + smi:local/f17d8361-2db1-4dd4-88b3-a2243c943053 + smi:local/auto + P + undecidable + + + + + smi:local/86a05ec9-1ee2-4241-959e-2470e394c34f + smi:local/auto + S + undecidable + + + + + smi:local/1a4cef62-8eae-43e4-8ad1-5e521b623b6f + smi:local/auto + P + undecidable + + + + + smi:local/7f734a78-b223-4561-a493-290b2d338d6a + smi:local/auto + S + undecidable + + + + + smi:local/de90b572-b9ca-4d84-a5c0-1aa1ebd487ce + smi:local/auto + P + undecidable + + + + + smi:local/026c5fb4-ba45-4864-b18e-edac71afa122 + smi:local/auto + S + undecidable + + + + + smi:local/78f93e1d-f945-421f-a0a8-d880f160271a + smi:local/auto + P + undecidable + + + + + smi:local/cd11eca8-2d55-4a05-9c38-5f531e7fded6 + smi:local/auto + S + undecidable + + + + + smi:local/7685af92-158a-4bc8-aafe-77b04ccaeddf + smi:local/auto + P + undecidable + + + + + smi:local/fa1632da-d817-434a-9e84-97c3fc380c7e + smi:local/auto + S + undecidable + + + + + smi:local/b00bb18e-fe5b-4712-9c4f-13c289116158 + smi:local/auto + P + undecidable + + + + + smi:local/a8d939cd-88ef-4b1a-aa75-e674c8825fc3 + smi:local/auto + S + undecidable + + + + + smi:local/427b552b-1857-48c3-b48f-d369f5527e85 + smi:local/auto + P + undecidable + + + + + smi:local/b1d86266-aea4-450e-99c9-6e3d001d6c58 + smi:local/auto + S + undecidable + + + + + smi:local/fb597e78-36a8-400c-87ba-d30d85eca690 + smi:local/auto + P + undecidable + + + + + smi:local/cb30ece1-0f0e-4064-8147-2d6709527488 + smi:local/auto + S + undecidable + + + + + smi:local/b01f7d40-6654-4751-b052-c43b5cbb62e6 + smi:local/auto + P + undecidable + + + + + smi:local/715d05a9-5f88-40c3-ab28-bf0a579356b7 + smi:local/auto + S + undecidable + + + + + smi:local/c6931a3c-c096-4e37-bb55-4161ac7e7741 + smi:local/auto + P + undecidable + + + + + smi:local/a0e03fec-66f7-4a5c-9f4b-9d1097515fea + smi:local/auto + S + undecidable + + + + + smi:local/9aea55fb-66aa-4b4c-8ff0-93f20e36045e + smi:local/auto + P + undecidable + + + + + smi:local/a7a59392-b734-4863-bd3b-d60f350efd26 + smi:local/auto + S + undecidable + + + + + smi:local/015b9f0b-32f2-46d7-8a4c-904f5756b670 + smi:local/auto + P + undecidable + + + + + smi:local/725cfafd-007c-4646-97a9-1dce6ee42d67 + smi:local/auto + S + undecidable + + + + + smi:local/461f257f-7883-44e4-b3be-c72054cd00ab + smi:local/auto + P + undecidable + + + + + smi:local/8437d512-920b-4d93-91db-cb96ffa69007 + smi:local/auto + S + undecidable + + + + + smi:local/41b776b7-eef0-482e-a447-04c9860a7770 + smi:local/auto + P + undecidable + + + + + smi:local/1c84b5e6-37a2-48b4-9fc5-54e0f16fef52 + smi:local/auto + S + undecidable + + + + + smi:local/8b3c98e8-f137-4ecc-b99f-6edc9a707127 + smi:local/auto + P + undecidable + + + + + smi:local/15159189-73a6-4cee-b228-03dad9d3ef71 + smi:local/auto + S + undecidable + + + + + smi:local/59b0ce63-218f-4769-ae80-df6b9b66f00f + smi:local/auto + P + undecidable + + + + + smi:local/1fdf44ad-68a3-4589-89b4-8ce8eda07d0c + smi:local/auto + S + undecidable + + + + + smi:local/b54a091b-7dbf-4034-b001-d870f98d336c + smi:local/auto + P + undecidable + + + + + smi:local/209aca08-9e48-48f8-be3b-6b4038299a8a + smi:local/auto + S + undecidable + + + + + smi:local/603eae19-8a64-4c98-ba45-e362e84372ed + smi:local/auto + P + undecidable + + + + + smi:local/b813f964-6b73-4a29-a13d-f9aeb5c2e95b + smi:local/auto + S + undecidable + + + + + smi:local/53c188db-0a6d-4535-92ed-8c5dfe91f30a + smi:local/auto + P + undecidable + + + + + smi:local/7cfedd74-c916-42a4-af87-4a9d862ae4aa + smi:local/auto + S + undecidable + + + + + smi:local/1cc8f430-093f-451e-890f-bc5438719f7c + smi:local/auto + P + undecidable + + + + + smi:local/03445153-bd7a-49be-ae7e-0ba522847d91 + smi:local/auto + S + undecidable + + + + + smi:local/732befdb-8273-4bf0-968a-ea2e2ab741b1 + smi:local/auto + P + undecidable + + + + + smi:local/533132fb-907e-432c-be0b-a41a70b22e13 + smi:local/auto + S + undecidable + + + + + smi:local/ddd75183-2fee-4dd4-ab0f-3a79d290a27d + smi:local/auto + P + undecidable + + + + + smi:local/85034240-8e38-4624-ad5f-e48a82f48cf4 + smi:local/auto + S + undecidable + + + + + smi:local/d1e49ed5-ef16-4929-8a75-f348e00a4791 + smi:local/auto + P + undecidable + + + + + smi:local/c9f1547d-b712-4903-b567-f32102885e1a + smi:local/auto + S + undecidable + + + + + smi:local/f1029c11-283c-4343-86ee-a05b9b6337be + smi:local/auto + P + undecidable + + + + + smi:local/0bee87ff-79d7-4179-9895-62a48bbc7787 + smi:local/auto + S + undecidable + + + + + smi:local/fd36fb65-28d7-4072-b60b-c2a1b912f3ab + smi:local/auto + P + undecidable + + + + + smi:local/610f063d-7b71-4491-9539-f3f45e73b6cd + smi:local/auto + S + undecidable + + + + + smi:local/7ee75f6b-fbd7-4b39-9de6-fc583104f9da + smi:local/auto + P + undecidable + + + + + smi:local/ddab01cb-bef9-489f-bc51-f260ba8ea39f + smi:local/auto + S + undecidable + + + + + smi:local/e8261df8-7266-469f-b051-5168a87f9611 + smi:local/auto + P + undecidable + + + + + smi:local/d678c98c-eddf-44f1-b06d-b4c2b58128ed + smi:local/auto + S + undecidable + + + + + smi:local/155f42dd-e045-4f6b-b897-b21e15d2512f + smi:local/auto + P + undecidable + + + + + smi:local/c5680b1e-c379-4524-8999-d715ee8ce737 + smi:local/auto + S + undecidable + + + + + smi:local/f14eadcf-e76a-40d1-a816-904b21e3ee70 + smi:local/auto + P + undecidable + + + + + smi:local/bfc50848-89bc-4bc2-86d2-8733238f0576 + smi:local/auto + S + undecidable + + + + + smi:local/5917608c-1562-4efc-89fc-4a0be325eff7 + smi:local/auto + P + undecidable + + + + + smi:local/8d28d53f-73da-41f4-b3b1-cad4707a73dd + smi:local/auto + S + undecidable + + + + + smi:local/ffab4924-2e61-470c-8a31-90edd979e1f2 + smi:local/auto + P + undecidable + + + + + smi:local/48eb3df7-9217-4769-bbd4-49f687a17457 + smi:local/auto + S + undecidable + + + + + smi:local/42d67562-672e-4af3-8d14-d7554cc97e69 + smi:local/auto + P + undecidable + + + + + smi:local/d9d73de0-cd7e-459b-a667-209370c6b3db + smi:local/auto + S + undecidable + + + + + smi:local/690225cc-6c9d-4168-a9e3-c4143a807339 + smi:local/auto + P + undecidable + + + + + smi:local/228740f4-d414-481f-b7c3-8b5411053d06 + smi:local/auto + S + undecidable + + + + + smi:local/ba6a244e-8afc-4b1b-bd07-3190959fc781 + smi:local/auto + P + undecidable + + + + + smi:local/a4b48bfc-6353-49d7-b7ce-40c3cfb2e930 + smi:local/auto + S + undecidable + + + + + smi:local/16f27177-f58e-4c10-931f-d9bd479313b0 + smi:local/auto + P + undecidable + + + + + smi:local/6be0c48f-f1df-45b2-a44d-0afbdd1bd5d9 + smi:local/auto + S + undecidable + + + + + smi:local/8707d100-6029-44c7-952c-5e535a172cc9 + smi:local/auto + P + undecidable + + + + + smi:local/73f2df45-9e89-4443-aa01-5fdeb73a3d23 + smi:local/auto + S + undecidable + + + + + smi:local/959d003e-d756-444f-a68d-ff5ec8f2c829 + smi:local/auto + P + undecidable + + + + + smi:local/f7eee7b5-037f-4883-be67-232abd1a8ab2 + smi:local/auto + S + undecidable + + + + + smi:local/583457ee-f37d-4928-a0fd-e96947eb90dc + smi:local/auto + P + undecidable + + + + + smi:local/ac4ab951-c1f0-44fd-845f-2a833641b6b7 + smi:local/auto + S + undecidable + + + + + smi:local/59d2ab2e-c1aa-4eb4-9255-44312d431ad0 + smi:local/auto + P + undecidable + + + + + smi:local/db44fce9-94e6-449a-b5b2-f58c4883fff9 + smi:local/auto + S + undecidable + + + + + smi:local/b11cd38e-960f-4058-a1fa-21ec7dc1a00e + smi:local/auto + P + undecidable + + + + + smi:local/6be26a88-c535-42f4-8fa4-a81a400c153f + smi:local/auto + S + undecidable + + + + + smi:local/4c016eb4-c093-4f0e-89a4-32fac87cd746 + smi:local/auto + P + undecidable + + + + + smi:local/2a79d6bf-8ff2-43f2-8df8-e8bfe2cce05f + smi:local/auto + S + undecidable + + + + + smi:local/cf4dad76-c25d-432b-b777-812d23a9f19e + smi:local/auto + P + undecidable + + + + + smi:local/6e40d671-30fb-4a5f-b01e-fb42204c85b1 + smi:local/auto + S + undecidable + + + + + smi:local/68749bd9-da4e-4481-b826-6692cd86bff0 + smi:local/auto + P + undecidable + + + + + smi:local/69aad3dc-3fb0-41fa-9f95-26697bdf762b + smi:local/auto + S + undecidable + + + + + smi:local/1f121812-c0cd-46cb-9e81-ae1b239303ff + smi:local/auto + P + undecidable + + + + + smi:local/fcf261b3-9e60-4966-a480-50dacb73dc32 + smi:local/auto + S + undecidable + + + + + smi:local/56c98958-e182-45f6-9717-e1eb943bda40 + smi:local/auto + P + undecidable + + + + + smi:local/70e2dd54-14e6-4276-b7d3-21a8d02372a6 + smi:local/auto + S + undecidable + + + + + smi:local/1146e8fb-05d3-40b1-89c5-3f5758669617 + smi:local/auto + P + undecidable + + + + + smi:local/32f16feb-9c72-4189-a89f-0b2d02b977ef + smi:local/auto + S + undecidable + + + + + smi:local/1b6071b7-da03-4c33-b81f-6ba62ce54810 + smi:local/auto + P + undecidable + + + + + smi:local/b8384c84-de23-495f-a45c-597e3180b3da + smi:local/auto + S + undecidable + + + + + smi:local/afbd873c-494b-42f8-9756-3d28c5feefee + smi:local/auto + P + undecidable + + + + + smi:local/ab4859f8-0ed8-45d1-b5e9-8a5e3235fe87 + smi:local/auto + S + undecidable + + + + + smi:local/129f93b6-2e7c-496b-8695-de13c0c7f2d1 + smi:local/auto + P + undecidable + + + + + smi:local/21ea8ce0-60ad-49d5-afec-5929472e258a + smi:local/auto + S + undecidable + + + + + smi:local/5c25b0be-c084-47db-b64a-4ea4772864f0 + smi:local/auto + P + undecidable + + + + + smi:local/839199ae-8385-4512-9414-4a81ed9ae8eb + smi:local/auto + S + undecidable + + + + + smi:local/c13476b1-0c29-41b1-921f-c340d188b63e + smi:local/auto + P + undecidable + + + + + smi:local/2401c751-1adf-4dc6-b8a6-779b1dd60a49 + smi:local/auto + S + undecidable + + + + + smi:local/17654a3a-6c4b-4951-aa5c-b2337adbe541 + smi:local/auto + P + undecidable + + + + + smi:local/900d0b5c-6d9c-4991-8d5f-9561ad1f3e06 + smi:local/auto + S + undecidable + + + + + smi:local/77aa2a0e-227a-4a16-b8bb-2572b32d8e72 + smi:local/auto + P + undecidable + + + + + smi:local/4c1fae0a-76f3-47ee-8137-bc9ecfda8939 + smi:local/auto + S + undecidable + + + + + smi:local/48a25fe7-0d53-41ae-bf06-369855752904 + smi:local/auto + P + undecidable + + + + + smi:local/44e9202d-cb2a-431c-97d4-781dc6ca1e61 + smi:local/auto + S + undecidable + + + + + smi:local/d70b4217-ed64-4a2d-8ed1-1ea1e047d0ed + smi:local/auto + P + undecidable + + + + + smi:local/c2b0ca26-4c8a-4b04-8ed9-c03f076a9e72 + smi:local/auto + S + undecidable + + + + + smi:local/d26ed6a1-a7fd-4626-a8f6-3a52ce80d08e + smi:local/auto + P + undecidable + + + + + smi:local/3a06a360-0556-402a-ac53-a61e4607f704 + smi:local/auto + S + undecidable + + + + + smi:local/b4226657-2a46-48aa-ac91-d7eba7792855 + smi:local/auto + P + undecidable + + + + + smi:local/17f8e001-691e-49be-ab01-ac29db266d98 + smi:local/auto + S + undecidable + + + + + smi:local/02e162a1-8b60-4059-adba-15b35bfc0a52 + smi:local/auto + P + undecidable + + + + + smi:local/1d0a042a-e508-4c62-a7f2-18face6b9184 + smi:local/auto + S + undecidable + + + + + smi:local/8db98a09-9fdf-4792-be00-8d9bbc4ccd6e + smi:local/auto + P + undecidable + + + + + smi:local/13bae9d2-ef72-4cc7-a771-2ec1b578572e + smi:local/auto + S + undecidable + + + + + smi:local/73c67921-77db-45e2-bf3c-aec793379ca7 + smi:local/auto + P + undecidable + + + + + smi:local/1f095ee7-0a82-4673-845f-9443656ebbb0 + smi:local/auto + S + undecidable + + + + + smi:local/2c1c350f-8ce4-4f95-97bc-4dee09ecc100 + smi:local/auto + P + undecidable + + + + + smi:local/e92f4190-0140-4552-bc2b-b024e291a1f4 + smi:local/auto + S + undecidable + + + + + smi:local/f8748aa1-c7f8-41e0-ac6d-979ba85a098a + smi:local/auto + P + undecidable + + + + + smi:local/09f1d34f-0449-4690-b81a-2c4eed2fb090 + smi:local/auto + S + undecidable + + + + + smi:local/a45dd8e4-628a-4f1e-8626-c2e66db0071b + smi:local/auto + P + undecidable + + + + + smi:local/564cc951-c09f-4523-b993-5c94a499eb6a + smi:local/auto + S + undecidable + + + + + smi:local/de474152-9123-4ed6-a060-bb432629a49c + smi:local/auto + P + undecidable + + + + + smi:local/4a292bcb-6923-4928-b0e6-a42c1d29b039 + smi:local/auto + S + undecidable + + + + + smi:local/b623a359-e738-49c9-af6d-d21136828159 + smi:local/auto + P + undecidable + + + + + smi:local/3a8f28a5-898f-46fb-8065-5334e5cdc81e + smi:local/auto + S + undecidable + + + + + smi:local/e9134d47-a528-4ad9-8bda-d7a8538d785b + smi:local/auto + P + undecidable + + + + + smi:local/0b6a7e45-d883-469a-bfaf-bd794863286b + smi:local/auto + S + undecidable + + + + + smi:local/d5245b34-9240-4405-ac4b-9f86ae77f520 + smi:local/auto + P + undecidable + + + + + smi:local/43ec6dcf-b83d-4f5f-8e2b-4f223bced953 + smi:local/auto + S + undecidable + + + + + smi:local/6b14b242-cd99-476b-b2f1-10022e319423 + smi:local/auto + P + undecidable + + + + + smi:local/4928434c-80eb-4e45-bed1-c127da8026f3 + smi:local/auto + S + undecidable + + + + + smi:local/6f1e454f-7768-411a-a224-eea548eeb7f4 + smi:local/auto + P + undecidable + + + + + smi:local/4fc3d6a1-b5d6-4880-94dd-ef9b14686ed1 + smi:local/auto + S + undecidable + + + + + smi:local/e49568c3-2e8d-425d-aa66-4b0c9d30c711 + smi:local/auto + P + undecidable + + + + + smi:local/13ed1883-36df-4371-ab1e-119f7b5c2001 + smi:local/auto + S + undecidable + + + + + smi:local/c97190df-ae97-4e7b-bc74-b4a3a90f7ec0 + smi:local/auto + P + undecidable + + + + + smi:local/699e2deb-8cb4-4110-9acd-16a6a48c4149 + smi:local/auto + S + undecidable + + + + + smi:local/2d6b1580-4ed7-4355-a3f2-65d8bfe85eb6 + smi:local/auto + P + undecidable + + + + + smi:local/19f14ab8-7143-417d-9aca-c54e13adb361 + smi:local/auto + S + undecidable + + + + + smi:local/564169e7-2b05-43b4-8664-0bee30e7c3c9 + smi:local/auto + P + undecidable + + + + + smi:local/1ed216a3-6539-4d72-ad2b-bfafdf2ee3ac + smi:local/auto + S + undecidable + + + + + smi:local/eec786a0-853d-4913-b9c0-1a1347ef2357 + smi:local/auto + P + undecidable + + + + + smi:local/812a2b8c-8e3f-4335-a6fc-7b86579fa32e + smi:local/auto + S + undecidable + + + + + smi:local/6aa5bb37-3a88-4eb9-8550-af6155d2a071 + smi:local/auto + P + undecidable + + + + + smi:local/c5d8beb8-fd33-4835-9b18-b813e89cbb0a + smi:local/auto + S + undecidable + + + + + smi:local/9738d4c6-4ee7-4a5c-ae4f-5582b832a945 + smi:local/auto + P + undecidable + + + + + smi:local/9ec26510-5e65-4ab7-827b-775da61a9104 + smi:local/auto + S + undecidable + + + + + smi:local/ffb44f26-59f7-4653-84db-66dcd5617397 + smi:local/auto + P + undecidable + + + + + smi:local/4ff82340-d740-4a3f-8f96-93bb70244165 + smi:local/auto + S + undecidable + + + + + smi:local/2eea70bb-dc22-4cf0-b0bd-d6b3a2103110 + smi:local/auto + P + undecidable + + + + + smi:local/6d5ada0b-aa7f-47b8-a916-9976c57159d1 + smi:local/auto + S + undecidable + + + + + smi:local/ee8e6a41-18a1-4d30-9a34-036f1a033124 + smi:local/auto + P + undecidable + + + + + + + smi:local/fe944bee-51a0-46b9-8299-89ffddda3e2a + smi:local/auto + P + undecidable + + + + + smi:local/58470956-894f-45cd-87f5-a67089aebc81 + smi:local/auto + S + undecidable + + + + + smi:local/a2e73948-f6a5-4cdc-b569-2be74ddd2f0d + smi:local/auto + P + undecidable + + + + + smi:local/d0cb990d-42cc-4dfe-8a09-4f252ce179e6 + smi:local/auto + S + undecidable + + + + + smi:local/b3574e10-cab2-447b-9f99-98ea464bad38 + smi:local/auto + P + undecidable + + + + + smi:local/79ee3ddc-9f46-4ec9-a877-e471a073e026 + smi:local/auto + S + undecidable + + + + + smi:local/02aab818-3954-4d57-bc03-0a45c5136c8f + smi:local/auto + P + undecidable + + + + + smi:local/5f457af4-6615-4d70-be26-3a2f6d313245 + smi:local/auto + S + undecidable + + + + + smi:local/f6b5c95e-c330-4ff8-ae7f-d16a3c440a25 + smi:local/auto + P + undecidable + + + + + smi:local/8158d9cc-320b-497e-8ed1-48aaeed56dc4 + smi:local/auto + S + undecidable + + + + + smi:local/ec4f8af7-4aad-421d-8ecb-a85f845dccae + smi:local/auto + P + undecidable + + + + + smi:local/0c12007b-7de4-465b-83d5-c1e5a28a0a84 + smi:local/auto + S + undecidable + + + + + smi:local/73b9b310-5926-45aa-b0ba-4fa5c4cefb05 + smi:local/auto + P + undecidable + + + + + smi:local/98adfada-c6f8-4f3a-847a-912f68e14eb8 + smi:local/auto + S + undecidable + + + + + smi:local/c0a35f7d-165b-41e2-9951-b3c19fa8c5fb + smi:local/auto + P + undecidable + + + + + smi:local/78b48d43-fb5a-4744-971e-f62ecee5a9eb + smi:local/auto + S + undecidable + + + + + smi:local/e491a918-27bb-44b6-9475-02aa4834a089 + smi:local/auto + P + undecidable + + + + + smi:local/ea1b6130-8a26-43c4-b42a-8cf08d9f1c96 + smi:local/auto + S + undecidable + + + + + smi:local/f70c606d-4cf9-4834-8a9b-cf429cb9e058 + smi:local/auto + P + undecidable + + + + + smi:local/6be687cc-5f7f-4e65-8d1d-d789ef1562b8 + smi:local/auto + S + undecidable + + + + + smi:local/e93cb6ac-fc65-4600-9196-1e83aaf00d21 + smi:local/auto + P + undecidable + + + + + smi:local/a2af34e9-2115-4511-b85f-54e545b2bc57 + smi:local/auto + S + undecidable + + + + + smi:local/71ba2365-c80c-45af-8be3-e1c958d898f3 + smi:local/auto + P + undecidable + + + + + smi:local/651e2549-e4ee-43f0-acfc-a486f4235b9d + smi:local/auto + S + undecidable + + + + + smi:local/24e839ed-5c48-419a-9ed1-7fcf2441fce5 + smi:local/auto + P + undecidable + + + + + smi:local/49c2520d-959f-45d0-8257-ea5efc212be4 + smi:local/auto + S + undecidable + + + + + smi:local/1b6b1033-b62a-4ffa-be40-73265cd8c433 + smi:local/auto + P + undecidable + + + + + smi:local/f59bc21e-ce80-491c-b18a-f35d4df31036 + smi:local/auto + S + undecidable + + + + + smi:local/9caa5d82-0ad1-4d04-b039-7a6aa497147d + smi:local/auto + P + undecidable + + + + + smi:local/0003bbe0-e2bc-4f7c-8970-96d27ee0d9f8 + smi:local/auto + S + undecidable + + + + + smi:local/79b93496-c20c-4d90-8323-e5503f4cb9a9 + smi:local/auto + P + undecidable + + + + + smi:local/5165dcd6-97c3-49b8-a235-efe51c987cb5 + smi:local/auto + S + undecidable + + + + + smi:local/068a1d14-61f8-4b45-b3cc-f28a09f40649 + smi:local/auto + P + undecidable + + + + + smi:local/2e2bab5f-db44-46aa-9aea-7a3ca372d655 + smi:local/auto + S + undecidable + + + + + smi:local/54497333-5f0d-4668-98b8-43d0475be219 + smi:local/auto + P + undecidable + + + + + smi:local/f58cd7a9-a09f-46dc-aad5-4b507bc7cccd + smi:local/auto + S + undecidable + + + + + smi:local/9ed9f7f9-7429-4393-bcd2-29ddb074eb1a + smi:local/auto + P + undecidable + + + + + smi:local/7e6a8614-ba8e-4280-a0ed-d8aa91328630 + smi:local/auto + S + undecidable + + + + + smi:local/13cef341-4ee5-47c5-acf6-1308ee2cf6cb + smi:local/auto + P + undecidable + + + + + smi:local/0e538def-9177-4baa-b75c-9b6e866483de + smi:local/auto + S + undecidable + + + + + smi:local/3502bc17-cce6-464c-b8f5-c20af23e7d3d + smi:local/auto + P + undecidable + + + + + smi:local/a99ce8cb-c092-4469-bef0-e81ca3a63f76 + smi:local/auto + S + undecidable + + + + + smi:local/83cb7ac9-ca6c-4f10-a1a4-51a7b9e7c001 + smi:local/auto + P + undecidable + + + + + smi:local/a7242f36-27e5-4ff4-8288-1684e2545495 + smi:local/auto + S + undecidable + + + + + smi:local/c6c369a5-d213-4722-8b24-a462d980f824 + smi:local/auto + P + undecidable + + + + + smi:local/15e546eb-ad9b-4097-8102-0bc0fdf6afc6 + smi:local/auto + S + undecidable + + + + + smi:local/2776af1a-ab85-4816-968d-d7b861ff28ef + smi:local/auto + P + undecidable + + + + + smi:local/b1405f72-a28b-4bf0-838c-565c4e41eba6 + smi:local/auto + S + undecidable + + + + + smi:local/7615e2dd-c493-4de7-91fe-1a5805626924 + smi:local/auto + P + undecidable + + + + + smi:local/9291b0f8-7f7c-4e85-9011-4814fd476ae2 + smi:local/auto + S + undecidable + + + + + smi:local/2f926fe2-9d04-4d96-ad7c-8f6b7379ec65 + smi:local/auto + P + undecidable + + + + + smi:local/fc07a917-c2a3-4264-b89f-1dc91207e999 + smi:local/auto + S + undecidable + + + + + smi:local/8398a55d-b2f1-4b73-badb-6d997f0176ad + smi:local/auto + P + undecidable + + + + + smi:local/9f47613d-d587-48c6-b359-8b51eecd6806 + smi:local/auto + S + undecidable + + + + + smi:local/6ac5c8dc-c88a-4098-a54c-3023c1566a95 + smi:local/auto + P + undecidable + + + + + smi:local/2e7b0082-4384-4735-83ab-3ba3fa77eed1 + smi:local/auto + S + undecidable + + + + + smi:local/872355d0-5146-480b-83b2-8202d5950d6b + smi:local/auto + P + undecidable + + + + + smi:local/2159b6ff-e08e-4225-976e-a50a85c8b9c9 + smi:local/auto + S + undecidable + + + + + smi:local/e69cb08e-04da-4250-bd96-6bca4fbd55cc + smi:local/auto + P + undecidable + + + + + smi:local/476f10ef-b858-4097-aeba-80a1c7c1c988 + smi:local/auto + S + undecidable + + + + + smi:local/3c9e0f8e-5542-4a17-9adb-3d60359b69ec + smi:local/auto + P + undecidable + + + + + smi:local/bb057ee4-3dab-4dc9-85c9-b7c261841841 + smi:local/auto + S + undecidable + + + + + smi:local/bed8d4fc-5be2-4160-8d92-94c4d8a10760 + smi:local/auto + P + undecidable + + + + + smi:local/e35239c3-7e38-46a0-bfaf-f9158bc05463 + smi:local/auto + S + undecidable + + + + + smi:local/726f83d3-dda0-4130-9d63-8497f8c6e4cb + smi:local/auto + P + undecidable + + + + + smi:local/4faf6ed3-24ad-4267-bee2-cfbc46db9cff + smi:local/auto + S + undecidable + + + + + smi:local/e1332897-d04e-4598-a4ec-6272c05821f6 + smi:local/auto + P + undecidable + + + + + smi:local/125d0767-ef53-4576-8ee0-3cdc07edc43f + smi:local/auto + S + undecidable + + + + + smi:local/29a60037-990f-45a4-a91d-8c28f84c5534 + smi:local/auto + P + undecidable + + + + + smi:local/4d94a4a0-3cc7-4d47-a7fd-b46536083095 + smi:local/auto + S + undecidable + + + + + smi:local/0b2f4dc4-49d9-4e98-8b3d-155c93ab3c9a + smi:local/auto + P + undecidable + + + + + smi:local/75ed1202-cea0-40a1-ba4c-eb761fe8be29 + smi:local/auto + S + undecidable + + + + + smi:local/4c22dda2-e699-4cac-8a94-c53153bc83c8 + smi:local/auto + P + undecidable + + + + + smi:local/179f4df1-e683-4145-8070-ba6a738611c9 + smi:local/auto + S + undecidable + + + + + smi:local/500b9835-86ee-4647-8106-f6c8c362c81e + smi:local/auto + P + undecidable + + + + + smi:local/22038a1c-a9d2-498e-bef9-78307948dd73 + smi:local/auto + S + undecidable + + + + + smi:local/594d5de3-1e3d-485c-8149-799b6a5d9dac + smi:local/auto + P + undecidable + + + + + smi:local/11f474dc-c660-4874-a349-86efb05033ae + smi:local/auto + S + undecidable + + + + + smi:local/de22d648-f0ec-4307-a8c5-34014c091d61 + smi:local/auto + P + undecidable + + + + + smi:local/6d8f15ff-aec2-4576-ae5d-2cbacfea4d4e + smi:local/auto + S + undecidable + + + + + smi:local/1a0896d2-4e83-4294-afd9-6126a9eec674 + smi:local/auto + P + undecidable + + + + + smi:local/3ff3369e-49ce-43b3-b398-075b8a528b2d + smi:local/auto + S + undecidable + + + + + smi:local/6f4482f2-364e-4efb-bb91-355e152e79b7 + smi:local/auto + P + undecidable + + + + + smi:local/98a9e84a-4d5a-4dcd-834f-814d4d456460 + smi:local/auto + S + undecidable + + + + + smi:local/c9808906-9437-4136-ab93-1f7b00f4be77 + smi:local/auto + P + undecidable + + + + + smi:local/05118e3d-ef71-46b9-8021-eee3099e8b01 + smi:local/auto + S + undecidable + + + + + smi:local/dcf71bd7-76ae-4b21-83d3-79ec641775bd + smi:local/auto + P + undecidable + + + + + smi:local/dee611c1-96c6-452b-a522-6b84d514d5e9 + smi:local/auto + S + undecidable + + + + + smi:local/f83d5884-a437-48e8-87f2-6e91329e5e81 + smi:local/auto + P + undecidable + + + + + smi:local/a231c31e-9140-45f8-b307-10319d23392d + smi:local/auto + S + undecidable + + + + + smi:local/429530a4-0ae7-4a03-a3e4-4efa7b55ed01 + smi:local/auto + P + undecidable + + + + + smi:local/e0ab061d-f282-42f9-8549-f0bc4f850fa2 + smi:local/auto + S + undecidable + + + + + smi:local/eb0d0c98-9d1e-4765-b708-8f2ce05bbd80 + smi:local/auto + P + undecidable + + + + + smi:local/0f94f86a-7e0e-479e-b95f-6849873e3a1b + smi:local/auto + S + undecidable + + + + + smi:local/5d4733ec-3e08-473a-8771-7b508ce37d7e + smi:local/auto + P + undecidable + + + + + smi:local/51aeff61-fd15-4afd-af11-519858ace2b4 + smi:local/auto + S + undecidable + + + + + smi:local/27b4245d-c951-44fb-b3d7-d62e90c63ade + smi:local/auto + P + undecidable + + + + + smi:local/d310988c-7abe-4eae-ba93-cd2349528143 + smi:local/auto + S + undecidable + + + + + smi:local/00596462-ec8b-44e8-8e76-6587be928926 + smi:local/auto + P + undecidable + + + + + smi:local/a89dd1e2-c176-45b0-a133-8c802e3fba7a + smi:local/auto + S + undecidable + + + + + smi:local/aa9e7e38-e48b-4a7a-a573-c144f021460c + smi:local/auto + P + undecidable + + + + + smi:local/26c6d890-d438-46fa-a77a-639eae78d806 + smi:local/auto + S + undecidable + + + + + smi:local/0511d499-5548-4982-a10d-27d0a29dafb2 + smi:local/auto + P + undecidable + + + + + smi:local/53476bc2-fb2c-448d-9108-7152904d0af5 + smi:local/auto + S + undecidable + + + + + smi:local/f5d09458-7e18-4bfe-9e4f-1bbf33c168da + smi:local/auto + P + undecidable + + + + + smi:local/3e2840c5-d33d-40ff-b93b-b5eb8c570c9b + smi:local/auto + S + undecidable + + + + + smi:local/8dc84b53-582a-4a74-85e7-5ea58ad19904 + smi:local/auto + P + undecidable + + + + + smi:local/6a48c5fc-b015-45c5-8822-0092d44b5f52 + smi:local/auto + S + undecidable + + + + + smi:local/14cabf41-2bfc-4455-a3f0-000361491522 + smi:local/auto + P + undecidable + + + + + smi:local/e76c6b41-08c2-450f-b4f4-50384256730a + smi:local/auto + S + undecidable + + + + + smi:local/1750fe74-1546-430b-8b5a-09ea602172ae + smi:local/auto + P + undecidable + + + + + smi:local/262cf6c7-fd7a-4000-ba92-894a4e593401 + smi:local/auto + S + undecidable + + + + + smi:local/0cbdb94c-431e-4f21-8b60-cf8808374a00 + smi:local/auto + P + undecidable + + + + + smi:local/b6a84b26-c16f-4d28-b7a4-df9b15786e6b + smi:local/auto + S + undecidable + + + + + smi:local/bae6887a-f6dd-4e66-9113-f4d7e7e256b8 + smi:local/auto + P + undecidable + + + + + smi:local/3901e8ef-9d73-4a0d-841c-b44f2c1542ec + smi:local/auto + S + undecidable + + + + + smi:local/15d2f735-fd16-4487-aa4e-ca6a682b91f9 + smi:local/auto + P + undecidable + + + + + smi:local/d20ae512-67b2-4c77-81ed-b9bbde1f8aec + smi:local/auto + S + undecidable + + + + + smi:local/bf9076aa-8469-4344-b367-070067889431 + smi:local/auto + P + undecidable + + + + + smi:local/e1698f1d-e56d-477d-bc0e-f3aef62cb727 + smi:local/auto + S + undecidable + + + + + smi:local/69e33493-7bdb-4366-b621-0ee9d5765645 + smi:local/auto + P + undecidable + + + + + smi:local/8121f0f1-a206-48ec-ac7b-afbd7807e8fb + smi:local/auto + S + undecidable + + + + + smi:local/f0398aa9-6a7a-4365-b697-0ac963379d2f + smi:local/auto + P + undecidable + + + + + smi:local/ff56456b-50f8-4809-984f-b04c8e7c72b4 + smi:local/auto + S + undecidable + + + + + smi:local/d29dd12d-dda3-467b-9dda-402cf62e9fe0 + smi:local/auto + P + undecidable + + + + + smi:local/c2318d29-0f96-4b21-b6e1-37eb7027beaa + smi:local/auto + S + undecidable + + + + + smi:local/2b1d3f85-9657-45d0-a47f-29a24cfc0a71 + smi:local/auto + P + undecidable + + + + + smi:local/2e7d832c-34b6-45c0-842c-fedce1887a90 + smi:local/auto + S + undecidable + + + + + smi:local/908216c5-222b-4451-8bd7-7ec80b493e43 + smi:local/auto + P + undecidable + + + + + smi:local/4966a615-4675-4484-9123-c98b42df432e + smi:local/auto + S + undecidable + + + + + smi:local/db533602-e1f5-47b1-bc40-21954dfdb9d1 + smi:local/auto + P + undecidable + + + + + smi:local/68b97628-d33b-4071-8447-638769497c50 + smi:local/auto + S + undecidable + + + + + smi:local/4fce945d-441a-4c8e-880a-9548d34846a8 + smi:local/auto + P + undecidable + + + + + smi:local/46020580-3a14-4966-bc94-f5ffa4c359ff + smi:local/auto + S + undecidable + + + + + smi:local/8b3d0738-1ae9-47e6-8f21-209886f3847f + smi:local/auto + P + undecidable + + + + + smi:local/a18cd82a-26ca-4a68-830d-a275019f2e9e + smi:local/auto + S + undecidable + + + + + smi:local/18513c9e-c631-4d5d-8255-7b3b92396c2b + smi:local/auto + P + undecidable + + + + + smi:local/330d1085-66f0-41ce-a3fd-370225a420d3 + smi:local/auto + S + undecidable + + + + + smi:local/48169b59-2ff2-4aba-8f23-f3e6d30251cd + smi:local/auto + P + undecidable + + + + + smi:local/2219c31e-4139-49f3-acca-3a0d4260e946 + smi:local/auto + S + undecidable + + + + + smi:local/2f0291d4-a30e-4268-bd07-468a704a0515 + smi:local/auto + P + undecidable + + + + + smi:local/47b6c60a-1f4b-420a-80de-85258b637218 + smi:local/auto + S + undecidable + + + + + smi:local/18b2a108-a40f-4114-8e77-d1f22174ae40 + smi:local/auto + P + undecidable + + + + + smi:local/241f2561-ba03-4959-babf-ae969c25ead4 + smi:local/auto + S + undecidable + + + + + smi:local/0faa31e5-6b83-4743-840b-a5ffc4c14aba + smi:local/auto + P + undecidable + + + + + smi:local/bed25bda-f2dd-46d1-bf93-ace548b33986 + smi:local/auto + S + undecidable + + + + + smi:local/cdad97d8-0c50-4cfa-9bef-2cafbc7eeafc + smi:local/auto + P + undecidable + + + + + smi:local/090ed278-d48f-48e8-abaf-f7d1c1cafaf0 + smi:local/auto + S + undecidable + + + + + smi:local/6877b542-7f3c-4138-93a9-7e2b2b16d6f8 + smi:local/auto + P + undecidable + + + + + smi:local/3a694539-d1c2-4960-932c-228cc4ca3998 + smi:local/auto + S + undecidable + + + + + smi:local/54007864-194a-4fdf-a214-8bd61b3da5df + smi:local/auto + P + undecidable + + + + + smi:local/f6b15a30-1050-4e94-8d27-dc157ac368c9 + smi:local/auto + S + undecidable + + + + + smi:local/ca7e9a6f-1a2b-4673-bced-7ff3f96c6eb9 + smi:local/auto + P + undecidable + + + + + smi:local/43da577b-7020-423f-b199-6669b1dc3f25 + smi:local/auto + S + undecidable + + + + + smi:local/6e46df17-941e-41a9-99cd-d93890052001 + smi:local/auto + P + undecidable + + + + + smi:local/52683152-282f-4ec5-93a9-d55a82a83f84 + smi:local/auto + S + undecidable + + + + + smi:local/7b392325-0a7e-4884-9bff-46b011ca613b + smi:local/auto + P + undecidable + + + + + smi:local/9d3739fd-02bc-4e61-ad4f-85cb99840b03 + smi:local/auto + S + undecidable + + + + + smi:local/30cca15f-86d0-4621-905b-c17a7dbdaaa2 + smi:local/auto + P + undecidable + + + + + smi:local/07c8ce5e-8339-4aeb-8db4-df2d9a96b30b + smi:local/auto + S + undecidable + + + + + smi:local/2ba95380-6b42-4b98-95fa-2b975d9f4872 + smi:local/auto + P + undecidable + + + + + smi:local/07713984-f18b-40bd-8811-5e2980307c62 + smi:local/auto + S + undecidable + + + + + smi:local/20d86c44-db89-4d75-b08f-e6be73f4cc1f + smi:local/auto + P + undecidable + + + + + smi:local/34c32069-e6d0-42c8-bafc-da5376285274 + smi:local/auto + S + undecidable + + + + + smi:local/2fb610fb-73a1-46a0-b21b-d81f26da3678 + smi:local/auto + P + undecidable + + + + + smi:local/45c87728-abdd-4b15-845f-faf63b479f3f + smi:local/auto + S + undecidable + + + + + smi:local/2f1758e7-4042-4daa-935e-6a96febacbc7 + smi:local/auto + P + undecidable + + + + + smi:local/3521ff70-7f67-4541-9111-672e636dba7f + smi:local/auto + S + undecidable + + + + + smi:local/d34a91ad-955a-40b9-88df-3339381617ae + smi:local/auto + P + undecidable + + + + + smi:local/0a6394ea-6f3d-418a-bf6b-407d2971a7d3 + smi:local/auto + S + undecidable + + + + + smi:local/c212402f-b8b4-42b8-a44a-0adc99032397 + smi:local/auto + P + undecidable + + + + + smi:local/6146d7e0-5fca-4a54-a561-9b168de7cd57 + smi:local/auto + S + undecidable + + + + + smi:local/f48d4f81-5609-427e-8d63-45bfe22f211f + smi:local/auto + P + undecidable + + + + + smi:local/d37393fb-58e6-40c8-a5d5-72b27c0f97d2 + smi:local/auto + S + undecidable + + + + + smi:local/fe32a805-0ccd-4ead-823a-dfd6b84fb4ff + smi:local/auto + P + undecidable + + + + + smi:local/c954e052-adfa-42b0-81dc-a026e3a05ee0 + smi:local/auto + S + undecidable + + + + + smi:local/099c3353-123c-450b-900e-c0e28353719d + smi:local/auto + P + undecidable + + + + + smi:local/9dfa168c-3940-4065-8ab4-e7e5e91d2f57 + smi:local/auto + S + undecidable + + + + + smi:local/1241d520-9225-472b-ac9e-bce760c0bc11 + smi:local/auto + P + undecidable + + + + + smi:local/948b8ba0-f386-403c-bd4b-3d2a37fb9de2 + smi:local/auto + S + undecidable + + + + + smi:local/3de1fcfb-f12b-4a64-b137-ff39436d3883 + smi:local/auto + P + undecidable + + + + + smi:local/4c45befa-f5ae-42fb-8079-5abe47348524 + smi:local/auto + S + undecidable + + + + + smi:local/747c37b6-c6ab-4e32-b3d3-e3b2ce7aac04 + smi:local/auto + P + undecidable + + + + + smi:local/d5adea25-8816-4cbf-b5ad-129da65c7a58 + smi:local/auto + S + undecidable + + + + + smi:local/d94a5951-d43f-45ab-8373-7b6410166db8 + smi:local/auto + P + undecidable + + + + + smi:local/66ece93e-a3a4-4723-a063-3d1ab8985c6f + smi:local/auto + S + undecidable + + + + + smi:local/1720ddb3-978c-4bf2-8a6f-e6e21be68ef1 + smi:local/auto + P + undecidable + + + + + smi:local/aa562dd3-4707-4ffd-8afe-3b3ec2a26b6e + smi:local/auto + S + undecidable + + + + + smi:local/189eb361-8a22-45ad-be18-40af4de85c0e + smi:local/auto + P + undecidable + + + + + + + smi:local/58d76f09-712e-4985-b497-be396f2c7878 + smi:local/auto + P + undecidable + + + + + smi:local/8ca82c0d-11d7-4bc8-b73f-eb49cee2a8b7 + smi:local/auto + S + undecidable + + + + + smi:local/d9ec9684-018d-45e0-a69c-35fdbc5f4e55 + smi:local/auto + P + undecidable + + + + + smi:local/fd42238f-0ae5-437f-9f9c-a865f7ccc5cd + smi:local/auto + S + undecidable + + + + + smi:local/6434992d-785b-49c0-ae96-3caf3b0a52e7 + smi:local/auto + P + undecidable + + + + + smi:local/1c564eff-f6c9-489b-9164-4481c5200c38 + smi:local/auto + S + undecidable + + + + + smi:local/f600157b-ec69-4acb-979e-c66644939dee + smi:local/auto + P + undecidable + + + + + smi:local/86930492-7eb6-4c7b-9713-c22e36790d7e + smi:local/auto + S + undecidable + + + + + smi:local/52781245-6d00-42a4-b0d4-26706060ea1a + smi:local/auto + P + undecidable + + + + + smi:local/02c85679-af5c-49a0-bb43-56cbd36975d2 + smi:local/auto + S + undecidable + + + + + smi:local/871cf10a-75cc-499e-af47-28fc07282a09 + smi:local/auto + P + undecidable + + + + + smi:local/292958ec-c0d5-45bc-9478-35a3bc6114c2 + smi:local/auto + S + undecidable + + + + + smi:local/abd3652d-23be-4497-af40-b42d3f948631 + smi:local/auto + P + undecidable + + + + + smi:local/40eb089f-dd31-4375-93a7-b38ad5426dbb + smi:local/auto + S + undecidable + + + + + smi:local/c4418535-b851-464c-b7fc-8908377be5cf + smi:local/auto + P + undecidable + + + + + smi:local/d82dfb57-0a61-4479-9de6-912cc5044c4a + smi:local/auto + S + undecidable + + + + + smi:local/aa673b3e-3364-4136-aa4a-441f14c11d7a + smi:local/auto + P + undecidable + + + + + smi:local/6c62d3af-30cd-413f-991e-5e9ba49f370f + smi:local/auto + S + undecidable + + + + + smi:local/006e53f3-10e6-4327-8cea-12fdb62675eb + smi:local/auto + P + undecidable + + + + + smi:local/286370ee-dbd4-4432-b4c4-025d2633b33d + smi:local/auto + S + undecidable + + + + + smi:local/545db2a6-7a10-42ff-b76f-69ee9704c823 + smi:local/auto + P + undecidable + + + + + smi:local/2dd97384-0612-49aa-ba45-f30e6b3019bb + smi:local/auto + S + undecidable + + + + + smi:local/05dbe610-9023-4174-8abb-8a24ce3eb236 + smi:local/auto + P + undecidable + + + + + smi:local/ffff6dda-bf2e-432c-bc01-f662950fbbd0 + smi:local/auto + S + undecidable + + + + + smi:local/1642e45e-1415-4ed2-b8a0-4e60aec2549b + smi:local/auto + P + undecidable + + + + + smi:local/dc39c4b6-df6c-4187-9987-e0df3c74bcda + smi:local/auto + S + undecidable + + + + + smi:local/40eb1637-cfaa-412d-9e09-5d6a46135ad8 + smi:local/auto + P + undecidable + + + + + smi:local/15f4cdc6-711b-4d2b-9c2a-b68d179342ae + smi:local/auto + S + undecidable + + + + + smi:local/747c2dc8-9175-469e-9566-23f10c0cce1b + smi:local/auto + P + undecidable + + + + + smi:local/7931865a-f3f9-4a1e-a2a4-f07615509059 + smi:local/auto + S + undecidable + + + + + smi:local/a822cecc-d6d0-42a5-827b-301f6168d32f + smi:local/auto + P + undecidable + + + + + smi:local/57cc0cfc-0c48-4e7f-b232-76d42df7f917 + smi:local/auto + S + undecidable + + + + + smi:local/c9e071c1-23b8-4258-af4a-16573cebb7b9 + smi:local/auto + P + undecidable + + + + + smi:local/cde7bc8c-5ac8-4eb6-b9c7-208d3910be4f + smi:local/auto + S + undecidable + + + + + smi:local/a9025ff7-6eb1-4b9f-bb8d-30bf6c00d551 + smi:local/auto + P + undecidable + + + + + smi:local/fbf1bb74-8547-4d97-b9d0-203dec4133c0 + smi:local/auto + S + undecidable + + + + + smi:local/e5a6b251-c935-41fc-aba0-6bb970424f54 + smi:local/auto + P + undecidable + + + + + smi:local/39b71c4c-457c-4e0b-bceb-505cd94b48fd + smi:local/auto + S + undecidable + + + + + smi:local/46a2c559-c385-4eba-993d-bc62fc9fe167 + smi:local/auto + P + undecidable + + + + + smi:local/6e0ecd4e-02fa-4e75-a6d3-bd6adc05d9d2 + smi:local/auto + S + undecidable + + + + + smi:local/658826a1-0bad-4b51-b037-78fcfa52d680 + smi:local/auto + P + undecidable + + + + + smi:local/dc786251-d09c-4ca5-b01b-b447d08faa29 + smi:local/auto + S + undecidable + + + + + smi:local/e394a19c-8e4d-43fe-9ba7-d86e9474ad81 + smi:local/auto + P + undecidable + + + + + smi:local/4986db95-387d-43b3-ab17-12ac4a123dd7 + smi:local/auto + S + undecidable + + + + + smi:local/e3b6813b-474c-4f99-82ac-7aad8f9f74ad + smi:local/auto + P + undecidable + + + + + smi:local/92a933be-a040-400d-bd12-e052d8930da4 + smi:local/auto + S + undecidable + + + + + smi:local/038fea1f-c441-4748-b757-f98eee5c87a7 + smi:local/auto + P + undecidable + + + + + smi:local/02c992be-32a1-44b3-a7c8-85922f930eef + smi:local/auto + S + undecidable + + + + + smi:local/c8c8ff48-1e3b-4484-b1f2-46e700173acc + smi:local/auto + P + undecidable + + + + + smi:local/5a3ef476-98c1-460e-b0dc-08f358aa7f93 + smi:local/auto + S + undecidable + + + + + smi:local/293552f6-ef7b-4b63-ab9e-999f7f847993 + smi:local/auto + P + undecidable + + + + + smi:local/6d943808-5dd2-41b6-bc33-6b16ff61a879 + smi:local/auto + S + undecidable + + + + + smi:local/e779e6b7-ffb0-4557-93c0-2ca99ec23557 + smi:local/auto + P + undecidable + + + + + smi:local/cf8909d3-3c9f-4995-8aab-234208512112 + smi:local/auto + S + undecidable + + + + + smi:local/9c8a795e-5806-4530-91f0-8d46c9369d0a + smi:local/auto + P + undecidable + + + + + smi:local/7dbd4234-a22d-4ef1-a1da-b9d51deb65c0 + smi:local/auto + S + undecidable + + + + + smi:local/0f57e718-9bce-4424-be29-b3b987672816 + smi:local/auto + P + undecidable + + + + + smi:local/be4304fd-aa53-4345-aa0a-4d560629329e + smi:local/auto + S + undecidable + + + + + smi:local/eb44728c-c435-4c6a-8df4-1c8c26fa7d2b + smi:local/auto + P + undecidable + + + + + smi:local/cd313c8c-e9d3-4d0b-bc39-ac8c111fa228 + smi:local/auto + S + undecidable + + + + + smi:local/cfdb607b-2b8a-4dba-bfce-f1bfe80698e9 + smi:local/auto + P + undecidable + + + + + smi:local/ae47e829-a69c-4650-8327-1e1ab9bd83c0 + smi:local/auto + S + undecidable + + + + + smi:local/faa430e7-43bf-4126-995e-f6e3bc4ece83 + smi:local/auto + P + undecidable + + + + + smi:local/ede16a29-de43-479e-b23b-e7211eed106a + smi:local/auto + S + undecidable + + + + + smi:local/ac574b3f-33f6-413a-84e1-ceb75889f0b9 + smi:local/auto + P + undecidable + + + + + smi:local/e570ee09-ab3e-4751-a538-817d53a243d8 + smi:local/auto + S + undecidable + + + + + smi:local/a50760d0-05ae-4f26-90fa-772f7908ff96 + smi:local/auto + P + undecidable + + + + + smi:local/aaa07f84-5357-44e8-8c99-025d18f73a0b + smi:local/auto + S + undecidable + + + + + smi:local/48bc78cc-2a46-4d9e-b283-aa5742bc836f + smi:local/auto + P + undecidable + + + + + smi:local/6a5d10df-ac6d-4816-8b93-672fb71dcea2 + smi:local/auto + S + undecidable + + + + + smi:local/ecb89863-6627-432d-986f-b485d4357fac + smi:local/auto + P + undecidable + + + + + smi:local/63126000-2beb-4b24-83e4-c26638c143f5 + smi:local/auto + S + undecidable + + + + + smi:local/1bcf53ae-a4b1-4b91-a648-41deb99d92ba + smi:local/auto + P + undecidable + + + + + smi:local/587788c6-0aae-48ec-9c9c-821f57310f1d + smi:local/auto + S + undecidable + + + + + smi:local/8425679b-4289-4dc8-84b3-6aa68c469773 + smi:local/auto + P + undecidable + + + + + smi:local/ed9d7fd4-7c87-4be6-803a-46ba11b82f98 + smi:local/auto + S + undecidable + + + + + smi:local/df8a205e-09ef-4710-885b-0e59832b88cd + smi:local/auto + P + undecidable + + + + + smi:local/6844e05a-c9d7-4893-9f19-4d364522643d + smi:local/auto + S + undecidable + + + + + smi:local/b265c937-4cdc-4be9-b158-4d940656832e + smi:local/auto + P + undecidable + + + + + smi:local/5a615743-e37a-4385-840f-f76176c7ab8e + smi:local/auto + S + undecidable + + + + + smi:local/b0264494-535a-4157-b2b0-4ce7c3ac565d + smi:local/auto + P + undecidable + + + + + smi:local/4991d886-6bbb-4e18-bf7f-76be896b6b8f + smi:local/auto + S + undecidable + + + + + smi:local/cacb1d59-a408-4384-aba8-457166369eac + smi:local/auto + P + undecidable + + + + + smi:local/3ea5dbf8-5596-4016-b4a5-5e1aee351c83 + smi:local/auto + S + undecidable + + + + + smi:local/f82a898e-2e13-4d5e-a34e-1905bc2fe24b + smi:local/auto + P + undecidable + + + + + smi:local/bc7fc9bb-bd0b-485e-97f4-7bdcc8a80eee + smi:local/auto + S + undecidable + + + + + smi:local/2bfbaf67-af83-49e4-80ba-63f271cf262e + smi:local/auto + P + undecidable + + + + + smi:local/534fb1e0-ac64-4035-99f3-9bc23ad6a000 + smi:local/auto + S + undecidable + + + + + smi:local/c354d96c-1390-4dde-9780-6a5292aaf6ef + smi:local/auto + P + undecidable + + + + + smi:local/79a356fe-94e9-47b5-b3f1-d243713e235b + smi:local/auto + S + undecidable + + + + + smi:local/cf398e70-acde-4729-8978-77d0de8de088 + smi:local/auto + P + undecidable + + + + + smi:local/a3cf3c8e-98ff-44d4-abf8-4a80feb75776 + smi:local/auto + S + undecidable + + + + + smi:local/75cadc48-dd27-45ca-8ce3-d861bffc2385 + smi:local/auto + P + undecidable + + + + + smi:local/1bf13f85-886e-490e-a702-71f36ff852c9 + smi:local/auto + S + undecidable + + + + + smi:local/b97d82d1-8148-4fad-a259-dbe86c42e66c + smi:local/auto + P + undecidable + + + + + smi:local/0e07ea7c-74e5-478c-9f07-ddf497e8ed83 + smi:local/auto + S + undecidable + + + + + smi:local/8b9bef06-8dce-414d-997b-759960812071 + smi:local/auto + P + undecidable + + + + + smi:local/74e772e3-4ada-4cdd-a4e6-3c71aee87093 + smi:local/auto + S + undecidable + + + + + smi:local/e936a5a3-2a88-4eb3-b212-26a7c3c57a25 + smi:local/auto + P + undecidable + + + + + smi:local/66da82ae-592d-4538-bef7-ff8b66ed8a76 + smi:local/auto + S + undecidable + + + + + smi:local/5a704e16-ca10-489d-b87c-9c623c2a5e24 + smi:local/auto + P + undecidable + + + + + smi:local/498789c6-33ae-432b-a89f-532ed6445bd7 + smi:local/auto + S + undecidable + + + + + smi:local/40a64d9a-2f51-4def-8e8a-8313fb08c569 + smi:local/auto + P + undecidable + + + + + smi:local/e857c5ee-1c98-4756-bddf-0dfe4caa15ce + smi:local/auto + S + undecidable + + + + + smi:local/56b84df4-619c-4d43-a242-cc51ba74748d + smi:local/auto + P + undecidable + + + + + smi:local/4bd3578f-bf11-4bcc-9e7e-d9d0fc81f8cf + smi:local/auto + S + undecidable + + + + + smi:local/1ab28bfe-d15c-4391-a538-999e4a5096f5 + smi:local/auto + P + undecidable + + + + + smi:local/54210907-4c5c-408c-9643-12a7e9db9eaf + smi:local/auto + S + undecidable + + + + + smi:local/27e93220-2cb5-47cd-a124-bdcef38a3261 + smi:local/auto + P + undecidable + + + + + smi:local/5b1e405a-a38c-4126-bf3d-0a4f71936a10 + smi:local/auto + S + undecidable + + + + + smi:local/a5414965-4c25-4d58-8f60-edc98639ecf5 + smi:local/auto + P + undecidable + + + + + smi:local/ec1589a1-a563-4fa9-a0b1-67a9bbfb94c3 + smi:local/auto + S + undecidable + + + + + smi:local/80a5a7bb-d65f-4f38-a6f4-bc7e21b841a4 + smi:local/auto + P + undecidable + + + + + smi:local/02fffba5-854d-4003-8d3b-8668efb33bf8 + smi:local/auto + S + undecidable + + + + + smi:local/fee98417-12c1-42c9-bbce-191184f5c4f7 + smi:local/auto + P + undecidable + + + + + smi:local/57c96d80-0d7f-4a01-8902-294583607703 + smi:local/auto + S + undecidable + + + + + smi:local/788d4828-15a0-47b6-a19f-47f612b041ee + smi:local/auto + P + undecidable + + + + + smi:local/5340ecb6-15f2-4e51-ae7c-a95f99c2054d + smi:local/auto + S + undecidable + + + + + smi:local/3f635cb2-7d41-40bf-816d-cd4f8e549149 + smi:local/auto + P + undecidable + + + + + smi:local/eec1883b-0240-49b5-be3c-0702fc4ce2d6 + smi:local/auto + S + undecidable + + + + + smi:local/f96af245-52d1-4c51-b9e4-cdc277a734ab + smi:local/auto + P + undecidable + + + + + smi:local/0281f496-f836-414e-819f-bde824bd87ce + smi:local/auto + S + undecidable + + + + + smi:local/7fa4d4dc-c6cd-4b50-8629-d49747e15086 + smi:local/auto + P + undecidable + + + + + smi:local/e7ba3108-8169-4029-8101-a2decfc9d9c0 + smi:local/auto + S + undecidable + + + + + smi:local/25e84551-38f1-458e-84fc-a394a2b75cc3 + smi:local/auto + P + undecidable + + + + + smi:local/9afb4d68-5d14-46dc-81d4-22b7096e3bb8 + smi:local/auto + S + undecidable + + + + + smi:local/93e35ff0-ee74-4232-8960-b19244bc772f + smi:local/auto + P + undecidable + + + + + smi:local/87ec9cc0-dd66-4aa8-a932-fff5e5b73b88 + smi:local/auto + S + undecidable + + + + + smi:local/ddada3ad-1528-4882-9182-85731ad6b50c + smi:local/auto + P + undecidable + + + + + smi:local/d80b6e0c-a955-4186-8819-4ec8532d43db + smi:local/auto + S + undecidable + + + + + smi:local/b2be7636-fcbd-4dae-a292-9c84db27ea03 + smi:local/auto + P + undecidable + + + + + smi:local/26aecc10-ccd9-44ab-abf6-c47ca682599a + smi:local/auto + S + undecidable + + + + + smi:local/da988dbe-ab22-4c02-b6c4-d83e907a153d + smi:local/auto + P + undecidable + + + + + smi:local/74869eaa-963b-442c-b0dc-80cac5c86315 + smi:local/auto + S + undecidable + + + + + smi:local/ad6b89c0-cfa8-4a54-aa1d-e9a1ff9ae7a8 + smi:local/auto + P + undecidable + + + + + smi:local/efd6a168-9bd7-4eb6-9017-7fcc0548a454 + smi:local/auto + S + undecidable + + + + + smi:local/53489032-340a-4ac2-836d-755dfaee3448 + smi:local/auto + P + undecidable + + + + + smi:local/4717a9fa-99c8-4abe-b429-bd8be8f70658 + smi:local/auto + S + undecidable + + + + + smi:local/38b44825-fba2-4c50-ad66-317272e1b2da + smi:local/auto + P + undecidable + + + + + smi:local/4ed22fe9-18cb-4d0c-8d76-28d6b2e4e9ff + smi:local/auto + S + undecidable + + + + + smi:local/e3b8379e-2209-4484-90c1-a0203a13400c + smi:local/auto + P + undecidable + + + + + smi:local/c1850a60-d134-41fa-8ebb-68c306ef4c8a + smi:local/auto + S + undecidable + + + + + smi:local/49608853-428b-4865-8277-82fface2a04c + smi:local/auto + P + undecidable + + + + + smi:local/c876f0ff-a3f1-4ed4-8356-afe3a6c04b43 + smi:local/auto + S + undecidable + + + + + smi:local/2ecd08ac-10da-469b-bcf4-3b50c4fc0b97 + smi:local/auto + P + undecidable + + + + + smi:local/ee374621-1bf6-464e-9085-3c36c5df6380 + smi:local/auto + S + undecidable + + + + + smi:local/a3ff3917-3017-4f94-b5d2-1471c3debd77 + smi:local/auto + P + undecidable + + + + + smi:local/6b233b15-bf88-4a09-b5fb-ef4e0d06cbcc + smi:local/auto + S + undecidable + + + + + smi:local/ce4cd6a3-152d-4342-b57c-a22968d57d08 + smi:local/auto + P + undecidable + + + + + smi:local/a042b617-5fdf-4409-ad36-36e7c9068ef2 + smi:local/auto + S + undecidable + + + + + smi:local/258662c3-94da-417b-b103-d59d1201dba2 + smi:local/auto + P + undecidable + + + + + smi:local/c6059248-9f7e-467b-9f2f-83648025086c + smi:local/auto + S + undecidable + + + + + smi:local/bebff8f8-4b3a-4821-a97d-8fdaa50ec164 + smi:local/auto + P + undecidable + + + + + smi:local/0d65ab22-fa49-4929-bf1e-174589a1e443 + smi:local/auto + S + undecidable + + + + + smi:local/5e3fdd00-5791-4b8d-a2e4-f8d8ff424c3b + smi:local/auto + P + undecidable + + + + + smi:local/b39967bc-7abf-4c4e-b94f-ae3b5524fbe2 + smi:local/auto + S + undecidable + + + + + smi:local/3af7706a-ad65-4046-8c34-4d31e02d0760 + smi:local/auto + P + undecidable + + + + + smi:local/10d8dcad-9faa-4d6c-8a4e-9271b85ef5e6 + smi:local/auto + S + undecidable + + + + + smi:local/cdff14e8-cdec-4735-b803-74046f691f51 + smi:local/auto + P + undecidable + + + + + smi:local/1e537621-9af8-4f42-b17f-24b925e84097 + smi:local/auto + S + undecidable + + + + + smi:local/2faf6620-4ed1-44b0-9454-7d9df96c4d1e + smi:local/auto + P + undecidable + + + + + smi:local/b0008a9a-fc73-4382-81e5-efbc8db1cabc + smi:local/auto + S + undecidable + + + + + smi:local/a54c2b23-2f4a-4d05-a8a6-c37f63295fa4 + smi:local/auto + P + undecidable + + + + + smi:local/387571b5-400e-414c-987e-4d424c162140 + smi:local/auto + S + undecidable + + + + + smi:local/a4dca316-0962-4708-b4df-eb26644c6a50 + smi:local/auto + P + undecidable + + + + + smi:local/7cf58394-931c-4d29-ba42-bff09d6e1511 + smi:local/auto + S + undecidable + + + + + smi:local/f6dfc5df-923b-43ac-8a9d-1c037065a6b6 + smi:local/auto + P + undecidable + + + + + smi:local/bdcfaa72-d346-47f0-a58b-fb0cf4389105 + smi:local/auto + S + undecidable + + + + + smi:local/5d417be3-3316-4ebd-8cfc-142208931fc2 + smi:local/auto + P + undecidable + + + + + smi:local/32d8d9f3-418a-4ff6-92c9-0156da950f45 + smi:local/auto + S + undecidable + + + + + smi:local/1120b69c-95c6-467d-aa79-2bfb6cbc3e0e + smi:local/auto + P + undecidable + + + + + smi:local/2054d0f7-91ff-4246-aed8-2832faff9ac9 + smi:local/auto + S + undecidable + + + + + smi:local/4ea755b0-0f3c-45da-adb2-99240df7e4f6 + smi:local/auto + P + undecidable + + + + + smi:local/0777e64b-613a-48ce-9945-4bf7228259fb + smi:local/auto + S + undecidable + + + + + smi:local/4988ec60-c9a8-4f34-9fb5-ba80205a3e6b + smi:local/auto + P + undecidable + + + + + smi:local/adb9e3cb-6c59-4701-a4d9-d8c073f9cd79 + smi:local/auto + S + undecidable + + + + + smi:local/360bacf0-abcf-4ccc-835f-376c8fbd542e + smi:local/auto + P + undecidable + + + + + smi:local/a2faf3ab-08c8-4e35-8854-733bafc1c021 + smi:local/auto + S + undecidable + + + + + smi:local/95644144-d648-4067-b7d2-99f4b77b8026 + smi:local/auto + P + undecidable + + + + + smi:local/e65e063c-666d-4f49-9002-ed80626061e5 + smi:local/auto + S + undecidable + + + + + smi:local/e15cd645-633c-4744-94c5-ac7ccb8a6af6 + smi:local/auto + P + undecidable + + + + + smi:local/6a694e71-8faa-4439-9014-e2e6badcb6f0 + smi:local/auto + S + undecidable + + + + + smi:local/dbc6b01b-836e-428a-9dbb-71b8e96c6ac9 + smi:local/auto + P + undecidable + + + + + smi:local/1effa514-5d32-4982-b9e2-cfb620bc11c8 + smi:local/auto + S + undecidable + + + + + smi:local/1a7a2e4d-b277-4989-afee-a94d900a09d3 + smi:local/auto + P + undecidable + + + + + smi:local/5a53b008-0277-46dd-beb5-9047bcd77467 + smi:local/auto + S + undecidable + + + + + smi:local/bd191d32-151d-4658-af4b-81966431d26f + smi:local/auto + P + undecidable + + + + + smi:local/d5d45e1e-b8a5-4d1b-a636-27e2b07abc75 + smi:local/auto + S + undecidable + + + + + smi:local/204f8f1f-a618-45ac-9a9f-d4bf32cc3155 + smi:local/auto + P + undecidable + + + + + smi:local/4f18fb05-1689-4e5d-99ab-d02a7cf13685 + smi:local/auto + S + undecidable + + + + + smi:local/742cae6c-f1c8-4e0c-b66a-a0308e878531 + smi:local/auto + P + undecidable + + + + + smi:local/92626dbd-e7b3-40b5-a2dd-f5d741f237a9 + smi:local/auto + S + undecidable + + + + + smi:local/cc3860bf-5ad5-4db7-b5a7-7ffad104cf65 + smi:local/auto + P + undecidable + + + + + smi:local/742436c6-18f6-440e-a7e1-203ff364d3dd + smi:local/auto + S + undecidable + + + + + smi:local/3de526e1-d34f-4e9d-a5e8-1a679f4eac96 + smi:local/auto + P + undecidable + + + + + smi:local/f098f6cd-f876-4408-a216-bd3deb8831b0 + smi:local/auto + S + undecidable + + + + + smi:local/d2c89cd7-4f99-40de-bbaf-f6fd3503c5b1 + smi:local/auto + P + undecidable + + + + + smi:local/e1f19b4f-9622-4e75-8fa6-b9ee3de9ce23 + smi:local/auto + S + undecidable + + + + + smi:local/1269d3aa-8715-440a-a3fb-b7c5490d8f3f + smi:local/auto + P + undecidable + + + + + smi:local/1f6cc07a-81b4-409f-b3e7-6515ed3d08d2 + smi:local/auto + S + undecidable + + + + + smi:local/949041a0-e029-49f5-a443-665aaddd43cb + smi:local/auto + P + undecidable + + + + + smi:local/971ee307-88f8-41ee-b475-457bf6cc5645 + smi:local/auto + S + undecidable + + + + + smi:local/89f4e795-1458-42d3-8879-83813520a6a6 + smi:local/auto + P + undecidable + + + + + smi:local/03cc3540-a32d-47bd-b9a6-509232d30ba4 + smi:local/auto + S + undecidable + + + + + smi:local/e3fe7d48-eaca-4859-a865-8bb1b2b559c9 + smi:local/auto + P + undecidable + + + + + smi:local/df05834a-72cb-4b06-bc38-87473de40c9f + smi:local/auto + S + undecidable + + + + + smi:local/d903964a-79b2-4c76-abe1-11ba513fcf5a + smi:local/auto + P + undecidable + + + + + smi:local/4255860d-41de-4a25-a17d-37583c630d8d + smi:local/auto + S + undecidable + + + + + smi:local/b7e62e1e-c869-4b88-9932-e8695dca09e6 + smi:local/auto + P + undecidable + + + + + smi:local/bbfe2ae7-645c-4398-b535-edffa1d2418b + smi:local/auto + S + undecidable + + + + + smi:local/f45620ab-4e63-4799-9a7f-80718bc6757d + smi:local/auto + P + undecidable + + + + + smi:local/35dfd5c9-4074-495c-a635-ac376e5cef3c + smi:local/auto + S + undecidable + + + + + smi:local/e4fe4d6b-022e-4bc8-8336-1a079fb98b75 + smi:local/auto + P + undecidable + + + + + smi:local/3cf77fdb-5f5c-421e-a05e-0dc1f6c54d40 + smi:local/auto + S + undecidable + + + + + smi:local/b27175be-fcc2-42e5-acb6-2bf4cfedf902 + smi:local/auto + P + undecidable + + + + + smi:local/33bbade9-32ca-4f4a-bb4e-52e56e7cddb5 + smi:local/auto + S + undecidable + + + + + smi:local/0da8a2c1-0416-48b3-9937-5f5ea467167d + smi:local/auto + P + undecidable + + + + + smi:local/5399bae0-06fd-4e1e-bd8b-c91e77b6ff38 + smi:local/auto + S + undecidable + + + + + smi:local/3ed34f10-8abd-4a1f-811c-88904b2c91fa + smi:local/auto + P + undecidable + + + + + smi:local/d25124ac-4c7b-4567-9e89-57001373eb88 + smi:local/auto + S + undecidable + + + + + smi:local/e1de07ac-5501-4292-a96a-6856a54b12ca + smi:local/auto + P + undecidable + + + + + smi:local/1c2dfe09-27a7-4276-b120-7d9600f755b2 + smi:local/auto + S + undecidable + + + + + smi:local/9aa80385-88e9-4f74-b14c-bfcde2d2e381 + smi:local/auto + P + undecidable + + + + + smi:local/b35a0e83-9ed8-4277-808b-5d163cdcf674 + smi:local/auto + S + undecidable + + + + + smi:local/ab06abc8-4062-4252-a5a9-121b28a23d0e + smi:local/auto + P + undecidable + + + + + smi:local/25bfeeda-cdd2-4047-9cbd-aef1474bf3a4 + smi:local/auto + S + undecidable + + + + + smi:local/d7a1ee52-6350-4ccf-8fb7-c4d7cb732af2 + smi:local/auto + P + undecidable + + + + + smi:local/df13214a-7262-45c5-a501-96b29788b7b3 + smi:local/auto + S + undecidable + + + + + smi:local/ab118e24-2944-4ab1-93c0-36e5ff7086aa + smi:local/auto + P + undecidable + + + + + smi:local/2855cc62-e7f0-41eb-b678-43d90c2072d5 + smi:local/auto + S + undecidable + + + + + smi:local/d3550c7c-0c4b-45b6-a790-b455711462fd + smi:local/auto + P + undecidable + + + + + smi:local/578612a4-cd97-4210-bdec-598c91985800 + smi:local/auto + S + undecidable + + + + + smi:local/915f1581-1054-4434-a440-6ac959cac572 + smi:local/auto + P + undecidable + + + + + smi:local/79f084fc-4d38-4c60-b5ea-d4a4ecf437a7 + smi:local/auto + S + undecidable + + + + + smi:local/037a4a8d-16fa-48c9-b508-dacfd765f2e7 + smi:local/auto + P + undecidable + + + + + smi:local/923aa884-9047-46f9-9c29-ab83082da2b3 + smi:local/auto + S + undecidable + + + + + smi:local/ae191d74-c494-479f-8e02-74acb69bc366 + smi:local/auto + P + undecidable + + + + + smi:local/e0a25cb7-f689-4fd8-aadf-a59021579fb9 + smi:local/auto + S + undecidable + + + + + smi:local/b98a5fef-0d98-4fee-93f9-b1539fb611f3 + smi:local/auto + P + undecidable + + + + + smi:local/27111fbe-4c29-4453-b6be-cb41d645ccac + smi:local/auto + S + undecidable + + + + + smi:local/53c1e991-384c-4cb0-a33e-8a7fdc692157 + smi:local/auto + P + undecidable + + + + + smi:local/a439f2d7-11d2-46d2-b9dc-b9694603fd4b + smi:local/auto + S + undecidable + + + + + smi:local/0c9c5824-6003-4746-b95a-5423abd73ddd + smi:local/auto + P + undecidable + + + + + smi:local/c132a728-43f9-4642-b594-cbd975c8318d + smi:local/auto + S + undecidable + + + + + smi:local/187c391c-9b09-4b44-8741-2ccae489fb57 + smi:local/auto + P + undecidable + + + + + smi:local/d5b53662-4d56-4a0b-8ded-dfff38fed872 + smi:local/auto + S + undecidable + + + + + smi:local/84910345-6374-48a2-9b2d-b39af89cf095 + smi:local/auto + P + undecidable + + + + + smi:local/5281a51d-7c41-4110-ac84-bc497fb64dba + smi:local/auto + S + undecidable + + + + + smi:local/1f5a82c4-95bb-4547-a881-306b5ff98ca0 + smi:local/auto + P + undecidable + + + + + smi:local/4b417fcb-8754-4cbc-aff5-903067b24717 + smi:local/auto + S + undecidable + + + + + smi:local/a893e394-45d3-42dd-8585-c4694878301d + smi:local/auto + P + undecidable + + + + + smi:local/fd077ff3-04f9-41e7-bd02-dccb9d6a3afa + smi:local/auto + S + undecidable + + + + + smi:local/dabf7ce0-b2a4-4467-a128-b78052da1a00 + smi:local/auto + P + undecidable + + + + + smi:local/f876031c-a51d-49c2-9a3f-eb936293beb7 + smi:local/auto + S + undecidable + + + + + smi:local/dbdfca2c-b16f-4c64-90c7-8d4879b61a5f + smi:local/auto + P + undecidable + + + + + smi:local/ce95c747-888e-414b-b626-b2a206531e1d + smi:local/auto + S + undecidable + + + + + smi:local/fd72da08-d178-4691-ae6b-fc65307b9435 + smi:local/auto + P + undecidable + + + + + smi:local/efc5aeba-84f8-4605-b4ad-4213419a72fb + smi:local/auto + S + undecidable + + + + + smi:local/c7c5d2aa-cd9e-4717-a8cd-d3b6155a8330 + smi:local/auto + P + undecidable + + + + + smi:local/9a98d115-d2ed-4deb-bbf7-2236748b34fb + smi:local/auto + S + undecidable + + + + + smi:local/3e81bb6c-a07a-41f1-a525-104fc732058e + smi:local/auto + P + undecidable + + + + + smi:local/62b306ff-0818-4ee8-8189-9460c8d29db4 + smi:local/auto + S + undecidable + + + + + smi:local/a256293b-4cac-414c-ae1b-3865582ef050 + smi:local/auto + P + undecidable + + + + + smi:local/802073cc-c433-4523-b91b-4a6c3eefb84b + smi:local/auto + S + undecidable + + + + + smi:local/b1419413-7dda-41bd-9b4c-ea9d503906b1 + smi:local/auto + P + undecidable + + + + + smi:local/735df0eb-cc46-40ea-aa76-9d018e327b8c + smi:local/auto + S + undecidable + + + + + smi:local/f4ed3e5c-eabc-49ac-a04c-59d34bd56218 + smi:local/auto + P + undecidable + + + + + smi:local/194e4a95-9a84-4b52-870b-e81bd226278a + smi:local/auto + S + undecidable + + + + + smi:local/998bd9cc-dde0-4a33-8b57-831ca61d600c + smi:local/auto + P + undecidable + + + + + smi:local/e37f7d86-a235-46e8-a181-7dcc39101894 + smi:local/auto + S + undecidable + + + + + smi:local/0dad84d6-717e-4861-9e2d-69125f414264 + smi:local/auto + P + undecidable + + + + + smi:local/f39af8cc-1423-4596-be38-fb32460e8c11 + smi:local/auto + S + undecidable + + + + diff --git a/tests/test_autopicker/pylot_alparray_mantle_corr_stack_0.03-0.5.in b/tests/test_autopicker/pylot_alparray_mantle_corr_stack_0.03-0.5.in new file mode 100644 index 00000000..89e6d906 --- /dev/null +++ b/tests/test_autopicker/pylot_alparray_mantle_corr_stack_0.03-0.5.in @@ -0,0 +1,99 @@ +%This is a parameter input file for PyLoT/autoPyLoT. +%All main and special settings regarding data handling +%and picking are to be set here! +%Parameters are optimized for %extent data sets! +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +#main settings# +dmt_database_test #datapath# %data path +20171010_063224.a #eventID# %event ID for single event processing (* for all events found in database) + #invdir# %full path to inventory or dataless-seed file +PILOT #datastructure# %choose data structure +True #apverbose# %choose 'True' or 'False' for terminal output +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +#NLLoc settings# +None #nllocbin# %path to NLLoc executable +None #nllocroot# %root of NLLoc-processing directory +None #phasefile# %name of autoPyLoT-output phase file for NLLoc +None #ctrfile# %name of autoPyLoT-output control file for NLLoc +ttime #ttpatter# %pattern of NLLoc ttimes from grid +AUTOLOC_nlloc #outpatter# %pattern of NLLoc-output file +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +#parameters for seismic moment estimation# +3530.0 #vp# %average P-wave velocity +2500.0 #rho# %average rock density [kg/m^3] +300.0 0.8 #Qp# %quality factor for P waves (Qp*f^a); list(Qp, a) +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +#settings local magnitude# +1.0 1.0 1.0 #WAscaling# %Scaling relation (log(Ao)+Alog(r)+Br+C) of Wood-Anderson amplitude Ao [nm] If zeros are set, original Richter magnitude is calculated! +1.0 1.0 #magscaling# %Scaling relation for derived local magnitude [a*Ml+b]. If zeros are set, no scaling of network magnitude is applied! +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +#filter settings# +0.03 0.03 #minfreq# %Lower filter frequency [P, S] +0.5 0.5 #maxfreq# %Upper filter frequency [P, S] +4 4 #filter_order# %filter order [P, S] +bandpass bandpass #filter_type# %filter type (bandpass, bandstop, lowpass, highpass) [P, S] +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +#common settings picker# +global #extent# %extent of array ("local", "regional" or "global") +-100.0 #pstart# %start time [s] for calculating CF for P-picking (if TauPy: seconds relative to estimated onset) +50.0 #pstop# %end time [s] for calculating CF for P-picking (if TauPy: seconds relative to estimated onset) +-50.0 #sstart# %start time [s] relative to P-onset for calculating CF for S-picking +50.0 #sstop# %end time [s] after P-onset for calculating CF for S-picking +True #use_taup# %use estimated traveltimes from TauPy for calculating windows for CF +ak135 #taup_model# %Define TauPy model for traveltime estimation. Possible values: 1066a, 1066b, ak135, ak135f, herrin, iasp91, jb, prem, pwdk, sp6 +P,Pdiff,S,SKS #taup_phases# %Specify possible phases for TauPy (comma separated). See Obspy TauPy documentation for possible values. +0.03 0.5 #bpz1# %lower/upper corner freq. of first band pass filter Z-comp. [Hz] +0.01 0.5 #bpz2# %lower/upper corner freq. of second band pass filter Z-comp. [Hz] +0.03 0.5 #bph1# %lower/upper corner freq. of first band pass filter H-comp. [Hz] +0.01 0.5 #bph2# %lower/upper corner freq. of second band pass filter z-comp. [Hz] +#special settings for calculating CF# +%!!Edit the following only if you know what you are doing!!% +#Z-component# +HOS #algoP# %choose algorithm for P-onset determination (HOS, ARZ, or AR3) +300.0 #tlta# %for HOS-/AR-AIC-picker, length of LTA window [s] +4 #hosorder# %for HOS-picker, order of Higher Order Statistics +2 #Parorder# %for AR-picker, order of AR process of Z-component +16.0 #tdet1z# %for AR-picker, length of AR determination window [s] for Z-component, 1st pick +10.0 #tpred1z# %for AR-picker, length of AR prediction window [s] for Z-component, 1st pick +12.0 #tdet2z# %for AR-picker, length of AR determination window [s] for Z-component, 2nd pick +6.0 #tpred2z# %for AR-picker, length of AR prediction window [s] for Z-component, 2nd pick +0.001 #addnoise# %add noise to seismogram for stable AR prediction +60.0 5.0 20.0 12.0 #tsnrz# %for HOS/AR, window lengths for SNR-and slope estimation [tnoise, tsafetey, tsignal, tslope] [s] +50.0 #pickwinP# %for initial AIC pick, length of P-pick window [s] +30.0 #Precalcwin# %for HOS/AR, window length [s] for recalculation of CF (relative to 1st pick) +2.0 #aictsmooth# %for HOS/AR, take average of samples for smoothing of AIC-function [s] +2.0 #tsmoothP# %for HOS/AR, take average of samples in this time window for smoothing CF [s] +0.006 #ausP# %for HOS/AR, artificial uplift of samples (aus) of CF (P) +2.0 #nfacP# %for HOS/AR, noise factor for noise level determination (P) +#H-components# +ARH #algoS# %choose algorithm for S-onset determination (ARH or AR3) +12.0 #tdet1h# %for HOS/AR, length of AR-determination window [s], H-components, 1st pick +6.0 #tpred1h# %for HOS/AR, length of AR-prediction window [s], H-components, 1st pick +8.0 #tdet2h# %for HOS/AR, length of AR-determinaton window [s], H-components, 2nd pick +4.0 #tpred2h# %for HOS/AR, length of AR-prediction window [s], H-components, 2nd pick +4 #Sarorder# %for AR-picker, order of AR process of H-components +100.0 #Srecalcwin# %for AR-picker, window length [s] for recalculation of CF (2nd pick) (H) +195.0 #pickwinS# %for initial AIC pick, length of S-pick window [s] +60.0 10.0 30.0 12.0 #tsnrh# %for ARH/AR3, window lengths for SNR-and slope estimation [tnoise, tsafetey, tsignal, tslope] [s] +22.0 #aictsmoothS# %for AIC-picker, take average of samples in this time window for smoothing of AIC-function [s] +20.0 #tsmoothS# %for AR-picker, take average of samples for smoothing CF [s] (S) +0.001 #ausS# %for HOS/AR, artificial uplift of samples (aus) of CF (S) +2.0 #nfacS# %for AR-picker, noise factor for noise level determination (S) +#first-motion picker# +1 #minfmweight# %minimum required P weight for first-motion determination +3.0 #minFMSNR# %miniumum required SNR for first-motion determination +10.0 #fmpickwin# %pick window [s] around P onset for calculating zero crossings +#quality assessment# +0.1 0.2 0.4 0.8 #timeerrorsP# %discrete time errors [s] corresponding to picking weights [0 1 2 3] for P +4.0 8.0 16.0 32.0 #timeerrorsS# %discrete time errors [s] corresponding to picking weights [0 1 2 3] for S +0.005 #minAICPslope# %below this slope [counts/s] the initial P pick is rejected +1.1 #minAICPSNR# %below this SNR the initial P pick is rejected +0.002 #minAICSslope# %below this slope [counts/s] the initial S pick is rejected +1.3 #minAICSSNR# %below this SNR the initial S pick is rejected +20.0 #minsiglength# %length of signal part for which amplitudes must exceed noiselevel [s] +1.0 #noisefactor# %noiselevel*noisefactor=threshold +10.0 #minpercent# %required percentage of amplitudes exceeding threshold +0.1 #zfac# %P-amplitude must exceed at least zfac times RMS-S amplitude +100.0 #mdttolerance# %maximum allowed deviation of P picks from median [s] +50.0 #wdttolerance# %maximum allowed deviation from Wadati-diagram +25.0 #jackfactor# %pick is removed if the variance of the subgroup with the pick removed is larger than the mean variance of all subgroups times safety factor diff --git a/tests/test_autopicker/test_autopylot.py b/tests/test_autopicker/test_autopylot.py new file mode 100644 index 00000000..744b9fd6 --- /dev/null +++ b/tests/test_autopicker/test_autopylot.py @@ -0,0 +1,67 @@ +import os +import pytest + +from obspy import read_events + +from autoPyLoT import autoPyLoT + + +class TestAutopickerGlobal(): + def init(self): + self.params_infile = 'pylot_alparray_mantle_corr_stack_0.03-0.5.in' + self.test_event_dir = 'dmt_database_test' + self.fname_outfile_xml = os.path.join( + self.test_event_dir, '20171010_063224.a', 'PyLoT_20171010_063224.a_autopylot.xml' + ) + + # check if the input files exist + if not os.path.isfile(self.params_infile): + print(f'Test input file {os.path.abspath(self.params_infile)} not found.') + return False + + if not os.path.exists(self.test_event_dir): + print( + f'Test event directory not found at location "{os.path.abspath(self.test_event_dir)}". ' + f'Make sure to load it from the website first.' + ) + return False + + return True + + def test_autopicker(self): + assert self.init(), 'Initialization failed due to missing input files.' + # check for output file in test directory and remove it if necessary + if os.path.isfile(self.fname_outfile_xml): + os.remove(self.fname_outfile_xml) + autoPyLoT(inputfile=self.params_infile, eventid='20171010_063224.a', obspyDMT_wfpath='processed') + + # test for different known output files if they are identical or not + compare_pickfiles(self.fname_outfile_xml, 'PyLoT_20171010_063224.a_autopylot.xml', True) + compare_pickfiles(self.fname_outfile_xml, 'PyLoT_20171010_063224.a_saved_from_GUI.xml', True) + compare_pickfiles(self.fname_outfile_xml, 'PyLoT_20171010_063224.a_corrected_taup_times_0.03-0.5_P.xml', False) + + +def compare_pickfiles(pickfile1: str, pickfile2: str, samefile: bool = True) -> None: + """ + Compare the pick times and errors from two pick files. + + Parameters: + pickfile1 (str): The path to the first pick file. + pickfile2 (str): The path to the second pick file. + samefile (bool): A flag indicating whether the two files are expected to be the same. Defaults to True. + + Returns: + None + """ + cat1 = read_events(pickfile1) + cat2 = read_events(pickfile2) + picks1 = sorted(cat1[0].picks, key=lambda pick: str(pick.waveform_id)) + picks2 = sorted(cat2[0].picks, key=lambda pick: str(pick.waveform_id)) + pick_times1 = [pick.time for pick in picks1] + pick_times2 = [pick.time for pick in picks2] + pick_terrs1 = [pick.time_errors for pick in picks1] + pick_terrs2 = [pick.time_errors for pick in picks2] + + # check if times and errors are identical or not depending on the samefile flag + assert (pick_times1 == pick_times2) is samefile, 'Pick times error' + assert (pick_terrs1 == pick_terrs2) is samefile, 'Pick time errors errors'