def _is_match(elem): try: if elem.Name != name: return False except AttributeError: # Name is not set return False for key, value in match.items(): try: if get_param(elem, key).pcdata != value: return False except ValueError: # no Param with this Name return False return True
def parse_COMPLEX16FrequencySeries(elem): t, = elem.getElementsByTagName(ligolw.Time.tagName) a, = elem.getElementsByTagName(ligolw.Array.tagName) dims = a.getElementsByTagName(ligolw.Dim.tagName) f0 = ligolw_param.get_param(elem, u"f0") return COMPLEX16FrequencySeries( name = a.Name, # FIXME: remove type cast when epoch can be a swig LIGOTimeGPS epoch = LIGOTimeGPS(str(t.pcdata)), f0 = f0.pcdata * float(LALUnit(f0.Unit) / LALUnit("s^-1")), deltaF = dims[0].Scale * float(LALUnit(dims[0].Unit) / LALUnit("s^-1")), sampleUnits = LALUnit(a.Unit), data = a.array[1] + 1j * a.array[2] )
def parse_COMPLEX16FrequencySeries(elem): t, = elem.getElementsByTagName(ligolw.Time.tagName) a, = elem.getElementsByTagName(ligolw.Array.tagName) dims = a.getElementsByTagName(ligolw.Dim.tagName) f0 = ligolw_param.get_param(elem, u"f0") return COMPLEX16FrequencySeries( name = a.Name, # FIXME: make Time class smart so we don't have to parse # it by hand epoch = LIGOTimeGPS(t.pcdata), f0 = f0.pcdata * float(LALUnit(f0.Unit) / LALUnit("s^-1")), deltaF = dims[0].Scale * float(LALUnit(dims[0].Unit) / LALUnit("s^-1")), sampleUnits = LALUnit(a.Unit), data = a.array[1] + 1j * a.array[2] )
def _parse_series(elem, creatorfunc, delta_target_unit_string): t, = elem.getElementsByTagName(ligolw.Time.tagName) a, = elem.getElementsByTagName(ligolw.Array.tagName) dims = a.getElementsByTagName(ligolw.Dim.tagName) f0 = ligolw_param.get_param(elem, u"f0") epoch = lal.LIGOTimeGPS(str(t.pcdata)) # Target units: inverse seconds inverse_seconds_unit = lal.Unit() inverse_seconds_unit = lal.ParseUnitString(inverse_seconds_unit, "s^-1") delta_target_unit = lal.Unit() delta_target_unit = lal.ParseUnitString(delta_target_unit, delta_target_unit_string) # Parse units of f0 field f0_unit = lal.Unit() f0_unit = lal.ParseUnitString(f0_unit, str(f0.Unit)) # Parse units of deltaF field delta_unit = lal.Unit() delta_unit = lal.ParseUnitString(delta_unit, str(dims[0].Unit)) # Parse units of data sample_unit = lal.Unit() sample_unit = lal.ParseUnitString(sample_unit, str(a.Unit)) # Initialize data structure series = creatorfunc( str(a.Name), epoch, float(f0.pcdata) * lal.UnitRatio(f0_unit, inverse_seconds_unit), float(dims[0].Scale) * lal.UnitRatio(delta_unit, delta_target_unit), sample_unit, len(a.array.T) ) # Assign data if np.iscomplexobj(series.data.data): series.data.data = a.array[1] + 1j * a.array[2] else: series.data.data = a.array[1] # Done! return series
def _parse_series(elem, creatorfunc, delta_target_unit_string): t, = elem.getElementsByTagName(ligolw.Time.tagName) a, = elem.getElementsByTagName(ligolw.Array.tagName) dims = a.getElementsByTagName(ligolw.Dim.tagName) f0 = ligolw_param.get_param(elem, u"f0") if t.Type != u"GPS": raise ValueError("epoch Type must be GPS") epoch = t.pcdata # Target units: inverse seconds inverse_seconds_unit = lal.Unit("s^-1") delta_target_unit = lal.Unit(delta_target_unit_string) # Parse units of f0 field f0_unit = lal.Unit(str(f0.Unit)) # Parse units of deltaF field delta_unit = lal.Unit(str(dims[0].Unit)) # Parse units of data sample_unit = lal.Unit(str(a.Unit)) # Initialize data structure series = creatorfunc( str(a.Name), epoch, f0.pcdata * float(f0_unit / inverse_seconds_unit), dims[0].Scale * float(delta_unit / delta_target_unit), sample_unit, len(a.array.T) ) # Assign data if np.iscomplexobj(series.data.data): series.data.data = a.array[1] + 1j * a.array[2] else: series.data.data = a.array[1] # Done! return series
def parse_REAL8FrequencySeries(elem): t, = elem.getElementsByTagName(ligolw.Time.tagName) a, = elem.getElementsByTagName(ligolw.Array.tagName) dims = a.getElementsByTagName(ligolw.Dim.tagName) f0 = ligolw_param.get_param(elem, u"f0") epoch = lal.LIGOTimeGPS(str(t.pcdata)) # Target units: inverse seconds inverse_seconds_unit = lal.Unit() lal.ParseUnitString(inverse_seconds_unit, "s^-1") # Parse units of f0 field f0_unit = lal.Unit() lal.ParseUnitString(f0_unit, str(f0.get_unit())) # Parse units of deltaF field deltaF_unit = lal.Unit() lal.ParseUnitString(deltaF_unit, str(dims[0].getAttribute(u"Unit"))) # Parse units of data sample_unit = lal.Unit() lal.ParseUnitString(sample_unit, str(a.getAttribute(u"Unit"))) # Parse data data = a.array[1] # Initialize data structure series = lal.CreateREAL8FrequencySeries( str(a.getAttribute(u"Name")), epoch, float(f0.pcdata) * lal.UnitRatio(f0_unit, inverse_seconds_unit), float(dims[0].getAttribute(u"Scale")) * lal.UnitRatio(deltaF_unit, inverse_seconds_unit), sample_unit, len(data) ) # Copy data series.data.data = data # Done! return series
def parse_REAL8FrequencySeries(elem): t, = elem.getElementsByTagName(ligolw.Time.tagName) a, = elem.getElementsByTagName(ligolw.Array.tagName) dims = a.getElementsByTagName(ligolw.Dim.tagName) f0 = ligolw_param.get_param(elem, u"f0") epoch = lal.LIGOTimeGPS(str(t.pcdata)) # Target units: inverse seconds inverse_seconds_unit = lal.Unit() lal.ParseUnitString(inverse_seconds_unit, "s^-1") # Parse units of f0 field f0_unit = lal.Unit() lal.ParseUnitString(f0_unit, str(f0.get_unit())) # Parse units of deltaF field deltaF_unit = lal.Unit() lal.ParseUnitString(deltaF_unit, str(dims[0].getAttribute(u"Unit"))) # Parse units of data sample_unit = lal.Unit() lal.ParseUnitString(sample_unit, str(a.getAttribute(u"Unit"))) # Parse data data = a.array[1] # Initialize data structure series = lal.CreateREAL8FrequencySeries( str(a.getAttribute(u"Name")), epoch, float(f0.pcdata) * lal.UnitRatio(f0_unit, inverse_seconds_unit), float(dims[0].getAttribute(u"Scale")) * lal.UnitRatio(deltaF_unit, inverse_seconds_unit), sample_unit, len(data)) # Copy data series.data.data = data # Done! return series
def read_series(source, name, match=None): """Read a `Series` from LIGO_LW-XML Parameters ---------- source : `file`, `str`, :class:`~glue.ligolw.ligolw.Document` file path or open LIGO_LW-format XML file name : `str` name of the relevant `LIGO_LW` element to read match : `dict`, optional dict of (key, value) `Param` pairs to match correct LIGO_LW element, this is useful if a single file contains multiple `LIGO_LW` elements with the same name """ from glue.ligolw.ligolw import (LIGO_LW, Time, Array, Dim) from glue.ligolw.param import get_param # read document xmldoc = read_ligolw(source, contenthandler=series_contenthandler()) # parse match dict if match is None: match = dict() def _is_match(elem): try: if elem.Name != name: return False except AttributeError: # Name is not set return False for key, value in match.items(): try: if get_param(elem, key).pcdata != value: return False except ValueError: # no Param with this Name return False return True # parse out correct element matches = filter(_is_match, xmldoc.getElementsByTagName(LIGO_LW.tagName)) try: elem, = matches except ValueError as exc: if not matches: exc.args = ("no LIGO_LW elements found matching request",) else: exc.args = ('multiple LIGO_LW elements found matching request, ' 'please consider using `match=` to select the ' 'correct element',) raise # get data array, = elem.getElementsByTagName(Array.tagName) # parse dimensions dims = array.getElementsByTagName(Dim.tagName) xdim = dims[0] x0 = xdim.Start dx = xdim.Scale xunit = xdim.Unit try: ndim = dims[1].n except IndexError: pass else: if ndim > 2: raise ValueError("Cannot parse LIGO_LW Array with {} " "dimensions".format(ndim)) # parse metadata array_kw = { 'name': array.Name, 'unit': array.Unit, 'xunit': xunit, } try: array_kw['epoch'] = to_gps( elem.getElementsByTagName(Time.tagName)[0].pcdata) except IndexError: pass for key in ('channel',): try: array_kw[key] = get_param(elem, key) except ValueError: pass # build Series try: xindex, value = array.array except ValueError: # not two dimensions stored return Series(array.array[0], x0=x0, dx=dx, **array_kw) return Series(value, xindex=xindex, **array_kw)