figaro 1.4.0__py3-none-any.whl

figaro/_likelihood.py

@@ -0,0 +1,159 @@
+import numpy as np
+from figaro._numba_functions import *
+
+LOG2PI = np.log(2*np.pi)
+
+@njit
+def scalar_product(v, M, n):
+    """
+    Scalar product: v*M*v^T
+    
+    Arguments:
+        np.ndarray v: array
+        np.ndarray M: matrix
+        int n:        len(v)
+    
+    Returns:
+        double: v*M*v^T
+    """
+    res = 0.
+    for i in prange(n):
+        for j in prange(n):
+            res = res + M[i,j]*v[i]*v[j]
+    return res
+
+@njit
+def log_norm_1d(x, m, s):
+    """
+    1D Normal logpdf
+    
+    Arguments:
+        double x: value
+        double m: mean
+        double s: var
+    
+    Returns:
+        Normal(m,s).logpdf(x)
+    """
+    return -(x-m)**2/(2*s) - 0.5*np.log(2*np.pi*s)
+
+@njit
+def log_norm(x, mu, cov):
+    """
+    Multivariate Normal logpdf
+    
+    Arguments:
+        np.ndarray x:   value
+        np.ndarray mu:  mean vector
+        np.ndarray cov: covariance matrix
+    
+    Returns:
+        double: MultivariateNormal(m,s).logpdf(x)
+    """
+    inv_cov  = inv_jit(cov)
+    exponent = -0.5*scalar_product(x-mu, inv_cov, len(mu))
+    lognorm  = 0.5*len(mu)*LOG2PI+0.5*logdet_jit(cov)
+    return -lognorm+exponent
+
+@njit
+def log_norm_int(x, mu, cov_1, inv_cov_1, cov_2):
+    """
+    Multivariate Normal logpdf (tailored to this problem!)
+    See https://arxiv.org/pdf/1811.04751v1.pdf
+    
+    Arguments:
+        np.ndarray x:         value
+        np.ndarray mu:        mean vector
+        np.ndarray cov_1:     1st covariance matrix
+        np.ndarray inv_cov_1: inverse of 1st covariance matrix
+        np.ndarray cov_2:     2nd covariance matrix
+    
+    Returns:
+        double: MultivariateNormal(m,s).logpdf(x)
+    """
+    inv_cov_2  = inv_jit(cov_2)
+    inv_cov    = inv_cov_1@inv_jit(inv_cov_1+inv_cov_2)@inv_cov_2
+    exponent   = -0.5*scalar_product(x-mu, inv_cov, len(mu))
+    lognorm    = 0.5*len(mu)*LOG2PI+0.5*(logdet_jit(cov_1) + logdet_jit(cov_2) + logdet_jit(inv_cov_1+inv_cov_2))
+    return -lognorm+exponent
+
+#------------#
+# 1D methods #
+#------------#
+
+@njit
+def eval_mix_1d(mu, sigma, means, covs):
+    """
+    Computes N(mu_k| mu, (sigma_k^2+sigma^2) for all the components of a mixture (for predictive likelihood, 1D).
+    
+    Arguments:
+        np.ndarray mu:    temptative mean of the parent mixture component
+        np.ndarray sigma: temptative variance of the parent mixture component
+        np.ndarray means: means of the event mixture components
+        np.ndarray vars:  variances of the event mixture components
+    
+    Returns:
+        np.ndarray: probability for each event mixture components
+    """
+    return np.array([log_norm_1d(means[i,0], mu, sigma+covs[i,0,0]) for i in prange(len(means))])
+
+@njit
+def evaluate_mixture_MC_draws_1d(mu, sigma, means, vars, w):
+    """
+    Computes N(mu_k| mu, (sigma_k^2+sigma^2) for a set of MC draws for mu and sigma.
+    
+    Arguments:
+        np.ndarray mu:    MC draws for the mean of the parent mixture component
+        np.ndarray sigma: MC draws for the variance of the parent mixture component
+        np.ndarray means: means of the event mixture components
+        np.ndarray vars:  variances of the event mixture components
+        np.ndarray w:     component weights
+    
+    Returns:
+        np.ndarray: probability for each MC draw
+    """
+    logP = np.zeros(len(mu), dtype = np.float64)
+    for i in prange(len(mu)):
+        logP[i] = logsumexp_jit(eval_mix_1d(mu[i], sigma[i], means, vars), b = w)
+    return logP
+
+#------------#
+# ND methods #
+#------------#
+
+@njit
+def eval_mix(mu, sigma, means, covs):
+    """
+    Computes N(mu_k| mu, (sigma_k^2+sigma^2) for all the components of a mixture (for predictive likelihood, ND).
+    
+    Arguments:
+        np.ndarray mu:    temptative mean of the parent mixture component
+        np.ndarray sigma: temptative covariance matrix of the parent mixture component
+        np.ndarray means: means of the event mixture components
+        np.ndarray covs:  covariance matrices of the event mixture components
+    
+    Returns:
+        np.ndarray: probability for each event mixture components
+    """
+    inv_sigma = inv_jit(sigma)
+    return np.array([log_norm_int(means[i], mu, sigma, inv_sigma, covs[i]) for i in prange(len(means))])
+
+@njit
+def evaluate_mixture_MC_draws(mu, sigma, means, covs, w):
+    """
+    Computes N(mu_k| mu, (sigma_k^2+sigma^2) for a set of MC draws for mu and sigma.
+    
+    Arguments:
+        np.ndarray mu:    MC draws for the mean vector of the parent mixture component
+        np.ndarray sigma: MC draws for the covariance matrix of the parent mixture component
+        np.ndarray means: means of the event mixture components
+        np.ndarray covs:  covariance matrices of the event mixture components
+        np.ndarray w:     component weights
+    
+    Returns:
+        np.ndarray: probability for each MC draw
+    """
+    logP = np.zeros(len(mu), dtype = np.float64)
+    for i in prange(len(mu)):
+        logP[i] = logsumexp_jit(eval_mix(mu[i], sigma[i], means, covs), b = w)
+    return logP

