cosmic-popsynth 3.5.0__tar.gz → 3.6.1__tar.gz

{cosmic_popsynth-3.5.0 → cosmic_popsynth-3.6.1}/.github/workflows/build_wheels_and_publish.yml

@@ -6,7 +6,7 @@ on:
   workflow_dispatch:
 
 env:
-  CIBW_BUILD: "cp39-* cp310-*"
+  CIBW_BUILD: "cp39-* cp310-* cp311-* cp312-*"
   CIBW_ARCHS_LINUX: "x86_64"
   CIBW_SKIP: "*-win32 *musllinux*"
   CIBW_MANYLINUX_X86_64_IMAGE: manylinux2014
@@ -20,7 +20,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest]
-        python-version: [3.9, "3.10"]
+        python-version: [3.9, "3.10", "3.11", "3.12"]
 
     steps:
     - uses: actions/checkout@v4

{cosmic_popsynth-3.5.0 → cosmic_popsynth-3.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cosmic-popsynth
-Version: 3.5.0
+Version: 3.6.1
 Summary: a Python-interfaced binary population synthesis suite
 Author: Scott Coughlin, Michael Zevin, Carl L. Rodriguez, Tom Wagg
 Author-Email: Katelyn Breivik <katie.breivik@gmail.com>

{cosmic_popsynth-3.5.0 → cosmic_popsynth-3.6.1}/bin/cosmic-pop

@@ -11,29 +11,24 @@
 ##############################################################################
 #  IMPORT ALL NECESSARY PYTHON PACKAGES
 ##############################################################################
-from collections import OrderedDict
-import warnings
 import argparse
 import schwimmbad
 
-import math
-import random
 import time
 from time import sleep
-import string
-import os.path
 import json
 
 import numpy as np
-import scipy.special as ss
 import pandas as pd
+from pandas.errors import PerformanceWarning
 import warnings
 
 from cosmic.sample.initialbinarytable import InitialBinaryTable
 from cosmic import Match, utils
 from cosmic.evolve import Evolve
 
-from schwimmbad import MultiPool, MPIPool
+from schwimmbad import MPIPool
+from os import sys
 
 def str2bool(v):
     if isinstance(v, bool):
@@ -243,10 +238,12 @@ if __name__ == '__main__':
         kstar2_range = args.final_kstar2
         kstar2_range_string = str(int(args.final_kstar2[0]))
 
+    dat_store_fname = 'dat_kstar1_{0}_kstar2_{1}_SFstart_{2}_SFduration_{3}_metallicity_{4}.h5'.format(kstar1_range_string, kstar2_range_string, sampling['SF_start'], sampling['SF_duration'], sampling['metallicity'])
     # Open the hdf5 file to store the fixed population data
     try:
-        dat_store = pd.HDFStore('dat_kstar1_{0}_kstar2_{1}_SFstart_{2}_SFduration_{3}_metallicity_{4}.h5'.format(kstar1_range_string, kstar2_range_string, sampling['SF_start'], sampling['SF_duration'], sampling['metallicity']),complib=args.complib,complevel=args.complevel)
-        conv_save = pd.read_hdf(dat_store, 'conv')
+        with pd.HDFStore(dat_store_fname,complib=args.complib,complevel=args.complevel) as dat_store:
+            # If the file exists, we will read it and continue from where we left off
+            conv_save = pd.read_hdf(dat_store, 'conv')
         log_file = open('log_kstar1_{0}_kstar2_{1}_SFstart_{2}_SFduration_{3}_metallicity_{4}.txt'.format(kstar1_range_string, kstar2_range_string, sampling['SF_start'], sampling['SF_duration'], sampling['metallicity']), 'a')
         log_file.write('There are already: '+str(conv_save.shape[0])+' '+kstar1_range_string+'_'+kstar2_range_string+' binaries evolved\n')
         log_file.write('\n')
@@ -258,8 +255,8 @@ if __name__ == '__main__':
         total_n_stars = np.max(pd.read_hdf(dat_store, 'n_stars'))[0]
         idx = int(np.max(pd.read_hdf(dat_store, 'idx'))[0])
     except:
+        #dat_store = pd.HDFStore('dat_kstar1_{0}_kstar2_{1}_SFstart_{2}_SFduration_{3}_metallicity_{4}.h5'.format(kstar1_range_string, kstar2_range_string, sampling['SF_start'], sampling['SF_duration'], sampling['metallicity']),complib=args.complib,complevel=args.complevel)
         conv_save = pd.DataFrame()
-        dat_store = pd.HDFStore('dat_kstar1_{0}_kstar2_{1}_SFstart_{2}_SFduration_{3}_metallicity_{4}.h5'.format(kstar1_range_string, kstar2_range_string, sampling['SF_start'], sampling['SF_duration'], sampling['metallicity']),complib=args.complib,complevel=args.complevel)
         total_mass_singles = 0  
         total_mass_binaries = 0
         total_mass_stars = 0
@@ -273,10 +270,14 @@ if __name__ == '__main__':
     configuration_settings = {'BSEDict' : BSEDict, 'filters' : filters,
                               'convergence' : convergence, 'sampling' : sampling}
 
-    for k, v in configuration_settings.items():
-        for k1, v1 in v.items():
-            dat_store.put('config/{0}/{1}/'.format(k, k1), pd.Series(v1))
-    dat_store.put('config/rand_seed/', pd.Series(seed_int))
+    with warnings.catch_warnings():
+        warnings.simplefilter(action="ignore", category=PerformanceWarning)
+        
+        with pd.HDFStore(dat_store_fname,complib=args.complib,complevel=args.complevel) as dat_store:
+            for k, v in configuration_settings.items():
+                for k1, v1 in v.items():
+                    dat_store.put('config/{0}/{1}/'.format(k, k1), pd.Series(v1))
+            dat_store.put('config/rand_seed/', pd.Series(seed_int))
 
     # Initialize the step counter and convergence array/list
     Nstep = idx - np.mod(idx, args.Nstep)
@@ -304,6 +305,9 @@ if __name__ == '__main__':
 
         # Select the initial binary sample method from user input
         if sampling['sampling_method'] == 'independent':
+            if hasattr(args,'qmin') and hasattr(args,'m2_min'):
+                raise ValueError("You cannot specify both qmin and m2_min in the inifile if you are using the independent sampler. Please choose one or the other.")
+            # If qmin is specified, use it to sample the initial binary table
             if hasattr(args,'qmin'):
                 init_samp_list = InitialBinaryTable.sampler(format_ = sampling['sampling_method'],
                                                             final_kstar1 = kstar1_range,
@@ -319,6 +323,7 @@ if __name__ == '__main__':
                                                             size = args.Nstep,
                                                             qmin = args.qmin,
                                                             params = args.inifile)
+            # if m2_min is specified, use it to sample the initial binary table
             elif hasattr(args,'m2_min'):
                 init_samp_list = InitialBinaryTable.sampler(format_ = sampling['sampling_method'],
                                                             final_kstar1 = kstar1_range,
@@ -343,14 +348,15 @@ if __name__ == '__main__':
             init_samp_list = InitialBinaryTable.sampler(format_ = sampling['sampling_method'],
                                                         final_kstar1 = kstar1_range,
                                                         final_kstar2 = kstar2_range,
-                                                        keep_singles = args.keep_singles,
                                                         rand_seed = rand_seed,
                                                         nproc = args.nproc,
                                                         SF_start = sampling['SF_start'],
                                                         SF_duration = sampling['SF_duration'],
                                                         met = sampling['metallicity'],
                                                         size = args.Nstep,
-                                                        pool=pool)
+                                                        pool=pool,
+                                                        keep_singles = args.keep_singles
+                                                        )
             IBT, mass_singles, mass_binaries, n_singles, n_binaries = init_samp_list
 
         # Log the total sampled mass from the initial binary sample
@@ -387,17 +393,33 @@ if __name__ == '__main__':
                                                       dtp=dtp,
                                                       timestep_conditions=filters['timestep_conditions'])
 
