rapid-pe 0.0.4.dev20230213__tar.gz → 0.1.2.dev20251209__tar.gz

{rapid_pe-0.0.4.dev20230213 → rapid_pe-0.1.2.dev20251209}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: rapid_pe
-Version: 0.0.4.dev20230213
+Version: 0.1.2.dev20251209
 Summary: RapidPE: The original low-latency gravitational wave parameter estimation code.
 Home-page: https://git.ligo.org/rapidpe-rift/rapidpe/
 License: GPL-2+
@@ -19,6 +19,26 @@ Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Scientific/Engineering :: Astronomy
 Classifier: Topic :: Scientific/Engineering :: Physics
 License-File: COPYING
+Requires-Dist: bilby
+Requires-Dist: h5py
+Requires-Dist: healpy
+Requires-Dist: lalsuite
+Requires-Dist: ligo.skymap
+Requires-Dist: lscsoft-glue
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: python-ligo-lw<1.9,>=1.8.1
+Requires-Dist: scikit-learn
+Requires-Dist: scipy
+Requires-Dist: six
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: summary
 
 RapidPE was the first piece of software written for rapidly measuring the
 parameters of compact binary mergers observed via gravitational waves.  It

rapid_pe-0.1.2.dev20251209/README.md

@@ -0,0 +1,27 @@
+# RapidPE
+
+The original low-latency gravitational wave parameter estimation code.
+
+# Installation
+
+The typical way to run RapidPE is as part of the [RapidPE--RIFT Pipeline](https://git.ligo.org/rapidpe-rift/rapidpe-rift-pipe).  If you do want to install RapidPE directly, you can install it in one of three ways
+```bash
+# Install from Conda (recommended)
+conda install rapid-pe
+```
+
+```bash
+# Install from PyPI
+pip install rapid-pe
+```
+
+```bash
+# Install from source
+git clone https://git.ligo.org/rapidpe-rift/rapidpe
+cd rapidpe
+pip install .
+```
+
+# Credit
+
+Copyright (c) 2012-2023 [RapidPE Contributors](CONTRIBUTORS.md)

{rapid_pe-0.0.4.dev20230213 → rapid_pe-0.1.2.dev20251209}/bin/rapidpe_compute_intrinsic_grid

@@ -28,12 +28,17 @@ import glob
 import json
 import bisect
 import re
+import math
+import operator
+import warnings
 from collections import defaultdict
+from functools import reduce
 from argparse import ArgumentParser
 from copy import copy
 
 import h5py
 import numpy
+import numpy as np
 from scipy.special import binom
 from sklearn.neighbors import BallTree
 
@@ -217,7 +222,9 @@ grid_section.add_argument("--output-xml-file-name",default="", help="Set the nam
 grid_section.add_argument("-t", "--tmplt-bank", help="XML file with template bank.")
 grid_section.add_argument("-O", "--use-overlap", action="append",help="Use overlap information to define 'closeness'. If a list of files is given, the script will find the file with the closest template, and select nearby templates only from that file.")
 grid_section.add_argument("-T", "--overlap-threshold", default=0.9,type=float, help="Threshold on overlap value.")
-grid_section.add_argument("-s", "--points-per-side", type=int, default=10, help="Number of points per side, default is 10.")
+point_specification = grid_section.add_mutually_exclusive_group()
+point_specification.add_argument("-s", "--points-per-side", type=int, help="Number of points per side.")
+point_specification.add_argument("--total-points", type=int, help="Requested total number of points in initial grid.  Note that actual number will only approximate this.")
 grid_section.add_argument("-I", "--initial-region", action="append", help="Override the initial region with a custom specification. Specify multiple times like, -I mass1=1.0,2.0 -I mass2=1.0,1.5")
 grid_section.add_argument("-D", "--deactivate", action="store_true", help="Deactivate cells initially which have no template within them.")
 grid_section.add_argument("-P", "--prerefine", help="Refine this initial grid based on overlap values.")
@@ -235,6 +242,13 @@ opts = argp.parse_args()
 if not (opts.setup or opts.refine or opts.prerefine):
     exit("Either --setup or --refine or --prerefine must be chosen")
 
+if opts.distance_coordinates == "mu1_mu2_q_s2z":
+    warnings.warn(
+        "--distance-coordinates=mu1_mu2_q_s2z has been deprecated, please use "
+        "--distance-coordinates=mu1_mu2_q_spin2z instead"
+    )
+    opts.distance_coordinates = "mu1_mu2_q_spin2z"
+
 
 # Hopefully the point is already present and we can just get it, otherwise it
 # could incur an overlap calculation, or suffer from the effects of being close
@@ -257,7 +271,7 @@ if not "spin1z" in intr_prms or not "spin2z" in intr_prms:
     else:
         sys.exit("spin1z or spin2z is specified but not the other spin. compute intrinsic grid is not setup to search just one")
 else:
-    if opts.distance_coordinates == "mu1_mu2_q_s2z":
+    if opts.distance_coordinates == "mu1_mu2_q_spin2z":
         spin_transform = opts.distance_coordinates
     else:
         spin_transform = "chi_z"
@@ -421,21 +435,37 @@ if opts.result_file:
 #
 # Build (or retrieve) the initial region
 #
+apply_truncation = False # Set to true if initial region truncation is needed
 if opts.refine or opts.prerefine:
-    init_region, region_labels = amrlib.load_init_region(opts.refine or opts.prerefine, get_labels=True)
+    grid_init_region, region_labels = amrlib.load_init_region(
+        opts.refine or opts.prerefine, get_labels=True,
+    )
 else:
+    points_per_side = opts.points_per_side
+    if opts.total_points is not None:
+        points_per_side = math.ceil(opts.total_points ** (1./len(intr_prms)))
+
     ####### BEGIN INITIAL GRID CODE #########
     if opts.initial_region is None:
         #This is the only time anything from the overlap file is used anywhere
-        init_region, idx = determine_region(pt, pts, ovrlp, opts.overlap_threshold, expand_prms)
+        grid_init_region, idx = determine_region(
+            pt, pts, ovrlp, opts.overlap_threshold, expand_prms
+        )
         region_labels = intr_prms
 #        print "init trgion",len(pts[idx:])
         # FIXME: To be reimplemented in a different way
         #if opts.expand_param is not None:
-            #expand_param(init_region, opts.expand_param)
+            #expand_param(grid_init_region, opts.expand_param)
+
     else:
         # Override initial region -- use with care
-        _, init_region = common_cl.parse_param(opts.initial_region)
+        _, boundary_init_region = common_cl.parse_param(opts.initial_region)
+
+        if len(boundary_init_region) != len(intr_prms):
+            raise ValueError(
+                "Boundary and gridding coordinate systems must have the same "
+                "number of dimensions."
+            )
 
         # HACK: These labels do not actually match the data, but they mis-match
         #       in a way that is self-consistent with the rest of the code.
@@ -446,12 +476,6 @@ else:
         param_mapping = {}
 
         def map_param(source, target):
-            if source not in init_region:
-                # User forgot to provide the required -I parameter
-                raise ValueError(
-                    f"Parameter {source} must be provided by -I or "
-                    "--initial-region argument for the chosen coordinate system"
-                )
             try:
                 # Indicate that the input parameter maps to the given index
                 param_mapping[source] = region_labels.index(target)
@@ -463,7 +487,7 @@ else:
                     "from the intrinsic parameters"
                 )
 
-        if opts.distance_coordinates == "mu1_mu2_q_s2z":
+        if opts.distance_coordinates == "mu1_mu2_q_spin2z":
             map_param("mu1", "mass1")
             map_param("mu2", "mass2")
             map_param("q", "spin1z")
@@ -495,17 +519,187 @@ else:
             else:
                 raise ValueError(f"Unknown spin transform {spin_transform}")
 
-        if len(param_mapping) != len(init_region):
+        if len(param_mapping) != len(boundary_init_region):
             raise ValueError(
-                f"Provided -I parameters {set(init_region.keys())}, but "
+                f"Provided -I parameters {set(boundary_init_region.keys())}, but "
                 f"expected parameters {set(param_mapping.keys())}"
             )
 
-        # Map the input ranges into an amrlib.Cell
-        init_region_array = numpy.empty((len(region_labels), 2))
-        for param_name, index in param_mapping.items():
-            init_region_array[index] = init_region[param_name]
-        init_region = amrlib.Cell(init_region_array)
+        # ### OLD ###
+        # NOTE: init_region has been re-named grid_init_region or
+        #       boundary_init_region depending on coordinates
+
+        # # Map the input ranges into an amrlib.Cell
+        # init_region_array = numpy.empty((len(region_labels), 2))
+        # for param_name, index in param_mapping.items():
+        #     init_region_array[index] = init_region[param_name]
+        # init_region = amrlib.Cell(init_region_array)
+
+        ### END ###
+
+        # There are two sets of coordinates:
+        # - the prior-boundary coordinates: `boundary_init_region`
+        # - the coordinates in which the grid is rectilinear:
+        #   `distance_coordinates` and `spin_transform`
+        #   which we'll call the "grid coordinates"
+        #
+        # Here we use a dense grid in the prior-boundary coordinates to
+        # approximately find the limits of the grid coordinates.  In all but
+        # one case, the spin coordinates are the same for both, so we only worry
+        # about the mass coordinates.
+
+        if boundary_init_region.keys() == {"mu1", "mu2", "q", "spin2z"}:
+            # mu1-mu2-q-spin2z is a special case, where mass and spin are
+            # combined through mu1, mu2, and spin2z, so we have to consider
+            # everything.
+            boundary_check_mass_coordinate_names = boundary_init_region.keys()
+            spin_transform_bound = spin_transform
+        else:
+            # The standard case has 2 mass coordinates along with chieff, chia,
+            # so we strip out the two spins as they will not impact the
+            # boundaries.
+            boundary_check_mass_coordinate_names = (
+                boundary_init_region.keys() - {"chieff", "chia"}
+            )
+            assert len(boundary_check_mass_coordinate_names) == 2, \
+              f"Expected 2 mass parameters, but got: " + \
+              ", ".join(boundary_check_mass_coordinate_names)
+
+            spin_transform_bound = None if spin_transform is None else 'chi_z'
+
+
+        # Get a string representation of the prior-boundary coordinates
+        boundary_check_mass_coordinates = "_".join(
+            boundary_check_mass_coordinate_names
+        )
+        # Get the limits of the prior boundary, turning param_name -> [min, max]
+        # into a list of each [min, max]
+        boundary_values = list(boundary_init_region.values())
+
+        # Determine how dense to make the prior-boundary coordinate grids for
+        # bounds checking.  While we'd like to go very dense, in higher
+        # dimensions this becomes computationally infeasible.  In the future we
+        # should take a smarter approach than we do now.
+        if len(boundary_init_region.keys())>2:
+            warnings.warn('4 dimensions in initial boundary region. To reduce '
+                          'computation, using only 7 points per dimension '
+                          'to find the initial region boundaries.'
+            )
+            boundary_check_points_per_side = 7
+        else:
+            boundary_check_points_per_side = 50
+
+        # Construct 1-D grids along each of the prior-boundary coordinate axes
+        boundary_check_1d_grids = [
+            np.linspace(lower_bound, upper_bound,
+                        boundary_check_points_per_side)
+            for lower_bound, upper_bound in boundary_values
+        ]
+        # Convert 1-D grids to a dense mesh grid
+        boundary_check_meshgrids = np.asarray(
+            np.meshgrid(*boundary_check_1d_grids, indexing="ij")
+        ).T
+
+        # Transform mesh grid in prior-boundary coordinates...
+        #
+        # ...first from prior-boundary coordinates to m1, m2[, spin1z, spin2z]
+        boundary_check_converted = amrlib.apply_inv_transform(
+            boundary_check_meshgrids,
+            intr_prms,
+            mass_transform=boundary_check_mass_coordinates,
+            spin_transform=spin_transform_bound,
+        )
+        # ...then from m1, m2[, spin1z, spin2z] to the grid coordinates.
+        boundary_check_converted = amrlib.apply_transform(
+            boundary_check_converted,
+            intr_prms,
+            mass_transform=opts.distance_coordinates,
+            spin_transform=spin_transform,
+        )
+
+        # Create a column matrix with the min and max of each grid coordinate
+        #
+        # [ min(grid_coord[0]), max(grid_coord[0]) ]
+        # [        ...        ,        ...         ]
+        # [ min(grid_coord[N]), max(grid_coord[N]) ]
+        axes_to_min_max = tuple(range(0, len(region_labels)))
+        grid_init_region_boundaries = np.column_stack((
+            np.nanmin(boundary_check_converted, axis=axes_to_min_max),
+            np.nanmax(boundary_check_converted, axis=axes_to_min_max),
+        ))
+
+        # Convert matrix into the initial AMR Cell
+        grid_init_region = amrlib.Cell(grid_init_region_boundaries)
+
+        # AMR requires `points_per_side`, but if `opts.total_points` was
+        # specified, and truncation may have occurred due to the different
+        # prior-boundary and grid coordinates, we need to find the minimal
+        # `points_per_side` that meets our `opts.total_points` requirement.
+        if opts.total_points is not None:
+            apply_truncation = True # Ensures truncation applied later
+            while True:
+                # Construct 1-D grids along each of the grid coordinate axes
+                total_points_check_1d_grids = [
+                    np.linspace(lower_bound, upper_bound, points_per_side)
+                    for lower_bound, upper_bound in grid_init_region_boundaries
+                ]
+                # Convert 1-D grids to a dense mesh grid
+                total_points_check_meshgrids = np.column_stack(
+                    tuple(mesh.flatten() for mesh in np.meshgrid(
+                        *total_points_check_1d_grids, indexing="ij")
+                ))
+                # Compute mask array which is True where the corresponding
+                # grid value is physical.  Skipping this could cause issues
+                # with transformation functions.
+                bounds_mask = amrlib.check_grid(
+                    total_points_check_meshgrids,
+                    intr_prms,
+                    opts.distance_coordinates,
+                )
+
+                # Transform mesh grid in grid coordinates...
+                #
+                # ...first from grid coordinates to m1, m2[, spin1z, spin2z]
+                total_points_check_converted = amrlib.apply_inv_transform(
+                    total_points_check_meshgrids[bounds_mask],
+                    intr_prms,
+                    mass_transform=opts.distance_coordinates,
+                    spin_transform=spin_transform,
+                )
+                # ...then from m1, m2[, spin1z, spin2z] to the prior-boundary
+                # coordinates.
+                total_points_check_converted = amrlib.apply_transform(
+                    total_points_check_converted,
+                    intr_prms,
+                    mass_transform=boundary_check_mass_coordinates,
+                    spin_transform=spin_transform_bound,
+                )
+                # Determine whether each point is within the prior-boundary
+                # limits
+                total_points_check_is_in_bounds = reduce(operator.and_, [
+                    (lower_bound <= points) & (points <= upper_bound)
+                    for points, (lower_bound, upper_bound)
+                    in zip(total_points_check_converted.T, boundary_values)
+                ])
+                # Count the number of points which were in our prior boundary,
+                total_points = np.count_nonzero(total_points_check_is_in_bounds)
+                # If the count meets the `opts.total_points` requirement then
+                # we're done, otherwise try again with one more point per side.
+                if total_points >= opts.total_points:
+                    break
+                else:
+                    points_per_side += 1
+
+            # Later we'll want to re-use the boundary checking we've already
+            # done.  We need to know the indices in
+            # `total_points_check_meshgrids` which were both physical and within
+            # the prior bounds.  For that we need to combine the information in
+            # `bounds_mask` and `total_points_check_is_in_bounds`.
+            truncation_mask = (
+                np.zeros_like(total_points_check_meshgrids[:,0], dtype=bool)
+            )
+            truncation_mask[bounds_mask] = total_points_check_is_in_bounds
+
 
         # Old code below: used incorrect labeling
 #        region_labels = init_region.keys()
@@ -513,8 +707,11 @@ else:
 
     # TODO: Alternatively, check density of points in the region to determine
     # the points to a side
-    grid, spacing = amrlib.create_regular_grid_from_cell(init_region, side_pts=opts.points_per_side // 2, return_cells=True)
-    
+    grid, spacing = amrlib.create_regular_grid_from_cell(
+        grid_init_region, side_pts=points_per_side,
+        return_cells=True,
+    )
+
     # "Deactivate" cells not close to template points
     # FIXME: This gets more and more dangerous in higher dimensions
     # FIXME: Move to function
@@ -537,8 +734,8 @@ intr_prms = list(region_labels)
 if opts.refine or opts.prerefine:
     res_pts = res_pts[:,reindex]
 
-extent_str = " ".join("(%f, %f)" % bnd for bnd in map(tuple, init_region._bounds))
-center_str = " ".join(map(str, init_region._center))
+extent_str = " ".join("(%f, %f)" % bnd for bnd in map(tuple, grid_init_region._bounds))
+center_str = " ".join(map(str, grid_init_region._center))
 label_str = ", ".join(region_labels)
 print("Initial region (" + label_str + ") has center " + center_str + " and extent " + extent_str)
 
@@ -567,13 +764,13 @@ if opts.prerefine:
     results = results[pt_select]
     grid, spacing = amrlib.refine_regular_grid(selected, spacing, return_cntr=True)
 
-else:
+elif opts.refine:
 #    print "selected",len(selected)
     grid, spacing = amrlib.refine_regular_grid(selected, spacing, return_cntr=opts.setup)
 #    print "refine grid",len(grid)
 
 print("%d cells after refinement" % len(grid))
-grid = amrlib.prune_duplicate_pts(grid, init_region._bounds, spacing)
+grid = amrlib.prune_duplicate_pts(grid, grid_init_region._bounds, spacing)
 #print "prune grid",len(grid)
 #
 # Clean up
@@ -581,6 +778,10 @@ grid = amrlib.prune_duplicate_pts(grid, init_region._bounds, spacing)
 
 grid = numpy.array(grid)
 bounds_mask = amrlib.check_grid(grid, intr_prms, opts.distance_coordinates)
+
+if apply_truncation:
+    bounds_mask &= truncation_mask.flatten()
+
 grid = grid[bounds_mask]
 print("%d cells after bounds checking" % len(grid))
 
@@ -594,7 +795,7 @@ grid = amrlib.apply_inv_transform(grid, intr_prms, opts.distance_coordinates,spi
 cells = amrlib.grid_to_cells(grid, spacing)
 if opts.setup:
     hdf_filename = opts.setup+".hdf" if not ".hdf" in opts.setup else opts.setup
-    grid_group = amrlib.init_grid_hdf(init_region, hdf_filename, opts.overlap_threshold, opts.distance_coordinates, intr_prms=intr_prms)
+    grid_group = amrlib.init_grid_hdf(grid_init_region, hdf_filename, opts.overlap_threshold, opts.distance_coordinates, intr_prms=intr_prms)
     level = amrlib.save_grid_cells_hdf(grid_group, cells, "mass1_mass2", intr_prms=intr_prms)
 else:
     grp = amrlib.load_grid_level(opts.refine, None)

{rapid_pe-0.0.4.dev20230213 → rapid_pe-0.1.2.dev20251209}/bin/rapidpe_create_event_dag

@@ -25,6 +25,7 @@ from __future__ import print_function
 import sys
 import os
 import ast
+import json
 import re
 from argparse import ArgumentParser
 
@@ -60,10 +61,13 @@ argp.add_argument("--write-script", action="store_true", help="In addition to th
 argp.add_argument("--write-eff-lambda", action="store_true", help="Use psi0 column of template bank XML as effective lambda point to calculate in DAG.")
 argp.add_argument("--write-deff-lambda", action="store_true", help="Use psi3 column of template bank XML as delta effective lambda point to calculate in DAG.")
 argp.add_argument("--condor-command", action="append", help="Append these condor commands to the submit files. Useful for account group information.")
+argp.add_argument("--accounting-group-user",default=None, help="accounting-group-user for condor")
 argp.add_argument("--exe-integrate-likelihood", default=None, help="This is executable to use to integrate the extrinsic likelihood per intrinsic grid point. It will default to the lalsuite rapidpe_integrate_extrinsic_likelihood.")
 argp.add_argument("--integration-args-dict", default="", help="Pass these options as the kwargs input of the integrate dag creation function. They will be set, without editing, as input to the integration exe. If you use this, it will not be possible to also pass other command line arguments to the integration executable via the create_event_dag command line.")
+argp.add_argument("--getenv", nargs="+", help="JSON encoded list of environment variable names to pass to Condor.")
+argp.add_argument("--environment", help="JSON encoded dictionary of environment variables to pass to Condor.")
 argp.add_argument("--iteration-level", default=None, help="integer denoting the iteration level")
-
+argp.add_argument("--cProfile", action="store_true", help="if True, cProfile each ILE job.")
 
 for cat, val in MAXJOBS.items():
     optname = "--maxjobs-%s" % cat.lower().replace("_", "-")
@@ -84,7 +88,13 @@ if not opts.template_bank_xml:
 condor_commands = None
 if opts.condor_command is not None:
     condor_commands = dict([c.split("=") for c in opts.condor_command])
+if opts.accounting_group_user:
+    condor_commands['accounting_group_user'] = opts.accounting_group_user
 
+if opts.environment is None:
+    environment_dict = None
+else:
+    environment_dict = json.loads(opts.environment)
 
 #
 # Get trigger information from coinc xml file
@@ -125,14 +135,14 @@ if tmplt_bnk is None:
 use_bayespe_postproc = False
 
 # initialize the analysis subdag
-dag = pipeline.CondorDAG(log=os.getcwd())
+dag = pipeline.CondorDAG(log=opts.log_directory)
 
 if opts.maxjobs_ile is not None:
     dag.add_maxjobs_category("ILE", opts.maxjobs_ile)
 
 # This is a subdag used for all our plotting and postproc so they don't block
 # completion of an individual event's ILEs
-ppdag = pipeline.CondorDAG(log=os.getcwd())
+ppdag = pipeline.CondorDAG(log=opts.log_directory)
 ppdag.add_maxjobs_category("SQL", MAXJOBS["SQL"])
 ppdag.add_maxjobs_category("PLOT", MAXJOBS["PLOT"])
 
@@ -167,6 +177,8 @@ if opts.integration_args_dict != "":
         ncopies=opts.n_copies,
         output_file=opts.output_file,
         iteration_level=opts.iteration_level,
+        getenv=opts.getenv,
+        environment_dict=environment_dict,
         **ast.literal_eval(opts.integration_args_dict)
         )
 
@@ -194,6 +206,8 @@ else:
         save_samples=opts.save_samples,
         output_file=opts.output_file,
         iteration_level=opts.iteration_level,
+        getenv=opts.getenv,
+        environment_dict=environment_dict,
         n_eff=opts.n_eff,
         n_max=opts.n_max,
         ncopies=opts.n_copies,
@@ -204,17 +218,22 @@ else:
         skymap_file=(opts.skymap_file or False),
         distance_maximum=opts.distance_maximum,
         )
+
+ile_sub_name = os.path.join(opts.working_directory,ile_sub_name)
+ile_job_type.set_sub_file(ile_sub_name)
 ile_job_type.write_sub_file()
 
+
+
 with open(ile_sub_name,'r') as integrate_sub_file:
     integrate_subfile_content = integrate_sub_file.read()
 
-if 'cProfile' in ast.literal_eval(opts.integration_args_dict):
+if opts.cProfile:
     uniq_str = "$(cluster)-$(process)"
     cprofile_stats_file = os.path.join(opts.log_directory, f'cprofile_integrate-{uniq_str}')
     replacement_pattern = rf'\1 -m cProfile -o {cprofile_stats_file}-\3.out {exe} \2\3\4'
 else:
-    replacement_pattern =  rf'\1{exe} \2\3\4'
+    replacement_pattern =  rf'\1 {exe} \2\3\4'
 
 replaced_integrate_subfile_content = re.sub(r'^(\s*arguments\s*=\s*\")(.*)(ILE_iteration_[0-9]+)(.*)$', replacement_pattern,integrate_subfile_content,flags = re.MULTILINE)
 
@@ -224,7 +243,7 @@ with open(ile_sub_name,'w') as integrate_sub_file:
 if use_bayespe_postproc:
     if not os.path.exists(opts.web_output):
         os.makedirs(opts.web_output)
-    bpp_plot_job_type, bpp_plot_job_name = dagutils.write_bayes_pe_postproc_sub(tag="bayes_pp_plot", log_dir=opts.log_directory, web_dir=opts.web_output)
+    bpp_plot_job_type, bpp_plot_job_name = dagutils.write_bayes_pe_postproc_sub(tag="bayes_pp_plot", log_dir=opts.log_directory, web_dir=opts.web_output, getenv=opts.getenv, environment_dict=environment_dict)
     bpp_plot_job_type.write_sub_file()
     bpp_plot_node = pipeline.CondorDAGNode(bpp_plot_job_type)
     bpp_plot_node.set_category("PLOT")

{rapid_pe-0.0.4.dev20230213 → rapid_pe-0.1.2.dev20251209}/rapid_pe/__init__.py

@@ -1,3 +1,3 @@
 # -*- coding: utf-8 -*-
 
-__version__ = "0.0.4"
+__version__ = "0.1.2"

{rapid_pe-0.0.4.dev20230213 → rapid_pe-0.1.2.dev20251209}/rapid_pe/amrlib.py

@@ -1,15 +1,16 @@
+import functools
 import itertools
 import copy
 
 import numpy
+import numpy as np
 import h5py
+from scipy.optimize import bisect
 
 import lal
 
 from . import lalsimutils
 
-m1m2 = numpy.vectorize(lalsimutils.m1m2)
-
 #
 # Utility functions
 #
@@ -486,7 +487,7 @@ def transform_m1m2_mceta(m1, m2):
     return lalsimutils.Mceta(m1, m2)
 
 def transform_mceta_m1m2(mc, eta):
-    return m1m2(mc, eta)
+    return lalsimutils.m1m2(mc, eta)
 
 __prefac_0 = 5. / 256 / numpy.pi
 __prefac_3 = 1. / 8
@@ -501,7 +502,7 @@ __prefac_tau = 5. / 32 / numpy.pi
 def transform_tau0tau3_m1m2(tau0, tau3, flow=40.):
     mt = __prefac_tau / numpy.pi / flow * tau3 / tau0
     eta = 1.0 / 8 / flow / tau3 * (tau0 / __prefac_tau / tau3)**(2./3)
-    m1, m2 = m1m2(mt*eta**(3./5), eta)
+    m1, m2 = lalsimutils.m1m2(mt*eta**(3./5), eta)
     return m1 / __dim_mass, m2 / __dim_mass
 
 def transform_s1zs2z_chi(m1, m2, s1z, s2z):
@@ -532,6 +533,16 @@ def transform_mcq_m1m2(mc, q):
     m = mc * (1 + q)**(1./5)
     return m / q**(3./5), m * q**(2/5.)
 
+def transform_mtotalq_m1m2(mtotal,q):
+    m1 = mtotal / (1.+q)
+    m2 = q*m1
+    return m1,m2
+
+def transform_m1m2_mtotalq(m1,m2):
+    mtotal = m1+m2
+    q = numpy.min([m1, m2], axis=0) / numpy.max([m1, m2], axis=0)
+    return mtotal,q
+
 MsunToTime = 4.92659 * 10.0**(-6.0)  # conversion from solar mass to seconds
 fref_mu = 200.  # reference frequency to calculate mu1 and mu2 introduced in (TODO: add reference here once the paper is in arxiv)
 # coefficients of mu1 and mu2
@@ -583,31 +594,45 @@ def transform_m1m2s1zs2z_mu1mu2qs2z(m1, m2, s1z, s2z):
         s2z
     )
 
-def _cancel_psi3(mc, eta):
-    return (mu_coeffs[0, 0] - mu_coeffs[1, 0] * mu_coeffs[0, 2] / mu_coeffs[1, 2]) * mcTopsi0(mc) + \
-        (mu_coeffs[0, 1] - mu_coeffs[1, 1] * mu_coeffs[0, 2] / mu_coeffs[1, 2]) * mcetaTopsi2(mc, eta)
-
 def _mu1mu2etaTomc(mu1, mu2, eta):
-    """Convert mu1, mu2, eta=m1*m2/(m1+m2)**2 into chirpmass using bisection search."""
-    psi3 = mu1 - (mu_coeffs[0, 2] / mu_coeffs[1, 2]) * mu2
-    mcmin = mcmax = (128. * mu1 / 3.)**(-3. / 5.) / (numpy.pi * fref_mu * MsunToTime)
-    while _cancel_psi3(mcmax, eta) >= psi3:
-        mcmax = mcmax * 2.
-    while _cancel_psi3(mcmin, eta) < psi3:
-        mcmin = mcmin * 0.5
-    mcmid = (mcmin + mcmax) / 2.
-    while ((mcmax - mcmin) / mcmin) > 10.**(-6.):
-        if _cancel_psi3(mcmid, eta) > psi3:
-            mcmin = mcmid
-        else:
-            mcmax = mcmid
-        mcmid = (mcmin + mcmax) / 2.
-    return mcmid
+    """Convert mu1, mu2, eta=m1*m2/(m1+m2)**2 into chirp mass.
+
+    mu1 and mu2 are given by linear combinations of psi0, psi2, and psi3:
+
+    .. math::
+
+        \mu^1 = k_0 \psi^0 + k_2 \psi^2 + k_3 \psi^3,
+        \mu^2 = l_0 \psi^0 + l_2 \psi^2 + l_3 \psi^3.
+
+    To cancel spin contributions, the following quantity is calculated:
+
+    .. math::
+
+        \alpha = \mu^1 - k_3 / l_3 \mu^2
+
+    Then, the following equation is solved with respect to chirpmass using bisection search:
+
+    .. math::
+
+        (k_0 - l_0 k_3 / l_3) \psi^0 + (k_2 - l_2 k_3 / l_3) \psi^2 = \alpha
+
+    """
+    alpha = mu1 - (mu_coeffs[0, 2] / mu_coeffs[1, 2]) * mu2
+    a = 3 / 128 * (mu_coeffs[0, 0] - mu_coeffs[1, 0] * mu_coeffs[0, 2] / mu_coeffs[1, 2])
+    b = 55 / 384 * (eta + 743 / 924) * eta**(-2 / 5) * (mu_coeffs[0, 1] - mu_coeffs[1, 1] * mu_coeffs[0, 2] / mu_coeffs[1, 2])
+    func = lambda y: a * y**5 + b * y**3 - alpha  # y refers to (pi * mc * fref)^(-1 / 3)
+    # bisection search assuming a>0, b>0, and alpha>0
+    ymax = (alpha / a)**(1 / 5)
+    y = bisect(func, 0, ymax)
+    return 1 / (numpy.pi * fref_mu * MsunToTime * y**3)
+
 
 def mu1mu2etaTomc(mu1, mu2, eta):
     """Convert mu1, mu2, eta=m1*m2/(m1+m2)**2 into chirpmass using bisection search. This function allows array as input"""
     if type(mu1) is numpy.ndarray:
-        return numpy.array([_mu1mu2etaTomc(_mu1, _mu2, _eta) for _mu1, _mu2, _eta in zip(mu1, mu2, eta)])
+        if mu1.size == 0:
+            return np.empty_like(mu1)
+        return numpy.vectorize(_mu1mu2etaTomc)(mu1, mu2, eta)
     else:
         return _mu1mu2etaTomc(mu1, mu2, eta)
 
@@ -622,9 +647,16 @@ def mu2mcetas2zTos1z(mu2, mc, eta, s2z):
 def transform_mu1mu2qs2z_m1m2s1zs2z(mu1, mu2, q, s2z):
     """mu1, mu2, q=m2/m1, z-component of secondary spin to component masses: m1, m2 and z-components of spins: s1z, s2z"""
     eta = qToeta(q)
-    mc = mu1mu2etaTomc(mu1, mu2, eta)
+
+    eta_valid = (0 < eta) & (eta <= 0.25)
+
+    mc = numpy.full_like(eta, numpy.nan)
+    mc[eta_valid] = mu1mu2etaTomc(
+        mu1[eta_valid], mu2[eta_valid], eta[eta_valid],
+    )
+
     s1z = mu2mcetas2zTos1z(mu2, mc, eta, s2z)
-    m1, m2 = m1m2(mc, eta)
+    m1, m2 = lalsimutils.m1m2(mc, eta)
     return m1, m2, s1z, s2z
 
 #
@@ -650,20 +682,33 @@ def check_mchirpeta(mchirp, eta):
 
 def check_mchirpq(mchirp, q):
     mchirp_arr = numpy.asarray(mchirp)
-    q_arr = numpy.asarray(q)
-    return (q_arr <= 0.25) & (q_arr > 0) & (mchirp_arr > 0)
+    return check_q(q) & (mchirp_arr > 0)
+
+def check_mtotalq(mtotal, q):
+    mtotal_arr = numpy.asarray(mtotal)
+    return check_q(q) & (mtotal_arr > 0)
 
 def check_spins(spin):
     return numpy.sqrt(numpy.atleast_2d(spin**2).sum(axis=0)) <= 1
 
 def check_q(q):
-    return (numpy.array(q)>0.)
+    q_arr = numpy.asarray(q)
+    return (q_arr > 0.) & (q_arr <= 1.) 
 
 def check_mass1mass2(mass1,mass2):
     mass1_arr = numpy.array(mass1)
     mass2_arr = numpy.array(mass2)
     return (mass1_arr>mass2_arr) & (mass1_arr > 0.) & (mass2_arr > 0.)
 
+BOUND_CHECK_MASS = {
+    "mchirp_eta": check_mchirpeta,
+    "mchirp_q": check_mchirpq,
+    "tau0_tau3": check_tau0tau3,
+    "mtotal_q": check_mtotalq,
+    "mass1_mass2": check_mass1mass2,
+    None: None
+}
+
 # Make sure the new grid points are physical
 def check_grid(grid, intr_prms, distance_coordinates):
     """
@@ -672,20 +717,14 @@ def check_grid(grid, intr_prms, distance_coordinates):
     m1_axis, m2_axis = intr_prms.index("mass1"), intr_prms.index("mass2")
     grid_check = numpy.array(grid).T
     if distance_coordinates != 'mu1_mu2_q_s2z':
-        if distance_coordinates == "tau0_tau3":
-            bounds_mask = check_tau0tau3(grid_check[m1_axis], grid_check[m2_axis])
-        elif distance_coordinates == "mchirp_eta":
-            bounds_mask = check_mchirpeta(grid_check[m1_axis], grid_check[m2_axis])
-        elif distance_coordinates == "mchirp_q":
-            bounds_mask = check_mchirpq(grid_check[m1_axis], grid_check[m2_axis])
-        elif distance_coordinates == "mass1_mass2":
-            bounds_mask = check_mass1mass2(grid_check[m1_axis], grid_check[m2_axis])
-        else:
+        try:
+            bound_check_func = BOUND_CHECK_MASS[distance_coordinates]
+            bounds_mask = bound_check_func(grid_check[m1_axis],grid_check[m2_axis])
+        except KeyError:
             raise NotImplementedError(
                 f"Coordinate system {distance_coordinates} needs a bounds "
                 f"check implemented."
             )
-
         # FIXME: Needs general spin
         if "spin1z" in intr_prms:
             s1_axis = intr_prms.index("spin1z")
@@ -697,7 +736,7 @@ def check_grid(grid, intr_prms, distance_coordinates):
             chi_axis = intr_prms.index("chi_z")
             bounds_mask &= check_spins(grid_check[chi_axis])
     else:
-        # spin1z axis is replaced by values for q if distance_coordinates = mu1_mu2_q_s2z'
+        # spin1z axis is replaced by values for q if distance_coordinates = mu1_mu2_q_spin2z'
         # So, check_q takes values from spin1z axis
         s1_axis = intr_prms.index("spin1z")
         bounds_mask = check_q(grid_check[s1_axis])
@@ -706,10 +745,11 @@ def check_grid(grid, intr_prms, distance_coordinates):
     return bounds_mask
 
 VALID_TRANSFORMS_MASS = {
-    "mchirp_eta": transform_m1m2_mceta,
-    "mchirp_q": transform_m1m2_mcq,
-    "tau0_tau3": transform_m1m2_tau0tau3,
-    "mu1_mu2_q_s2z": transform_m1m2s1zs2z_mu1mu2qs2z,
+    frozenset({"mchirp","eta"}): transform_m1m2_mceta,
+    frozenset({"mchirp","q"}): transform_m1m2_mcq,
+    frozenset({"tau0","tau3"}): transform_m1m2_tau0tau3,
+    frozenset({"mtotal", "q"}): transform_m1m2_mtotalq,
+    frozenset({"mu1","mu2","q","spin2z"}): transform_m1m2s1zs2z_mu1mu2qs2z,
     None: None
 }
 
@@ -717,63 +757,130 @@ INVERSE_TRANSFORMS_MASS = {
     transform_m1m2_mceta: transform_mceta_m1m2,
     transform_m1m2_mcq: transform_mcq_m1m2,
     transform_m1m2_tau0tau3: transform_tau0tau3_m1m2,
+    transform_m1m2_mtotalq: transform_mtotalq_m1m2,
     transform_m1m2s1zs2z_mu1mu2qs2z: transform_mu1mu2qs2z_m1m2s1zs2z,
     None: None
 }
 
 def apply_transform(pts, intr_prms, mass_transform=None, spin_transform=None):
-##%    #FIXME TESTING
-##%    m1,m2 = 8.87543,16.149322
-##%    print "pre inv transofmr",m1,m2
-##%    t1,t2 = VALID_TRANSFORMS_MASS[mass_transform](m1,m2)
-##%    print "transform",t1,t2
-##%    print mass_transform
-##%    print "inv",INVERSE_TRANSFORMS_MASS[VALID_TRANSFORMS_MASS[mass_transform]](t1,t2)
-##%    assert 1==0
-##%##%
-    # You know what... recarrays are dumb, and so's your face.
-    # FIXME: Why does numpy want me to repack this into tuples!?
-    #tpts = numpy.array([tuple(pt) for pt in pts.T], dtype = numpy.dtype([(a ,"float64") for a in intr_prms]))
-
-    m1_idx, m2_idx = intr_prms.index("mass1"), intr_prms.index("mass2")
-    if mass_transform == "mu1_mu2_q_s2z":
-        s1z_idx, s2z_idx = intr_prms.index("spin1z"), intr_prms.index("spin2z")
-        pts[:,m1_idx], pts[:,m2_idx], pts[:,s1z_idx],pts[:,s2z_idx] = VALID_TRANSFORMS_MASS[mass_transform](pts[:,m1_idx], pts[:,m2_idx], pts[:,s1z_idx], pts[:,s2z_idx]) 
+    """
+    Transforms `pts` from `intr_prms` coordinates ("mass1", "mass2", and
+    optionally "spin1z" and "spin2z") into the system specified by
+    `mass_transform` and `spin_transform`.  Transformation is performed
+    in-place.
+    """
+    mass_transform_name = mass_transform
+    if mass_transform is not None:
+        mass_transform = frozenset(mass_transform.split("_"))
+
+    m1_idx = intr_prms.index("mass1")
+    m2_idx = intr_prms.index("mass2")
+
+    if mass_transform == {"mu1", "mu2", "q", "spin2z"}:
+        s1z_idx = intr_prms.index("spin1z")
+        s2z_idx = intr_prms.index("spin2z")
+
+        mu1_idx = m1_idx
+        mu2_idx = m2_idx
+        q_idx = s1z_idx
+
+        (
+            pts[...,mu1_idx], pts[...,mu2_idx],
+            pts[...,q_idx], pts[...,s2z_idx],
+        ) = VALID_TRANSFORMS_MASS[mass_transform](
+            pts[...,m1_idx], pts[...,m2_idx],
+            pts[...,s1z_idx], pts[...,s2z_idx],
+        )
     else:
         if spin_transform:
             if spin_transform == "chi_z":
-                s1z_idx, s2z_idx = intr_prms.index("spin1z"), intr_prms.index("spin2z")
-#                chi_z = transform_s1zs2z_chi(pts[:,m1_idx], pts[:,m2_idx], pts[:,s1z_idx], pts[:,s2z_idx]) 
-                #The grid is converted from m1 m2 s1 s2 to mc eta chi_eff because it's better to choose the closest grid points in mc eta chi_eff space. 
-                #chi_a is not considered when choosing the closes grid points, but we do need it to transform back to s1 s2
-                pts[:,s1z_idx],pts[:,s2z_idx] = transform_s1zs2z_chi_eff_chi_a(pts[:,m1_idx], pts[:,m2_idx], pts[:,s1z_idx], pts[:,s2z_idx])
-                
-#                pts = numpy.vstack((pts.T, chi_eff)).T
-#                intr_prms.append("chi_z")
-
-        if mass_transform != "mass1_mass2":
-           pts[:,m1_idx], pts[:,m2_idx] = VALID_TRANSFORMS_MASS[mass_transform](pts[:,m1_idx], pts[:,m2_idx])
-
+                s1z_idx = intr_prms.index("spin1z")
+                s2z_idx = intr_prms.index("spin2z")
+
+                chieff_idx = s1z_idx
+                chia_idx = s2z_idx
+
+                (
+                    pts[...,chieff_idx], pts[...,chia_idx],
+                ) = transform_s1zs2z_chi_eff_chi_a(
+                    pts[...,m1_idx], pts[...,m2_idx],
+                    pts[...,s1z_idx], pts[...,s2z_idx],
+                )
+            else:
+                raise NotImplementedError(
+                    f"Unknown spin_transform: {spin_transform}"
+                )
+
+        if mass_transform != {"mass1", "mass2"}:
+            mA_idx = m1_idx
+            mB_idx = m2_idx
+
+            (
+                pts[...,mA_idx], pts[...,mB_idx],
+            ) = VALID_TRANSFORMS_MASS[mass_transform](
+                pts[...,m1_idx], pts[...,m2_idx],
+            )
     # Independent transforms go here
 
     return pts
 
-def apply_inv_transform(pts, intr_prms, mass_transform=None,spin_transform=None):
-    m1_idx, m2_idx = intr_prms.index("mass1"), intr_prms.index("mass2")
-
-    if mass_transform == "mu1_mu2_q_s2z":
-        s1z_idx, s2z_idx = intr_prms.index("spin1z"), intr_prms.index("spin2z")
-        pts[:,m1_idx], pts[:,m2_idx], pts[:,s1z_idx],pts[:,s2z_idx] = INVERSE_TRANSFORMS_MASS[VALID_TRANSFORMS_MASS[mass_transform]](pts[:,m1_idx], pts[:,m2_idx], pts[:,s1z_idx], pts[:,s2z_idx])
+def apply_inv_transform(pts, intr_prms,
+                        mass_transform=None, spin_transform=None):
+    """
+    The inverse of `apply_transform`.
+    """
+    mass_transform_name = mass_transform
+    if mass_transform is not None:
+        mass_transform = frozenset(mass_transform.split("_"))
+
+    m1_idx = intr_prms.index("mass1")
+    m2_idx = intr_prms.index("mass2")
+
+    if mass_transform == {"mu1", "mu2", "q", "spin2z"}:
+        s1z_idx = intr_prms.index("spin1z")
+        s2z_idx = intr_prms.index("spin2z")
+
+        mu1_idx = m1_idx
+        mu2_idx = m2_idx
+        q_idx = s1z_idx
+
+        (
+            pts[...,m1_idx], pts[...,m2_idx],
+            pts[...,s1z_idx], pts[...,s2z_idx],
+        ) = INVERSE_TRANSFORMS_MASS[VALID_TRANSFORMS_MASS[mass_transform]](
+            pts[...,mu1_idx], pts[...,mu2_idx],
+            pts[...,q_idx], pts[...,s2z_idx],
+        )
     else:
-        if mass_transform != "mass1_mass2":
-            pts[:,m1_idx], pts[:,m2_idx] = INVERSE_TRANSFORMS_MASS[VALID_TRANSFORMS_MASS[mass_transform]](pts[:,m1_idx], pts[:,m2_idx])
-        
+        mA_idx = m1_idx
+        mB_idx = m2_idx
+
+        if mass_transform != {"mass1", "mass2"}:
+            (
+                pts[...,m1_idx], pts[...,m2_idx],
+            ) = INVERSE_TRANSFORMS_MASS[VALID_TRANSFORMS_MASS[mass_transform]](
+                pts[...,mA_idx], pts[...,mB_idx],
+            )
+
         if spin_transform:
             if spin_transform == "chi_z":
-                s1z_idx, s2z_idx = intr_prms.index("spin1z"), intr_prms.index("spin2z")
-                pts[:,s1z_idx],pts[:,s2z_idx] =transform_chi_eff_chi_a_s1zs2z(pts[:,m1_idx], pts[:,m2_idx], pts[:,s1z_idx], pts[:,s2z_idx])
+                s1z_idx = intr_prms.index("spin1z")
+                s2z_idx = intr_prms.index("spin2z")
+
+                chieff_idx = s1z_idx
+                chia_idx = s2z_idx
+
+                (
+                    pts[...,s1z_idx], pts[...,s2z_idx],
+                ) = transform_chi_eff_chi_a_s1zs2z(
+                    pts[...,m1_idx], pts[...,m2_idx],
+                    pts[...,chieff_idx], pts[...,chia_idx],
+                )
+            else:
+                raise NotImplementedError(
+                    f"Unknown spin_transform: {spin_transform}"
+                )
 
-        
     # Independent transforms go here
 
     return pts

{rapid_pe-0.0.4.dev20230213 → rapid_pe-0.1.2.dev20251209}/rapid_pe/dagutils.py

@@ -21,6 +21,7 @@ A collection of routines to manage Condor workflows (DAGs).
 import warnings
 import os,ast
 
+from pathlib import PurePath
 from glue import pipeline
 
 __author__ = "Evan Ochsner <evano@gravity.phys.uwm.edu>, Chris Pankow <pankow@gravity.phys.uwm.edu>"
@@ -42,8 +43,43 @@ def which(program):
 
     return None
 
+def escape_quotes(s):
+    """
+    Escapes quotes in a string for use in a Condor submit file.
+
+    Any quote character is simply repeated twice, removing its special meaning
+    and making it behave as a literal quote character.
+    """
+    return s.replace('"', '""').replace("'", "''")
+
+def format_getenv(getenv):
+    """
+    Produces the 'getenv' section's value for a Condor submit file, given a
+    list of environment variable names.
+    """
+    return ", ".join(getenv)
+
+def format_environment(environment_dict):
+    """
+    Produces the 'environment' section's value for a Condor submit file, given
+    a dictionary of environment variable names and values.
+
+    This uses the 'new' format (space-delimited key=value pairs with
+    double-quotes enclosing the entire list), with literal quotes properly
+    escaped, and with single-quotes used to surround each value in case it
+    contains whitespace.
+    """
+    # Compute key='value' pairs, quoted properly
+    pairs = (f"{k}='{escape_quotes(v)}'"
+             for k, v in environment_dict.items())
+    # Join the pairs into a single string
+    contents = " ".join(pairs)
+    # Construct the final expression
+    return f'"{contents}"'
+
+
 # FIXME: Keep in sync with arguments of integrate_likelihood_extrinsic
-def write_integrate_likelihood_extrinsic_sub(tag='integrate', exe=None, log_dir=None, intr_prms=("mass1", "mass2"), ncopies=1, condor_commands=None, **kwargs):
+def write_integrate_likelihood_extrinsic_sub(tag='integrate', exe=None, log_dir=None, intr_prms=("mass1", "mass2"), ncopies=1, condor_commands=None, getenv=None, environment_dict=None, **kwargs):
     """
     Write a submit file for launching jobs to marginalize the likelihood over
     extrinsic parameters.
@@ -98,8 +134,9 @@ def write_integrate_likelihood_extrinsic_sub(tag='integrate', exe=None, log_dir=
         #
         # Need to modify the output file so it's unique
         #
-        ofname = kwargs["output-file"].split(".")
-        ofname, ext = ofname[0], ".".join(ofname[1:])
+        ofname = PurePath(kwargs["output-file"])
+        ext = "".join(PurePath(ofname).suffixes[-2:])
+        ofname= kwargs["output-file"][:-len(ext)]
         ile_job.add_file_opt("output-file", "%s-%s.%s" % (ofname, uniq_str, ext))
         del kwargs["output-file"]
         #if kwargs.has_key("save-samples") and kwargs["save-samples"] == True:
@@ -107,8 +144,6 @@ def write_integrate_likelihood_extrinsic_sub(tag='integrate', exe=None, log_dir=
             ile_job.add_opt("save-samples", '')
             del kwargs["save-samples"]
 
-    if "cProfile" in kwargs:
-        del kwargs["cProfile"]
     del kwargs["iteration-level"]
     #
     # Add normal arguments
@@ -135,12 +170,17 @@ def write_integrate_likelihood_extrinsic_sub(tag='integrate', exe=None, log_dir=
     for p in intr_prms:
         ile_job.add_var_opt(p)
 
-    ile_job.add_condor_cmd('getenv', 'True')
+    if getenv is not None and len(getenv) != 0:
+        ile_job.add_condor_cmd('getenv', format_getenv(getenv))
+    if environment_dict is not None and len(environment_dict) != 0:
+        ile_job.add_condor_cmd('environment',
+                               format_environment(environment_dict))
     ile_job.add_condor_cmd('request_memory', '4096')
+    ile_job.add_condor_cmd('max_retries', '5')
     warnings.warn("Requesting hard-coded disk space for ILE job")
     ile_job.add_condor_cmd('request_disk', '1 GB')
     if 'gpu' in kwargs:
-    	ile_job.add_condor_cmd('request_GPUs', '1')
+        ile_job.add_condor_cmd('request_GPUs', '1')
     if condor_commands is not None:
         for cmd, value in condor_commands.items():
             ile_job.add_condor_cmd(cmd, value)
@@ -148,7 +188,7 @@ def write_integrate_likelihood_extrinsic_sub(tag='integrate', exe=None, log_dir=
     
     return ile_job, ile_sub_name
 
-def write_result_coalescence_sub(tag='coalesce', exe=None, log_dir=None, output_dir="./", use_default_cache=True):
+def write_result_coalescence_sub(tag='coalesce', exe=None, log_dir=None, output_dir="./", use_default_cache=True, getenv=None, environment_dict=None):
     """
     Write a submit file for launching jobs to coalesce ILE output
     """
@@ -182,14 +222,19 @@ def write_result_coalescence_sub(tag='coalesce', exe=None, log_dir=None, output_
     sql_job.add_opt("tmp-space", tmpdir)
     sql_job.add_opt("verbose", '')
 
-    sql_job.add_condor_cmd('getenv', 'True')
+    if getenv is not None and len(getenv) != 0:
+        sql_job.add_condor_cmd('getenv', format_getenv(getenv))
+    if environment_dict is not None and len(environment_dict) != 0:
+        sql_job.add_condor_cmd('environment',
+                               format_environment(environment_dict))
+
     sql_job.add_condor_cmd('request_memory', '1024')
     warnings.warn("Requesting hard-coded disk space for SQL job")
     sql_job.add_condor_cmd('request_disk', '1 GB')
 
     return sql_job, sql_sub_name
 
-def write_posterior_plot_sub(tag='plot_post', exe=None, log_dir=None, output_dir="./"):
+def write_posterior_plot_sub(tag='plot_post', exe=None, log_dir=None, output_dir="./", getenv=None, environment_dict=None):
     """
     Write a submit file for launching jobs to coalesce ILE output
     """
@@ -214,14 +259,19 @@ def write_posterior_plot_sub(tag='plot_post', exe=None, log_dir=None, output_dir
     plot_job.add_opt("input-cache", "ILE_all.cache")
     plot_job.add_opt("log-evidence", '')
 
-    plot_job.add_condor_cmd('getenv', 'True')
+    if getenv is not None and len(getenv) != 0:
+        plot_job.add_condor_cmd('getenv', format_getenv(getenv))
+    if environment_dict is not None and len(environment_dict) != 0:
+        plot_job.add_condor_cmd('environment',
+                               format_environment(environment_dict))
+
     plot_job.add_condor_cmd('request_memory', '1024')
     warnings.warn("Requesting hard-coded disk space for plot job")
     plot_job.add_condor_cmd('request_disk', '1 GB')
 
     return plot_job, plot_sub_name
 
-def write_tri_plot_sub(tag='plot_tri', injection_file=None, exe=None, log_dir=None, output_dir="./"):
+def write_tri_plot_sub(tag='plot_tri', injection_file=None, exe=None, log_dir=None, output_dir="./", getenv=None, environment_dict=None):
     """
     Write a submit file for launching jobs to coalesce ILE output
     """
@@ -245,14 +295,19 @@ def write_tri_plot_sub(tag='plot_tri', injection_file=None, exe=None, log_dir=No
         plot_job.add_opt("injection", injection_file)
     plot_job.add_arg("ILE_$(macromassid).sqlite")
 
-    plot_job.add_condor_cmd('getenv', 'True')
+    if getenv is not None and len(getenv) != 0:
+        plot_job.add_condor_cmd('getenv', format_getenv(getenv))
+    if environment_dict is not None and len(environment_dict) != 0:
+        plot_job.add_condor_cmd('environment',
+                               format_environment(environment_dict))
+
     #plot_job.add_condor_cmd('request_memory', '2048')
     warnings.warn("Requesting hard-coded disk space for plot job")
     plot_job.add_condor_cmd('request_disk', '1 GB')
 
     return plot_job, plot_sub_name
 
-def write_1dpos_plot_sub(tag='1d_post_plot', exe=None, log_dir=None, output_dir="./"):
+def write_1dpos_plot_sub(tag='1d_post_plot', exe=None, log_dir=None, output_dir="./", getenv=None, environment_dict=None):
     """
     Write a submit file for plotting 1d posterior cumulants.
     """
@@ -275,14 +330,19 @@ def write_1dpos_plot_sub(tag='1d_post_plot', exe=None, log_dir=None, output_dir=
     plot_job.add_opt("disable-triplot", '')
     plot_job.add_opt("disable-1d-density", '')
 
-    plot_job.add_condor_cmd('getenv', 'True')
+    if getenv is not None and len(getenv) != 0:
+        plot_job.add_condor_cmd('getenv', format_getenv(getenv))
+    if environment_dict is not None and len(environment_dict) != 0:
+        plot_job.add_condor_cmd('environment',
+                               format_environment(environment_dict))
+
     plot_job.add_condor_cmd('request_memory', '2048')
     warnings.warn("Requesting hard-coded disk space for plot job")
     plot_job.add_condor_cmd('request_disk', '1 GB')
 
     return plot_job, plot_sub_name
 
-def write_bayes_pe_postproc_sub(tag='bayespe_post_plot', exe=None, log_dir=None, web_dir="./", inj_xml=None):
+def write_bayes_pe_postproc_sub(tag='bayespe_post_plot', exe=None, log_dir=None, web_dir="./", inj_xml=None, getenv=None, environment_dict=None):
     """
     Write a submit file for postprocessing output and pushing it through cbcBayesPostProc.py
     """
@@ -317,7 +377,12 @@ def write_bayes_pe_postproc_sub(tag='bayespe_post_plot', exe=None, log_dir=None,
     plot_job.add_opt("header", "header.txt")
     plot_job.add_opt("data", "tmp")
 
-    plot_job.add_condor_cmd('getenv', 'True')
+    if getenv is not None and len(getenv) != 0:
+        plot_job.add_condor_cmd('getenv', format_getenv(getenv))
+    if environment_dict is not None and len(environment_dict) != 0:
+        plot_job.add_condor_cmd('environment',
+                               format_environment(environment_dict))
+
     plot_job.add_condor_cmd('request_memory', '1024')
     warnings.warn("Requesting hard-coded disk space for plot job")
     plot_job.add_condor_cmd('request_disk', '1 GB')

{rapid_pe-0.0.4.dev20230213 → rapid_pe-0.1.2.dev20251209}/rapid_pe/lalsimutils.py

@@ -739,7 +739,7 @@ def norm_sym_ratio(eta):
         #eta[np.isclose(eta, 0.25)] = 0.25
 
     # Assert phyisicality
-    assert np.all(eta <= 0.25)
+#    assert np.all(eta <= 0.25)
 
     return np.sqrt(1 - 4. * eta)
 

{rapid_pe-0.0.4.dev20230213 → rapid_pe-0.1.2.dev20251209}/rapid_pe/xmlutils.py

@@ -286,5 +286,5 @@ if __file__ == sys.argv[0]:
     for m1i, m2i, loglikelihood in zip(m1, m2, loglikes):
         append_likelihood_result_to_xmldoc(xmldoc, loglikelihood, **{"mass1": m1i, "mass2": m2i})
 
-    from glue.ligolw import utils
+    from ligo.lw import utils
     utils.write_filename(xmldoc, "iotest.xml.gz")

{rapid_pe-0.0.4.dev20230213 → rapid_pe-0.1.2.dev20251209}/rapid_pe.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
-Name: rapid-pe
-Version: 0.0.4.dev20230213
+Metadata-Version: 2.4
+Name: rapid_pe
+Version: 0.1.2.dev20251209
 Summary: RapidPE: The original low-latency gravitational wave parameter estimation code.
 Home-page: https://git.ligo.org/rapidpe-rift/rapidpe/
 License: GPL-2+
@@ -19,6 +19,26 @@ Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Scientific/Engineering :: Astronomy
 Classifier: Topic :: Scientific/Engineering :: Physics
 License-File: COPYING
+Requires-Dist: bilby
+Requires-Dist: h5py
+Requires-Dist: healpy
+Requires-Dist: lalsuite
+Requires-Dist: ligo.skymap
+Requires-Dist: lscsoft-glue
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: python-ligo-lw<1.9,>=1.8.1
+Requires-Dist: scikit-learn
+Requires-Dist: scipy
+Requires-Dist: six
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: summary
 
 RapidPE was the first piece of software written for rapidly measuring the
 parameters of compact binary mergers observed via gravitational waves.  It

rapid_pe-0.0.4.dev20230213/README.md

@@ -1,21 +0,0 @@
-# RapidPE
-
-The original low-latency gravitational wave parameter estimation code.
-
-
-# Credit
-
-Copyright (c) 2012-2022 RapidPE Contributors
-
-Past and present RapidPE Contributors ordered by given name:
-
-- Caitlin Rose
-- Chris Pankow
-- Daniel Wysocki
-- Evan Oschner
-- Hong Qi
-- Patrick Brady
-- Richard O'Shaughnessy
-- Sinead Walsh
-- Soichiro Morisaki
-- Vinaya Valsan