def get_sft_array(sftfilepattern, F0=None, dF0=None):
"""Return the raw data (absolute values) from a set of SFTs.
FIXME: currently only returns data for first detector.
Parameters
----------
sftfilepattern: str
Pattern to match SFTs using wildcards (`*?`) and ranges [0-9];
multiple patterns can be given separated by colons.
F0, dF0: float or None
Restrict frequency range to `[F0-dF0,F0+dF0]`.
Returns
----------
times: np.ndarray
The SFT starttimes as a 1D array.
freqs: np.ndarray
The frequency bins in each SFT.
These will be the same for each SFT,
so only a single 1D array is returned.
data: np.ndarray
A 2D array of the absolute values of the SFT data
in each frequency bin at each timestamp.
"""
if True: # pragma: no cover
import warnings
warnings.warn(
"`get_sft_array` is deprecated and will be removed in a future release. "
"Please, use `get_sft_as_arrays` to load SFT complex amplitudes.")
if F0 is None and dF0 is None:
fMin = -1
fMax = -1
elif F0 is None or dF0 is None:
raise ValueError("Need either none or both of F0, dF0.")
else:
fMin = F0 - dF0
fMax = F0 + dF0
SFTCatalog = lalpulsar.SFTdataFind(sftfilepattern,
lalpulsar.SFTConstraints())
MultiSFTs = lalpulsar.LoadMultiSFTs(SFTCatalog, fMin, fMax)
ndet = MultiSFTs.length
if ndet > 1:
logging.warning(
"Loaded SFTs from {:d} detectors, only using the first.".format(
ndet))
SFTs = MultiSFTs.data[0]
times = np.array([sft.epoch.gpsSeconds for sft in SFTs.data])
data = [np.abs(sft.data.data) for sft in SFTs.data]
data = np.array(data).T
nbins, nsfts = data.shape
sft0 = SFTs.data[0]
freqs = np.linspace(sft0.f0, sft0.f0 + (nbins - 1) * sft0.deltaF, nbins)
return times, freqs, data
def validate_and_load_SFTs ( globstr, fmin, fmax ):
sftnames = list(glob.glob(os.path.join(testdir,globstr)))
assert len(sftnames) == 1
sftname = sftnames[0]
app = "lalapps_SFTvalidate"
cl = app + " " + sftname
print("Executing: " + cl)
out = subprocess.check_output(cl, shell=True, stderr=subprocess.STDOUT, universal_newlines=True)
print("{:s}: {}".format(app,out))
catalog = lalpulsar.SFTdataFind(sftname, None)
sfts = lalpulsar.LoadSFTs(catalog, fmin, fmax)
return sfts, sftname
def get_sft_array(sftfilepattern, data_duration, F0, dF0):
""" Return the raw data from a set of sfts """
SFTCatalog = lalpulsar.SFTdataFind(sftfilepattern,
lalpulsar.SFTConstraints())
MultiSFTs = lalpulsar.LoadMultiSFTs(SFTCatalog, F0 - dF0, F0 + dF0)
SFTs = MultiSFTs.data[0]
data = []
for sft in SFTs.data:
data.append(np.abs(sft.data.data))
data = np.array(data).T
n, nsfts = data.shape
freqs = np.linspace(sft.f0, sft.f0 + n * sft.deltaF, n)
times = np.linspace(0, data_duration, nsfts)
return times, freqs, data
def compute_Fstat_spindown_simulateCW():
# waveform: simple spindown model
def waveform(h0, cosi, freq, f1dot):
def wf(dt):
dphi = lal.TWOPI * (freq * dt + f1dot * 0.5 * dt**2)
ap = h0 * (1.0 + cosi**2) / 2.0
ax = h0 * cosi
return dphi, ap, ax
return wf
# waveform parameters
dt_wf = 5
# create simulator
S = simCW.CWSimulator(tref, tstart, Tdata, waveform(h0, cosi, freq, f1dot), dt_wf, phi0, psi, alpha, delta, detector, earth_ephem_file=earth_ephem_file, sun_ephem_file=sun_ephem_file)
# write SFTs
for path, i, N in S.write_sft_files(fmax, Tsft, 'simulateCWTest'):
pass
# load SFTs from catalog
sft_catalog = lalpulsar.SFTdataFind('V-1_V1_1800SFT_simCW_simulateCWTest-*.sft', None)
# create default F-statistic optional arguments
Fstat_opt_args = lalpulsar.FstatOptionalArgs(lalpulsar.FstatOptionalArgsDefaults)
Fstat_opt_args.FstatMethod = lalpulsar.FMETHOD_DEMOD_BEST
Fstat_assume_noise = lalpulsar.MultiNoiseFloor()
Fstat_assume_noise.length = 1
Fstat_assume_noise.sqrtSn[0] = assume_sqrtSh
Fstat_opt_args.assumeSqrtSX = Fstat_assume_noise
# create F-statistic input data
Fstat_input = lalpulsar.CreateFstatInput(sft_catalog, fcmin, fcmax, dfreq, ephemerides, Fstat_opt_args)
Fstat_res = 0
doppler = lalpulsar.PulsarDopplerParams()
doppler.refTime = tref
doppler.Alpha = alpha
doppler.Delta = delta
doppler.fkdot[0] = fsmin
doppler.fkdot[1] = f1dot
# search SFTs using F-statistic
Fstat_res = lalpulsar.ComputeFstat(Fstat_res, Fstat_input, doppler, Nfs, lalpulsar.FSTATQ_2F)
return Fstat_res.twoF
def get_multi_detector_states_from_sfts(
self,
sftfilepath,
central_frequency,
time_offset=None,
frequency_wing_bins=1,
sft_constraint=None,
return_sfts=False,
):
"""
Parameters
----------
sftfilepath: str
Path to SFT files in a format compatible with XLALSFTdataFind.
central_frequency: float
Frequency [Hz] around which SFT data will be retrieved.
This option is only relevant if further information is to be
retrieved from the SFTs (i.e. `return_sfts=True`).
time_offset: float
Timestamp offset to retrieve detector states.
Defaults to LALSuite's default of using the central time of an STF (SFT's timestamp + Tsft/2).
frequency_wing_bins: int
Frequency bins around the central frequency to retrieve from
SFT data. Bin size is determined using the SFT baseline time
as obtained from the catalog.
This option is only relevant if further information is to be
retrieved from the SFTs (i.e. `return_sfts=True`).
sft_constraint: lalpulsar.SFTConstraint
Optional argument to specify further constraints in XLALSFTdataFind.
return_sfts: bool
If True, also return the loaded SFTs. This is useful to compute further
quantities such as noise weights.
Returns
-------
multi_detector_states: lalpulsar.MultiDetectorStateSeries
Resulting multi-detector states produced by XLALGetMultiDetectorStatesFromMultiSFTs
multi_sfts: lalpulsar.MultiSFTVector
Only if `return_sfts` is True.
MultiSFTVector produced by XLALLoadMultiSFTs along the specified frequency band.
"""
# FIXME: Use MultiCatalogView once lalsuite implements the proper
# SWIG wrapper around XLALLoadMultiSFTsFromView.
sft_catalog = lalpulsar.SFTdataFind(sftfilepath, sft_constraint)
df = sft_catalog.data[0].header.deltaF
wing_Hz = df * frequency_wing_bins
multi_sfts = lalpulsar.LoadMultiSFTs(
sft_catalog,
fMin=central_frequency - wing_Hz,
fMax=central_frequency + wing_Hz,
)
if time_offset is None:
time_offset = 0.5 / df
multi_detector_states = lalpulsar.GetMultiDetectorStatesFromMultiSFTs(
multiSFTs=multi_sfts, edat=self.ephems, tOffset=time_offset)
if return_sfts:
return multi_detector_states, multi_sfts
else:
return multi_detector_states
def get_sft_as_arrays(sftfilepattern, fMin=None, fMax=None, constraints=None):
"""
Parameters
----------
sftfilepattern: str
Pattern to match SFTs using wildcards (`*?`) and ranges [0-9];
multiple patterns can be given separated by colons.
fMin, fMax: float or None
Restrict frequency range to `[fMin, fMax]`.
If None, retreive the full frequency range.
constraints: lalpulsar.SFTConstraints() or None
Constrains to be fed into XLALSFTdataFind to specify detector,
GPS time range or timestamps to be retrieved.
Returns
----------
freqs: np.ndarray
The frequency bins in each SFT.
These will be the same for each SFT,
so only a single 1D array is returned.
times: dict of np.ndarray
The SFT start times as a dictionary of 1D arrays, one for each detector.
Keys correspond to the official detector names as returned by XLALlalpulsar.ListIFOsInCatalog.
data: dict of np.ndarray
A dictionary of 2D arrays of the complex Fourier amplitudes of the SFT data
for each detector in each frequency bin at each timestamp.
Keys correspond to the official detector names as returned by XLALlalpulsar.ListIFOsInCatalog.
"""
constraints = constraints or lalpulsar.SFTConstraints()
if fMin is None and fMax is None:
fMin = fMax = -1
elif fMin is None or fMax is None:
raise ValueError("Need either none or both of fMin, fMax.")
sft_catalog = lalpulsar.SFTdataFind(sftfilepattern, constraints)
ifo_labels = lalpulsar.ListIFOsInCatalog(sft_catalog)
logging.info(
f"Loading {sft_catalog.length} SFTs from {', '.join(ifo_labels.data)}..."
)
multi_sfts = lalpulsar.LoadMultiSFTs(sft_catalog, fMin, fMax)
logging.info("done!")
times = {}
amplitudes = {}
old_frequencies = None
for ind, ifo in enumerate(ifo_labels.data):
sfts = multi_sfts.data[ind]
times[ifo] = np.array([sft.epoch.gpsSeconds for sft in sfts.data])
amplitudes[ifo] = np.array([sft.data.data for sft in sfts.data]).T
nbins, nsfts = amplitudes[ifo].shape
logging.info(f"{nsfts} retrieved from {ifo}.")
f0 = sfts.data[0].f0
df = sfts.data[0].deltaF
frequencies = np.linspace(f0, f0 + (nbins - 1) * df, nbins)
if (old_frequencies
is not None) and not np.allclose(frequencies, old_frequencies):
raise ValueError(
f"Frequencies don't match between {ifo_labels.data[ind-1]} and {ifo}"
)
old_frequencies = frequencies
return frequencies, times, amplitudes