예제 #1
0
def test_read_salt2_cov():
    fname = join(dirname(__file__), "data", "lc-03D4ag.list")
    data = sncosmo.read_lc(fname, format="salt2", read_covmat=True)
    assert data["Fluxcov"].shape == (len(data), len(data))
    assert_allclose(data["Fluxcov"][0:3, 0:3],
                    [[0.867712297284, 0.01139998771, 0.01119398747],
                     [0.01139998771, 2.03512047975, 0.01190299234],
                     [0.01119398747, 0.01190299234, 1.3663344852]])
예제 #2
0
def test_read_salt2_cov():
    fname = join(dirname(__file__), "data", "lc-03D4ag.list")
    data = sncosmo.read_lc(fname, format="salt2", read_covmat=True)
    assert data["Fluxcov"].shape == (len(data), len(data))
    assert_allclose(data["Fluxcov"][0:3, 0:3],
                    [[0.867712297284, 0.01139998771, 0.01119398747],
                     [0.01139998771, 2.03512047975, 0.01190299234],
                     [0.01119398747, 0.01190299234, 1.3663344852]])
예제 #3
0
def plot_testdata(nsne, under_model):

    if not os.path.exists("lcplots_%s"%(under_model.name(nsne))):
        os.mkdir("lcplots_%s"%(under_model.name(nsne)))

    fnames = glob("testdata_%s/*"%(under_model.name(nsne)))
    for fname in fnames:
        plotname = fname.replace("testdata_%s"%(under_model.name(nsne)), "lcplots_%s"%(under_model.name(nsne))).replace("dat", "png")
        data = sncosmo.read_lc(fname)
        sncosmo.plot_lc(data, fname=plotname)
예제 #4
0
def buildzdist(dirname):

    lclist = glob.glob(dirname + "/*")

    z = []
    for lcfile in lclist:
        lc = sncosmo.read_lc(lcfile)
        zval = lc.meta["z"]
        z.append(zval)
    return z
예제 #5
0
파일: test_io.py 프로젝트: tallamjr/sncosmo
def test_read_salt2_old():
    dname = join(dirname(__file__), "data", "SNLS3-04D3gx")
    data = sncosmo.read_lc(dname, format="salt2-old")

    # Test length and column names:
    assert len(data) == 25 + 37 + 38 + 18  # g + r + i + z lengths
    assert data.colnames == ["Date", "Flux", "Fluxerr", "ZP", "Filter",
                             "MagSys"]

    # Test a bit of metadata and data
    assert data.meta["NAME"] == "04D3gx"
    assert_allclose(data.meta["Redshift"], 0.91)
    assert_allclose(data.meta["RA"], 215.056948)
    assert np.all(data["MagSys"] == "VEGA")
예제 #6
0
def test_read_salt2_old():
    dname = join(dirname(__file__), "data", "SNLS3-04D3gx")
    data = sncosmo.read_lc(dname, format="salt2-old")

    # Test length and column names:
    assert len(data) == 25 + 37 + 38 + 18  # g + r + i + z lengths
    assert data.colnames == ["Date", "Flux", "Fluxerr", "ZP", "Filter",
                             "MagSys"]

    # Test a bit of metadata and data
    assert data.meta["NAME"] == "04D3gx"
    assert_allclose(data.meta["Redshift"], 0.91)
    assert_allclose(data.meta["RA"], 215.056948)
    assert np.all(data["MagSys"] == "VEGA")
예제 #7
0
파일: test_io.py 프로젝트: sofiatti/sncosmo
def test_read_salt2():
    fname = join(dirname(__file__), "data", "salt2_example.dat")
    data = sncosmo.read_lc(fname, format="salt2")

    # Test a few columns
    assert_allclose(data["Date"], [52816.54, 52824.59, 52795.59, 52796.59])
    assert_allclose(data["ZP"], [27.091335, 27.091335, 25.913054, 25.913054])
    assert np.all(data["Filter"] == np.array(
        ["MEGACAM::g", "MEGACAM::g", "MEGACAM::i", "MEGACAM::i"]))
    assert np.all(data["MagSys"] == "VEGA")

    # Test a bit of metadata
    assert_allclose(data.meta["Z_HELIO"], 0.285)
    assert_allclose(data.meta["RA"], 333.690959)
    assert data.meta["z_source"] == "H"
예제 #8
0
def test_read_salt2():
    fname = join(dirname(__file__), "data", "salt2_example.dat")
    data = sncosmo.read_lc(fname, format="salt2")

    # Test a few columns
    assert_allclose(data["Date"], [52816.54, 52824.59, 52795.59, 52796.59])
    assert_allclose(data["ZP"], [27.091335, 27.091335, 25.913054, 25.913054])
    assert np.all(data["Filter"] == np.array(["MEGACAM::g", "MEGACAM::g",
                                              "MEGACAM::i", "MEGACAM::i"]))
    assert np.all(data["MagSys"] == "VEGA")

    # Test a bit of metadata
    assert_allclose(data.meta["Z_HELIO"], 0.285)
    assert_allclose(data.meta["RA"], 333.690959)
    assert data.meta["z_source"] == "H"
예제 #9
0
def test_read_salt2():
    fname = join(dirname(__file__), "data", "lc-03D4ag.list")
    data = sncosmo.read_lc(fname, format="salt2")

    # Test a few columns
    assert_allclose(data["Date"][0:4], [52816.54, 52824.59, 52851.53, 52873.4])
    assert_allclose(data["ZP"][0:4], 27.036167)

    assert np.all(data["Filter"][0:4] == "MEGACAMPSF::g")
    assert np.all(data["MagSys"] == "AB_B12")

    # Test a bit of metadata
    assert_allclose(data.meta["Z_HELIO"], 0.285)
    assert_allclose(data.meta["RA"], 333.690959)
    assert data.meta["z_source"] == "H"
예제 #10
0
def test_read_salt2():
    fname = join(dirname(__file__), "data", "lc-03D4ag.list")
    data = sncosmo.read_lc(fname, format="salt2")

    # Test a few columns
    assert_allclose(data["Date"][0:4],
                    [52816.54, 52824.59, 52851.53, 52873.4])
    assert_allclose(data["ZP"][0:4], 27.036167)

    assert np.all(data["Filter"][0:4] == "MEGACAMPSF::g")
    assert np.all(data["MagSys"] == "AB_B12")

    # Test a bit of metadata
    assert_allclose(data.meta["Z_HELIO"], 0.285)
    assert_allclose(data.meta["RA"], 333.690959)
    assert data.meta["z_source"] == "H"
예제 #11
0
def test_roundtripping():
    for format in ['json', 'ascii', 'salt2']:
        f = NamedTemporaryFile(delete=False)
        f.close()  # close to ensure that we can open it in write_lc()

        # raw=True is for the benefit of salt2 writer that modifies column
        # and header names by default.
        sncosmo.write_lc(lcdata, f.name, format=format, raw=True,
                         pedantic=False)
        data = sncosmo.read_lc(f.name, format=format)

        for key in lcdata.colnames:
            assert np.all(data[key] == lcdata[key])
        for key in lcdata.meta:
            assert data.meta[key] == lcdata.meta[key]

        os.unlink(f.name)
예제 #12
0
    def fromSALTFormat(cls, fname):
        _lc = sncosmo.read_lc(fname, format='salt2')
        lc = _lc.to_pandas()
        lc.MagSys = 'ab'

        def filtername(x):
            if 'megacam' in x.lower():
                return 'megacam'
            else:
                return x[:-3].lower()

        banddict = dict((key.lower(), filtername(key) + key[-1])
                        for key in lc.Filter.unique())
        return cls(lc,
                   bandNameDict=banddict,
                   ignore_case=True,
                   propDict=_lc.meta)
예제 #13
0
파일: test_io.py 프로젝트: tallamjr/sncosmo
def test_roundtripping():
    for format in ['json', 'ascii', 'salt2']:
        f = NamedTemporaryFile(delete=False)
        f.close()  # close to ensure that we can open it in write_lc()

        # raw=True is for the benefit of salt2 writer that modifies column
        # and header names by default.
        sncosmo.write_lc(lcdata, f.name, format=format, raw=True,
                         pedantic=False)
        data = sncosmo.read_lc(f.name, format=format)

        for key in lcdata.colnames:
            assert np.all(data[key] == lcdata[key])
        for key in lcdata.meta:
            assert data.meta[key] == lcdata.meta[key]

        os.unlink(f.name)
