From bf44fa404b3da7d93e769b4a9efefeb9c3ab8775 Mon Sep 17 00:00:00 2001 From: Avi Vajpeyi Date: Thu, 22 May 2025 11:45:00 +1200 Subject: [PATCH 1/6] allow binned-cosmic-inntegrator to also include BNS, BHS --- .../bbh_population.py | 252 -------- .../binary_population.py | 327 ++++++++++ .../detection_matrix.py | 32 +- .../detection_rate_computer.py | 14 +- .../binned_cosmic_integrator/plotting.py | 4 +- .../notebooks/CosmicIntegration.ipynb | 564 ------------------ .../notebooks/CosmicIntegration.py | 10 +- py_tests/conftest.py | 6 +- py_tests/test_binned_integrator.py | 13 +- py_tests/test_total_mass_evolved_per_z.py | 6 +- 10 files changed, 370 insertions(+), 858 deletions(-) delete mode 100644 compas_python_utils/cosmic_integration/binned_cosmic_integrator/bbh_population.py create mode 100644 compas_python_utils/cosmic_integration/binned_cosmic_integrator/binary_population.py delete mode 100644 online-docs/pages/User guide/Post-processing/notebooks/CosmicIntegration.ipynb diff --git a/compas_python_utils/cosmic_integration/binned_cosmic_integrator/bbh_population.py b/compas_python_utils/cosmic_integration/binned_cosmic_integrator/bbh_population.py deleted file mode 100644 index 089aebe87..000000000 --- a/compas_python_utils/cosmic_integration/binned_cosmic_integrator/bbh_population.py +++ /dev/null @@ -1,252 +0,0 @@ -import numpy as np -import h5py - -from .gpu_utils import xp -import h5py as h5 -from typing import List, Optional - -from ..totalMassEvolvedPerZ import ( - analytical_star_forming_mass_per_binary_using_kroupa_imf, - draw_samples_from_kroupa_imf) -from .conversions import m1_m2_to_chirp_mass, m1_m2_to_eta -from .plotting import plot_bbh_population - -# Default values for BBH population -M1_MIN = 5 -M1_MAX = 150 -M2_MIN = 0.1 - - -class BBHPopulation(object): - - def __init__( - self, - m1, - m2, - t_delay, - z_zams, - n_systems, - m1_min=M1_MIN, - m1_max=M1_MAX, - m2_min=M2_MIN, - binary_fraction=0.7, - ): - self.m1_min = m1_min - self.m1_max = m1_max - self.m2_min = m2_min - self.binaryFraction = binary_fraction - self.mass_evolved_per_binary = analytical_star_forming_mass_per_binary_using_kroupa_imf( - m1_max=self.m1_max, - m1_min=self.m1_min, - m2_min=self.m2_min, - fbin=self.binaryFraction, - ) - self.m1 = m1 - self.m2 = m2 - self.t_delay = t_delay - self.z_zams = z_zams - self.n_systems = n_systems - - - - @classmethod - def from_compas_h5( - cls, - path=None, - m1_min=M1_MIN, - m1_max=M1_MAX, - m2_min=M2_MIN, - binary_fraction=0.7, - ): - """ - Loads the BBH population from COMPAS output. - Requires the COMPAS output to contain the following datasets: - Size N (number of systems) - - BSE_System_Parameters/SEED - - BSE_System_Parameters/Metallicity@ZAMS(1) - - Size N_CE (number of CE events) < N - - BSE_Common_Envelopes/SEED - - BSE_Common_Envelopes/Immediate_RLOF>CE - - BSE_Common_Envelopes/Optimistic_CE - - Size N_BBH (number of BBHs) < N - - BSE_Double_Compact_Objects/SEED - - BSE_Double_Compact_Objects/Mass(1) - - BSE_Double_Compact_Objects/Mass(2) - - BSE_Double_Compact_Objects/Time - - BSE_Double_Compact_Objects/Coalescence_Time - - BSE_Double_Compact_Objects/Stellar_Type(1) - - BSE_Double_Compact_Objects/Stellar_Type(2) - - BSE_Double_Compact_Objects/Merges_Hubble_Time - - """ - mask = BBHPopulation.__generate_mask(path) - m1, m2, t_form, t_merge, dco_seeds = _load_data( - path, "BSE_Double_Compact_Objects", - ["Mass(1)", "Mass(2)", "Time", "Coalescence_Time", "SEED"], - mask=mask - ) - all_seeds, z_zams = _load_data(path, "BSE_System_Parameters", ["SEED", "Metallicity@ZAMS(1)"]) - dco_mask = xp.in1d(all_seeds, dco_seeds) - return cls( - m1_min = m1_min, - m1_max = m1_max, - m2_min = m2_min, - binary_fraction = binary_fraction, - m1 = m1, - m2 = m2, - t_delay = t_form + t_merge, - z_zams = z_zams[dco_mask], - n_systems = len(all_seeds), - ) - - @property - def avg_sf_mass_needed(self): - return self.mass_evolved_per_binary * self.n_systems - - @property - def chirp_mass(self): - if not hasattr(self, "_chirp_mass"): - self._chirp_mass = m1_m2_to_chirp_mass(self.m1, self.m2) - return self._chirp_mass - - @property - def eta(self): - if not hasattr(self, "_eta"): - self._eta = m1_m2_to_eta(self.m1, self.m2) - return self._eta - - def __repr__(self): - return f"" - - def __str__(self): - return self.__repr__() - - @staticmethod - def __generate_mask(path): - type_1, type_2, hubble_mask, dco_seeds = _load_data( - path, "BSE_Double_Compact_Objects", - ["Stellar_Type(1)", "Stellar_Type(2)", "Merges_Hubble_Time", "SEED"] - ) - hubble_mask = hubble_mask.astype(bool) - bbh_mask = (type_1 == 14) & (type_2 == 14) - del type_1, type_2 - - # get the flags and unique seeds from the Common Envelopes file - ce_seeds, rlof_flag, optimistic_ce = _load_data( - path, "BSE_Common_Envelopes", ["SEED", "Immediate_RLOF>CE", "Optimistic_CE"]) - dco_from_ce = xp.in1d(ce_seeds, dco_seeds) - dco_ce_seeds = ce_seeds[dco_from_ce] - del ce_seeds - - # mask out all DCOs that have RLOF after CE - rlof_flag = rlof_flag[dco_from_ce].astype(bool) - rlof_seeds = xp.unique(dco_ce_seeds[rlof_flag]) - mask_out_with_rlof_seeds = xp.logical_not(xp.in1d(dco_seeds, rlof_seeds)) - del rlof_flag, rlof_seeds - - # mask out all DCOs that have an "optimistic CE" - optimistic_ce_flag = optimistic_ce[dco_from_ce].astype(bool) - optimistic_ce_seeds = xp.unique(dco_ce_seeds[optimistic_ce_flag]) - mask_out_optimistic_ce_seeds = xp.logical_not(xp.in1d(dco_seeds, optimistic_ce_seeds)) - del optimistic_ce_flag, optimistic_ce_seeds - - return bbh_mask * hubble_mask * mask_out_with_rlof_seeds * mask_out_optimistic_ce_seeds - - @property - def label(self): - return f"n{self.n_bbh}_bbh_population" - - @property - def n_bbh(self): - return len(self.m1) - - def plot(self): - return plot_bbh_population( - data=xp.asarray([self.m1, self.m2, self.chirp_mass, np.log(self.z_zams), np.log(self.t_delay)]).T, - params=[ - r"$m_1\ [M_{\odot}]$", r"$m_2\ [M_{\odot}]$", r"$\mathcal{M}_{\rm chirp}\ [M_{\odot}]$", - r"$\ln z_{\rm ZAMS}$", r"$\ln t_{\rm delay}\ [\ln {\rm Myr}]$", - ]) - - - def bootstrap_population(self): - """Artificially generate a new population by drawing from the original population with replacement""" - n_bbh = np.random.poisson(self.n_bbh) - idx = np.random.choice(np.arange(self.n_bbh), size=n_bbh, replace=True) - return BBHPopulation( - m1=self.m1[idx], - m2=self.m2[idx], - t_delay=self.t_delay[idx], - z_zams=self.z_zams[idx], - n_systems=self.n_systems, - m1_min=self.m1_min, - m1_max=self.m1_max, - m2_min=self.m2_min, - binary_fraction=self.binaryFraction, - ) - - -def _load_data(path: str, group: str, var_names: List[str], mask: Optional[xp.ndarray] = None): - """Load variables from a hdf5 file""" - with h5.File(path, "r") as compas_file: - data = [ - compas_file[group][var_name][...].squeeze().flatten() for var_name in var_names - ] - if mask is not None: # apply mask if given - for i in range(len(data)): # not using list comprehension to avoid copying data - data[i] = data[i][mask] - return data - - -def generate_mock_bbh_population_file( - filename: str = "", n_systems: int = 2000, frac_bbh: float = 0.7, m1_min: float = M1_MIN, - m1_max: float = M1_MAX, m2_min: float = M2_MIN, -): - """Generate a mock BBH population file with the given number of systems and BBHs. - - Args: - filename: The filename of the mock population file. - n_systems: The number of systems in the population. - frac_bbh: The fraction of systems that are BBHs. - m1_min: The minimum mass of the primary star in solar masses. - m1_max: The maximum mass of the primary star in solar masses. - m2_min: The minimum mass of the secondary star in solar masses. - - Returns: filename - """ - if filename == "": - filename = f"bbh_mock_population.h5" - - m1, m2 = draw_samples_from_kroupa_imf( - n_samples=n_systems, Mlower=m1_min, Mupper=m1_max, m2_low=m2_min) - n_systems = len(m1) - - # draw BBH masses - mask = np.random.uniform(size=n_systems) < frac_bbh - n_bbh = np.sum(mask) - - SYS_PARAM = "BSE_System_Parameters" - DCO = "BSE_Double_Compact_Objects" - CE = "BSE_Common_Envelopes" - with h5py.File(filename, "w") as f: - f.create_group(SYS_PARAM) - f.create_group(DCO) - f.create_group(CE) - f[SYS_PARAM].create_dataset("SEED", data=np.arange(n_systems)) - f[SYS_PARAM].create_dataset("Metallicity@ZAMS(1)", data=np.random.uniform(1e-4, 1e-2, size=n_systems)) - f[SYS_PARAM].create_dataset("Mass@ZAMS(1)", data=m1) - f[SYS_PARAM].create_dataset("Mass@ZAMS(2)", data=m2) - f[CE].create_dataset("SEED", data=np.arange(n_systems)) - f[CE].create_dataset("Immediate_RLOF>CE", data=np.array([False] * n_systems)) - f[CE].create_dataset("Optimistic_CE", data=np.array([False] * n_systems)) - f[DCO].create_dataset("SEED", data=np.arange(n_bbh)) - f[DCO].create_dataset("Mass(1)", data=m1[mask]) - f[DCO].create_dataset("Mass(2)", data=m2[mask]) - f[DCO].create_dataset("Time", data=np.random.uniform(4, 13.8, size=n_bbh)) - f[DCO].create_dataset("Coalescence_Time", data=np.random.uniform(0, 14000, size=n_bbh)) - f[DCO].create_dataset("Stellar_Type(1)", data=np.array([14] * n_bbh)) - f[DCO].create_dataset("Stellar_Type(2)", data=np.array([14] * n_bbh)) - f[DCO].create_dataset("Merges_Hubble_Time", data=np.array([True] * n_bbh)) - return filename diff --git a/compas_python_utils/cosmic_integration/binned_cosmic_integrator/binary_population.py b/compas_python_utils/cosmic_integration/binned_cosmic_integrator/binary_population.py new file mode 100644 index 000000000..a9f75327f --- /dev/null +++ b/compas_python_utils/cosmic_integration/binned_cosmic_integrator/binary_population.py @@ -0,0 +1,327 @@ +import numpy as np +import h5py +from .gpu_utils import xp +from typing import List, Optional + +from ..totalMassEvolvedPerZ import ( + analytical_star_forming_mass_per_binary_using_kroupa_imf, + draw_samples_from_kroupa_imf, +) +from .conversions import m1_m2_to_chirp_mass, m1_m2_to_eta +from .plotting import plot_binary_population + +# Default IMF limits +M1_MIN = 5 +M1_MAX = 150 +M2_MIN = 0.1 + +class BinaryPopulation: + """ + General DCO population class supporting BBH, BNS, BHNS. + + Loads the DCOs population from COMPAS output. + Requires the COMPAS output to contain the following datasets: + Size N (number of systems) + - BSE_System_Parameters/SEED + - BSE_System_Parameters/Metallicity@ZAMS(1) + + Size N_CE (number of CE events) <= N + - BSE_Common_Envelopes/SEED + - BSE_Common_Envelopes/Immediate_RLOF>CE + - BSE_Common_Envelopes/Optimistic_CE + + Size N_DCOs (number of N_DCOs) <= N + - BSE_Double_Compact_Objects/SEED + - BSE_Double_Compact_Objects/Mass(1) + - BSE_Double_Compact_Objects/Mass(2) + - BSE_Double_Compact_Objects/Time + - BSE_Double_Compact_Objects/Coalescence_Time + - BSE_Double_Compact_Objects/Stellar_Type(1) + - BSE_Double_Compact_Objects/Stellar_Type(2) + - BSE_Double_Compact_Objects/Merges_Hubble_Time + + + + Flags: + include_bbh: bool + include_bns: bool + include_bhns: bool + """ + def __init__( + self, + m1: np.ndarray, + m2: np.ndarray, + t_delay: np.ndarray, + z_zams: np.ndarray, + n_systems: int, + include_bbh: bool = True, + include_bns: bool = False, + include_bhns: bool = False, + m1_min: float = M1_MIN, + m1_max: float = M1_MAX, + m2_min: float = M2_MIN, + binary_fraction: float = 0.7, + ): + # Population selection + self.include_bbh = include_bbh + self.include_bns = include_bns + self.include_bhns = include_bhns + + # IMF parameters + self.m1_min = m1_min + self.m1_max = m1_max + self.m2_min = m2_min + self.binary_fraction = binary_fraction + self.mass_evolved_per_binary = analytical_star_forming_mass_per_binary_using_kroupa_imf( + m1_max=self.m1_max, + m1_min=self.m1_min, + m2_min=self.m2_min, + fbin=self.binary_fraction, + ) + + # Data arrays + self.m1 = m1 + self.m2 = m2 + self.t_delay = t_delay + self.z_zams = z_zams + self.n_systems = n_systems + + @classmethod + def from_compas_h5( + cls, + path: str, + include_bbh: bool = True, + include_bns: bool = False, + include_bhns: bool = False, + m1_min: float = M1_MIN, + m1_max: float = M1_MAX, + m2_min: float = M2_MIN, + binary_fraction: float = 0.7, + ) -> "BinaryPopulation": + mask = cls._generate_mask(path, include_bbh, include_bns, include_bhns) + + m1, m2, t0, tC, seeds = _load_data( + path, + "BSE_Double_Compact_Objects", + ["Mass(1)", "Mass(2)", "Time", "Coalescence_Time", "SEED"], + mask=mask, + ) + seeds = seeds.flatten() + + all_seeds, z_zams = _load_data( + path, + "BSE_System_Parameters", + ["SEED", "Metallicity@ZAMS(1)"], + ) + dco_mask = xp.in1d(all_seeds, seeds) + + return cls( + m1=m1, + m2=m2, + t_delay=t0 + tC, + z_zams=z_zams[dco_mask], + n_systems=len(all_seeds), + include_bbh=include_bbh, + include_bns=include_bns, + include_bhns=include_bhns, + m1_min=m1_min, + m1_max=m1_max, + m2_min=m2_min, + binary_fraction=binary_fraction, + ) + + @staticmethod + def _generate_mask( + path: str, + include_bbh: bool, + include_bns: bool, + include_bhns: bool, + ) -> xp.ndarray: + # Load fundamental DCO variables + t1, t2, hubble_flag, dco_seeds = _load_data( + path, + "BSE_Double_Compact_Objects", + ["Stellar_Type(1)", "Stellar_Type(2)", "Merges_Hubble_Time", "SEED"], + ) + # Base masks by type + masks = [] + if include_bbh: + masks.append((t1 == 14) & (t2 == 14)) + if include_bns: + masks.append((t1 == 13) & (t2 == 13)) + if include_bhns: + masks.append((t1 == 14) & (t2 == 13) | (t1 == 13) & (t2 == 14)) + + if not masks: + raise ValueError("At least one DCO type must be included.") + + + type_mask = np.logical_or.reduce(masks) + # Hubble time filter + hubble_mask = hubble_flag.astype(bool) + + + # get the flags and unique seeds from the Common Envelopes file + ce_seeds, rlof_flag, optimistic_ce = _load_data( + path, "BSE_Common_Envelopes", ["SEED", "Immediate_RLOF>CE", "Optimistic_CE"]) + dco_from_ce = xp.in1d(ce_seeds, dco_seeds) + dco_ce_seeds = ce_seeds[dco_from_ce] + del ce_seeds + + # mask out all DCOs that have RLOF after CE + rlof_flag = rlof_flag[dco_from_ce].astype(bool) + rlof_seeds = xp.unique(dco_ce_seeds[rlof_flag]) + mask_out_with_rlof_seeds = xp.logical_not(xp.in1d(dco_seeds, rlof_seeds)) + del rlof_flag, rlof_seeds + + # mask out all DCOs that have an "optimistic CE" + optimistic_ce_flag = optimistic_ce[dco_from_ce].astype(bool) + optimistic_ce_seeds = xp.unique(dco_ce_seeds[optimistic_ce_flag]) + mask_out_optimistic_ce_seeds = xp.logical_not(xp.in1d(dco_seeds, optimistic_ce_seeds)) + del optimistic_ce_flag, optimistic_ce_seeds + + lens = dict( + type=len(type_mask), + hubble=len(hubble_mask), + rlof=len(mask_out_with_rlof_seeds), + ce=len(mask_out_optimistic_ce_seeds) + ) + # assert all lens are equal + assert len(set(lens.values())) == 1, f"Length mismatch in masks: {lens}" + + return type_mask * hubble_mask * mask_out_with_rlof_seeds * mask_out_optimistic_ce_seeds + + + @property + def n_dcos(self) -> int: + return len(self.m1) + + @property + def chirp_mass(self) -> np.ndarray: + if not hasattr(self, "_chirp_mass"): + self._chirp_mass = m1_m2_to_chirp_mass(self.m1, self.m2) + return self._chirp_mass + + @property + def eta(self) -> np.ndarray: + if not hasattr(self, "_eta"): + self._eta = m1_m2_to_eta(self.m1, self.m2) + return self._eta + + @property + def avg_sf_mass_needed(self) -> float: + return self.mass_evolved_per_binary * self.n_systems + + def plot(self): + arr = xp.asarray([ + self.m1, + self.m2, + self.chirp_mass, + np.log(self.z_zams), + np.log(self.t_delay), + ]).T + labels = [ + r"$m_1\ [M_{\odot}]$", + r"$m_2\ [M_{\odot}]$", + r"$\mathcal{M}_{\rm chirp}\ [M_{\odot}]$", + r"$\ln z_{\rm ZAMS}$", + r"$\ln t_{\rm delay}\ [\ln {\rm Myr}]$", + ] + return plot_binary_population(data=arr, params=labels) + + def bootstrap_population(self) -> "BinaryPopulation": + n = np.random.poisson(self.n_dcos) + idx = np.random.choice(self.n_dcos, size=n, replace=True) + return BinaryPopulation( + m1=self.m1[idx], + m2=self.m2[idx], + t_delay=self.t_delay[idx], + z_zams=self.z_zams[idx], + n_systems=self.n_systems, + include_bbh=self.include_bbh, + include_bns=self.include_bns, + include_bhns=self.include_bhns, + m1_min=self.m1_min, + m1_max=self.m1_max, + m2_min=self.m2_min, + binary_fraction=self.binary_fraction, + ) + + @property + def label(self): + return f"n{self.n_dcos}_dco_population" + + def __repr__(self): + return f"" + + def __str__(self): + return self.__repr__() + + +# Helper I/O function remains unchanged + +def _load_data(path: str, group: str, var_names: List[str], mask: Optional[xp.ndarray] = None): + with h5py.File(path, "r") as f: + data = [f[group][v][...].squeeze().flatten() for v in var_names] + if mask is not None: + data = [d[mask] for d in data] + return data + +# Mock generation utility + +def generate_mock_population( + filename: str = "", + n_systems: int = 2000, + frac_bbh: float = 0.7, + frac_bns: float = 0.2, + frac_bhns: float = 0.1, + m1_min: float = M1_MIN, + m1_max: float = M1_MAX, + m2_min: float = M2_MIN, +): + if filename == "": + filename = "dco_mock_population.h5" + + # sample masses and assign types + m1, m2 = draw_samples_from_kroupa_imf(n_samples=n_systems, Mlower=m1_min, Mupper=m1_max, m2_low=m2_min) + n_systems = len(m1) + n_dcos = n_systems // 2 + n_ce = n_systems * 2 + types = np.random.choice(["BBH","BNS","BHNS"], size=n_dcos, + p=[frac_bbh, frac_bns, frac_bhns]) + + # Define the type-to-mass mapping + type_to_pair = { + "BBH": [14, 14], + "BNS": [13, 13], + "BHNS": [13, 14] + } + + # Create a 2D array by mapping each type to its corresponding mass pair + mass_pairs = np.array([type_to_pair[t] for t in types]).T + + + # create file structure + with h5py.File(filename, "w") as f: + f.create_group("BSE_System_Parameters") + f.create_group("BSE_Common_Envelopes") + f.create_group("BSE_Double_Compact_Objects") + seeds = np.arange(n_systems) + f["BSE_System_Parameters"].create_dataset("SEED", data=seeds) + f["BSE_System_Parameters"].create_dataset("Metallicity@ZAMS(1)", data=np.random.uniform(1e-4,1e-2,n_systems)) + # CE + ce_seeds = np.arange(n_ce) + f["BSE_Common_Envelopes"].create_dataset("SEED", data=ce_seeds) + f["BSE_Common_Envelopes"].create_dataset("Immediate_RLOF>CE", data=np.zeros(n_ce,dtype=bool)) # no RLOF after CE + f["BSE_Common_Envelopes"].create_dataset("Optimistic_CE", data=np.zeros(n_ce,dtype=bool)) # no optimistic CE + # DCOs + dco_seeds = np.arange(n_dcos) + f["BSE_Double_Compact_Objects"].create_dataset("Stellar_Type(1)", data=mass_pairs[0, :]) + f["BSE_Double_Compact_Objects"].create_dataset("Stellar_Type(2)", data=mass_pairs[1, :]) + f["BSE_Double_Compact_Objects"].create_dataset("SEED", data=dco_seeds) + f["BSE_Double_Compact_Objects"].create_dataset("Mass(1)", data=m1[:n_dcos]) + f["BSE_Double_Compact_Objects"].create_dataset("Mass(2)", data=m2[:n_dcos]) + f["BSE_Double_Compact_Objects"].create_dataset("Time", data=np.random.uniform(4,13.8,n_dcos)) + f["BSE_Double_Compact_Objects"].create_dataset("Coalescence_Time", data=np.random.uniform(0,14000,n_dcos)) + f["BSE_Double_Compact_Objects"].create_dataset("Merges_Hubble_Time", data=np.ones(n_dcos,dtype=bool)) + return filename diff --git a/compas_python_utils/cosmic_integration/binned_cosmic_integrator/detection_matrix.py b/compas_python_utils/cosmic_integration/binned_cosmic_integrator/detection_matrix.py index f99305308..aacfc1f91 100644 --- a/compas_python_utils/cosmic_integration/binned_cosmic_integrator/detection_matrix.py +++ b/compas_python_utils/cosmic_integration/binned_cosmic_integrator/detection_matrix.py @@ -4,7 +4,7 @@ import h5py as h5 from tqdm.auto import trange -from .bbh_population import BBHPopulation +from .binary_population import BinaryPopulation from .cosmological_model import CosmologicalModel from .snr_grid import SNRGrid from .gpu_utils import xp @@ -23,7 +23,7 @@ def __init__( chirp_mass_bins: np.array, redshift_bins: np.array, n_systems: int, - n_bbh: int, + n_dcos: int, outdir: str = None, sens: str = 'O1', bootstrapped_rate_matrices: np.ndarray = None @@ -36,7 +36,7 @@ def __init__( self.outdir = outdir self.bootstrapped_rate_matrices = bootstrapped_rate_matrices self.n_systems = n_systems - self.n_bbh = n_bbh + self.n_dcos = n_dcos self.sens = sens @property @@ -65,15 +65,15 @@ def from_compas_output( sens: str = 'O1' ) -> "DetectionMatrix": - bbh_population = BBHPopulation.from_compas_h5(compas_path) + dco_population = BinaryPopulation.from_compas_h5(compas_path) cosmological_model = CosmologicalModel(**cosmological_parameters) snr_grid = SNRGrid(sensitivity=sens) - sorted_idx = xp.argsort(bbh_population.chirp_mass) + sorted_idx = xp.argsort(dco_population.chirp_mass) redshift = cosmological_model.redshift if chirp_mass_bins is None: - chirp_mass_bins = bbh_population.chirp_mass[sorted_idx] + chirp_mass_bins = dco_population.chirp_mass[sorted_idx] elif isinstance(chirp_mass_bins, int): chirp_mass_bins = xp.linspace(3, 40, chirp_mass_bins) @@ -83,7 +83,7 @@ def from_compas_output( redshift_bins = xp.linspace(0, max_detectable_redshift, redshift_bins) rate_matrix = compute_binned_detection_rates( - bbh_population, cosmological_model, snr_grid, + dco_population, cosmological_model, snr_grid, max_detectable_redshift=max_detectable_redshift, chirp_mass_bins=chirp_mass_bins, redshift_bins=redshift_bins, @@ -96,13 +96,13 @@ def from_compas_output( chirp_mass_bins=chirp_mass_bins, redshift_bins=redshift_bins, outdir=outdir, - n_systems=bbh_population.n_systems, - n_bbh=bbh_population.n_bbh, + n_systems=dco_population.n_systems, + n_dcos=dco_population.n_dcos, ) if n_bootstrapped_matrices > 0: mycls.compute_bootstrapped_rate_matrices( - bbh_population, cosmological_model, snr_grid, + dco_population, cosmological_model, snr_grid, n_bootstrapped_matrices ) @@ -110,7 +110,7 @@ def from_compas_output( mycls.plot().savefig(f"{outdir}/plot_{mycls.label}.png") cosmological_model.plot().savefig(f"{outdir}/plot_{cosmological_model.label}.png") snr_grid.plot().savefig(f"{outdir}/plot_{snr_grid.label}.png") - bbh_population.plot().savefig(f"{outdir}/plot_{bbh_population.label}.png") + dco_population.plot().savefig(f"{outdir}/plot_{dco_population.label}.png") return mycls @classmethod @@ -132,7 +132,7 @@ def to_dict(self) -> Dict: chirp_mass_bins=self.chirp_mass_bins, redshift_bins=self.redshift_bins, n_systems=self.n_systems, - n_bbh=self.n_bbh, + n_dcos=self.n_dcos, ) @property @@ -146,7 +146,7 @@ def param_str(self): def plot(self): fig = plot_detection_rate_matrix(self.rate_matrix, self.chirp_mass_bins, self.redshift_bins) - title = f"N BBH / N systems: {self.n_bbh:,}/{self.n_systems:,}" + title = f"N DCOs / N systems: {self.n_dcos:,}/{self.n_systems:,}" fig.suptitle(title) return fig @@ -191,14 +191,14 @@ def bin_data(self, mc_bins=50, z_bins=100): self.redshift_bins = z_bins def compute_bootstrapped_rate_matrices( - self, bbh_population: BBHPopulation, cosmological_model: CosmologicalModel, + self, dco_population: BinaryPopulation, cosmological_model: CosmologicalModel, snr_grid: SNRGrid, n_bootstraps=10): """Computes bootstrapped rate matrices""" self.bootstrapped_rate_matrices = np.zeros((n_bootstraps, *self.rate_matrix.shape)) for i in trange(n_bootstraps, desc="Bootstrapping rate matrices"): - boostrap_bbh = bbh_population.bootstrap_population() + boostrap_bbh = dco_population.bootstrap_population() self.bootstrapped_rate_matrices[i] = compute_binned_detection_rates( - bbh_population=boostrap_bbh, cosmological_model=cosmological_model, snr_grid=snr_grid, + dco_population=boostrap_bbh, cosmological_model=cosmological_model, snr_grid=snr_grid, chirp_mass_bins=self.chirp_mass_bins, redshift_bins=self.redshift_bins, verbose=False diff --git a/compas_python_utils/cosmic_integration/binned_cosmic_integrator/detection_rate_computer.py b/compas_python_utils/cosmic_integration/binned_cosmic_integrator/detection_rate_computer.py index 59f5ce445..0a03e25fe 100644 --- a/compas_python_utils/cosmic_integration/binned_cosmic_integrator/detection_rate_computer.py +++ b/compas_python_utils/cosmic_integration/binned_cosmic_integrator/detection_rate_computer.py @@ -2,7 +2,7 @@ from scipy.interpolate import interp1d import numpy as np -from .bbh_population import BBHPopulation +from .binary_population import BinaryPopulation from .cosmological_model import CosmologicalModel from .snr_grid import SNRGrid from .gpu_utils import xp @@ -10,7 +10,7 @@ def compute_binned_detection_rates( - bbh_population: BBHPopulation, + dco_population: BinaryPopulation, cosmological_model: CosmologicalModel, snr_grid: SNRGrid, chirp_mass_bins: np.ndarray, @@ -25,7 +25,7 @@ def compute_binned_detection_rates( If the GPU is not available, this function will perform the computation on the CPU. """ - n_formed = cosmological_model.sfr / bbh_population.avg_sf_mass_needed + n_formed = cosmological_model.sfr / dco_population.avg_sf_mass_needed # Divide the star formation rate density by the representative SF mass # calculate the formation and merger rates using what we computed above @@ -38,10 +38,10 @@ def compute_binned_detection_rates( dPdlogZ=cosmological_model.dPdlogZ, metallicities=cosmological_model.metallicities, p_draw_metallicity=cosmological_model.p_draw_metallicity, - COMPAS_metallicites=bbh_population.z_zams, - COMPAS_delay_times=bbh_population.t_delay, - COMPAS_Mc=bbh_population.chirp_mass, - COMPAS_eta=bbh_population.eta, + COMPAS_metallicites=dco_population.z_zams, + COMPAS_delay_times=dco_population.t_delay, + COMPAS_Mc=dco_population.chirp_mass, + COMPAS_eta=dco_population.eta, distances=cosmological_model.distance, snr_grid_at_1Mpc=snr_grid.snr_grid_at_1Mpc, detection_probability_from_snr=snr_grid.pdetection, diff --git a/compas_python_utils/cosmic_integration/binned_cosmic_integrator/plotting.py b/compas_python_utils/cosmic_integration/binned_cosmic_integrator/plotting.py index e70a0bd50..86988ffcd 100644 --- a/compas_python_utils/cosmic_integration/binned_cosmic_integrator/plotting.py +++ b/compas_python_utils/cosmic_integration/binned_cosmic_integrator/plotting.py @@ -219,7 +219,7 @@ def plot_snr_grid( return plt.gcf() -def plot_bbh_population( +def plot_binary_population( data: np.ndarray, params: List[str] ) -> plt.Figure: n_sys = len(data) @@ -251,5 +251,5 @@ def plot_bbh_population( splines.set_visible(False) ax.spines["bottom"].set_visible(True) - fig.suptitle(f"BBH Population ({n_sys:,} BBHs)") + fig.suptitle(f"Binary Population ({n_sys:,} Binaries)") return fig diff --git a/online-docs/pages/User guide/Post-processing/notebooks/CosmicIntegration.ipynb b/online-docs/pages/User guide/Post-processing/notebooks/CosmicIntegration.ipynb deleted file mode 100644 index 89caac777..000000000 --- a/online-docs/pages/User guide/Post-processing/notebooks/CosmicIntegration.ipynb +++ /dev/null @@ -1,564 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "1066be07", - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "6414b33a", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
✔️ 743 µs (2023-09-11T17:49:49/2023-09-11T17:49:49)
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "%load_ext memory_profiler\n", - "%load_ext autotime" - ] - }, - { - "cell_type": "markdown", - "id": "f65f10e5", - "metadata": {}, - "source": [ - "# Cosmic Integration\n", - "\n", - "The duration from the birth of the binary until the merger as a double compact object (DCO) can range from a few million years (lifetime of the stars) to more than 100 giga years depending on the evolution of the system.\n", - "\n", - "Hence, \n", - "1. DCOs merge at different redshifts\n", - "2. Multiple DCOs merging at a specific redshift could have formed at different times.\n", - " \n", - "We thus need to know the star formation that went into forming a single system. However, the star formation rate is non-constant over the lifetime of the universe. Furthermore, star formation is heavily dependent on the metallicity of the star forming gas, which also changes over the lifetime of the universe. Combined, we call this the metallicity-specific star formation rate (MSSFR).\n", - "\n", - "**The cosmic-integration code predicts the merger rate of DCOs along a grid of redshifts and chirp-masses, assuming a model for the MSSFR.**\n", - "This tutorial covers how to use the COMPAS Cosmic Integration python tools (see [Neijssel et al. 2020](https://arxiv.org/abs/1906.08136) for derivations). \n", - "\n" - ] - }, - { - "cell_type": "markdown", - "id": "f29267f5", - "metadata": {}, - "source": [ - "## Load COMPAS BBHs\n", - "\n", - "To run the Cosmic-integrator, we need a COMPAS data set with non-constant (preferably, randomly-sampled) metallicity and some number of double compact objects. \n", - "\n", - "In this tutorial we make a mock-COMPAS dataset. Some realistic example data can be downloaded from our [Zenodo database](https://zenodo.org/communities/compas/?page=1&size=20).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "4b8a05df", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/html": [ - "
✔️ 1.89 s (2023-09-11T17:49:49/2023-09-11T17:49:51)
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import numpy as np\n", - "from compas_python_utils.cosmic_integration.binned_cosmic_integrator.bbh_population import generate_mock_bbh_population_file\n", - "from compas_python_utils.cosmic_integration.binned_cosmic_integrator.bbh_population import BBHPopulation\n", - "\n", - "np.random.seed(42)\n", - "\n", - "m1_min = 5\n", - "m1_max = 150\n", - "m2_min = 0.1\n", - "\n", - "compas_fname = generate_mock_bbh_population_file(\n", - " \"mock_compas_data.h5\", n_systems=int(1e4), frac_bbh=1,\n", - " m1_min=m1_min, m1_max=m1_max, m2_min=m2_min\n", - ")\n", - "bbh_population = BBHPopulation.from_compas_h5(compas_fname, m1_min=m1_min, m1_max=m1_max, m2_min=m2_min)\n", - "fig = bbh_population.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "db853456", - "metadata": {}, - "source": [ - "In order to calculate the formation rate of BBHs at a given redshift, we need to know:\n", - "\n", - "- The grid of metallicities we assume for the integral\n", - "- The amount of solar mass evolved per metallicity per system $dZ/dM_{\\odot}$\n", - "- Each DCOs'\n", - " - metallicity at formation\n", - " - delay time $t_{\\rm delay}$ (time from formation till merger)\n", - " - merger time $t_c$ for each DCO\n", - " - component masses $m_1, m_2$ at $t_c$ (for selection effects)\n", - "\n", - "Given a time at which the BBH merges we can then calculate the time at which the BBH formed to recover the MSSFR ($dM_{\\odot}/dt)$" - ] - }, - { - "cell_type": "markdown", - "id": "30b3671b", - "metadata": {}, - "source": [ - "## Select a MSSFR model\n", - "\n", - "\n", - "The universe evolved over time and as such the star formation rate and the metallicity of the starforming gas change. The metallicity-specific star formation rate (MSSFR) determines the amount of star formation that went into forming a system born at redshift z, in a metallicity bin dZ.\n", - "\n", - "A schematic picture of how the MSSFR is constructed is given in Figure 10 of the COMPAS methods paper and added below (note that SFRD stands for Star Formation Rate Distribution, which is the same as the MSSFR).\n", - "\n", - "![https://raw.githubusercontent.com/TeamCOMPAS/COMPAS/dev/misc/examples/Tutorials/SFRD_cartoon.png](https://raw.githubusercontent.com/TeamCOMPAS/COMPAS/dev/misc/examples/Tutorials/SFRD_cartoon.png)\n", - "\n", - "In the Cosmic-integrator code, this can be done by using the `CosmologicalModel` class (the parameters are taken from [Neijssel et al. 2020](https://arxiv.org/abs/1906.08136)):\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "6a77264f", - "metadata": { - "lines_to_next_cell": 2 - }, - "outputs": [ - { - "data": { - "text/html": [ - "
✔️ 3.53 s (2023-09-11T17:49:51/2023-09-11T17:49:55)
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from compas_python_utils.cosmic_integration.binned_cosmic_integrator.cosmological_model import CosmologicalModel\n", - "\n", - "cosmological_model = CosmologicalModel(\n", - " aSF=0.01, bSF=2.77, cSF=2.90, dSF=4.70,\n", - " mu_0=0.035, sigma_0=0.39, mu_z=-.23, sigma_z=0, alpha=0,\n", - " min_observed_log_metallicity=-4,\n", - " max_observed_log_metallicity=0,\n", - ")\n", - "\n", - "fig = cosmological_model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "b9d36dde", - "metadata": {}, - "source": [ - "## Accounting for selection effects and observation sensitivity\n", - "\n", - "Before we can calculate the formation rate of BBHs at a given redshift, we need to account for selection effects and observation sensitivity.\n", - "We determine if we can confidently select a system by choosing a signal-to-noise ratio (SNR), for which we often use 8.\n", - "The SNR of a binary depends on:\n", - "- its component masses,\n", - "- its distance and the sky-orientation (compared to the gravitational wave detector)\n", - "- the sensitivity of the detector\n", - "\n", - "After accounting for the above, we can compute a grid of SNRs for a grid of component masses (note: we can alter the distance and sky-orientation later on)." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "49eed913", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
✔️ 694 ms (2023-09-11T17:49:55/2023-09-11T17:49:55)
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from compas_python_utils.cosmic_integration.binned_cosmic_integrator.snr_grid import SNRGrid\n", - "\n", - "snr_grid = SNRGrid(sensitivity='O1')\n", - "fig = snr_grid.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "5f5e2dc0", - "metadata": {}, - "source": [ - "## Run the cosmic-integrator\n", - "\n", - "Finally, we can run the cosmic-integrator.\n", - "This iterates over all the binaries in the COMPAS data set and calculates the formation rate of each binary given an MSSFR, producing a formation rate distribution (FRD) as a function of redshift for each binary. Accounting for the selection effects we can then compute the detection rate for each binary.\n", - "\n", - "As each binary has a chirp-mass, we can bin all the detection rates as a into chirp-mass and redshift bins, which is called the detection matrix." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "b63ec709", - "metadata": { - "lines_to_next_cell": 0 - }, - "outputs": [ - { - "data": { - "text/html": [ - "
✔️ 1.51 s (2023-09-11T17:49:55/2023-09-11T17:49:57)
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "6a7535bfb1084f4bb7a54e3bc1de0952", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Computing detection rates: 0%| | 0/9879 [00:00✔️ 3.83 s (2023-09-11T17:49:57/2023-09-11T17:50:01)" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "cc4a8f5919654c6dac06b5b040efd1c7", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Computing detection rates: 0%| | 0/9879 [00:00" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "detection_matrix = DetectionMatrix.from_compas_output(\n", - " compas_fname, save_plots=False,\n", - " chirp_mass_bins=50, redshift_bins=100,\n", - " cosmological_parameters=dict(aSF=0.01, dSF=4.70, mu_z=-.23, sigma_z=0), sens='O1'\n", - " )\n", - "fig = detection_matrix.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "945cd6d6", - "metadata": {}, - "source": [ - "The integration can be executed without binning the detection rates (this is not recommended for large data sets for memory reasons).\n" - ] - }, - { - "cell_type": "markdown", - "id": "d8a7ffad", - "metadata": {}, - "source": [ - "## Bootstrapping\n", - "\n", - "You may want to generate $N$ detection-rate matrices using bootstrap samples from the original BBH population. This can be done with: " - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "bfcda665", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
✔️ 8.39 s (2023-09-11T17:50:01/2023-09-11T17:50:09)
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "7b17f56f73324f1a952965854a17eb15", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Bootstrapping rate matrices: 0%| | 0/5 [00:00" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "detection_matrix.compute_bootstrapped_rate_matrices(\n", - " bbh_population, cosmological_model=cosmological_model, snr_grid=snr_grid,\n", - " n_bootstraps=5\n", - ")\n", - "fig = detection_matrix.plot_bootstrapped_uncertainty()" - ] - }, - { - "cell_type": "markdown", - "id": "778f154c", - "metadata": {}, - "source": [ - "\n", - "## GPU usage\n", - "If you have a CUDA-enabled GPU, the cosmic-integrator will automatically use it to speed up the calculation. To check if your GPU is used, you can run the following" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "78d33951", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
✔️ 851 µs (2023-09-11T17:50:10/2023-09-11T17:50:10)
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "GPU available: False\n" - ] - } - ], - "source": [ - "from compas_python_utils.cosmic_integration.binned_cosmic_integrator.gpu_utils import gpu_available\n", - "\n", - "print(f\"GPU available: {gpu_available}\")" - ] - }, - { - "cell_type": "markdown", - "id": "bd293b37", - "metadata": {}, - "source": [ - "## Acknowledgements\n", - "If you use the cosmic-integration code, please cite:\n", - "\n", - "```bib\n", - "\n", - "@ARTICLE{2018MNRAS.477.4685B,\n", - " author = {{Barrett}, Jim W. and {Gaebel}, Sebastian M. and {Neijssel}, Coenraad J. and {Vigna-G{\\'o}mez}, Alejandro and {Stevenson}, Simon and {Berry}, Christopher P.~L. and {Farr}, Will M. and {Mandel}, Ilya},\n", - " title = \"{Accuracy of inference on the physics of binary evolution from gravitational-wave observations}\",\n", - " journal = {\\mnras},\n", - " keywords = {black hole physics, gravitational waves, stars: black holes, stars: evolution, Astrophysics - High Energy Astrophysical Phenomena, Astrophysics - Solar and Stellar Astrophysics, Physics - Data Analysis, Statistics and Probability},\n", - " year = 2018,\n", - " month = jul,\n", - " volume = {477},\n", - " number = {4},\n", - " pages = {4685-4695},\n", - " doi = {10.1093/mnras/sty908},\n", - "archivePrefix = {arXiv},\n", - " eprint = {1711.06287},\n", - " primaryClass = {astro-ph.HE},\n", - " adsurl = {https://ui.adsabs.harvard.edu/abs/2018MNRAS.477.4685B},\n", - " adsnote = {Provided by the SAO/NASA Astrophysics Data System}\n", - "}\n", - "\n", - "@ARTICLE{2019MNRAS.490.3740N,\n", - " author = {{Neijssel}, Coenraad J. and {Vigna-G{\\'o}mez}, Alejandro and {Stevenson}, Simon and {Barrett}, Jim W. and {Gaebel}, Sebastian M. and {Broekgaarden}, Floor S. and {de Mink}, Selma E. and {Sz{\\'e}csi}, Dorottya and {Vinciguerra}, Serena and {Mandel}, Ilya},\n", - " title = \"{The effect of the metallicity-specific star formation history on double compact object mergers}\",\n", - " journal = {\\mnras},\n", - " keywords = {gravitational waves, (stars:) binaries: general, stars: massive, galaxies: star formation, Astrophysics - Solar and Stellar Astrophysics, Astrophysics - Astrophysics of Galaxies},\n", - " year = 2019,\n", - " month = dec,\n", - " volume = {490},\n", - " number = {3},\n", - " pages = {3740-3759},\n", - " doi = {10.1093/mnras/stz2840},\n", - "archivePrefix = {arXiv},\n", - " eprint = {1906.08136},\n", - " primaryClass = {astro-ph.SR},\n", - " adsurl = {https://ui.adsabs.harvard.edu/abs/2019MNRAS.490.3740N},\n", - " adsnote = {Provided by the SAO/NASA Astrophysics Data System}\n", - "}\n", - "```" - ] - }, - { - "cell_type": "markdown", - "id": "63bbe6bc", - "metadata": {}, - "source": [ - "#### Older version of Cosmic-integrator\n", - "\n", - "The cosmic-integrator code has undergone a major overhaul in 2023. If you would like to use the previous version, you can find it [here](https://github.com/TeamCOMPAS/COMPAS/tree/8af87e8e84568da11133deae034e23aee92c68e9). Please let the COMPAS team know that you are using this version, so we can know that there is still interest in this version." - ] - } - ], - "metadata": { - "jupytext": { - "formats": "py:light,ipynb" - }, - "kernelspec": { - "display_name": "base", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.5" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/online-docs/pages/User guide/Post-processing/notebooks/CosmicIntegration.py b/online-docs/pages/User guide/Post-processing/notebooks/CosmicIntegration.py index 375ad79cf..5f1037c6a 100644 --- a/online-docs/pages/User guide/Post-processing/notebooks/CosmicIntegration.py +++ b/online-docs/pages/User guide/Post-processing/notebooks/CosmicIntegration.py @@ -42,8 +42,8 @@ # + import numpy as np -from compas_python_utils.cosmic_integration.binned_cosmic_integrator.bbh_population import generate_mock_bbh_population_file -from compas_python_utils.cosmic_integration.binned_cosmic_integrator.bbh_population import BBHPopulation +from compas_python_utils.cosmic_integration.binned_cosmic_integrator.binary_population import generate_mock_population +from compas_python_utils.cosmic_integration.binned_cosmic_integrator.binary_population import BinaryPopulation np.random.seed(42) @@ -51,11 +51,11 @@ m1_max = 150 m2_min = 0.1 -compas_fname = generate_mock_bbh_population_file( - "mock_compas_data.h5", n_systems=int(1e4), frac_bbh=1, +compas_fname = generate_mock_population( + "mock_compas_data.h5", n_systems=int(1e4), frac_bbh=1, frac_bhns=0, frac_bns=0, m1_min=m1_min, m1_max=m1_max, m2_min=m2_min ) -bbh_population = BBHPopulation.from_compas_h5(compas_fname, m1_min=m1_min, m1_max=m1_max, m2_min=m2_min) +bbh_population = BinaryPopulation.from_compas_h5(compas_fname, m1_min=m1_min, m1_max=m1_max, m2_min=m2_min) fig = bbh_population.plot() # - diff --git a/py_tests/conftest.py b/py_tests/conftest.py index 53053e2ed..1af7d4650 100644 --- a/py_tests/conftest.py +++ b/py_tests/conftest.py @@ -4,8 +4,8 @@ import subprocess import h5py import pytest -from compas_python_utils.cosmic_integration.binned_cosmic_integrator.bbh_population import \ - generate_mock_bbh_population_file +from compas_python_utils.cosmic_integration.binned_cosmic_integrator.binary_population import \ + generate_mock_population HERE = os.path.dirname(__file__) TEST_CONFIG_DIR = os.path.join(HERE, "test_data") @@ -58,7 +58,7 @@ def get_compas_data(path: str) -> Dict[str, Any]: @pytest.fixture def fake_compas_output(tmpdir) -> str: fname = f"{tmpdir}/COMPAS_mock_output.h5" - generate_mock_bbh_population_file( + generate_mock_population( filename=fname, ) return fname \ No newline at end of file diff --git a/py_tests/test_binned_integrator.py b/py_tests/test_binned_integrator.py index 19afcce7d..9b28bf8c8 100644 --- a/py_tests/test_binned_integrator.py +++ b/py_tests/test_binned_integrator.py @@ -1,5 +1,5 @@ from compas_python_utils.cosmic_integration.binned_cosmic_integrator.cosmological_model import CosmologicalModel -from compas_python_utils.cosmic_integration.binned_cosmic_integrator.bbh_population import BBHPopulation +from compas_python_utils.cosmic_integration.binned_cosmic_integrator.binary_population import BinaryPopulation from compas_python_utils.cosmic_integration.binned_cosmic_integrator.snr_grid import SNRGrid from compas_python_utils.cosmic_integration.binned_cosmic_integrator.conversions import * from compas_python_utils.cosmic_integration.binned_cosmic_integrator import DetectionMatrix @@ -19,9 +19,8 @@ def test_cosmological_models(test_archive_dir): def test_bbh_population(fake_compas_output): - population = BBHPopulation.from_compas_h5(fake_compas_output) - assert population.n_bbh > 2 - assert population.n_systems >= population.n_bbh + population = BinaryPopulation.from_compas_h5(fake_compas_output) + assert population.n_systems > 2 assert population.mass_evolved_per_binary > 0 def test_SNR_grid(test_archive_dir): @@ -42,14 +41,16 @@ def test_conversions(): assert np.isclose(m1_new, m1) assert np.isclose(m2_new, m2) -def test_binned_cosmic_integration(fake_compas_output, test_archive_dir,): +def test_binned_cosmic_integration(fake_compas_output, test_archive_dir,): + # fake_compas_output = '/Users/avaj0001/Documents/projects/compas_dev/COMPAS/py_tests/test_data/COMPAS_Output/h5out_5M.h5' + detection_matrix = DetectionMatrix.from_compas_output( fake_compas_output, outdir=test_archive_dir, save_plots=True, chirp_mass_bins=None, redshift_bins=None, n_bootstrapped_matrices=1 ) assert detection_matrix.rate_matrix.shape == (len(detection_matrix.chirp_mass_bins), len(detection_matrix.redshift_bins)) detection_matrix.save() - det_matrix_fn = glob.glob(f'{test_archive_dir}/*.h5')[0] + det_matrix_fn = glob.glob(f'{test_archive_dir}/{detection_matrix.label}.h5')[0] loaded_det_matrix = DetectionMatrix.from_h5(det_matrix_fn) assert np.allclose(detection_matrix.rate_matrix, loaded_det_matrix.rate_matrix) loaded_det_matrix.bin_data(mc_bins=50, z_bins=100) diff --git a/py_tests/test_total_mass_evolved_per_z.py b/py_tests/test_total_mass_evolved_per_z.py index 8f77ec4ed..fac88e4d6 100644 --- a/py_tests/test_total_mass_evolved_per_z.py +++ b/py_tests/test_total_mass_evolved_per_z.py @@ -2,8 +2,8 @@ IMF, get_COMPAS_fraction, analytical_star_forming_mass_per_binary_using_kroupa_imf, star_forming_mass_per_binary, inverse_sample_IMF, ) -from compas_python_utils.cosmic_integration.binned_cosmic_integrator.bbh_population import \ - generate_mock_bbh_population_file +from compas_python_utils.cosmic_integration.binned_cosmic_integrator.binary_population import \ + generate_mock_population import numpy as np import matplotlib.pyplot as plt import h5py as h5 @@ -90,7 +90,7 @@ def plot_star_forming_mass_per_binary_comparison( vals = np.zeros(len(n_samps)) for i, n in enumerate(n_samps): fname = f"{tmpdir}/test_{i}.h5" - generate_mock_bbh_population_file(tmpdir, n_systems=int(n)) + generate_mock_population(tmpdir, n_systems=int(n)) vals[i] = (star_forming_mass_per_binary(fname, m1_min, m1_max, m2_min, fbin)) numerical_vals.append(vals) From 79334f5f8f71e7548cb434fd004c7c1e2833a76b Mon Sep 17 00:00:00 2001 From: Avi Vajpeyi Date: Thu, 22 May 2025 11:48:12 +1200 Subject: [PATCH 2/6] remove hacked in comment --- py_tests/test_binned_integrator.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/py_tests/test_binned_integrator.py b/py_tests/test_binned_integrator.py index 9b28bf8c8..19445b4c0 100644 --- a/py_tests/test_binned_integrator.py +++ b/py_tests/test_binned_integrator.py @@ -42,8 +42,6 @@ def test_conversions(): assert np.isclose(m2_new, m2) def test_binned_cosmic_integration(fake_compas_output, test_archive_dir,): - # fake_compas_output = '/Users/avaj0001/Documents/projects/compas_dev/COMPAS/py_tests/test_data/COMPAS_Output/h5out_5M.h5' - detection_matrix = DetectionMatrix.from_compas_output( fake_compas_output, outdir=test_archive_dir, save_plots=True, chirp_mass_bins=None, redshift_bins=None, n_bootstrapped_matrices=1 From 412e449af3150c306587fde931912313c94d071c Mon Sep 17 00:00:00 2001 From: Avi Vajpeyi Date: Thu, 22 May 2025 12:20:50 +1200 Subject: [PATCH 3/6] add mass@zams to test object --- .../binned_cosmic_integrator/binary_population.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/compas_python_utils/cosmic_integration/binned_cosmic_integrator/binary_population.py b/compas_python_utils/cosmic_integration/binned_cosmic_integrator/binary_population.py index a9f75327f..e32f494ab 100644 --- a/compas_python_utils/cosmic_integration/binned_cosmic_integrator/binary_population.py +++ b/compas_python_utils/cosmic_integration/binned_cosmic_integrator/binary_population.py @@ -309,6 +309,8 @@ def generate_mock_population( seeds = np.arange(n_systems) f["BSE_System_Parameters"].create_dataset("SEED", data=seeds) f["BSE_System_Parameters"].create_dataset("Metallicity@ZAMS(1)", data=np.random.uniform(1e-4,1e-2,n_systems)) + f["BSE_System_Parameters"].create_dataset("Mass@ZAMS(1)", data=m1) + f["BSE_System_Parameters"].create_dataset("Mass@ZAMS(2)", data=m2) # CE ce_seeds = np.arange(n_ce) f["BSE_Common_Envelopes"].create_dataset("SEED", data=ce_seeds) From 2163abe025cb647c550630e8c119cdace6a43af3 Mon Sep 17 00:00:00 2001 From: Avi Vajpeyi Date: Thu, 22 May 2025 14:51:09 +1200 Subject: [PATCH 4/6] add different stellar types for binned cosmic integrator --- .../binary_population.py | 171 ++++++++++-------- .../detection_matrix.py | 3 +- .../binned_cosmic_integrator/stellar_type.py | 33 ++++ 3 files changed, 127 insertions(+), 80 deletions(-) create mode 100644 compas_python_utils/cosmic_integration/binned_cosmic_integrator/stellar_type.py diff --git a/compas_python_utils/cosmic_integration/binned_cosmic_integrator/binary_population.py b/compas_python_utils/cosmic_integration/binned_cosmic_integrator/binary_population.py index e32f494ab..0f62ea7ca 100644 --- a/compas_python_utils/cosmic_integration/binned_cosmic_integrator/binary_population.py +++ b/compas_python_utils/cosmic_integration/binned_cosmic_integrator/binary_population.py @@ -9,15 +9,28 @@ ) from .conversions import m1_m2_to_chirp_mass, m1_m2_to_eta from .plotting import plot_binary_population +from .stellar_type import BH, NS, WD # Default IMF limits M1_MIN = 5 M1_MAX = 150 M2_MIN = 0.1 +DCO_GROUPS = dict( + BBH=[BH, BH], + BNS=[NS, NS], + BWD=[WD, WD], + NSBH=[NS, BH], + WDNS=[WD, NS], + WDBH=[WD, BH], +) + +VALID_DCO_TYPES = list(DCO_GROUPS.keys()) + + class BinaryPopulation: """ - General DCO population class supporting BBH, BNS, BHNS. + General DCO population class supporting BBH, BNS, NSBH. Loads the DCOs population from COMPAS output. Requires the COMPAS output to contain the following datasets: @@ -40,32 +53,28 @@ class BinaryPopulation: - BSE_Double_Compact_Objects/Stellar_Type(2) - BSE_Double_Compact_Objects/Merges_Hubble_Time - - - Flags: - include_bbh: bool - include_bns: bool - include_bhns: bool """ + def __init__( - self, - m1: np.ndarray, - m2: np.ndarray, - t_delay: np.ndarray, - z_zams: np.ndarray, - n_systems: int, - include_bbh: bool = True, - include_bns: bool = False, - include_bhns: bool = False, - m1_min: float = M1_MIN, - m1_max: float = M1_MAX, - m2_min: float = M2_MIN, - binary_fraction: float = 0.7, + self, + m1: np.ndarray, + m2: np.ndarray, + t_delay: np.ndarray, + z_zams: np.ndarray, + n_systems: int, + dcos_included: List[str], + m1_min: float = M1_MIN, + m1_max: float = M1_MAX, + m2_min: float = M2_MIN, + binary_fraction: float = 0.7, ): # Population selection - self.include_bbh = include_bbh - self.include_bns = include_bns - self.include_bhns = include_bhns + self.dcos_included = dcos_included + if not any([x in VALID_DCO_TYPES for x in dcos_included]): + raise ValueError( + f"Invalid DCO types: {dcos_included}. " + f"Valid types are: {VALID_DCO_TYPES}" + ) # IMF parameters self.m1_min = m1_min @@ -88,17 +97,15 @@ def __init__( @classmethod def from_compas_h5( - cls, - path: str, - include_bbh: bool = True, - include_bns: bool = False, - include_bhns: bool = False, - m1_min: float = M1_MIN, - m1_max: float = M1_MAX, - m2_min: float = M2_MIN, - binary_fraction: float = 0.7, + cls, + path: str, + dcos_included: List[str] = ["BBH"], + m1_min: float = M1_MIN, + m1_max: float = M1_MAX, + m2_min: float = M2_MIN, + binary_fraction: float = 0.7, ) -> "BinaryPopulation": - mask = cls._generate_mask(path, include_bbh, include_bns, include_bhns) + mask = cls._generate_mask(path, dcos_included) m1, m2, t0, tC, seeds = _load_data( path, @@ -121,9 +128,7 @@ def from_compas_h5( t_delay=t0 + tC, z_zams=z_zams[dco_mask], n_systems=len(all_seeds), - include_bbh=include_bbh, - include_bns=include_bns, - include_bhns=include_bhns, + dcos_included=dcos_included, m1_min=m1_min, m1_max=m1_max, m2_min=m2_min, @@ -132,35 +137,21 @@ def from_compas_h5( @staticmethod def _generate_mask( - path: str, - include_bbh: bool, - include_bns: bool, - include_bhns: bool, + path: str, + dcos_included: List[str], ) -> xp.ndarray: - # Load fundamental DCO variables - t1, t2, hubble_flag, dco_seeds = _load_data( + type_mask = _generate_dco_mask(path, dcos_included) + + # Load the Hubble time flag + BSE seeds + hubble_flag, dco_seeds = _load_data( path, "BSE_Double_Compact_Objects", - ["Stellar_Type(1)", "Stellar_Type(2)", "Merges_Hubble_Time", "SEED"], + ["Merges_Hubble_Time", "SEED"], ) - # Base masks by type - masks = [] - if include_bbh: - masks.append((t1 == 14) & (t2 == 14)) - if include_bns: - masks.append((t1 == 13) & (t2 == 13)) - if include_bhns: - masks.append((t1 == 14) & (t2 == 13) | (t1 == 13) & (t2 == 14)) - if not masks: - raise ValueError("At least one DCO type must be included.") - - - type_mask = np.logical_or.reduce(masks) # Hubble time filter hubble_mask = hubble_flag.astype(bool) - # get the flags and unique seeds from the Common Envelopes file ce_seeds, rlof_flag, optimistic_ce = _load_data( path, "BSE_Common_Envelopes", ["SEED", "Immediate_RLOF>CE", "Optimistic_CE"]) @@ -191,7 +182,6 @@ def _generate_mask( return type_mask * hubble_mask * mask_out_with_rlof_seeds * mask_out_optimistic_ce_seeds - @property def n_dcos(self) -> int: return len(self.m1) @@ -238,9 +228,7 @@ def bootstrap_population(self) -> "BinaryPopulation": t_delay=self.t_delay[idx], z_zams=self.z_zams[idx], n_systems=self.n_systems, - include_bbh=self.include_bbh, - include_bns=self.include_bns, - include_bhns=self.include_bhns, + dcos_included=self.dcos_included, m1_min=self.m1_min, m1_max=self.m1_max, m2_min=self.m2_min, @@ -258,7 +246,32 @@ def __str__(self): return self.__repr__() -# Helper I/O function remains unchanged +def _generate_dco_mask( + compas_path: str, + dcos_included: List[str] +) -> xp.ndarray: + # Load fundamental DCO variables + t1, t2 = _load_data( + compas_path, + "BSE_Double_Compact_Objects", + ["Stellar_Type(1)", "Stellar_Type(2)"], + ) + + masks = [] + for dco in dcos_included: + if dco not in DCO_GROUPS: + continue + a, b = DCO_GROUPS[dco] + # check if t1 in set 'a' of stellar types and t2 in set 'b' of stellar types + masks.append((np.isin(t1, a) & np.isin(t2, b)) | (np.isin(t1, b) & np.isin(t2, a))) + + if not masks: + raise ValueError("At least one DCO type must be included.") + + # Combine all masks using logical OR + type_mask = np.logical_or.reduce(masks) + return type_mask + def _load_data(path: str, group: str, var_names: List[str], mask: Optional[xp.ndarray] = None): with h5py.File(path, "r") as f: @@ -267,17 +280,18 @@ def _load_data(path: str, group: str, var_names: List[str], mask: Optional[xp.nd data = [d[mask] for d in data] return data + # Mock generation utility def generate_mock_population( - filename: str = "", - n_systems: int = 2000, - frac_bbh: float = 0.7, - frac_bns: float = 0.2, - frac_bhns: float = 0.1, - m1_min: float = M1_MIN, - m1_max: float = M1_MAX, - m2_min: float = M2_MIN, + filename: str = "", + n_systems: int = 2000, + frac_bbh: float = 0.7, + frac_bns: float = 0.2, + frac_bhns: float = 0.1, + m1_min: float = M1_MIN, + m1_max: float = M1_MAX, + m2_min: float = M2_MIN, ): if filename == "": filename = "dco_mock_population.h5" @@ -287,20 +301,19 @@ def generate_mock_population( n_systems = len(m1) n_dcos = n_systems // 2 n_ce = n_systems * 2 - types = np.random.choice(["BBH","BNS","BHNS"], size=n_dcos, + types = np.random.choice(["BBH", "BNS", "NSBH"], size=n_dcos, p=[frac_bbh, frac_bns, frac_bhns]) # Define the type-to-mass mapping type_to_pair = { "BBH": [14, 14], "BNS": [13, 13], - "BHNS": [13, 14] + "NSBH": [13, 14] } # Create a 2D array by mapping each type to its corresponding mass pair mass_pairs = np.array([type_to_pair[t] for t in types]).T - # create file structure with h5py.File(filename, "w") as f: f.create_group("BSE_System_Parameters") @@ -308,14 +321,14 @@ def generate_mock_population( f.create_group("BSE_Double_Compact_Objects") seeds = np.arange(n_systems) f["BSE_System_Parameters"].create_dataset("SEED", data=seeds) - f["BSE_System_Parameters"].create_dataset("Metallicity@ZAMS(1)", data=np.random.uniform(1e-4,1e-2,n_systems)) + f["BSE_System_Parameters"].create_dataset("Metallicity@ZAMS(1)", data=np.random.uniform(1e-4, 1e-2, n_systems)) f["BSE_System_Parameters"].create_dataset("Mass@ZAMS(1)", data=m1) f["BSE_System_Parameters"].create_dataset("Mass@ZAMS(2)", data=m2) # CE ce_seeds = np.arange(n_ce) f["BSE_Common_Envelopes"].create_dataset("SEED", data=ce_seeds) - f["BSE_Common_Envelopes"].create_dataset("Immediate_RLOF>CE", data=np.zeros(n_ce,dtype=bool)) # no RLOF after CE - f["BSE_Common_Envelopes"].create_dataset("Optimistic_CE", data=np.zeros(n_ce,dtype=bool)) # no optimistic CE + f["BSE_Common_Envelopes"].create_dataset("Immediate_RLOF>CE", data=np.zeros(n_ce, dtype=bool)) # no RLOF after CE + f["BSE_Common_Envelopes"].create_dataset("Optimistic_CE", data=np.zeros(n_ce, dtype=bool)) # no optimistic CE # DCOs dco_seeds = np.arange(n_dcos) f["BSE_Double_Compact_Objects"].create_dataset("Stellar_Type(1)", data=mass_pairs[0, :]) @@ -323,7 +336,7 @@ def generate_mock_population( f["BSE_Double_Compact_Objects"].create_dataset("SEED", data=dco_seeds) f["BSE_Double_Compact_Objects"].create_dataset("Mass(1)", data=m1[:n_dcos]) f["BSE_Double_Compact_Objects"].create_dataset("Mass(2)", data=m2[:n_dcos]) - f["BSE_Double_Compact_Objects"].create_dataset("Time", data=np.random.uniform(4,13.8,n_dcos)) - f["BSE_Double_Compact_Objects"].create_dataset("Coalescence_Time", data=np.random.uniform(0,14000,n_dcos)) - f["BSE_Double_Compact_Objects"].create_dataset("Merges_Hubble_Time", data=np.ones(n_dcos,dtype=bool)) + f["BSE_Double_Compact_Objects"].create_dataset("Time", data=np.random.uniform(4, 13.8, n_dcos)) + f["BSE_Double_Compact_Objects"].create_dataset("Coalescence_Time", data=np.random.uniform(0, 14000, n_dcos)) + f["BSE_Double_Compact_Objects"].create_dataset("Merges_Hubble_Time", data=np.ones(n_dcos, dtype=bool)) return filename diff --git a/compas_python_utils/cosmic_integration/binned_cosmic_integrator/detection_matrix.py b/compas_python_utils/cosmic_integration/binned_cosmic_integrator/detection_matrix.py index aacfc1f91..13ed20343 100644 --- a/compas_python_utils/cosmic_integration/binned_cosmic_integrator/detection_matrix.py +++ b/compas_python_utils/cosmic_integration/binned_cosmic_integrator/detection_matrix.py @@ -62,7 +62,8 @@ def from_compas_output( outdir: str = None, save_plots: bool = False, n_bootstrapped_matrices: int = 0, - sens: str = 'O1' + sens: str = 'O1', + binary_types_to_include=[] ) -> "DetectionMatrix": dco_population = BinaryPopulation.from_compas_h5(compas_path) diff --git a/compas_python_utils/cosmic_integration/binned_cosmic_integrator/stellar_type.py b/compas_python_utils/cosmic_integration/binned_cosmic_integrator/stellar_type.py new file mode 100644 index 000000000..67f9ef0c8 --- /dev/null +++ b/compas_python_utils/cosmic_integration/binned_cosmic_integrator/stellar_type.py @@ -0,0 +1,33 @@ +from enum import Enum, auto + + +class STELLAR_TYPE(Enum): + MS_LTE_07 = auto() + MS_GT_07 = auto() + HERTZSPRUNG_GAP = auto() + FIRST_GIANT_BRANCH = auto() + CORE_HELIUM_BURNING = auto() + EARLY_ASYMPTOTIC_GIANT_BRANCH = auto() + THERMALLY_PULSING_ASYMPTOTIC_GIANT_BRANCH = auto() + NAKED_HELIUM_STAR_MS = auto() + NAKED_HELIUM_STAR_HERTZSPRUNG_GAP = auto() + NAKED_HELIUM_STAR_GIANT_BRANCH = auto() + HELIUM_WHITE_DWARF = auto() + CARBON_OXYGEN_WHITE_DWARF = auto() + OXYGEN_NEON_WHITE_DWARF = auto() + NEUTRON_STAR = auto() + BLACK_HOLE = auto() + MASSLESS_REMNANT = auto() + CHEMICALLY_HOMOGENEOUS = auto() + STAR = auto() + BINARY_STAR = auto() + NONE = auto() + + +BH = [STELLAR_TYPE.BLACK_HOLE] +NS = [STELLAR_TYPE.NEUTRON_STAR] +WD = [STELLAR_TYPE.HELIUM_WHITE_DWARF, + STELLAR_TYPE.CARBON_OXYGEN_WHITE_DWARF, + STELLAR_TYPE.HELIUM_WHITE_DWARF, + STELLAR_TYPE.OXYGEN_NEON_WHITE_DWARF] + From 0dbf36048b54652d93b29ae8bb576a1ce5182eea Mon Sep 17 00:00:00 2001 From: Avi Vajpeyi Date: Thu, 22 May 2025 15:31:41 +1200 Subject: [PATCH 5/6] fix enum bug --- .../binned_cosmic_integrator/binary_population.py | 10 +++++----- .../binned_cosmic_integrator/detection_matrix.py | 8 +++++--- .../binned_cosmic_integrator/stellar_type.py | 3 +-- py_tests/test_binned_integrator.py | 1 + 4 files changed, 12 insertions(+), 10 deletions(-) diff --git a/compas_python_utils/cosmic_integration/binned_cosmic_integrator/binary_population.py b/compas_python_utils/cosmic_integration/binned_cosmic_integrator/binary_population.py index 0f62ea7ca..514d87b6c 100644 --- a/compas_python_utils/cosmic_integration/binned_cosmic_integrator/binary_population.py +++ b/compas_python_utils/cosmic_integration/binned_cosmic_integrator/binary_population.py @@ -259,11 +259,11 @@ def _generate_dco_mask( masks = [] for dco in dcos_included: - if dco not in DCO_GROUPS: - continue - a, b = DCO_GROUPS[dco] - # check if t1 in set 'a' of stellar types and t2 in set 'b' of stellar types - masks.append((np.isin(t1, a) & np.isin(t2, b)) | (np.isin(t1, b) & np.isin(t2, a))) + if dco in DCO_GROUPS: + a = [type.value for type in DCO_GROUPS[dco][0]] + b = [type.value for type in DCO_GROUPS[dco][1]] + # check if t1 in set 'a' of stellar types and t2 in set 'b' of stellar types + masks.append((np.isin(t1, a) & np.isin(t2, b)) | (np.isin(t1, b) & np.isin(t2, a))) if not masks: raise ValueError("At least one DCO type must be included.") diff --git a/compas_python_utils/cosmic_integration/binned_cosmic_integrator/detection_matrix.py b/compas_python_utils/cosmic_integration/binned_cosmic_integrator/detection_matrix.py index 13ed20343..25f7e272b 100644 --- a/compas_python_utils/cosmic_integration/binned_cosmic_integrator/detection_matrix.py +++ b/compas_python_utils/cosmic_integration/binned_cosmic_integrator/detection_matrix.py @@ -1,6 +1,6 @@ import numpy as np import os -from typing import Dict +from typing import Dict, List import h5py as h5 from tqdm.auto import trange @@ -26,6 +26,7 @@ def __init__( n_dcos: int, outdir: str = None, sens: str = 'O1', + dcos_included: List[str] = ["BBH"], bootstrapped_rate_matrices: np.ndarray = None ): self.compas_path = compas_path @@ -37,6 +38,7 @@ def __init__( self.bootstrapped_rate_matrices = bootstrapped_rate_matrices self.n_systems = n_systems self.n_dcos = n_dcos + self.dcos_included = dcos_included self.sens = sens @property @@ -63,10 +65,10 @@ def from_compas_output( save_plots: bool = False, n_bootstrapped_matrices: int = 0, sens: str = 'O1', - binary_types_to_include=[] + dcos_included: List[str] = ["BBH"], ) -> "DetectionMatrix": - dco_population = BinaryPopulation.from_compas_h5(compas_path) + dco_population = BinaryPopulation.from_compas_h5(compas_path, dcos_included=dcos_included) cosmological_model = CosmologicalModel(**cosmological_parameters) snr_grid = SNRGrid(sensitivity=sens) diff --git a/compas_python_utils/cosmic_integration/binned_cosmic_integrator/stellar_type.py b/compas_python_utils/cosmic_integration/binned_cosmic_integrator/stellar_type.py index 67f9ef0c8..dcc7737ee 100644 --- a/compas_python_utils/cosmic_integration/binned_cosmic_integrator/stellar_type.py +++ b/compas_python_utils/cosmic_integration/binned_cosmic_integrator/stellar_type.py @@ -2,7 +2,7 @@ class STELLAR_TYPE(Enum): - MS_LTE_07 = auto() + MS_LTE_07 = 0 MS_GT_07 = auto() HERTZSPRUNG_GAP = auto() FIRST_GIANT_BRANCH = auto() @@ -23,7 +23,6 @@ class STELLAR_TYPE(Enum): BINARY_STAR = auto() NONE = auto() - BH = [STELLAR_TYPE.BLACK_HOLE] NS = [STELLAR_TYPE.NEUTRON_STAR] WD = [STELLAR_TYPE.HELIUM_WHITE_DWARF, diff --git a/py_tests/test_binned_integrator.py b/py_tests/test_binned_integrator.py index 19445b4c0..39d04bcb6 100644 --- a/py_tests/test_binned_integrator.py +++ b/py_tests/test_binned_integrator.py @@ -22,6 +22,7 @@ def test_bbh_population(fake_compas_output): population = BinaryPopulation.from_compas_h5(fake_compas_output) assert population.n_systems > 2 assert population.mass_evolved_per_binary > 0 + assert population.n_dcos > 0 def test_SNR_grid(test_archive_dir): snr_grid = SNRGrid() From 8b8393615375054074513364b74ed601dadf4379 Mon Sep 17 00:00:00 2001 From: Avi Vajpeyi Date: Fri, 23 May 2025 17:05:57 +1200 Subject: [PATCH 6/6] adjust example to include dcos_included=[BBH] --- .../notebooks/CosmicIntegration.py | 27 +++++++++++++------ 1 file changed, 19 insertions(+), 8 deletions(-) diff --git a/online-docs/pages/User guide/Post-processing/notebooks/CosmicIntegration.py b/online-docs/pages/User guide/Post-processing/notebooks/CosmicIntegration.py index 5f1037c6a..6dcdbaef6 100644 --- a/online-docs/pages/User guide/Post-processing/notebooks/CosmicIntegration.py +++ b/online-docs/pages/User guide/Post-processing/notebooks/CosmicIntegration.py @@ -47,15 +47,23 @@ np.random.seed(42) -m1_min = 5 -m1_max = 150 -m2_min = 0.1 + +mass_params = dict( + m1_min = 5, + m1_max = 150, + m2_min = 0.1, +) compas_fname = generate_mock_population( - "mock_compas_data.h5", n_systems=int(1e4), frac_bbh=1, frac_bhns=0, frac_bns=0, - m1_min=m1_min, m1_max=m1_max, m2_min=m2_min + "mock_compas_data.h5", n_systems=int(1e4), + frac_bbh=1, frac_bhns=0, frac_bns=0, + **mass_params, +) +bbh_population = BinaryPopulation.from_compas_h5( + compas_fname, + dcos_included=['BBH'], + **mass_params ) -bbh_population = BinaryPopulation.from_compas_h5(compas_fname, m1_min=m1_min, m1_max=m1_max, m2_min=m2_min) fig = bbh_population.plot() # - @@ -112,7 +120,7 @@ # + from compas_python_utils.cosmic_integration.binned_cosmic_integrator.snr_grid import SNRGrid -snr_grid = SNRGrid() +snr_grid = SNRGrid(sensitivity="O3") fig = snr_grid.plot() # - @@ -135,7 +143,10 @@ # We have a helper class to do this in one go: detection_matrix = DetectionMatrix.from_compas_output( - compas_fname, save_plots=False, + compas_fname, + sens="O3", + dcos_included=["BBH"], + save_plots=False, chirp_mass_bins=50, redshift_bins=100, cosmological_parameters=dict(aSF=0.01, dSF=4.70, mu_z=-.23, sigma_z=0), )