def attempt_advance(self, blocksize, timeout=10):
""" Attempt to advance the frame buffer. Retry upon failure, except
if the frame file is beyond the timeout limit.
Parameters
----------
blocksize: int
The number of seconds to attempt to read from the channel
timeout: {int, 10}, Optional
Number of seconds before giving up on reading a frame
Returns
-------
data: TimeSeries
TimeSeries containg 'blocksize' seconds of frame data
"""
if self.force_update_cache:
self.update_cache()
try:
if self.increment_update_cache:
self.update_cache_by_increment(blocksize)
return DataBuffer.advance(self, blocksize)
except RuntimeError:
if lal.GPSTimeNow() > timeout + self.raw_buffer.end_time:
# The frame is not there and it should be by now, so we give up
# and treat it as zeros
DataBuffer.null_advance(self, blocksize)
return None
else:
# I am too early to give up on this frame, so we should try again
time.sleep(1)
return self.attempt_advance(blocksize, timeout=timeout)
def parseTimeDelayDegeneracy(self, ifos, gpstime=lal.GPSTimeNow(),\
dt=0.0005):
# get detectors
detectors = [inject.cached_detector.get(inject.prefix_to_name[ifo])\
for ifo in ifos]
timeDelays = []
degenerate = []
new = table.new_from_template(self)
for n, row in enumerate(self):
# get all time delays for this point
timeDelays.append([])
for i in xrange(len(ifos)):
for j in xrange(i + 1, len(ifos)):
timeDelays[n].append(date.XLALArrivalTimeDiff(\
detectors[i].location,\
detectors[j].location,\
row.longitude,\
row.latitude,\
LIGOTimeGPS(gpstime)))
# skip the first point
if n == 0:
degenerate.append(False)
new.append(row)
continue
else:
degenerate.append(True)
# test this point against all others
for i in xrange(0, n):
# if check point is degenerate, skip
if degenerate[i]:
continue
# check each time delay individually
for j in xrange(0, len(timeDelays[n])):
# if this time delay is non-degenerate the point is valid
if np.fabs(timeDelays[i][j] - timeDelays[n][j]) >= dt:
degenerate[n] = False
break
else:
degenerate[n] = True
if degenerate[n]:
break
if not degenerate[n]:
new.append(row)
return new
def setUp(self):
available_detectors = get_available_detectors()
available_detectors = [a[0] for a in available_detectors]
self.assertTrue('H1' in available_detectors)
self.assertTrue('L1' in available_detectors)
self.assertTrue('V1' in available_detectors)
self.detectors = [Detector(d) for d in ['H1', 'L1', 'V1']]
self.sample_rate = 4096.
self.earth_time = lal.REARTH_SI / lal.C_SI
# create a few random injections
self.injections = []
start_time = float(lal.GPSTimeNow())
taper_choices = ('TAPER_NONE', 'TAPER_START', 'TAPER_END',
'TAPER_STARTEND')
for i, taper in zip(xrange(20), itertools.cycle(taper_choices)):
inj = MyInjection()
inj.end_time = start_time + 40000 * i + \
numpy.random.normal(scale=3600)
random = numpy.random.uniform
inj.mass1 = random(low=1., high=20.)
inj.mass2 = random(low=1., high=20.)
inj.distance = random(low=0.9, high=1.1) * 1e6 * lal.PC_SI
inj.latitude = numpy.arccos(random(low=-1, high=1))
inj.longitude = random(low=0, high=2 * lal.PI)
inj.inclination = numpy.arccos(random(low=-1, high=1))
inj.polarization = random(low=0, high=2 * lal.PI)
inj.taper = taper
self.injections.append(inj)
# create LIGOLW document
xmldoc = ligolw.Document()
xmldoc.appendChild(ligolw.LIGO_LW())
# create sim inspiral table, link it to document and fill it
sim_table = lsctables.New(lsctables.SimInspiralTable)
xmldoc.childNodes[-1].appendChild(sim_table)
for i in xrange(len(self.injections)):
row = sim_table.RowType()
self.injections[i].fill_sim_inspiral_row(row)
row.process_id = 'process:process_id:0'
row.simulation_id = 'sim_inspiral:simulation_id:%d' % i
sim_table.append(row)
# write document to temp file
self.inj_file = tempfile.NamedTemporaryFile(suffix='.xml')
ligolw_utils.write_fileobj(xmldoc, self.inj_file)
def write_sky_map(filename, prob, objid=None, url=None, instruments=None,
gps_time=None, gps_creation_time=None, creator=None, runtime=None):
"""Write a gravitational-wave sky map to a file, populating the header
with optional metadata."""
#
# Populate optional header fieds.
#
extra_metadata = []
if objid is not None:
extra_metadata.append(('OBJECT', objid,
'Unique identifier for this event'))
if url is not None:
extra_metadata.append(('REFERENC', url,
'URL of this event'))
if instruments is not None:
extra_metadata.append(('INSTRUME', instruments,
'Gravitational-wave instruments contributing data to this event'))
if gps_time is not None:
extra_metadata.append(('DATE-OBS', gps_to_iso8601(gps_time),
'UTC date of the observation'))
extra_metadata.append(('MJD-OBS', gps_to_mjd(gps_time),
'modified Julian date of the observation'))
if gps_creation_time is None:
gps_creation_time = lal.GPSTimeNow()
extra_metadata.append(('DATE', gps_to_iso8601(gps_creation_time),
'UTC date of file creation'))
if creator is not None:
extra_metadata.append(('CREATOR', creator,
'Program that created this file'))
if runtime is not None:
extra_metadata.append(('RUNTIME', runtime,
'Runtime in seconds of the CREATOR program'))
write_map(filename, prob, nest=False, fits_IDL=True, coord='C',
column_names=('PROB',), unit='pix-1', extra_metadata=extra_metadata)
#####################################################################
# Input
USAGE='''%prog [options] [args]
Run external analysis programs on internally generated post-merger injections
with Gaussian noise.
'''
opts, args, cp = parser()
# Data configuration
datalen=cp.getfloat('analysis', 'datalength')
flow=cp.getfloat('analysis','flow')
srate=cp.getfloat('analysis','srate')
seed=opts.init_seed
seed+=random.randint(0,lal.GPSTimeNow())
target_snr=opts.target_snr
if target_snr is None and cp.has_option('injections','target-snr'):
target_snr=cp.getfloat('injections','target-snr')
epoch=0.0
trigtime=0.5*datalen+epoch
if opts.output_dir is None:
outdir=cp.get('program', 'output-dir')
ts0=time.time()
######################################################################
# Data Generation
def localize(event,
waveform='o2-uberbank',
f_low=30.0,
min_inclination=0,
max_inclination=np.pi / 2,
min_distance=None,
max_distance=None,
prior_distance_power=None,
cosmology=False,
mcmc=False,
chain_dump=None,
enable_snr_series=True,
f_high_truncate=0.95):
"""Localize a compact binary signal using the BAYESTAR algorithm.
Parameters
----------
event : `ligo.skymap.io.events.Event`
The event candidate.
waveform : str, optional
The name of the waveform approximant.
f_low : float, optional
The low frequency cutoff.
min_distance, max_distance : float, optional
The limits of integration over luminosity distance, in Mpc
(default: determine automatically from detector sensitivity).
prior_distance_power : int, optional
The power of distance that appears in the prior
(default: 2, uniform in volume).
cosmology: bool, optional
Set to enable a uniform in comoving volume prior (default: false).
mcmc : bool, optional
Set to use MCMC sampling rather than more accurate Gaussian quadrature.
chain_dump : str, optional
Save posterior samples to this filename if `mcmc` is set.
enable_snr_series : bool, optional
Set to False to disable SNR time series.
f_high_truncate : float, optional
Truncate the noise power spectral densities at this factor times the
highest sampled frequency to suppress artifacts caused by incorrect
PSD conditioning by some matched filter pipelines.
Returns
-------
skymap : `astropy.table.Table`
A 3D sky map in multi-order HEALPix format.
"""
# Hide event parameters, but show all other arguments
def formatvalue(value):
if isinstance(value, Event):
return '=...'
else:
return '=' + repr(value)
frame = inspect.currentframe()
argstr = inspect.formatargvalues(*inspect.getargvalues(frame),
formatvalue=formatvalue)
run_time = time.perf_counter()
epoch, sample_rate, toas, snr_series, responses, locations, horizons = \
condition(event, waveform=waveform, f_low=f_low,
enable_snr_series=enable_snr_series,
f_high_truncate=f_high_truncate)
min_distance, max_distance, prior_distance_power, cosmology = \
condition_prior(horizons, min_distance, max_distance,
prior_distance_power, cosmology)
gmst = lal.GreenwichMeanSiderealTime(epoch)
# Time and run sky localization.
log.debug('starting computationally-intensive section')
args = (min_inclination, max_inclination, min_distance, max_distance,
prior_distance_power, cosmology, gmst, sample_rate, toas,
snr_series, responses, locations, horizons)
if mcmc:
max_abs_t = 2 * snr_series.data.shape[1] / sample_rate
skymap = localize_emcee(
args=args,
xmin=[0, -1, min_distance, -1, 0, 0],
xmax=[2 * np.pi, 1, max_distance, 1, 2 * np.pi, 2 * max_abs_t],
chain_dump=chain_dump)
else:
skymap, log_bci, log_bsn = core.toa_phoa_snr(*args)
skymap = Table(skymap)
skymap.meta['log_bci'] = log_bci
skymap.meta['log_bsn'] = log_bsn
# Convert distance moments to parameters
try:
distmean = skymap.columns.pop('DISTMEAN')
diststd = skymap.columns.pop('DISTSTD')
except KeyError:
distmean, diststd, _ = distance.parameters_to_moments(
skymap['DISTMU'], skymap['DISTSIGMA'])
else:
skymap['DISTMU'], skymap['DISTSIGMA'], skymap['DISTNORM'] = \
distance.moments_to_parameters(distmean, diststd)
# Add marginal distance moments
good = np.isfinite(distmean) & np.isfinite(diststd)
prob = (moc.uniq2pixarea(skymap['UNIQ']) * skymap['PROBDENSITY'])[good]
distmean = distmean[good]
diststd = diststd[good]
rbar = (prob * distmean).sum()
r2bar = (prob * (np.square(diststd) + np.square(distmean))).sum()
skymap.meta['distmean'] = rbar
skymap.meta['diststd'] = np.sqrt(r2bar - np.square(rbar))
run_time = time.perf_counter() - run_time
end_time = lal.GPSTimeNow()
log.info('finished computationally-intensive section in %.3f s', run_time)
# Fill in metadata and return.
program, _ = os.path.splitext(os.path.basename(sys.argv[0]))
skymap.meta.update(metadata_for_version_module(version))
skymap.meta['creator'] = 'BAYESTAR'
skymap.meta['origin'] = 'LIGO/Virgo'
skymap.meta['gps_time'] = float(epoch)
skymap.meta['runtime'] = float(run_time)
skymap.meta['instruments'] = {single.detector for single in event.singles}
skymap.meta['gps_creation_time'] = end_time
skymap.meta['history'] = [
'', 'Generated by calling the following Python function:',
'{}.{}{}'.format(__name__, frame.f_code.co_name, argstr), '',
'This was the command line that started the program:',
' '.join([program] + sys.argv[1:])
]
return skymap
def write_sky_map(filename,
prob,
nest=False,
objid=None,
url=None,
instruments=None,
gps_time=None,
gps_creation_time=None,
creator=None,
origin=None,
runtime=None):
"""Write a gravitational-wave sky map to a file, populating the header
with optional metadata."""
#
# Populate optional header fieds.
#
extra_metadata = []
if objid is not None:
extra_metadata.append(
('OBJECT', objid, 'Unique identifier for this event'))
if url is not None:
extra_metadata.append(('REFERENC', url, 'URL of this event'))
if instruments is not None:
if not isinstance(instruments, basestring):
instruments = str(lsctables.ifos_from_instrument_set(instruments))
extra_metadata.append(
('INSTRUME', instruments, 'Instruments that triggered this event'))
if gps_time is not None:
extra_metadata.append(('DATE-OBS', gps_to_iso8601(gps_time),
'UTC date of the observation'))
extra_metadata.append(('MJD-OBS', gps_to_mjd(gps_time),
'modified Julian date of the observation'))
if gps_creation_time is None:
gps_creation_time = lal.GPSTimeNow()
extra_metadata.append(('DATE', gps_to_iso8601(gps_creation_time),
'UTC date of file creation'))
if creator is not None:
extra_metadata.append(
('CREATOR', creator, 'Program that created this file'))
if origin is not None:
extra_metadata.append(
('ORIGIN', origin, 'Organization responsible for this FITS file'))
if runtime is not None:
extra_metadata.append(
('RUNTIME', runtime, 'Runtime in seconds of the CREATOR program'))
write_map(filename,
prob,
nest=nest,
fits_IDL=True,
coord='C',
column_names=('PROB', ),
unit='pix-1',
extra_metadata=extra_metadata)
def write_sky_map(filename, m, nest=False, objid=None, url=None, instruments=None,
gps_time=None, gps_creation_time=None, creator=None, origin=None,
runtime=None, distmean=None, diststd=None):
"""Write a gravitational-wave sky map to a file, populating the header
with optional metadata."""
#
# Populate optional header fieds.
#
extra_header = []
if objid is not None:
extra_header.append(('OBJECT', objid,
'Unique identifier for this event'))
if url is not None:
extra_header.append(('REFERENC', url,
'URL of this event'))
if instruments is not None:
if not isinstance(instruments, six.string_types):
instruments = str(lsctables.ifos_from_instrument_set(instruments))
extra_header.append(('INSTRUME', instruments,
'Instruments that triggered this event'))
if gps_time is not None:
extra_header.append(('DATE-OBS', gps_to_iso8601(gps_time),
'UTC date of the observation'))
extra_header.append(('MJD-OBS', gps_to_mjd(gps_time),
'modified Julian date of the observation'))
if gps_creation_time is None:
gps_creation_time = lal.GPSTimeNow()
extra_header.append(('DATE', gps_to_iso8601(gps_creation_time),
'UTC date of file creation'))
if creator is not None:
extra_header.append(('CREATOR', creator,
'Program that created this file'))
if origin is not None:
extra_header.append(('ORIGIN', origin,
'Organization responsible for this FITS file'))
if runtime is not None:
extra_header.append(('RUNTIME', runtime,
'Runtime in seconds of the CREATOR program'))
if distmean is not None:
extra_header.append(('DISTMEAN', distmean,
'Posterior mean distance in Mpc'))
if diststd is not None:
extra_header.append(('DISTSTD', diststd,
'Posterior standard deviation of distance in Mpc'))
m = np.atleast_2d(m)
hp.write_map(filename, m, nest=nest, fits_IDL=True, coord='C',
column_names=('PROB', 'DISTMU', 'DISTSIGMA', 'DISTNORM')[:len(m)],
column_units=('pix-1', 'Mpc', 'Mpc', 'Mpc-2')[:len(m)],
extra_header=extra_header)
def localize(event,
waveform='o2-uberbank',
f_low=30.0,
min_distance=None,
max_distance=None,
prior_distance_power=None,
cosmology=False,
method='toa_phoa_snr',
nside=-1,
chain_dump=None,
enable_snr_series=True,
f_high_truncate=0.95):
"""Convenience function to produce a sky map from LIGO-LW rows. Note that
min_distance and max_distance should be in Mpc.
Returns a 'NESTED' ordering HEALPix image as a Numpy array.
"""
frame = inspect.currentframe()
argstr = inspect.formatargvalues(*inspect.getargvalues(frame))
start_time = lal.GPSTimeNow()
singles = event.singles
if not enable_snr_series:
singles = [single for single in singles if single.snr is not None]
ifos = [single.detector for single in singles]
# Extract SNRs from table.
snrs = np.ma.asarray([
np.ma.masked if single.snr is None else single.snr
for single in singles
])
# Look up physical parameters for detector.
detectors = [
lalsimulation.DetectorPrefixToLALDetector(str(ifo)) for ifo in ifos
]
responses = np.asarray([det.response for det in detectors])
locations = np.asarray([det.location for det in detectors])
# Power spectra for each detector.
psds = [single.psd for single in singles]
psds = [
timing.InterpolatedPSD(filter.abscissa(psd),
psd.data.data,
f_high_truncate=f_high_truncate) for psd in psds
]
log.debug('calculating templates')
H = filter.sngl_inspiral_psd(waveform, f_min=f_low, **event.template_args)
log.debug('calculating noise PSDs')
HS = [filter.signal_psd_series(H, S) for S in psds]
# Signal models for each detector.
log.debug('calculating Fisher matrix elements')
signal_models = [timing.SignalModel(_) for _ in HS]
# Get SNR=1 horizon distances for each detector.
horizons = np.asarray([
signal_model.get_horizon_distance() for signal_model in signal_models
])
weights = np.ma.asarray([
1 / np.square(signal_model.get_crb_toa_uncert(snr))
for signal_model, snr in zip(signal_models, snrs)
])
# Center detector array.
locations -= np.sum(locations * weights.reshape(-1, 1),
axis=0) / np.sum(weights)
if cosmology:
log.warn('Enabling cosmological prior. ' 'This feature is UNREVIEWED.')
if enable_snr_series:
log.warn('Enabling input of SNR time series. '
'This feature is UNREVIEWED.')
snr_series = [single.snr_series for single in singles]
if all(s is None for s in snr_series):
snr_series = None
else:
snr_series = None
# Maximum barycentered arrival time error:
# |distance from array barycenter to furthest detector| / c + 5 ms.
# For LHO+LLO, this is 15.0 ms.
# For an arbitrary terrestrial detector network, the maximum is 26.3 ms.
max_abs_t = np.max(np.sqrt(np.sum(np.square(locations / lal.C_SI),
axis=1))) + 0.005
if snr_series is None:
log.warn(
"No SNR time series found, so we are creating a zero-noise "
"SNR time series from the whitened template's autocorrelation "
"sequence. The sky localization uncertainty may be "
"underestimated.")
acors, sample_rates = zip(
*[filter.autocorrelation(_, max_abs_t) for _ in HS])
sample_rate = sample_rates[0]
deltaT = 1 / sample_rate
nsamples = len(acors[0])
assert all(sample_rate == _ for _ in sample_rates)
assert all(nsamples == len(_) for _ in acors)
nsamples = nsamples * 2 - 1
snr_series = []
for acor, single in zip(acors, singles):
series = lal.CreateCOMPLEX8TimeSeries('fake SNR', 0, 0, deltaT,
lal.StrainUnit, nsamples)
series.epoch = single.time - 0.5 * (nsamples - 1) * deltaT
acor = np.concatenate((np.conj(acor[:0:-1]), acor))
series.data.data = single.snr * filter.exp_i(single.phase) * acor
snr_series.append(series)
# Ensure that all of the SNR time series have the same sample rate.
# FIXME: for now, the Python wrapper expects all of the SNR time sries to
# also be the same length.
deltaT = snr_series[0].deltaT
sample_rate = 1 / deltaT
if any(deltaT != series.deltaT for series in snr_series):
raise ValueError('BAYESTAR does not yet support SNR time series with '
'mixed sample rates')
# Ensure that all of the SNR time series have odd lengths.
if any(len(series.data.data) % 2 == 0 for series in snr_series):
raise ValueError('SNR time series must have odd lengths')
# Trim time series to the desired length.
max_abs_n = int(np.ceil(max_abs_t * sample_rate))
desired_length = 2 * max_abs_n - 1
for i, series in enumerate(snr_series):
length = len(series.data.data)
if length > desired_length:
snr_series[i] = lal.CutCOMPLEX8TimeSeries(
series, length // 2 + 1 - max_abs_n, desired_length)
# FIXME: for now, the Python wrapper expects all of the SNR time sries to
# also be the same length.
nsamples = len(snr_series[0].data.data)
if any(nsamples != len(series.data.data) for series in snr_series):
raise ValueError('BAYESTAR does not yet support SNR time series of '
'mixed lengths')
# Perform sanity checks that the middle sample of the SNR time series match
# the sngl_inspiral records. Relax valid interval slightly from
# +/- 0.5 deltaT to +/- 0.6 deltaT for floating point roundoff error.
for single, series in zip(singles, snr_series):
if np.abs(0.5 * (nsamples - 1) * series.deltaT +
float(series.epoch - single.time)) >= 0.6 * deltaT:
raise ValueError('BAYESTAR expects the SNR time series to be '
'centered on the single-detector trigger times')
# Extract the TOAs in GPS nanoseconds from the SNR time series, assuming
# that the trigger happened in the middle.
toas_ns = [
series.epoch.ns() + 1e9 * 0.5 *
(len(series.data.data) - 1) * series.deltaT for series in snr_series
]
# Collect all of the SNR series in one array.
snr_series = np.vstack([series.data.data for series in snr_series])
# Center times of arrival and compute GMST at mean arrival time.
# Pre-center in integer nanoseconds to preserve precision of
# initial datatype.
epoch = sum(toas_ns) // len(toas_ns)
toas = 1e-9 * (np.asarray(toas_ns) - epoch)
# FIXME: np.average does not yet support masked arrays.
# Replace with np.average when numpy 1.13.0 is available.
mean_toa = np.sum(toas * weights) / np.sum(weights)
toas -= mean_toa
epoch += int(np.round(1e9 * mean_toa))
epoch = lal.LIGOTimeGPS(0, int(epoch))
gmst = lal.GreenwichMeanSiderealTime(epoch)
# Translate SNR time series back to time of first sample.
toas -= 0.5 * (nsamples - 1) * deltaT
# If minimum distance is not specified, then default to 0 Mpc.
if min_distance is None:
min_distance = 0
# If maximum distance is not specified, then default to the SNR=4
# horizon distance of the most sensitive detector.
if max_distance is None:
max_distance = max(horizons) / 4
# If prior_distance_power is not specified, then default to 2
# (p(r) ~ r^2, uniform in volume).
if prior_distance_power is None:
prior_distance_power = 2
# Raise an exception if 0 Mpc is the minimum effective distance and the
# prior is of the form r**k for k<0
if min_distance == 0 and prior_distance_power < 0:
raise ValueError(
('Prior is a power law r^k with k={}, '
'undefined at min_distance=0').format(prior_distance_power))
# Time and run sky localization.
log.debug('starting computationally-intensive section')
if method == 'toa_phoa_snr':
skymap, log_bci, log_bsn = _sky_map.toa_phoa_snr(
min_distance, max_distance, prior_distance_power, cosmology, gmst,
sample_rate, toas, snr_series, responses, locations, horizons)
skymap = Table(skymap)
skymap.meta['log_bci'] = log_bci
skymap.meta['log_bsn'] = log_bsn
elif method == 'toa_phoa_snr_mcmc':
skymap = localize_emcee(
logl=_sky_map.log_likelihood_toa_phoa_snr,
loglargs=(gmst, sample_rate, toas, snr_series, responses,
locations, horizons),
logp=toa_phoa_snr_log_prior,
logpargs=(min_distance, max_distance, prior_distance_power,
max_abs_t),
xmin=[0, -1, min_distance, -1, 0, 0],
xmax=[2 * np.pi, 1, max_distance, 1, 2 * np.pi, 2 * max_abs_t],
nside=nside,
chain_dump=chain_dump)
else:
raise ValueError('Unrecognized method: %s' % method)
# Convert distance moments to parameters
distmean = skymap.columns.pop('DISTMEAN')
diststd = skymap.columns.pop('DISTSTD')
skymap['DISTMU'], skymap['DISTSIGMA'], skymap['DISTNORM'] = \
distance.moments_to_parameters(distmean, diststd)
# Add marginal distance moments
good = np.isfinite(distmean) & np.isfinite(diststd)
prob = (moc.uniq2pixarea(skymap['UNIQ']) * skymap['PROBDENSITY'])[good]
distmean = distmean[good]
diststd = diststd[good]
rbar = (prob * distmean).sum()
r2bar = (prob * (np.square(diststd) + np.square(distmean))).sum()
skymap.meta['distmean'] = rbar
skymap.meta['diststd'] = np.sqrt(r2bar - np.square(rbar))
log.debug('finished computationally-intensive section')
end_time = lal.GPSTimeNow()
# Fill in metadata and return.
program, _ = os.path.splitext(os.path.basename(sys.argv[0]))
skymap.meta['creator'] = 'BAYESTAR'
skymap.meta['origin'] = 'LIGO/Virgo'
skymap.meta['vcs_info'] = vcs_info
skymap.meta['gps_time'] = float(epoch)
skymap.meta['runtime'] = float(end_time - start_time)
skymap.meta['instruments'] = {single.detector for single in singles}
skymap.meta['gps_creation_time'] = end_time
skymap.meta['history'] = [
'', 'Generated by calling the following Python function:',
'{}.{}{}'.format(__name__, frame.f_code.co_name, argstr), '',
'This was the command line that started the program:',
' '.join([program] + sys.argv[1:])
]
return skymap
#
# Produce data with a coherent signal in H1, L1, V1
#
data_dict = {}
Psig = None
# Read in *coincidence* XML (overridden by injection, if present)
if opts.coinc:
print("Loading coinc XML:", opts.coinc)
xmldoc = utils.load_filename(opts.coinc)
coinc_table = table.get_table(xmldoc,
lsctables.CoincInspiralTable.tableName)
assert len(coinc_table) == 1
coinc_row = coinc_table[0]
event_time = float(coinc_row.get_end()) #
event_time_gps = lal.GPSTimeNow(
) # Pack as GPSTime *explicitly*, so all time operations are type-consistent
event_time_gps.gpsSeconds = int(event_time)
event_time_gps.gpsNanoSeconds = int(
1e9 * (event_time - event_time_gps.gpsSeconds))
theEpochFiducial = event_time_gps # really should avoid duplicate names
print("Coinc XML loaded, event time: %s" % str(coinc_row.get_end()))
# Populate the SNR sequence and mass sequence
sngl_inspiral_table = table.get_table(
xmldoc, lsctables.SnglInspiralTable.tableName)
m1, m2 = None, None
for sngl_row in sngl_inspiral_table:
# NOTE: gstlal is exact match, but other pipelines may not be
assert m1 is None or (sngl_row.mass1 == m1 and sngl_row.mass2 == m2)
m1, m2 = sngl_row.mass1, sngl_row.mass2
rhoExpected[str(
sngl_row.ifo)] = sngl_row.snr # record for comparisons later
def ligolw_sky_map(sngl_inspirals,
waveform,
f_low,
min_distance=None,
max_distance=None,
prior_distance_power=None,
method="toa_phoa_snr",
psds=None,
nside=-1,
chain_dump=None,
phase_convention='antifindchirp',
snr_series=None,
enable_snr_series=False):
"""Convenience function to produce a sky map from LIGO-LW rows. Note that
min_distance and max_distance should be in Mpc.
Returns a 'NESTED' ordering HEALPix image as a Numpy array.
"""
# Ensure that sngl_inspiral is either a single template or a list of
# identical templates
for key in 'mass1 mass2 spin1x spin1y spin1z spin2x spin2y spin2z'.split():
if hasattr(sngl_inspirals[0], key):
value = getattr(sngl_inspirals[0], key)
if any(value != getattr(_, key) for _ in sngl_inspirals):
raise ValueError(
'{0} field is not the same for all detectors'.format(key))
ifos = [sngl_inspiral.ifo for sngl_inspiral in sngl_inspirals]
# Extract SNRs from table.
snrs = np.ma.asarray([
np.ma.masked if sngl_inspiral.snr is None else sngl_inspiral.snr
for sngl_inspiral in sngl_inspirals
])
# Look up physical parameters for detector.
detectors = [
lalsimulation.DetectorPrefixToLALDetector(str(ifo)) for ifo in ifos
]
responses = np.asarray([det.response for det in detectors])
locations = np.asarray([det.location for det in detectors])
# Power spectra for each detector.
if psds is None:
psds = [timing.get_noise_psd_func(ifo) for ifo in ifos]
log.debug('calculating templates')
H = filter.sngl_inspiral_psd(sngl_inspirals[0], waveform, f_min=f_low)
log.debug('calculating noise PSDs')
HS = [filter.signal_psd_series(H, S) for S in psds]
# Signal models for each detector.
log.debug('calculating Fisher matrix elements')
signal_models = [timing.SignalModel(_) for _ in HS]
# Get SNR=1 horizon distances for each detector.
horizons = np.asarray([
signal_model.get_horizon_distance() for signal_model in signal_models
])
weights = np.ma.asarray([
1 / np.square(signal_model.get_crb_toa_uncert(snr))
for signal_model, snr in zip(signal_models, snrs)
])
# Center detector array.
locations -= np.sum(locations * weights.reshape(-1, 1),
axis=0) / np.sum(weights)
if enable_snr_series:
log.warn(
'Enabling input of SNR time series. This feature is UNREVIEWED.')
else:
snr_series = None
# Maximum barycentered arrival time error:
# |distance from array barycenter to furthest detector| / c + 5 ms.
# For LHO+LLO, this is 15.0 ms.
# For an arbitrary terrestrial detector network, the maximum is 26.3 ms.
max_abs_t = np.max(np.sqrt(np.sum(np.square(locations / lal.C_SI),
axis=1))) + 0.005
if snr_series is None:
log.warn(
"No SNR time series found, so we are creating a zero-noise "
"SNR time series from the whitened template's autocorrelation "
"sequence. The sky localization uncertainty may be "
"underestimated.")
acors, sample_rates = zip(
*[filter.autocorrelation(_, max_abs_t) for _ in HS])
sample_rate = sample_rates[0]
deltaT = 1 / sample_rate
nsamples = len(acors[0])
assert all(sample_rate == _ for _ in sample_rates)
assert all(nsamples == len(_) for _ in acors)
nsamples = nsamples * 2 - 1
snr_series = []
for acor, sngl in zip(acors, sngl_inspirals):
series = lal.CreateCOMPLEX8TimeSeries('fake SNR', 0, 0, deltaT,
lal.StrainUnit, nsamples)
series.epoch = sngl.end - 0.5 * (nsamples - 1) * deltaT
acor = np.concatenate((np.conj(acor[:0:-1]), acor))
if phase_convention.lower() == 'antifindchirp':
# The matched filter phase convention does NOT affect the
# template autocorrelation sequence; however it DOES affect
# the maximum-likelihood phase estimate AND the SNR time series.
# So if we are going to apply the anti-findchirp phase
# correction later, we'll have to apply a complex conjugate to
# the autocorrelation sequence to cancel it here.
acor = np.conj(acor)
series.data.data = sngl.snr * filter.exp_i(sngl.coa_phase) * acor
snr_series.append(series)
# Ensure that all of the SNR time series have the same sample rate.
# FIXME: for now, the Python wrapper expects all of the SNR time sries to
# also be the same length.
deltaT = snr_series[0].deltaT
sample_rate = 1 / deltaT
if any(deltaT != series.deltaT for series in snr_series):
raise ValueError(
'BAYESTAR does not yet support SNR time series with mixed sample rates'
)
# Ensure that all of the SNR time series have odd lengths.
if any(len(series.data.data) % 2 == 0 for series in snr_series):
raise ValueError('SNR time series must have odd lengths')
# Trim time series to the desired length.
max_abs_n = int(np.ceil(max_abs_t * sample_rate))
desired_length = 2 * max_abs_n - 1
for i, series in enumerate(snr_series):
length = len(series.data.data)
if length > desired_length:
snr_series[i] = lal.CutCOMPLEX8TimeSeries(
series, length // 2 + 1 - max_abs_n, desired_length)
# FIXME: for now, the Python wrapper expects all of the SNR time sries to
# also be the same length.
nsamples = len(snr_series[0].data.data)
if any(nsamples != len(series.data.data) for series in snr_series):
raise ValueError(
'BAYESTAR does not yet support SNR time series of mixed lengths')
# Perform sanity checks that the middle sample of the SNR time series match
# the sngl_inspiral records.
for sngl_inspiral, series in zip(sngl_inspirals, snr_series):
if np.abs(0.5 * (nsamples - 1) * series.deltaT +
float(series.epoch - sngl_inspiral.end)) >= 0.5 * deltaT:
raise ValueError(
'BAYESTAR expects the SNR time series to be centered on the sngl_inspiral end times'
)
# Extract the TOAs in GPS nanoseconds from the SNR time series, assuming
# that the trigger happened in the middle.
toas_ns = [
series.epoch.ns() + 1e9 * 0.5 *
(len(series.data.data) - 1) * series.deltaT for series in snr_series
]
# Collect all of the SNR series in one array.
snr_series = np.vstack([series.data.data for series in snr_series])
# Fudge factor for excess estimation error in gstlal_inspiral.
fudge = 0.83
snr_series *= fudge
# If using 'findchirp' phase convention rather than gstlal/mbta,
# then flip signs of phases.
if phase_convention.lower() == 'antifindchirp':
log.warn('Using anti-FINDCHIRP phase convention; inverting phases. '
'This is currently the default and it is appropriate for '
'gstlal and MBTA but not pycbc as of observing run 1 ("O1"). '
'The default setting is likely to change in the future.')
snr_series = np.conj(snr_series)
# Center times of arrival and compute GMST at mean arrival time.
# Pre-center in integer nanoseconds to preserve precision of
# initial datatype.
epoch = sum(toas_ns) // len(toas_ns)
toas = 1e-9 * (np.asarray(toas_ns) - epoch)
# FIXME: np.average does not yet support masked arrays.
# Replace with np.average when numpy 1.13.0 is available.
mean_toa = np.sum(toas * weights) / np.sum(weights)
toas -= mean_toa
epoch += int(np.round(1e9 * mean_toa))
epoch = lal.LIGOTimeGPS(0, int(epoch))
gmst = lal.GreenwichMeanSiderealTime(epoch)
# Translate SNR time series back to time of first sample.
toas -= 0.5 * (nsamples - 1) * deltaT
# If minimum distance is not specified, then default to 0 Mpc.
if min_distance is None:
min_distance = 0
# If maximum distance is not specified, then default to the SNR=4
# horizon distance of the most sensitive detector.
if max_distance is None:
max_distance = max(horizons) / 4
# If prior_distance_power is not specified, then default to 2
# (p(r) ~ r^2, uniform in volume).
if prior_distance_power is None:
prior_distance_power = 2
# Raise an exception if 0 Mpc is the minimum effective distance and the prior
# is of the form r**k for k<0
if min_distance == 0 and prior_distance_power < 0:
raise ValueError(
("Prior is a power law r^k with k={}, " +
"undefined at min_distance=0").format(prior_distance_power))
# Rescale distances to horizon distance of most sensitive detector.
max_horizon = np.max(horizons)
horizons /= max_horizon
min_distance /= max_horizon
max_distance /= max_horizon
# Time and run sky localization.
log.debug('starting computationally-intensive section')
start_time = lal.GPSTimeNow()
if method == "toa_phoa_snr":
skymap = Table(
_sky_map.toa_phoa_snr(min_distance, max_distance,
prior_distance_power, gmst, sample_rate,
toas, snr_series, responses, locations,
horizons))
elif method == "toa_phoa_snr_mcmc":
skymap = emcee_sky_map(
logl=_sky_map.log_likelihood_toa_phoa_snr,
loglargs=(gmst, sample_rate, toas, snr_series, responses,
locations, horizons),
logp=toa_phoa_snr_log_prior,
logpargs=(min_distance, max_distance, prior_distance_power,
max_abs_t),
xmin=[0, -1, min_distance, -1, 0, 0],
xmax=[2 * np.pi, 1, max_distance, 1, 2 * np.pi, 2 * max_abs_t],
nside=nside,
chain_dump=chain_dump,
max_horizon=max_horizon * fudge)
else:
raise ValueError("Unrecognized method: %s" % method)
# Convert distance moments to parameters
distmean = skymap.columns.pop('DISTMEAN')
diststd = skymap.columns.pop('DISTSTD')
skymap['DISTMU'], skymap['DISTSIGMA'], skymap['DISTNORM'] = \
distance.moments_to_parameters(distmean, diststd)
# Add marginal distance moments
good = np.isfinite(distmean) & np.isfinite(diststd)
prob = (moc.uniq2pixarea(skymap['UNIQ']) * skymap['PROBDENSITY'])[good]
distmean = distmean[good]
diststd = diststd[good]
rbar = (prob * distmean).sum()
r2bar = (prob * (np.square(diststd) + np.square(distmean))).sum()
skymap.meta['distmean'] = rbar
skymap.meta['diststd'] = np.sqrt(r2bar - np.square(rbar))
# Rescale
rescale = max_horizon * fudge
skymap['DISTMU'] *= rescale
skymap['DISTSIGMA'] *= rescale
skymap.meta['distmean'] *= rescale
skymap.meta['diststd'] *= rescale
skymap['DISTNORM'] /= np.square(rescale)
end_time = lal.GPSTimeNow()
log.debug('finished computationally-intensive section')
# Fill in metadata and return.
skymap.meta['creator'] = 'BAYESTAR'
skymap.meta['origin'] = 'LIGO/Virgo'
skymap.meta['gps_time'] = float(epoch)
skymap.meta['runtime'] = float(end_time - start_time)
skymap.meta['instruments'] = {
sngl_inspiral.ifo
for sngl_inspiral in sngl_inspirals
}
skymap.meta['gps_creation_time'] = end_time
return skymap
from __future__ import division import pycbc import lal import itertools import numpy from pycbc.detector import Detector from pycbc.inject import InjectionSet from pycbc.types import TimeSeries from glue.ligolw import ligolw from glue.ligolw import lsctables from glue.ligolw import utils as ligolw_utils end_time = float(lal.GPSTimeNow()) mass1 = 30 mass2 = 30 distance = 1e6 * lal.PC_SI taper = 'TAPER_STARTEND' random = numpy.random.uniform latitude = numpy.arccos(random(low=-1, high=1)) longitude = random(low=0, high=2 * lal.PI) inclination = numpy.arccos(random(low=-1, high=1)) polarization = random(low=0, high=2 * lal.PI) # create LIGOLW document xmldoc = ligolw.Document() xmldoc.appendChild(ligolw.LIGO_LW()) # create sim inspiral table, link it to document and fill it sim_table = lsctables.New(lsctables.SimInspiralTable)
def pick_coinc():
"""Pick a coincidence from the "First Two Years" paper."""
filename = pkg_resources.resource_filename(
__name__, '../data/first2years/2016/gstlal.xml.gz')
xmldoc = utils.load_filename(filename, contenthandler=ContentHandler)
root, = xmldoc.childNodes
# Remove unneeded tables
for lsctable in (lsctables.FilterTable, lsctables.SegmentTable,
lsctables.SegmentDefTable, lsctables.SimInspiralTable,
lsctables.SummValueTable, lsctables.SearchSummVarsTable):
root.removeChild(lsctable.get_table(xmldoc))
coinc_inspiral_table = table = lsctables.CoincInspiralTable.get_table(
xmldoc)
# Determine event with most recent sideral time
gps_time_now = lal.GPSTimeNow()
gmsts = np.asarray([lal.GreenwichMeanSiderealTime(_.end) for _ in table])
gmst_now = lal.GreenwichMeanSiderealTime(gps_time_now)
div, rem = divmod(gmst_now - gmsts, 2 * np.pi)
i = np.argmin(rem)
new_gmst = div[i] * 2 * np.pi + gmsts[i]
old_time = table[i].end
new_time = lal.LIGOTimeGPS()
result = lal.GreenwichMeanSiderealTimeToGPS(new_gmst, new_time)
result.disown()
del result
delta_t = new_time - old_time
target_coinc_event_id = int(table[i].coinc_event_id)
# Remove unneeded rows
table[:] = [
row for row in table
if int(row.coinc_event_id) == target_coinc_event_id
]
target_end_time = table[0].get_end()
coinc_table = table = lsctables.CoincTable.get_table(xmldoc)
table[:] = [
row for row in table
if int(row.coinc_event_id) == target_coinc_event_id
]
table = lsctables.CoincMapTable.get_table(xmldoc)
table[:] = [
row for row in table
if int(row.coinc_event_id) == target_coinc_event_id
]
target_sngl_inspirals = frozenset(row.event_id for row in table)
sngl_inspiral_table = table = lsctables.SnglInspiralTable.get_table(xmldoc)
table[:] = [row for row in table if row.event_id in target_sngl_inspirals]
table = lsctables.ProcessTable.get_table(xmldoc)
table[:] = [row for row in table if row.program == 'gstlal_inspiral']
target_process_ids = frozenset(row.process_id for row in table)
table = lsctables.SearchSummaryTable.get_table(xmldoc)
table[:] = [
row for row in table if target_end_time in row.get_out()
and row.process_id in target_process_ids
]
target_process_ids = frozenset(row.process_id for row in table)
table = lsctables.ProcessTable.get_table(xmldoc)
table[:] = [row for row in table if row.process_id in target_process_ids]
table = lsctables.ProcessParamsTable.get_table(xmldoc)
table[:] = [row for row in table if row.process_id in target_process_ids]
# Shift event times
for row in coinc_inspiral_table:
row.end += delta_t
for row in sngl_inspiral_table:
row.end += delta_t
row.end_time_gmst = lal.GreenwichMeanSiderealTime(row.end)
# The old version of gstlal used to produce the "First Two Years" data set
# stored likelihood in the coinc_event.likelihood column, but newer
# versions store the *natural log* of the likelihood here. The p_astro
# calculation requires this to be log likelihood.
for row in coinc_table:
row.likelihood = np.log(row.likelihood)
# Gstlal stores the template's SVD bank index in the Gamma1 column.
# Fill this in so that we can calculate p_astro
# (see :mod:`gwcelery.tasks.p_astro_gstlal`).
for row in sngl_inspiral_table:
row.Gamma1 = 16
coinc_xml = io.BytesIO()
utils.write_fileobj(xmldoc, coinc_xml)
return coinc_xml.getvalue()
#
# Generate an inner product using the original discrete PSD
# Perform an inner product using it *and* using an analytic PSD
#
# Populate signal
m1 = 10*lal.LAL_MSUN_SI
m2 = 10*lal.LAL_MSUN_SI
df = psd_dict[detectors[0]].deltaF
fSample = df * 2 *( len(psd_dict[detectors[0]].data.data)-1) # rescale
print("To construct a signal, we reconstruct the sampling rate and time window, consistent with the default PSD sampling: (fSample, 1/df) = ", fSample, 1/df)
Psig = lalsimutils.ChooseWaveformParams(
m1 = m1,m2 =m2,
fmin = 30,
fref=100, ampO=0,
tref = lal.GPSTimeNow(), # factored_likelihood requires GPS be assigned
radec=True, theta=1.2, phi=2.4,
detector='H1',
dist=25.*1.e6*lal.LAL_PC_SI,
deltaT=1./fSample,
deltaF = df
)
data_dict={}
data_dict['H1'] = lalsimutils.non_herm_hoff(Psig)
Psig.detector = 'L1'
data_dict['L1'] = lalsimutils.non_herm_hoff(Psig)
Psig.detector = 'V1'
data_dict['V1'] = lalsimutils.non_herm_hoff(Psig)
psd_analytic_dict = {}
psd_analytic_dict['H1'] = lalsim.SimNoisePSDaLIGOZeroDetHighPower# lal.LIGOIPsd
psd_analytic_dict['L1'] = lalsim.SimNoisePSDaLIGOZeroDetHighPower #lal.LIGOIPsd
) # Use actual injection GPS time (assumed from trigger)
#theEpochFiducial = lal.LIGOTimeGPS(1000000000.000000000) # Use epoch of the data
tEventFiducial = 0 # time relative to fiducial epoch, used to identify window to look in. Checked empirically.
detectors = ['H1', "L1", "V1"]
psd_dict['H1'] = lalsim.SimNoisePSDiLIGOSRD
#psd_dict['L1'] = lalsim.SimNoisePSDiLIGOSRD
psd_dict['V1'] = lalsim.SimNoisePSDiLIGOSRD
Psig = lalsimutils.xml_to_ChooseWaveformParams_array("mdc.xml.gz")[
0] # Load in the physical parameters of the injection (=first element)
Psig.approx = lalsim.SEOBNRv4
Psig.print_params()
# Load IFO FFTs.
tS = lal.GPSTimeNow()
# ASSUME data has same sampling rate!
df = 1. / 32
dt = 1. / fSample
Psig.deltaF = df
Psig.detector = 'H1'
data_dict['H1'] = lalsimutils.non_herm_hoff(Psig)
#Psig.detector='L1'
#data_dict['L1'] = lalsimutils.non_herm_hoff(Psig)
Psig.detector = 'V1'
data_dict['V1'] = lalsimutils.non_herm_hoff(Psig)
tE = lal.GPSTimeNow()
cost_dict['readin'] = tE - tS
#print data_dict['H1'].data.data[10] # confirm data loaded
df = data_dict['H1'].deltaF
m1, m2, opts.eff_lambda, opts.deff_lambda or 0)
Psig.lambda1 = lambda1
Psig.lambda2 = lambda2
if Psig and not opts.cache_file: # Print parameters of fake data
Psig.print_params()
print("---- End injection parameters ----")
# 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(
" The zero of time (and the region to be windowed) will be changed; you had better know what you are doing. "
)
print(" original ", lalsimutils.stringGPSNice(theEpochFiducial))
print(" new ", opts.force_gps_time)
theEpochFiducial = lal.GPSTimeNow()
theEpochFiducial = opts.force_gps_time
# theEpochFiducial.gpsSeconds = int(opts.force_gps_time)
# theEpochFiducial.gpsNanoSeconds = int(1e9*(opts.force_gps_time - int(opts.force_gps_time)))
# Create artificial "signal". Needed to minimize duplicate code when I
# - consistently test waveform duration
# - copy template parameters
# - [test code] : generate plots vs time [test code], expected SNR, etc
# WARNING: Test code plots will not look perfect, because we don't know the true sky location (or phase, polarization, ...)
if not Psig and opts.channel_name: # If data loaded but no signal generated
if (not opts.template_mass1) or (not opts.template_mass2) or (
not opts.force_gps_time):
print(
" CANCEL: For frame-file reading, arguments --mass1 --mass2 --event-time all required "
)
def plot_segments_history(
seglistdicts,
segments_to_plot=['trigger buffers', 'h(t) gate', 'state vector'],
t_max=None,
length=86400.,
labelspacing=10800.,
colors={
'H1': numpy.array((1.0, 0.0, 0.0)),
'L1': numpy.array((0.0, 0.8, 0.0)),
'V1': numpy.array((1.0, 0.0, 1.0)),
'H1L1': numpy.array((.5, .5, .5))
},
fig=None,
axes=None):
if fig is None:
fig = plt.figure(figsize=(15, 5), )
if axes is None:
axes = fig.add_subplot(111)
# If t_max is specified, cut the segments so they end at t_max,
# otherwise set it to the current time
if t_max is None:
t_max = float(lal.GPSTimeNow())
else:
seglist_to_drop = segments.segmentlist(
[segments.segment(lal.LIGOTimeGPS(t_max), segments.PosInfinity)])
for seglistdict in seglistdicts.values():
for seglist in seglistdict.values():
seglist -= seglist_to_drop
t_min = t_max - length
bottom = []
width = []
left_edge = []
y_ticks = []
y_tick_labels = []
color_list = []
color_dict = {
'H1': numpy.array((1.0, 0.0, 0.0)),
'L1': numpy.array((0.0, 0.8, 0.0)),
'V1': numpy.array((1.0, 0.0, 1.0)),
'H1L1': numpy.array((.5, .5, .5))
}
x_format = tkr.FuncFormatter(lambda x, pos: datetime.datetime(
*lal.GPSToUTC(int(x))[:7]).strftime('%Y-%m-%d, %H:%M:%S UTC'))
x_ticks = numpy.arange(t_min, t_max + labelspacing, labelspacing)
for j, segtype in enumerate(segments_to_plot):
for row, (ifo,
segmentlist) in enumerate(seglistdicts[segtype].items()):
y_ticks.append(row + 2 * j + 0.5)
y_tick_labels.append('%s %s' % (ifo, segtype))
bottom.extend([row + 2 * j + 0.25] * len(segmentlist))
color_list.extend([color_dict[ifo]] * len(segmentlist))
for segment in segmentlist:
width.append(float(segment[1]) - float(segment[0]))
left_edge.append(float(segment[0]))
edgecolor_list = ['w'] * len(bottom)
fig.patch.set_alpha(0.0)
axes.barh(bottom,
width,
height=0.5,
left=left_edge,
color=color_list,
edgecolor=edgecolor_list)
plt.xlim([t_min, t_max])
axes.xaxis.set_major_formatter(x_format)
plt.yticks(y_ticks, y_tick_labels)
plt.xticks(x_ticks, rotation=10.)
axes.tick_params(axis='y', which='both', left='off', right='off')
axes.grid(color=(0.1, 0.4, 0.5), linewidth=2)
# FIXME use this grid() when we have a newer matplotlib
# axes.grid(color=(0.1,0.4,0.5), linewidth=2, which='both', axis='x')
# FIXME Switch to tight_layout() when matplotlib is updated
try:
fig.tight_layout(pad=.8)
return fig, axes
except AttributeError:
return fig, axes
def write_sky_map(filename, m, nest=False, moc=False, objid=None, url=None,
instruments=None, gps_time=None, gps_creation_time=None, creator=None,
origin=None, runtime=None, distmean=None, diststd=None):
"""Write a gravitational-wave sky map to a file, populating the header
with optional metadata."""
#
# Populate optional header fieds.
#
extra_header = []
if objid is not None:
extra_header.append(('OBJECT', objid,
'Unique identifier for this event'))
if url is not None:
extra_header.append(('REFERENC', url,
'URL of this event'))
if instruments is not None:
if not isinstance(instruments, six.string_types):
instruments = str(lsctables.ifos_from_instrument_set(instruments))
extra_header.append(('INSTRUME', instruments,
'Instruments that triggered this event'))
if gps_time is not None:
extra_header.append(('DATE-OBS', gps_to_iso8601(gps_time),
'UTC date of the observation'))
extra_header.append(('MJD-OBS', gps_to_mjd(gps_time),
'modified Julian date of the observation'))
if gps_creation_time is None:
gps_creation_time = lal.GPSTimeNow()
extra_header.append(('DATE', gps_to_iso8601(gps_creation_time),
'UTC date of file creation'))
if creator is not None:
extra_header.append(('CREATOR', creator,
'Program that created this file'))
if origin is not None:
extra_header.append(('ORIGIN', origin,
'Organization responsible for this FITS file'))
if runtime is not None:
extra_header.append(('RUNTIME', runtime,
'Runtime in seconds of the CREATOR program'))
if distmean is not None:
extra_header.append(('DISTMEAN', distmean,
'Posterior mean distance in Mpc'))
if diststd is not None:
extra_header.append(('DISTSTD', diststd,
'Posterior standard deviation of distance in Mpc'))
if moc:
m = m.copy()
for name, default_unit in (('PROBDENSITY', u.steradian**-1),
('DISTMU', u.Mpc),
('DISTSIGMA', u.Mpc),
('DISTNORM', u.Mpc**-2)):
try:
col = m[name]
except KeyError:
continue
if not col.unit:
col.unit = default_unit
hdu = fits.table_to_hdu(m)
hdu.header.extend((
('PIXTYPE', 'HEALPIX', 'HEALPIX pixelisation'),
('ORDERING', 'NUNIQ', 'Pixel ordering scheme: RING, NESTED, or NUNIQ'),
('COORDSYS', 'C', 'Ecliptic, Galactic or Celestial (equatorial)')))
hdu.header.extend(extra_header)
hdulist = fits.HDUList([fits.PrimaryHDU(), hdu])
hdulist.writeto(filename, clobber=True)
else:
m = np.atleast_2d(m)
hp.write_map(filename, m, nest=nest, fits_IDL=True, coord='C',
column_names=('PROB', 'DISTMU', 'DISTSIGMA', 'DISTNORM')[:len(m)],
column_units=('pix-1', 'Mpc', 'Mpc', 'Mpc-2')[:len(m)],
extra_header=extra_header)
) # plot in Mpc, not m. Note PDF has to change
pdfvalsPrior = pdfvalsPrior * (1e6 * lal.LAL_PC_SI
) # rescale units
pdfvals = pdfvals * (1e6 * lal.LAL_PC_SI) # rescale units
plt.plot(xvals,
pdfvalsPrior,
label="prior:" + str(param),
linestyle='--')
plt.plot(xvals, pdfvals, label=str(param))
plt.plot(xvals, cdfvals, label='cdf:' + str(param))
plt.xlabel(str(param))
plt.legend()
plt.savefig("test_like_and_samp-" + str(param) + ".pdf")
# plt.show()
tGPSStart = lal.GPSTimeNow()
res, var, ret, lnLmarg, neff = sampler.integrate(
likelihood_function,
"ra",
"dec",
"tref",
"phi",
"incl",
"psi",
"dist",
n=100,
nmax=nMaxEvals,
igrandmax=rho2Net / 2,
full_output=True,
neff=100,
igrand_threshold_fraction=fracThreshold,