예제 #14
0
def test_read_lc():
    f = StringIO("""
@id 1
@RA 36.0
@description good
time band flux fluxerr zp zpsys
50000. g 1. 0.1 25. ab
50000.1 r 2. 0.1 25. ab
""")
    t = sncosmo.read_lc(f, format='ascii')
    assert str(t) == ("  time  band flux fluxerr  zp  zpsys\n"
                      "------- ---- ---- ------- ---- -----\n"
                      "50000.0    g  1.0     0.1 25.0    ab\n"
                      "50000.1    r  2.0     0.1 25.0    ab")
    assert t.meta['id'] == 1
    assert t.meta['RA'] == 36.0
    assert t.meta['description'] == 'good'
예제 #15
0
def test_read_lc():
    from astropy.extern.six import StringIO
    f = StringIO("""
@id 1
@RA 36.0
@description good
time band flux fluxerr zp zpsys
50000. g 1. 0.1 25. ab
50000.1 r 2. 0.1 25. ab
""")
    t = sncosmo.read_lc(f, format='ascii')
    assert str(t) == ("  time  band flux fluxerr  zp  zpsys\n"
                      "------- ---- ---- ------- ---- -----\n"
                      "50000.0    g  1.0     0.1 25.0    ab\n"
                      "50000.1    r  2.0     0.1 25.0    ab")
    assert t.meta['id'] == 1
    assert t.meta['RA'] == 36.0
    assert t.meta['description'] == 'good'
예제 #16
0
def importance_sampling(nsne, under_model):
    # sampler parameters
    ndim = under_model.dim
    nwalkers = 20
    nburn = 200
    nsamples = 500

    # Read all SN redshifts and previously-generated parameter samples
    snsamples = []
    for fname in sorted(glob("testdata_%s/*" % (under_model.name(nsne)))):
        z = sncosmo.read_lc(fname).meta['z']  # load whole file just to get 'z'
        sfname = fname.replace(
            "testdata_%s" % (under_model.name(nsne)),
            "samples_%s" % (under_model.name(nsne))).replace(".dat", ".npy")
        samples = np.load(sfname)
        snsamples.append((z, samples))

    # Create sampler
    sampler = emcee.EnsembleSampler(nwalkers,
                                    ndim,
                                    under_model.lnlike,
                                    args=(snsamples, ))

    # Starting positions
    errors = under_model.initial * 0.01
    pos = np.array([
        under_model.initial + errors * np.random.randn(ndim)
        for i in range(nwalkers)
    ])

    # burn-in
    pos, prob, state = sampler.run_mcmc(pos, nburn)
    print("Burn in done")

    # production run
    sampler.reset()
    sampler.run_mcmc(pos, nsamples)
    print("Avg acceptance fraction:", np.mean(sampler.acceptance_fraction))

    results = sampler.flatchain
    np.save(
        "samples_%s/globalsamples_%s.npy" %
        (under_model.name(nsne), under_model.name(nsne)), results)
예제 #17
0
def test_fit_lc_vs_snfit():
    """Test fit_lc versus snfit result for one SN."""

    # purposefully use CCM dust to match snfit
    model = sncosmo.Model(source='salt2',
                          effects=[sncosmo.CCM89Dust()],
                          effect_names=['mw'],
                          effect_frames=['obs'])

    fname = join(dirname(__file__), "data", "lc-03D4ag.list")

    data = sncosmo.read_lc(fname,
                           format='salt2',
                           read_covmat=True,
                           expand_bands=True)
    model.set(mwebv=data.meta['MWEBV'], z=data.meta['Z_HELIO'])
    result, fitted_model = sncosmo.fit_lc(data,
                                          model, ['t0', 'x0', 'x1', 'c'],
                                          bounds={
                                              'x1': (-3., 3.),
                                              'c': (-0.4, 0.4)
                                          },
                                          modelcov=True,
                                          phase_range=(-15., 45.),
                                          wave_range=(3000., 7000.),
                                          warn=False,
                                          verbose=False)

    print(result)
    assert result.ndof == 25
    assert result.nfit == 3
    assert_allclose(fitted_model['t0'], 52830.9313, atol=0.01, rtol=0.)
    assert_allclose(fitted_model['x0'], 5.6578663e-05, atol=0., rtol=0.005)
    assert_allclose(fitted_model['x1'], 0.937399344, atol=0.005, rtol=0.)
    assert_allclose(fitted_model['c'], -0.0851965244, atol=0.001, rtol=0.)

    # errors
    assert_allclose(result.errors['t0'], 0.0955792638, atol=0., rtol=0.01)
    assert_allclose(result.errors['x0'], 1.52745001e-06, atol=0., rtol=0.01)
    assert_allclose(result.errors['x1'], 0.104657847, atol=0., rtol=0.01)
    assert_allclose(result.errors['c'], 0.0234763446, atol=0., rtol=0.01)
예제 #18
0
def test_fit_lc_vs_snfit():
    """Test fit_lc versus snfit result for one SN."""

    # purposefully use CCM dust to match snfit
    model = sncosmo.Model(source='salt2',
                          effects=[sncosmo.CCM89Dust()],
                          effect_names=['mw'],
                          effect_frames=['obs'])

    fname = join(dirname(__file__), "data", "lc-03D4ag.list")

    data = sncosmo.read_lc(fname, format='salt2', read_covmat=True,
                           expand_bands=True)
    model.set(mwebv=data.meta['MWEBV'], z=data.meta['Z_HELIO'])
    result, fitted_model = sncosmo.fit_lc(
        data, model, ['t0', 'x0', 'x1', 'c'],
        bounds={'x1': (-3., 3.), 'c': (-0.4, 0.4)},
        modelcov=True,
        phase_range=(-15., 45.),
        wave_range=(3000., 7000.),
        warn=False,
        verbose=False)

    print(result)
    assert result.ndof == 25
    assert result.nfit == 3
    assert_allclose(fitted_model['t0'], 52830.9313, atol=0.01, rtol=0.)
    assert_allclose(fitted_model['x0'], 5.6578663e-05, atol=0., rtol=0.005)
    assert_allclose(fitted_model['x1'], 0.937399344, atol=0.005, rtol=0.)
    assert_allclose(fitted_model['c'], -0.0851965244, atol=0.001, rtol=0.)

    # errors
    assert_allclose(result.errors['t0'], 0.0955792638, atol=0., rtol=0.01)
    assert_allclose(result.errors['x0'], 1.52745001e-06, atol=0., rtol=0.01)
    assert_allclose(result.errors['x1'], 0.104657847, atol=0., rtol=0.01)
    assert_allclose(result.errors['c'], 0.0234763446, atol=0., rtol=0.01)
예제 #19
0
import matplotlib 
matplotlib.use('Agg')
from copy import copy
import sncosmo
import numpy as np
from bolomc import bump
from bolomc import burns
from bolomc.distributions import TruncNorm

lc = sncosmo.read_lc('../data/CSP_Photometry_DR2/SN2005elopt+nir_photo.dat', format='csp')

model = sncosmo.Model(bump.BumpSource(),
                      effect_names=['host','mw'],
                      effect_frames=['rest','obs'],
                      effects=[sncosmo.OD94Dust(), sncosmo.F99Dust()])

model2 = copy(model)
model2.set(UV_bump_amp=1.,#blue_bump_amp=0.2,
           blue_bump_amp=-0.2, 
           i1_bump_amp=0.1,
           i2_bump_amp=-0.2,
           y1_bump_amp=-0.2, 
           y2_bump_amp=0.2,
           y3_bump_amp=-0.1,
           j1_bump_amp=-0.2, 
           j2_bump_amp=0.2,
           h1_bump_amp=-0.2, 
           h2_bump_amp=0.2,
           k1_bump_amp=-0.2, 
           k2_bump_amp=0.2)
예제 #20
0
import sncosmo
import os
import corner
import copy
import filters

from scipy.stats import chi2
from scipy.integrate import quad
phot_d = None
###########################################################################
# DATA
sn = '16geu'  # ground data
fname = '%s_clean.dat' % (sn)  # Cleaned light curve

##############################################################################
phot_d = sncosmo.read_lc(fname)  # read the ground data
phot_d['imageid'] = 0  # ground data have imageid = 0!
errfloor = 0.0
##############################################################################
# Here the error bars of the grond data can be adjusted.
lenserr = 0.00  # set to 0.05 when using gravlens model
#phot_d['fluxerr'] = np.sqrt(phot_d['fluxerr']**2+(phot_d['flux']*lenserr)**2)

phot_d['fluxerr'] = np.sqrt((phot_d['flux'] * errfloor)**2 +
                            (phot_d['fluxerr'])**2)  # scale error bars