figaro/_numba_functions.py

@@ -0,0 +1,68 @@
+import numpy as np
+from numba import njit, prange
+from numba.extending import get_cython_function_address
+import ctypes
+
+@njit
+def inv_jit(M):
+  return np.linalg.inv(M)
+
+@njit
+def logdet_jit(M):
+    return np.log(np.linalg.det(M))
+
+@njit
+def logsumexp_jit(a, b):
+    a_max = np.max(a)
+    tmp = b * np.exp(a - a_max)
+    return np.log(np.sum(tmp)) + a_max
+
+@njit
+def log_add(x, y):
+    if x >= y:
+        return x+_log1p_jit(np.exp(y-x))
+    else:
+        return y+_log1p_jit(np.exp(x-y))
+
+@njit
+def _outer_jit(x, y):
+    return np.outer(x, y)
+    
+@njit
+def _divide_jit(x, y):
+    return np.divide(x, y)
+
+@njit
+def _diag_jit(m):
+    return np.diag(m)
+
+@njit
+def _rescale_matrix(S, n):
+    std = np.sqrt(_diag_jit(S))
+    rho = _divide_jit(S, _outer_jit(std,std))
+    return rho * _outer_jit(std/np.sqrt(n), std/np.sqrt(n))
+
+@njit
+def _eigh_jit(m):
+    return np.linalg.eigh(m)
+
+@njit
+def _log1p_jit(x):
+    return np.log1p(x)
+
+"""
+See https://stackoverflow.com/a/54855769
+Wrapper (based on https://github.com/numba/numba/issues/3086) for scipy's cython implementation of gammaln.
+"""
+
+_PTR = ctypes.POINTER
+_dble = ctypes.c_double
+_ptr_dble = _PTR(_dble)
+
+addr = get_cython_function_address("scipy.special.cython_special", "gammaln")
+functype = ctypes.CFUNCTYPE(_dble, _dble)
+gammaln_float64 = functype(addr)
+
+@njit
+def _gammaln_jit(x):
+    return gammaln_float64(x)