+        # extract single stars
+
+        if (args.keep_singles==True):
+            singles_bin_num = initCond.loc[initCond.kstar_2 == 15].bin_num.unique()
+            # get the singles from the bcm and bpp arrays
+            bcm_singles = bcm.loc[bcm.bin_num.isin(singles_bin_num)]
+            bpp_singles = bpp.loc[bpp.bin_num.isin(singles_bin_num)]
+            initCond_singles = initCond.loc[initCond.bin_num.isin(singles_bin_num)]
+            kick_info_singles = kick_info.loc[kick_info.bin_num.isin(singles_bin_num)]
+
+            bpp = bpp.loc[~bpp.bin_num.isin(singles_bin_num)]
+            bcm = bcm.loc[~bcm.bin_num.isin(singles_bin_num)]
+            initCond = initCond.loc[~initCond.bin_num.isin(singles_bin_num)]
+            kick_info = kick_info.loc[~kick_info.bin_num.isin(singles_bin_num)]
         # get any nans and pull them out for now
         nans = np.isnan(bpp.sep)
         if nans.any():
             nan_bin_nums = np.unique(bpp[nans]["bin_num"].values)
             initCond_nan = initCond.loc[initCond.bin_num.isin(nan_bin_nums)]
-            if pd.__version__<="2.0.0":
-                dat_store.append("nan_initC", initCond_nan)
-            else:
-                dat_store["nan_initC"] = initCond_nan
-            log_file.write(f"There are {len(nan_bin_nums)} NaNs stored in the datfile with key: 'nan_initC'")
-            log_file.write(f"These NaNs likely arise because you have pts1 = 0.001, try running with pts1 = 0.01")
+            with pd.HDFStore(dat_store_fname,complib=args.complib,complevel=args.complevel) as dat_store:
+                if pd.__version__<="2.0.0":
+                    dat_store.append("nan_initC", initCond_nan)
+                else:
+                    dat_store["nan_initC"] = initCond_nan
+            log_file.write(f"There are {len(nan_bin_nums)} NaNs stored in the datfile with key: 'nan_initC'\n")
+            log_file.write(f"You might want to check them out carefully to see if there is something that impacts your results\n")
+            #log_file.write(f"These NaNs likely arise because you have pts1 = 0.001, try running with pts1 = 0.01")
 
             bcm = bcm.loc[~bcm.bin_num.isin(nan_bin_nums)]
             bpp = bpp.loc[~bpp.bin_num.isin(nan_bin_nums)]
