def equality_data_to_seglist(data, start, dt, equality, invert=False): """ Apply equality test threshold to data and parse the result into a segment list. """ # FIXME: numpy operations? if invert: return from_bitstream([d != equality for d in data], start, dt) else: return from_bitstream([d == equality for d in data], start, dt)
def equality_data_to_seglist(data, start, dt, equality, invert=False):
"""
Apply equality test threshold to data and parse the result into a segment list.
"""
# FIXME: numpy operations?
if invert:
return from_bitstream([d != equality for d in data], start, dt)
else:
return from_bitstream([d == equality for d in data], start, dt)
def threshold_data_to_seglist(data, start, dt, min_threshold=None, max_threshold=None, invert=False):
"""
Apply min and max threshold to data and parse the result into a segment list. If invert, then invert, tautologies not withstanding.
"""
if min_threshold is None:
min_threshold = -float("inf")
if max_threshold is None:
max_threshold = float("inf")
if invert:
return from_bitstream([min_threshold > d or d > max_threshold for d in data], start, dt)
else:
return from_bitstream([min_threshold < d and d < max_threshold for d in data], start, dt)
def mask_data_to_seglist(data, start, dt, mask_on=0x1, mask_off=0x0):
"""
Apply bitmask to data and parse the result into a segment list.
"""
# FIXME: numpy operations?
return from_bitstream([(d & mask_on) & (not (d & mask_off)) for d in data],
start, dt)
def threshold_data_to_seglist(data,
start,
dt,
min_threshold=None,
max_threshold=None,
invert=False):
"""
Apply min and max threshold to data and parse the result into a segment list. If invert, then invert, tautologies not withstanding.
"""
if min_threshold is None:
min_threshold = -float("inf")
if max_threshold is None:
max_threshold = float("inf")
if invert:
return from_bitstream(
[min_threshold > d or d > max_threshold for d in data], start, dt)
else:
return from_bitstream(
[min_threshold < d and d < max_threshold for d in data], start, dt)
def to_dqflag(self,
name=None,
minlen=1,
dtype=float,
round=False,
label=None,
description=None):
"""Convert this `StateTimeSeries` into a
`~gwpy.segments.DataQualityFlag`
Each contiguous set of `True` values are grouped as a
`~gwpy.segments.Segment` running from the GPS time the first
found `True`, to the GPS time of the next `False` (or the end
of the series)
Parameters
----------
minlen : `int`, optional, default: 1
minimum number of consecutive `True` values to identify as a
`~gwpy.segments.Segment`. This is useful to ignore single
bit flips, for example.
dtype : `type`, `callable`, default: `float`
output segment entry type, can pass either a type for simple
casting, or a callable function that accepts a float and returns
another numeric type
round : `bool`, optional, default: False
choose to round each `~gwpy.segments.Segment` to its
inclusive integer boundaries
Returns
-------
dqflag : `~gwpy.segments.DataQualityFlag`
a segment representation of this `StateTimeSeries`, the span
defines the `known` segments, while the contiguous `True`
sets defined each of the `active` segments
"""
from ..segments import (Segment, SegmentList, DataQualityFlag)
start = self.x0.value
dt = self.dx.value
active = from_bitstream(self.value, start, dt, minlen=int(minlen))
if dtype is not float:
active = active.__class__(
[Segment(dtype(s[0]), dtype(s[1])) for s in active])
known = SegmentList([self.span])
out = DataQualityFlag(name=name or self.name,
active=active,
known=known,
label=label or self.name,
description=description)
if round:
out = out.round()
return out.coalesce()
def to_dqflag(self, name=None, minlen=1, dtype=None, round=False,
label=None, description=None):
"""Convert this series into a `~gwpy.segments.DataQualityFlag`
Each contiguous set of `True` values are grouped as a
`~gwpy.segments.Segment` running from the GPS time the first
found `True`, to the GPS time of the next `False` (or the end
of the series)
Parameters
----------
minlen : `int`, optional, default: 1
minimum number of consecutive `True` values to identify as a
`~gwpy.segments.Segment`. This is useful to ignore single
bit flips, for example.
dtype : `type`, `callable`
output segment entry type, can pass either a type for simple
casting, or a callable function that accepts a float and returns
another numeric type, defaults to the `dtype` of the time index
round : `bool`, optional, default: False
choose to round each `~gwpy.segments.Segment` to its
inclusive integer boundaries
Returns
-------
dqflag : `~gwpy.segments.DataQualityFlag`
a segment representation of this `StateTimeSeries`, the span
defines the `known` segments, while the contiguous `True`
sets defined each of the `active` segments
"""
from glue.segmentsUtils import from_bitstream
from ..segments import (Segment, SegmentList, DataQualityFlag)
# format dtype
if dtype is None:
dtype = self.t0.dtype.type
elif isinstance(dtype, numpy.dtype):
dtype = dtype.type
start = dtype(self.t0.value) # <-- sets the dtype for the segments
dt = self.dt.value
# build segmentlists
active = from_bitstream(self.value, start, dt, minlen=int(minlen))
known = SegmentList([Segment(*map(dtype, self.span))])
# build flag and return
out = DataQualityFlag(name=name or self.name, active=active,
known=known, label=label or self.name,
description=description)
if round:
out = out.round()
return out.coalesce()
def to_dqflag(self, name=None, minlen=1, dtype=float, round=False,
label=None, description=None):
"""Convert this `StateTimeSeries` into a
`~gwpy.segments.DataQualityFlag`
Each contiguous set of `True` values are grouped as a
`~gwpy.segments.Segment` running from the GPS time the first
found `True`, to the GPS time of the next `False` (or the end
of the series)
Parameters
----------
minlen : `int`, optional, default: 1
minimum number of consecutive `True` values to identify as a
`~gwpy.segments.Segment`. This is useful to ignore single
bit flips, for example.
dtype : `type`, `callable`, default: `float`
output segment entry type, can pass either a type for simple
casting, or a callable function that accepts a float and returns
another numeric type
round : `bool`, optional, default: False
choose to round each `~gwpy.segments.Segment` to its
inclusive integer boundaries
Returns
-------
dqflag : `~gwpy.segments.DataQualityFlag`
a segment representation of this `StateTimeSeries`, the span
defines the `known` segments, while the contiguous `True`
sets defined each of the `active` segments
"""
from ..segments import (Segment, SegmentList, DataQualityFlag)
start = self.x0.value
dt = self.dx.value
active = from_bitstream(self.value, start, dt, minlen=int(minlen))
if dtype is not float:
active = active.__class__([Segment(dtype(s[0]), dtype(s[1])) for
s in active])
known = SegmentList([self.span])
out = DataQualityFlag(name=name or self.name, active=active,
known=known, label=label or self.name,
description=description)
if round:
out = out.round()
return out.coalesce()
def mask_data_to_seglist(data, start, dt, mask_on=0x1, mask_off=0x0): """ Apply bitmask to data and parse the result into a segment list. """ # FIXME: numpy operations? return from_bitstream([(d & mask_on) & (not(d & mask_off)) for d in data], start, dt)