lalsuite 7.22.1.dev20240408__cp312-cp312-manylinux_2_28_aarch64.whl → 7.26.2.dev20251202__cp312-cp312-manylinux_2_28_aarch64.whl

lalburst/snglcoinc.py

@@ -47,10 +47,10 @@ from collections import ChainMap, Counter
 import warnings
 
 
-from ligo.lw import ligolw
-from ligo.lw import lsctables
-from ligo.lw.utils import coincs as ligolw_coincs
-from ligo import segments
+from igwn_ligolw import ligolw
+from igwn_ligolw import lsctables
+from igwn_ligolw.utils import coincs as ligolw_coincs
+import igwn_segments as segments
 import lal
 from . import offsetvector
 
@@ -370,8 +370,8 @@ class singlesqueue(object):
 		lal.LIGOTimeGPS object.  If some other type is used, it
 		must support arithmetic and comparison with python float
 		objects and lal.LIGOTimeGPS objects, and support comparison
-		with ligo.segments.PosInfinity and
-		ligo.segments.NegInfinity, and it must have a .__dict__ or
+		with igwn_segments.PosInfinity and
+		igwn_segments.NegInfinity, and it must have a .__dict__ or
 		other mechanism allowing an additional attribute named
 		.event to be set on the object.  The builtin float type is
 		not suitable, but a subclass of float would be.
@@ -853,7 +853,8 @@ class TimeSlideGraphNode(object):
 			# the unused events returned by the doubles
 			# generator in the len==2 code path.
 			assert not coinc_windows
-			self.components = (coincgen_doubles_type.singlesqueue(0.),)
+			offset, = offset_vector.values()
+			self.components = (coincgen_doubles_type.singlesqueue(offset, 0.),)
 			self.index = self.components[0].index
 		else:
 			raise ValueError("offset_vector cannot be empty")
@@ -1472,7 +1473,7 @@ class CoincTables(object):
 		try:
 			self.coinctable = lsctables.CoincTable.get_table(xmldoc)
 		except ValueError:
-			self.coinctable = lsctables.New(lsctables.CoincTable)
+			self.coinctable = lsctables.CoincTable.new()
 			xmldoc.childNodes[0].appendChild(self.coinctable)
 		self.coinctable.sync_next_id()
 
@@ -1480,7 +1481,7 @@ class CoincTables(object):
 		try:
 			self.coincmaptable = lsctables.CoincMapTable.get_table(xmldoc)
 		except ValueError:
-			self.coincmaptable = lsctables.New(lsctables.CoincMapTable)
+			self.coincmaptable = lsctables.CoincMapTable.new()
 			xmldoc.childNodes[0].appendChild(self.coincmaptable)
 
 		# look-up the coinc_def_id, creating a new one if required
@@ -1606,82 +1607,112 @@ class CoincRates(object):
 
 		self.rate_factors = {}
 		for instruments in self.all_instrument_combos:
-		# choose the instrument whose TOA forms the "epoch" of the
-		# coinc.  to improve the convergence rate this should be
-		# the instrument with the smallest Cartesian product of
-		# coincidence windows with other instruments (so that
-		# coincidence with this instrument provides the tightest
-		# prior constraint on the time differences between the
-		# other instruments).
+		# choose the instrument whose event time forms the "epoch"
+		# of the coinc.  which we choose is irrelevant
+			# frozenset of names
 			key = instruments
-			anchor = min(instruments, key = lambda a: sum(math.log(self.tau[frozenset((a, b))]) for b in instruments - set([a])))
-			instruments = tuple(instruments - set([anchor]))
-		# the computation of a coincidence rate starts by computing
-		# \mu_{1} * \mu_{2} ... \mu_{N} * 2 * \tau_{12} * 2 *
-		# \tau_{13} ... 2 * \tau_{1N}.  this is the rate at which
-		# events from instrument 1 are coincident with events from
-		# all of instruments 2...N.  the factors of 2 are because
-		# to be coincident the time difference can be anywhere in
-		# [-tau, +tau], so the size of the coincidence window is 2
-		# tau.  removing the factor of
+			# name, list of names
+			anchor, *instruments = instruments
+		# to understand the calculation consider the following
+		# diagram.  this depicts the inter-instrument time delays
+		# for candidates in a three-detector network.
 		#