errfloor = 0.08
##############################################################################
# Set up the data of the HST to be read in
sumdata = False
lcfname = {  # the names of the data files
    'uvf625w': 'lc_uvf625w_resolved.csv',
예제 #21
0
def task(filename, i, j, nrv, nebv, kind='mcmc'):
    
    lc = sncosmo.read_lc(filename, format='csp')

    model = sncosmo.Model(bump.BumpSource(),
                          effect_names=['host','mw'],
                          effect_frames=['rest','obs'],
                          effects=[sncosmo.OD94Dust(), sncosmo.F99Dust()])

    rv_prior = burns.get_hostrv_prior(lc.meta['name'], 
                                      'gmm', sncosmo.OD94Dust)

    host_ebv, err = burns.get_hostebv(lc.meta['name'])
    ebv_prior = TruncNorm(-np.inf, np.inf, host_ebv, err)

    rv_prior, low, high = burns.get_hostrv_prior(lc.meta['name'], 
                                                 'gmm', sncosmo.OD94Dust,
                                                 retlims=True)
    host_ebv, err = burns.get_hostebv(lc.meta['name'])
    
    rv = np.linspace(low if low >= 0 else 0, high, nrv)[i]
    ebvlo = host_ebv - err
    ebvhi = host_ebv + err
    ebv = np.linspace(ebvlo if ebvlo >= 0 else 0, ebvhi, nebv)[j]

    model.set(z=lc.meta['zcmb'])
    model.set(mwebv=burns.get_mwebv(lc.meta['name'])[0])
    model.set(hostebv=ebv)
    model.set(hostr_v=rv)
    model.set(t0=burns.get_t0(lc.meta['name']))

    vparams = filter(lambda x: 'bump' in x, model._param_names)
    vparams += ['t0', 's']
    bounds = {b.name + "_bump_amp":(-1,2) for b in 
                                     model.source.bumps}
    #bounds['hostr_v'] = (rv_prior.mean - 0.5, rv_prior.mean + 0.5)
    #bounds['hostebv'] = (0, 0.2)
    bounds['s'] = (0, 3.)

    res, model = sncosmo.fit_lc(lc,model,['amplitude']+vparams,
                                bounds=bounds)

    bounds['t0'] = (model.get('t0')-2, model.get('t0')+2)
    
    vparams.append('amplitude')
    bounds['amplitude'] = (0.5 * model.get('amplitude'),
                           2 * model.get('amplitude'))

    qualifier = '_ebv_%.2f_rv_%.2f' % (ebv, rv)

    if kind != 'fit':
        if kind == 'mcmc':
            result = sncosmo.mcmc_lc(lc, model, vparams,
                                     bounds=bounds,
                                     nwalkers=500,
                                     nburn=1000,
                                     nsamples=20)
        elif kind == 'nest':
            result = sncosmo.nest_lc(lc, model, vparams, bounds=bounds,
                                     method='multi', npoints=800)

        samples = result[0].samples.reshape(500, 20, -1)
        vparams = result[0].vparam_names
        plot_arg = np.rollaxis(samples, 2)

        plotting.plot_chains(plot_arg, param_names=vparams, 
                             filename='fits/%s_samples%s.pdf' % (lc.meta['name'], qualifier))

        dicts = [dict(zip(vparams, samp)) for samp in samples.reshape(500 * 20, -1)]
        thinned = samples.reshape(500, 20, -1)[:, [0, -1]].reshape(1000, -1)

        pickle.dump(samples, open('fits/%s_samples%s.pkl' % (lc.meta['name'], qualifier), 'wb'))

        models = [copy(result[1]) for i in range(len(thinned))]
        for d, m in zip(dicts, models):
            m.set(**d)

        fig = sncosmo.plot_lc(data=lc, model=models, ci=(50-68/2., 50., 50+68/2.),
                              model_label=lc.meta['name'])
        fig.savefig('fits/%s%s.pdf' % (lc.meta['name'], qualifier))
        
    else:
        
        fitres, model = sncosmo.fit_lc(lc, model, vparams, bounds=bounds)
        fig = sncosmo.plot_lc(data=lc, model=model)
        fig.savefig('fits/%s_fit%s.pdf' % (lc.meta['name'], qualifier))
예제 #22
0
def nonvparams(snname):
    lc = sncosmo.read_lc('../data/CSP_Photometry_DR2/%sopt+nir_photo.dat' % snname,
                         format='csp')
    z = lc.meta['zcmb']
    mwebv, _ = burns.get_mwebv(snname)
    return {'z':z, 'mwebv':mwebv}
예제 #23
0
def task(filename, i, j, nrv, nebv, kind='mcmc'):

    lc = sncosmo.read_lc(filename, format='csp')

    model = sncosmo.Model(bump.BumpSource(),
                          effect_names=['host', 'mw'],
                          effect_frames=['rest', 'obs'],
                          effects=[sncosmo.OD94Dust(),
                                   sncosmo.F99Dust()])

    rv_prior = burns.get_hostrv_prior(lc.meta['name'], 'gmm', sncosmo.OD94Dust)

    host_ebv, err = burns.get_hostebv(lc.meta['name'])
    ebv_prior = TruncNorm(-np.inf, np.inf, host_ebv, err)

    rv_prior, low, high = burns.get_hostrv_prior(lc.meta['name'],
                                                 'gmm',
                                                 sncosmo.OD94Dust,
                                                 retlims=True)
    host_ebv, err = burns.get_hostebv(lc.meta['name'])

    rv = np.linspace(low if low >= 0 else 0, high, nrv)[i]
    ebvlo = host_ebv - err
    ebvhi = host_ebv + err
    ebv = np.linspace(ebvlo if ebvlo >= 0 else 0, ebvhi, nebv)[j]

    model.set(z=lc.meta['zcmb'])
    model.set(mwebv=burns.get_mwebv(lc.meta['name'])[0])
    model.set(hostebv=ebv)
    model.set(hostr_v=rv)
    model.set(t0=burns.get_t0(lc.meta['name']))

    vparams = filter(lambda x: 'bump' in x, model._param_names)
    vparams += ['t0', 's']
    bounds = {b.name + "_bump_amp": (-1, 2) for b in model.source.bumps}
    #bounds['hostr_v'] = (rv_prior.mean - 0.5, rv_prior.mean + 0.5)
    #bounds['hostebv'] = (0, 0.2)
    bounds['s'] = (0, 3.)

    res, model = sncosmo.fit_lc(lc,
                                model, ['amplitude'] + vparams,
                                bounds=bounds)

    bounds['t0'] = (model.get('t0') - 2, model.get('t0') + 2)

    vparams.append('amplitude')
    bounds['amplitude'] = (0.5 * model.get('amplitude'),
                           2 * model.get('amplitude'))

    qualifier = '_ebv_%.2f_rv_%.2f' % (ebv, rv)

    if kind != 'fit':
        if kind == 'mcmc':
            result = sncosmo.mcmc_lc(lc,
                                     model,
                                     vparams,
                                     bounds=bounds,
                                     nwalkers=500,
                                     nburn=1000,
                                     nsamples=20)
        elif kind == 'nest':
            result = sncosmo.nest_lc(lc,
                                     model,
                                     vparams,
                                     bounds=bounds,
                                     method='multi',
                                     npoints=800)

        samples = result[0].samples.reshape(500, 20, -1)
        vparams = result[0].vparam_names
        plot_arg = np.rollaxis(samples, 2)

        plotting.plot_chains(plot_arg,
                             param_names=vparams,
                             filename='fits/%s_samples%s.pdf' %
                             (lc.meta['name'], qualifier))

        dicts = [
            dict(zip(vparams, samp)) for samp in samples.reshape(500 * 20, -1)
        ]
        thinned = samples.reshape(500, 20, -1)[:, [0, -1]].reshape(1000, -1)

        pickle.dump(
            samples,
            open('fits/%s_samples%s.pkl' % (lc.meta['name'], qualifier), 'wb'))

        models = [copy(result[1]) for i in range(len(thinned))]
        for d, m in zip(dicts, models):
            m.set(**d)

        fig = sncosmo.plot_lc(data=lc,
                              model=models,
                              ci=(50 - 68 / 2., 50., 50 + 68 / 2.),
                              model_label=lc.meta['name'])
        fig.savefig('fits/%s%s.pdf' % (lc.meta['name'], qualifier))

    else:

        fitres, model = sncosmo.fit_lc(lc, model, vparams, bounds=bounds)
        fig = sncosmo.plot_lc(data=lc, model=model)
        fig.savefig('fits/%s_fit%s.pdf' % (lc.meta['name'], qualifier))
예제 #24
0
         np.float64, np.float64, np.float64, np.float64, np.float64,
         np.float64, np.float64, np.float64, np.float64, np.float64,
         np.float64, np.float64, np.float64, np.float64, np.float64,
         np.float64, np.float64, np.float64, np.float64, np.float64,
         np.float64, np.float64, np.float64, np.float64, np.float64,
         np.float64, np.float64, np.float64, np.float64, np.float64,
         np.float64, np.float64, np.float64, np.float64, np.float64,
         np.float64, np.float64, np.float64, np.float64, np.float64,
         np.float64, np.float64, np.float64, np.float64, np.float64,
         np.float64, np.float64, np.float64, np.float64, np.float64,
         np.float64)
