def test_run_computefstatistic_allowedMismatchFromSFTLength(self):
long_Tsft_params = default_Writer_params.copy()
long_Tsft_params["Tsft"] = 3600
long_Tsft_params["duration"] = 4 * long_Tsft_params["Tsft"]
long_Tsft_params["label"] = "long_Tsft"
long_Tsft_params["F0"] = 1500
long_Tsft_params["Band"] = 2.0
long_Tsft_Writer = pyfstat.Writer(**long_Tsft_params)
long_Tsft_Writer.run_makefakedata()
search = pyfstat.ComputeFstat(
tref=long_Tsft_Writer.tref,
sftfilepattern=long_Tsft_Writer.sftfilepath,
minCoverFreq=1499.5,
maxCoverFreq=1500.5,
allowedMismatchFromSFTLength=0.1,
)
with pytest.raises(RuntimeError):
search.get_fullycoherent_twoF(F0=1500,
F1=0,
F2=0,
Alpha=0,
Delta=0)
search = pyfstat.ComputeFstat(
tref=long_Tsft_Writer.tref,
sftfilepattern=long_Tsft_Writer.sftfilepath,
minCoverFreq=1499.5,
maxCoverFreq=1500.5,
allowedMismatchFromSFTLength=0.5,
)
search.get_fullycoherent_twoF(F0=1500, F1=0, F2=0, Alpha=0, Delta=0)
def test_injectSources(self):
# This seems to be writing with a signal...
Writer = pyfstat.Writer(
self.label,
outdir=self.outdir,
add_noise=False,
duration=86400,
h0=1,
sqrtSX=1,
)
Writer.make_cff()
injectSources = Writer.config_file_name
search = pyfstat.ComputeFstat(
tref=Writer.tref,
assumeSqrtSX=1,
injectSources=injectSources,
minCoverFreq=28,
maxCoverFreq=32,
minStartTime=Writer.tstart,
maxStartTime=Writer.tstart + Writer.duration,
detectors=Writer.detectors,
)
FS_from_file = search.get_fullycoherent_twoF(
Writer.tstart,
Writer.tend,
Writer.F0,
Writer.F1,
Writer.F2,
Writer.Alpha,
Writer.Delta,
)
Writer.make_data()
predicted_FS = Writer.predict_fstat()
self.assertTrue(np.abs(predicted_FS - FS_from_file) / FS_from_file < 0.3)
injectSourcesdict = pyfstat.core.read_par(Writer.config_file_name)
injectSourcesdict["F0"] = injectSourcesdict["Freq"]
injectSourcesdict["F1"] = injectSourcesdict["f1dot"]
injectSourcesdict["F2"] = injectSourcesdict["f2dot"]
search = pyfstat.ComputeFstat(
tref=Writer.tref,
assumeSqrtSX=1,
injectSources=injectSourcesdict,
minCoverFreq=28,
maxCoverFreq=32,
minStartTime=Writer.tstart,
maxStartTime=Writer.tstart + Writer.duration,
detectors=Writer.detectors,
)
FS_from_dict = search.get_fullycoherent_twoF(
Writer.tstart,
Writer.tend,
Writer.F0,
Writer.F1,
Writer.F2,
Writer.Alpha,
Writer.Delta,
)
self.assertTrue(FS_from_dict == FS_from_file)
def test_run_computefstatistic_single_point_injectSources(self):
predicted_FS = self.Writer.predict_fstat()
injectSources = self.Writer.config_file_name
search = pyfstat.ComputeFstat(
tref=self.Writer.tref,
assumeSqrtSX=1,
injectSources=injectSources,
minCoverFreq=28,
maxCoverFreq=32,
minStartTime=self.Writer.tstart,
maxStartTime=self.Writer.tend,
detectors=self.Writer.detectors,
)
FS_from_file = search.get_fullycoherent_twoF(
F0=self.Writer.F0,
F1=self.Writer.F1,
F2=self.Writer.F2,
Alpha=self.Writer.Alpha,
Delta=self.Writer.Delta,
)
self.assertTrue(
np.abs(predicted_FS - FS_from_file) / FS_from_file < 0.3)
injectSourcesdict = search.read_par(filename=injectSources)
injectSourcesdict["F0"] = injectSourcesdict.pop("Freq")
injectSourcesdict["F1"] = injectSourcesdict.pop("f1dot")
injectSourcesdict["F2"] = injectSourcesdict.pop("f2dot")
injectSourcesdict["phi"] = injectSourcesdict.pop("phi0")
search = pyfstat.ComputeFstat(
tref=self.Writer.tref,
assumeSqrtSX=1,
injectSources=injectSourcesdict,
minCoverFreq=28,
maxCoverFreq=32,
minStartTime=self.Writer.tstart,
maxStartTime=self.Writer.tend,
detectors=self.Writer.detectors,
)
FS_from_dict = search.get_fullycoherent_twoF(
F0=self.Writer.F0,
F1=self.Writer.F1,
F2=self.Writer.F2,
Alpha=self.Writer.Alpha,
Delta=self.Writer.Delta,
)
self.assertTrue(FS_from_dict == FS_from_file)
def test_run_computefstatistic_single_point_no_noise_manual_ephem(self):
predicted_FS = self.Writer.predict_fstat(assumeSqrtSX=1)
# let's get the default ephemeris files (to be sure their paths exist)
# and then pretend we pass them manually, to test those class options
(
earth_ephem_default,
sun_ephem_default,
) = pyfstat.helper_functions.get_ephemeris_files()
search = pyfstat.ComputeFstat(
tref=self.Writer.tref,
assumeSqrtSX=1,
sftfilepattern=self.Writer.sftfilepath,
earth_ephem=earth_ephem_default,
sun_ephem=sun_ephem_default,
search_ranges=self.search_ranges,
)
FS = search.get_fullycoherent_twoF(
F0=self.Writer.F0,
F1=self.Writer.F1,
F2=self.Writer.F2,
Alpha=self.Writer.Alpha,
Delta=self.Writer.Delta,
)
self.assertTrue(np.abs(predicted_FS - FS) / FS < 0.3)
def run_computefstatistic_single_point_no_noise(self):
Writer = pyfstat.Writer(
self.label,
outdir=self.outdir,
add_noise=False,
duration=86400,
h0=1,
sqrtSX=1,
)
Writer.make_data()
predicted_FS = Writer.predict_fstat()
search = pyfstat.ComputeFstat(
tref=Writer.tref,
assumeSqrtSX=1,
sftfilepattern="{}/*{}*sft".format(Writer.outdir, Writer.label),
)
FS = search.get_fullycoherent_twoF(
Writer.tstart,
Writer.tend,
Writer.F0,
Writer.F1,
Writer.F2,
Writer.Alpha,
Writer.Delta,
)
self.assertTrue(np.abs(predicted_FS - FS) / FS < 0.3)
def test_run_computefstatistic_single_point_with_SFTs(self):
twoF_predicted = self.Writer.predict_fstat()
search = pyfstat.ComputeFstat(
tref=self.Writer.tref,
sftfilepattern=self.Writer.sftfilepath,
search_ranges=self.search_ranges,
)
twoF = search.get_fullycoherent_twoF(
F0=self.Writer.F0,
F1=self.Writer.F1,
F2=self.Writer.F2,
Alpha=self.Writer.Alpha,
Delta=self.Writer.Delta,
)
diff = np.abs(twoF - twoF_predicted) / twoF_predicted
print(("Predicted twoF is {}"
" while recovered value is {},"
" relative difference: {}".format(twoF_predicted, twoF, diff)))
self.assertTrue(diff < 0.3)
# the following seems to be a leftover from when this test case was
# doing separate H1 vs H1,L1 searches, but now only really tests the
# SSBprec. But well, it still does add a tiny bit of coverage, can still
# be replaced by something more systematic later.
search = pyfstat.ComputeFstat(
tref=self.Writer.tref,
detectors=self.Writer.detectors,
sftfilepattern=self.Writer.sftfilepath,
SSBprec=lalpulsar.SSBPREC_RELATIVISTIC,
search_ranges=self.search_ranges,
)
twoF2 = search.get_fullycoherent_twoF(
F0=self.Writer.F0,
F1=self.Writer.F1,
F2=self.Writer.F2,
Alpha=self.Writer.Alpha,
Delta=self.Writer.Delta,
)
diff = np.abs(twoF2 - twoF_predicted) / twoF_predicted
print(("Predicted twoF is {}"
" while recovered value is {},"
" relative difference: {}".format(twoF_predicted, twoF2, diff)))
self.assertTrue(diff < 0.3)
diff = np.abs(twoF2 - twoF) / twoF
self.assertTrue(diff < 0.001)
def test_run_computefstatistic_single_point(self):
Writer = pyfstat.Writer(
self.label,
outdir=self.outdir,
duration=86400,
h0=1,
sqrtSX=1,
detectors="H1",
)
Writer.make_data()
predicted_FS = Writer.predict_fstat()
search_H1L1 = pyfstat.ComputeFstat(
tref=Writer.tref,
sftfilepattern="{}/*{}*sft".format(Writer.outdir, Writer.label),
)
FS = search_H1L1.get_fullycoherent_twoF(
Writer.tstart,
Writer.tend,
Writer.F0,
Writer.F1,
Writer.F2,
Writer.Alpha,
Writer.Delta,
)
self.assertTrue(np.abs(predicted_FS - FS) / FS < 0.3)
Writer.detectors = "H1"
predicted_FS = Writer.predict_fstat()
search_H1 = pyfstat.ComputeFstat(
tref=Writer.tref,
detectors="H1",
sftfilepattern="{}/*{}*sft".format(Writer.outdir, Writer.label),
SSBprec=lalpulsar.SSBPREC_RELATIVISTIC,
)
FS = search_H1.get_fullycoherent_twoF(
Writer.tstart,
Writer.tend,
Writer.F0,
Writer.F1,
Writer.F2,
Writer.Alpha,
Writer.Delta,
)
self.assertTrue(np.abs(predicted_FS - FS) / FS < 0.3)
def test_run_computefstatistic_single_point_no_noise(self):
predicted_FS = self.Writer.predict_fstat(assumeSqrtSX=1)
search = pyfstat.ComputeFstat(
tref=self.Writer.tref,
assumeSqrtSX=1,
sftfilepattern=self.Writer.sftfilepath,
search_ranges=self.search_ranges,
)
FS = search.get_fullycoherent_twoF(
F0=self.Writer.F0,
F1=self.Writer.F1,
F2=self.Writer.F2,
Alpha=self.Writer.Alpha,
Delta=self.Writer.Delta,
)
self.assertTrue(np.abs(predicted_FS - FS) / FS < 0.3)
def test_run_computefstatistic_single_point_injectSqrtSX(self):
# not using any SFTs
search = pyfstat.ComputeFstat(
tref=self.tref,
minStartTime=self.tstart,
maxStartTime=self.tstart + self.duration,
detectors=self.detectors,
injectSqrtSX=self.sqrtSX,
minCoverFreq=self.F0 - 0.1,
maxCoverFreq=self.F0 + 0.1,
)
FS = search.get_fullycoherent_twoF(
F0=self.F0,
F1=self.F1,
F2=self.F2,
Alpha=self.Alpha,
Delta=self.Delta,
)
self.assertTrue(FS > 0.0)
data.make_data()
# The predicted twoF, given by lalapps_predictFstat can be accessed by
twoF = data.predict_fstat()
print("Predicted twoF value: {}\n".format(twoF))
# Create a search object for each of the possible SFT combinations
# (H1 only, L1 only, H1 + L1).
ifo_constraints = ["L1", "H1", None]
compute_fstat_per_ifo = [
pyfstat.ComputeFstat(
sftfilepattern=os.path.join(
data.outdir,
(f"{ifo_constraint[0]}*.sft"
if ifo_constraint is not None else "*.sft"),
),
tref=data.tref,
binary=phase_parameters.get("asini", 0),
minCoverFreq=-0.5,
maxCoverFreq=-0.5,
) for ifo_constraint in ifo_constraints
]
for ind, compute_f_stat in enumerate(compute_fstat_per_ifo):
compute_f_stat.plot_twoF_cumulative(
label=label + (f"_{ifo_constraints[ind]}" if ind < 2 else "_H1L1"),
outdir=outdir,
savefig=True,
CFS_input=phase_parameters,
PFS_input=PFS_input,
custom_ax_kwargs={
def test_cumulative_twoF(self):
Nsft = 100
# not using any SFTs on disk
search = pyfstat.ComputeFstat(
tref=self.tref,
minStartTime=self.tstart,
maxStartTime=self.tstart + Nsft * self.Tsft,
detectors=self.detectors,
injectSqrtSX=self.sqrtSX,
injectSources=default_signal_params,
minCoverFreq=self.F0 - 0.1,
maxCoverFreq=self.F0 + 0.1,
)
start_time, taus, twoF_cumulative = search.calculate_twoF_cumulative(
self.Writer.F0,
self.Writer.F1,
self.Writer.F2,
self.Writer.Alpha,
self.Writer.Delta,
num_segments=Nsft + 1,
)
twoF = search.get_fullycoherent_detstat(
F0=self.Writer.F0,
F1=self.Writer.F1,
F2=self.Writer.F2,
Alpha=self.Writer.Alpha,
Delta=self.Writer.Delta,
tstart=self.Writer.tstart,
tend=self.Writer.tstart + taus[-1],
)
reldiff = np.abs(twoF_cumulative[-1] - twoF) / twoF
print("2F from get_fullycoherent_detstat() is {:.4f}"
" while last value from calculate_twoF_cumulative() is {:.4f};"
" relative difference: {:.2f}".format(twoF, twoF_cumulative[-1],
100 * reldiff))
self.assertTrue(reldiff < 0.1)
idx = int(Nsft / 2)
partial_2F_expected = (taus[idx] / taus[-1]) * twoF
reldiff = (np.abs(twoF_cumulative[idx] - partial_2F_expected) /
partial_2F_expected)
print("Middle 2F value from calculate_twoF_cumulative() is {:.4f}"
" while from duration ratio we'd expect {:.4f}*{:.4f}={:.4f};"
" relative difference: {:.2f}%".format(
twoF_cumulative[idx],
taus[idx] / taus[-1],
twoF,
partial_2F_expected,
100 * reldiff,
))
self.assertTrue(reldiff < 0.1)
_, _, pfs, pfs_sigma = search.predict_twoF_cumulative(
F0=self.Writer.F0,
Alpha=self.Writer.Alpha,
Delta=self.Writer.Delta,
h0=self.Writer.h0,
cosi=self.Writer.cosi,
psi=self.Writer.psi,
tstart=self.tstart,
tend=self.tstart + Nsft * self.Tsft,
IFOs=self.detectors,
assumeSqrtSX=self.sqrtSX,
num_segments=3, # this is slow, so only do start,mid,end
)
reldiffmid = 100 * (twoF_cumulative[idx] - pfs[1]) / pfs[1]
reldiffend = 100 * (twoF_cumulative[-1] - pfs[2]) / pfs[2]
print("Predicted 2F values from predict_twoF_cumulative() are"
" {:.4f}+-{:.4f}(+-{:.2f}%) at midpoint of data"
" and {:.4f}+-{:.4f}(+-{:.2f}%) after full data,"
" , relative differences: {:.2f}% and {:.2f}%".format(
pfs[1],
pfs_sigma[1],
100 * pfs_sigma[1] / pfs[1],
pfs[2],
pfs_sigma[2],
100 * pfs_sigma[2] / pfs[2],
reldiffmid,
reldiffend,
))
self.assertTrue(reldiffmid < 0.25)
self.assertTrue(reldiffend < 0.25)
def test_get_fully_coherent_BSGL(self):
# first pure noise, expect log10BSGL<0
search_H1L1_noBSGL = pyfstat.ComputeFstat(
tref=self.tref,
minStartTime=self.tstart,
maxStartTime=self.tstart + self.duration,
detectors="H1,L1",
injectSqrtSX=np.repeat(self.sqrtSX, 2),
minCoverFreq=self.F0 - 0.1,
maxCoverFreq=self.F0 + 0.1,
BSGL=False,
singleFstats=True,
randSeed=self.randSeed,
)
twoF = search_H1L1_noBSGL.get_fullycoherent_detstat(
F0=self.F0,
F1=self.F1,
F2=self.F2,
Alpha=self.Alpha,
Delta=self.Delta,
)
twoFX = search_H1L1_noBSGL.get_fullycoherent_single_IFO_twoFs()
search_H1L1_BSGL = pyfstat.ComputeFstat(
tref=self.tref,
minStartTime=self.tstart,
maxStartTime=self.tstart + self.duration,
detectors="H1,L1",
injectSqrtSX=np.repeat(self.sqrtSX, 2),
minCoverFreq=self.F0 - 0.1,
maxCoverFreq=self.F0 + 0.1,
BSGL=True,
randSeed=self.randSeed,
)
log10BSGL = search_H1L1_BSGL.get_fullycoherent_detstat(
F0=self.F0,
F1=self.F1,
F2=self.F2,
Alpha=self.Alpha,
Delta=self.Delta,
)
self.assertTrue(log10BSGL < 0)
self.assertTrue(log10BSGL == lalpulsar.ComputeBSGL(
twoF, twoFX, search_H1L1_BSGL.BSGLSetup))
# now with an added signal, expect log10BSGL>0
search_H1L1_noBSGL = pyfstat.ComputeFstat(
tref=self.tref,
minStartTime=self.tstart,
maxStartTime=self.tstart + self.duration,
detectors="H1,L1",
injectSqrtSX=np.repeat(self.sqrtSX, 2),
injectSources=
"{{Alpha={:g}; Delta={:g}; h0={:g}; cosi={:g}; Freq={:g}; f1dot={:g}; f2dot={:g}; refTime={:d};}}"
.format(
self.Alpha,
self.Delta,
self.h0,
self.cosi,
self.F0,
self.F1,
self.F2,
self.tref,
),
minCoverFreq=self.F0 - 0.1,
maxCoverFreq=self.F0 + 0.1,
BSGL=False,
singleFstats=True,
randSeed=self.randSeed,
)
twoF = search_H1L1_noBSGL.get_fullycoherent_detstat(
F0=self.F0,
F1=self.F1,
F2=self.F2,
Alpha=self.Alpha,
Delta=self.Delta,
)
twoFX = search_H1L1_noBSGL.get_fullycoherent_single_IFO_twoFs()
search_H1L1_BSGL = pyfstat.ComputeFstat(
tref=self.tref,
minStartTime=self.tstart,
maxStartTime=self.tstart + self.duration,
detectors="H1,L1",
injectSqrtSX=np.repeat(self.sqrtSX, 2),
injectSources=
"{{Alpha={:g}; Delta={:g}; h0={:g}; cosi={:g}; Freq={:g}; f1dot={:g}; f2dot={:g}; refTime={:d};}}"
.format(
self.Alpha,
self.Delta,
self.h0,
self.cosi,
self.F0,
self.F1,
self.F2,
self.tref,
),
minCoverFreq=self.F0 - 0.1,
maxCoverFreq=self.F0 + 0.1,
BSGL=True,
randSeed=self.randSeed,
)
log10BSGL = search_H1L1_BSGL.get_fullycoherent_detstat(
F0=self.F0,
F1=self.F1,
F2=self.F2,
Alpha=self.Alpha,
Delta=self.Delta,
)
self.assertTrue(log10BSGL > 0)
self.assertTrue(log10BSGL == lalpulsar.ComputeBSGL(
twoF, twoFX, search_H1L1_BSGL.BSGLSetup))
detectors=IFO,
randSeed=randSeed,
SFTWindowType="tukey",
SFTWindowBeta=0.001,
)
sftfilepattern = os.path.join(
noise_and_signal_writer.outdir,
"*{}*{}*sft".format(duration_Tsft, noise_and_signal_writer.label),
)
noise_and_signal_writer.make_data()
# compute Fstat
coherent_search = pyfstat.ComputeFstat(
tref=noise_and_signal_writer.tref,
sftfilepattern=sftfilepattern,
minCoverFreq=-0.5,
maxCoverFreq=-0.5,
)
FS_1 = coherent_search.get_fullycoherent_twoF(
noise_and_signal_writer.F0,
noise_and_signal_writer.F1,
noise_and_signal_writer.F2,
noise_and_signal_writer.Alpha,
noise_and_signal_writer.Delta,
)
# create noise sfts
# window options are again optional for this step
noise_writer = pyfstat.Writer(
label="test_noiseSFTs_only_noise",
outdir=outdir,
r"$e$",
]
grid_arrays = np.meshgrid(*[
signal_parameters[key] *
(1 + 0.01 *
np.arange(-half_points_per_dimension, half_points_per_dimension + 1, 1))
for key in search_keys
])
grid_points = np.hstack(
[grid_arrays[i].reshape(-1, 1) for i in range(len(grid_arrays))])
compute_f_stat = pyfstat.ComputeFstat(
sftfilepattern=os.path.join(outdir, "*simulated_signal*sft"),
tref=signal_parameters["tref"],
binary=True,
minCoverFreq=-0.5,
maxCoverFreq=-0.5,
)
twoF_values = np.zeros(grid_points.shape[0])
for ind in range(grid_points.shape[0]):
point = grid_points[ind]
twoF_values[ind] = compute_f_stat.get_fullycoherent_twoF(
F0=signal_parameters["F0"],
F1=signal_parameters["F1"],
F2=signal_parameters["F2"],
Alpha=signal_parameters["Alpha"],
Delta=signal_parameters["Delta"],
period=point[0],
asini=point[1],
tp=point[2],