lalsuite 7.26.2.dev20251210__cp312-cp312-macosx_12_0_arm64.whl

lalburst/SimBurstUtils.py

@@ -0,0 +1,324 @@
+# Copyright (C) 2007,2016--2018,2021  Kipp Cannon
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation; either version 2 of the License, or (at your
+# option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
+# Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+
+#
+# =============================================================================
+#
+#                                   Preamble
+#
+# =============================================================================
+#
+
+
+import math
+import sys
+
+
+import lal
+from lal import rate
+
+
+from . import SnglBurstUtils
+
+
+__author__ = "Kipp Cannon <kipp.cannon@ligo.org>"
+from .git_version import date as __date__
+from .git_version import version as __version__
+
+
+#
+# =============================================================================
+#
+#                                    Misc.
+#
+# =============================================================================
+#
+
+
+def on_instruments(sim, seglists, offsetvector):
+	"""
+	Return a set of the names of the instruments that were on at the
+	time of the injection.
+	"""
+	return set(instrument for instrument, seglist in seglists.items() if sim.time_at_instrument(instrument, offsetvector) in seglist)
+
+
+#
+# =============================================================================
+#
+#                           Amplitudes in Instrument
+#
+# =============================================================================
+#
+
+
+def hrss_in_instrument(sim, instrument, offsetvector):
+	"""
+	Given an injection and an instrument, compute and return the h_rss
+	of the injection as should be observed in the instrument.  That is,
+	project the waveform onto the instrument, and return the root
+	integrated strain squared.
+	"""
+	# FIXME:  this function is really only correct for sine-Gaussian
+	# injections.  that's OK because I only quote sensitivities in
+	# units of hrss when discussing sine-Gaussians.
+	#
+	# the problem is the following.  first,
+	#
+	#	h = F+ h+ + Fx hx
+	#
+	# so
+	#
+	#	h^{2} = F+^2 h+^2 + Fx^2 hx^2 + 2 F+ Fx h+ hx
+	#
+	# which means to calculate the hrss in the instrument you need to
+	# know:  mean-square h in the + polarization, mean-square h in the
+	# x polarization, and the correlation between the polarizations <h+
+	# hx>.  these could be recorded in the sim_burst table, but they
+	# aren't at present.
+
+	# semimajor and semiminor axes of polarization ellipse
+
+	a = 1.0 / math.sqrt(2.0 - sim.pol_ellipse_e**2)
+	b = a * math.sqrt(1.0 - sim.pol_ellipse_e**2)
+
+	# hrss in plus and cross polarizations
+
+	hplusrss  = sim.hrss * (a * math.cos(sim.pol_ellipse_angle) - b * math.sin(sim.pol_ellipse_angle))
+	hcrossrss = sim.hrss * (b * math.cos(sim.pol_ellipse_angle) + a * math.sin(sim.pol_ellipse_angle))
+
+	# antenna response factors
+
+	fplus, fcross = lal.ComputeDetAMResponse(
+		lal.cached_detector_by_prefix[instrument].response,
+		sim.ra,
+		sim.dec,
+		sim.psi,
+		lal.GreenwichMeanSiderealTime(sim.time_at_instrument(instrument, offsetvector))
+	)
+
+	# hrss in detector
+
+	return math.sqrt((fplus * hplusrss)**2 + (fcross * hcrossrss)**2)
+
+
+def string_amplitude_in_instrument(sim, instrument, offsetvector):
+	"""
+	Given a string cusp injection and an instrument, compute and return
+	the amplitude of the injection as should be observed in the
+	instrument.
+	"""
+	assert sim.waveform == "StringCusp"
+
+	# antenna response factors
+
+	fplus, fcross = lal.ComputeDetAMResponse(
+		lal.cached_detector_by_prefix[instrument].response,
+		sim.ra,
+		sim.dec,
+		sim.psi,
+		lal.GreenwichMeanSiderealTime(sim.time_at_instrument(instrument, offsetvector))
+	)
+
+	# amplitude in detector
+
+	return fplus * sim.amplitude
+
+
+#
+# =============================================================================
+#
+#                             Efficiency Contours
+#
+# =============================================================================
+#
+
+
+#
+# typical width of a string cusp signal's autocorrelation function when the
+# signal is normalized to the interferometer noise (whitened).  this is
+# used to provide a window around each injection for the purpose of
+# identifying burst events that match the injection.  this number is
+# O(1/f_{bucket}).
+#
+
+
+stringcusp_autocorrelation_width = .016	# seconds
+
+
+#
+# used to find burst events near injections for the purpose of producing a
+# short list of coinc events for use in more costly comparisons
+#
+
+
+burst_is_near_injection_window = 2.0	# seconds
+
+
+#
+# h_{rss} vs. peak frequency
+#
+
+
+class Efficiency_hrss_vs_freq(object):
+	def __init__(self, instruments, amplitude_func, amplitude_lbl, error):
+		self.instruments = set(instruments)
+		self.amplitude_func = amplitude_func
+		self.amplitude_lbl = amplitude_lbl
+		self.error = error
+		self.injected_x = []
+		self.injected_y = []
+		self.found_x = []
+		self.found_y = []
+
+
+	def add_contents(self, contents):
+		# FIXME:  the first left outer join can yield multiple
+		# rows.
+		cursor = contents.connection.cursor()
+		for values in contents.connection.cursor().execute("""
+SELECT
+	sim_burst.*,
+	coinc_event.coinc_event_id
+FROM
+	sim_burst
+	-- The rest of this join can yield at most 1 row for each sim_burst
+	-- row
+	LEFT OUTER JOIN coinc_event_map ON (
+		coinc_event_map.table_name == 'sim_burst'
+		AND coinc_event_map.event_id == sim_burst.simulation_id
+	)
+	LEFT OUTER JOIN coinc_event ON (
+		coinc_event.coinc_event_id == coinc_event_map.coinc_event_id
+	)
+WHERE
+	coinc_event.coinc_def_id == ?
+		""", (contents.sb_definer_id,)):
+			sim = contents.sim_burst_table.row_from_cols(values)
+			coinc_event_id = values[-1]
+			instruments = set(cursor.execute("""
+SELECT
+	sngl_burst.ifo
+FROM
+	coinc_event_map
+	JOIN sngl_burst ON (
+		coinc_event_map.table_name == 'sngl_burst'
+		AND coinc_event_map.event_id == sngl_burst.event_id
+	)
+WHERE
+	coinc_event_map.coinc_event_id == ?
+			""", (coinc_event_id,)))
+			found = self.instruments.issubset(instruments)
+			# FIXME:  this following assumes all injections are
+			# done at zero lag (which is correct, for now, but
+			# watch out for this)
+			if injection_was_made(sim, contents.seglists, self.instruments):
+				for instrument in self.instruments:
+					amplitude = self.amplitude_func(sim, instrument)
+					self.injected_x.append(sim.frequency)
+					self.injected_y.append(amplitude)
+					if found:
+						self.found_x.append(sim.frequency)
+						self.found_y.append(amplitude)
+			elif found:
+				print("odd, injection %s was found in %s but not injected..." % (sim.simulation_id, "+".join(self.instruments)), file=sys.stderr)
+
+	def _bin_events(self, binning = None):
+		# called internally by finish()
+		if binning is None:
+			minx, maxx = min(self.injected_x), max(self.injected_x)
+			miny, maxy = min(self.injected_y), max(self.injected_y)
+			binning = rate.NDBins((rate.LogarithmicBins(minx, maxx, 256), rate.LogarithmicBins(miny, maxy, 256)))
+
+		self.efficiency = rate.BinnedRatios(binning)
+
+		for xy in zip(self.injected_x, self.injected_y):
+			self.efficiency.incdenominator(xy)
+		for xy in zip(self.found_x, self.found_y):
+			self.efficiency.incnumerator(xy)
+
+		# 1 / error^2 is the number of injections that need to be
+		# within the window in order for the fractional uncertainty
+		# in that number to be = error.  multiplying by
+		# bins_per_inj tells us how many bins the window needs to
+		# cover, and taking the square root translates that into
+		# the window's length on a side in bins.  because the
+		# contours tend to run parallel to the x axis, the window
+		# is dilated in that direction to improve resolution.
+
+		bins_per_inj = self.efficiency.used() / float(len(self.injected_x))
+		self.window_size_x = self.window_size_y = math.sqrt(bins_per_inj / self.error**2)
+		self.window_size_x *= math.sqrt(2)
+		self.window_size_y /= math.sqrt(2)
+		if self.window_size_x > 100 or self.window_size_y > 100:
+			# program will take too long to run
+			raise ValueError("smoothing filter too large (not enough injections)")
+
+		print("The smoothing window for %s is %g x %g bins" % ("+".join(self.instruments), self.window_size_x, self.window_size_y), end=' ', file=sys.stderr)
+		print("which is %g%% x %g%% of the binning" % (100.0 * self.window_size_x / binning[0].n, 100.0 * self.window_size_y / binning[1].n), file=sys.stderr)
+
+	def finish(self, binning = None):
+		# compute the binning if needed, and set the injections
+		# into the numerator and denominator bins.  also compute
+		# the smoothing window's parameters.
+
+		self._bin_events(binning)
+
+		# smooth the efficiency data.
+		print("Sum of numerator bins before smoothing = %g" % self.efficiency.numerator.array.sum(), file=sys.stderr)
+		print("Sum of denominator bins before smoothing = %g" % self.efficiency.denominator.array.sum(), file=sys.stderr)
+		rate.filter_binned_ratios(self.efficiency, rate.gaussian_window(self.window_size_x, self.window_size_y))
+		print("Sum of numerator bins after smoothing = %g" % self.efficiency.numerator.array.sum(), file=sys.stderr)
+		print("Sum of denominator bins after smoothing = %g" % self.efficiency.denominator.array.sum(), file=sys.stderr)
+
+		# regularize to prevent divide-by-zero errors
+		self.efficiency.regularize()
+
+
+def plot_Efficiency_hrss_vs_freq(efficiency):
+	"""
+	Generate a plot from an Efficiency_hrss_vs_freq instance.
+	"""
+	fig, axes = SnglBurstUtils.make_burst_plot("Frequency (Hz)", efficiency.amplitude_lbl)
+	axes.loglog()
+
+	xcoords, ycoords = efficiency.efficiency.centres()
+	zvals = efficiency.efficiency.ratio()
+	cset = axes.contour(xcoords, ycoords, zvals.T, (.1, .2, .3, .4, .5, .6, .7, .8, .9))
+	cset.clabel(inline = True, fontsize = 5, fmt = r"$%%g \pm %g$" % efficiency.error, colors = "k")
+	axes.set_title(r"%s Injection Detection Efficiency (%d of %d Found)" % ("+".join(sorted(efficiency.instruments)), len(efficiency.found_x), len(efficiency.injected_x)))
+	return fig
+
+
+#
+# =============================================================================
+#
+#                             Source Co-ordinates
+#
+# =============================================================================
+#
+
+
+#
+# Location of the galactic core
+#	ra = 27940.04 s = 7 h 45 m 40.04 s
+#	dec = -29o 00' 28.1"
+#
+
+
+MW_CENTER_J2000_RA_RAD = 2.0318570464121519
+MW_CENTER_J2000_DEC_RAD = -0.50628171572274738

lalburst/SnglBurstUtils.py

@@ -0,0 +1,367 @@
+# Copyright (C) 2005-2013,2016,2017-2019,2021  Kipp Cannon
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation; either version 2 of the License, or (at your
+# option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
+# Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+#
+# =============================================================================
+#
+#                                   Preamble
+#
+# =============================================================================
+#
+
+
+import itertools
+import math
+import matplotlib
+matplotlib.rcParams.update({
+	"font.size": 8.0,
+	"axes.titlesize": 10.0,
+	"axes.labelsize": 10.0,
+	"xtick.labelsize": 8.0,
+	"ytick.labelsize": 8.0,
+	"legend.fontsize": 8.0,
+	"figure.dpi": 600,
+	"savefig.dpi": 600,
+	"text.usetex": True	# render all text with TeX
+})
+from matplotlib import figure
+from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
+import re
+import sys
+
+
+from igwn_ligolw import lsctables
+from igwn_ligolw import dbtables
+from igwn_ligolw.utils import search_summary as ligolw_search_summary
+from igwn_ligolw.utils import segments as ligolw_segments
+from .offsetvector import offsetvector
+
+
+__author__ = "Kipp Cannon <kipp.cannon@ligo.org>"
+from .git_version import date as __date__
+from .git_version import version as __version__
+
+
+#
+# =============================================================================
+#
+#                                   Database
+#
+# =============================================================================
+#
+
+
+class CoincDatabase(object):
+	def __init__(self, connection, live_time_program, search = "excesspower", veto_segments_name = None):
+		"""
+		Compute and record some summary information about the
+		database.  Call this after all the data has been inserted,
+		and before you want any of this information.
+		"""
+
+		self.connection = connection
+		self.xmldoc = dbtables.get_xml(connection)
+
+		# find the tables
+		try:
+			self.sngl_burst_table = lsctables.SnglBurstTable.get_table(self.xmldoc)
+		except ValueError:
+			self.sngl_burst_table = None
+		try:
+			self.sim_burst_table = lsctables.SimBurstTable.get_table(self.xmldoc)
+		except ValueError:
+			self.sim_burst_table = None
+		try:
+			self.coinc_def_table = lsctables.CoincDefTable.get_table(self.xmldoc)
+			self.coinc_table = lsctables.CoincTable.get_table(self.xmldoc)
+			self.time_slide_table = lsctables.TimeSlideTable.get_table(self.xmldoc)
+		except ValueError:
+			self.coinc_def_table = None
+			self.coinc_table = None
+			self.time_slide_table = None
+		try:
+			self.multi_burst_table = lsctables.MultiBurstTable.get_table(self.xmldoc)
+		except ValueError:
+			self.multi_burst_table = None
+
+		# get the segment lists
+		self.seglists = ligolw_search_summary.segmentlistdict_fromsearchsummary(self.xmldoc, live_time_program).coalesce()
+		self.instruments = set(self.seglists.keys())
+		if veto_segments_name is not None:
+			self.vetoseglists = ligolw_segments.segmenttable_get_by_name(self.xmldoc, veto_segments_name).coalesce()
+		else:
+			self.vetoseglists = ligolw_segments.segments.segmentlistdict()
+
+		# determine a few coinc_definer IDs
+		# FIXME:  don't hard-code the numbers
+		if self.coinc_def_table is not None:
+			try:
+				self.bb_definer_id = self.coinc_def_table.get_coinc_def_id(search, 0, create_new = False)
+			except KeyError:
+				self.bb_definer_id = None
+			try:
+				self.sb_definer_id = self.coinc_def_table.get_coinc_def_id(search, 1, create_new = False)
+			except KeyError:
+				self.sb_definer_id = None
+			try:
+				self.sce_definer_id = self.coinc_def_table.get_coinc_def_id(search, 2, create_new = False)
+			except KeyError:
+				self.sce_definer_id = None
+			try:
+				self.scn_definer_id = self.coinc_def_table.get_coinc_def_id(search, 3, create_new = False)
+			except KeyError:
+				self.scn_definer_id = None
+		else:
+			self.bb_definer_id = None
+			self.sb_definer_id = None
+			self.sce_definer_id = None
+			self.scn_definer_id = None
+
+
+	def get_noninjections(self):
+		"""
+		Generator function to return
+
+			is_background, event_list, offsetvector
+
+		tuples by querying the coinc_event and sngl_burst tables in
+		the database.  Only coincs corresponding to
+		sngl_burst<-->sngl_burst coincs will be retrieved.
+		"""
+		cursor = self.connection.cursor()
+		for coinc_event_id, time_slide_id in self.connection.cursor().execute("""
+	SELECT
+		coinc_event_id,
+		time_slide_id
+	FROM
+		coinc_event
+	WHERE
+		coinc_def_id == ?
+		""", (self.bb_definer_id,)):
+			rows = [(self.sngl_burst_table.row_from_cols(row), row[-1]) for row in cursor.execute("""
+	SELECT
+		sngl_burst.*,
+		time_slide.offset
+	FROM
+		coinc_event_map
+		JOIN sngl_burst ON (
+			coinc_event_map.table_name == 'sngl_burst'
+			AND sngl_burst.event_id == coinc_event_map.event_id
+		)
+		JOIN time_slide ON (
+			time_slide.instrument == sngl_burst.ifo
+		)
+	WHERE
+		coinc_event_map.coinc_event_id == ?
+		AND time_slide.time_slide_id == ?
+			""", (coinc_event_id, time_slide_id))]
+			offsets = offsetvector((event.ifo, offset) for event, offset in rows)
+			yield any(offsets.values()), [event for event, offset in rows], offsets
+		cursor.close()
+
+
+	def get_injections(self):
+		"""
+		Generator function to return
+
+			sim, event_list, offsetvector
+
+		tuples by querying the sim_burst, coinc_event and
+		sngl_burst tables in the database.  Only coincs
+		corresponding to "exact" sim_burst<-->coinc_event coincs
+		will be retrieved.
+		"""
+		cursor = self.connection.cursor()
+		for values in self.connection.cursor().execute("""
+	SELECT
+		sim_burst.*,
+		burst_coinc_event_map.event_id
+	FROM
+		sim_burst
+		JOIN coinc_event_map AS sim_coinc_event_map ON (
+			sim_coinc_event_map.table_name == 'sim_burst'
+			AND sim_coinc_event_map.event_id == sim_burst.simulation_id
+		)
+		JOIN coinc_event AS sim_coinc_event ON (
+			sim_coinc_event.coinc_event_id == sim_coinc_event_map.coinc_event_id
+		)
+		JOIN coinc_event_map AS burst_coinc_event_map ON (
+			burst_coinc_event_map.coinc_event_id == sim_coinc_event_map.coinc_event_id
+			AND burst_coinc_event_map.table_name == 'coinc_event'
+		)
+	WHERE
+		sim_coinc_event.coinc_def_id == ?
+		""", (self.sce_definer_id,)):
+			# retrieve the injection and the coinc_event_id
+			sim = self.sim_burst_table.row_from_cols(values)
+			coinc_event_id = values[-1]
+
+			# retrieve the list of the sngl_bursts in this
+			# coinc, and their time slide dictionary
+			rows = [(self.sngl_burst_table.row_from_cols(row), row[-1]) for row in cursor.execute("""
+	SELECT
+		sngl_burst.*,
+		time_slide.offset
+	FROM
+		sngl_burst
+		JOIN coinc_event_map ON (
+			coinc_event_map.table_name == 'sngl_burst'
+			AND coinc_event_map.event_id == sngl_burst.event_id
+		)
+		JOIN coinc_event ON (
+			coinc_event.coinc_event_id == coinc_event_map.coinc_event_id
+		)
+		JOIN time_slide ON (
+			coinc_event.time_slide_id == time_slide.time_slide_id
+			AND time_slide.instrument == sngl_burst.ifo
+		)
+	WHERE
+		coinc_event.coinc_event_id == ?
+			""", (coinc_event_id,))]
+			# pass the events to whatever wants them
+			yield sim, [event for event, offset in rows], offsetvector((event.ifo, offset) for event, offset in rows)
+		cursor.close()
+
+
+def summarize_coinc_database(contents, filename = None):
+	if filename is None:
+		filename = ""
+	else:
+		filename = "%s: " % filename
+	cursor = contents.connection.cursor()
+	print("%sdatabase stats:" % filename, file=sys.stderr)
+	for instrument, seglist in sorted(contents.seglists.items()):
+		print("\t%s%s livetime: %g s (%g%% vetoed)" % (filename, instrument, abs(seglist), 100.0 * float(abs(instrument in contents.vetoseglists and (seglist & contents.vetoseglists[instrument]) or 0.0)) / float(abs(seglist))), file=sys.stderr)
+	if contents.sngl_burst_table is not None:
+		print("\t%sburst events: %d" % (filename, len(contents.sngl_burst_table)), file=sys.stderr)
+	if contents.sim_burst_table is not None:
+		print("\t%sburst injections: %d" % (filename, len(contents.sim_burst_table)), file=sys.stderr)
+	if contents.time_slide_table is not None:
+		print("\t%stime slides: %d" % (filename, cursor.execute("SELECT COUNT(DISTINCT(time_slide_id)) FROM time_slide").fetchone()[0]), file=sys.stderr)
+	if contents.coinc_def_table is not None:
+		for description, n in cursor.execute("SELECT description, COUNT(*) FROM coinc_definer NATURAL JOIN coinc_event GROUP BY coinc_def_id ORDER BY description"):
+			print("\t%s%s: %d" % (filename, description, n), file=sys.stderr)
+	cursor.close()
+
+
+def coinc_sngl_bursts(contents, coinc_event_id):
+	for values in contents.connection.cursor().execute("""
+SELECT sngl_burst.* FROM
+	sngl_burst
+	JOIN coinc_event_map ON (
+		sngl_burst.event_id == coinc_event_map.event_id
+		AND coinc_event_map.table_name == 'sngl_burst'
+	)
+WHERE
+	coinc_event_map.coinc_event_id == ?
+	""", (coinc_event_id,)):
+		yield contents.sngl_burst_table.row_from_cols(values)
+
+
+#
+# =============================================================================
+#
+#                               Live Time Tools
+#
+# =============================================================================
+#
+
+
+def get_time_slides(connection):
+	"""
+	Query the database for the IDs and offsets of all time slides, and
+	return two dictionaries one containing the all-zero time slides and
+	the other containing the not-all-zero time slides.
+	"""
+	time_slides = dbtables.TimeSlideTable(connection = connection).as_dict()
+
+	zero_lag_time_slides = dict((time_slide_id, offsetvector) for time_slide_id, offsetvector in time_slides.items() if not any(offsetvector.values()))
+	background_time_slides = dict((time_slide_id, offsetvector) for time_slide_id, offsetvector in time_slides.items() if any(offsetvector.values()))
+
+	return zero_lag_time_slides, background_time_slides
+
+
+def time_slides_livetime(seglists, time_slides, verbose = False):
+	"""
+	Given a sequence of time slides (each of which is an instrument -->
+	offset dictionary), use the segmentlistdict dictionary of segment
+	lists to compute the live time in each time slide.  Return the sum
+	of the live times from all slides.
+	"""
+	livetime = 0.0
+	old_offsets = seglists.offsets.copy()
+	N = len(time_slides)
+	if verbose:
+		print("computing the live time for %d time slides:" % N, file=sys.stderr)
+	for n, time_slide in enumerate(time_slides):
+		if verbose:
+			print("\t%.1f%%\r" % (100.0 * n / N), end=' ', file=sys.stderr)
+		seglists.offsets.update(time_slide)
+		livetime += float(abs(seglists.intersection(time_slide.keys())))
+	seglists.offsets.update(old_offsets)
+	if verbose:
+		print("\t100.0%", file=sys.stderr)
+	return livetime
+
+
+#
+# =============================================================================
+#
+#                                 TeX Helpers
+#
+# =============================================================================
+#
+
+
+floatpattern = re.compile("([+-]?[.0-9]+)[Ee]([+-]?[0-9]+)")
+
+def latexnumber(s):
+	"""
+	Convert a string of the form "d.dddde-dd" to "d.dddd \\times
+	10^{-dd}"
+
+	Example:
+
+	>>> import math
+	>>> print latexnumber("%.16e" % math.pi)
+	3.1415926535897931 \\times 10^{0}
+	"""
+	m, e = floatpattern.match(s).groups()
+	return r"%s \times 10^{%d}" % (m, int(e))
+
+
+#
+# =============================================================================
+#
+#                                    Plots
+#
+# =============================================================================
+#
+
+
+def make_burst_plot(x_label, y_label, width = 165.0):
+	"""
+	width is in mm
+	"""
+	fig = figure.Figure()
+	FigureCanvas(fig)
+	# width mm wide, golden ratio high
+	fig.set_size_inches(width / 25.4, width / 25.4 / ((1 + math.sqrt(5)) / 2))
+	axes = fig.gca()
+	axes.grid(True)
+	axes.set_xlabel(x_label)
+	axes.set_ylabel(y_label)
+	return fig, axes

lalburst/__init__.py

@@ -0,0 +1,7 @@
+# Import SWIG wrappings, if available
+from ._lalburst_swig import *
+
+__version__ = "2.0.7.1"
+
+## \addtogroup lalburst_python
+"""This package provides Python wrappings and extensions to LALBurst"""