-		#	\prod_{i} \mu_{i}
+		#                   3
+		#     t3-t2 = const ^
+		#              /    |      t2-t1 = const
+		#          |  /     |        |
+		#        --+-/------+--------+-- t3-t1 = const
+		#          |/XXXXXXX|XXXXXXXX|
+		#          /XXXXXXXX|XXXXXXXX|
+		#         /|XXXXXXXX|XXXXXXXX|
+		#       ---|--------1--------|---> 2
+		#          |XXXXXXXX|XXXXXXXX|/
+		#          |XXXXXXXX|XXXXXXXX/
+		#          |XXXXXXXX|XXXXXXX/|
+		#        --+--------+------/-+-- t3-t1 = const
+		#          |        |     /  |
+		#   t2-t1 = const   |    /
+		#                     t3-t2 = const
 		#
-		# leaves
+		# in this example the time of the event seen in detector 1
+		# (arbitrary) is represented by the origin.  the x axis
+		# indicates the time difference between the event seen in
+		# detector 2 and the event seen in detector 1, while the y
+		# axis depicts the time differenc between the event seen in
+		# detector 3 and the event seen in detector 1.  in this
+		# parameter space, the coincidence windows take the form of
+		# half-spaces:  for example, the requirement that |t2-t1|
+		# <= const becomes two t2-t1=const half-space boundaries,
+		# in this case vertical lines parallel to the y-axis.
+		# similarly, the requirement that |t3-t1| <= const becomes
+		# a pair of t3-t1=const half-space boundaries parallel to
+		# the x-axis.  the requirement that |t3-t2| <= const can
+		# also be shown in this space, that requirement becomes a
+		# third pair of half-space boundaries, this time at 45
+		# degrees to the axes.
 		#
-		#	\prod_{i} 2 \tau_{1i}.
+		# in this 2-dimensional parameter space, all valid 3-way
+		# mutual coincidences must fall within the shaded region
+		# marked with "X"s, meaning their (t2-t1) and (t3-t1)
+		# values must fall in that area.  this is the intersection
+		# of the 6 half-spaces.
 		#
-		# in the N-1 dimensional space defined by the time
-		# differences between each instrument and the anchor
-		# instrument, the coincidence windows between instruments
-		# define pairs of half-space boundaries.  for the
-		# coincidence windows between each instrument and the
-		# anchor instrument these boundaries are perpendicular to
-		# co-ordinate axes, while for other pairs of instruments
-		# the coincidence windows correspond to planes angled at 45
-		# degrees in various orientations.  altogether they define
-		# a convex polyhedron containing the origin.
+		# all of this generalizes to more than 3 detectors,
+		# becoming an (N-1)-dimensional space of the \Delta t's,
+		# with the allowed volume being the intersection of the
+		# half-spaces defined by the coincidence windows.  it's
+		# aparent that the final quantity we seek here is the
+		# volume of the convex polyhedron defined by all of the
+		# constraints.  this can be computed using the qhull
+		# library's half-space intersection implementation.
 		#
-		# the product of taus, above, is the volume of the
-		# rectangular polyhedron defined by the anchor instrument
-		# constraints alone.  it's aparent that the final quantity
-		# we seek here is the volume of the convex polyhedron
-		# defined by all of the constraints.  this can be computed
-		# using the qhull library's half-space intersection
-		# implementation.
-		#
-		# the half-space instersection code assumes constraints of
-		# the form
+		# the half-space instersection code requires constraints be
+		# provided to it in the form
 		#
 		#	A x + b <= 0,
 		#
 		# where A has size (n constraints x m dimensions), where
