def time_test_cluster():
from popstar import synthetic as syn
from popstar import atmospheres as atm
from popstar import evolution
from popstar import reddening
from popstar.imf import imf
from popstar.imf import multiplicity
logAge = 6.7
AKs = 2.7
distance = 4000
cluster_mass = 10**4
startTime = time.time()
evo = evolution.MergedBaraffePisaEkstromParsec()
atm_func = atm.get_merged_atmosphere
red_law = reddening.RedLawNishiyama09()
filt_list = ['nirc2,J', 'nirc2,Kp']
iso = syn.IsochronePhot(logAge, AKs, distance,
evo_model=evo, atm_func=atm_func,
red_law=red_law, filters=filt_list)
print('Constructed isochrone: %d seconds' % (time.time() - startTime))
imf_limits = np.array([0.07, 0.5, 150])
imf_powers = np.array([-1.3, -2.35])
multi = multiplicity.MultiplicityUnresolved()
my_imf = imf.IMF_broken_powerlaw(imf_limits, imf_powers, multiplicity=multi)
print('Constructed IMF with multiples: %d seconds' % (time.time() - startTime))
cluster = syn.ResolvedCluster(iso, my_imf, cluster_mass)
print('Constructed cluster: %d seconds' % (time.time() - startTime))
return
def test_UnresolvedCluster():
from popstar import synthetic as syn
from popstar import atmospheres as atm
from popstar import evolution
from popstar.imf import imf
from popstar.imf import multiplicity
log_age = 6.7
AKs = 0.0
distance = 4000
metallicity=0
cluster_mass = 10**4.
startTime = time.time()
multi = multiplicity.MultiplicityUnresolved()
imf_in = imf.Kroupa_2001(multiplicity=multi)
evo = evolution.MergedBaraffePisaEkstromParsec()
atm_func = atm.get_merged_atmosphere
iso = syn.Isochrone(log_age, AKs, distance, metallicity=metallicity,
evo_model=evo, atm_func=atm_func, mass_sampling=10)
print('Made Isochrone: %d seconds' % (time.time() - startTime))
cluster = syn.UnresolvedCluster(iso, imf_in, cluster_mass)
print('Constructed unresolved cluster: %d seconds' % (time.time() - startTime))
# Plot an integrated spectrum of the whole cluster.
wave = cluster.wave_trim
flux = cluster.spec_trim
plt.clf()
plt.plot(wave, flux, 'k.')
return
def test_UnresolvedCluster():
from popstar import synthetic as syn
from popstar import atmospheres as atm
from popstar import evolution
from popstar.imf import imf
from popstar.imf import multiplicity
log_age = 6.7
AKs = 0.0
distance = 4000
cluster_mass = 30.
startTime = time.time()
multi = multiplicity.MultiplicityUnresolved()
imf_in = imf.Kroupa_2001(multiplicity=multi)
evo = evolution.MergedBaraffePisaEkstromParsec()
iso = syn.Isochrone(log_age, AKs, distance, evo, mass_sampling=10)
print 'Made cluster: %d seconds' % (time.time() - startTime)
cluster = syn.UnresolvedCluster(iso, imf_in, cluster_mass)
print 'Constructed unresolved cluster: %d seconds' % (time.time() -
startTime)
# Plot an integrated spectrum of the whole cluster.
wave = cluster.spec_trim.wave
flux = cluster.spec_trim.flux
plt.clf()
plt.plot(wave, flux, 'k.')
pdb.set_trace()
return
def test_evolution_models():
"""
Test to make sure the different evolution models work
"""
from popstar import evolution
# Age ranges to test
age_young_arr = [6.7, 7.9]
age_all_arr = [6.7, 8.0, 9.7]
# Metallicity ranges to test (if applicable)
metal_range = [-2.5, 0, 0.4]
metal_solar = [0]
# Array of evolution models to test
evo_models = [
evolution.MISTv1(version=1.2),
evolution.MergedBaraffePisaEkstromParsec(),
evolution.MergedSiessGenevaPadova(),
evolution.Parsec(),
evolution.Baraffe15(),
evolution.Ekstrom12(),
evolution.Pisa()
]
# Array of age_ranges for the specific evolution models to test
age_vals = [
age_all_arr, age_all_arr, age_all_arr, age_all_arr, age_young_arr,
age_young_arr, age_young_arr
]
# Array of metallicities for the specific evolution models to test
metal_vals = [
metal_range, metal_solar, metal_solar, metal_solar, metal_solar,
metal_solar, metal_solar
]
assert len(evo_models) == len(age_vals) == len(metal_vals)
# Loop through models, testing if them work
for ii in range(len(evo_models)):
evo = evo_models[ii]
# Loop through metallicities
for jj in metal_vals[ii]:
# Loop through ages
for kk in age_vals[ii]:
try:
test = evo.isochrone(age=10**kk, metallicity=jj)
except:
print('TEST FAILED: {0}, age = {1}, metal = {2}'.format(
evo, kk, jj))
pdb.set_trace()
print('Done {0}'.format(evo))
return
def make_sim_cluster():
work_dir = '/u/jlu/work/gc/jwst/2018_03_19/'
ages = [4e6, 1e8, 8e9]
cluster_mass = [1e4, 1e4, 1e7]
AKs = 2.7
deltaAKs = 1.0
distance = 8000
mass_sampling = 5
isochrones = []
clusters = []
evo = evolution.MergedBaraffePisaEkstromParsec()
atm_func = atm.get_merged_atmosphere
red_law = reddening.RedLawHosek18()
multi = multiplicity.MultiplicityUnresolved()
imf_mass_limits = np.array([0.07, 0.5, 1, np.inf])
imf_powers_old = np.array([-1.3, -2.3, -2.3])
imf_powers_yng = np.array([-1.3, -1.8, -1.8])
my_imf_old = imf.IMF_broken_powerlaw(imf_mass_limits,
imf_powers_old,
multiplicity=multi)
my_imf_yng = imf.IMF_broken_powerlaw(imf_mass_limits,
imf_powers_yng,
multiplicity=multi)
# Test all filters
filt_list = [
'wfc3,ir,f127m', 'wfc3,ir,f139m', 'wfc3,ir,f153m', 'acs,wfc1,f814w',
'wfc3,ir,f125w', 'wfc3,ir,f160w', 'jwst,F090W', 'jwst,F115W',
'jwst,F164N', 'jwst,F187N', 'jwst,F212N', 'jwst,F323N', 'jwst,F405N',
'jwst,F466N', 'jwst,F470N', 'jwst,F140M', 'jwst,F162M', 'jwst,F182M',
'jwst,F210M', 'jwst,F250M', 'jwst,F300M', 'jwst,F335M', 'jwst,F360M',
'jwst,F410M', 'jwst,F430M', 'jwst,F460M', 'jwst,F480M', 'nirc2,J',
'nirc2,H', 'nirc2,Kp', 'nirc2,Lp', 'nirc2,Ms'
]
startTime = time.time()
for ii in range(len(ages)):
logAge = np.log10(ages[ii])
iso = syn.IsochronePhot(logAge,
AKs,
distance,
evo_model=evo,
atm_func=atm_func,
red_law=red_law,
filters=filt_list,
mass_sampling=mass_sampling,
iso_dir=work_dir)
print('Constructed isochrone: %d seconds' % (time.time() - startTime))
if ii < 2:
imf_ii = my_imf_yng
else:
imf_ii = my_imf_old
cluster = syn.ResolvedClusterDiffRedden(iso, imf_ii, cluster_mass[ii],
deltaAKs)
# Save generated clusters to file.
save_file_fmt = '{0}/clust_{1:.2f}_{2:4.2f}_{3:4s}.fits'
save_file_txt = save_file_fmt.format(work_dir, logAge, AKs,
str(distance).zfill(5))
save_file = open(save_file_txt, 'wb')
pickle.dump(cluster, save_file)
return
return
def test_iso_wave():
"""
Test to make sure isochrones generated have spectra with the proper
wavelength range, and that the user has control over that wavelength
range (propagated through IsochronePhot)
"""
# Define isochrone parameters
logAge = np.log10(5 * 10**6.) # Age in log(years)
AKs = 0.8 # extinction in mags
dist = 4000 # distance in parsec
# Define evolution/atmosphere models and extinction law (optional)
evo_model = evolution.MergedBaraffePisaEkstromParsec()
atm_func = atmospheres.get_merged_atmosphere
red_law = reddening.RedLawHosek18b()
# Also specify filters for synthetic photometry (optional). Here we use
# the HST WFC3-IR F127M, F139M, and F153M filters
filt_list = ['wfc3,ir,f127m']
# First, let's make sure the vega spectrum has the proper limits
vega = synthetic.Vega()
assert np.min(vega.wave) == 995
assert np.max(vega.wave) == 100200
# Make Isochrone object. Will use wave_range = [3000,52000].
# Make sure range matches to resolution of atmosphere.
wave_range1 = [3000, 52000]
my_iso = synthetic.IsochronePhot(logAge,
AKs,
dist,
evo_model=evo_model,
atm_func=atm_func,
red_law=red_law,
filters=filt_list,
mass_sampling=10,
wave_range=wave_range1,
recomp=True)
test = my_iso.spec_list[0]
assert np.min(test.wave) == 3010
assert np.max(test.wave) == 51900
# Now let's try changing the wave range. Is it carried through
# properly?
wave_range2 = [1200, 90000]
my_iso = synthetic.IsochronePhot(logAge,
AKs,
dist,
evo_model=evo_model,
atm_func=atm_func,
red_law=red_law,
filters=filt_list,
mass_sampling=10,
wave_range=wave_range2,
recomp=True)
test2 = my_iso.spec_list[0]
assert np.min(test2.wave) == 1205
assert np.max(test2.wave) == 89800
# Does the error exception catch the bad wave_range?
wave_range3 = [1200, 1000000]
try:
my_iso = synthetic.IsochronePhot(logAge,
AKs,
dist,
evo_model=evo_model,
atm_func=atm_func,
red_law=red_law,
filters=filt_list,
mass_sampling=10,
wave_range=wave_range3,
recomp=True)
print(
'WAVE TEST FAILED!!! Should have crashed here, wavelength range out of bounds'
)
pdb.set_trace()
except:
print('Wavelength out of bound condition passed. Test is good')
pass
return
def test_ResolvedClusterDiffRedden():
from popstar import synthetic as syn
from popstar import atmospheres as atm
from popstar import evolution
from popstar import reddening
from popstar.imf import imf
from popstar.imf import multiplicity
logAge = 6.7
AKs = 2.4
distance = 4000
cluster_mass = 10**5.
deltaAKs = 0.05
mass_sampling = 5
# Test filters
filt_list = ['nirc2,J', 'nirc2,Kp']
startTime = time.time()
evo = evolution.MergedBaraffePisaEkstromParsec()
atm_func = atm.get_merged_atmosphere
red_law = reddening.RedLawNishiyama09()
iso = syn.IsochronePhot(logAge,
AKs,
distance,
evo_model=evo,
atm_func=atm_func,
red_law=red_law,
filters=filt_list,
mass_sampling=mass_sampling)
print('Constructed isochrone: %d seconds' % (time.time() - startTime))
imf_mass_limits = np.array([0.07, 0.5, 1, np.inf])
imf_powers = np.array([-1.3, -2.3, -2.3])
##########
# Start without multiplicity
##########
my_imf1 = imf.IMF_broken_powerlaw(imf_mass_limits,
imf_powers,
multiplicity=None)
print('Constructed IMF: %d seconds' % (time.time() - startTime))
cluster1 = syn.ResolvedClusterDiffRedden(iso, my_imf1, cluster_mass,
deltaAKs)
clust1 = cluster1.star_systems
print('Constructed cluster: %d seconds' % (time.time() - startTime))
assert len(clust1) > 0
plt.figure(3)
plt.clf()
plt.plot(clust1['m_nirc2_J'] - clust1['m_nirc2_Kp'], clust1['m_nirc2_J'],
'r.')
plt.plot(iso.points['m_nirc2_J'] - iso.points['m_nirc2_Kp'],
iso.points['m_nirc2_J'], 'c.')
plt.gca().invert_yaxis()
# *** Visual Inspections: ***
# - check that points (red) fall between isochrone points (blue)
##########
# Test with multiplicity
##########
multi = multiplicity.MultiplicityUnresolved()
my_imf2 = imf.IMF_broken_powerlaw(imf_mass_limits,
imf_powers,
multiplicity=multi)
print('Constructed IMF with multiples: %d seconds' %
(time.time() - startTime))
cluster2 = syn.ResolvedClusterDiffRedden(iso, my_imf2, cluster_mass,
deltaAKs)
clust2 = cluster2.star_systems
print('Constructed cluster with multiples: %d seconds' %
(time.time() - startTime))
assert len(clust2) > 0
assert len(cluster2.companions) > 0
assert np.sum(clust2['N_companions']) == len(cluster2.companions)
##########
# Plots
##########
# Plot an IR CMD and compare cluster members to isochrone.
plt.figure(1)
plt.clf()
plt.plot(clust1['m_nirc2_J'] - clust1['m_nirc2_Kp'], clust1['m_nirc2_J'],
'r.')
plt.plot(clust2['m_nirc2_J'] - clust2['m_nirc2_Kp'], clust2['m_nirc2_J'],
'b.')
plt.plot(iso.points['m_nirc2_J'] - iso.points['m_nirc2_Kp'],
iso.points['m_nirc2_J'], 'c-')
plt.gca().invert_yaxis()
plt.xlabel('J - Kp (mag)')
plt.ylabel('J (mag')
# Plot a mass-magnitude relationship.
plt.figure(2)
plt.clf()
plt.semilogx(clust1['mass'], clust1['m_nirc2_J'], 'r.')
plt.semilogx(clust2['mass'], clust2['m_nirc2_J'], 'r.')
plt.gca().invert_yaxis()
plt.xlabel('Mass (Msun)')
plt.ylabel('J (mag)')
return
def test_IsochronePhot(plot=False):
from popstar import synthetic as syn
from popstar import evolution, atmospheres, reddening
logAge = 6.7
AKs = 2.7
distance = 4000
filt_list = ['wfc3,ir,f127m', 'nirc2,J']
mass_sampling = 1
iso_dir = 'iso/'
evo_model = evolution.MISTv1()
atm_func = atmospheres.get_merged_atmosphere
redlaw = reddening.RedLawNishiyama09()
startTime = time.time()
iso = syn.IsochronePhot(logAge,
AKs,
distance,
evo_model=evo_model,
atm_func=atm_func,
red_law=redlaw,
filters=filt_list,
mass_sampling=mass_sampling,
iso_dir=iso_dir)
endTime = time.time()
print('IsochronePhot generated in: %d seconds' % (endTime - startTime))
# Typically takes 120 seconds if file is regenerated.
# Limited by pysynphot.Icat call in atmospheres.py
assert iso.points.meta['LOGAGE'] == logAge
assert iso.points.meta['AKS'] == AKs
assert iso.points.meta['DISTANCE'] == distance
assert len(iso.points) > 100
assert 'm_nirc2_J' in iso.points.colnames
if plot:
plt.figure(1)
iso.plot_CMD('mag814w', 'mag160w')
plt.figure(2)
iso.plot_mass_magnitude('mag160w')
# Finally, let's test the isochronePhot file generation
assert os.path.exists('{0}/iso_{1:.2f}_{2:4.2f}_{3:4s}_p00.fits'.format(
iso_dir, logAge, AKs,
str(distance).zfill(5)))
# Check 1: If we try to remake the isochrone, does it read the file rather than
# making a new one
iso_new = syn.IsochronePhot(logAge,
AKs,
distance,
evo_model=evo_model,
atm_func=atm_func,
red_law=redlaw,
filters=filt_list,
mass_sampling=mass_sampling,
iso_dir=iso_dir)
assert iso_new.recalc == False
# Check 2: If we change evo model, atmo model, or redlaw,
# does IsochronePhot regenerate the isochrone and overwrite the existing one?
evo2 = evolution.MergedBaraffePisaEkstromParsec()
mass_sampling = 20
iso_new = syn.IsochronePhot(logAge,
AKs,
distance,
evo_model=evo2,
atm_func=atm_func,
red_law=redlaw,
filters=filt_list,
mass_sampling=mass_sampling,
iso_dir=iso_dir)
assert iso_new.recalc == True
redlaw2 = reddening.RedLawHosek18b()
iso_new = syn.IsochronePhot(logAge,
AKs,
distance,
evo_model=evo2,
atm_func=atm_func,
red_law=redlaw2,
filters=filt_list,
mass_sampling=mass_sampling,
iso_dir=iso_dir)
assert iso_new.recalc == True
atm2 = atmospheres.get_castelli_atmosphere
iso_new = syn.IsochronePhot(logAge,
AKs,
distance,
evo_model=evo2,
atm_func=atm2,
red_law=redlaw2,
filters=filt_list,
mass_sampling=mass_sampling,
iso_dir=iso_dir)
assert iso_new.recalc == True
return
def test_ResolvedCluster():
from popstar import synthetic as syn
from popstar import atmospheres as atm
from popstar import evolution
from popstar import reddening
from popstar.imf import imf
from popstar.imf import multiplicity
# Define cluster parameters
logAge = 6.7
AKs = 2.4
distance = 4000
cluster_mass = 10**5.
mass_sampling=5
# Test all filters
filt_list = ['wfc3,ir,f127m', 'wfc3,ir,f139m', 'wfc3,ir,f153m', 'acs,wfc1,f814w',
'wfc3,ir,f125w', 'wfc3,ir,f160w', 'decam,y', 'decam,i', 'decam,z',
'decam,u', 'decam,g', 'decam,r', 'vista,Y', 'vista,Z',
'vista,J', 'vista,H', 'vista,Ks', 'ps1,z', 'ps1,g', 'ps1,r',
'ps1,i', 'ps1,y', 'jwst,F090W', 'jwst,F164N', 'jwst,F212N',
'jwst,F323N', 'jwst,F466N', 'nirc2,J', 'nirc2,H', 'nirc2,Kp',
'nirc2,K', 'nirc2,Lp', 'nirc2,Ms', 'nirc2,Hcont', 'nirc2,FeII',
'nirc2,Brgamma', 'jg,J', 'jg,H', 'jg,K']
startTime = time.time()
evo = evolution.MergedBaraffePisaEkstromParsec()
atm_func = atm.get_merged_atmosphere
red_law = reddening.RedLawNishiyama09()
iso = syn.IsochronePhot(logAge, AKs, distance,
evo_model=evo, atm_func=atm_func,
red_law=red_law, filters=filt_list,
mass_sampling=mass_sampling)
print('Constructed isochrone: %d seconds' % (time.time() - startTime))
# Now to create the cluster.
imf_mass_limits = np.array([0.07, 0.5, 1, np.inf])
imf_powers = np.array([-1.3, -2.3, -2.3])
##########
# Start without multiplicity
##########
my_imf1 = imf.IMF_broken_powerlaw(imf_mass_limits, imf_powers,
multiplicity=None)
print('Constructed IMF: %d seconds' % (time.time() - startTime))
cluster1 = syn.ResolvedCluster(iso, my_imf1, cluster_mass)
clust1 = cluster1.star_systems
print('Constructed cluster: %d seconds' % (time.time() - startTime))
plt.figure(3)
plt.clf()
plt.plot(clust1['m_nirc2_J'] - clust1['m_nirc2_Kp'], clust1['m_nirc2_J'], 'r.')
plt.plot(iso.points['m_nirc2_J'] - iso.points['m_nirc2_Kp'], iso.points['m_nirc2_J'], 'c.')
plt.gca().invert_yaxis()
# *** Visual Inspections: ***
# - check that points (red) fall between isochrone points (blue)
##########
# Test with multiplicity
##########
multi = multiplicity.MultiplicityUnresolved()
my_imf2 = imf.IMF_broken_powerlaw(imf_mass_limits, imf_powers,
multiplicity=multi)
print('Constructed IMF with multiples: %d seconds' % (time.time() - startTime))
cluster2 = syn.ResolvedCluster(iso, my_imf2, cluster_mass)
clust2 = cluster2.star_systems
print('Constructed cluster with multiples: %d seconds' % (time.time() - startTime))
##########
# Plots
##########
# Plot an IR CMD and compare cluster members to isochrone.
plt.figure(1)
plt.clf()
plt.plot(clust1['m_nirc2_J'] - clust1['m_nirc2_Kp'], clust1['m_nirc2_J'], 'r.')
plt.plot(clust2['m_nirc2_J'] - clust2['m_nirc2_Kp'], clust2['m_nirc2_J'], 'b.')
plt.plot(iso.points['m_nirc2_J'] - iso.points['m_nirc2_Kp'], iso.points['m_nirc2_J'], 'c-')
plt.gca().invert_yaxis()
plt.xlabel('J - Kp (mag)')
plt.ylabel('J (mag')
# Plot a mass-magnitude relationship.
plt.figure(2)
plt.clf()
plt.semilogx(clust1['mass'], clust1['m_nirc2_J'], 'r.')
plt.semilogx(clust2['mass'], clust2['m_nirc2_J'], 'r.')
plt.gca().invert_yaxis()
plt.xlabel('Mass (Msun)')
plt.ylabel('J (mag)')
# # Plot the spectrum of the most massive star
# idx = cluster.mass.argmax()
# plt.clf()
# plt.plot(cluster.stars[idx].wave, cluster.stars[idx].flux, 'k.')
# # Plot an integrated spectrum of the whole cluster.
# wave, flux = cluster.get_integrated_spectrum()
# plt.clf()
# plt.plot(wave, flux, 'k.')
return
def multinest_run(root_dir='/Users/jlu/work/wd1/analysis_2015_01_05/',
data_tab='catalog_diffDered_NN_opt_10.fits',
comp_tab='completeness_ccmd.fits',
out_dir='multinest/fit_0001/'):
if not os.path.exists(root_dir + out_dir):
os.makedirs(root_dir + out_dir)
# Input the observed data
t = Table.read(root_dir + data_tab)
# Input the completeness table and bins.
completeness_map = pyfits.getdata(root_dir + comp_tab)
completeness_map = completeness_map.T
_in_bins = open(root_dir + comp_tab.replace('.fits', '_bins.pickle'), 'r')
bins_mag = pickle.load(_in_bins)
bins_col1 = pickle.load(_in_bins)
bins_col2 = pickle.load(_in_bins)
# Some components of our model are static.
imf_multi = multiplicity.MultiplicityUnresolved()
imf_mmin = 0.1 # msun
imf_mmax = 150.0 # msun
evo_model = evolution.MergedBaraffePisaEkstromParsec()
red_law = reddening.RedLawNishiyama09()
atm_func = atmospheres.get_merged_atmosphere
Mcl_sim = 5.0e6
# Our data vs. model comparison will be done in
# magnitude-color-color space. Models will be binned
# to construct 3D probability density spaces.
# These are the bin sizes for the models.
#
# Note Dimensions:
# mag = m_2010_F160W
# col1 = m_2005_F814W - m_2010_F160W
# col2 = m_2010_F125W - m_2010_F160W
#
bins = np.array([bins_mag, bins_col1, bins_col2])
def priors(cube, ndim, nparams):
return
def likelihood(cube, ndim, nparams):
##########
# Priors (I think order matters)
##########
parName = [
'distance', 'LogAge', 'AKs', 'dAKs', 'alpha1', 'alpha2', 'mbreak',
'Mcl'
]
par, par_prior_logp = get_prior_info(cube, parName)
sysMass = np.zeros(len(t))
##########
# Load up the model cluster.
##########
imf_mass_limits = np.array([imf_mmin, par['mbreak'], imf_mmax])
imf_powers = np.array([par['alpha2'], par['alpha1']])
imf_multi = None
new_imf = imf.IMF_broken_powerlaw(imf_mass_limits, imf_powers,
imf_multi)
print 'Getting Isochrone'
new_iso = synthetic.IsochronePhot(par['LogAge'],
par['AKs'],
par['distance'],
evo_model=evo_model,
atm_func=atm_func,
red_law=red_law)
print 'Getting Cluster'
cluster = synthetic.ResolvedClusterDiffRedden(new_iso,
new_imf,
Mcl_sim,
par['dAKs'],
red_law=red_law)
# Convert simulated cluster into agnitude-color-color histogram
mag = cluster.star_systems['mag160w']
col1 = cluster.star_systems['mag814w'] - mag
col2 = cluster.star_systems['mag125w'] - mag
data = np.array([mag, col1, col2]).T
bins = np.array([bins_mag, bins_col1, bins_col2])
H_sim_c, edges = np.histogramdd(data, bins=bins, normed=True)
H_sim = H_sim_c * completeness_map
# Convert Observed cluster into magnitude-color-color histogram
mag = t['m_2010_F160W']
col1 = t['m_2005_F814W'] - t['m_2010_F160W']
col2 = t['m_2010_F125W'] - t['m_2010_F160W']
data = np.array([mag, col1, col2]).T
bins = np.array([bins_mag, bins_col1, bins_col2])
H_obs, edges = np.histogramdd(data, bins=bins)
# Plotting
extent = (bins_col1[0], bins_col2[-1], bins_mag[0], bins_mag[-1])
py.figure(1)
py.clf()
py.imshow(H_sim_c.sum(axis=2), extent=extent)
py.gca().invert_yaxis()
py.colorbar()
py.axis('tight')
py.title('Sim Complete')
py.figure(2)
py.clf()
py.imshow(H_sim.sum(axis=2), extent=extent)
py.gca().invert_yaxis()
py.colorbar()
py.axis('tight')
py.title('Sim Incomplete')
py.figure(3)
py.clf()
py.imshow(H_obs.sum(axis=2), extent=extent)
py.gca().invert_yaxis()
py.colorbar()
py.axis('tight')
py.title('Obs Incomplete')
py.figure(4)
py.clf()
py.imshow(completeness_map.mean(axis=2), extent=extent, vmin=0, vmax=1)
py.gca().invert_yaxis()
py.colorbar()
py.axis('tight')
py.title('Completeness Map')
pdb.set_trace()
mcc_cluster = 1
print likei.sum()
return likei.sum()
num_dims = 8
num_params = 8
ev_tol = 0.3
samp_eff = 0.8
n_live_points = 300
# pymultinest.run(likelihood, priors, num_dims, n_params=num_params,
# outputfiles_basename=out_dir + 'test',
# verbose=True, resume=False, evidence_tolerance=ev_tol,
# sampling_efficiency=samp_eff, n_live_points=n_live_points,
# multimodal=True, n_clustering_params=num_dims)
cube_test = [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5]
likelihood(cube_test, num_dims, num_params)
