def test_scott_bin_width(N=10000, rseed=0): rng = np.random.RandomState(rseed) X = rng.randn(N) delta = scott_bin_width(X) assert_allclose(delta, 3.5 * np.std(X) / N ** (1 / 3)) delta, bins = scott_bin_width(X, return_bins=True) assert_allclose(delta, 3.5 * np.std(X) / N ** (1 / 3)) with pytest.raises(ValueError): scott_bin_width(rng.rand(2, 10))
def test_scott_bin_width(N=10000, rseed=0): rng = np.random.default_rng(rseed) X = rng.standard_normal(N) delta = scott_bin_width(X) assert_allclose(delta, 3.5 * np.std(X) / N**(1 / 3)) delta, bins = scott_bin_width(X, return_bins=True) assert_allclose(delta, 3.5 * np.std(X) / N**(1 / 3)) with pytest.raises(ValueError): scott_bin_width(rng.random((2, 10)))
def scotts_bin_width(data, return_bins=False): r"""Return the optimal histogram bin width using Scott's rule: Parameters ---------- data : array-like, ndim=1 observed (one-dimensional) data return_bins : bool (optional) if True, then return the bin edges Returns ------- width : float optimal bin width using Scott's rule bins : ndarray bin edges: returned if `return_bins` is True Notes ----- The optimal bin width is .. math:: \Delta_b = \frac{3.5\sigma}{n^{1/3}} where :math:`\sigma` is the standard deviation of the data, and :math:`n` is the number of data points. See Also -------- knuth_bin_width freedman_bin_width astroML.plotting.hist """ return astropy_stats.scott_bin_width(data, return_bins)
def knuth_bw_selector(dat_list): """Selects the kde bandwidth using Knuth's rule implemented in Astropy If Knuth's rule raises error, Scott's rule is used Parameters ---------- dat_list : list List of data arrays that will be used to generate a kde Returns ------- bw_min : float Minimum of bandwidths for all of the data arrays in dat_list """ bw_list = [] for dat in dat_list: try: bw = astrostats.knuth_bin_width(dat) except: print('Using Scott Rule!!') bw = astrostats.scott_bin_width(dat) bw_list.append(bw) return np.mean(bw_list)
def histogram(a, bins=10, range=None, **kwargs): """Enhanced histogram This is a histogram function that enables the use of more sophisticated algorithms for determining bins. Aside from the `bins` argument allowing a string specified how bins are computed, the parameters are the same as numpy.histogram(). Parameters ---------- a : array_like array of data to be histogrammed bins : int or list or str (optional) If bins is a string, then it must be one of: 'blocks' : use bayesian blocks for dynamic bin widths 'knuth' : use Knuth's rule to determine bins 'scotts' : use Scott's rule to determine bins 'freedman' : use the Freedman-diaconis rule to determine bins range : tuple or None (optional) the minimum and maximum range for the histogram. If not specified, it will be (x.min(), x.max()) other keyword arguments are described in numpy.hist(). Returns ------- hist : array The values of the histogram. See `normed` and `weights` for a description of the possible semantics. bin_edges : array of dtype float Return the bin edges ``(length(hist)+1)``. See Also -------- numpy.histogram astroML.plotting.hist """ a = np.asarray(a) # if range is specified, we need to truncate the data for # the bin-finding routines if (range is not None and (bins in ['blocks', 'knuth', 'scotts', 'freedman'])): a = a[(a >= range[0]) & (a <= range[1])] if isinstance(bins, str): if bins == 'blocks': bins = astropy_stats.bayesian_blocks(a) elif bins == 'knuth': da, bins = astropy_stats.knuth_bin_width(a, True) elif bins == 'scotts': da, bins = astropy_stats.scott_bin_width(a, True) elif bins == 'freedman': da, bins = astropy_stats.freedman_bin_width(a, True) else: raise ValueError("unrecognized bin code: '{}'".format(bins)) return np.histogram(a, bins, range, **kwargs)
def get_bin_sizes_xy(x, y, algo='scott'): """ Smartly get bin size to have a loer bias due to binning""" from astropy.stats import freedman_bin_width, scott_bin_width, knuth_bin_width, bayesian_blocks logger.info(" > Get smart bin sizes in 2D") if algo == 'scott': logger.info("use scott rule of thumb") width_x, bins_x = scott_bin_width(x, return_bins=True) width_y, bins_y = scott_bin_width(y, return_bins=True) elif algo == 'knuth': logger.info("use knuth rule of thumb") width_x, bins_x = knuth_bin_width(x, return_bins=True) width_y, bins_y = knuth_bin_width(y, return_bins=True) elif algo == 'freedman': logger.info("use freedman rule of thumb") width_x, bins_x = freedman_bin_width(x, return_bins=True) width_y, bins_y = freedman_bin_width(y, return_bins=True) else: raise NotImplementedError("use scott or knuth") n_bins_x, n_bins_y = len(bins_x), len(bins_y) return bins_x, bins_y, width_x, width_y
def calc_bin(data, mode): n = len(data) if mode == "sqrt": bins = np.sqrt(n) elif mode == "sturges": bins = np.log2(n) + 1 elif mode == "scott": width, bins = scott_bin_width(data, return_bins=True) bins = len(bins) elif mode == "freedman": width, bins = freedman_bin_width(data, return_bins=True) bins = len(bins) elif mode == "knuth": width, bins = knuth_bin_width(data, return_bins=True) bins = len(bins) return bins
def plot_all_col_plotly(df, hue=None, numeric_only=False, string_only=False, bin_width=None): '''plot all columns conditioned on one, using plotly.express `bin_width`: for numeric data only. If None, pass nbins=None to plotly, if 'freedman', use Freedman–Diaconis rule, else use Scott's normal reference rule. ''' for name, col in df.items(): if name == hue: pass elif is_numeric_dtype(col): if not string_only: if bin_width is None: nbins = None else: from astropy.stats import freedman_bin_width, scott_bin_width values = col.values width = freedman_bin_width( values ) if bin_width == 'freedman' else scott_bin_width(values) nbins = int(np.round((values.max() - values.min()) / width)) if width else None fig = px.histogram(df, y=name, color=hue, orientation='h', barmode='overlay', histnorm='probability density', nbins=nbins) fig.show() elif is_string_dtype(col): if not numeric_only: fig = px.histogram(df, y=name, color=hue, orientation='h', barmode='group', histnorm='probability density') fig.show() else: raise ValueError
def get_nofz(z, fsky, cosmo=None): ''' calculate nbar(z) given redshift values and f_sky (sky coverage fraction) ''' # calculate nbar(z) for each galaxy _, edges = scott_bin_width(z, return_bins=True) dig = np.searchsorted(edges, z, "right") N = np.bincount(dig, minlength=len(edges) + 1)[1:-1] R_hi = cosmo.comoving_distance(edges[1:]) # Mpc/h R_lo = cosmo.comoving_distance(edges[:-1]) # Mpc/h dV = (4. / 3.) * np.pi * (R_hi**3 - R_lo**3) * fsky nofz = InterpolatedUnivariateSpline(0.5 * (edges[1:] + edges[:-1]), N / dV, ext='const') return nofz(z)
def get_bin_sizes_x(x, algo='scott'): """ Smartly get bin size to have a loer bias due to binning""" from astropy.stats import freedman_bin_width, scott_bin_width, knuth_bin_width, bayesian_blocks logger.info(" > Get smart bin sizes in 1D") if algo == 'scott': logger.info("use scott rule of thumb") width_x, bins_x = scott_bin_width(x, return_bins=True) elif algo == 'knuth': logger.info("use knuth rule of thumb") width_x, bins_x = knuth_bin_width(x, return_bins=True) elif algo == 'freedman': logger.info("use freedman rule of thumb") width_x, bins_x = freedman_bin_width(x, return_bins=True) elif algo == 'blocks': logger.info("use bayesian blocks rule of thumb") width_x, bins_x = bayesian_blocks(x, return_bins=True) else: raise NotImplementedError("use scott, knuth, freedman or blocks") return bins_x, width_x
def hist(x, bins=10, range=None, *args, **kwargs): """Enhanced histogram This is a histogram function that enables the use of more sophisticated algorithms for determining bins. Aside from the `bins` argument allowing a string specified how bins are computed, the parameters are the same as pylab.hist(). Parameters ---------- x : array_like array of data to be histogrammed bins : int or list or str (optional) If bins is a string, then it must be one of: 'blocks' : use bayesian blocks for dynamic bin widths 'knuth' : use Knuth's rule to determine bins 'scott' : use Scott's rule to determine bins 'freedman' : use the Freedman-diaconis rule to determine bins range : tuple or None (optional) the minimum and maximum range for the histogram. If not specified, it will be (x.min(), x.max()) ax : Axes instance (optional) specify the Axes on which to draw the histogram. If not specified, then the current active axes will be used. **kwargs : other keyword arguments are described in pylab.hist(). """ if isinstance(bins, str) and "weights" in kwargs: warnings.warn("weights argument is not supported: it will be ignored.") kwargs.pop('weights') x = np.asarray(x) if 'ax' in kwargs: ax = kwargs['ax'] del kwargs['ax'] else: # import here so that testing with Agg will work from matplotlib import pyplot as plt ax = plt.gca() # if range is specified, we need to truncate the data for # the bin-finding routines if (range is not None and (bins in ['blocks', 'knuth', 'knuths', 'scott', 'scotts', 'freedman', 'freedmans'])): x = x[(x >= range[0]) & (x <= range[1])] if bins in ['blocks']: bins = bayesian_blocks(x) elif bins in ['knuth', 'knuths']: dx, bins = knuth_bin_width(x, True) elif bins in ['scott', 'scotts']: dx, bins = scott_bin_width(x, True) elif bins in ['freedman', 'freedmans']: dx, bins = freedman_bin_width(x, True) elif isinstance(bins, str): raise ValueError("unrecognized bin code: '{}'".format(bins)) return ax.hist(x, bins, range, **kwargs)
def match(dataCm): """Performs the Match calculation in Eq. 1 of Breivik & Larson (2018) Parameters ---------- dataCm : list List of two cumulative data sets for a single paramter Returns ------- match : list List of matches for each cumulative data set binwidth : float Binwidth of histograms used for match computation """ # DEFINE A LIST TO HOLD THE BINNED DATA: histo = [[], []] histoBinEdges = [[], []] # COMPUTE THE BINWIDTH FOR THE MOST COMPLETE DATA SET: # NOTE: THIS WILL BE THE BINWIDTH FOR ALL THE HISTOGRAMS IN THE HISTO LIST with warnings.catch_warnings(): warnings.filterwarnings( "ignore", message="divide by zero encountered in double_scalars") try: bw, binEdges = astroStats.knuth_bin_width(np.array(dataCm[0]), return_bins=True) except Exception: bw, binEdges = astroStats.scott_bin_width(np.array(dataCm[0]), return_bins=True) if bw < 1e-4: bw = 1e-4 binEdges = np.arange(binEdges[0], binEdges[-1], bw) # BIN THE DATA: for i in range(2): histo[i], histoBinEdges[i] = astroStats.histogram(dataCm[i], bins=binEdges, density=True) # COMPUTE THE MATCH: nominator = [] denominator1 = [] denominator2 = [] nominatorSum = [] denominator1Sum = [] denominator2Sum = [] histo2 = histo[1] histo1 = histo[0] for j in range(len(histo1)): nominator.append(histo1[j] * histo2[j]) denominator1.append((histo1[j] * histo1[j])) denominator2.append((histo2[j] * histo2[j])) nominatorSum.append(np.sum(nominator)) denominator1Sum.append(np.sum(denominator1)) denominator2Sum.append(np.sum(denominator2)) nominatorSum = np.array(nominatorSum) denominator1Sum = np.array(denominator1Sum) denominator2Sum = np.array(denominator2Sum) binwidth = binEdges[1] - binEdges[0] if binwidth < 1e-7: match = 1e-9 else: match = np.log10(1 - nominatorSum / np.sqrt(denominator1Sum * denominator2Sum)) return match[0], binwidth
def hist(x, bins=10, range=None, *args, **kwargs): """Enhanced histogram This is a histogram function that enables the use of more sophisticated algorithms for determining bins. Aside from the `bins` argument allowing a string specified how bins are computed, the parameters are the same as pylab.hist(). Parameters ---------- x : array_like array of data to be histogrammed bins : int or list or str (optional) If bins is a string, then it must be one of: 'blocks' : use bayesian blocks for dynamic bin widths 'knuth' : use Knuth's rule to determine bins 'scott' : use Scott's rule to determine bins 'freedman' : use the Freedman-diaconis rule to determine bins range : tuple or None (optional) the minimum and maximum range for the histogram. If not specified, it will be (x.min(), x.max()) ax : Axes instance (optional) specify the Axes on which to draw the histogram. If not specified, then the current active axes will be used. **kwargs : other keyword arguments are described in pylab.hist(). """ if isinstance(bins, str) and "weights" in kwargs: warnings.warn("weights argument is not supported: it will be ignored.") kwargs.pop('weights') x = np.asarray(x) if 'ax' in kwargs: ax = kwargs['ax'] del kwargs['ax'] else: # import here so that testing with Agg will work from matplotlib import pyplot as plt ax = plt.gca() # if range is specified, we need to truncate the data for # the bin-finding routines if (range is not None and (bins in [ 'blocks', 'knuth', 'knuths', 'scott', 'scotts', 'freedman', 'freedmans' ])): x = x[(x >= range[0]) & (x <= range[1])] if bins in ['blocks']: bins = bayesian_blocks(x) elif bins in ['knuth', 'knuths']: dx, bins = knuth_bin_width(x, True, disp=False) elif bins in ['scott', 'scotts']: dx, bins = scott_bin_width(x, True) elif bins in ['freedman', 'freedmans']: dx, bins = freedman_bin_width(x, True) elif isinstance(bins, str): raise ValueError("unrecognized bin code: '%s'" % bins) return ax.hist(x, bins, range, **kwargs)
def LSSTsim(Ncores, Nbin): def paramTransform(dat): datMin = min(dat) - 0.0001 datMax = max(dat) + 0.0001 datZeroed = dat - datMin datTransformed = datZeroed / (datMax - datMin) return datTransformed # SET TIME TO TRACK COMPUTATION TIME ############################################################################## start_time = time.time() #np.random.seed() # CONSTANTS ############################################################################## G = 6.67384 * 10.**-11.0 c = 2.99792458 * 10.**8.0 parsec = 3.08567758 * 10.**16. Rsun = 6.955 * 10.**8. Msun = 1.9891 * 10.**30. day = 86400.0 rsun_in_au = 215.0954 day_in_year = 365.242 sec_in_day = 86400.0 sec_in_hour = 3600.0 hrs_in_day = 24.0 sec_in_year = 3.15569 * 10**7.0 Tobs = 3.15569 * 10**7.0 geo_mass = G / c**2 m_in_AU = 1.496 * 10**11.0 mTotDisk = 2.15 * 10**10 binID = '0012' ############################################################################## # STELLAR TYPES - KW # # 0 - deeply or fully convective low mass MS star # 1 - Main Sequence star # 2 - Hertzsprung Gap # 3 - First Giant Branch # 4 - Core Helium Burning # 5 - First Asymptotic Giant Branch # 6 - Second Asymptotic Giant Branch # 7 - Main Sequence Naked Helium star # 8 - Hertzsprung Gap Naked Helium star # 9 - Giant Branch Naked Helium star # 10 - Helium White Dwarf # 11 - Carbon/Oxygen White Dwarf # 12 - Oxygen/Neon White Dwarf # 13 - Neutron Star # 14 - Black Hole # 15 - Massless Supernova ############################################################################## # LOAD THE FIXED POPULATION DATA ############################################################################## ############## UNITS ################ # # # mass: Msun, porb: year, sep: rsun # # # ##################################### dts = { 'names': ('binNum', 'tBornBin', 'Time', 'tBorn1', 'tBorn2', 'commonEnv', 'id1', 'id2', 'm1', 'm2', 'm1Init', 'm2Init', 'Lum1', 'Lum2', 'rad1', 'rad2', 'T1', 'T2', 'massc1', 'massc2', 'radc1', 'radc2', 'menv1', 'menv2', 'renv1', 'renv2', 'spin1', 'spin2', 'rrol1', 'rrol2', 'porb', 'sep', 'ecc'), 'formats': ('i', 'f', 'f', 'f', 'f', 'i', 'i', 'i', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f') } #FixedPop = np.loadtxt('fixedData_'+binID+'.dat', delimiter = ',', dtype=dts) FixedPop = pd.read_hdf('../input/dat_ThinDisk_12_0_12_0.h5', key='bcm') FixedPopLog = np.loadtxt('../input/fixedPopLogCm_' + binID + '.dat', delimiter=',') # COMPUTE THE NUMBER AT PRESENT DAY NORMALIZED BY TOTAL MASS OF THE GX COMPONENT ############################################################################## mTotFixed = sum(FixedPopLog[:, 2]) nPop = int(len(FixedPop) * mTotDisk / mTotFixed) print('The number of binaries in the Gx for: ' + str(binID) + ' is: ' + str(nPop)) # TRANSFORM THE FIXED POP DATA TO HAVE LIMITS [0,1] & # COMPUTE THE BINWIDTH TO USE FOR THE KDE SAMPLE; SEE KNUTH_BIN_WIDTH IN ASTROPY ############################################################################## # UNITS: # MASS [MSUN], ORBITAL PERIOD [LOG10(YEARS)], LUMINOSITIES [LSUN], RADII [RSUN] #FixedPop['m1'] = FixedPop['mass_1'] #or maybe some more efficient way ### #print (FixedPop['m1']) FixedPop['m1'] = FixedPop['mass_1'] #print (FixedPop['m1']) FixedPop['m2'] = FixedPop['mass_2'] FixedPop['Lum1'] = FixedPop['lumin_1'] FixedPop['Lum2'] = FixedPop['lumin_2'] FixedPop['rad1'] = FixedPop['rad_1'] FixedPop['rad2'] = FixedPop['rad_2'] m1Trans = ss.logit(paramTransform(FixedPop['m1'])) bwM1 = astroStats.scott_bin_width(m1Trans) m2Trans = ss.logit(paramTransform(FixedPop['m2'])) bwM2 = astroStats.scott_bin_width(m2Trans) porbTrans = ss.logit(paramTransform(np.log10(FixedPop['porb']))) bwPorb = astroStats.scott_bin_width(porbTrans) Lum1Trans = ss.logit(paramTransform(FixedPop['Lum1'])) bwLum1 = astroStats.scott_bin_width(FixedPop['Lum1']) Lum2Trans = ss.logit(paramTransform(FixedPop['Lum2'])) bwLum2 = astroStats.scott_bin_width(FixedPop['Lum2']) # The eccentricity is already transformed, but only fit KDE to ecc if ecc!=0.0 eIndex, = np.where(FixedPop['ecc'] > 1e-2) if len(eIndex) > 50: eccTrans = FixedPop['ecc'] for jj in eccTrans.keys(): if eccTrans[jj] > 0.999: eccTrans[jj] = 0.999 elif eccTrans[jj] < 1e-4: eccTrans[jj] = 1e-4 eccTrans = ss.logit(eccTrans) bwEcc = astroStats.scott_bin_width(eccTrans) else: bwEcc = 100.0 rad1Trans = ss.logit(paramTransform(FixedPop['rad1'])) bwRad1 = astroStats.scott_bin_width(rad1Trans) rad2Trans = ss.logit(paramTransform(FixedPop['rad2'])) bwRad2 = astroStats.scott_bin_width(rad2Trans) #print(bwEcc,bwPorb,bwM1,bwM2,bwLum1,bwLum2,bwRad1,bwRad2) popBw = min(bwEcc, bwPorb, bwM1, bwM2, bwLum1, bwLum2, bwRad1, bwRad2) # GENERATE THE DATA LIST DEPENDING ON THE TYPE OF COMPACT BINARY TYPE ############################################################################## type1Save = 1 if type1Save < 14 and len(eIndex) > 50: print('both bright stars and eccentric') datList = np.array((m1Trans, m2Trans, porbTrans, eccTrans, rad1Trans, rad2Trans, Lum1Trans, Lum2Trans)) elif type1Save < 14 and len(eIndex) < 50: print('both bright stars and circular') datList = np.array((m1Trans, m2Trans, porbTrans, rad1Trans, rad2Trans, Lum1Trans, Lum2Trans)) # GENERATE THE KDE FOR THE DATA LIST ##############################################################################\ print(popBw) print(datList) # for i,x in enumerate(datList): # print(len(x)) # f = plt.figure() # plt.plot(x) # f.savefig(str(i)+".png") sampleKernel = scipy.stats.gaussian_kde(datList) #, bw_method=popBw) # CALL THE MONTE CARLO GALAXY SAMPLE CODE ############################################################################## print('nSample: ' + str(Nbin)) output = multiprocessing.Queue() processes = [multiprocessing.Process(target = GxSample.GxSample, \ args = (x, Ncores, FixedPop, sampleKernel,\ binID, Nbin, popBw, len(eIndex), Tobs, output)) \ for x in range(Ncores)] for p in processes: p.start() for p in processes: p.join() nSRC = [output.get() for p in processes] print('The number of sources in pop ' + binID + ' is ', nSRC) gxDatTot = [] for kk in range(Ncores): print(kk) if os.path.getsize('gxRealization_' + str(kk) + '_' + str(binID) + '.dat') > 0: gxReal = np.loadtxt('gxRealization_' + str(kk) + '_' + str(binID) + '.dat', delimiter=',') else: gxReal = [] if len(gxReal) > 0: gxDatTot.append(gxReal) os.remove('gxRealization_' + str(kk) + '_' + str(binID) + '.dat') gxDatSave = np.vstack(gxDatTot) print(np.shape(gxDatSave)) return gxDatSave
def setKernel(self): print("getting Breivik kernel") def paramTransform(dat): datMin = min(dat) - 0.0001 datMax = max(dat) + 0.0001 datZeroed = dat - datMin datTransformed = datZeroed / (datMax - datMin) return datTransformed # SET TIME TO TRACK COMPUTATION TIME ############################################################################## start_time = time.time() #np.random.seed() # CONSTANTS ############################################################################## G = 6.67384 * 10.**-11.0 c = 2.99792458 * 10.**8.0 parsec = 3.08567758 * 10.**16. Rsun = 6.955 * 10.**8. Msun = 1.9891 * 10.**30. day = 86400.0 rsun_in_au = 215.0954 day_in_year = 365.242 sec_in_day = 86400.0 sec_in_hour = 3600.0 hrs_in_day = 24.0 sec_in_year = 3.15569 * 10**7.0 Tobs = 3.15569 * 10**7.0 geo_mass = G / c**2 m_in_AU = 1.496 * 10**11.0 mTotDisk = 2.15 * 10**10 ############################################################################## # STELLAR TYPES - KW # # 0 - deeply or fully convective low mass MS star # 1 - Main Sequence star # 2 - Hertzsprung Gap # 3 - First Giant Branch # 4 - Core Helium Burning # 5 - First Asymptotic Giant Branch # 6 - Second Asymptotic Giant Branch # 7 - Main Sequence Naked Helium star # 8 - Hertzsprung Gap Naked Helium star # 9 - Giant Branch Naked Helium star # 10 - Helium White Dwarf # 11 - Carbon/Oxygen White Dwarf # 12 - Oxygen/Neon White Dwarf # 13 - Neutron Star # 14 - Black Hole # 15 - Massless Supernova ############################################################################## # LOAD THE FIXED POPULATION DATA ############################################################################## ############## UNITS ################ # # # mass: Msun, porb: year, sep: rsun # # # ##################################### dts = { 'names': ('binNum', 'tBornBin', 'Time', 'tBorn1', 'tBorn2', 'commonEnv', 'id1', 'id2', 'm1', 'm2', 'm1Init', 'm2Init', 'Lum1', 'Lum2', 'rad1', 'rad2', 'T1', 'T2', 'massc1', 'massc2', 'radc1', 'radc2', 'menv1', 'menv2', 'renv1', 'renv2', 'spin1', 'spin2', 'rrol1', 'rrol2', 'porb', 'sep', 'ecc'), 'formats': ('i', 'f', 'f', 'f', 'f', 'i', 'i', 'i', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f') } self.fixedPop = pd.read_hdf(self.GalaxyFile, key='bcm') FixedPopLog = np.loadtxt(self.GalaxyFileLogPrefix + self.popID + '.dat', delimiter=',') # COMPUTE THE NUMBER AT PRESENT DAY NORMALIZED BY TOTAL MASS OF THE GX COMPONENT ############################################################################## mTotFixed = sum(FixedPopLog[:, 2]) nPop = int(len(self.fixedPop) * mTotDisk / mTotFixed) print('The number of binaries in the Gx for: ' + str(self.popID) + ' is: ' + str(nPop)) # TRANSFORM THE FIXED POP DATA TO HAVE LIMITS [0,1] & # COMPUTE THE BINWIDTH TO USE FOR THE KDE SAMPLE; SEE KNUTH_BIN_WIDTH IN ASTROPY ############################################################################## # UNITS: # MASS [MSUN], ORBITAL PERIOD [LOG10(YEARS)], LUMINOSITIES [LSUN], RADII [RSUN] #self.fixedPop['m1'] = self.fixedPop['mass_1'] #or maybe some more efficient way ### #print (self.fixedPop['m1']) #some changes to the names here because some were in the log but not names as such by Katie! self.fixedPop['m1'] = self.fixedPop['mass_1'] #print (self.fixedPop['m1']) self.fixedPop['m2'] = self.fixedPop['mass_2'] self.fixedPop['logL1'] = self.fixedPop['lumin_1'] self.fixedPop['logL2'] = self.fixedPop['lumin_2'] self.fixedPop['logr1'] = self.fixedPop['rad_1'] self.fixedPop['logr2'] = self.fixedPop['rad_2'] self.fixedPop['logp'] = np.log10(self.fixedPop['porb']) self.setMinMax() m1Trans = ss.logit(paramTransform(self.fixedPop['m1'])) bwM1 = astroStats.scott_bin_width(m1Trans) m2Trans = ss.logit(paramTransform(self.fixedPop['m2'])) bwM2 = astroStats.scott_bin_width(m2Trans) porbTrans = ss.logit(paramTransform(self.fixedPop['logp'])) bwPorb = astroStats.scott_bin_width(porbTrans) Lum1Trans = ss.logit(paramTransform(self.fixedPop['logL1'])) bwLum1 = astroStats.scott_bin_width(self.fixedPop['logL1']) Lum2Trans = ss.logit(paramTransform(self.fixedPop['logL2'])) bwLum2 = astroStats.scott_bin_width(self.fixedPop['logL2']) # The eccentricity is already transformed, but only fit KDE to ecc if ecc!=0.0 eIndex, = np.where(self.fixedPop['ecc'] > 1e-2) if len(eIndex) > 50: eccTrans = self.fixedPop['ecc'] for jj in eccTrans.keys(): if eccTrans[jj] > 0.999: eccTrans[jj] = 0.999 elif eccTrans[jj] < 1e-4: eccTrans[jj] = 1e-4 eccTrans = ss.logit(eccTrans) bwEcc = astroStats.scott_bin_width(eccTrans) else: bwEcc = 100.0 rad1Trans = ss.logit(paramTransform(self.fixedPop['logr1'])) bwRad1 = astroStats.scott_bin_width(rad1Trans) rad2Trans = ss.logit(paramTransform(self.fixedPop['logr2'])) bwRad2 = astroStats.scott_bin_width(rad2Trans) #print(bwEcc,bwPorb,bwM1,bwM2,bwLum1,bwLum2,bwRad1,bwRad2) #popBw = min(bwEcc,bwPorb,bwM1,bwM2,bwLum1,bwLum2,bwRad1,bwRad2) # GENERATE THE DATA LIST DEPENDING ON THE TYPE OF COMPACT BINARY TYPE ############################################################################## type1Save = 1 if type1Save < 14 and len(eIndex) > 50: print('both bright stars and eccentric') datList = np.array((m1Trans, m2Trans, porbTrans, eccTrans, rad1Trans, rad2Trans, Lum1Trans, Lum2Trans)) elif type1Save < 14 and len(eIndex) < 50: print('both bright stars and circular') datList = np.array((m1Trans, m2Trans, porbTrans, rad1Trans, rad2Trans, Lum1Trans, Lum2Trans)) # GENERATE THE KDE FOR THE DATA LIST ############################################################################## if (self.verbose): print(datList) self.sampleKernel = scipy.stats.gaussian_kde( datList) #, bw_method=popBw)