-		# for N instruments m = N-1.  each coincidence window
+		# for N instruments m = N-1.  in this form, x is the vector
+		# of time differences between the events seen in each of
+		# the detectors and the event seen in the "anchor"
+		# instrument at the origin.  each coincidence window
 		# between an instrument, i, and the anchor imposes two
 		# constraints of the form
 		#
 		#	+/-t_{i} - \tau_{1i} <= 0
 		#
-		# for a total of 2*(N-1) constraints.  each coincidence
-		# window between a pair of (non-anchor) instruments imposes
-		# two constraints of the form
+		# giving 2*(N-1) constraints.  additionally, each
+		# coincidence window between a pair of non-anchor
+		# instruments imposes two constraints of the form
 		#
 		#	+/-(t_{i} - t_{j}) - \tau_{ij} <= 0
 		#
-		# for a total (N-1)*(N-2) constraints.  altogether there
-		# are
+		# for an additional (N-1)*(N-2) constraints.  altogether
+		# there are
 		#
 		#	n = (N-1)^2 + (N-1) = m * (m + 1)
 		#
 		# constraints
+		#
+		# the "rate factor" we compute below is the volume in units
+		# of time^(N-1) of the convex polyhedron described above.
+		# this is the proportionality constant giving us the rate
+		# of N-way mutual coincidences
+		#
+		# coinc rate = (polyhedron volume) \\prod_{i} \\mu_{i}.
+		#
+		# the volume has units of time^(N-1), the \\mu have units
+		# of 1/time, there are N of them, so as hoped the rate of
+		# coincidences has units of 1/time.
+
 			if not instruments:
 				# one-instrument case, no-op
 				self.rate_factors[key] = 1.
 			elif len(instruments) == 1:
 				# two-instrument (1-D) case, don't use qhull
-				self.rate_factors[key] = 2. * self.tau[frozenset((anchor, instruments[0]))]
+				self.rate_factors[key] = 2. * self.tau[key]
 			else:
-				# three- and more instrument (2-D and
+				# three and more instrument (2-D and
 				# higher) case
 				dimensions = len(instruments)	# anchor not included
 				halfspaces = numpy.zeros((dimensions * (dimensions + 1), dimensions + 1), dtype = "double")
@@ -1703,67 +1734,7 @@ class CoincRates(object):
 				# the origin is in the interior
 				interior = numpy.zeros((len(instruments),), dtype = "double")
 				# compute volume
-				try:
-					self.rate_factors[key] = spatial.ConvexHull(spatial.HalfspaceIntersection(halfspaces, interior).intersections).volume
-				except AttributeError:
-					# fall-through to old version
-					pass
-				else:
-					# it worked, continue
-					continue
-
-				# old stone-throwing version in case qhull
-				# is not available.  FIXME:  remove when we
-				# are sure it's not needed.  for each
-				# instrument 2...N, the interval within
-				# which an event is coincident with
-				# instrument 1
-				windows = tuple((-self.tau[frozenset((anchor, instrument))], +self.tau[frozenset((anchor, instrument))]) for instrument in instruments)
-				# pre-assemble a sequence of instrument
-				# index pairs and the maximum allowed
-				# \Delta t between them to avoid doing the
-				# work associated with assembling the
-				# sequence inside a loop
-				ijseq = tuple((i, j, self.tau[frozenset((instruments[i], instruments[j]))]) for (i, j) in itertools.combinations(range(len(instruments)), 2))
-				# compute the numerator and denominator of
-				# the fraction of events coincident with
-				# the anchor instrument that are also
-				# mutually coincident.  this is done by
-				# picking a vector of allowed \Delta ts and
-				# testing them against the coincidence
-				# windows.  the loop's exit criterion is
-				# arrived at as follows.  after d trials,
-				# the number of successful outcomes is a
-				# binomially-distributed RV with variance =
-				# d p (1 - p) <= d/4 where p is the
-				# probability of a successful outcome.  we
-				# quit when the ratio of the bound on the
-				# standard deviation of the number of
-				# successful outcomes (\sqrt{d/4}) to the
-				# actual number of successful outcomes (n)
-				# falls below rel accuracy: \sqrt{d/4} / n
-				# < rel accuracy, or
-				#
-				# \sqrt{d} < 2 * rel accuracy * n
-				#
-				# note that if the true probability is 0,
-				# so that n=0 identically, then the loop
-				# will never terminate; from the nature of
-				# the problem we know 0<p<1 so the loop
-				# will, eventually, terminate.
-				math_sqrt = math.sqrt
-				random_uniform = random.uniform
-				two_epsilon = 2. * abundance_rel_accuracy
-				n, d = 0, 0
-				while math_sqrt(d) >= two_epsilon * n:
-					dt = tuple(random_uniform(*window) for window in windows)
-					if all(abs(dt[i] - dt[j]) <= maxdt for i, j, maxdt in ijseq):
-						n += 1
-					d += 1
-				self.rate_factors[key] = float(n) / float(d)
-				for instrument in instruments:
-					self.rate_factors[key] *= 2. * self.tau[frozenset((anchor, instrument))]
-
+				self.rate_factors[key] = spatial.ConvexHull(spatial.HalfspaceIntersection(halfspaces, interior).intersections).volume
 		# done computing rate_factors
 
 
@@ -1956,6 +1927,14 @@ class CoincRates(object):
 		>>> x = iter(coincrates.random_instruments(H1 = 0.001, L1 = 0.002, V1 = 0.003))
 		>>> x.next()	# doctest: +SKIP
 		(frozenset(['H1', 'L1']), -3.738788683913535)
+
+		NOTE:  the generator yields instrument combinations drawn
+		uniformly from the set of allowed instrument combinations,
+		but this is not considered part of the definition of the
+		behaviour of this generator and this implementation detail
+		should not be relied upon by calling code.  It is stated
+		here simply for clarity in case it helps improve
+		optimization choices elsewhere.
 		"""
 		# guaranteed non-empty
 		lnP_instruments = self.lnP_instruments(**rates)

lalburst/stringutils.py

@@ -35,15 +35,13 @@ import scipy.stats
 import sys
 
 
-from ligo.lw import ligolw
-from ligo.lw import array as ligolw_array
-from ligo.lw import param as ligolw_param
-from ligo.lw import lsctables
-from ligo.lw import utils as ligolw_utils
-from ligo.lw.utils import process as ligolw_process
+from igwn_ligolw import ligolw
+from igwn_ligolw import lsctables
+from igwn_ligolw import utils as ligolw_utils
+from igwn_ligolw.utils import process as ligolw_process
 import lal
 from lal import rate
-from ligo.segments import utils as segmentsUtils
+from igwn_segments import utils as segmentsUtils
 from .offsetvector import offsetvector
 from . import snglcoinc
 
@@ -225,7 +223,7 @@ class LnLRDensity(snglcoinc.LnLRDensity):
 	def to_xml(self, name):
 		xml = super(LnLRDensity, self).to_xml(name)
 		instruments = set(key.split("_", 1)[0] for key in self.densities if key.endswith("_snr2_chi2"))
-		xml.appendChild(ligolw_param.Param.from_pyvalue("instruments", lsctables.instrumentsproperty.set(instruments)))
+		xml.appendChild(ligolw.Param.from_pyvalue("instruments", lsctables.instrumentsproperty.set(instruments)))
 		for key, pdf in self.densities.items():
 			xml.appendChild(pdf.to_xml(key))
 		return xml
@@ -233,7 +231,7 @@ class LnLRDensity(snglcoinc.LnLRDensity):
 	@classmethod
 	def from_xml(cls, xml, name):
 		xml = cls.get_xml_root(xml, name)
-		self = cls(lsctables.instrumentsproperty.get(ligolw_param.get_pyvalue(xml, "instruments")))
+		self = cls(lsctables.instrumentsproperty.get(ligolw.Param.get_param(xml, "instruments").value))
 		for key in self.densities:
 			self.densities[key] = rate.BinnedLnPDF.from_xml(xml, key)
 		return self
@@ -242,12 +240,6 @@ class LnLRDensity(snglcoinc.LnLRDensity):
 class StringCoincParamsDistributions(snglcoinc.LnLikelihoodRatioMixin):
 	ligo_lw_name_suffix = u"stringcusp_coincparamsdistributions"
 
-	@ligolw_array.use_in
-	@ligolw_param.use_in
-	@lsctables.use_in
-	class LIGOLWContentHandler(ligolw.LIGOLWContentHandler):
-		pass
-
 	def __init__(self, instruments):
 		self.triangulators = triangulators(dict.fromkeys(instruments, 8e-5))
 		self.numerator = LnLRDensity(instruments)
@@ -407,7 +399,7 @@ def load_likelihood_data(filenames, verbose = False):
 	for n, filename in enumerate(filenames, 1):
 		if verbose:
 			print("%d/%d:" % (n, len(filenames)), end=' ', file=sys.stderr)
-		xmldoc = ligolw_utils.load_filename(filename, verbose = verbose, contenthandler = StringCoincParamsDistributions.LIGOLWContentHandler)
+		xmldoc = ligolw_utils.load_filename(filename, verbose = verbose)
 		this_coinc_params = StringCoincParamsDistributions.from_xml(xmldoc, u"string_cusp_likelihood")
 		this_seglists = lsctables.SearchSummaryTable.get_table(xmldoc).get_out_segmentlistdict(lsctables.ProcessTable.get_table(xmldoc).get_ids_by_program(u"lalapps_string_meas_likelihood")).coalesce()
 		xmldoc.unlink()

lalburst/timeslides.py

@@ -25,6 +25,7 @@
 
 
 import itertools
+from tqdm import tqdm
 
 
 from . import offsetvector
@@ -188,3 +189,48 @@ def Inspiral_Num_Slides_Iter(count, offsets):
 	offsets = offsets.items()
 	for n in range(-count, +count + 1):
 		yield offsetvector.offsetvector((instrument, offset * n) for instrument, offset in offsets)
+
+
+def vacuum(time_slides, verbose = False):
+	"""
+	Given a dictionary mapping time slide ID to offsetvector, for
+	example as returned by the .as_dict() method of the TimeSlideTable
+	class in ligolw.lsctables, construct and return a mapping
+	indicating time slide equivalences.  This can be used to delete
+	redundant time slides from a time slide table, and then also used
+	via the .applyKeyMapping() method of ligolw.table.Table instances
+	to update cross references (for example in the coinc_event table).
+
+	Example:
+
+	>>> slides = {0: offsetvector({"H1": 0, "H2": 0}), 1: offsetvector({"H1": 10, "H2": 10}), 2: offsetvector({"H1": 0, "H2": 10})}
+	>>> vacuum(slides)
+	{1: 0}
+
+	indicating that time slide ID 1 describes a time slide that is
+	equivalent to time slide ID 0.  The calling code could use this
+	information to delete time slide ID 1 from the time_slide table,
+	and replace references to that ID in other tables with references
+	to time slide ID 0.
+	"""
+	# convert offsets to deltas
+	time_slides = dict((time_slide_id, offsetvect.deltas) for time_slide_id, offsetvect in time_slides.items())
+	with tqdm(total = len(time_slides), disable = not verbose) as progressbar:
+		# old --> new mapping
+		mapping = {}
+		# while there are time slide offset dictionaries remaining
+		while time_slides:
+			# pick an ID/offset dictionary pair at random
+			id1, deltas1 = time_slides.popitem()
+			# for every other ID/offset dictionary pair in the
+			# time slides, if the relative offset dictionaries
+			# are equivalent record in the old --> new mapping
+			ids_to_delete = [id2 for id2, deltas2 in time_slides.items() if deltas2 == deltas1]
+			for id2 in ids_to_delete:
+				mapping[id2] = id1
+				time_slides.pop(id2)
+			# number of offset vectors removed from time_slides
+			# in this iteration
+			progressbar.update(1 + len(ids_to_delete))
+	# done
+	return mapping

lalframe/__init__.py

@@ -1,7 +1,7 @@
 # Import SWIG wrappings, if available
-from .lalframe import *
+from ._lalframe_swig import *
 
-__version__ = "3.0.4.1"
+__version__ = "3.0.7.1"
 
 ## \addtogroup lalframe_python
 """This package provides Python wrappings and extensions to LALFrame"""

lalframe/{lalframe.py → _lalframe_swig.py}

@@ -1,5 +1,5 @@
 # This file was automatically generated by SWIG (https://www.swig.org).
-# Version 4.1.1
+# Version 4.3.1
 #
 # Do not make changes to this file unless you know what you are doing - modify
 # the SWIG interface file instead.

lalframe/frread.py

@@ -30,7 +30,8 @@ including:
 import os
 import re
 
-from lal import (utils as lalutils, lal)
+import lal
+from lal import utils as lalutils
 
 try:
     from glue import lal as gcache
@@ -39,7 +40,8 @@ except ImportError:
 else:
     _HAS_GLUE = True
 
-from . import (lalframe, git_version)
+import lalframe
+from . import git_version
 __author__ = "Duncan Macleod <duncan.macleod@ligo.org>"
 __version__ = git_version.id
 __date__ = git_version.date

lalframe/git_version.py

@@ -20,8 +20,8 @@
 # Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 # MA 02110-1301 USA
 
-id = "171dc16bb73611969b9d9d62cd7f27f076519294"
-date = "2024-04-4 22:38:44 +0000"
+id = "53acc0c2cd7ea2d3c83fc71a7bd88035c2861d6c"
+date = "2025-10-27 23:19:54 +0000"
 branch = "None"
 tag = "None"
 if tag == "None":
@@ -33,7 +33,7 @@ status = "CLEAN: All modifications committed"
 version = id
 verbose_msg = """Branch: None
 Tag: None
-Id: 171dc16bb73611969b9d9d62cd7f27f076519294
+Id: 53acc0c2cd7ea2d3c83fc71a7bd88035c2861d6c
 
 Builder: Unknown User <>
 Repository status: CLEAN: All modifications committed"""
@@ -54,9 +54,9 @@ def check_match(foreign_id, onmismatch="raise"):
     """
     if onmismatch not in ("raise", "warn"):
         raise ValueError(onmismatch + " is an unrecognized value of onmismatch")
-    if foreign_id == "171dc16bb73611969b9d9d62cd7f27f076519294":
+    if foreign_id == "53acc0c2cd7ea2d3c83fc71a7bd88035c2861d6c":
         return
-    msg = "Program id (171dc16bb73611969b9d9d62cd7f27f076519294) does not match given id (%s)." % foreign_id
+    msg = "Program id (53acc0c2cd7ea2d3c83fc71a7bd88035c2861d6c) does not match given id (%s)." % foreign_id
     if onmismatch == "raise":
         raise VersionMismatchError(msg)
 

lalframe/utils/frtools.py

@@ -25,7 +25,7 @@ __author__ = "Duncan Macleod <duncan.macleod@ligo.org>"
 
 
 def get_channels(framefile):
-    """Return a list of all channels written into the given GWF-format
+    r"""Return a list of all channels written into the given GWF-format
     framefile
 
     @param framefile

lalinference/__init__.py

@@ -1,7 +1,7 @@
 # Import SWIG wrappings, if available
-from .lalinference import *
+from ._lalinference_swig import *
 
-__version__ = "4.1.6.1"
+__version__ = "4.1.9.1"
 
 ## \addtogroup lalinference_python
 """This package provides Python wrappings and extensions to LALInference"""

lalinference/{lalinference.py → _lalinference_swig.py}

@@ -1,5 +1,5 @@
 # This file was automatically generated by SWIG (https://www.swig.org).
-# Version 4.1.1
+# Version 4.3.1
 #
 # Do not make changes to this file unless you know what you are doing - modify
 # the SWIG interface file instead.