@@ -410,6 +432,8 @@ if __name__ == '__main__':
         # If dtp is not set, filter out first timestep in bcm
         if np.all(dtp == IBT['tphysf'].values):
             bcm = bcm.loc[bcm['tphys'].isin(dtp)]
+            if (args.keep_singles==True):
+                bcm_singles = bcm_singles.loc[bcm_singles['tphys'].isin(dtp)]
 
         # Now get the converging population and bin_nums for conv systems whic
         # satisfy the convergence_limits
@@ -417,6 +441,9 @@ if __name__ == '__main__':
                                                            kstar1_range, kstar2_range,
                                                            convergence['pop_select'],
                                                            convergence['convergence_limits'])
+        if (args.keep_singles==True):
+            conv_singles_filter = utils.conv_select_singles(bcm_singles, bpp_singles, kstar1_range)
+        
         if conv_filter.empty:
             warnings.warn("After filtering for desired convegence systems there were no systems matching your request. It is possible you are suggesting incompatible bin_state choices and pop_select, e.g. bin_state=[0,1], pop_select='disruption'")
             log_file.write("After filtering for desired convegence systems there were no systems matching your request. It is possible you are suggesting incompatible bin_state choices and pop_select, e.g. bin_state=[0,1], pop_select='disruption'")
@@ -426,6 +453,12 @@ if __name__ == '__main__':
         initC_filter = initCond.loc[initCond.bin_num.isin(conv_filter.bin_num)]
         kick_info_filter = kick_info.loc[kick_info.bin_num.isin(conv_filter.bin_num)]
 
+        if (args.keep_singles==True):
+            bpp_singles_filter = bpp_singles.loc[bpp_singles.bin_num.isin(conv_singles_filter.bin_num)]
+            bcm_singles_filter = bcm_singles.loc[bcm_singles.bin_num.isin(conv_singles_filter.bin_num)]
+            initC_singles_filter = initCond_singles.loc[initCond_singles.bin_num.isin(conv_singles_filter.bin_num)]
+            kick_info_singles_filter = kick_info_singles.loc[kick_info_singles.bin_num.isin(conv_singles_filter.bin_num)]
+
         # Filter the bin_state based on user specified filters
         bcm_filter, bin_state_nums = utils.filter_bin_state(bcm_filter, bpp_filter, filters, kstar1_range, kstar2_range)
         if bcm_filter.empty:
@@ -444,19 +477,17 @@ if __name__ == '__main__':
         conv_filter = conv_filter.loc[conv_filter.bin_num.isin(conv_lims_bin_num)]
 
         # Filter the bcm and bpp arrays according to user specified filters
-        if len(bcm_filter_match) == 0:
-            bcm_filter_match = bcm_filter.copy()
-            bpp_filter_match = bpp_filter.copy()
-            initC_filter_match = initC_filter.copy()
-            conv_filter_match = conv_filter.copy()
-            kick_info_filter_match = kick_info_filter.copy()
-        else:
-            bcm_filter_match = pd.concat([bcm_filter_match,bcm_filter], ignore_index=True)
-            bpp_filter_match = pd.concat([bpp_filter_match,bpp_filter], ignore_index=True)
-            initC_filter_match = pd.concat([initC_filter_match,initC_filter], ignore_index=True)
-            kick_info_filter_match = pd.concat([kick_info_filter_match,kick_info_filter], ignore_index=True)
-            conv_filter_match = pd.concat([conv_filter_match,conv_filter.loc[conv_filter.bin_num.isin(conv_lims_bin_num)]], ignore_index=True)
-                
+        bcm_filter_match = bcm_filter.copy()
+        bpp_filter_match = bpp_filter.copy()
+        initC_filter_match = initC_filter.copy()
+        conv_filter_match = conv_filter.copy()
+        kick_info_filter_match = kick_info_filter.copy()
+        if (args.keep_singles==True):
+            conv_singles_filter_match = conv_singles_filter.copy()
+            bpp_singles_filter_match = bpp_singles_filter.copy()
+            bcm_singles_filter_match = bcm_singles_filter.copy()
+            initC_filter_singles_match = initC_singles_filter.copy()
+            kick_info_singles_filter_match = kick_info_singles_filter.copy()          
 
         if len(conv_filter_match) >= np.min([50, args.Niter]):
             conv_save = pd.concat([conv_save, pd.DataFrame(conv_filter_match)], ignore_index=True)
@@ -478,9 +509,20 @@ if __name__ == '__main__':
             # write the data and the logs!
             mass_list = [total_mass_singles, total_mass_binaries, total_mass_stars]
             n_list = [total_n_singles, total_n_binaries, total_n_stars]
-            utils.pop_write(dat_store, log_file, mass_list, n_list, bcm_filter_match,
-                            bpp_filter_match, initC_filter_match, conv_filter_match, kick_info_filter_match,
-                            bin_state_nums, match_save, idx)
+
+            # write the data to the dat_store
+            with pd.HDFStore(dat_store_fname,complib=args.complib,complevel=args.complevel) as dat_store:
+                if (args.keep_singles==True):
+                    utils.pop_write(dat_store, log_file, mass_list, n_list, bcm_filter_match,
+                                bpp_filter_match, initC_filter_match, conv_filter_match, kick_info_filter_match,
+                                bin_state_nums, match_save, idx, 
+                                conv_singles=conv_singles_filter_match, bcm_singles=bcm_singles_filter_match, 
+                                bpp_singles=bpp_singles_filter_match, initC_singles=initC_filter_singles_match,
+                                kick_info_singles=kick_info_singles_filter_match)
+                else:
+                    utils.pop_write(dat_store, log_file, mass_list, n_list, bcm_filter_match,
+                                bpp_filter_match, initC_filter_match, conv_filter_match, kick_info_filter_match,
+                                bin_state_nums, match_save, idx)
 
             # reset the bcm_filter DataFrame
             bcm_filter_match = []
@@ -488,12 +530,20 @@ if __name__ == '__main__':
             initC_filter_match = []
             conv_filter_match = []
             kick_info_filter_match = []
+            if (args.keep_singles==True):
+                conv_singles_filter_match = []
+                bpp_singles_filter_match = []
+                bcm_singles_filter_match = []
+                initC_filter_singles_match = []
+                kick_info_singles_filter_match = []
             log_file.write('\n')
         Nstep += args.Nstep
         log_file.flush()
-    # Close the data storage file
-    dat_store.close()
-
+    
+    # close the log file and print the final message
     log_file.write('All done friend!')
     log_file.close()
 
+    pool.close()
+    pool.join()
+

{cosmic_popsynth-3.5.0 → cosmic_popsynth-3.6.1}/changelog.md

@@ -49,4 +49,9 @@ See the discussed changes in our previous releases here: https://github.com/COSM
  - Bug fix: Changed `kick.f` to use the Pfahl+02 kick prescription by default instead of Kiel & Hurley 2009, this fixes ejection velocities of secondaries and also changed kick_info to have an extra column
 
 ## 3.6.0
- - Overhaul documentation and added debugging environment
+ - Overhaul documentation and added debugging environment
+ - Feature: Added Disberg+2025 kick prescription as a new choice of `kickflag` (`kickflag=5`). Applies log-normal distribution to regular CCSN, ECSN/USSN still use `sigmadiv` Maxwellian and BH fallback scaling is still applied via `bhflag` and `bhsigmafrac` as with `kickflag=1`
+
+## 3.6.1
+ - Add support for single stars in both independent and multidim sampling
+ - update documentation

{cosmic_popsynth-3.5.0 → cosmic_popsynth-3.6.1}/docs/cosmic-settings.json

@@ -845,6 +845,10 @@
                         "name": 4,
                         "description": "Natal kicks are drawn according to Eq. 1 of <a class='reference external' href='https://ui.adsabs.harvard.edu/abs/2016MNRAS.461.3747B/abstract'>Bray &amp; Eldridge 2016</a>, with their default parameters (\\(\\alpha=70 \\, {\\rm km/s}, \\beta = 120 \\, {\\rm km/s)}"
                     },
+                    {
+                        "name": 5,
+                        "description": "Follows the same prescription as 1, but uses the kick prescription described in <a class='reference external' href='https://ui.adsabs.harvard.edu/abs/2025arXiv250522102D/abstract'>Disberg & Mandel 2025</a> for CCSN."
+                    },
                     {
                         "name": "negative values",
                         "description": "Same as above settings but using the old Kiel & Hurley 2009 prescription for changing the orbital configuration of the binary, available for reproducibility purposes but not recommended for new work"

{cosmic_popsynth-3.5.0 → cosmic_popsynth-3.6.1}/docs/pages/evolve/evolve_sample.rst

@@ -27,8 +27,8 @@ about the independent sampler in the :ref:`independent` page.
        ...:       InitialBinaryTable.sampler('independent', final_kstars, final_kstars,
        ...:                                  binfrac_model=0.5, primary_model='kroupa01',
        ...:                                  ecc_model='sana12', porb_model='sana12',
-       ...:                                  qmin=-1, m2_min=0.08, SF_start=13700.0,
-       ...:                                  SF_duration=0.0, met=0.02, size=10)
+       ...:                                  qmin=-1, SF_start=13700.0,
+       ...:                                  SF_duration=0.0, met=0.02, size=10, keep_singles=True)
 
 
 And finally, we can evolve the initial binary population using the Evolve class as we've done in the previous

{cosmic_popsynth-3.5.0 → cosmic_popsynth-3.6.1}/docs/pages/fixedpop.rst

@@ -92,7 +92,15 @@ The fixed population contains several pandas DataFrames accessed by the followin
 
 * ``kick_info`` : The magnitude and direction of natal kicks, three dimensional systemic velocity changes, total tilt of orbital plane, and azimuthal angle of orbital angular momentum axis with respect to spins
 
-* ``initCond`` : The initial conditions for each binary which satisfies the user-specified final kstars and filter in the ``convergence`` subsection
+* ``initC`` : The initial conditions for each binary which satisfies the user-specified final kstars and filter in the ``convergence`` subsection
+
+* ``bpp_singles`` : The evolutionary history of single stars which satisfy the user-specified final kstars and filter in the ``convergence`` subsection
+
+* ``bcm_singles`` : The final state of single stars in the bcm array which satisfy the user-specified final kstars and filter in the ``convergence`` subsection
+
+* ``kick_info_singles`` : The magnitude and direction of natal kicks, three dimensional systemic velocity changes, total tilt of orbital plane, and azimuthal angle of orbital angular momentum axis with respect to spins
+
+* ``initC_singles`` : The initial conditions for each single star which satisfies the user-specified final kstars and filter in the ``convergence`` subsection
 
 * ``idx`` : An integer that keeps track of the total number of simulated binaries to maintain proper indexing across several runs of ``cosmic-pop``
 

{cosmic_popsynth-3.5.0 → cosmic_popsynth-3.6.1}/docs/pages/sample/independent.rst

@@ -47,9 +47,9 @@ If you don't want to filter the binaries, you can supply final kstars as
 
     In [6]: final_kstars = np.linspace(0, 14, 15)
 
-    In [7]: InitialBinaries, mass_singles, mass_binaries, n_singles, n_binaries = InitialBinaryTable.sampler('independent', final_kstars, final_kstars, binfrac_model=0.5, primary_model='kroupa01', ecc_model='sana12', porb_model='sana12', qmin=-1, m2_min=0.08, SF_start=13700.0, SF_duration=0.0, met=0.02, size=10000)
+    In [7]: InitialBinaries, mass_singles, mass_binaries, n_singles, n_binaries = InitialBinaryTable.sampler('independent', final_kstars, final_kstars, binfrac_model=0.5, primary_model='kroupa01', ecc_model='sana12', porb_model='sana12', qmin=-1, SF_start=13700.0, SF_duration=0.0, met=0.02, size=10000)
 
-Additionally if you are interested in single stars then you can specify ``keep_singles=True``.
+Additionally if you are interested in single stars then you can specify ``keep_singles=True``. In this case, the singles will be added onto the end of the InitialBinaryTable where ``kstar_1`` will host the singles, ``kstar_2`` will be filled with 15s only, and all orbital properties (e.g. ``porb`` or ``ecc``) will be indicated with -1.
 
 Understanding parameter sampling models
 =======================================
@@ -76,7 +76,7 @@ Using the final kstar inputs we mentioned above, the initial binary population c
 
 .. ipython::
 
-    In [9]: InitialBinaries, mass_singles, mass_binaries, n_singles, n_binaries = InitialBinaryTable.sampler('independent', final_kstar1, final_kstar2, binfrac_model=0.5, primary_model='kroupa01', ecc_model='sana12', porb_model='sana12', qmin=-1, m2_min=0.08, SF_start=13700.0, SF_duration=0.0, met=0.02, size=10000)
+    In [9]: InitialBinaries, mass_singles, mass_binaries, n_singles, n_binaries = InitialBinaryTable.sampler('independent', final_kstar1, final_kstar2, binfrac_model=0.5, primary_model='kroupa01', ecc_model='sana12', porb_model='sana12', qmin=-1, SF_start=13700.0, SF_duration=0.0, met=0.02, size=10000)
 
     In [10]: print(InitialBinaries)
 
@@ -95,7 +95,7 @@ Alternatively, we could do the same thing but now instead set our ``sampling_tar
 
 .. ipython::
 
-    In [10]: InitialBinaries, mass_singles, mass_binaries, n_singles, n_binaries = InitialBinaryTable.sampler('independent', final_kstar1, final_kstar2, binfrac_model=0.5, primary_model='kroupa01', ecc_model='sana12', porb_model='sana12', qmin=-1, m2_min=0.08, SF_start=13700.0, SF_duration=0.0, met=0.02, sampling_target="total_mass", total_mass=15000)
+    In [10]: InitialBinaries, mass_singles, mass_binaries, n_singles, n_binaries = InitialBinaryTable.sampler('independent', final_kstar1, final_kstar2, binfrac_model=0.5, primary_model='kroupa01', ecc_model='sana12', porb_model='sana12', qmin=-1, SF_start=13700.0, SF_duration=0.0, met=0.02, sampling_target="total_mass", total_mass=15000)
 
     In [11]: print(InitialBinaries)
 

{cosmic_popsynth-3.5.0 → cosmic_popsynth-3.6.1}/docs/pages/sample/multidim.rst

@@ -33,3 +33,7 @@ The multidimensional sample is generated as follows:
 
     NOTE that in the multidimensional case, the binary fraction is a parameter in the sample. This results in the size of the initial binary data matching the size provided to the sampler. As in the independent sampling case, we keep track of the total sampled mass of singles and binaries as well as the total number of single and binary stars to scale the simulated population to astrophysical populations.
 
+.. note::
+
+    NOTE that you can also keep singles for the multidim sampelr as well. As with the independent sampler, the singles will be added onto the end of the InitialBinaryTable where ``kstar_1`` will host the singles, ``kstar_2`` will be filled with 15s only, and all orbital properties (e.g. ``porb`` or ``ecc``) will be indicated with -1.
+

{cosmic_popsynth-3.5.0 → cosmic_popsynth-3.6.1}/meson.build

@@ -1,7 +1,7 @@
 project('cosmic', 
     'c',
     'fortran',
-    version : '3.5.0',
+    version : '3.6.1',
     default_options: ['warning_level=0', 'optimization=3'],
 )
 

{cosmic_popsynth-3.5.0 → cosmic_popsynth-3.6.1}/pyproject.toml

@@ -10,7 +10,7 @@ authors = [
     { name="Tom Wagg" },
 ]
 readme = "README.md"
-version = "3.5.0"
+version = "3.6.1"
 requires-python = ">=3.9"
 license = { text = "MIT License" }
 classifiers = [

cosmic_popsynth-3.6.1/src/cosmic/_version.py

@@ -0,0 +1 @@
+__version__ = "3.6.1"

{cosmic_popsynth-3.5.0 → cosmic_popsynth-3.6.1}/src/cosmic/evolve.py

@@ -46,7 +46,7 @@ __credits__ = ['Katelyn Breivik <katie.breivik@gmail.com>',
 __all__ = ['Evolve']
 
 
-
+# Make this match the ordering of all_cols in bpp_array.f
 ALL_COLUMNS = ['tphys', 'mass_1', 'mass_2', 'kstar_1', 'kstar_2', 'sep', 'porb',
                'ecc', 'RRLO_1', 'RRLO_2', 'evol_type', 'aj_1', 'aj_2', 'tms_1',
                'tms_2', 'massc_1', 'massc_2', 'rad_1', 'rad_2', 'mass0_1',

{cosmic_popsynth-3.5.0 → cosmic_popsynth-3.6.1}/src/cosmic/sample/initialcmctable.py

@@ -332,9 +332,10 @@ class InitialCMCTable(pd.DataFrame):
         )
         singles = pd.concat([singles, Singles])
         singles = pd.concat([singles, singles_bottom])
-        singles["r"].iloc[-1] = 1e40
-        singles["r"].iloc[0] = 2.2250738585072014e-308
-        singles["m"].iloc[0] = Singles.central_bh
+        
+        singles.iloc[-1, singles.columns.get_loc("r")] = 1e40
+        singles.iloc[0, singles.columns.get_loc("r")] = 2.2250738585072014e-308
+        singles.iloc[0, singles.columns.get_loc("m")] = Singles.central_bh
 
         # Add a special row to the end of Bianries table
         binaries = pd.DataFrame(

{cosmic_popsynth-3.5.0 → cosmic_popsynth-3.6.1}/src/cosmic/sample/sampler/cmc.py

@@ -231,7 +231,7 @@ def get_cmc_sampler(
     singles_table.metallicity = met
     binaries_table.metallicity = met
     singles_table.virial_radius = kwargs.get("virial_radius",1) 
-    singles_table.tidal_radius = kwargs.get("tidal_radius",1e13) 
+    singles_table.tidal_radius = kwargs.get("tidal_radius",1e6) 
     singles_table.central_bh = kwargs.get("central_bh",0)
     singles_table.scale_with_central_bh = kwargs.get("scale_with_central_bh",False)
     singles_table.mass_of_cluster = np.sum(singles_table["m"]) + singles_table.central_bh

{cosmic_popsynth-3.5.0 → cosmic_popsynth-3.6.1}/src/cosmic/sample/sampler/independent.py

@@ -343,7 +343,7 @@ def get_independent_sampler(
             np.ones_like(mass1_singles) * 15,       # kstar2 (all massless remnants)
             metallicity_singles,                    # metallicity
         )
-        binary_table = pd.concat([binary_table, singles_table])
+        binary_table = pd.concat([binary_table, singles_table], ignore_index=True)
     else:
         binary_table = InitialBinaryTable.InitialBinaries(
             mass1_binary,
@@ -362,7 +362,7 @@ def get_independent_sampler(
         m_sampled_singles,
         m_sampled_binaries,
         n_singles,
-        n_binaries,
+        n_binaries
     )
 
 
@@ -505,7 +505,6 @@ class Sample(object):
             sampled secondary masses with array size matching size of
             primary_mass
         """
-
         qmin = kwargs["qmin"] if "qmin" in kwargs.keys() else 0.0
         m1_min = kwargs["m1_min"] if "m1_min" in kwargs.keys() else 0.08
         m2_min = kwargs["m2_min"] if "m2_min" in kwargs.keys() else None
@@ -515,6 +514,9 @@ class Sample(object):
             raise ValueError("The m2_min you specified is above the minimum"
                              " primary mass of the IMF, either lower m2_min or"
                              " raise the lower value of your sampled primaries")
+        
+        if (m2_min is not None) & (qmin != 0):
+            raise ValueError("You cannot specify both m2_min and qmin, please choose one or the other")  
 
         # --- `msort` kwarg can be set to have different qmin above `msort`
         msort = kwargs["msort"] if "msort" in kwargs.keys() else None

{cosmic_popsynth-3.5.0 → cosmic_popsynth-3.6.1}/src/cosmic/sample/sampler/multidim.py

@@ -25,6 +25,7 @@ from .. import InitialBinaryTable
 from ... import utils
 
 import numpy as np
+import pandas as pd
 
 __author__ = "Katelyn Breivik <katie.breivik@gmail.com>"
 __credits__ = "Scott Coughlin <scott.coughlin@ligo.org>"
@@ -146,6 +147,7 @@ def get_multidim_sampler(
         mass2_binary,
         porb,
         ecc,
+        single_mass_list,
         mass_singles,
         mass_binaries,
         n_singles,
@@ -174,7 +176,7 @@ def get_multidim_sampler(
     metallicity[metallicity < 1e-4] = 1e-4
     metallicity[metallicity > 0.03] = 0.03
 
-    if kwargs.pop("keep_singles", False):
+    if kwargs.pop("keep_singles", True):
         binary_table = InitialBinaryTable.InitialBinaries(
             mass1_binary,
             mass2_binary,
@@ -187,22 +189,22 @@ def get_multidim_sampler(
             binfrac=binfrac,
         )
         tphysf, metallicity = initconditions.sample_SFH(
-            SF_start=SF_start, SF_duration=SF_duration, met=met, size=mass_singles.size
+            SF_start=SF_start, SF_duration=SF_duration, met=met, size=single_mass_list.size
         )
         metallicity[metallicity < 1e-4] = 1e-4
         metallicity[metallicity > 0.03] = 0.03
-        kstar1 = initconditions.set_kstar(mass_singles)
+        kstar1 = initconditions.set_kstar(single_mass_list)
         singles_table = InitialBinaryTable.InitialBinaries(
-            mass_singles,
-            np.ones_like(mass_singles)*0,
-            np.ones_like(mass_singles)*-1,
-            np.ones_like(mass_singles)*-1,
+            single_mass_list,
+            np.ones_like(single_mass_list)*0,
+            np.ones_like(single_mass_list)*-1,
+            np.ones_like(single_mass_list)*-1,
             tphysf,
             kstar1,
-            np.ones_like(mass_singles)*0,
+            np.ones_like(single_mass_list)*15, # # kstar2 is not used for singles
             metallicity,
         )
-        binary_table = binary_table.append(singles_table)
+        binary_table = pd.concat([binary_table, singles_table], ignore_index=True)
     else:
         binary_table = InitialBinaryTable.InitialBinaries(
             mass1_binary,
@@ -321,6 +323,8 @@ class MultiDim:
             array of orbital periods in days with size=size
         ecc_list : array
             array of eccentricities with size=size
+        single_mass_list : array
+            array of mass of single stars
         mass_singles : `float`
             Total mass in single stars needed to generate population
         mass_binaries : `float`
@@ -360,7 +364,7 @@ class MultiDim:
             worker = Worker()
             results = list(pool.map(worker, inputs))
 
-        dat_lists = [[], [], [], [], [], [], [], [], []]
+        dat_lists = [[], [], [], [], [], [], [], [], [], []]
 
         for output_list in results:
             ii = 0
@@ -372,17 +376,19 @@ class MultiDim:
         secondary_mass_list = np.hstack(dat_lists[1])
         porb_list = np.hstack(dat_lists[2])
         ecc_list = np.hstack(dat_lists[3])
-        mass_singles = np.sum(dat_lists[4])
-        mass_binaries = np.sum(dat_lists[5])
-        n_singles = np.sum(dat_lists[6])
-        n_binaries = np.sum(dat_lists[7])
-        binfrac_list = np.hstack(dat_lists[8])
+        single_mass_list = np.hstack(dat_lists[4])
+        mass_singles = np.sum(dat_lists[5])
+        mass_binaries = np.sum(dat_lists[6])
+        n_singles = np.sum(dat_lists[7])
+        n_binaries = np.sum(dat_lists[8])
+        binfrac_list = np.hstack(dat_lists[9])
 
         return (
                 primary_mass_list,
                 secondary_mass_list,
                 porb_list,
                 ecc_list,
+                single_mass_list,
                 mass_singles,
                 mass_binaries,
                 n_singles,
@@ -773,6 +779,7 @@ class Worker(object):
         n_binaries = 0
         primary_mass_list = []
         secondary_mass_list = []
+        single_mass_list = []
         porb_list = []
         ecc_list = []
         binfrac_list = []
@@ -857,6 +864,7 @@ class Worker(object):
                 mass_binaries += myq * myM1
                 n_binaries += 1
             else:
+                single_mass_list.append(myM1)
                 mass_singles += myM1
                 n_singles += 1
 
@@ -865,6 +873,7 @@ class Worker(object):
                 secondary_mass_list,
                 porb_list,
                 ecc_list,
+                single_mass_list,
                 mass_singles,
                 mass_binaries,
                 n_singles,