Skip to content
GitLab
Projects
Groups
Snippets
/
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Menu
Open sidebar
Gregory Ashton
PyFstat
Commits
ce6f4793
Commit
ce6f4793
authored
Mar 23, 2017
by
Gregory Ashton
Browse files
Improvements to glitch section of the paper
parent
0abdd7d2
Changes
7
Hide whitespace changes
Inline
Sidebyside
Paper/Examples/single_glitch.py
View file @
ce6f4793
import
pyfstat
import
numpy
as
np
import
matplotlib.pyplot
as
plt
import
matplotlib
sqrtSX
=
1e22
tstart
=
1000000000
...
...
@@ 26,7 +27,8 @@ DeltaF0 = VF0 * dF0
DeltaF1
=
VF1
*
dF1
# Next, taking the same signal parameters, we include a glitch half way through
dtglitch
=
duration
/
2.0
R
=
0.5
dtglitch
=
R
*
duration
delta_F0
=
0.25
*
DeltaF0
delta_F1
=

0.1
*
DeltaF1
...
...
@@ 35,6 +37,7 @@ glitch_data = pyfstat.Writer(
F1
=
F1
,
F2
=
F2
,
duration
=
duration
,
Alpha
=
Alpha
,
Delta
=
Delta
,
h0
=
h0
,
sqrtSX
=
sqrtSX
,
dtglitch
=
dtglitch
,
delta_F0
=
delta_F0
,
delta_F1
=
delta_F1
)
glitch_data
.
make_data
()
FCtwoFPM
=
glitch_data
.
predict_fstat
()
F0s
=
[
F0

DeltaF0
/
2.
,
F0
+
DeltaF0
/
2.
,
1
*
dF0
]
F1s
=
[
F1

DeltaF1
/
2.
,
F1
+
DeltaF1
/
2.
,
1
*
dF1
]
...
...
@@ 45,7 +48,12 @@ search = pyfstat.GridSearch(
'single_glitch_F0F1_grid'
,
'data'
,
'data/*single_glitch*sft'
,
F0s
,
F1s
,
F2s
,
Alphas
,
Deltas
,
tref
,
tstart
,
tend
)
search
.
run
()
search
.
plot_2D
(
'F0'
,
'F1'
)
ax
=
search
.
plot_2D
(
'F0'
,
'F1'
,
save
=
False
)
ax
.
xaxis
.
set_major_locator
(
matplotlib
.
ticker
.
MaxNLocator
(
6
))
plt
.
tight_layout
()
plt
.
savefig
(
'data/single_glitch_F0F1_grid_2D.png'
,
dpi
=
500
)
FCtwoF
=
search
.
get_max_twoF
()[
'twoF'
]
theta_prior
=
{
'F0'
:
{
'type'
:
'unif'
,
'lower'
:
F0

DeltaF0
/
2.
,
'upper'
:
F0
+
DeltaF0
/
2
},
...
...
@@ 55,21 +63,6 @@ theta_prior = {'F0': {'type': 'unif', 'lower': F0DeltaF0/2.,
'Alpha'
:
Alpha
,
'Delta'
:
Delta
}
ntemps
=
3
log10temperature_min
=

0.05
nwalkers
=
100
nsteps
=
[
500
,
500
]
mcmc
=
pyfstat
.
MCMCSearch
(
'single_glitch'
,
'data'
,
sftfilepath
=
'data/*_single_glitch*.sft'
,
theta_prior
=
theta_prior
,
tref
=
tref
,
minStartTime
=
tstart
,
maxStartTime
=
tend
,
nsteps
=
nsteps
,
nwalkers
=
nwalkers
,
ntemps
=
ntemps
,
log10temperature_min
=
log10temperature_min
)
mcmc
.
run
()
mcmc
.
plot_corner
(
figsize
=
(
3.2
,
3.2
))
mcmc
.
print_summary
()
theta_prior
=
{
'F0'
:
{
'type'
:
'unif'
,
'lower'
:
F0

DeltaF0
/
2.
,
'upper'
:
F0
+
DeltaF0
/
2
},
...
...
@@ 80,8 +73,8 @@ theta_prior = {'F0': {'type': 'unif', 'lower': F0DeltaF0/2.,
'Delta'
:
Delta
,
'tglitch'
:
{
'type'
:
'unif'
,
'lower'
:
tstart
+
0.1
*
duration
,
'upper'
:
tend

0.1
*
duration
},
'delta_F0'
:
{
'type'
:
'halfnorm'
,
'loc'
:
0
,
'scale'
:
Delta
F0
},
'delta_F1'
:
{
'type'
:
'norm'
,
'loc'
:
0
,
'scale'
:
Delta
F1
},
'delta_F0'
:
{
'type'
:
'halfnorm'
,
'loc'
:
0
,
'scale'
:
1e7
*
F0
},
'delta_F1'
:
{
'type'
:
'norm'
,
'loc'
:
0
,
'scale'
:
abs
(
1e3
*
F1
)
},
}
ntemps
=
3
log10temperature_min
=

0.1
...
...
@@ 93,7 +86,30 @@ glitch_mcmc = pyfstat.MCMCGlitchSearch(
tref
=
tref
,
minStartTime
=
tstart
,
maxStartTime
=
tend
,
nsteps
=
nsteps
,
nwalkers
=
nwalkers
,
ntemps
=
ntemps
,
log10temperature_min
=
log10temperature_min
)
glitch_mcmc
.
write_prior_table
()
glitch_mcmc
.
run
()
glitch_mcmc
.
plot_corner
(
figsize
=
(
6
,
6
))
glitch_mcmc
.
print_summary
()
GlitchtwoF
=
glitch_mcmc
.
get_max_twoF
()[
1
]
from
latex_macro_generator
import
write_to_macro
write_to_macro
(
'SingleGlitchTspan'
,
'{:1.1f}'
.
format
(
duration
/
86400
),
'../macros.tex'
)
write_to_macro
(
'SingleGlitchR'
,
'{:1.1f}'
.
format
(
R
),
'../macros.tex'
)
write_to_macro
(
'SingleGlitchDepth'
,
'{}'
.
format
(
pyfstat
.
texify_float
(
sqrtSX
/
h0
)),
'../macros.tex'
)
write_to_macro
(
'SingleGlitchF0'
,
'{}'
.
format
(
F0
),
'../macros.tex'
)
write_to_macro
(
'SingleGlitchF1'
,
'{}'
.
format
(
F1
),
'../macros.tex'
)
write_to_macro
(
'SingleGlitchdeltaF0'
,
'{}'
.
format
(
pyfstat
.
texify_float
(
delta_F0
)),
'../macros.tex'
)
write_to_macro
(
'SingleGlitchdeltaF1'
,
'{}'
.
format
(
pyfstat
.
texify_float
(
delta_F1
)),
'../macros.tex'
)
write_to_macro
(
'SingleGlitchFCtwoFPM'
,
'{:1.1f}'
.
format
(
FCtwoFPM
),
'../macros.tex'
)
write_to_macro
(
'SingleGlitchFCtwoF'
,
'{:1.1f}'
.
format
(
FCtwoF
),
'../macros.tex'
)
write_to_macro
(
'SingleGlitch_FCMismatch'
,
'{:1.1f}'
.
format
((
FCtwoFPM

FCtwoF
)
/
FCtwoFPM
),
'../macros.tex'
)
write_to_macro
(
'SingleGlitchGlitchtwoF'
,
'{:1.1f}'
.
format
(
GlitchtwoF
),
'../macros.tex'
)
Paper/SingleGlitchMCNoiseOnly/generate_data.py
View file @
ce6f4793
...
...
@@ 59,7 +59,7 @@ glitch_data.make_data()
startTime
=
time
.
time
()
theta_prior
=
{
'F0'
:
{
'type'
:
'unif'
,
'lower'
:
F0

DeltaF0
/
2.
,
theta_prior
=
{
'F0'
:
{
'type'
:
'unif'
,
'lower'
:
F0

DeltaF0
/
2.
,
# PROBLEM
'upper'
:
F0
+
DeltaF0
/
2
},
'F1'
:
{
'type'
:
'unif'
,
'lower'
:
F1

DeltaF1
/
2.
,
'upper'
:
F1
+
DeltaF1
/
2
},
...
...
Paper/definitions.tex
View file @
ce6f4793
\newcommand
{
\fdot
}{
\dot
{
f
}}
\newcommand
{
\F
}{{
\mathcal
{
F
}}}
\newcommand
{
\twoFhat
}{
\widehat
{
2
\F
}}
\newcommand
{
\twoFtilde
}{
\widetilde
{
2
\F
}}
\newcommand
{
\A
}{
\boldsymbol
{
\mathcal
{
A
}}}
\newcommand
{
\blambda
}{
\boldsymbol
{
\mathbf
{
\lambda
}}}
...
...
@@ 7,7 +8,7 @@
\newcommand
{
\tglitch
}{
t
_{
\rm
glitch
}}
\newcommand
{
\tstart
}{
t
_{
\rm
start
}}
\newcommand
{
\tend
}{
t
_{
\rm
end
}}
\newcommand
{
\Nglitches
}{
N
_{
\rm
g
litches
}}
\newcommand
{
\Nglitches
}{
N
_{
\rm
g
}}
\newcommand
{
\Tspan
}{
T
_{
\rm
span
}}
\newcommand
{
\Tcoh
}{
T
_{
\rm
coh
}}
\newcommand
{
\tref
}{
t
_{
\rm
ref
}}
...
...
Paper/macros.tex
View file @
ce6f4793
...
...
@@ 14,3 +14,14 @@
\def\BasicExamplenprod
{
50.0
}
\def\DirectedMCNoiseN
{
1.0
{
\times
}
10
^{
4
}}
\def\DirectedMCNoiseOnlyMaximum
{
52.4
}
\def\SingleGlitchDepth
{
10.0
}
\def\SingleGlitchFCMismatch
{
0.7
}
\def\SingleGlitchFCtwoF
{
718.5
}
\def\SingleGlitchFCtwoFPM
{
2645.7
}
\def\SingleGlitchFone
{
1e10
}
\def\SingleGlitchFzero
{
30.0
}
\def\SingleGlitchGlitchtwoF
{
2622.1
}
\def\SingleGlitchR
{
0.5
}
\def\SingleGlitchTspan
{
100.0
}
\def\SingleGlitchdeltaFone
{$

2
.
9
{
\times
}
10
^{

13
}$}
\def\SingleGlitchdeltaFzero
{$
3
.
2
{
\times
}
10
^{

6
}$}
Paper/paper_cw_mcmc.tex
View file @
ce6f4793
...
...
@@ 835,7 +835,7 @@ of parallel tempering (see Sec.~\ref{sec_parallel_tempering}). This was intenion
not used here to highlight the utility of the convergence statistic.
\section
{
F
ollowup
}
\section
{
Zoom f
ollowup
}
\label
{
sec
_
follow
_
up
}
Incoherent detection statistics trade significance (the height of the peak) for
...
...
@@ 964,11 +964,12 @@ possible for this to occur during an ordinary MCMC simulation (with $\Tcoh$
fixed at
$
\Tspan
$
), it would take substantially longer to converge as the
chains explore the other `noise peaks' in the data.
\section
{
Monte Carlo studies
}
\subsection
{
MonteCarlo studies
}
\label
{
sec
_
MCS
_
zoom
}
In order to understand how well the MCMC followup method works, we will test
its ability to succesfully identify simulated signals in Gaussian noise. This will be
done in a Monte
Carlo study, with independent random realisations of the
done in a Monte

Carlo study, with independent random realisations of the
Guassian noise, amplitude, and Doppler parameters in suitable ranges. Such a
method is analagous to the studies performed in
\citet
{
shaltev2013
}
, except
that we present results as a function of the fixed injected signal depth,
...
...
@@ 996,7 +997,7 @@ sense that signals are `lost' during the followup due simply to the fact that
they are not sufficiently strong to rise above the noise.
\subsection
{
Followup candidates from a directed search
}
\subs
ubs
ection
{
Followup candidates from a directed search
}
\label
{
sec
_
directed
_
follow
_
up
}
In a directed search, the sky location parameters
$
\alpha
$
and
$
\delta
$
are
...
...
@@ 1074,7 +1075,7 @@ Table~\ref{tab_directed_MC_follow_up}.}
\end{figure}
\subsection
{
Followup candidates from an allsky search
}
\subs
ubs
ection
{
Followup candidates from an allsky search
}
\label
{
sec
_
all
_
sky
_
follow
_
up
}
We now test the followup method when applied to candidates from an allsky
...
...
@@ 1139,23 +1140,22 @@ Table~\ref{tab_directed_MC_follow_up}.}
\label
{
fig
_
allsky
_
MC
_
follow
_
up
}
\end{figure}
\section
{
Alternative waveform models
}
\section
{
Alternative waveform models: transients
}
\label
{
sec
_
transients
}
In a grided search, the template bank is constructed to ensure that a canonical
CW signal (i.e. when it lasts much longer than the observation span and has a
phase evolution welldescribed by a Equation~
\eqref
{
eqn
_
phi
}
) will be
recovered with a fixed maximum loss of detection statistic; this loss can be
described as the `templatebank mismatch'. In addition to this mismatch, CW
searches may experience a mismatch if the waveform model differs from the
matchedfilter template. There are of course an unlimited number of ways this
may manifest given our ignorance of neutron stars, but from studying pulsars
three obvious mechanisms present themselves: transient, glitching, and noisy
waveforms. In the following sections we will discuss the first two of these, we
discussed the effect of random jitters in the phase evolution (noisy waveforms)
in
\citet
{
ashton2015
}
and concluded it was unlikely to be of immediate concern.
\subsection
{
Transients
}
\label
{
sec
_
transients
}
phase evolution welldescribed by a Equation~
\eqref
{
eqn
_
phi
}
) will be recovered
with a fixed maximum loss of detection statistic; this loss can be described as
the `templatebank mismatch'. In addition to this mismatch, CW searches may
experience a mismatch if the waveform model differs from the matchedfilter
template. There are of course an unlimited number of ways this may manifest
given our ignorance of neutron stars, but from studying pulsars three obvious
mechanisms present themselves: transient, glitching, and noisy waveforms. In
the this section we will discuss the first of these, then in
Section~
\ref
{
sec
_
glitches
}
the second, we discussed the effect of random
jitters in the phase evolution (noisy waveforms) in
\citet
{
ashton2015
}
and
concluded it was unlikely to be of immediate concern.
The term
\emph
{
transientCWs
}
refers to periodic gravitational wave signals
with a duration
$
\mathcal
{
O
}
(
\textrm
{
hours

weeks
}
)
$
which have a
...
...
@@ 1237,85 +1237,180 @@ a simulated transient signal and Gaussian noise.}
\
sub
section
{
Glitches
}
\section
{
Alternative waveform models: Glitchrobust followup search
}
\label
{
sec
_
glitches
}
Observations of radio pulsars show that occasionally neutron stars undergo
sudden glitch events during which the pulsation frequency suddenly
\emph
{
increases
}
quite distinct from the usual spindown due to EM or GW
torques (see
\citet
{
espinoza2011
}
for a review). These events are typically
Poisson distributed
\citet
{
melatos2008
}
, but the exact mechanism is not yet
fully understood. However, it seems plausible that the glitch mechanism will
similarly effect any CW emission, i.e. CW signals will also undergo glitches.
In
\citet
{
ashton2016
}
we demonstrated that if this is the case, CW sources in
directed and allsky searches have a reasonable probability of undergoing one
or more glitches during typical observations spans and that these glitches may
be sufficiently large to disrupt the detection; this is particuarly true for
areas of parameter space with large spindowns. However, the effect is mitigated
by the use of incoherent searches. As such, we may expect allsky and directed
searches to correctly identify glitching signals as candidates, but
subseuqnetly `loose' them during the followup process. As such, we will now
Observations of radio pulsars show that occasionally the regular spindown of a
neutron stars due to electromagnetic and (potentially) gravitational torques is
interrupted by sudden glitch events during which the rotation frequency
suddenly
\emph
{
increases
}
(see for example
\citet
{
espinoza2011
}
for an
observational review). The glitch mechanism is not yet fully understood, but as
argued in
\citet
{
ashton2017
}
, it seems plausable that the glitch mechanism, as
it effects the radio pulsars, will also effect gravitars. As such, wide
parameter space searches which look for unknown neutron stars spinning down
primarily by gravitational wave emission (i.e. gravitars), could be hampered by
the existence of glitches in the signals. This was investigated by
\citet
{
ashton2017
}
and it was found that for many recent and ongoing searches,
there exists a reasonable probability of one or more glitches occuring in the
signal during typical observations spans and that these glitches may be
sufficiently large such that the loss of detection statistic could be of order
unity. This is particuarly true for searches looking for signals with a large
spindown and over long data span (
$
\gtrsim
100
$
~days). Semicoherent searches
are less effected (in terms of the loss of detection statistic) such that,
provided the number of glitches in a signal during a search is less than say
3, the initial search should still find the signal. However, that signal may
look like a transient signal, or be `lost' during the follow up process.
This work motivates the existence of a
\emph
{
glitchrobust
}
followup search
which is capable of fitting for the glitch parameters. As such, we will now
discuss how the
$
\F
$
statistic optimisation routine discussed in this work can
be used to search for glitching signals.
We will model a glitch as a sudden discontinuous change in the Doppler
parameters
$
\delta
\blambda
$
at some time
$
\tglitch
$
: that the change is only
in the frequency and spindown Doppler parameters, i.e.
$
\delta\blambda
=
[
0
,
0
,
\delta
f,
\delta
\fdot
,
\ldots
]
$
. This is to be interpretted, as is done for
radiopulsar glitches, as the instantaneous change in frequency and spindown at
the time of the glitch. Moreover, multiple glitches can be included (we will
define
$
\Nglitches
$
as the number of glitches) by adding
an index to the glitch magnitude and glitch time.
\subsection
{
Glitchrobust detection statistic
}
In our analysis, we consider a signal which undergoes
$
\Nglitches
$
glitches.
We will model a glitch
$
\ell
$
as a sudden discontinuous change in the frequency
and spindown Doppler parameters
$
\delta
\blambda
^
\ell
=
[
0
,
0
,
\delta
f,
\delta
\fdot
,
\ldots
]
$
at some time
$
\tglitch
^
\ell
$
. This is to be
interpretted, as is done for radiopulsar glitches, as the instantaneous change
in frequency and spindown at the time of the glitch. For convienience, we
define
$
\delta\blambda
^
0
=
[
0
,
0
,
0
,
0
\ldots
]
$
,
$
\tglitch
^
0
=
t
_
\mathrm
{
start
}$
(i.e. the start time of the observation), and
$
\tglitch
^{
\Nglitches
+
1
}
=
t
_
\mathrm
{
end
}$
(i.e. the end time of the
observation). We refer to
$
\{\delta\blambda
^{
\ell
}
\}
,
\{\tglitch
^
\ell\}
$
as
the set of all glitch parameters.
An ideal glitch search would include these new parameters into the phase model
itself and compute the
$
\F
$
statistic fullycoherently i.e. rewriting
Equation~
\eqref
{
eqn
_
B
_
S
_
N
}
as
\begin{multline}
\Bsn
(x
\tglitch
,
\delta\blambda
,
\Pic
,
\blambda
, I)
\equiv
\\
\Bsn
(x
\{
\tglitch
^
\ell\}
,
\{
\delta\blambda
^
\ell\}
,
\Pic
,
\blambda
, I)
\equiv
\\
\int
\mathcal
{
L
}
(x ;
\A
,
\blambda
,
\tglitch
,
\delta\blambda
)
\mathcal
{
L
}
(x ;
\A
,
\blambda
,
\{
\tglitch
^
\ell\}
,
\{
\delta\blambda
^
\ell\}
)
P(
\A

\Hs
, I) d
\A
\end{multline}
where
$
\tglitch
,
\delta\blambda
$
modify the phase model. However, we propose the
following pragmatic approach: let us instead use an semicoherent detection
statistic with the epoch between
\emph
{
segments
}
as
$
\tglitch
$
, i.e.
where the glitch parameters subsequently modify the phase model. However, we
propose instead the following pragmatic approach: let us instead use a
semicoherent detection statistic with the epoch between
\emph
{
segments
}
as
$
\tglitch
^
\ell
$
, i.e.
\begin{multline}
\Bsn
(x
\tglitch
,
\delta\blambda
,
\Pic
,
\blambda
, I)
\equiv
\\
\int
_{
\tstart
}^{
\tglitch
}
\mathcal
{
L
}
(x ;
\A
,
\blambda
)
P(
\A

\Hs
, I) d
\A
\\
+
\int
_{
\tglitch
}^{
\tend
}
\mathcal
{
L
}
(x ;
\A
,
\blambda
{
+
}
\delta\blambda
)
\sum
_{
\ell
=0
}^{
\Nglitches
}
\int
_{
\tglitch
^
\ell
}^{
\tglitch
^{
\ell
+1
}}
\mathcal
{
L
}
(x ;
\A
,
\blambda
+
\delta\blambda
^
\ell
)
P(
\A

\Hs
, I) d
\A
\end{multline}
or, written in terms of the
$
\mathcal
{
F
}$
statistic,
\begin{multline}
\twoFhat
(N
_{
\rm
glitch
}
,
\lambda
,
\{\tglitch
^
\ell\}
,
\{\delta\blambda
^{
\ell
}
\}
)=
\\
\sum
_{
\ell
=0
}^{
N
_{
\rm
glitch
}}
\twoFtilde
(
\alpha
,
\delta
,
\blambda
+
\delta\blambda
^
\ell
;
t
_{
\rm
glitch
}^
\ell
, t
_{
\rm
glitch
}^{
\ell
+1
}
)
\label
{
eqn
_
glitch
_
likelihood
}
\end{multline}
\comment
{
Need to think about how to connect these two statements and if the
first one is required
}
This simplistic method leverages readily available and tested code with a loss
of sensitivity over the fullycoherent search by a factor
$
\sqrt
{
\Nglitches
+
1
}$
. Such a loss is acceptable, given that the signals must
be
sufficiently strong to have been identified by the initial allsky or directed
of sensitivity over the fullycoherent search by a factor
$
\sqrt
{
\Nglitches
+
1
}$
\citep
{
wette2015
}
. Such a loss is acceptable, given that the signals must
be
sufficiently strong to have been identified by the initial allsky or directed
search.
The general methodology for a glitchrobust statistic (i.e.
Eq.
\eqref
{
eqn
_
glitch
_
likelihood
}
) could be implemented in any number of ways,
the most straightforward of course beging a gridded search over the glitch
parameters. However, for each glitch this introduces at least two new
parameters to search over. For reasonable priors on the unknown glitch
parameters, the likelihood peak occupies a small fraction of the total search
space and so a gridded search will spend the majority of the compute time in
exploring the empty regions of parameter space. However, provided that the
initial Doppler parameters
$
\blambda
$
are well constrained, the fraction of the
search space occupied should not be so small as to make application of the MCMC
procedures described in this work inefficient. On the contrary, we find in
practise that the MCMC parameter estimation to be highly efficient.
\subsection
{
Case study: directed glitching signals
}
As an illustration of the use of this method, we simulate a signal in Gaussian
noise which undergoes a glitch. Firstly in Figure~
\ref
{
fig
_
glitch
_
grid
}
we show
the fullycoherent
$
2
\F
$
value computed for a grid of points: this distinctly
shows two peaks, a feature indicative of a glitching signal, with a maximum
value of
$
\sim\CHECK
{
400
}$
. Using our incoherent glitch statistic, we plot
the resulting posterior distributions in Figure~
\ref
{
fig
_
glitch
_
posteriors
}
.
noise which undergoes a single glitch; the properties of this signal and the
data are given in Table~
\ref
{
tab
_
single
_
glitch
}
.
\begin{table}
\caption
{
Values used to generate the simulated glitching signal
}
\label
{
tab
_
single
_
glitch
}
\begin{tabular}
{
cc
}
&
\\
\hline
$
T
$
&
\SingleGlitchTspan
~days
\\
$
\sqrt
{
X
}
/
h
0
$
&
\SingleGlitchDepth
\\
$
f
$
&
\SingleGlitchFzero
~Hz
\\
$
\dot
{
f
}$
&
\SingleGlitchFone
~Hz/s
\\
$
\delta
f
$
&
\SingleGlitchdeltaFzero
~Hz
\\
$
\delta
\dot
{
f
}$
&
\SingleGlitchdeltaFone
~Hz/s
\\
$
\frac
{
\tglitch

\tstart
}{
T
}$
&
\SingleGlitchR
\end{tabular}
\end{table}
In Figure~
\ref
{
fig
_
glitch
_
grid
}
we show the fullycoherent
$
\twoFtilde
$
value
computed on a grid over
$
f
$
and
$
\dot
{
f
}$
(i.e. with a nonglitching template).
The maximum computed
$
\twoFtilde
$
value is found to be
$
\SingleGlitchFCtwoF
$
.
This can be compared to the expected
$
\twoFtilde
$
for a perfectly matched
signal in the same data which is
$
\SingleGlitchFCtwoFPM
$
: the glitch results in
the loss of
$
\SingleGlitchFCMismatch
$
of the detection statistic. The figure
distinctly shows two peaks, a feature indicative of a glitching signal.
\begin{figure}
[htb]
\centering
\includegraphics
[width=0.5\textwidth]
{
single
_
glitch
_
F0F1
_
grid
_
2D
}
\caption
{}
\caption
{
The fullycoherent
$
\twoFtilde
$
computed over a grid in
$
f
$
and
$
\dot
{
f
}$
for the simulated glitching signal with the properties described in
Table~
\ref
{
tab
_
single
_
glitch
}
.
}
\label
{
fig
_
glitch
_
grid
}
\end{figure}
\begin{figure}
[htb]
To perform the glitchrobust search we define a prior as follows. Uniform in
$
f
$
and
$
\dot
{
f
}$
(over the range shown in Figure~
\ref
{
fig
_
glitch
_
grid
}
; for
$
\tglitch
$
we define a uniform prior over the entire duration except the first
and last 10
\%
; then for
$
\delta
f
$
we asign a prior of
$
\CHECK
{
\mathcal
{
N
}
(
0
,
10
^{

7
}
f
_
0
)
}$
and for
$
\delta\dot
{
f
}$
a prior of
$
\CHECK
{

\mathcal
{
N
}
(
0
,
10
^{

3
}
\dot
{
f
}
)

}$
(i.e. a range of physical reasonable values preferring no
glitch, but allowing an arbitrarily large glitch). Running the MCMC simulation
with such a prior, we find the walkers converge to a single solution after
$
\sim
1000
$
steps. Taking the converged sample (after the burnperiod), in
Figure~
\ref
{
fig
_
glitch
_
posteriors
}
we plot the resulting posteriors. Finally,
the maximum recovered
$
\twoFhat
$
was found to be
$
\SingleGlitchGlitchtwoF
$
.
Comparing this to the fullycoherent
$
\twoFtilde
=
\SingleGlitchFCtwoFPM
$
, we see
that we have recovered the signal with negligible mismatch.
\begin{figure*}
[htb]
\centering
\includegraphics
[width=0.5\textwidth]
{
single
_
glitch
_
glitchSearch
_
corner
}
\caption
{}
\includegraphics
[width=0.8\textwidth]
{
single
_
glitch
_
glitchSearch
_
corner
}
\caption
{
The posterior distributions for the Doppler and glitch parameters
applied to a simulated glitching signal. The simulation parameters are listed
in Table~
\ref
{
tab
_
single
_
glitch
}
. The extent of these plots does not correspond
to the prior range.
}
\label
{
fig
_
glitch
_
posteriors
}
\end{figure*}
\subsection
{
MonteCarlo studies
}
\label
{
sec
_
MCS
_
glitch
}
The glitchrobust statistic is similar to a semicoherent
$
\mathcal
{
F
}$
statistic, but with additional degrees of freedom due to the
glitch parameters. As such, to compute a
$
p
$
value (or false alarm rate) for a
given
$
\twoFhat
$
we must understand the distribution of
$
\twoFhat
(
\Nglitches
)
$
in
noise. We follow the same prescription laid out in Sec.~
\ref
{
sec
_
MCS
_
zoom
}
,
namely we repeatedly run a single glitch search on independent 100~day data
span with Gaussian noise. Taking the maximum
$
\twoFhat
$
from each search, we
plot the resulting histogram in Figure~
\ref
{
fig
_
single
_
glitch
_
twoFhat
_
histgram
}
.
\begin{figure}
[htb]
\centering
\includegraphics
[width=0.5\textwidth]
{
single
_
glitch
_
noise
_
twoF
_
histogram
}
\caption
{
The distribution of
$
\twoFhat
$
}
\label
{
fig
_
single
_
glitch
_
twoFhat
_
histgram
}
\end{figure}
\section
{
Conclusion
}
\label
{
sec
_
conclusion
}
...
...
Paper/single_glitch_F0F1_grid_2D.png
View replaced file @
0abdd7d2
View file @
ce6f4793
98.7 KB

W:

H:
115 KB

W:

H:
2up
Swipe
Onion skin
Paper/single_glitch_glitchSearch_corner.png
View replaced file @
0abdd7d2
View file @
ce6f4793
739 KB

W:

H:
821 KB

W:

H:
2up
Swipe
Onion skin
Write
Preview
Supports
Markdown
0%
Try again
or
attach a new file
.
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment