From a0eee809ebe8a4f5daec839d39d2f1619f997241 Mon Sep 17 00:00:00 2001
From: Gregory Ashton <gregory.ashton@ligo.org>
Date: Fri, 29 Sep 2017 18:16:27 +0200
Subject: [PATCH] Renaming functions for clarity of twoF and fix issue of F ->
likelihood
Fixes #4 .
---
pyfstat/core.py | 28 ++++++++----------------
pyfstat/grid_based_searches.py | 6 +++---
pyfstat/mcmc_based_searches.py | 26 +++++++++++------------
tests.py | 39 ++++++++++++----------------------
4 files changed, 38 insertions(+), 61 deletions(-)
diff --git a/pyfstat/core.py b/pyfstat/core.py
index 88bac00..0ff84cb 100755
--- a/pyfstat/core.py
+++ b/pyfstat/core.py
@@ -576,19 +576,9 @@ class ComputeFstat(BaseSearchClass):
self.windowRange.tauBand = 0
self.windowRange.dtau = 1
- def compute_fullycoherent_det_stat_single_point(
- self, F0, F1, F2, Alpha, Delta, asini=None, period=None, ecc=None,
- tp=None, argp=None):
- """ Compute the fully-coherent det. statistic at a single point """
-
- return self.run_computefstatistic_single_point(
- self.minStartTime, self.maxStartTime, F0, F1, F2, Alpha, Delta,
- asini, period, ecc, tp, argp)
-
- def run_computefstatistic_single_point(self, tstart, tend, F0, F1,
- F2, Alpha, Delta, asini=None,
- period=None, ecc=None, tp=None,
- argp=None):
+ def get_fullycoherent_twoF(self, tstart, tend, F0, F1, F2, Alpha, Delta,
+ asini=None, period=None, ecc=None, tp=None,
+ argp=None):
""" Returns twoF or ln(BSGL) fully-coherently at a single point """
self.PulsarDopplerParams.fkdot = np.array([F0, F1, F2, 0, 0, 0, 0])
@@ -684,7 +674,7 @@ class ComputeFstat(BaseSearchClass):
self.transient = True
self.init_computefstatistic_single_point()
for tau in taus:
- twoFs.append(self.run_computefstatistic_single_point(
+ twoFs.append(self.get_fullycoherent_twoF(
tstart=tstart, tend=tstart+tau, F0=F0, F1=F1, F2=F2,
Alpha=Alpha, Delta=Delta, asini=asini, period=period, ecc=ecc,
tp=tp, argp=argp))
@@ -875,7 +865,7 @@ class SemiCoherentSearch(ComputeFstat):
'Semi-coherent end time {} after last SFT timestamp {}'
.format(self.tboundaries[-1], self.SFT_timestamps[-1]))
- def run_semi_coherent_computefstatistic_single_point(
+ def get_semicoherent_twoF(
self, F0, F1, F2, Alpha, Delta, asini=None,
period=None, ecc=None, tp=None, argp=None,
record_segments=False):
@@ -992,7 +982,7 @@ class SemiCoherentGlitchSearch(ComputeFstat):
self.binary = False
self.init_computefstatistic_single_point()
- def compute_nglitch_fstat(self, F0, F1, F2, Alpha, Delta, *args):
+ def get_semicoherent_nglitch_twoF(self, F0, F1, F2, Alpha, Delta, *args):
""" Returns the semi-coherent glitch summed twoF """
args = list(args)
@@ -1013,7 +1003,7 @@ class SemiCoherentGlitchSearch(ComputeFstat):
for i, theta_i_at_tref in enumerate(thetas):
ts, te = tboundaries[i], tboundaries[i+1]
- twoFVal = self.run_computefstatistic_single_point(
+ twoFVal = self.get_fullycoherent_twoF(
ts, te, theta_i_at_tref[1], theta_i_at_tref[2],
theta_i_at_tref[3], Alpha, Delta)
twoFSum += twoFVal
@@ -1039,14 +1029,14 @@ class SemiCoherentGlitchSearch(ComputeFstat):
theta_post_glitch = self._shift_coefficients(
theta_post_glitch_at_glitch, tref - tglitch)
- twoFsegA = self.run_computefstatistic_single_point(
+ twoFsegA = self.get_fullycoherent_twoF(
self.minStartTime, tglitch, theta[0], theta[1], theta[2], Alpha,
Delta)
if tglitch == self.maxStartTime:
return twoFsegA
- twoFsegB = self.run_computefstatistic_single_point(
+ twoFsegB = self.get_fullycoherent_twoF(
tglitch, self.maxStartTime, theta_post_glitch[0],
theta_post_glitch[1], theta_post_glitch[2], Alpha,
Delta)
diff --git a/pyfstat/grid_based_searches.py b/pyfstat/grid_based_searches.py
index 99e16e8..42c84fa 100644
--- a/pyfstat/grid_based_searches.py
+++ b/pyfstat/grid_based_searches.py
@@ -60,7 +60,7 @@ class GridSearch(BaseSearchClass):
BSGL=self.BSGL, SSBprec=self.SSBprec,
injectSources=self.injectSources,
assumeSqrtSX=self.assumeSqrtSX)
- self.search.get_det_stat = self.search.run_computefstatistic_single_point
+ self.search.get_det_stat = self.search.get_fullycoherent_twoF
else:
self.search = SemiCoherentSearch(
label=self.label, outdir=self.outdir, tref=self.tref,
@@ -71,7 +71,7 @@ class GridSearch(BaseSearchClass):
injectSources=self.injectSources)
def cut_out_tstart_tend(*vals):
- return self.search.run_semi_coherent_computefstatistic_single_point(*vals[2:])
+ return self.search.get_semicoherent_twoF(*vals[2:])
self.search.get_det_stat = cut_out_tstart_tend
def get_array_from_tuple(self, x):
@@ -397,7 +397,7 @@ class FrequencySlidingWindow(GridSearch):
BSGL=self.BSGL, SSBprec=self.SSBprec,
injectSources=self.injectSources)
self.search.get_det_stat = (
- self.search.run_computefstatistic_single_point)
+ self.search.get_fullycoherent_twoF)
def get_input_data_array(self):
arrays = []
diff --git a/pyfstat/mcmc_based_searches.py b/pyfstat/mcmc_based_searches.py
index cc3ebaf..9e12524 100644
--- a/pyfstat/mcmc_based_searches.py
+++ b/pyfstat/mcmc_based_searches.py
@@ -160,9 +160,9 @@ class MCMCSearch(core.BaseSearchClass):
def logl(self, theta, search):
for j, theta_i in enumerate(self.theta_idxs):
self.fixed_theta[theta_i] = theta[j]
- FS = search.compute_fullycoherent_det_stat_single_point(
- *self.fixed_theta)
- return FS + self.likelihoodcoef
+ twoF = search.get_fullycoherent_twoF(
+ self.minStartTime, self.maxStartTime, *self.fixed_theta)
+ return twoF/2.0 + self.likelihoodcoef
def _unpack_input_theta(self):
full_theta_keys = ['F0', 'F1', 'F2', 'Alpha', 'Delta']
@@ -1244,11 +1244,11 @@ class MCMCSearch(core.BaseSearchClass):
"""
if any(np.isposinf(self.lnlikes)):
- logging.info('twoF values contain positive infinite values')
+ logging.info('lnlike values contain positive infinite values')
if any(np.isneginf(self.lnlikes)):
- logging.info('twoF values contain negative infinite values')
+ logging.info('lnlike values contain negative infinite values')
if any(np.isnan(self.lnlikes)):
- logging.info('twoF values contain nan')
+ logging.info('lnlike values contain nan')
idxs = np.isfinite(self.lnlikes)
jmax = np.nanargmax(self.lnlikes[idxs])
maxlogl = self.lnlikes[jmax]
@@ -1262,7 +1262,7 @@ class MCMCSearch(core.BaseSearchClass):
maxtwoF = self.logl(p, self.search)
self.search.BSGL = self.BSGL
else:
- maxtwoF = maxlogl - self.likelihoodcoef
+ maxtwoF = (maxlogl - self.likelihoodcoef)*2
repeats = []
for i, k in enumerate(self.theta_keys):
@@ -1633,8 +1633,8 @@ class MCMCGlitchSearch(MCMCSearch):
for j, theta_i in enumerate(self.theta_idxs):
self.fixed_theta[theta_i] = theta[j]
- FS = search.compute_nglitch_fstat(*self.fixed_theta)
- return FS + self.likelihoodcoef
+ twoF = search.get_semicoherent_nglitch_twoF(*self.fixed_theta)
+ return twoF/2.0 + self.likelihoodcoef
def _unpack_input_theta(self):
glitch_keys = ['delta_F0', 'delta_F1', 'tglitch']
@@ -1839,9 +1839,9 @@ class MCMCSemiCoherentSearch(MCMCSearch):
def logl(self, theta, search):
for j, theta_i in enumerate(self.theta_idxs):
self.fixed_theta[theta_i] = theta[j]
- FS = search.run_semi_coherent_computefstatistic_single_point(
+ twoF = search.get_semicoherent_twoF(
*self.fixed_theta)
- return FS + self.likelihoodcoef
+ return twoF/2.0 + self.likelihoodcoef
class MCMCFollowUpSearch(MCMCSemiCoherentSearch):
@@ -2152,8 +2152,8 @@ class MCMCTransientSearch(MCMCSearch):
in_theta[1] = in_theta[0] + in_theta[1]
if in_theta[1] > self.maxStartTime:
return -np.inf
- FS = search.run_computefstatistic_single_point(*in_theta)
- return FS + self.likelihoodcoef
+ twoF = search.get_fullycoherent_twoF(*in_theta)
+ return twoF/2.0 + self.likelihoodcoef
def _unpack_input_theta(self):
full_theta_keys = ['transient_tstart',
diff --git a/tests.py b/tests.py
index c6408bb..4ece9d9 100644
--- a/tests.py
+++ b/tests.py
@@ -97,13 +97,9 @@ class TestComputeFstat(Test):
search = pyfstat.ComputeFstat(
tref=Writer.tref,
sftfilepattern='{}/*{}*sft'.format(Writer.outdir, Writer.label))
- FS = search.run_computefstatistic_single_point(Writer.tstart,
- Writer.tend,
- Writer.F0,
- Writer.F1,
- Writer.F2,
- Writer.Alpha,
- Writer.Delta)
+ FS = search.get_fullycoherent_twoF(
+ Writer.tstart, Writer.tend, Writer.F0, Writer.F1, Writer.F2,
+ Writer.Alpha, Writer.Delta)
print predicted_FS, FS
self.assertTrue(np.abs(predicted_FS-FS)/FS < 0.2)
@@ -116,13 +112,9 @@ class TestComputeFstat(Test):
search = pyfstat.ComputeFstat(
tref=Writer.tref, assumeSqrtSX=1,
sftfilepattern='{}/*{}*sft'.format(Writer.outdir, Writer.label))
- FS = search.run_computefstatistic_single_point(Writer.tstart,
- Writer.tend,
- Writer.F0,
- Writer.F1,
- Writer.F2,
- Writer.Alpha,
- Writer.Delta)
+ FS = search.get_fullycoherent_twoF(
+ Writer.tstart, Writer.tend, Writer.F0, Writer.F1, Writer.F2,
+ Writer.Alpha, Writer.Delta)
print predicted_FS, FS
self.assertTrue(np.abs(predicted_FS-FS)/FS < 0.2)
@@ -137,13 +129,9 @@ class TestComputeFstat(Test):
minCoverFreq=28, maxCoverFreq=32, minStartTime=Writer.tstart,
maxStartTime=Writer.tstart+Writer.duration,
detectors=Writer.detectors)
- FS = search.run_computefstatistic_single_point(Writer.tstart,
- Writer.tend,
- Writer.F0,
- Writer.F1,
- Writer.F2,
- Writer.Alpha,
- Writer.Delta)
+ FS = 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()
print predicted_FS, FS
@@ -153,7 +141,7 @@ class TestComputeFstat(Test):
class TestSemiCoherentGlitchSearch(Test):
label = "TestSemiCoherentGlitchSearch"
- def test_compute_nglitch_fstat(self):
+ def test_get_semicoherent_nglitch_twoF(self):
duration = 10*86400
dtglitch = .5*duration
delta_F0 = 0
@@ -171,10 +159,9 @@ class TestSemiCoherentGlitchSearch(Test):
tref=Writer.tref, minStartTime=Writer.tstart,
maxStartTime=Writer.tend, nglitch=1)
- FS = search.compute_nglitch_fstat(Writer.F0, Writer.F1, Writer.F2,
- Writer.Alpha, Writer.Delta,
- Writer.delta_F0, Writer.delta_F1,
- search.minStartTime+dtglitch)
+ FS = search.get_semicoherent_nglitch_twoF(
+ Writer.F0, Writer.F1, Writer.F2, Writer.Alpha, Writer.Delta,
+ Writer.delta_F0, Writer.delta_F1, search.minStartTime+dtglitch)
# Compute the predicted semi-coherent glitch Fstat
minStartTime = Writer.tstart
--
GitLab