def data_from_cli(opts):
"""Loads the data needed for a model from the given
command-line options. Gates specifed on the command line are also applied.
Parameters
----------
opts : ArgumentParser parsed args
Argument options parsed from a command line string (the sort of thing
returned by `parser.parse_args`).
Returns
-------
strain_dict : dict
Dictionary of instruments -> `TimeSeries` strain.
stilde_dict : dict
Dictionary of instruments -> `FrequencySeries` strain.
psd_dict : dict
Dictionary of instruments -> `FrequencySeries` psds.
"""
# get gates to apply
gates = gates_from_cli(opts)
psd_gates = psd_gates_from_cli(opts)
# get strain time series
instruments = opts.instruments if opts.instruments is not None else []
strain_dict = strain_from_cli_multi_ifos(opts, instruments,
precision="double")
# apply gates if not waiting to overwhiten
if not opts.gate_overwhitened:
strain_dict = apply_gates_to_td(strain_dict, gates)
# get strain time series to use for PSD estimation
# if user has not given the PSD time options then use same data as analysis
if opts.psd_start_time and opts.psd_end_time:
logging.info("Will generate a different time series for PSD "
"estimation")
psd_opts = opts
psd_opts.gps_start_time = psd_opts.psd_start_time
psd_opts.gps_end_time = psd_opts.psd_end_time
psd_strain_dict = strain_from_cli_multi_ifos(psd_opts,
instruments,
precision="double")
# apply any gates
logging.info("Applying gates to PSD data")
psd_strain_dict = apply_gates_to_td(psd_strain_dict, psd_gates)
elif opts.psd_start_time or opts.psd_end_time:
raise ValueError("Must give --psd-start-time and --psd-end-time")
else:
psd_strain_dict = strain_dict
# FFT strain and save each of the length of the FFT, delta_f, and
# low frequency cutoff to a dict
stilde_dict = {}
length_dict = {}
delta_f_dict = {}
low_frequency_cutoff_dict = low_frequency_cutoff_from_cli(opts)
for ifo in instruments:
stilde_dict[ifo] = strain_dict[ifo].to_frequencyseries()
length_dict[ifo] = len(stilde_dict[ifo])
delta_f_dict[ifo] = stilde_dict[ifo].delta_f
# get PSD as frequency series
psd_dict = psd_from_cli_multi_ifos(
opts, length_dict, delta_f_dict, low_frequency_cutoff_dict,
instruments, strain_dict=psd_strain_dict, precision="double")
# apply any gates to overwhitened data, if desired
if opts.gate_overwhitened and opts.gate is not None:
logging.info("Applying gates to overwhitened data")
# overwhiten the data
for ifo in gates:
stilde_dict[ifo] /= psd_dict[ifo]
stilde_dict = apply_gates_to_fd(stilde_dict, gates)
# unwhiten the data for the model
for ifo in gates:
stilde_dict[ifo] *= psd_dict[ifo]
return strain_dict, stilde_dict, psd_dict
def data_from_cli(opts):
"""Loads the data needed for a model from the given
command-line options. Gates specifed on the command line are also applied.
Parameters
----------
opts : ArgumentParser parsed args
Argument options parsed from a command line string (the sort of thing
returned by `parser.parse_args`).
Returns
-------
strain_dict : dict
Dictionary of instruments -> `TimeSeries` strain.
stilde_dict : dict
Dictionary of instruments -> `FrequencySeries` strain.
psd_dict : dict
Dictionary of instruments -> `FrequencySeries` psds.
"""
# get gates to apply
gates = gates_from_cli(opts)
psd_gates = psd_gates_from_cli(opts)
# get strain time series
instruments = opts.instruments if opts.instruments is not None else []
strain_dict = strain_from_cli_multi_ifos(opts,
instruments,
precision="double")
# apply gates if not waiting to overwhiten
if not opts.gate_overwhitened:
strain_dict = apply_gates_to_td(strain_dict, gates)
# get strain time series to use for PSD estimation
# if user has not given the PSD time options then use same data as analysis
if opts.psd_start_time and opts.psd_end_time:
logging.info("Will generate a different time series for PSD "
"estimation")
psd_opts = opts
psd_opts.gps_start_time = psd_opts.psd_start_time
psd_opts.gps_end_time = psd_opts.psd_end_time
psd_strain_dict = strain_from_cli_multi_ifos(psd_opts,
instruments,
precision="double")
# apply any gates
logging.info("Applying gates to PSD data")
psd_strain_dict = apply_gates_to_td(psd_strain_dict, psd_gates)
elif opts.psd_start_time or opts.psd_end_time:
raise ValueError("Must give --psd-start-time and --psd-end-time")
else:
psd_strain_dict = strain_dict
# FFT strain and save each of the length of the FFT, delta_f, and
# low frequency cutoff to a dict
stilde_dict = {}
length_dict = {}
delta_f_dict = {}
low_frequency_cutoff_dict = low_frequency_cutoff_from_cli(opts)
for ifo in instruments:
stilde_dict[ifo] = strain_dict[ifo].to_frequencyseries()
length_dict[ifo] = len(stilde_dict[ifo])
delta_f_dict[ifo] = stilde_dict[ifo].delta_f
# get PSD as frequency series
psd_dict = psd_from_cli_multi_ifos(opts,
length_dict,
delta_f_dict,
low_frequency_cutoff_dict,
instruments,
strain_dict=psd_strain_dict,
precision="double")
# apply any gates to overwhitened data, if desired
if opts.gate_overwhitened and opts.gate is not None:
logging.info("Applying gates to overwhitened data")
# overwhiten the data
for ifo in gates:
stilde_dict[ifo] /= psd_dict[ifo]
stilde_dict = apply_gates_to_fd(stilde_dict, gates)
# unwhiten the data for the model
for ifo in gates:
stilde_dict[ifo] *= psd_dict[ifo]
return strain_dict, stilde_dict, psd_dict
def data_from_cli(opts,
check_for_valid_times=False,
shift_psd_times_to_valid=False,
err_on_missing_detectors=False):
"""Loads the data needed for a model from the given command-line options.
Gates specifed on the command line are also applied.
Parameters
----------
opts : ArgumentParser parsed args
Argument options parsed from a command line string (the sort of thing
returned by `parser.parse_args`).
check_for_valid_times : bool, optional
Check that valid data exists in the requested gps times. Default is
False.
shift_psd_times_to_valid : bool, optional
If estimating the PSD from data, shift the PSD times to a valid
segment if needed. Default is False.
err_on_missing_detectors : bool, optional
Raise a NoValidDataError if any detector does not have valid data.
Otherwise, a warning is printed, and that detector is skipped.
Returns
-------
strain_dict : dict
Dictionary of detectors -> time series strain.
psd_strain_dict : dict or None
If ``opts.psd_(start|end)_time`` were set, a dctionary of
detectors -> time series data to use for PSD estimation. Otherwise,
``None``.
"""
# get gates to apply
gates = gates_from_cli(opts)
psd_gates = psd_gates_from_cli(opts)
# get strain time series
instruments = opts.instruments
# validate times
if check_for_valid_times:
dets_with_data = detectors_with_valid_data(
instruments,
opts.gps_start_time,
opts.gps_end_time,
pad_data=opts.pad_data,
err_on_missing_detectors=err_on_missing_detectors,
shift_to_valid=False,
segment_name=opts.dq_segment_name,
source=opts.dq_source,
server=opts.dq_server,
veto_definer=opts.veto_definer)
# reset instruments to only be those with valid data
instruments = list(dets_with_data.keys())
strain_dict = strain_from_cli_multi_ifos(opts,
instruments,
precision="double")
# apply gates if not waiting to overwhiten
if not opts.gate_overwhitened:
strain_dict = apply_gates_to_td(strain_dict, gates)
# check that there aren't nans in the data
check_for_nans(strain_dict)
# get strain time series to use for PSD estimation
# if user has not given the PSD time options then use same data as analysis
if opts.psd_start_time and opts.psd_end_time:
logging.info("Will generate a different time series for PSD "
"estimation")
if check_for_valid_times:
psd_times = detectors_with_valid_data(
instruments,
opts.psd_start_time,
opts.psd_end_time,
pad_data=opts.pad_data,
err_on_missing_detectors=err_on_missing_detectors,
shift_to_valid=shift_psd_times_to_valid,
segment_name=opts.dq_segment_name,
source=opts.dq_source,
server=opts.dq_server,
veto_definer=opts.veto_definer)
# remove detectors from the strain dict that did not have valid
# times for PSD estimation
for det in set(strain_dict.keys()) - set(psd_times.keys()):
_ = strain_dict.pop(det)
# reset instruments to only be those with valid data
instruments = list(psd_times.keys())
else:
psd_times = {
det: (opts.psd_start_time[det], opts.psd_end_time[det])
for det in instruments
}
psd_strain_dict = {}
for det, (psd_start, psd_end) in psd_times.items():
opts.gps_start_time = psd_start
opts.gps_end_time = psd_end
psd_strain_dict.update(
strain_from_cli_multi_ifos(opts, [det], precision="double"))
# apply any gates
logging.info("Applying gates to PSD data")
psd_strain_dict = apply_gates_to_td(psd_strain_dict, psd_gates)
# check that there aren't nans in the psd data
check_for_nans(psd_strain_dict)
elif opts.psd_start_time or opts.psd_end_time:
raise ValueError("Must give psd-start-time and psd-end-time")
else:
psd_strain_dict = None
# check that we have data left to analyze
if instruments == []:
raise NoValidDataError("No valid data could be found in any of the "
"requested instruments.")
return strain_dict, psd_strain_dict