# Read in *injection* XML
if opts.inj:
print("Loading injection XML:", opts.inj)
Psig = lalsimutils.xml_to_ChooseWaveformParams_array(str(opts.inj))[
opts.event_id] # Load in the physical parameters of the injection.
m1 = Psig.m1
m2 = Psig.m2
timeWaveform = float(-lalsimutils.hoft(Psig).epoch)
Psig.deltaF = 1. / lalsimutils.nextPow2(
opts.seglen
) # Frequency binning needs to account for target segment length
theEpochFiducial = Psig.tref # Reset
tEventFiducial = 0 # Reset
print(" ++ Targeting event at time ++ ",
lalsimutils.stringGPSNice(Psig.tref))
print(" +++ WARNING: ADOPTING STRONG PRIORS +++ ")
rosUseStrongPriorOnParameters = True
Psig.print_params()
print("---- End injeciton parameters ----")
# Use forced parameters, if provided
if opts.template_mass1:
Psig.m1 = opts.template_mass1 * lal.LAL_MSUN_SI
if opts.template_mass2:
Psig.m2 = opts.template_mass2 * lal.LAL_MSUN_SI
# Reset origin of time, if required. (This forces different parts of data to be read- important! )
if opts.force_gps_time:
print(" +++ USER HAS OVERRIDDEN FIDUCIAL EPOCH +++ ")
print(
m2 = Psig.m2
f_temp = Psig.fmin
if Psig.fmin < 1e-2:
Psig.fmin = opts.fmin_SNR # necessary for duration estimate
timeWaveform = lalsimutils.estimateWaveformDuration(
Psig) #float(-lalsimutils.hoft(Psig).epoch)
Psig.fmin = f_temp
Psig.deltaT = 1. / fSample # default sampling rate
Psig.deltaF = 1. / lalsimutils.nextPow2(
opts.seglen
) # Frequency binning needs to account for target segment length
Psig.fref = opts.signal_fref
theEpochFiducial = Psig.tref # Reset
tEventFiducial = 0 # Reset
print(" ++ Targeting event at time ++ ",
lalsimutils.stringGPSNice(Psig.tref))
print(" +++ WARNING: ADOPTING STRONG PRIORS +++ ")
rosUseStrongPriorOnParameters = True
# Psig.print_params()
# Use forced parameters, if provided
if opts.template_mass1 and Psig:
Psig.m1 = opts.template_mass1 * lalsimutils.lsu_MSUN
if opts.template_mass2 and Psig:
Psig.m2 = opts.template_mass2 * lalsimutils.lsu_MSUN
# Use forced parameters, if provided. Note these will override the first set
if opts.signal_mass1 and Psig:
Psig.m1 = opts.signal_mass1 * lalsimutils.lsu_MSUN
if opts.signal_mass2 and Psig:
Psig.m2 = opts.signal_mass2 * lalsimutils.lsu_MSUN
if opts.eff_lambda and Psig:
def TestLogLikelihoodInfrastructure(TestDictionary, theEpochFiducial,
data_dict, psd_dict, fmaxSNR,
analyticPSD_Q, Psig, rholms, rholms_intp,
crossTerms, crossTermsV, detectors, Lmax):
global tWindowReference
fmin_SNR = 30
# keysPairs = lalsimutils.constructLMIterator(Lmax)
print(detectors)
keysPairs = rholms_intp[detectors[0]].keys()
df = data_dict[detectors[0]].deltaF
# fSample = opts.srate # this may be reset by the data -- be careful. SHOULD recalculate from deltaF and length of data
fSample = data_dict[detectors[0]].deltaF * len(
data_dict[detectors[0]].data.data)
rhoExpected = {}
rhoExpectedAlt = {}
rhoFake = {}
# tWindowReference = tWindowReference
tWindowExplore = factored_likelihood.tWindowExplore
tEventFiducial = float(Psig.tref - theEpochFiducial)
if not bNoMatplotlib:
plt.figure(0) # Make sure not overwritten
plt.title("Placeholder - reset to this screen")
rho2Net = 0
print(
" ++ WARNING : Some tests depend on others. Not made robust yet ++ ")
# Data: what is the SNR of the injected signal?
# Only useful for *zero noise* signals.
if TestDictionary["DataReport"]:
print(" == Data report == ")
detectors = data_dict.keys()
rho2Net = 0
for det in detectors:
if analyticPSD_Q:
IP = lalsimutils.ComplexIP(fLow=fmin_SNR,
fNyq=fSample / 2,
deltaF=df,
psd=psd_dict[det],
fMax=fmaxSNR,
analyticPSD_Q=analyticPSD_Q)
IPOverlap = lalsimutils.ComplexOverlap(
fLow=fmin_SNR,
fNyq=fSample / 2,
deltaF=df,
psd=psd_dict[det],
fMax=fmaxSNR,
analyticPSD_Q=analyticPSD_Q,
full_output=True) # Use for debugging later
else:
IP = lalsimutils.ComplexIP(fLow=fmin_SNR,
fNyq=fSample / 2,
deltaF=df,
psd=psd_dict[det].data.data,
fMax=fmaxSNR,
analyticPSD_Q=analyticPSD_Q)
IPOverlap = lalsimutils.ComplexOverlap(
fLow=fmin_SNR,
fNyq=fSample / 2,
deltaF=df,
psd=psd_dict[det].data.data,
fMax=fmaxSNR,
analyticPSD_Q=analyticPSD_Q,
full_output=True)
rhoExpected[det] = rhoDet = IP.norm(data_dict[det])
rhoExpectedAlt[det] = rhoDet2 = IPOverlap.norm(data_dict[det])
rho2Net += rhoDet * rhoDet
print(
det, rhoDet, rhoDet2,
" [via IP and Overlap]; both should agree with analytic expectations (if zero noise)."
)
print("Network : ", np.sqrt(rho2Net))
print(
" .... Generating the zero-noise template (in case the real data is noisy), to estimate its amplitude at the signal ..... "
)
print(
" [for some signals (coincs) the distance is not set, so the amplitude will be set to a fiducial distance. The value will be off] "
)
data_fake_dict = {}
rho2Net = 0
for det in detectors:
Psig.detector = det
data_fake_dict[det] = lal.ResizeCOMPLEX16FrequencySeries(
lalsimutils.non_herm_hoff(Psig), 0,
len(data_dict[det].data.data)) # Pad if needed!
if analyticPSD_Q:
IP = lalsimutils.ComplexIP(fLow=fmin_SNR,
fNyq=fSample / 2,
deltaF=df,
psd=psd_dict[det],
fMax=fmaxSNR,
analyticPSD_Q=analyticPSD_Q)
else:
IP = lalsimutils.ComplexIP(fLow=fmin_SNR,
fNyq=fSample / 2,
deltaF=df,
psd=psd_dict[det].data.data,
fMax=fmaxSNR,
analyticPSD_Q=analyticPSD_Q)
rhoFake[det] = IP.norm(data_fake_dict[det]) # Reset
rho2Net += rhoFake[det] * rhoFake[det]
print(" Fake data :", det, rhoFake[det])
print(" Fake network:", np.sqrt(rho2Net))
if TestDictionary["DataReportTime"]:
print(" == Timing report == ")
for det in detectors:
print(det, " Time offset between data and fiducial : ",
float(data_dict[det].epoch - theEpochFiducial))
if not (det is "Fake"):
print(
det, " Time offset from time of flight (known parms): ",
float(
factored_likelihood.ComputeArrivalTimeAtDetector(
det, Psig.phi, Psig.theta, theEpochFiducial) -
theEpochFiducial))
# U report
if TestDictionary["UVReport"]:
print(" ======= UV report ==========")
for det in detectors:
for pair1 in keysPairs:
for pair2 in keysPairs:
if np.abs(crossTerms[det][pair1, pair2]) > 1e-5:
print("U", det, pair1, pair2, crossTerms[det][pair1,
pair2])
print("V", det, pair1, pair2, crossTermsV[det][pair1,
pair2])
# UV reflection symmetry
if (TestDictionary["UVReflection"]): # Only valid for nonprecessing
print(" ======= UV symmetry check (reflection symmetric) ==========")
constraint1 = 0
for det in detectors:
for pair1 in keysPairs:
for pair2 in keysPairs:
constraint1 += np.abs(crossTerms[det][pair1, pair2] - (
(-1)**(pair1[0] + pair2[0])) * np.conj(crossTerms[det][
(pair1[0], -pair1[1]), (pair2[0], -pair2[1])]))**2
print(" : Reflection symmetry constraint (UV) : 0 ~= ", constraint1)
if np.abs(constraint1) > 1e-15:
print(" ++ WARNING ++")
print(
" If you see this message, UV reflection symmetry does not hold. If you have run with a nonprecessing binary "
)
print(
" then this symmetry *must* hold, preferably to machine precision.. \n PLEASE CHECK ANY RECENT CHANGES TO THE LOW-LEVEL INFRASTRUCTURE (e.g., inner products, psd import, etc)"
)
# Q(t) reflection symmetry [discrete]
if TestDictionary["QReflection"]: # Only valid for nonprecessing
constraint1 = 0
for det in detectors:
hxx = rholms[det][(2, 2)]
hyy = rholms[det][(2, -2)]
for i in np.arange(len(hxx.data.data)):
constraint1 += np.abs(hxx.data.data[i] -
np.conj(hyy.data.data[i]))**2
print(
" : Reflection symmetry constraint (Q22,Q2-2) with raw data: : 0 ~= ",
constraint1 / len(hxx.data.data)) # error per point
if TestDictionary["Rho22Timeseries"] and not bNoMatplotlib:
print(" ======= rho22: Plot versus time ==========")
print(
" Note in Evan's implementation, they are functions of t in GPS units (i.e., 10^9) "
)
plt.clf()
plt.figure(2) # plot not geocentered
# Plot
for det in detectors:
q = rholms[det][(
2, 2
)] # factored_likelihood.QSumOfSquaresDiscrete(rholms[det],crossTerms[det])
print(" rho22 plot ", det, lalsimutils.stringGPSNice(q.epoch),
lalsimutils.stringGPSNice(theEpochFiducial))
tvals = float(q.epoch - theEpochFiducial) + np.arange(
len(q.data.data)
) * q.deltaT # rho timeseries are truncated, so short
plt.plot(tvals, np.abs(q.data.data), label='rho22(t):' + det)
plt.xlabel('t(s) [not geocentered] : relative to ' +
lalsimutils.stringGPSNice(theEpochFiducial))
plt.ylabel('rho22')
plt.title('q:' + lalsimutils.stringGPSNice(theEpochFiducial))
qf = rholms_intp[det][(
2, 2
)] # factored_likelihood.QSumOfSquaresDiscrete(rholms[det],crossTerms[det]
tvals = np.linspace(
tWindowExplore[0], tWindowExplore[1],
fSample *
(tWindowExplore[1] -
tWindowExplore[0])) # rho timeseries are truncated, so short
# Evan's implementation: large time scale for rholms(t)
tvals = map(lambda x: float(theEpochFiducial + x), tvals)
qvals = map(qf, tvals)
plt.plot(tvals, np.abs(qvals), label='rho22intp(t):' + det)
plt.xlabel('t(s) [not geocentered] : relative to ' +
lalsimutils.stringGPSNice(theEpochFiducial))
plt.ylabel('rho22')
plt.title('q:' + lalsimutils.stringGPSNice(theEpochFiducial))
plt.legend()
plt.savefig("FLT-rho22." + fExtensionHighDensity)
# lnLmodel (known parameters).
# Using conventional interpolated likelihood, so skip if not available
if TestDictionary["lnLModelAtKnown"]:
print(" ======= UV test: Recover the SNR of the injection ==========")
print(
" Detector lnLmodel (-2lnLmodel)^(1/2) rho(directly) [last two entries should be equal!] "
)
for det in detectors:
lnLModel = factored_likelihood.SingleDetectorLogLikelihoodModel(
crossTerms, crossTermsV, Psig.tref, Psig.phi, Psig.theta,
Psig.incl, Psig.phiref, Psig.psi, Psig.dist, Lmax, det)
print(det, lnLModel, np.sqrt(-2 * lnLModel), rhoExpected[det],
" [last two equal (in zero noise)?]")
# lnL (known parameters)
if TestDictionary["lnLAtKnown"]:
print(
" ======= End to end LogL: Recover the SNR of the injection at the injection parameters =========="
)
lnL = factored_likelihood.FactoredLogLikelihood(
Psig, rholms, rholms_intp, crossTerms, crossTermsV, Lmax)
print(" : Default code : ", lnL, " versus rho^2/2 ", rho2Net / 2,
" [last two equal (in zero noise)?]")
print(
" [should agree in zero noise. Some disagreement expected because *recovered* (=best-fit-to-data) time and phase parameters are slightly different than injected]"
)
# lnLMarginalizeTime
if TestDictionary["lnLAtKnownMarginalizeTime"]:
print(
" ======= \int L dt/T: Consistency across multiple methods =========="
)
tvals = np.linspace(
tWindowExplore[0], tWindowExplore[1],
int(fSample * (tWindowExplore[1] - tWindowExplore[0])))
lnLmargT1 = factored_likelihood.FactoredLogLikelihoodTimeMarginalized(
tvals, Psig, rholms_intp, rholms, crossTerms, crossTermsV, Lmax)
lnLmargT1b = factored_likelihood.FactoredLogLikelihoodTimeMarginalized(
tvals,
Psig,
rholms_intp,
rholms,
crossTerms,
crossTermsV,
Lmax,
interpolate=True)
# lnLmargT1 = factored_likelihood.NetworkLogLikelihoodTimeMarginalized(theEpochFiducial,rholms_intp, crossTerms, Psig.tref, tWindowExplore, Psig.phi, Psig.theta, Psig.incl, Psig.phiref,Psig.psi, Psig.dist, 2, detectors)
lnLmargT2 = factored_likelihood.NetworkLogLikelihoodTimeMarginalizedDiscrete(
theEpochFiducial, rholms, crossTerms, crossTermsV, Psig.tref,
tWindowExplore, Psig.phi, Psig.theta, Psig.incl, Psig.phiref,
Psig.psi, Psig.dist, Lmax, detectors)
def fn(x):
P2 = Psig.copy()
P2.tref = theEpochFiducial + x
return np.exp(
np.max([
factored_likelihood.FactoredLogLikelihood(
P2, rholms, rholms_intp, crossTerms, crossTermsV,
Lmax), -15
])) # control for roundoff
lnLmargT3 = np.log(
integrate.quad(fn,
tWindowExplore[0],
tWindowExplore[1],
points=[0],
limit=500)[0])
print(
"Validating ln \int L dt/T over a window (manual,interp,discrete)= ",
lnLmargT3, lnLmargT1, lnLmargT1b, " note time window has length ",
tWindowExplore[1] - tWindowExplore[0])
# lnLdata (plot)
if TestDictionary["lnLDataPlot"] and not bNoMatplotlib:
# Plot the interpolated lnLData versus *time*
print(
" ======= lnLdata timeseries at the injection parameters =========="
)
tvals = np.linspace(tWindowExplore[0], tWindowExplore[1],
fSample * (tWindowExplore[1] - tWindowExplore[0]))
for det in detectors:
lnLData = map(
lambda x: factored_likelihood.SingleDetectorLogLikelihoodData(
theEpochFiducial, rholms_intp, theEpochFiducial + x, Psig.
phi, Psig.theta, Psig.incl, Psig.phiref, Psig.psi, Psig.
dist, Lmax, det), tvals)
lnLDataEstimate = np.ones(
len(tvals)) * rhoExpected[det] * rhoExpected[det]
plt.figure(1)
plt.xlabel('t(s) [geocentered]relative to ' +
lalsimutils.stringGPSNice(theEpochFiducial))
plt.ylabel('lnLdata')
plt.title("lnLdata (interpolated) vs narrow time interval")
indx = [
k for k, value in enumerate((tvals > tWindowExplore[0]) *
(tvals < tWindowExplore[1]))
if value
] # gets results if true
lnLfac = 4 * np.max([np.abs(lnLData[k])
for k in indx]) # Max in window
if lnLfac < 100:
lnLfac = 100
plt.ylim(
-lnLfac, lnLfac
) # sometimes we get yanked off the edges. Larger than this isn't likely
tvalsPlot = tvals
plt.plot(tvalsPlot, lnLData, label='Ldata(t)+' + det)
plt.plot(tvalsPlot, lnLDataEstimate, label="$rho^2(" + det + ")$")
nBinsDiscrete = len(
data_dict[det].data.data
) #int(fSample*1) # plot all of data, straight up!
tStartOffsetDiscrete = 0 #tWindowExplore[0]-0.5 # timeshift correction *should* already performed by DiscreteSingleDetectorLogLikelihood
tvalsDiscrete = tStartOffsetDiscrete + np.arange(
nBinsDiscrete) * 1.0 / fSample
lnLDataDiscrete = factored_likelihood.DiscreteSingleDetectorLogLikelihoodData(
theEpochFiducial, rholms,
theEpochFiducial + tStartOffsetDiscrete, nBinsDiscrete,
Psig.phi, Psig.theta, Psig.incl, Psig.phiref, Psig.psi,
Psig.dist, Lmax, det)
tvalsDiscrete = tvalsDiscrete[:len(lnLDataDiscrete)]
plt.figure(2)
plt.xlabel('t(s) [not geocentered] relative to ' +
lalsimutils.stringGPSNice(theEpochFiducial))
plt.ylabel('lnLdata')
nSkip = 1 # len(tvalsDiscrete)/4096 # Go to fixed number of points
lnLDataEstimate = np.ones(
len(tvalsDiscrete)) * rhoExpected[det] * rhoExpected[det]
plt.plot(tvalsDiscrete,
lnLDataEstimate,
label="$rho^2(" + det + ")$")
plt.plot(tvalsDiscrete[::nSkip],
lnLDataDiscrete[::nSkip],
label='Ldata(t):discrete+' + det)
plt.title('lnLdata(t) discrete, NO TIME SHIFTS')
plt.legend()
tEventRelative = float(Psig.tref - theEpochFiducial)
print(" Real time (relative to fiducial start time) ", tEventFiducial,
" and our triggering time is ", tEventRelative)
plt.figure(1)
plt.plot([tEventFiducial, tEventFiducial], [0, rho2Net],
color='k',
linestyle='--')
plt.title("lnLdata (interpolated) vs narrow time interval")
plt.xlim(-0.05, 0.05)
if bSavePlots:
plt.savefig("FLT-lnLData." + fExtensionLowDensity)
print(
" ======= rholm test: Plot the lnL timeseries at the injection parameters =========="
)
tvals = np.linspace(tWindowExplore[0], tWindowExplore[1],
fSample * (tWindowExplore[1] - tWindowExplore[0]))
print(" ... plotting over range ",
[min(tvals), max(tvals)], " with npts = ", len(tvals))
P = Psig.copy()
lnL = np.zeros(len(tvals))
for indx in np.arange(len(tvals)):
P.tref = theEpochFiducial + tvals[indx]
lnL[indx] = factored_likelihood.FactoredLogLikelihood(
P, rholms, rholms_intp, crossTerms, crossTermsV, Lmax)
lnLEstimate = np.ones(len(tvals)) * rho2Net / 2
plt.figure(1)
tvalsPlot = tvals
plt.plot(tvalsPlot, lnL, label='lnL(t)')
plt.plot(tvalsPlot, lnLEstimate, label="$rho^2/2(net)$")
indx = [
k for k, value in enumerate((tvals > tWindowExplore[0]) *
(tvals < tWindowExplore[1])) if value
] # gets results if true
lnLfac = 4 * np.max([np.abs(lnL[k]) for k in indx]) # Max in window
if lnLfac < 100:
lnLfac = 100
plt.ylim(
-lnLfac, lnLfac
) # sometimes we get yanked off the edges. Larger than this isn't likely
tEventRelative = float(Psig.tref - theEpochFiducial)
print(" Real time (relative to fiducial start time) ", tEventFiducial,
" and our triggering time is the same ", tEventRelative)
plt.plot([tEventFiducial, tEventFiducial], [0, rho2Net],
color='k',
linestyle='--')
plt.title("lnL (interpolated) vs narrow time interval")
plt.xlim(-0.05, 0.05)
plt.legend()
if bSavePlots:
plt.savefig("FLT-lnL." + fExtensionLowDensity)
# lnLdata (plot), using vectorized packing
if TestDictionary["lnLDataPlotAlt"] and not bNoMatplotlib:
lookupNKDict = {}
lookupKNDict = {}
lookupKNconjDict = {}
ctUArrayDict = {}
ctVArrayDict = {}
rholmArrayDict = {}
rholms_intpArrayDict = {}
epochDict = {}
for det in rholms_intp.keys():
lookupNKDict[det], lookupKNDict[det], lookupKNconjDict[
det], ctUArrayDict[det], ctVArrayDict[det], rholmArrayDict[
det], rholms_intpArrayDict[det], epochDict[
det] = factored_likelihood.PackLikelihoodDataStructuresAsArrays(
rholms[det].keys(), rholms_intp[det], rholms[det],
crossTerms[det], crossTermsV[det])
# Plot the interpolated lnLData versus *time*
print(
" ======= lnLdata timeseries at the injection parameters =========="
)
tvals = np.linspace(tWindowExplore[0], tWindowExplore[1],
fSample * (tWindowExplore[1] - tWindowExplore[0]))
for det in detectors:
lnLData = map(
lambda x: factored_likelihood.SingleDetectorLogLikelihoodData(
theEpochFiducial, rholms_intp, theEpochFiducial + x, Psig.
phi, Psig.theta, Psig.incl, Psig.phiref, Psig.psi, Psig.
dist, Lmax, det), tvals)
lnLDataEstimate = np.ones(
len(tvals)) * rhoExpected[det] * rhoExpected[det]
plt.figure(1)
plt.xlabel('t(s) [geocentered]relative to ' +
lalsimutils.stringGPSNice(theEpochFiducial))
plt.ylabel('lnLdata')
plt.title("lnLdata (interpolated) vs narrow time interval")
indx = [
k for k, value in enumerate((tvals > tWindowExplore[0]) *
(tvals < tWindowExplore[1]))
if value
] # gets results if true
lnLfac = 4 * np.max([np.abs(lnLData[k])
for k in indx]) # Max in window
if lnLfac < 100:
lnLfac = 100
plt.ylim(
-lnLfac, lnLfac
) # sometimes we get yanked off the edges. Larger than this isn't likely
tvalsPlot = tvals
plt.plot(tvalsPlot, lnLData, label='Ldata(t)+' + det)
plt.plot(tvalsPlot, lnLDataEstimate, label="$rho^2(" + det + ")$")
nBinsDiscrete = len(
data_dict[det].data.data
) #int(fSample*1) # plot all of data, straight up!
tStartOffsetDiscrete = 0 #tWindowExplore[0]-0.5 # timeshift correction *should* already performed by DiscreteSingleDetectorLogLikelihood
tvalsDiscrete = tStartOffsetDiscrete + np.arange(
nBinsDiscrete) * 1.0 / fSample
lnLDataDiscrete = factored_likelihood.DiscreteSingleDetectorLogLikelihoodDataViaArray(
tvalsPlot,
Psig,
lookupNKDict,
rholmArrayDict,
Lmax=Lmax,
det=det)
tvalsDiscrete = tvalsDiscrete[:len(lnLDataDiscrete)]
plt.figure(2)
plt.xlabel('t(s) [not geocentered] relative to ' +
lalsimutils.stringGPSNice(theEpochFiducial))
plt.ylabel('lnLdata')
nSkip = 1 # len(tvalsDiscrete)/4096 # Go to fixed number of points
lnLDataEstimate = np.ones(
len(tvalsDiscrete)) * rhoExpected[det] * rhoExpected[det]
plt.plot(tvalsDiscrete,
lnLDataEstimate,
label="$rho^2(" + det + ")$")
plt.plot(tvalsDiscrete[::nSkip],
lnLDataDiscrete[::nSkip],
label='Ldata(t):discrete+' + det)
plt.title('lnLdata(t) discrete, NO TIME SHIFTS')
plt.legend()
tEventRelative = float(Psig.tref - theEpochFiducial)
print(" Real time (relative to fiducial start time) ", tEventFiducial,
" and our triggering time is ", tEventRelative)
plt.figure(1)
plt.plot([tEventFiducial, tEventFiducial], [0, rho2Net],
color='k',
linestyle='--')
plt.title("lnLdata (interpolated) vs narrow time interval")
plt.xlim(-0.05, 0.05)
if bSavePlots:
plt.savefig("FLT-lnLaltData." + fExtensionLowDensity)
print(
" ======= rholm test: Plot the lnL timeseries at the injection parameters =========="
)
tvals = np.linspace(tWindowExplore[0], tWindowExplore[1],
fSample * (tWindowExplore[1] - tWindowExplore[0]))
print(" ... plotting over range ",
[min(tvals), max(tvals)], " with npts = ", len(tvals))
P = Psig.copy()
lnL = np.zeros(len(tvals))
for indx in np.arange(len(tvals)):
P.tref = theEpochFiducial + tvals[indx]
lnL[indx] = factored_likelihood.FactoredLogLikelihood(
P, rholms, rholms_intp, crossTerms, crossTermsV, Lmax)
lnLEstimate = np.ones(len(tvals)) * rho2Net / 2
plt.figure(1)
tvalsPlot = tvals
plt.plot(tvalsPlot, lnL, label='lnL(t)')
plt.plot(tvalsPlot, lnLEstimate, label="$rho^2/2(net)$")
indx = [
k for k, value in enumerate((tvals > tWindowExplore[0]) *
(tvals < tWindowExplore[1])) if value
] # gets results if true
lnLfac = 4 * np.max([np.abs(lnL[k]) for k in indx]) # Max in window
if lnLfac < 100:
lnLfac = 100
plt.ylim(
-lnLfac, lnLfac
) # sometimes we get yanked off the edges. Larger than this isn't likely
tEventRelative = float(Psig.tref - theEpochFiducial)
print(" Real time (relative to fiducial start time) ", tEventFiducial,
" and our triggering time is the same ", tEventRelative)
plt.plot([tEventFiducial, tEventFiducial], [0, rho2Net],
color='k',
linestyle='--')
plt.title("lnL (interpolated) vs narrow time interval")
plt.xlim(-0.05, 0.05)
plt.legend()
if bSavePlots:
plt.savefig("FLT-lnL_alt." + fExtensionLowDensity)
# lnLdata (plot)
if TestDictionary["lnLDataPlotVersusPsi"] and not bNoMatplotlib:
print(
" ======= Code test: Plot the lnL versus psi, at the injection parameters =========="
)
psivals = np.linspace(0, 2 * np.pi, 500)
P = Psig.copy()
P.tref = Psig.tref #Probably already created. Be careful re recreating, some memory management issues
lnL = np.zeros(len(psivals))
for indx in np.arange(len(psivals)):
P.psi = psivals[indx]
lnL[indx] = factored_likelihood.FactoredLogLikelihood(
P, rholms, rholms_intp, crossTerms, crossTermsV, 2)
lnLEstimate = np.ones(len(psivals)) * rho2Net / 2
plt.figure(5)
plt.plot(psivals, lnL, label='lnL(phi)')
plt.plot(psivals, lnLEstimate, label="$rho^2/2(net)$")
psiEvent = Psig.psi
plt.ylabel('lnL')
plt.xlabel('$\psi$')
plt.plot([psiEvent, psiEvent], [0, rho2Net], color='k', linestyle='--')
plt.plot([psiEvent + np.pi, psiEvent + np.pi], [0, rho2Net],
color='k',
linestyle='--') # add second line
plt.plot([psiEvent + 2 * np.pi, psiEvent + 2 * np.pi], [0, rho2Net],
color='k',
linestyle='--') # add third line
plt.title("lnL (interpolated) vs phase (psi)")
plt.legend()
# lnL (plot)
if TestDictionary[
"lnLDataPlotVersusPhi"]: # here phi means *phiref*, not *phiS*
print(
" ======= Code test: Plot the lnL versus phi, at the injection parameters =========="
)
phivals = np.linspace(0, 2 * np.pi, 500)
P = Psig.copy()
P.tref = Psig.tref #Probably already created. Be careful re recreating, some memory management issues
lnL = np.zeros(len(phivals))
lnLdata = {}
for indx in np.arange(len(phivals)):
P.phiref = phivals[indx]
lnL[indx] = factored_likelihood.FactoredLogLikelihood(
P, rholms, rholms_intp, crossTerms, crossTermsV, 2)
for det in detectors:
lnLdata[det] = np.zeros(len(phivals))
for indx in np.arange(len(phivals)):
P.phiref = phivals[indx]
lnLdata[det][
indx] = factored_likelihood.SingleDetectorLogLikelihoodData(
theEpochFiducial, rholms_intp, P.tref, P.phi, P.theta,
P.incl, -P.phiref, P.psi, P.dist, Lmax, det)
lnLEstimate = np.ones(len(phivals)) * rho2Net / 2
plt.figure(6)
plt.plot(phivals, lnL, label='lnL(phi)')
plt.plot(phivals, lnLEstimate, label="$rho^2/2(net)$")
for det in detectors:
plt.plot(phivals, lnLdata[det], label='lnLdata(phi):' + det)
phiEvent = Psig.phiref
plt.ylabel('lnL')
plt.xlabel('$\phi$')
plt.plot([phiEvent, phiEvent], [0, rho2Net], color='k', linestyle='-')
plt.plot(
[phiEvent + np.pi, phiEvent + np.pi], [0, rho2Net],
color='k',
linestyle='--'
) # not a physically required extrema, but often a good approx
plt.plot([phiEvent + 2 * np.pi, phiEvent + 2 * np.pi], [0, rho2Net],
color='k',
linestyle='-') # add second line
plt.title("lnL (interpolated) vs phase (phi)")
plt.legend()
# lnLdata (plot)
if TestDictionary["lnLDataPlotVersusPhiPsi"]:
print(
" ======= Code test: Plot the lnL versus phi,psi, at the injection parameters =========="
)
psivals = np.linspace(0, 2 * np.pi, 50)
phivals = np.linspace(0, 2 * np.pi, 50)
psivals, phivals = np.meshgrid(psivals, phivals)
P = Psig.copy()
P.tref = Psig.tref #Probably already created. Be careful re recreating, some memory management issues
lnL = np.zeros(psivals.shape)
for indx in np.arange(psivals.shape[0]):
for y in np.arange(psivals.shape[1]):
P.psi = psivals[indx, y]
P.phiref = phivals[indx, y]
lnL[indx, y] = factored_likelihood.FactoredLogLikelihood(
P, rholms, rholms_intp, crossTerms, crossTermsV, 2)
myfig = plt.figure(7)
ax = myfig.add_subplot(111, projection='3d')
ax.plot_wireframe(psivals, phivals, lnL)
# ax.plot_wireframe(psivals,phivals,phivals) # Confirm I am plotting what I think I am
ax.set_xlabel('psi')
ax.set_ylabel('phi')
ax.set_zlabel('lnL')
if (not bNoMatplotlib) and (not bNoInteractivePlots) and (
TestDictionary["lnLDataPlotVersusPsi"]
or TestDictionary["lnLDataPlot"]
or TestDictionary["lnLDataPlotVersusPhiPsi"]
): # TestDictionary["DataReport"] or
print(" Making plots ")
print(TestDictionary)
plt.show()
return True
deltaF=df,
psd=psd_dict[det],
analyticPSD_Q=True,
full_output=True) # Use for debugging later
rhoExpected[det] = rhoDet = IP.norm(data_dict[det])
rhoExpectedAlt[det] = rhoDet2 = IPOverlap.norm(data_dict[det])
rho2Net += rhoDet * rhoDet
print(
det, rhoDet, rhoDet2, " has arrival time relative to fiducial of ",
float(
factored_likelihood.ComputeArrivalTimeAtDetector(
det, Psig.phi, Psig.theta, Psig.tref) - theEpochFiducial))
tarrive = factored_likelihood.ComputeArrivalTimeAtDetector(
det, Psig.phi, Psig.theta, Psig.tref)
print(" and has epoch ", float(data_dict[det].epoch),
" with arrival time ", lalsimutils.stringGPSNice(tarrive))
print("Network : ", np.sqrt(rho2Net))
if checkInputPlots:
print(
" == Plotting detector data (time domain; requires regeneration, MANUAL TIMESHIFTS, and seperate code path! Argh!) == "
)
P = Psig.copy()
P.tref = Psig.tref
for det in detectors:
P.detector = det # we do
hT = hoft(P)
tvals = float(P.tref - theEpochFiducial) + hT.deltaT * np.arange(
len(hT.data.data))
plt.figure(1)
plt.plot(tvals, hT.data.data, label=det)
)
Psig.print_params()
# Read in *injection* XML
if opts.inj:
print("Loading injection XML:", opts.inj)
Psig = lalsimutils.xml_to_ChooseWaveformParams_array(str(opts.inj))[
opts.event_id] # Load in the physical parameters of the injection.
timeWaveform = float(-lalsimutils.hoft(Psig).epoch)
Psig.deltaF = 1. / lalsimutils.nextPow2(
opts.seglen
) # Frequency binning needs to account for target segment length
theEpochFiducial = Psig.tref # Reset
tEventFiducial = 0 # Reset
print(" ++ Targeting event at time ++ ",
lalsimutils.stringGPSNice(Psig.tref))
print(" +++ WARNING: ADOPTING STRONG PRIORS +++ ")
rosUseStrongPriorOnParameters = True
# TEST THE SEGMENT LENGTH TARGET
if Psig:
timeSegmentLength = float(-lalsimutils.hoft(Psig).epoch)
if rosDebugMessagesDictionary["DebugMessages"]:
print(" Template duration : ", timeSegmentLength)
if timeSegmentLength > opts.seglen:
print(
" +++ CATASTROPHE : You are requesting less data than your template target needs! +++"
)
print(" Requested data size: ", opts.seglen)
print(" Template duration : ", timeSegmentLength)
sys.exit(0)
" Detector lnLmodel (-2lnLmodel)^(1/2) rho(directly) [last two entries should be equal!] "
)
for det in detectors:
lnLModel = factored_likelihood.SingleDetectorLogLikelihoodModel(
crossTerms, Psig.tref, Psig.phi, Psig.theta, Psig.incl,
Psig.phiref, Psig.psi, Psig.dist, 2, det)
print(det, lnLModel, np.sqrt(-2 * lnLModel), rhoExpected[det],
" [last two equal?]")
print(
" ======= End to end LogL: Recover the SNR of the injection at the injection parameters =========="
)
lnL = factored_likelihood.FactoredLogLikelihood(Psig, rholms_intp,
crossTerms, Lmax)
print(" : Evan's code : ", lnL, " versus rho^2/2 ", rho2Net / 2)
print(" : Timing issues (checkme!) : fiducial = ",
lsu.stringGPSNice(theEpochFiducial))
print(
" ======= rholm test: Plot the lnLdata timeseries at the injection parameters (* STILL TIME OFFSET *) =========="
)
tmin = np.max(
float(epoch_post - theEpochFiducial),
factored_likelihood.tWindowReference[0] +
0.03) # the minimum time used is set by the rolling condition
# tvals = np.linspace(tmin,factored_likelihood.tWindowReference[1],4*fSample*(factored_likelihood.tWindowReference[1]-tmin))
tvals = np.linspace(
factored_likelihood.tWindowExplore[0] + tEventFiducial,
factored_likelihood.tWindowExplore[1] + tEventFiducial,
fSample * (factored_likelihood.tWindowExplore[1] -
factored_likelihood.tWindowExplore[0]))
for det in detectors: