def test_floating_point_types_are_indempotent(self): """ Applying the constructor multiple times should not change the values. """ f = FloatWithUncertainties(1.0, lower_uncertainty=0.5, upper_uncertainty=1.5) assert f == 1.0 assert f.lower_uncertainty == 0.5 assert f.upper_uncertainty == 1.5 f = FloatWithUncertainties(f) assert f == 1.0 assert f.lower_uncertainty == 0.5 assert f.upper_uncertainty == 1.5 f = FloatWithUncertaintiesAndUnit(1.0, lower_uncertainty=0.5, upper_uncertainty=1.5, unit="AB") assert f == 1.0 assert f.lower_uncertainty == 0.5 assert f.upper_uncertainty == 1.5 assert f.unit == "AB" f = FloatWithUncertaintiesAndUnit(f) assert f == 1.0 assert f.lower_uncertainty == 0.5 assert f.upper_uncertainty == 1.5 assert f.unit == "AB"
def test_floating_point_types_are_indempotent(self): """ Applying the constructor multiple times should not change the values. """ f = FloatWithUncertainties(1.0, lower_uncertainty=0.5, upper_uncertainty=1.5) self.assertEqual(f, 1.0) self.assertEqual(f.lower_uncertainty, 0.5) self.assertEqual(f.upper_uncertainty, 1.5) f = FloatWithUncertainties(f) self.assertEqual(f, 1.0) self.assertEqual(f.lower_uncertainty, 0.5) self.assertEqual(f.upper_uncertainty, 1.5) f = FloatWithUncertaintiesAndUnit(1.0, lower_uncertainty=0.5, upper_uncertainty=1.5, unit="AB") self.assertEqual(f, 1.0) self.assertEqual(f.lower_uncertainty, 0.5) self.assertEqual(f.upper_uncertainty, 1.5) self.assertEqual(f.unit, "AB") f = FloatWithUncertaintiesAndUnit(f) self.assertEqual(f, 1.0) self.assertEqual(f.lower_uncertainty, 0.5) self.assertEqual(f.upper_uncertainty, 1.5) self.assertEqual(f.unit, "AB")
def extract_unique_sensors_responses(inv): resultSensors = defaultdict(list) resultResponses = defaultdict(list) for net in inv.networks: for sta in net.stations: for cha in sta.channels: assert cha.code != 0 try: if (cha.code not in resultResponses.keys()): if (cha.response and cha.response.get_paz()): good = True for rs in cha.response.response_stages: if rs.decimation_delay is None: rs.decimation_delay = FloatWithUncertaintiesAndUnit( 0) if rs.decimation_correction is None: rs.decimation_correction = FloatWithUncertaintiesAndUnit( 0) if ( good ): # CONFUSED: why don't we index dict by network and station code as well, since cha.code is not unique resultSensors[cha.code] = cha.sensor resultResponses[cha.code] = cha.response except: pass return resultSensors, resultResponses
def obtain_nominal_instrument_response(netcode, statcode, chcode, req): """ For given network, station and channel code, find suitable response(s) in IRIS database and return as dict of obspy instrument responses. :param netcode: Network code (may include wildcards) :type netcode: str :param statcode: Station code (may include wildcards) :type statcode: str :param chcode: Channel code (may include wildcards) :type chcode: str :param req: Request object to use for URI query :type req: Object conforming to interface of 'requests' library :return: Dictionary of instrument responses from IRIS for given network(s), station(s) and channel(s). :rtype: dict of {str, Instrument(obspy.core.inventory.util.Equipment, obspy.core.inventory.response.Response)} """ from obspy.core.util.obspy_types import FloatWithUncertaintiesAndUnit query_url = form_response_request_url(netcode, statcode, chcode) tries = 10 while tries > 0: try: tries -= 1 response_xml = req.get(query_url) first_line = sio.StringIO(response_xml.text).readline().rstrip() assert 'Error 404' not in first_line break except req.exceptions.RequestException as e: # pylint: disable=unused-variable time.sleep(1) assert tries > 0 set_text_encoding(response_xml, quiet=True) # This line decodes when .text attribute is extracted, then encodes to utf-8 obspy_input = bio.BytesIO(response_xml.text.encode('utf-8')) try: channel_data = read_inventory(obspy_input) responses = { cha.code: Instrument(cha.sensor, cha.response) for net in channel_data.networks for sta in net.stations for cha in sta.channels if cha.code is not None and cha.response is not None } # Make responses valid for Seiscomp3 for inst in responses.values(): assert inst.response for rs in inst.response.response_stages: if rs.decimation_delay is None: rs.decimation_delay = FloatWithUncertaintiesAndUnit(0) if rs.decimation_correction is None: rs.decimation_correction = FloatWithUncertaintiesAndUnit(0) except ValueError: responses = {} return responses
def water_level(self, value): if value is None: self._water_level = None elif isinstance(value, FloatWithUncertaintiesAndUnit): self._water_level = value else: self._water_level = FloatWithUncertaintiesAndUnit(value)
def genArrWithUncertainty(vals, errs): outArr = [ FloatWithUncertaintiesAndUnit(val, lower_uncertainty=err, upper_uncertainty=err) for val, err in zip(vals, errs) ] return outArr
def getStation(stationBlock, units, transFuncs): ## Should probably do a check up here to see that the order given in block is consistent ## for entry in stationBlock: if entry.name == 'Station Identifier': # print 'NewStation!',entry.station_call_letters staDict = { 'code': entry.station_call_letters, 'latitude': entry.latitude, 'longitude': entry.longitude, 'elevation': entry.elevation, 'channels': [], 'site': Site(entry.site_name), 'creation_date': UTCDateTime(entry.start_effective_date), # Allows for save 'start_date': UTCDateTime(entry.start_effective_date), 'end_date': UTCDateTime(entry.end_effective_date) } staNetCode = entry.network_code # If found a new channel, reset the stages elif entry.name == 'Channel Identifier': # print 'NewChannel!',entry.channel_identifier stages = [] chaDict = { 'code': entry.channel_identifier, 'location_code': entry.location_identifier, 'latitude': entry.latitude, 'longitude': entry.longitude, 'elevation': entry.elevation, 'depth': entry.local_depth, 'sample_rate': entry.sample_rate, 'start_date': UTCDateTime(entry.start_date), 'end_date': UTCDateTime(entry.end_date), 'azimuth': entry.azimuth, 'dip': entry.dip } #code, location_code, latitude, longitude, elevation, depth # If on a new stage, set up the dictionary again # ...paz stage elif entry.name == 'Response Poles and Zeros': # Get units stageReqs = {} # print entry.name,entry.stage_sequence_number # print entry # quit() stageReqs['input_units'] = units[entry.stage_signal_input_units] stageReqs['output_units'] = units[entry.stage_signal_output_units] # Collect the poles and zeros lastType = 'paz' if entry.number_of_complex_zeros == 0: zeros = np.array([], dtype=float) else: zeros = np.array(entry.real_zero, dtype=float) + np.array( entry.imaginary_zero, dtype=float) * 1j if entry.number_of_complex_poles == 0: poles = np.array([], dtype=float) else: poles = np.array(entry.real_pole, dtype=float) + np.array( entry.imaginary_pole, dtype=float) * 1j # Form the paz response dictionary (also ensure arrays are 1D) pazDict = { 'pz_transfer_function_type': transFuncs[entry.transfer_function_types], 'normalization_factor': entry.A0_normalization_factor, 'normalization_frequency': entry.normalization_frequency, 'zeros': setArrDim(zeros), 'poles': setArrDim(poles) } # ...coeff stage elif entry.name == 'Response Coefficients': # Get units stageReqs = {} # print entry.name,entry.stage_sequence_number stageReqs['input_units'] = units[entry.signal_input_units] stageReqs['output_units'] = units[entry.signal_output_units] # Collect the coefficients lastType = 'coef' if entry.number_of_denominators == 0: denom = np.array([], dtype=float) denomErr = np.array([], dtype=float) else: denom = np.array(entry.denominator_coefficient, dtype=float) denomErr = np.array(entry.denominator_error, dtype=float) if entry.number_of_numerators == 0: numer = np.array([], dtype=float) numerErr = np.array([], dtype=float) else: numer = np.array(entry.numerator_coefficient, dtype=float) numerErr = np.array(entry.numerator_error, dtype=float) # Convert these arrays into lists of numbers which have uncertainty (also ensure arrays are 1D) denomArr = genArrWithUncertainty(setArrDim(denom), setArrDim(denomErr)) numerArr = genArrWithUncertainty(setArrDim(numer), setArrDim(numerErr)) # Form the coeefficient response dictionary coefDict = { 'cf_transfer_function_type': transFuncs[entry.response_type], 'numerator': numerArr, 'denominator': denomArr } # Get the decimation sampling info elif entry.name == 'Decimation': # print entry.name,entry.stage_sequence_number stageReqs['decimation_input_sample_rate'] = Frequency( entry.input_sample_rate) stageReqs['decimation_factor'] = entry.decimation_factor stageReqs['decimation_offset'] = entry.decimation_offset stageReqs['decimation_delay'] = FloatWithUncertaintiesAndUnit( entry.estimated_delay) stageReqs['decimation_correction'] = FloatWithUncertaintiesAndUnit( entry.correction_applied) # Get the stage sensitivity elif entry.name == 'Channel Sensitivity Gain': # print entry.name,entry.stage_sequence_number if entry.stage_sequence_number != 0: stageReqs[ 'stage_sequence_number'] = entry.stage_sequence_number stageReqs['stage_gain'] = entry.sensitivity_gain stageReqs['stage_gain_frequency'] = entry.frequency # See what type of stage this was if lastType == 'paz': pazDict.update(stageReqs) stages.append(PolesZerosResponseStage(**pazDict)) else: coefDict.update(stageReqs) stages.append(CoefficientsTypeResponseStage(**coefDict)) # If on the last stage, send off the collected stage info else: if len(stages) > 0: instrSens = InstrumentSensitivity(entry.sensitivity_gain, entry.frequency, stages[0].input_units, stages[-1].output_units) # Finalize the channel dictionary, and append this channel to the station dictionary chaResp = Response(response_stages=stages, instrument_sensitivity=instrSens) chaDict['response'] = chaResp staDict['channels'].append(Channel(**chaDict)) # Return the stations to the list of stations (also track the network code) return Station(**staDict), staNetCode