def __call__(self, filename, *args, **kwargs):
from ..stokes_spectral_cube import StokesSpectralCube
if isinstance(filename, PosixPath):
filename = str(filename)
kwargs['target_cls'] = StokesSpectralCube
try:
return registry.read(StokesSpectralCube, filename, *args, **kwargs)
except IsADirectoryError: # See note above StringWrapper
return registry.read(StokesSpectralCube, StringWrapper(filename), *args, **kwargs)
def read(cls, source, *args, **kwargs):
"""Read data for multiple bit vector channels into a `StateVectorDict`
Parameters
----------
source : `str`, `~glue.lal.Cache`
a single file path `str`, or a `~glue.lal.Cache` containing
a contiguous list of files.
channels : `~gwpy.detector.channel.ChannelList`, `list`
a list of channels to read from the source.
start : `~gwpy.time.LIGOTimeGPS`, `float`, `str` optional
GPS start time of required data, anything parseable by
:meth:`~gwpy.time.to_gps` is fine
end : `~gwpy.time.LIGOTimeGPS`, `float`, `str`, optional
GPS end time of required data, anything parseable by
:meth:`~gwpy.time.to_gps` is fine
bits : `list` of `lists`, `dict`, optional
the ordered list of interesting bit lists for each channel,
or a `dict` of (`channel`, `list`) pairs
format : `str`, optional
source format identifier. If not given, the format will be
detected if possible. See below for list of acceptable
formats.
nproc : `int`, optional, default: ``1``
number of parallel processes to use, serial process by
default.
.. note::
Parallel frame reading, via the ``nproc`` keyword argument,
is only available when giving a :class:`~glue.lal.Cache` of
frames, or using the ``format='cache'`` keyword argument.
gap : `str`, optional
how to handle gaps in the cache, one of
- 'ignore': do nothing, let the undelying reader method handle it
- 'warn': do nothing except print a warning to the screen
- 'raise': raise an exception upon finding a gap (default)
- 'pad': insert a value to fill the gaps
pad : `float`, optional
value with which to fill gaps in the source data, only used if
gap is not given, or `gap='pad'` is given
Returns
-------
statevectordict : `StateVectorDict`
a `StateVectorDict` of (`channel`, `StateVector`) pairs. The keys
are guaranteed to be the ordered list `channels` as given.
Notes
-----"""
return io_registry.read(cls, source, *args, **kwargs)
def read(cls, source, *args, **kwargs):
"""Read data into a `Spectrogram`
Arguments and keywords depend on the output format, see the
online documentation for full details for each format, the
parameters below are common to most formats.
Parameters
----------
source : `str`, :class:`~glue.lal.Cache`
source of data, any of the following:
- `str` path of single data file
- `str` path of LAL-format cache file
- :class:`~glue.lal.Cache` describing one or more data files,
format : `str`, optional
source format identifier. If not given, the format will be
detected if possible. See below for list of acceptable
formats
Returns
-------
specgram : `Spectrogram`
Notes
-----"""
return io_registry.read(cls, source, *args, **kwargs)
def read(cls, source, *args, **kwargs):
"""Read data into a `Spectrogram`
Arguments and keywords depend on the output format, see the
online documentation for full details for each format, the
parameters below are common to most formats.
Parameters
----------
source : `str`, `~glue.lal.Cache`
source of data, any of the following:
- `str` path of single data file
- `str` path of LAL-format cache file
- `~glue.lal.Cache` describing one or more data files,
format : `str`, optional
source format identifier. If not given, the format will be
detected if possible. See below for list of acceptable
formats
Returns
-------
specgram : `Spectrogram`
Notes
-----"""
return io_registry.read(cls, source, *args, **kwargs)
def read(cls, source, flags=None, format=None, **kwargs):
"""Read segments from file into a `DataQualityDict`
Parameters
----------
source : `str`
path of file to read
format : `str`, optional
source format identifier. If not given, the format will be
detected if possible. See below for list of acceptable
formats.
flags : `list`, optional, default: read all flags found
list of flags to read, by default all flags are read separately.
coalesce : `bool`, optional, default: `True`
coalesce all `SegmentLists` before returning.
Returns
-------
flagdict : `DataQualityDict`
a new `DataQualityDict` of `DataQualityFlag` entries with
``active`` and ``known`` segments seeded from the XML tables
in the given file.
Notes
-----"""
return io_registry.read(cls, source, flags=flags, format=format,
**kwargs)
def read(cls, source, *args, **kwargs):
"""Read segments from file into a `DataQualityFlag`.
Parameters
----------
filename : `str`
path of file to read
flag : `str`, optional, default: read all segments
name of flag to read from file.
format : `str`, optional
source format identifier. If not given, the format will be
detected if possible. See below for list of acceptable
formats.
coltype : `type`, optional, default: `float`
datatype to force for segment times, only valid for
``format='segwizard'``.
strict : `bool`, optional, default: `True`
require segment start and stop times match printed duration,
only valid for ``format='segwizard'``.
Returns
-------
dqflag : `DataQualityFlag`
formatted `DataQualityFlag` containing the active and known
segments read from file.
Notes
-----"""
return io_registry.read(cls, source, *args, **kwargs)
def read(cls, source, *args, **kwargs):
"""Read data into a `SpectralVariance`
Arguments and keywords depend on the output format, see the
online documentation for full details for each format, the
parameters below are common to most formats.
Parameters
----------
source : `str`, `list`
Source of data, any of the following:
- `str` path of single data file,
- `str` path of LAL-format cache file,
- `list` of paths.
*args
Other arguments are (in general) specific to the given
``format``.
format : `str`, optional
Source format identifier. If not given, the format will be
detected if possible. See below for list of acceptable
formats.
**kwargs
Other keywords are (in general) specific to the given ``format``.
Notes
-----"""
return io_registry.read(cls, source, *args, **kwargs)
def read(cls, source, *args, **kwargs):
"""Read data into a `FrequencySeries`
Arguments and keywords depend on the output format, see the
online documentation for full details for each format, the
parameters below are common to most formats.
Parameters
----------
source : `str`, `list`
Source of data, any of the following:
- `str` path of single data file,
- `str` path of LAL-format cache file,
- `list` of paths.
*args
Other arguments are (in general) specific to the given
``format``.
format : `str`, optional
Source format identifier. If not given, the format will be
detected if possible. See below for list of acceptable
formats.
**kwargs
Other keywords are (in general) specific to the given ``format``.
Notes
-----"""
return io_registry.read(cls, source, *args, **kwargs)
def read(cls, *args, **kwargs):
"""Read and parse gridded N-dimensional data and return as an
`~.NDDataBase`-derived object.
This function provides the `~.NDDataBase` interface to the astropy
unified I/O layer. This allows easily reading a file in the supported
data formats.
"""
return io_registry.read(cls, *args, **kwargs)
def read(cls, *args, **kwargs):
"""
Read and parse gridded N-dimensional data and return as an
NDData-derived object.
This function provides the NDDataBase interface to the astropy unified
I/O layer. This allows easily reading a file in the supported data
formats.
"""
return io_registry.read(cls, *args, **kwargs)
def read(cls, source, *args, **kwargs):
"""Read a `ChannelList` from a file
Parameters
----------
source : `str`, `file`
either an open file object, or a file name path to read
Notes
-----"""
return io_registry.read(cls, source, *args, **kwargs)
def read(cls, source, *args, **kwargs):
"""Read a `ChannelList` from a file
Parameters
----------
source : `str`, `file`
either an open file object, or a file name path to read
Notes
-----"""
return io_registry.read(cls, source, *args, **kwargs)
def __call__(self, *args, **kwargs):
cls = self._cls
out = registry.read(cls, *args, **kwargs)
# For some readers (e.g., ascii.ecsv), the returned `out` class is not
# guaranteed to be the same as the desired output `cls`. If so,
# try coercing to desired class without copying (io.registry.read
# would normally do a copy). The normal case here is swapping
# Table <=> QTable.
if cls is not out.__class__:
try:
out = cls(out, copy=False)
except Exception:
raise TypeError('could not convert reader output to {0} '
'class.'.format(cls.__name__))
return out
def __call__(self, *args, **kwargs):
from astropy.cosmology.core import Cosmology
# so subclasses can override, also pass the class as a kwarg.
# allows for `FlatLambdaCDM.read` and
# `Cosmology.read(..., cosmology=FlatLambdaCDM)`
if self._cls is not Cosmology:
kwargs.setdefault("cosmology", self._cls) # set, if not present
# check that it is the correct cosmology, can be wrong if user
# passes in e.g. `w0wzCDM.read(..., cosmology=FlatLambdaCDM)`
valid = (self._cls, self._cls.__qualname__)
if kwargs["cosmology"] not in valid:
raise ValueError(
"keyword argument `cosmology` must be either the class "
f"{valid[0]} or its qualified name '{valid[1]}'")
cosmo = io_registry.read(self._cls, *args, **kwargs)
return cosmo
def read(cls, source, *args, **kwargs):
"""Read data into a `StarField`
This utility is essentially a wrapper around
`~astropy.table.Table.read` which populates a `StarField` from the
data collected in a `Table`
Parameters
----------
source : `str`
path of a single data file from which to read
*args : `tuple`, optional
other positional arguments passed directly to the
underlying reader method for the given format
format : `str`, optional
file format for input data; if not given, the data reader will
attempt to automatically identify the format based on ``source``
**kwargs : `dict`, optional
other keyword arguments passed directly to the
underlying reader method for the given format
Returns
-------
field : `StarField`
Raises
------
astropy.io.registry.IORegistryError
if the `format` cannot be automatically identified
Notes
-----"""
# read as a table, then convert to a `StarField`
data = registry.read(Table, source, *args, **kwargs)
return cls(
theta=data['theta'],
phi=data['phi'],
mag=data['mag'],
angrad=data['angrad'],
brightness=data['brightness'],
)
def read(cls, source, format=None, **kwargs):
"""Read segments from file into a `SegmentList`
Parameters
----------
filename : `str`
path of file to read
format : `str`, optional
source format identifier. If not given, the format will be
detected if possible. See below for list of acceptable
formats.
Returns
-------
segmentlist : `SegmentList`
`SegmentList` active and known segments read from file.
Notes
-----"""
return io_registry.read(cls, source, format=format, **kwargs)
def __call__(self, *args, **kwargs):
return registry.read(self._cls, *args, **kwargs)
def __call__(self, *args, **kwargs):
return registry.read(self._cls, *args, **kwargs)
def read(cls, source, *args, **kwargs):
"""Read data into a `StateVector`
Parameters
----------
source : `str`, `~glue.lal.Cache`
source of data, any of the following:
- `str` path of single data file
- `str` path of LAL-format cache file
- `~glue.lal.Cache` describing one or more data files,
channel : `str`, `~gwpy.detector.Channel`
the name of the channel to read, or a `Channel` object.
start : `~gwpy.time.LIGOTimeGPS`, `float`, `str`
GPS start time of required data,
any input parseable by `~gwpy.time.to_gps` is fine
end : `~gwpy.time.LIGOTimeGPS`, `float`, `str`, optional
GPS end time of required data, defaults to end of data found;
any input parseable by `~gwpy.time.to_gps` is fine
bits : `list`, optional
list of bits names for this `StateVector`, give `None` at
any point in the list to mask that bit
format : `str`, optional
source format identifier. If not given, the format will be
detected if possible. See below for list of acceptable
formats.
nproc : `int`, optional, default: `1`
number of parallel processes to use, serial process by
default.
.. note::
Parallel frame reading, via the ``nproc`` keyword argument,
is only available when giving a `~glue.lal.Cache` of
frames, or using the ``format='cache'`` keyword argument.
gap : `str`, optional
how to handle gaps in the cache, one of
- 'ignore': do nothing, let the undelying reader method handle it
- 'warn': do nothing except print a warning to the screen
- 'raise': raise an exception upon finding a gap (default)
- 'pad': insert a value to fill the gaps
pad : `float`, optional
value with which to fill gaps in the source data, only used if
gap is not given, or `gap='pad'` is given
Example
-------
To read the S6 state vector, with names for all the bits::
>>> sv = StateVector.read(
'H-H1_LDAS_C02_L2-968654592-128.gwf', 'H1:IFO-SV_STATE_VECTOR',
bits=['Science mode', 'Conlog OK', 'Locked',
'No injections', 'No Excitations'],
dtype='uint32')
then you can convert these to segments
>>> segments = sv.to_dqflags()
or to read just the interferometer operations bits::
>>> sv = StateVector.read(
'H-H1_LDAS_C02_L2-968654592-128.gwf', 'H1:IFO-SV_STATE_VECTOR',
bits=['Science mode', None, 'Locked'], dtype='uint32')
Running `to_dqflags` on this example would only give 2 flags, rather
than all five.
Alternatively the `bits` attribute can be reset after reading, but
before any further operations.
Notes
-----"""
return io_registry.read(cls, source, *args, **kwargs)
