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: 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_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 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)