figaro/_pipelines/create_glade.py

@@ -0,0 +1,135 @@
+#from astropy.table import Table
+import matplotlib.pyplot as plt
+import numpy as np
+#from tqdm import tqdm
+#import healpy as hp
+import h5py
+import pandas as pd
+#from tqdm import tqdm
+from pathlib import Path
+import optparse as op
+
+'''
+GLADE+ columns (29/04/2022)
+
+0    GLADE no    GLADE+ catalog number
+1    PGC no    Principal Galaxies Catalogue number
+2    GWGC name    Name in the GWGC catalog
+3    HyperLEDA name    Name in the HyperLEDA catalog
+4    2MASS name    Name in the 2MASS XSC catalog
+5    WISExSCOS name    Name in the WISExSuperCOSMOS catalog (wiseX)
+6    SDSS-DR16Q name    Name in the SDSS-DR16Q catalog
+7    Object type flag    Q: the source is from the SDSS-DR16Q catalog, G:the source is from another catalog and has not been identified as a quasar
+8    RA    Right ascension in degrees
+9    Dec    Declination in degrees
+10    B    Apparent B magnitude
+11    B_err    Absolute error of apparent B magnitude
+12    B flag    0: the B magnitude is measured, 1: the B magnitude is calculated from the B_J magnitude
+13    B_Abs    Absolute B magnitude
+14    J    Apparent J magnitude
+15    J_err    Absolute error of apparent J magnitude
+16    H    Apparent H magnitude
+17    H_err    Absolute error of apparent H magnitude
+18    K    Apparent K_s magnitude
+19    K_err    Absolute error of apparent K_s magnitude
+20    W1    Apparent W1 magnitude
+21    W1_err    Absolute error of apparent W1 magnitude
+22    W2    Apparent W2 magnitude
+23    W2_err    Absolute error of apparent W2 magnitude
+24    W1 flag    0: the W1 magnitude is measured, 1: the W1 magnitude is calculated from the K_s magnitude
+25    B_J    Apparent B_J magnitude
+26    B_J err    Absolute error of apparent B_J magnitude
+27    z_helio    Redshift in the heliocentric frame
+28    z_cmb    Redshift converted to the Cosmic Microwave Background (CMB) frame
+29    z flag    0: the CMB frame redshift and luminosity distance values given in columns 25 and 28 are not corrected for the peculiar velocity, 1: they are corrected values
+30    v_err    Error of redshift from the peculiar velocity estimation
+31    z_err    Measurement error of heliocentric redshift
+32    d_L    Luminosity distance in Mpc units
+33    d_L err    Error of luminosity distance in Mpc units
+34    dist flag    0: the galaxy has no measured redshift or distance value, 1: it has a measured photometric redshift from which we have calculated its luminosity distance, 2: it has a measured luminosity distance value from which we have calculated its redshift, 3: it has a measured spectroscopic redshift from which we have calculated its luminosity distance
+35    M*    Stellar mass in 10^10 M_Sun units
+36    M*_err    Absolute error of stellar mass in 10^10 M_Sun units
+37    M* flag    0: if the stellar mass was calculated assuming no active star formation, 1: if the stellar mass was calculated assuming active star formation
+38    Merger rate    Base-10 logarithm of estimated BNS merger rate in the galaxy in Gyr^-1 units
+39    Merger rate error    Absolute error of estimated BNS merger rate in the galaxy
+'''
+
+def main():
+    """
+    Preprocess the .txt file downloaded from the GLADE+ website - http://glade.elte.hu - selecting only some columns.
+    The output file is a lighter .hdf5 file, saved in the same folder as the .txt file, that has the structure required by figaro.threeDvolume.VolumeReconstruction.load_glade
+    """
+    parser = op.OptionParser()
+    parser.add_option("-i", type = "string", dest = "glade_file", help = "GLADE+ txt file")
+    
+    (options, args) = parser.parse_args()
+    glade_file      = Path(options.glade_file).resolve()
+    glade_folder    = glade_file.parent
+    
+    dict_out={}
+
+    # Load all the columns of interest, please note that usecols must be in creasing order
+    chunk = pd.read_csv(glade_file,
+                        usecols=(7, 8, 9, 10, 12, 18, 20, 25, 27, 28, 29, 30, 31, 34),
+                        header=None,
+                        names=['objtype', 'ra', 'dec', 'B', 'Bflag', 'K', 'W1', 'bJ', 'zhelio', 'zcmb', 'pecflag', 'pecerr', 'zhelioerr', 'redflag'],
+                        delim_whitespace=True,
+                        na_values="null",
+                        )
+
+    # Check the galaxies
+    COND_GALAXY = (chunk['objtype']=='G')
+
+    # Check if the redshift is measured and not obtained from dl
+    COND_RED_ORIGIN = True#(chunk['redflag']==1) | (chunk['redflag']==3)
+
+    # Check if peculiar corrections are applied. If not, saves the galaxy only if it is above redshift 0.5
+    COND_PEC = (chunk['zcmb']>0.05) | (chunk['pecflag']==1)
+
+    # Check if cmb redshift is positive
+    COND_NEGATIVE_RED = chunk['zcmb']>0
+
+    # Combine the above conditions, must be all true
+    idx=np.where(COND_GALAXY & COND_RED_ORIGIN & COND_PEC & COND_NEGATIVE_RED)[0]
+
+    # Saves the columns in a disctionary as numpy arrays
+    for kk in ['objtype',"ra", "dec", "B", "Bflag", "bJ",'K','W1','zhelio','zcmb','pecflag','pecerr','zhelioerr','redflag']:
+        dict_out[kk]=chunk[kk][idx].to_numpy()
+
+    # Save GLADE catalog
+    bands=['B', 'K','W1','bJ']
+    nGal = len(dict_out['zcmb'])
+
+    # Converts to radians
+    dict_out['ra']*=np.pi/180
+    dict_out['dec']*=np.pi/180
+
+#    # Finds the numpy index, just as general info
+#    nside = 1024
+#    ind = hp.pixelfunc.ang2pix(nside,dict_out['dec']+np.pi/2,dict_out['ra'])
+
+#     Limits for an all sky catalogs
+#    ra_dec_lim = 0
+#    ra_min = 0.0
+#    ra_max = np.pi*2.0
+#    dec_min = -np.pi/2.0
+#    dec_max = np.pi/2.0
+
+    # Just a test print. I wanted to check how many galaxies had B from bj. I got around 10%
+#    idx0=np.where(dict_out['Bflag']==0)[0]
+#    idx1=np.where(dict_out['Bflag']==1)[0]
+#    print('bJflag ratio 0/1', len(idx0)/len(idx1))
+
+    # Saves the catalog in hdf5 format
+    with h5py.File(Path(glade_folder, "glade+.hdf5"), "w") as f:
+        f.create_dataset("ra", data=dict_out['ra'])
+        f.create_dataset("dec", data=dict_out['dec'])
+        f.create_dataset("z", data=dict_out['zcmb'])
+#        f.create_dataset("sigmaz", data=(dict_out['zhelioerr']/dict_out['zhelio'])*dict_out['zcmb'])
+#        f.create_dataset("skymap_indices", data=ind)
+#        f.create_dataset("radec_lim", data=np.array([ra_dec_lim,ra_min,ra_max,dec_min,dec_max]))
+        for j in range(len(bands)):
+            f.create_dataset("m_{0}".format(bands[j]), data=dict_out[bands[j]])
+
+if __name__ == '__main__':
+    main()

