In [ ]:
from isochrones import StarModel, get_ichrone
In [ ]:
mist = get_ichrone('mist')
props = dict(Teff=(5800, 100), logg=(4.5, 0.1),
J=(3.58,0.05), K=(3.22, 0.05))
mod = StarModel(mist, **props)
In [ ]:
mod._bounds
In [ ]:
mod.bounds('age')
In [ ]:
mod.bounds('feh')
In [ ]:
mod._priors['feh'].bounds
In [ ]:
from isochrones.priors import feh_prior
In [ ]:
for i in range(1000):
feh_prior.test_integral()
In [ ]:
In [ ]:
from isochrones import get_ichrone
mist = get_ichrone('mist')
In [ ]:
mist.initialize()
In [ ]:
mist.get_eep(2.0499395202970088, 5.25942144066161, -2.7254562821409767)
In [ ]:
mist.interp_value([375, 9.55, -2.01], ['mass'])
In [ ]:
mist.interp_value([376, 9.55, -2.01], ['mass'])
In [ ]:
mist.model_grid.df.head()
In [ ]:
mist.model_grid.df.xs(-2.5, level=1).query('374 < eep < 378 and 9.5 <= age <= 9.6')
In [ ]:
mist.model_grid.df.xs((9.55, 376), level=(0, 2))
In [ ]:
mist.ages
In [ ]:
mist.model_grid
In [ ]:
mist.initial_mass(1200.76272583, 9.241634540264647, -2.5023077952677317)
In [ ]:
mist.interp_value([770, 9.1745, -3.55], ['mass'])
In [ ]:
eeps_to_try = (100, 800, 400)
In [ ]:
eeps_to_try.pop()
In [ ]:
eeps_to_try
In [ ]:
from isochrones import StarModel
In [ ]:
mod = StarModel(mist, logg=(4.44, 0.1), feh=(0.0, 0.1))
In [ ]:
mod.bands
In [ ]:
mod.obs.get_obs_nodes()
In [ ]:
mist.logg()
In [ ]:
mist.isochrone(9.6)
In [ ]:
mist.get_eep
In [ ]:
mist.model_grid.bounds
In [ ]:
mist.logg(700, 9.3, -0.03)
In [ ]:
mist.model_grid.df.sample(10)
In [ ]:
mist.model_grid.df.loc[(7.55, -1.75, 632)].logg
In [ ]:
from isochrones.priors import feh_prior
In [ ]:
feh_prior.test_integral()
In [ ]:
feh_prior.test_sampling()
In [ ]:
from isochrones.tests.test_ini import test_ini
test_ini()
In [ ]:
from isochrones import get_ichrone, StarModel
from isochrones.starmodel import BasicStarModel
mist = get_ichrone('mist')
In [ ]:
ls ../isochrones/tests
In [ ]:
from isochrones import BinaryStarModel
mod = BinaryStarModel.from_ini(mist, '../isochrones/tests/star2')
In [ ]:
mod.print_ascii()
In [ ]:
import os
for d in ['star1', 'star2', 'star3', 'star4']:
print(d)
mod = StarModel.from_ini(mist, os.path.join('..', 'isochrones', 'tests', d))
mod.print_ascii()
import numpy as np
print(np.isnan(mod.emcee_p0(10)).sum())
In [ ]:
from isochrones.mist import MIST_Isochrone
from isochrones import StarModel, get_ichrone
bands = ["B", "V", "J", "H", "K"]
mist = get_ichrone("mist", bands=bands)
In [ ]:
import pandas as pd
iso_params = pd.DataFrame(dict(Teff=(5770, 10), logg=(4.45, 0.05), B=(10, 0.02), V=(9.6, 0.02)))
mod = StarModel(mist, **iso_params)
pars = [300, 9.7, 0.0, 200, 0.1]
mod.lnlike(pars)
In [ ]:
mod.lnprior(pars)
In [ ]:
import holoviews as hv
import hvplot.pandas
hv.extension('bokeh')
In [ ]:
from isochrones import get_ichrone
iso = get_ichrone('mist')
track = get_ichrone('mist', tracks=True)
In [ ]:
iso.model_grid.interp_orig.grid.shape
In [ ]:
%timeit iso.model_grid.interp([9.76, 0.0, 320], ['logg'])
In [ ]:
%timeit iso.model_grid.interp_orig([9.76, 0.0, 320], ['max_conv_vel_div_csound'])
In [ ]:
import re
[print(c) for c in iso.model_grid.df_orig.columns if re.search('conv', c)]
In [ ]:
store.close()
In [ ]:
iso.model_grid.read_hdf(orig=True)
In [ ]:
import pandas as pd
store = pd.HDFStore(iso.model_grid.hdf_filename)
store
In [ ]:
store.keys()
In [ ]:
iso.model_grid
In [ ]:
In [ ]:
iso.model_grid.interp([300, 9.8, 0.0], ['conv_env_turnover_time_l_g'])
In [ ]:
iso.model_grid.df.head()
In [ ]:
bands = ['J', 'H', 'K', 'G','BP', 'RP', 'W1', 'W2', 'W3', 'IRAC_3.6', 'IRAC_4.5', 'IRAC_5.8', 'IRAC_8.0']
track = get_ichrone('mist', tracks=True, bands=bands)
In [ ]:
track.bc_grid.df.head()
In [ ]:
from isochrones.starmodel import BasicStarModel
In [ ]:
# mod = BasicStarModel(iso, Teff=(5700, 50), logg=(4.5, 0.08), J=(10, 0.01), eep_bounds=(200, 800))
mod = BasicStarModel(track, Teff=(5700, 50), logg=(4.5, 0.08), J=(10, 0.01), eep_bounds=(200, 800))
In [ ]:
cube = [0.01, 0.2, 0.5, 0.1, 0.1]
mod.mnest_prior(cube, 5, 5)
cube
In [ ]:
mod.mnest_loglike(cube, 5, 5)
In [ ]:
import intake
In [ ]:
cat = intake.open_fits_table('/Users/tdm/Downloads/spectrophotometric_parallax_HER2018.fits', ext=1)
In [ ]:
rgbs = cat.read()
In [ ]:
from astropy.io import fits
import pandas as pd
table = fits.getdata('/Users/tdm/Downloads/spectrophotometric_parallax_HER2018.fits')
In [ ]:
type(table)
In [ ]:
from astropy.table import Table
In [ ]:
rgbs = Table(table)
In [ ]:
columns = ['J', 'J_ERR', 'H', 'H_ERR', 'K', 'K_ERR', 'source_id2', 'ref_epoch', 'ra_1', 'ra_error_1', 'dec_1', 'dec_error_1',
'parallax', 'parallax_error', 'duplicated_source', 'phot_g_n_obs', 'phot_g_mean_flux', 'phot_g_mean_flux_error',
'phot_g_mean_flux_over_error', 'phot_g_mean_mag', 'phot_bp_n_obs', 'phot_bp_mean_flux', 'phot_bp_mean_flux_error',
'phot_bp_mean_flux_over_error', 'phot_bp_mean_mag', 'phot_rp_n_obs', 'phot_rp_mean_flux', 'phot_rp_mean_flux_error',
'phot_rp_mean_flux_over_error', 'phot_rp_mean_mag', 'IRAC_3_6', 'IRAC_3_6_ERR', 'IRAC_4_5', 'IRAC_4_5_ERR',
'IRAC_5_8', 'IRAC_5_8_ERR', 'IRAC_8_0', 'IRAC_8_0_ERR', 'w1mpro', 'w1mpro_error', 'w2mpro', 'w2mpro_error',
'w3mpro', 'w3mpro_error', 'w4mpro', 'w4mpro_error',]
rgb_df = rgbs[columns].to_pandas()
In [ ]:
ZP_G = 25.6914
ZP_BP = 25.3488
ZP_RP = 24.7627
G_flux = rgb_df['phot_g_mean_flux']
G_flux_unc = rgb_df['phot_g_mean_flux_error']
BP_flux = rgb_df['phot_bp_mean_flux']
BP_flux_unc = rgb_df['phot_bp_mean_flux_error']
RP_flux = rgb_df['phot_rp_mean_flux']
RP_flux_unc = rgb_df['phot_rp_mean_flux_error']
rgb_df['G'] = -2.5 * np.log10(G_flux) + ZP_G
rgb_df['BP'] = -2.5 * np.log10(BP_flux) + ZP_BP
rgb_df['RP'] = -2.5 * np.log10(RP_flux) + ZP_RP
In [ ]:
rgb_df[['parallax', 'parallax_error']].head(20)
In [ ]:
rgb_df.query('IRAC_8_0 > 0')
In [ ]:
rgbs[0]
In [ ]:
from isochrones.likelihood import star_lnlike, gauss_lnprob
In [ ]:
import numpy as np
import pandas as pd
from isochrones import StarModel
from isochrones.priors import (salpeter_prior, feh_prior, q_prior,
age_prior, distance_prior, AV_prior,
FlatPrior)
class BasicStarModel(StarModel):
use_emcee = False
def __init__(self, ic, eep_bounds=None, **kwargs):
self._ic = ic
self.eep_bounds = eep_bounds if eep_bounds is not None else self.ic.eep_bounds
self.kwargs = kwargs
self._bands = None
self._spec_props = None
self._props = None
self._param_names = None
self._priors = {'mass':salpeter_prior,
'feh':feh_prior,
'q':q_prior,
'age':age_prior,
'distance':distance_prior,
'AV':AV_prior,
'eep':FlatPrior(bounds=self.eep_bounds)}
self._bounds = {'mass':None,
'feh':None,
'age':None,
'q':q_prior.bounds,
'distance':distance_prior.bounds,
'AV':AV_prior.bounds,
'eep':self.eep_bounds}
if 'maxAV' in kwargs:
self.set_bounds(AV=(0, kwargs['maxAV']))
if 'max_distance' in kwargs:
self.set_bounds(distance=(0, kwargs['max_distance']))
self._directory = '.'
self._samples = None
self._derived_samples = None
@property
def param_names(self):
if self._param_names is None:
self._param_names = self.ic.param_names
return self._param_names
@property
def bands(self):
if self._bands is None:
self._bands = [k for k in self.kwargs if k in self.ic.bc_grid.bands]
return self._bands
@property
def props(self):
if self._props is None:
self._props = [k for k in self.kwargs if k in self._not_a_band]
return self._props
@property
def spec_props(self):
if self._spec_props is None:
self._spec_props = [self.kwargs.get(k, (np.nan, np.nan)) for k in ['Teff', 'logg', 'feh']]
return self._spec_props
def bounds(self, prop):
if self._bounds[prop] is not None:
return self._bounds[prop]
elif prop == 'mass':
lo, hi = self.ic.model_grid.get_limits('mass')
self._bounds['mass'] = (lo, hi)
self._priors['mass'].bounds = (lo, hi)
elif prop == 'feh':
lo, hi = self.ic.model_grid.get_limits('feh')
self._bounds['feh'] = (lo, hi)
self._priors['feh'].bounds = (lo, hi)
elif prop == 'age':
lo, hi = self.ic.model_grid.get_limits('age')
self._bounds['age'] = (lo, hi)
self._priors['age'].bounds = (lo, hi)
else:
raise ValueError('Unknown property {}'.format(prop))
return self._bounds[prop]
def set_bounds(self, **kwargs):
for k,v in kwargs.items():
if len(v) != 2:
raise ValueError('Must provide (min, max)')
self._bounds[k] = v
self._priors[k].bounds = v
@property
def n_params(self):
return 5
def lnlike(self, pars):
pars = np.array([pars[0], pars[1], pars[2], pars[3], pars[4]], dtype=float)
spec_vals, spec_uncs = zip(*[prop for prop in self.spec_props])
mag_vals, mag_uncs = zip(*[self.kwargs[b] for b in self.bands])
i_mags = [self.ic.bc_grid.interp.column_index[b] for b in self.bands]
lnlike = star_lnlike(pars, self.ic.param_index_order,
spec_vals, spec_uncs,
mag_vals, mag_uncs, i_mags,
self.ic.model_grid.interp.grid,
self.ic.model_grid.interp.column_index['Teff'],
self.ic.model_grid.interp.column_index['logg'],
self.ic.model_grid.interp.column_index['feh'],
self.ic.model_grid.interp.column_index['Mbol'],
*self.ic.model_grid.interp.index_columns,
self.ic.bc_grid.interp.grid,
*self.ic.bc_grid.interp.index_columns)
if 'parallax' in self.kwargs:
lnlike += gauss_lnprob(*self.kwargs['parallax'], 1000./pars[3])
return lnlike
def lnprior(self, pars):
lnp = 0
for val, par in zip(pars, self.param_names):
if par == 'eep':
orig_par = self.ic.eep_replaces
if orig_par == 'age':
deriv_prop = 'dt_deep'
elif orig_par == 'mass':
deriv_prop = 'dm_deep'
orig_val, dx_deep = self.ic.interp_value(pars, [orig_par, deriv_prop])
lnp += self._priors[orig_par].lnpdf(orig_val)
# print('{}: {}'.format(orig_par, lnp))
# Change of variables
lnp += np.log(np.abs(dx_deep))
# print('change of vars: {}'.format(lnp))
else:
lnp += self._priors[par].lnpdf(val)
# print('{}: {}'.format(par, lnp))
return lnp
def mnest_prior(self, cube, ndim, nparams):
for i, par in enumerate(self.param_names):
lo, hi = self.bounds(par)
cube[i] = (hi - lo)*cube[i] + lo
def mnest_loglike(self, cube, ndim, nparams):
"""loglikelihood function for multinest
"""
return self.lnpost(cube)
@property
def derived_samples(self):
if self._derived_samples is None:
self._make_samples()
return self._derived_samples
def _make_samples(self):
filename = '{}post_equal_weights.dat'.format(self.mnest_basename)
try:
df = pd.read_csv(filename, names=self.param_names + ('lnprob',), delim_whitespace=True)
except:
logging.error('Error loading chains from {}'.format(filename))
raise
self._samples = df
self._derived_samples = self.ic(*[df[c].values for c in self.param_names])
def sample_from_prior(self, n):
pars = []
for p in self.param_names:
samples = self._priors[p].sample(n)
pars.append(samples)
df = pd.DataFrame(np.array(pars).T, columns=self.param_names)
# Resample EEPs with proper weights
if self.ic.eep_replaces == 'age':
values = mod.ic.interp_value([df['mass'], df['eep'], df['feh']], ['dt_deep', 'age'])
dt_deep, age = [values[:, 0], values[:, 1]]
weights = np.log10(age)/np.log10(np.e) * dt_deep
df['eep'] = df['eep'].sample(n, weights=weights, replace=True).values
return df
In [ ]:
# mod = BasicStarModel(iso, Teff=(5700, 50), logg=(4.5, 0.08), J=(10, 0.01), eep_bounds=(200, 800))
mod = BasicStarModel(track, Teff=(5700, 50), logg=(4.5, 0.08), J=(10, 0.01), eep_bounds=(200, 800))
In [ ]:
from holoviews.operation.datashader import datashade
df = mod.sample_from_prior(1000)
hvplot.scatter_matrix(df, alpha=0.3)
In [ ]:
mod.fit(basename='test-bolo')
In [ ]:
mod.samples.describe()
In [ ]:
track(*[mod.samples[c].values for c in mod.param_names])
In [ ]:
# pars = np.array([320, 9.7, 0.0, 100, 0])
pars = np.array([1.0, 320, 0.0, 190, 0.4])
mod.lnlike(pars)
In [ ]:
%timeit mod.lnlike(pars)
In [ ]:
mod.lnprior(pars)
In [ ]:
%timeit mod.lnprior(pars)
In [ ]:
mod.lnpost(pars)
In [ ]:
%timeit mod.lnpost(pars)
In [ ]:
%load_ext line_profiler
In [ ]:
%lprun -f BasicStarModel.lnprior mod.lnprior(pars)
In [ ]:
In [ ]:
track.bc_grid.df.head()
In [ ]:
iso.interp_mag([330, 9.8, 0.0, 10, 0], ['G'])
In [ ]:
iso.interp_value([330, 9.8, 0.0], ['logg'])
In [ ]:
iso.model_grid.interp([9.8, 0.0, 325], ['logg'])
In [ ]:
iso.model_grid.interp.grid.shape
In [ ]:
subdf = iso.model_grid.df.xs((9.8, 0.0), level=(0, 1))
In [ ]:
subdf.query('320 < eep < 335')
In [ ]:
from isochrones.mist.models import MISTModelGrid, MISTIsochroneGrid
In [ ]:
df = MISTIsochroneGrid.to_df('/Users/tdm/.isochrones/mist/MIST_v1.2_vvcrit0.4_full_isos/MIST_v1.2_feh_p0.00_afe_p0.0_vvcrit0.4_full.iso')
In [ ]:
df.head()
In [ ]:
subdf = df.query('log10_isochrone_age_yr==9.8 and 325 < EEP < 350')
In [ ]:
subdf
In [ ]:
for e in subdf.EEP:
print(e)
In [ ]:
list(iso.model_grid.df.age.unique()).index(9.8)
In [ ]:
list(iso.model_grid.df.index.levels[0]).index(9.8)
In [ ]:
list(iso.model_grid.df.index.levels[1]).index(0.0)
In [ ]:
list(iso.model_grid.df.index.levels[2]).index(327)
In [ ]:
iso.model_grid.interp.grid.shape
In [ ]:
iso.model_grid.interp.grid[96, 12, 300:400, 9]
In [ ]:
iso.model_grid.df.head()
In [ ]:
list(iso.model_grid.df.initial_feh.unique()).index(0.0)
In [ ]:
iso.model_grid.interp
In [ ]:
%timeit track.interp_mag([0.6, 300, 0.0, 10, 0.12], ['G'])
In [ ]:
%load_ext line_profiler
In [ ]:
%timeit iso([300,350,400,450, 500] , 9.6, 0.0)
In [ ]:
from isochrones.models import ModelGridInterpolator
%lprun -f ModelGridInterpolator.__call__ iso([300,350,400,450, 500] , 9.6, 0.0)
In [ ]:
import numpy as np
import pandas as pd
a = np.arange(10)
b = a*10
pd.DataFrame(np.concatenate([np.atleast_2d(a), np.atleast_2d(b)], axis=1))
In [ ]:
iso.interp_mag([500, 9.6, 0., 10., 0.], iso.bc_grid.bands)
In [ ]:
iso.bc_grid.bands
In [ ]:
from isochrones.starmodel import StarModel
mod = StarModel(iso, Teff=(5700, 50), logg=(4.5, 0.1), feh=(0.01, 0.06), J=(10.3, 0.02), K=(10.0, 0.2), BP=(11, 0.01))
In [ ]:
pars = (300, 9.7, 0.0, 300, 0.1)
mod.lnprior(pars)
In [ ]:
mod.lnlike(pars, use_cache=False)
In [ ]:
%timeit mod.lnlike(pars, use_cache=False)
In [ ]:
%load_ext line_profiler
In [ ]:
from isochrones.observation import ObservationTree, ObsNode
%lprun -f StarModel.lnlike mod.lnlike(pars, use_cache=False)
In [ ]:
import numpy as np
np.array([[1,2,3]]).squeeze()
In [ ]:
n = mod.obs.get_obs_nodes()[0]
In [ ]:
m = n.leaves[0]
In [ ]:
m.label
In [ ]:
m.
In [ ]:
mod.obs.p2pardict(pars)
In [ ]:
bands = {n.band for n in mod.obs.get_obs_nodes()}
props = {k for v in mod.obs.spectroscopy.values() for k in v.keys()}
In [ ]:
props - {'Teff', 'logg', 'feh'}
In [ ]:
mod.obs.spectroscopy
In [ ]:
In [ ]:
iso.fehs
In [ ]:
eeps = [300., 350.]
In [ ]:
masses, dm_deeps = zip(*[iso.interp_value([eep, 9.5, -0.32], ['initial_mass', 'dm_deep']) for eep in eeps])
In [ ]:
masses
In [ ]:
dm_deeps
In [ ]:
x = [(i, i**2) for i in range(5)]
In [ ]:
a, b = zip(*[(i, i**2) for i in range(5)])
In [ ]:
a
In [ ]:
b
In [ ]:
import numpy as np
np.vstack(x)
In [ ]:
import numpy as np
pars = np.array([300., 9.5, -0.32, 400, 0.2])
# pars = [np.arange(250, 260, 0.5), 9.5, -0.32, 400., 0.2]
iso.interp_value(pars, ['initial_mass', 'dm_deep'])
In [ ]:
import numpy as np
pars = np.array([300., 9.5, -0.32, 400, 0.2])
# pars = [np.arange(250, 260, 0.5), 9.5, -0.32, 400., 0.2]
iso.interp_value(pars, ['initial_mass', 'dm_deep'])
In [ ]:
dict((('a', 1), ('b', 2)))
In [ ]:
iso.interp_mag(pars, ['G', 'BP', 'RP'])
In [ ]:
%timeit iso.interp_mag(pars, ['G', 'BP', 'RP'])
In [ ]:
%timeit iso.interp_mag(pars, ['G', 'BP', 'RP'])
In [ ]:
263 / len(pars[0])
In [ ]:
%timeit iso.interp_value(pars, ['radius'])
%timeit iso.interp_mag(pars, ['G', 'BP', 'RP'])
In [ ]:
pars2 = np.array([0.67, 300, -0.23, 500, 0.6])
pars2 = [np.arange(0.5, 1.0, 0.05), 300, -0.23, 500, 0.6]
track.interp_value(pars2, ['radius'])
In [ ]:
track.interp_mag(pars2, ['G', 'BP', 'RP'])
In [ ]:
In [ ]:
%timeit track.interp_value(pars2, ['radius'])
%timeit track.interp_mag(pars2, ['G', 'BP', 'RP'])
In [ ]:
ic = MISTIsochrone()
In [ ]:
pars = np.array([300., 9.5, 0.1, 200, 0.2])
bands = ['G', 'BP', 'RP']
ic.interp_mag(pars, bands)
In [ ]:
%timeit ic.interp_value(pars, ['logg', 'Teff'])
%timeit ic.interp_mag(pars, bands)
In [ ]:
ic2 = MISTIsochrone_Track()
In [ ]:
pars2 = np.array([1.01, 353, 0.11, 200, 0.2])
ic2.interp_mag(pars2, bands)
In [ ]:
%timeit ic2.interp_value(pars2, ['logg', 'Teff', 'feh'])
%timeit ic2.interp_mag(pars2, bands)
In [ ]:
%load_ext line_profiler
In [ ]:
%lprun -f MISTIsochrone.interp_value ic2.interp_value(pars2, ['logg', 'Teff', 'feh'])
In [ ]:
%timeit ic2.interp_value(pars2, ['logg', 'Teff'])
In [ ]:
mod = BasicStarModel(ic, Teff=(5700., 50.), logg=(4.44, 0.1), feh=(0.0, 0.1), G=(9.71, 0.01), BP=(9.85, 0.01))
In [ ]:
pars = np.array([300, 8.54, -0.4, 200., 0.1])
In [ ]:
mod.lnlike(pars)
In [ ]:
%timeit mod.lnlike(pars)
In [ ]:
mod.lnpost(pars)
In [ ]:
ic.model_grid.interp.column_index
In [ ]:
ic.model_grid.df.columns
In [ ]:
pars = np.array([8.54, -0.4, 300., 200., 0.1])
In [ ]:
%timeit ic.interp_mag(pars, ['G', 'BP', 'RP', 'J', 'H', 'K'])
In [ ]:
ic.bc_grid.bands
In [ ]:
%load_ext line_profiler
In [ ]:
%lprun -f ic.interp_mag ic.interp_mag(np.array([8.54, -0.4, 300., 200., 0.1]), ['G', 'BP'])
In [ ]:
ic.interp_mag(np.array([8.54, -0.4, 300., 200., 0.1]), ['G', 'BP'])
In [ ]:
from isochrones import StarModel as StarModelOld
from isochrones import get_ichrone
mist = get_ichrone('mist')
mod_old = StarModelOld(mist, Teff=(5700, 50), logg=(4.44, 0.1), G=(9.71, 0.01), BP=(9.85, 0.01))
In [ ]:
mod_old.lnlike([400, 9.6, 0.1, 200, 0.1])
In [ ]:
mod.bands
In [ ]:
mod.props
In [ ]:
mod.kwargs
In [ ]:
from isochrones.interp import find_indices_3d, find_indices, find_indices_4d
In [ ]:
col0 = ic.model_grid.interp.index_columns[0]
col1 = ic.model_grid.interp.index_columns[1]
col2 = ic.model_grid.interp.index_columns[2]
i1, d1, oob1 = find_indices([8.11, -1.1, 300.], ic.model_grid.interp.index_columns)
i2, d2, oob2 = find_indices_3d(8.11, -1.1, 300., col0, col1, col2)
assert (i1 == i2).all()
assert (d1 == d2).all()
assert oob1 == oob2
%timeit find_indices_3d(8.11, -1.1, 300., col0, col1, col2)
In [ ]:
col0 = ic.bc_grid.interp.index_columns[0]
col1 = ic.bc_grid.interp.index_columns[1]
col2 = ic.bc_grid.interp.index_columns[2]
col3 = ic.bc_grid.interp.index_columns[3]
i1, d1, oob1 = find_indices([5842., 4.34, 0.03, 0.42], ic.bc_grid.interp.index_columns)
i2, d2, oob2 = find_indices_4d(5842., 4.34, 0.03, 0.42, col0, col1, col2, col3)
assert (i1 == i2).all()
assert (d1 == d2).all()
assert oob1 == oob2
%timeit find_indices_4d(5842., 4.34, 0.03, 0.42, col0, col1, col2, col3)
In [ ]:
%timeit find_indices(np.array([5842., 4.34, 0.03, 0.42]), ic.bc_grid.interp.index_columns)
In [ ]:
%timeit find_indices(np.array([8.11, -1.1, 300]), ic.model_grid.interp.index_columns)
In [ ]:
In [ ]:
%load_ext line_profiler
In [ ]:
pars = np.array([8.11, -1.1, 300, 200, 0.])
bands = ['G', 'BP']
%timeit ic.interp_mag(pars, bands)
In [ ]:
%timeit ic.interp_value(pars, ['log_g', 'log_Teff', 'log_L'])
In [ ]:
%lprun -f ic.model_grid.interp.__call__ ic.interp_value(pars, ['log_g', 'log_Teff', 'log_L'])
In [ ]:
pars = np.array([8.11, -1.1, 300, 200, 0.])
bands = ['G', 'BP']
ic.interp_mag(pars, bands)
In [ ]:
%timeit ic.interp_value(pars, ['log_g'])
In [ ]:
pars = np.array([8.11, -1.1, 300, 200, 1.1])
ic.interp_mag(pars, bands)
In [ ]:
In [ ]:
In [ ]:
In [ ]:
ic.interp_value()
In [ ]:
mist.mag['G'](300., 8.11, -1.1, 200., 0.)
In [ ]:
mist.mag['G'](300., 8.11, -1.1, 200., 1.1)
In [ ]:
bc.df.columns
In [ ]:
%load_ext line_profiler
In [ ]:
%lprun -f ic.interp_mag ic.interp_mag(pars, bands)
In [ ]:
%timeit grid.interp([8.11, -1.1, 300.], ['log_L', 'initial_mass', 'star_mass', 'log_Teff'])
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [ ]:
grid.df.head()
In [ ]:
In [ ]:
len(grid.df)
In [ ]:
df = grid.df_all()
In [ ]:
df.head()
In [ ]:
In [ ]:
len(df)
In [ ]:
grid.get_existing_filenames()
In [ ]:
In [ ]:
In [ ]:
ls /Users/tdm/.isochrones/mist/MIST_v1.2_vvcrit0.0_full_isos/MIST_v1.2_feh_m0.25_afe_p0.0_vvcrit0.0_full.iso
In [ ]:
grid = MISTModelGrid()
In [ ]:
df.to
In [ ]:
df.head()
In [ ]:
grid.get_directory_path('full_isos')