outdata = astropy.table.Table(masked=True, names=names, dtype=dtype)
for i, lc in enumerate(lcfile):
    #################################################################################
    if args.jla:
        data = sncosmo.read_lc(lc, format='salt2')
        nickname = data.meta['SN']
    if args.cadencesim:
        data = sncosmo.read_lc(lc, format='ascii')
        nickname = lc.split('.')[0].split('/')[-1]
    #################################################################################

    try:
        nickname = str(int(nickname))
    except:
        pass
    #################################################################################
    if args.jla:
        fitfile = './fit_results/emcee/JLA/%s/%s.dat' % (nickname, nickname)
    if args.cadencesim:
        fitfile = './fit_results/emcee/cadencesim/%s/%s.dat' % (nickname,
예제 #25
0
파일: init_fit2.py 프로젝트: srodney/snsed
        return (_snFit(args))
    except:
        return (None)


files = glob.glob('*clipped.dat')
zpMag = sncosmo.get_magsystem('Vega')
sne = []
times = []
#plt.figure()
for f in files:
    if f not in ['lc_2009kn_clipped.dat', 'lc_2010bq_clipped.dat']:
        continue
    print(f)
    t0 = 0
    lc = sncosmo.read_lc(f)
    f = f[:-8]
    if len(lc[lc['Band'] == 'U']) == 0 and len(
            lc[lc['Band'] == 'u']) == 0 and len(lc[lc['Band'] == 'J']) == 0:
        #os.remove(f)
        continue

    lc = lc[lc['Band'] != 'U']
    lc = lc[lc['Band'] != 'u']
    lc = lc[lc['Band'] != 'H']
    lc = lc[lc['Band'] != 'J']
    lc = lc[lc['Band'] != 'K']
    lc = lc[lc['Band'] != 'i']
    lc = lc[lc['Band'] != 'I']
    if not lc:
        #os.remove(f)
예제 #26
0
    figname = (fname.replace("testdata", "lcplots")
               .replace(".dat", "_lcfit.png"))
    model.parameters[1:5] = showparams
    sncosmo.plot_lc(data, model, fname=figname)

    labels = ["${0}$".format(s) for s in model.param_names_latex[1:5]]
    fig = triangle.corner(samples, labels=labels, bins=30)
    figname = (fname.replace("testdata", "lcplots")
               .replace(".dat", "_corner.png"))
    plt.savefig(figname)
"""
# Get data from all SNe
data_list = []
for fname in fnames[:n_obs]:

    data = sncosmo.read_lc(fname)
    data_list.append(data)

# Do MCMC:
all_samples = sample_all(data_list)
np.savetxt('emcee_samples.dat', all_samples)
all_params = np.average(all_samples, axis=0)

# Make plots of best fit global parameters and histograms of best fit
# parameters for each supernova:
labels = ['Omega', 'x0_0', 'alpha', 'beta']
fig = triangle.corner(all_samples[:, :4], labels=labels, bins=30)
plt.savefig('global_params_%ssne.png' % n_obs)

fig2, axes = plt.subplots(2, 2)
titles = ['t0', 'sigma', 'x1', 'c']
예제 #27
0
rank = comm.Get_rank()
size = comm.Get_size()

# partition an iterable i into n parts
_split = lambda i,n: [i[:len(i)/n]]+_split(i[len(i)/n:],n-1) if n != 0 else []

# Shorthand for a few variables with long names.
od94 = sncosmo.OD94Dust
f99 = sncosmo.F99Dust

# Load the run configuration file. 
config_filename = sys.argv[1]
config = yaml.load(open(config_filename).read())

# Read the LC to fit. 
lc = sncosmo.read_lc(config['lc_filename'], format='csp')
name = lc.meta['name']

# Configure the properties of the host galaxy dust.
dust_type = od94 if config['dust_type'] == 'od94' else f99
bintype = config['burns_bintype']

# Get the host galaxy dust data.
host_ebv, err = burns.get_hostebv(name)
_, rv_low, rv_hi = burns.get_hostrv_prior(name, bintype, dust_type,
                                          retlims=True)
ebvlo = host_ebv - err
ebvhi = host_ebv + err

# Do ebv / r_v gridding. 
nrv = config['nrv']
예제 #28
0
import matplotlib

matplotlib.use('Agg')
from copy import copy
import sncosmo
import numpy as np
from bolomc import bump
from bolomc import burns
from bolomc.distributions import TruncNorm

lc = sncosmo.read_lc('../data/CSP_Photometry_DR2/SN2005elopt+nir_photo.dat',
                     format='csp')

model = sncosmo.Model(bump.BumpSource(),
                      effect_names=['host', 'mw'],
                      effect_frames=['rest', 'obs'],
                      effects=[sncosmo.OD94Dust(),
                               sncosmo.F99Dust()])

model2 = copy(model)
model2.set(
    UV_bump_amp=1.,  #blue_bump_amp=0.2,
    blue_bump_amp=-0.2,
    i1_bump_amp=0.1,
    i2_bump_amp=-0.2,
    y1_bump_amp=-0.2,
    y2_bump_amp=0.2,
    y3_bump_amp=-0.1,
    j1_bump_amp=-0.2,
    j2_bump_amp=0.2,
    h1_bump_amp=-0.2,
예제 #29
0
def load_example_lcs():
    return ([
        _standardize(sncosmo.read_lc(f)) for f in glob.glob(
            os.path.join(__dir__, 'example_setup', 'lcs', '*.lc'))
    ])
예제 #30
0
from astropy.table import Table
import numpy as np
import glob
from IPython import embed
import sys

sne = glob.glob('./lc/*.list')

names = ['SN', 'tmax', 'color', 'x1r', 'x1f', 'mB', 'mwebv']
dtype = [
    'S50', np.float64, np.float64, np.float64, np.float64, np.float64,
    np.float64
]
t = Table(names=names, dtype=dtype)

for i, sn in enumerate(sne):
    data = sncosmo.read_lc(sn, format='salt2')
    daymax = data.meta['DAYMAX']
    x1r = data.meta['X1R']
    x1f = data.meta['X1F']
    c = data.meta['C']
    mB = data.meta['MB']
    name = sn.split('.')[-2].split('/')[-1]
    mwebv = data.meta['MWEBV']
    t.add_row([name, daymax, c, x1r, x1f, mB, mwebv])

t.write('./cadence_sim_inputs.txt',
        format='ascii.fixed_width',
        delimiter=' ',
        overwrite=True)
예제 #31
0
def sample_lcs(nsne, under_model):

    if not os.path.exists("samples_%s" % (under_model.name(nsne))):
        os.mkdir("samples_%s" % (under_model.name(nsne)))

    # sampler parameters
    ndim = 4
    nwalkers = 20
    nburn = 100
    nsamples = 500
    thin = 10

    # define likelihood
    model = sncosmo.Model(source='salt2-extended')

    bounds = {
        0: (-20., 40.),  # t0
        2: (-4., 4.),  # x1
        3: (-0.4, 0.4)
    }

    def lnlike(parameters, data):
        """Return log L for array of parameters."""

        # If any parameters are out-of-bounds, return 0 probability.
        for i, b in bounds.items():
            if not b[0] < parameters[i] < b[1]:
                return -np.inf

        model.parameters[1:5] = parameters  # set model t0, x0, x1, c
        mflux = model.bandflux(data['band'],
                               data['time'],
                               zp=data['zp'],
                               zpsys=data['zpsys'])
        chisq = np.sum(((data['flux'] - mflux) / data['fluxerr'])**2)
        return -chisq / 2.

    def sample(data):
        """Return MCMC samples for model defined above."""

        # fix redshift in the model
        model.set(z=data.meta['z'])

        # Create sampler
        sampler = emcee.EnsembleSampler(nwalkers,
                                        ndim,
                                        lnlike,
                                        args=(data, ),
                                        a=3.50)

        # Starting positions of walkers.
        # Here we cheat by setting the "guess" equal to the known true parameters!
        current = np.array([
            data.meta['t0'], data.meta['x0'], data.meta['x1'], data.meta['c']
        ])
        errors = np.array([1., 0.1 * data.meta['x0'], 1., 0.1])
        pos = [
            current + errors * np.random.randn(ndim) for i in range(nwalkers)
        ]

        # burn-in
        pos, prob, state = sampler.run_mcmc(pos, nburn)
        sampler.reset()

        # production run
        sampler.run_mcmc(pos, nsamples, thin=thin)
        print("Avg acceptance fraction:", np.mean(sampler.acceptance_fraction))

        return sampler.flatchain

    fnames = sorted(glob("testdata_%s/*" % (under_model.name(nsne))))
    for fname in fnames:

        print("processing", fname)

        # read data, run sampler on it, save samples
        data = sncosmo.read_lc(fname)
        samples = sample(data)
        sfname = (fname.replace(
            "testdata_%s" % (under_model.name(nsne)),
            "samples_%s" % (under_model.name(nsne))).replace(".dat", ".npy"))
        np.save(sfname, samples)
예제 #32
0
print str(x)

print str(len(relevantdata[0]))

# Write out to a file as this is how we will do things in a larger set by looping through, and then read in the file

model.set(**params[0])

# fig_relevant = sncosmo.plot_lc(relevantdata[0], model=model)

#print "Close Window to continute"
#pl.show()
sncosmo.write_lc(Table(relevantdata[0]), fname='lc.dat', format='ascii')

# sncosmo.write_lc(Table(relevantdata[0]), fname='lc.dat.json', format='json')

# sncosmo.write_lc(Table(relevantdata[0]), fname='lc.dat.fits', format='snana') # fits

lc = sncosmo.read_lc('lc.dat', format='ascii')

fmodel = sncosmo.Model(source='salt2-extended')
for z in zvals:
    fmodel.set(z=z)
    res, fitmodel = sncosmo.fit_lc(relevantdata[0], fmodel, ['t0', 'x0', 'x1', 'c']) 

print res

print params[0]


예제 #33
0
파일: curve_io.py 프로젝트: arseeq/sntd
def _read_data(filename,**kwargs):
    table_done=True
    try:
        table = sncosmo.read_lc(filename, masked=True,**kwargs)
        for col in table.colnames:
            if col != _get_default_prop_name(col.lower()):
                table.rename_column(col, _get_default_prop_name(col.lower()))
    except:
        try:
            table = ascii.read(filename, masked=True,**kwargs)
            for col in table.colnames:
                if col != _get_default_prop_name(col.lower()):
                    table.rename_column(col, _get_default_prop_name(col.lower()))
        except:
            table = Table(masked=True)
            table_done=False


    delim = kwargs.get('delim', None)
    myCurve=curve()
    with anyOpen(filename) as f:
        lines=f.readlines()
        length=mode([len(l.split()) for l in lines])[0][0]#uses the most common line length as the correct length
        for i,line in enumerate(lines):
            if np.any([x in line for x in _comment_char]):
                continue
            line = line.strip(delim)

            if len(line)==0:
                continue
            if np.any([x in line for x in _meta__]):
                pos = line.find(' ')
                if (lines[i + 1][0] in _meta__ or lines[i + 1][0] in _comment_char or len(
                        line) != length):  # just making sure we're not about to put the col names into meta
                    if (pos == -1 or not any([_isfloat(x) for x in line.split()])):
                        if line[-1] not in string.punctuation:
                            line=line+'.'
                    else:
                        myCurve.meta[line[1:pos]] = _cast_str(line[pos:])
                continue
            line=line.split()
            if len(line)!= length:
                raise(RuntimeError,"Make sure your data are in a square matrix.")
            if table.colnames:
                colnames=table.colnames
            else:
                colnames = odict.fromkeys([_get_default_prop_name(x.lower()) for x in line])
                if len(colnames) != len(line):
                    raise (RuntimeError, "Do you have duplicate column names?")
                colnames=odict(zip(colnames,range(len(colnames))))
            startLine=i
            break
    f.close()
    if not table_done:
        lines = [x.strip().split() for x in lines[startLine + 1:] if not np.any([y in x for y in _comment_char])]

        for col in colnames:
            table[col]=np.asarray([_cast_str(x[colnames[col]]) for x in lines])
        colnames=colnames.keys()

    for col in [_get_default_prop_name(x) for x in ['band','zp','zpsys']]:
        if col not in colnames:
            temp=kwargs.get(col,None)
            if temp is not None:
                table[col]=temp
            else:
                print('Column "%s" is not in your file and you did not define it in kwargs.'%col)
                sys.exit(1)
    table=standardize_table_colnames(table)
    bnds = {x for x in table[_get_default_prop_name('band')]}
    table=_norm_flux_mag(table)
    for band in bnds:
        if _isfloat(band[0]):
            band='band_'+band
        try:
            if band[0:5]=='band_':
                sncosmo.get_bandpass(band[5:])
            else:
                sncosmo.get_bandpass(band)
        except:
            print('Skipping band %s, not in registry.' %band)
            table.mask[table[_get_default_prop_name('band')]==band]=True
            continue
        myCurve.bands.append(band)

    myCurve.table=table
    myCurve.zpsys=table['zpsys'][0]
    return myCurve
예제 #34
0
def load_example_lc():
    return (_standardize(
        sncosmo.read_lc(
            os.path.join(__dir__, 'example_setup', 'lcs',
                         'example_2006aj.lc'))))
예제 #35
0
def curveToColor(lc,
                 colors,
                 bandFit=None,
                 snType='II',
                 bandDict=_filters,
                 color_bands=_opticalBands,
                 zpsys='AB',
                 model=None,
                 singleBand=False,
                 verbose=True,
                 **kwargs):
    """
    Function takes a lightcurve file and creates a color table for it.

    :param lc: Name of lightcurve file you want to read, or astropy Table containing data
    :type lc: str or astropy.Table
    :param colors: Colors you want to calculate for the given SN (i.e U-B, r'-J)
    :type colors: str or list of strings
    :param bandFit: If there is a specific band you would like to fit instead of default
    :type bandFit: str,optional
    :param snType: Classification of SN
    :type snType: str,optional
    :param bandDict: sncosmo bandpass for each band used in the fitting/table generation
    :type bandDict: dict,optional
    :param color_bands: bands making up the known component of chosen colors
    :type color_bands: list,optional
    :param zpsys: magnitude system (i.e. AB or Vega)
    :type zpsys: str,optional
    :param model: If there is a specific sncosmo model you would like to fit with, otherwise all models mathcing the SN classification will be tried
    :type model: str,optional
    :param singleBand: If you would like to only fit the bands in the color
    :type singleBand: Boolean,optional
    :param verbose: If you would like printing information to be turned on/off
    :type verbose: Boolean,optional
    :param kwargs: Catches all SNCOSMO fitting parameters here
    :returns: colorTable: Astropy Table object containing color information
    """

    bands = append([col[0] for col in colors], [col[-1] for col in colors])
    for band in _filters:
        if band not in bandDict.keys() and band in bands:
            bandDict[band] = sncosmo.get_bandpass(_filters[band])
    if not isinstance(colors, (tuple, list)):
        colors = [colors]
    zpMag = sncosmo.get_magsystem(zpsys)

    if isinstance(lc, str):
        curve = _standardize(sncosmo.read_lc(lc))
    else:
        try:
            curve = _standardize(lc)
        except:
            raise RuntimeError("Can't understand your lightcurve.")
    if _get_default_prop_name('zpsys') not in curve.colnames:
        curve[_get_default_prop_name('zpsys')] = zpsys
    colorTable = Table(masked=True)
    colorTable.add_column(Column(data=[], name=_get_default_prop_name('time')))

    for band in bandDict:
        if not isinstance(bandDict[band], sncosmo.Bandpass):
            bandDict = _bandCheck(bandDict, band)
    t0 = None
    if verbose:
        print('Getting best fit for: ' + ','.join(colors))

    args = []
    for p in _fittingParams:
        args.append(kwargs.get(p, _fittingParams[p]))

        if p == 'method':
            try:
                importlib.import_module(_fittingPackages[args[-1]])
            except RuntimeError:
                sys.exit()
    for color in colors:  #start looping through desired colors
        if bandDict[color[
                0]].wave_eff < _UVrightBound:  #then extrapolating into the UV from optical
            if not bandFit:
                bandFit = color[-1]
            if singleBand:
                color_bands = [color[-1]]
            blue = curve[curve[_get_default_prop_name('band')] ==
                         color[0]]  #curve on the blue side of current color
            red = curve[[
                x in color_bands for x in curve[_get_default_prop_name('band')]
            ]]  #curve on the red side of current color
        else:  #must be extrapolating into the IR
            if not bandFit:
                bandFit = color[0]
            if singleBand:
                color_bands = [color[0]]
            blue = curve[[
                x in color_bands for x in curve[_get_default_prop_name('band')]
            ]]
            red = curve[curve[_get_default_prop_name('band')] == color[-1]]
        if len(blue) == 0 or len(red) == 0:
            if verbose:
                print('Asked for color %s but missing necessary band(s)' %
                      color)
            bandFit = None
            continue

        btemp = [
            bandDict[blue[_get_default_prop_name('band')][i]].name
            for i in range(len(blue))
        ]
        rtemp = [
            bandDict[red[_get_default_prop_name('band')][i]].name
            for i in range(len(red))
        ]
        blue.remove_column(_get_default_prop_name('band'))
        blue[_get_default_prop_name('band')] = btemp
        red.remove_column(_get_default_prop_name('band'))
        red[_get_default_prop_name('band')] = rtemp
        #now make sure we have zero-points and fluxes for everything
        if _get_default_prop_name('zp') not in blue.colnames:
            blue[_get_default_prop_name('zp')] = [
                zpMag.band_flux_to_mag(1 / sncosmo.constants.HC_ERG_AA,
                                       blue[_get_default_prop_name('band')][i])
                for i in range(len(blue))
            ]
        if _get_default_prop_name('zp') not in red.colnames:
            red[_get_default_prop_name('zp')] = [
                zpMag.band_flux_to_mag(1 / sncosmo.constants.HC_ERG_AA,
                                       red[_get_default_prop_name('band')][i])
                for i in range(len(red))
            ]
        if _get_default_prop_name('flux') not in blue.colnames:
            blue = mag_to_flux(blue, bandDict, zpsys)
        if _get_default_prop_name('flux') not in red.colnames:
            red = mag_to_flux(red, bandDict, zpsys)

        if not t0:  #this just ensures we only run the fitting once
            if not model:
                if verbose:
                    print('No model provided, running series of models.')

                mod, types = loadtxt(os.path.join(__dir__, 'data', 'sncosmo',
                                                  'models.ref'),
                                     dtype='str',
                                     unpack=True)
                modDict = {mod[i]: types[i] for i in range(len(mod))}
                if snType != 'Ia':
                    mods = [
                        x for x in sncosmo.models._SOURCES._loaders.keys()
                        if x[0] in modDict.keys()
                        and modDict[x[0]][:len(snType)] == snType
                    ]
                elif snType == 'Ia':
                    mods = [
                        x for x in sncosmo.models._SOURCES._loaders.keys()
                        if 'salt2' in x[0]
                    ]

                mods = {
                    x[0] if isinstance(x, (tuple, list)) else x
                    for x in mods
                }
                if bandFit == color[0] or len(blue) > len(red):
                    args[0] = blue
                    if len(blue) > 60:
                        fits = []
                        for mod in mods:
                            fits.append(_snFit([mod] + args))
                    else:
                        fits = pyParz.foreach(mods, _snFit, args)
                    fitted = blue
                    notFitted = red
                    fit = color[0]
                elif bandFit == color[-1] or len(blue) < len(red):
                    args[0] = red
                    '''
                    data,temp= sncosmo_fitting.cut_bands(photometric_data(red), sncosmo.Model(tempMod),
                                                             z_bounds=all_bounds.get('z', None),
                                                             warn=True)
                    print(data.fluxerr)
                    cov = diag(data.fluxerr**2) if data.fluxcov is None else data.fluxcov
                    invcov = linalg.pinv(cov)

                    args.append(invcov)
                    
                    sys.exit()
                    
                    fits=pyParz.foreach(mods,_snFit,args)
                    args.pop()
                    '''
                    if len(red) > 60:
                        fits = []
                        for mod in mods:
                            fits.append(_snFit([mod] + args))
                    else:
                        fits = pyParz.foreach(mods, _snFit, args)
                    fitted = red
                    notFitted = blue
                    fit = color[-1]
                else:
                    raise RuntimeError(
                        'Neither band "%s" nor band "%s" has more points, and you have not specified which to fit.'
                        % (color[0], color[-1]))
                bestChisq = inf
                for f in fits:
                    if f:
                        res, mod = f
                        if res.chisq < bestChisq:
                            bestChisq = res.chisq
                            bestFit = mod
                            bestRes = res
                if verbose:
                    print('Best fit model is "%s", with a Chi-squared of %f' %
                          (bestFit._source.name, bestChisq))
            elif bandFit == color[0] or len(blue) > len(red):
                args[0] = blue
                bestRes, bestFit = _snFit(append(model, args))
                fitted = blue
                notFitted = red
                fit = color[0]
                if verbose:
                    print(
                        'The model you chose (%s) completed with a Chi-squared of %f'
                        % (model, bestRes.chisq))
            elif bandFit == color[-1] or len(blue) < len(red):
                args[0] = red
                bestRes, bestFit = _snFit(append(model, args))
                fitted = red
                notFitted = blue
                fit = color[-1]
                if verbose:
                    print(
                        'The model you chose (%s) completed with a Chi-squared of %f'
                        % (model, bestRes.chisq))
            else:
                raise RuntimeError(
                    'Neither band "%s" nor band "%s" has more points, and you have not specified which to fit.'
                    % (color[0], color[-1]))

            t0 = _getBandMaxTime(bestFit, fitted, bandDict, 'B',
                                 zpMag.band_flux_to_mag(1, bandDict['B']),
                                 zpsys)
            if len(t0) == 1:
                t0 = t0[0]
            else:
                raise RuntimeError('Multiple global maxima in best fit.')
        else:
            if len(blue) > len(red) or bandFit == color[0]:
                fitted = blue
                notFitted = red
                fit = color[0]
            elif len(blue) < len(red) or bandFit == color[-1]:
                fitted = red
                notFitted = blue
                fit = color[-1]
            else:
                raise RuntimeError(
                    'Neither band "%s" nor band "%s" has more points, and you have not specified which to fit.'
                    % (color[0], color[-1]))

        #return(bestFit,bestRes,t0,fitted,notFitted)
        tGrid, bestMag = _snmodel_to_mag(bestFit, fitted, zpsys, bandDict[fit])

        ugrid, UMagErr, lgrid, LMagErr = _getErrorFromModel(
            append([bestFit._source.name, fitted], args[1:]), zpsys,
            bandDict[fit])
        tempTable = Table(
            [tGrid - t0, bestMag, bestMag * .1],
            names=(_get_default_prop_name('time'),
                   _get_default_prop_name('mag'),
                   _get_default_prop_name('magerr')
                   ))  #****RIGHT NOW THE ERROR IS JUST SET TO 10%*****
        interpFunc = scint.interp1d(
            array(tempTable[_get_default_prop_name('time')]),
            array(tempTable[_get_default_prop_name('mag')]))
        minterp = interpFunc(
            array(notFitted[_get_default_prop_name('time')] - t0))
        interpFunc = scint.interp1d(ugrid - t0, UMagErr)
        uinterp = interpFunc(
            array(notFitted[_get_default_prop_name('time')] - t0))
        interpFunc = scint.interp1d(lgrid - t0, LMagErr)
        linterp = interpFunc(
            array(notFitted[_get_default_prop_name('time')] - t0))
        magerr = mean([minterp - uinterp, linterp - minterp], axis=0)

        for i in range(len(minterp)):
            colorTable.add_row(append(
                notFitted[_get_default_prop_name('time')][i] - t0,
                [1 for j in range(len(colorTable.colnames) - 1)]),
                               mask=[
                                   True if j > 0 else False
                                   for j in range(len(colorTable.colnames))
                               ])
        if fit == color[0]:
            colorTable[color] = MaskedColumn(
                append([1 for j in range(len(colorTable) - len(minterp))],
                       minterp -
                       array(notFitted[_get_default_prop_name('mag')])),
                mask=[
                    True if j < (len(colorTable) - len(minterp)) else False
                    for j in range(len(colorTable))
                ])
        else:
            colorTable[color] = MaskedColumn(
                append([1 for j in range(len(colorTable) - len(minterp))],
                       array(notFitted[_get_default_prop_name('mag')]) -
                       minterp),
                mask=[
                    True if j < (len(colorTable) - len(minterp)) else False
                    for j in range(len(colorTable))
                ])
        colorTable[color[0] + color[-1] + '_err'] = MaskedColumn(
            append([1 for j in range(len(colorTable) - len(magerr))], magerr +
                   array(notFitted[_get_default_prop_name('magerr')])),
            mask=[
                True if j < (len(colorTable) - len(magerr)) else False
                for j in range(len(colorTable))
            ])
        #colorTable['V-r']=MaskedColumn(append([1 for j in range(len(colorTable)-len(magerr))],[bestFit.color('bessellv','sdss::r',zpsys,t0) for i in range(len(linterp))]),mask=[True if j<(len(colorTable)-len(magerr)) else False for j in range(len(colorTable))])
        tempVRCorr = 0
        for name in bestFit.effect_names:
            magCorr = _unredden(
                color, bandDict,
                bestRes.parameters[bestRes.param_names.index(name + 'ebv')],
                bestRes.parameters[bestRes.param_names.index(name + 'r_v')])
            colorTable[color] -= magCorr
            tempVRCorr += _unredden(
                'V-R', bandDict,
                bestRes.parameters[bestRes.param_names.index(name + 'ebv')],
                bestRes.parameters[bestRes.param_names.index(name + 'r_v')])
            corr1 = _ccm_extinction(
                sncosmo.get_bandpass('besselli').wave_eff,
                bestRes.parameters[bestRes.param_names.index(name + 'ebv')],
                r_v=3.1)
            corr2 = _ccm_extinction(
                sncosmo.get_bandpass('bessellr').wave_eff,
                bestRes.parameters[bestRes.param_names.index(name + 'ebv')],
                r_v=3.1)
            corr3 = _ccm_extinction(
                sncosmo.get_bandpass('bessellb').wave_eff,
                bestRes.parameters[bestRes.param_names.index(name + 'ebv')],
                r_v=3.1)
            corr4 = _ccm_extinction(
                sncosmo.get_bandpass('bessellv').wave_eff,
                bestRes.parameters[bestRes.param_names.index(name + 'ebv')],
                r_v=3.1)
        vr = [
            x - tempVRCorr
            for x in bestFit.color('bessellv', 'bessellr', zpsys,
                                   arange(t0 - 20, t0 + 100, 1))
        ]
        #vr=(bestFit.bandmag('bessellr',zpsys,arange(t0-20,t0+100,1))-bestFit.bandmag('besselli',zpsys,arange(t0-20,t0+100,1))-(corr2-corr1))/(bestFit.bandmag('bessellb',zpsys,arange(t0-20,t0+100,1))-bestFit.bandmag('bessellv',zpsys,arange(t0-20,t0+100,1))-(corr3-corr4))
        bandFit = None
    colorTable.sort(_get_default_prop_name('time'))

    return (colorTable, vr)
예제 #36
0
def grabdata(loc,list):
    f = open(list,'r').readlines()
    files = []
    for file in f:
        files.append(os.path.join(loc,file.strip()))

    lightcurves = []
    hostzs = []
    hostz_stds = []
    snids = []
    sntypes = []
    params = []

    max = 20000
    cntr = 0

    for file in files:
        cntr += 1
        if cntr > max:
            continue
        sn = open(file,'r').readlines()
        keepgoing = True
        i = 0
        sntype = -999
        snid = -999
        hostz = -999
        hostz_std = -999
        while keepgoing:
            if 'SNID:' in sn[i]:
                snid = sn[i].split()[1]
            if 'SNTYPE:' in sn[i]:
                sntype = sn[i].split()[1]
            if 'HOST_GALAXY_PHOTO-Z:' in sn[i]:
                hostz = float(sn[i].split()[1])
                hostz_std = float(sn[i].split()[3])
                keepgoing = False
            i += 1

        hostzs.append(hostz)
        hostz_stds.append(hostz_std)
        snids.append(snid)
        sntypes.append(sntype)

        sndata = dt.read(file,23,24)
        flux = sndata['FLUXCAL']
        fluxerr = sndata['FLUXCALERR']
        filt = sndata['FLT']
        mjd = sndata['MJD']

        badrow = -9
        for i,f,fe,flt,m in zip(range(len(flux)),flux,fluxerr,filt,mjd):
            if 'g+r+i+z' in str(f):
                badrow = i
            elif 'g+r+i+z' in str(fe):
                badrow = i
            elif 'g+r+i+z' in str(flt):
                badrow = i
            elif 'g+r+i+z' in str(m):
                badrow = i
        if badrow != -9:
            flux = np.delete(flux,badrow)
            fluxerr = np.delete(fluxerr,badrow)
            filt = np.delete(filt, badrow)
            mjd = np.delete(mjd, badrow)

        cosmofile = file.split('.')[0]+'.sncosmo'
        out = open(cosmofile,'w')
        out.write('time band flux fluxerr zp zpsys\n')
        for i,f,fe,flt,m in zip(range(len(flux)),flux,fluxerr,filt,mjd):
            out.write(str(m)+' des'+str(flt)+' '+str(f)+' '+str(fe)+' 27.5 ab\n')
        out.close()
        lc = sncosmo.read_lc(cosmofile)
        lightcurves.append(lc)

        params.append({'snid':snid,'type':sntype,'hostz':hostz,'hostz_std':hostz_std})
        print(snid,sntype,hostz,hostz_std)

    hostzs = np.array(hostzs)
    hostz_stds = np.array(hostz_std)
    snids = np.array(snids)
    sntypes = np.array(sntypes,dtype='float')

    print('unique types',np.unique(sntypes))

    dsntypes = np.zeros(len(sntypes))
    dsntypes[sntypes > 1] = np.ones(len(sntypes[sntypes > 1]))
    dsntypes[sntypes == 1] = np.zeros(len(sntypes[sntypes == 1]))
    dsntypes[sntypes == -9] = np.zeros(len(sntypes[sntypes == -9]))-9

    print('nonia',len(dsntypes[dsntypes == 1]))
    print('ia',len(dsntypes[dsntypes == 0]))
    print('none',len(dsntypes[dsntypes == -9]))

    'FEED ONLY LCs WITH NON -9 TYPES THROUGH ALL THE LIGHCURVE FITS AND SPLIT THAT INTO TEST AND TRAIN'
    knownlightcurves = []
    knownparams = []
    knowntypes = []
    blindlightcurves = []
    blindparams = []
    for lc,t,p in zip(lightcurves,dsntypes,params):
        if t == -9:
            blindlightcurves.append(lc)
            blindparams.append(p)
        else:
            knownlightcurves.append(lc)
            knownparams.append(p)
            knowntypes.append(t)

    ndim = 1 + 1 + 1 + len(sources) + 2
    fitparams = np.zeros((len(knownlightcurves), ndim)) #THIS NEEDS TO CUT OUT -9S

    fitparams, truetypes = lcfit(knownlightcurves, knownparams, fitparams, knowntypes, sources)
    print('fitparams.shape', fitparams.shape)
    print('truetypes.shape', truetypes.shape)
    np.savez('sncc_known2.npz', big_data_array=fitparams, truetypes=truetypes, params=knownparams)
    print('saved sncc_known2.npz')
    return
          x0=5.52396533233e-05,
          x1=-1.62106970624,
          c=0.079535505334)

times = np.array([
    54346.219, 54356.262, 54358.207, 54359.172, 54365.238, 54373.313,
    54382.246, 54386.25, 54388.254, 54393.238, 54403.168, 54406.16, 54412.16,
    54416.156, 54420.184, 54421.164, 54423.156, 54425.156, 54431.164, 54433.1
])
model_rcov = model._bandflux_rcov('sdssg', times)
relerr2 = np.diag(model_rcov) - model_rcov[0, 1]
for i, t in enumerate(times):
    print(i, t, relerr2[i])

data = sncosmo.read_lc('jla_light_curves/lc-SDSS19230.list',
                       format='salt2',
                       read_covmat=True)
# print(data)
data = sncosmo.photdata.photometric_data(data)

mask = sncosmo.fitting._data_mask(data, model.get('t0'), model.get('z'),
                                  (-15., 45.), (3000., 7000.))
# print(len(data[mask]))
# print(sncosmo.chisq(data[mask], model, modelcov=True))
# print(data[mask])
result, fitted_model = sncosmo.fit_lc(data,
                                      model, ['t0', 'x0', 'x1', 'c'],
                                      guess_amplitude=False,
                                      guess_t0=False,
                                      phase_range=(-15., 45.),
                                      wave_range=(3000., 7000.),
예제 #38
0

def snname_from_fname(fname):
    return re.match(REGEX, fname).groups()[0]


if __name__ == "__main__":

    model = sncosmo.Model(source='salt2',
                          effects=[sncosmo.F99Dust()],
                          effect_names=['mw'],
                          effect_frames=['obs'])

    fnames = glob.glob("jla_light_curves/lc-SDSS19230.list")
    for fname in fnames[0:1]:
        snname = snname_from_fname(fname)

        data = sncosmo.read_lc(fname, format='salt2', read_covmat=True)

        model.set(mwebv=data.meta['MWEBV'], z=data.meta['Z_HELIO'])
        t0 = time.time()
        result, m = sncosmo.fit_lc(data, model, ['t0', 'x0', 'x1', 'c'],
                                   modelcov=True, phase_range=(-15., 45.),
                                   wave_range=(3000., 7000.), verbose=True)
        print("time:", time.time() - t0, 's')
        print(result)

        snfit_result = snfitio.read_snfit_result('results_snfit/result-{}.dat'
                                                 .format(snname))
        print(snfit_result)
예제 #39
0
import os
import numpy as np
import sncosmo

lcs = sncosmo.read_lc('../lc.standardsystem.sesn_allphot.dat')
sne = np.unique(lcs['Name'])
for s in sne:
    sncosmo.write_lc(lcs[lcs['Name'] == s], 'lc_' + s + '.dat')
예제 #40
0
from mpi4py import MPI
from bolomc import bump, burns

__whatami__ = "Construct a bolometric light curve from CSP data."
__author__ = "Danny Goldstein <*****@*****.**>"

comm = MPI.COMM_WORLD
rank = comm.Get_rank()
size = comm.Get_size()

# Shorthand for a few variables with long names.
od94 = sncosmo.OD94Dust
f99 = sncosmo.F99Dust

# Read the LC to fit. 
lc = sncosmo.read_lc('scripts/sn2011fe.lc', format='ascii')
name = lc.meta['name']

# Configure the properties of the host galaxy dust.
dust_type = od94 
bintype = 'gmm'

# rv, ebv
my_jobs = [(3.1, 0.)]

if len(my_jobs) == 0:
    result = None  # this processor will be idle
    param_names = None
else:
    result = []
    param_names = []
예제 #41
0
파일: mklc.py 프로젝트: bhayden53/SALT2X
def do_stuff(ctr):
    p = pb.ProgressBar(maxval=740, widgets = [pb.Percentage(),pb.Bar(),pb.ETA()]).start()
    pbctr = 0
    for i,l in enumerate(lc):
        p.update(pbctr)
        pbctr += 1

        restcut = (3000,7000)
        data = sncosmo.read_lc(l, format='salt2')
        try:
            z = data.meta['Redshift']
        except:
            pass
        try:
            z = data.meta['Z_CMB']
        except:
            pass
        try:
            survey = data.meta['SURVEY']
        except:
            pass
        try:
            survey = data.meta['SET']
        except:
            pass
        nickname = data.meta['SN']
        try:
            nickname = str(int(nickname))
        except:
            pass
        mwebv = data.meta['MWEBV']
        dust = sncosmo.CCM89Dust()
        data = astropy.table.Table(data, masked=True)
        #rename columns so that my fitter can handle things
        data.rename_column('Filter', 'tmp')
        data.rename_column('Date', 'time')
        data.rename_column('Flux', 'flux')
        data.rename_column('Fluxerr', 'fluxerr')
        data.rename_column('MagSys', 'zpsys')
        data.rename_column('ZP', 'zp')

        if survey == 'SNLS':
            sn_nickname = l.split('/')[-1].split('.')[0].split('-')[-1]
            band = []
            for j, bp in enumerate(data['tmp']):
                band.append( '%s-%s' %(sn_nickname, bp) )
            band = astropy.table.Column(band, name='band')
            data.add_column(band)
            data.remove_column('tmp')
        else:
            data.rename_column('tmp', 'band')

        # deal with swope filters
        mask = (data['band'] == 'SWOPE2::V')
        nswopev = len(mask.nonzero()[0])
        if nswopev > 0:
            band = []
            for j, bp in enumerate(data['band']):
                if (bp == 'SWOPE2::V'):
                    if (data['time'][j] < 53749):
                        band.append('swope2::v_lc3014')
                    elif (data['time'][j] < 53760):
                        band.append('swope2::v_lc3009')
                    else:
                        band.append('swope2::v_lc9844')
                else:
                    band.append(bp)
            data.remove_column('band')
            band = astropy.table.Column(band, name='band')
            data.add_column(band)

            ind = np.where( (data['band'] == 'SWOPE2::V') & (data['time']>53749.) & ((data['time']<=53760.)) )
            data['band'][ind] = 'swope2::v_lc3009'
            ind = np.where( (data['band'] == 'SWOPE2::V') & (data['time']>53760.) )
            data['band'][ind] = 'swope2::v_lc9844'
            # print ind

        #deal with filter coverage
        #also deal with STANDARD filter zeropoints
        unique_bands = np.unique(data['band'])
        fit_bands = []
        nofit_bands = []
        # print unique_bands
        tmperr = np.copy(data['fluxerr'])
        for ub in unique_bands:
            # print ub
            bp = sncosmo.get_bandpass(ub)
            rest = bp.wave_eff / (1.0+z)
            if (rest >= restcut[0]) & (rest <= restcut[1]):
                fit_bands.append(ub)
            else:
                nofit_bands.append(ub)
            if 'STANDARD' in ub:
                ind = np.where(data['band'] == ub)
                data['zp'][ind] = data['zp'][ind] - float(standard_zps[ub])
                errcor = 10**(-0.4*standard_zps[ub])
                data['fluxerr'][ind] *= errcor
            if '4SHOOTER2' in ub:
                ind = np.where(data['band'] == ub)
                data['zp'][ind] = data['zp'][ind] - float(FourShooter_zps[ub])
                errcor = 10**(-0.4*FourShooter_zps[ub])
                data['fluxerr'][ind] *= errcor
            if 'KEPLERCAM' in ub:
                ind = np.where(data['band'] == ub)
                data['zp'][ind] = data['zp'][ind] - float(keplercam_zps[ub])
                errcor = 10**(-0.4*keplercam_zps[ub])
                data['fluxerr'][ind] *= errcor
                # print ub
                # print data['zp'][ind]
            if 'swope' in ub.lower():
                ind = np.where(data['band'] == ub)
                data['zp'][ind] = data['zp'][ind] - float(swope_zps[ub])
                errcor = 10**(-0.4*swope_zps[ub])
                data['fluxerr'][ind] *= errcor
            if 'sdss' in ub.lower():
                ind = np.where(data['band'] == ub)
                data['zp'][ind] = data['zp'][ind] - float(sdss_zps[ub])
                errcor = 10**(-0.4*sdss_zps[ub])
                data['fluxerr'][ind] *= errcor

        for nfb in nofit_bands:
            mask = data['band'] == nfb
            for c in data.colnames:
                data[c].mask = (data[c].mask | mask)

        mwebv = data.meta['MWEBV']

        mask = data['band'].mask.nonzero()[0]
        data.remove_rows(mask)

        ind = np.where(lcfits['SN'] == nickname)
        t0 = lcfits['DayMax'][ind][0]

        x1r, x1f, c = np.random.multivariate_normal(mean,cov,size=1)[0]
        mu = cosmo.distmod(z).value
        absmag = MB - ar*x1r - af*x1f + beta*c + np.random.normal(scale=sigint, size=1)[0]
        mB = mu + absmag

        source = Salt2XSource(version='2.4', modeldir=modeldir)
        model  = sncosmo.Model(source=source, effects=[dust], effect_names=['mw'], effect_frames=['obs'])

        model.set(z=z, x1=x1f, s=x1r, c=c, t0=t0, mwebv=mwebv)
        model.set_source_peakabsmag(absmag, 'bessellb', 'ab')
        flux = model.bandflux(data['band'], data['time'], zp=data['zp'], zpsys=data['zpsys'])
        whocares, saltcov = model.bandfluxcov(data['band'], data['time'], data['zp'],data['zpsys'])

        # handle model cov blowups
        saltcov = np.copy(saltcov)
        diag = np.copy(saltcov.diagonal())
        model_snr = whocares/np.sqrt(diag)

        ind = np.where((np.abs(model_snr) < 1) & ~np.isnan(model_snr))

        diag[ind] = diag[ind] * np.abs(model_snr[ind])**2
        np.fill_diagonal(saltcov, diag)


        diagerr = np.diag(data['fluxerr']**2)
        fullcov = saltcov + diagerr
        try:
            np.linalg.cholesky(fullcov)
        except:
            print 'Cholesky failed... exiting'
            sys.exit()
            
        noise = np.random.multivariate_normal(np.zeros(len(diagerr)), fullcov, size=1)[0]

        #lower zp, lower flux
        data['flux'] = flux + noise

        data.meta['x1r'] = x1r
        data.meta['x1f'] = x1f
        data.meta['c'] = c
        data.meta['alpha_r'] = ar
        data.meta['alpha_f'] = af
        data.meta['beta'] = beta
        data.meta['MB'] = MB
        data.meta['mB'] = mu+MB
        data.meta['DayMax'] = t0
        data.meta['cosmology'] = 'Planck15'

        data.rename_column('band', 'Filter')
        data.rename_column('time', 'Date')
        data.rename_column('flux', 'Flux')
        data.rename_column('fluxerr', 'Fluxerr')
        data.rename_column('zpsys', 'MagSys')
        data.rename_column('zp', 'ZP')

        if survey == 'SNLS':
            for row in data:
                tmp = row['Filter']
                ind = tmp.find('MEGACAM')
                row['Filter'] = row['Filter'][ind:]

        sncosmo.write_lc(data,'./cadence_sim/lc/%s_%s.list' %(nickname, ctr), format='salt2')
    p.finish()