figaro/_pipelines/hierarchical_inference.py

@@ -0,0 +1,200 @@
+import numpy as np
+
+import optparse as op
+import importlib
+
+from pathlib import Path
+from tqdm import tqdm
+
+from figaro.mixture import DPGMM, HDPGMM
+from figaro.transform import transform_to_probit
+from figaro.utils import save_options, load_options, get_priors
+from figaro.plot import plot_median_cr, plot_multidim
+from figaro.load import load_data, load_single_event, save_density, load_density
+
+def main():
+
+    parser = op.OptionParser()
+    # Input/output
+    parser.add_option("-i", "--input", type = "string", dest = "samples_folder", help = "Folder with single-event samples files", default = None)
+    parser.add_option("-b", "--bounds", type = "string", dest = "bounds", help = "Density bounds. Must be a string formatted as '[[xmin, xmax], [ymin, ymax],...]'. For 1D distributions use '[xmin, xmax]'. Quotation marks are required and scientific notation is accepted", default = None)
+    parser.add_option("-o", "--output", type = "string", dest = "output", help = "Output folder. Default: same directory as samples folder", default = None)
+    parser.add_option("-j", dest = "json", action = 'store_true', help = "Save mixtures in json file", default = False)
+    parser.add_option("--inj_density", type = "string", dest = "inj_density_file", help = "Python module with injected density - please name the method 'density'", default = None)
+    parser.add_option("--selfunc", type = "string", dest = "selfunc_file", help = "Python module with selection function - please name the method 'selection_function'", default = None)
+    parser.add_option("--parameter", type = "string", dest = "par", help = "GW parameter(s) to be read from files", default = None)
+    parser.add_option("--waveform", type = "string", dest = "wf", help = "Waveform to load from samples file. To be used in combination with --parameter. Accepted values: 'combined', 'imr', 'seob'", default = 'combined')
+    # Plot
+    parser.add_option("--name", type = "string", dest = "h_name", help = "Name to be given to hierarchical inference files. Default: same name as samples folder parent directory", default = None)
+    parser.add_option("-p", "--postprocess", dest = "postprocess", action = 'store_true', help = "Postprocessing", default = False)
+    parser.add_option("-s", "--save_se", dest = "save_single_event", action = 'store_true', help = "Save single event plots", default = False)
+    parser.add_option("--symbol", type = "string", dest = "symbol", help = "LaTeX-style quantity symbol, for plotting purposes", default = None)
+    parser.add_option("--unit", type = "string", dest = "unit", help = "LaTeX-style quantity unit, for plotting purposes", default = None)
+    parser.add_option("--hier_samples", type = "string", dest = "true_vals", help = "Samples from hierarchical distribution (true single-event values, for simulations only)", default = None)
+    # Settings
+    parser.add_option("--draws", type = "int", dest = "n_draws", help = "Number of draws for hierarchical distribution", default = 100)
+    parser.add_option("--se_draws", type = "int", dest = "n_se_draws", help = "Number of draws for single-event distribution. Default: same as hierarchical distribution", default = None)
+    parser.add_option("--n_samples_dsp", type = "int", dest = "n_samples_dsp", help = "Number of samples to analyse (downsampling). Default: all", default = -1)
+    parser.add_option("--exclude_points", dest = "exclude_points", action = 'store_true', help = "Exclude points outside bounds from analysis", default = False)
+    parser.add_option("--cosmology", type = "string", dest = "cosmology", help = "Cosmological parameters (h, om, ol). Default values from Planck (2021)", default = '0.674,0.315,0.685')
+    parser.add_option("-e", "--events", dest = "run_events", action = 'store_false', help = "Skip single-event analysis", default = True)
+    parser.add_option("--se_sigma_prior", dest = "se_sigma_prior", type = "string", help = "Expected standard deviation (prior) for single-event inference - single value or n-dim values. If None, it is estimated from samples", default = None)
+    parser.add_option("--sigma_prior", dest = "sigma_prior", type = "string", help = "Expected standard deviation (prior) for hierarchical inference - single value or n-dim values. If None, it is estimated from samples", default = None)
+    parser.add_option("--fraction", dest = "scale", type = "float", help = "Fraction of samples standard deviation for sigma prior. Overrided by sigma_prior.", default = None)
+    parser.add_option("--mc_draws", dest = "mc_draws", type = "int", help = "Number of draws for assignment MC integral", default = None)
+    parser.add_option("--snr_threshold", dest = "snr_threshold", type = "float", help = "SNR threshold for simulated GW datasets", default = None)
+    parser.add_option("--far_threshold", dest = "far_threshold", type = "float", help = "FAR threshold for simulated GW datasets", default = None)
+    parser.add_option("--no_probit", dest = "probit", action = 'store_false', help = "Disable probit transformation", default = True)
+    parser.add_option("--config", dest = "config", type = "string", help = "Config file. Warning: command line options are ignored if provided", default = None)
+    
+    (options, args) = parser.parse_args()
+
+    # Paths
+    if options.samples_folder is not None:
+        options.samples_folder = Path(options.samples_folder).resolve()
+    elif options.config is not None:
+        options.samples_folder = Path('.').resolve()
+    else:
+        raise Exception("Please provide path to samples.")
+    if options.output is not None:
+        options.output = Path(options.output).resolve()
+        if not options.output.exists():
+            options.output.mkdir(parents=True)
+    else:
+        options.output = options.samples_folder.parent
+    if options.config is not None:
+        options.config = Path(options.config).resolve()
+    output_plots = Path(options.output, 'plots')
+    if not output_plots.exists():
+        output_plots.mkdir()
+    output_draws = Path(options.output, 'draws')
+    if not output_draws.exists():
+        output_draws.mkdir()
+    # Read hierarchical name
+    if options.h_name is None:
+        options.h_name = options.samples_folder.parent.parts[-1]
+    # File extension
+    if options.json:
+        options.ext = 'json'
+    else:
+        options.ext = 'pkl'
+        
+    if options.config is not None:
+        options = load_options(options, options.config)
+    save_options(options, options.output, name = options.h_name)
+    
+    # Read bounds
+    if options.bounds is not None:
+        options.bounds = np.array(np.atleast_2d(eval(options.bounds)), dtype = np.float64)
+    elif options.bounds is None and not options.postprocess:
+        raise Exception("Please provide bounds for the inference (use -b '[[xmin,xmax],[ymin,ymax],...]')")
+    # Read cosmology
+    options.h, options.om, options.ol = (float(x) for x in options.cosmology.split(','))
+    # Read parameter(s)
+    if options.par is not None:
+        options.par = options.par.split(',')
+    # Read number of single-event draws
+    if options.n_se_draws is None:
+        options.n_se_draws = options.n_draws
+    if options.se_sigma_prior is not None:
+        options.se_sigma_prior = np.array([float(s) for s in options.se_sigma_prior.split(',')])
+    if options.sigma_prior is not None:
+        options.sigma_prior = np.array([float(s) for s in options.sigma_prior.split(',')])
+
+    # If provided, load injected density
+    inj_density = None
+    if options.inj_density_file is not None:
+        inj_file_name = Path(options.inj_density_file).parts[-1].split('.')[0]
+        spec = importlib.util.spec_from_file_location(inj_file_name, options.inj_density_file)
+        inj_module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(inj_module)
+        inj_density = inj_module.density
+    #If provided, load selecton function
+    selfunc = None
+    if options.selfunc_file is not None:
+        selfunc_file_name = Path(options.selfunc_file).parts[-1].split('.')[0]
+        spec = importlib.util.spec_from_file_location(selfunc_file_name, options.selfunc_file)
+        selfunc_module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(selfunc_module)
+        selfunc = selfunc_module.selection_function
+    # If provided, load true values
+    true_vals = None
+    if options.true_vals is not None:
+        options.true_vals = Path(options.true_vals).resolve()
+        true_vals, true_name = load_single_event(options.true_vals, par = options.par, h = options.h, om = options.om, ol = options.ol, waveform = options.wf)
+        if np.shape(true_vals)[-1] == 1:
+            true_vals = true_vals.flatten()
+            
+    # Load samples
+    events, names = load_data(options.samples_folder, par = options.par, n_samples = options.n_samples_dsp, h = options.h, om = options.om, ol = options.ol, waveform = options.wf, snr_threshold = options.snr_threshold, far_threshold = options.far_threshold)
+    try:
+        dim = np.shape(events[0][0])[-1]
+    except IndexError:
+        dim = 1
+    if options.exclude_points:
+        print("Ignoring points outside bounds.")
+        for i, ev in enumerate(events):
+            events[i] = ev[np.where((np.prod(options.bounds[:,0] < ev, axis = 1) & np.prod(ev < options.bounds[:,1], axis = 1)))]
+    else:
+        # Check if all samples are within bounds
+        all_samples = np.atleast_2d(np.concatenate(events))
+        if options.probit:
+            if not np.all([(all_samples[:,i] > options.bounds[i,0]).all() and (all_samples[:,i] < options.bounds[i,1]).all() for i in range(dim)]):
+                raise ValueError("One or more samples are outside the given bounds.")
+
+    # Plot labels
+    if dim > 1:
+        if options.symbol is not None:
+            symbols = options.symbol.split(',')
+        else:
+            symbols = options.symbol
+        if options.unit is not None:
+            units = options.unit.split(',')
+        else:
+            units = options.unit
+    
+    # Reconstruction
+    if not options.postprocess:
+        if options.run_events:
+            mix = DPGMM(options.bounds, probit = options.probit)
+            posteriors = []
+            # Run each single-event analysis
+            for i in tqdm(range(len(events)), desc = 'Events'):
+                ev   = events[i]
+                name = names[i]
+                prior_pars = get_priors(mix.bounds, samples = ev, probit = options.probit, std = options.se_sigma_prior, scale = options.scale, hierarchical = False)
+                mix.initialise(prior_pars = prior_pars)
+                # Draw samples
+                draws = [mix.density_from_samples(ev) for _ in range(options.n_se_draws)]
+                posteriors.append(draws)
+                # Make plots
+                if options.save_single_event:
+                    plt_bounds = np.atleast_2d([ev.min(axis = 0), ev.max(axis = 0)]).T
+                    if dim == 1:
+                        plot_median_cr(draws, samples = ev, bounds = plt_bounds[0], out_folder = output_plots, name = name, label = options.symbol, unit = options.unit, subfolder = True)
+                    else:
+                        plot_multidim(draws, samples = ev, bounds = plt_bounds, out_folder = output_plots, name = name, labels = symbols, units = units, subfolder = True)
+                # Save single-event draws
+                save_density(draws, folder = output_draws, name = 'draws_'+name, ext = options.ext)
+            # Save all single-event draws together
+            posteriors = np.array(posteriors)
+            save_density(posteriors, folder = output_draws, name = 'posteriors_single_event', ext = options.ext)
+        else:
+            # Load pre-computed posteriors
+            posteriors = load_density(Path(output_draws, 'posteriors_single_event.'+options.ext))
+        # Run hierarchical analysis
+        prior_pars = get_priors(options.bounds, samples = events, std = options.sigma_prior, scale = options.scale, probit = options.probit, hierarchical = True)
+        mix        = HDPGMM(options.bounds, prior_pars = prior_pars, MC_draws = options.mc_draws, probit = options.probit)
+        draws      = np.array([mix.density_from_samples(posteriors) for _ in tqdm(range(options.n_draws), desc = 'Hierarchical')])
+        # Save draws
+        save_density(draws, folder = output_draws, name = 'draws_'+options.h_name, ext = options.ext)
+    else:
+        draws = load_density(Path(output_draws, 'draws_'+options.h_name+'.'+options.ext))
+    # Plot
+    if dim == 1:
+        plot_median_cr(draws, injected = inj_density, selfunc = selfunc, samples = true_vals, out_folder = output_plots, name = options.h_name, label = options.symbol, unit = options.unit, hierarchical = True)
+    else:
+        plot_multidim(draws, samples = true_vals, out_folder = output_plots, name = options.h_name, labels = symbols, units = units, hierarchical = True)
+
+if __name__ == '__main__':
+    main()