Example #1
0
def calcMass(options, args):
    if options.sample.lower() == "g":
        if options.select.lower() == "program":
            raw = read_gdwarfs(_GDWARFFILE, logg=True, ebv=True, sn=True)
        elif options.select.lower() == "fakebimodal":
            raw = read_gdwarfs(_FAKEBIMODALGDWARFFILE, logg=True, ebv=True, sn=True)
            options.select = "all"
        else:
            raw = read_gdwarfs(logg=True, ebv=True, sn=True)
    elif options.sample.lower() == "k":
        if options.select.lower() == "program":
            raw = read_kdwarfs(_KDWARFFILE, logg=True, ebv=True, sn=True)
        else:
            raw = read_kdwarfs(logg=True, ebv=True, sn=True)
    # Bin the data
    binned = pixelAfeFeh(raw, dfeh=options.dfeh, dafe=options.dafe)
    # Savefile
    if os.path.exists(args[0]):  # Load savefile
        savefile = open(args[0], "rb")
        mass = pickle.load(savefile)
        ii = pickle.load(savefile)
        jj = pickle.load(savefile)
        savefile.close()
    else:
        mass = []
        ii, jj = 0, 0
    # parameters
    if os.path.exists(args[1]):  # Load initial
        savefile = open(args[1], "rb")
        fits = pickle.load(savefile)
        savefile.close()
    else:
        print "Error: must provide parameters of best fits"
        print "Returning ..."
        return None
    # Sample?
    if options.mcsample:
        if ii < len(binned.fehedges) - 1 and jj < len(binned.afeedges) - 1:
            print "First do all of the best-fit mass estimates ..."
            print "Returning ..."
            return None
        if os.path.exists(args[2]):  # Load savefile
            savefile = open(args[2], "rb")
            masssamples = pickle.load(savefile)
            ii = pickle.load(savefile)
            jj = pickle.load(savefile)
            savefile.close()
        else:
            masssamples = []
            ii, jj = 0, 0
        if os.path.exists(args[3]):  # Load savefile
            savefile = open(args[3], "rb")
            denssamples = pickle.load(savefile)
            savefile.close()
        else:
            print "If mcsample you need to provide the file with the density samples ..."
            print "Returning ..."
            return None
    # Set up model etc.
    if options.model.lower() == "hwr":
        densfunc = _HWRDensity
    elif options.model.lower() == "twodblexp":
        densfunc = _TwoDblExpDensity
    like_func = _HWRLikeMinus
    pdf_func = _HWRLike
    if options.sample.lower() == "g":
        colorrange = [0.48, 0.55]
    elif options.sample.lower() == "k":
        colorrange = [0.55, 0.75]
    # Load selection function
    plates = numpy.array(list(set(list(raw.plate))), dtype="int")  # Only load plates that we use
    print "Using %i plates, %i stars ..." % (len(plates), len(raw))
    sf = segueSelect(
        plates=plates,
        type_faint="tanhrcut",
        sample=options.sample,
        type_bright="tanhrcut",
        sn=True,
        select=options.select,
    )
    platelb = bovy_coords.radec_to_lb(sf.platestr.ra, sf.platestr.dec, degree=True)
    indx = [not "faint" in name for name in sf.platestr.programname]
    platebright = numpy.array(indx, dtype="bool")
    indx = ["faint" in name for name in sf.platestr.programname]
    platefaint = numpy.array(indx, dtype="bool")
    if options.sample.lower() == "g":
        grmin, grmax = 0.48, 0.55
        rmin, rmax = 14.5, 20.2
    # Run through the bins
    while ii < len(binned.fehedges) - 1:
        while jj < len(binned.afeedges) - 1:
            data = binned(binned.feh(ii), binned.afe(jj))
            if len(data) < options.minndata:
                if options.mcsample:
                    masssamples.append(None)
                else:
                    mass.append(None)
                jj += 1
                if jj == len(binned.afeedges) - 1:
                    jj = 0
                    ii += 1
                    break
                continue
            print binned.feh(ii), binned.afe(jj), len(data)
            fehindx = binned.fehindx(binned.feh(ii))
            afeindx = binned.afeindx(binned.afe(jj))
            # set up feh and color
            feh = binned.feh(ii)
            fehrange = [binned.fehedges[ii], binned.fehedges[ii + 1]]
            # FeH
            fehdist = DistSpline(
                *numpy.histogram(data.feh, bins=5, range=fehrange), xrange=fehrange, dontcuttorange=False
            )
            # Color
            colordist = DistSpline(
                *numpy.histogram(data.dered_g - data.dered_r, bins=9, range=colorrange), xrange=colorrange
            )

            # Age marginalization
            afe = binned.afe(jj)
            if options.simpleage:
                agemin, agemax = 0.5, 10.0
            else:
                if afe > 0.25:
                    agemin, agemax = 7.0, 10.0
                else:
                    agemin, agemax = 1.0, 8.0
            if options.mcsample:
                # Loop over samples
                thissamples = denssamples[afeindx + fehindx * binned.npixafe()]
                if options.nsamples < len(thissamples):
                    print "Taking random ..."
                    # Random permutation
                    thissamples = numpy.random.permutation(thissamples)[0 : options.nsamples]
                thismasssamples = []
                print "WARNING: DISK MASS IN CALCMASS ONLY FOR G COLORS"
                for kk in range(len(thissamples)):
                    thisparams = thissamples[kk]
                    thismasssamples.append(
                        predictDiskMass(
                            densfunc,
                            thisparams,
                            sf,
                            colordist,
                            fehdist,
                            fehrange[0],
                            fehrange[1],
                            feh,
                            data,
                            0.45,
                            0.58,
                            agemin,
                            agemax,
                            normalize=options.normalize,
                            imfmodel=options.imfmodel,
                        )
                    )
                # Print some stuff
                print numpy.mean(numpy.array(thismasssamples)), numpy.std(numpy.array(thismasssamples))
                masssamples.append(thismasssamples)
            else:
                thisparams = fits[afeindx + fehindx * binned.npixafe()]
                print "WARNING: DISK MASS IN CALCMASS ONLY FOR G COLORS"
                mass.append(
                    predictDiskMass(
                        densfunc,
                        thisparams,
                        sf,
                        colordist,
                        fehdist,
                        fehrange[0],
                        fehrange[1],
                        feh,
                        data,
                        0.45,
                        0.58,
                        agemin,
                        agemax,
                        normalize=options.normalize,
                        imfmodel=options.imfmodel,
                    )
                )
                print mass[-1]
            jj += 1
            if jj == len(binned.afeedges) - 1:
                jj = 0
                ii += 1
            if options.mcsample:
                save_pickles(args[2], masssamples, ii, jj)
            else:
                save_pickles(args[0], mass, ii, jj)
            if jj == 0:  # this means we've reset the counter
                break
    if options.mcsample:
        save_pickles(args[2], masssamples, ii, jj)
    else:
        save_pickles(args[0], mass, ii, jj)
    return None
Example #2
0
def plotPixelFitVel(options, args):
    if options.sample.lower() == "g":
        if options.select.lower() == "program":
            raw = read_gdwarfs(_GDWARFFILE, logg=True, ebv=True, sn=options.snmin, distfac=options.distfac)
        else:
            raw = read_gdwarfs(logg=True, ebv=True, sn=options.snmin, distfac=options.distfac)
    elif options.sample.lower() == "k":
        if options.select.lower() == "program":
            raw = read_kdwarfs(_KDWARFFILE, logg=True, ebv=True, sn=options.snmin, distfac=options.distfac)
        else:
            raw = read_kdwarfs(logg=True, ebv=True, sn=options.snmin, distfac=options.distfac)
    if not options.bmin is None:
        # Cut on |b|
        raw = raw[(numpy.fabs(raw.b) > options.bmin)]
    # print len(raw)
    # Bin the data
    binned = pixelAfeFeh(raw, dfeh=options.dfeh, dafe=options.dafe)
    if options.tighten:
        tightbinned = pixelAfeFeh(
            raw, dfeh=options.dfeh, dafe=options.dafe, fehmin=-1.6, fehmax=0.5, afemin=-0.05, afemax=0.55
        )
    else:
        tightbinned = binned
    # Savefile
    if os.path.exists(args[0]):  # Load savefile
        savefile = open(args[0], "rb")
        fits = pickle.load(savefile)
        savefile.close()
    # Now plot
    # Run through the pixels and gather
    if (
        options.type.lower() == "afe"
        or options.type.lower() == "feh"
        or options.type.lower() == "fehafe"
        or options.type.lower() == "afefeh"
    ):
        plotthis = []
    else:
        plotthis = numpy.zeros((tightbinned.npixfeh(), tightbinned.npixafe()))
    # ndata= 0
    # maxndata= 0
    for ii in range(tightbinned.npixfeh()):
        for jj in range(tightbinned.npixafe()):
            data = binned(tightbinned.feh(ii), tightbinned.afe(jj))
            fehindx = binned.fehindx(tightbinned.feh(ii))  # Map onto regular binning
            afeindx = binned.afeindx(tightbinned.afe(jj))
            if afeindx + fehindx * binned.npixafe() >= len(fits):
                if (
                    options.type.lower() == "afe"
                    or options.type.lower() == "feh"
                    or options.type.lower() == "fehafe"
                    or options.type.lower() == "afefeh"
                ):
                    continue
                else:
                    plotthis[ii, jj] = numpy.nan
                    continue
            thisfit = fits[afeindx + fehindx * binned.npixafe()]
            if thisfit is None:
                if (
                    options.type.lower() == "afe"
                    or options.type.lower() == "feh"
                    or options.type.lower() == "fehafe"
                    or options.type.lower() == "afefeh"
                ):
                    continue
                else:
                    plotthis[ii, jj] = numpy.nan
                    continue
            if len(data) < options.minndata:
                if (
                    options.type.lower() == "afe"
                    or options.type.lower() == "feh"
                    or options.type.lower() == "fehafe"
                    or options.type.lower() == "afefeh"
                ):
                    continue
                else:
                    plotthis[ii, jj] = numpy.nan
                    continue
            # if len(data) > maxndata: maxndata= len(data)
            # ndata+= len(data)
            if options.model.lower() == "hwr":
                if options.type == "sz":
                    plotthis[ii, jj] = numpy.exp(thisfit[1])
                elif options.type == "sz2":
                    plotthis[ii, jj] = numpy.exp(2.0 * thisfit[1])
                elif options.type == "hs":
                    plotthis[ii, jj] = numpy.exp(thisfit[4])
                elif options.type == "hsm":
                    plotthis[ii, jj] = numpy.exp(-thisfit[4])
                elif options.type == "pbad":
                    plotthis[ii, jj] = thisfit[0]
                elif options.type == "slopes":
                    plotthis[ii, jj] = thisfit[2]
                elif options.type == "slope":
                    plotthis[ii, jj] = thisfit[2]
                elif options.type == "chi2dof":
                    plotthis[ii, jj] = thisfit[6]
                elif (
                    options.type.lower() == "afe"
                    or options.type.lower() == "feh"
                    or options.type.lower() == "fehafe"
                    or options.type.lower() == "afefeh"
                ):
                    plotthis.append(
                        [
                            tightbinned.feh(ii),
                            tightbinned.afe(jj),
                            numpy.exp(thisfit[1]),
                            numpy.exp(thisfit[3]),
                            len(data),
                        ]
                    )
    # print ndata
    # print maxndata
    # Set up plot
    # print numpy.nanmin(plotthis), numpy.nanmax(plotthis)
    if options.type == "sz":
        if options.vr:
            vmin, vmax = 40.0, 80.0
            zlabel = r"$\sigma_R(z = \langle z \rangle)\ [\mathrm{km\ s}^{-1}]$"
        else:
            vmin, vmax = 10.0, 60.0
            zlabel = r"$\sigma_z(z_{1/2})\ [\mathrm{km\ s}^{-1}]$"
    elif options.type == "sz2":
        if options.vr:
            vmin, vmax = 40.0 ** 2.0, 80.0 ** 2.0
            zlabel = r"$\sigma_R^2(z= \langle z \rangle)\ [\mathrm{km\ s}^{-1}]$"
        else:
            vmin, vmax = 15.0 ** 2.0, 50.0 ** 2.0
            zlabel = r"$\sigma_z^2(z= \langle z \rangle)\ [\mathrm{km\ s}^{-1}]$"
    elif options.type == "hs":
        if options.vr:
            vmin, vmax = 3.0, 25.0
            zlabel = r"$R_\sigma\ [\mathrm{kpc}]$"
        else:
            vmin, vmax = 3.0, 15.0
            zlabel = r"$h_\sigma\ [\mathrm{kpc}]$"
    elif options.type == "hsm":
        if options.vr:
            vmin, vmax = 0.0, 0.3
            zlabel = r"$R^{-1}_\sigma\ [\mathrm{kpc}^{-1}]$"
        else:
            vmin, vmax = 0.0, 0.3
            zlabel = r"$R^{-1}_\sigma\ [\mathrm{kpc}^{-1}]$"
    elif options.type == "slope":
        vmin, vmax = -5.0, 5.0
        zlabel = r"$\frac{\mathrm{d} \sigma_z}{\mathrm{d} z}(z_{1/2})\ [\mathrm{km\ s}^{-1}\ \mathrm{kpc}^{-1}]$"
    elif options.type == "pbad":
        vmin, vmax = 0.0, 0.1
        zlabel = r"$P_{\mathrm{bad}}$"
    elif options.type == "chi2dof":
        vmin, vmax = 0.5, 1.5
        zlabel = r"$\chi^2/\mathrm{dof}$"
    elif options.type == "afe":
        vmin, vmax = 0.05, 0.4
        zlabel = r"$[\alpha/\mathrm{Fe}]$"
    elif options.type == "feh":
        vmin, vmax = -1.5, 0.0
        zlabel = r"$[\mathrm{Fe/H}]$"
    elif options.type == "fehafe":
        vmin, vmax = -0.7, 0.7
        zlabel = r"$[\mathrm{Fe/H}]-[\mathrm{Fe/H}]_{1/2}([\alpha/\mathrm{Fe}])$"
    elif options.type == "afefeh":
        vmin, vmax = -0.15, 0.15
        zlabel = r"$[\alpha/\mathrm{Fe}]-[\alpha/\mathrm{Fe}]_{1/2}([\mathrm{Fe/H}])$"
    if options.tighten:
        xrange = [-1.6, 0.5]
        yrange = [-0.05, 0.55]
    else:
        xrange = [-2.0, 0.6]
        yrange = [-0.1, 0.6]
    if (
        options.type.lower() == "afe"
        or options.type.lower() == "feh"
        or options.type.lower() == "fehafe"
        or options.type.lower() == "afefeh"
    ):
        print "Update!! Never used until now (afe etc. type fitting is in plotsz2hz"
        return None
        bovy_plot.bovy_print(fig_height=3.87, fig_width=5.0)
        # Gather hR and hz
        hz, hr, afe, feh, ndata = [], [], [], [], []
        for ii in range(len(plotthis)):
            hz.append(plotthis[ii][2])
            hr.append(plotthis[ii][3])
            afe.append(plotthis[ii][1])
            feh.append(plotthis[ii][0])
            ndata.append(plotthis[ii][4])
        hz = numpy.array(hz)
        hr = numpy.array(hr)
        afe = numpy.array(afe)
        feh = numpy.array(feh)
        ndata = numpy.array(ndata)
        # Process ndata
        ndata = ndata ** 0.5
        ndata = ndata / numpy.median(ndata) * 35.0
        # ndata= numpy.log(ndata)/numpy.log(numpy.median(ndata))
        # ndata= (ndata-numpy.amin(ndata))/(numpy.amax(ndata)-numpy.amin(ndata))*25+12.
        if options.type.lower() == "afe":
            plotc = afe
        elif options.type.lower() == "feh":
            plotc = feh
        elif options.type.lower() == "afefeh":
            # Go through the bins to determine whether feh is high or low for this alpha
            plotc = numpy.zeros(len(afe))
            for ii in range(tightbinned.npixfeh()):
                fehbin = ii
                data = tightbinned.data[
                    (tightbinned.data.feh > tightbinned.fehedges[fehbin])
                    * (tightbinned.data.feh <= tightbinned.fehedges[fehbin + 1])
                ]
                medianafe = numpy.median(data.afe)
                for jj in range(len(afe)):
                    if feh[jj] == tightbinned.feh(ii):
                        plotc[jj] = afe[jj] - medianafe
        else:
            # Go through the bins to determine whether feh is high or low for this alpha
            plotc = numpy.zeros(len(feh))
            for ii in range(tightbinned.npixafe()):
                afebin = ii
                data = tightbinned.data[
                    (tightbinned.data.afe > tightbinned.afeedges[afebin])
                    * (tightbinned.data.afe <= tightbinned.afeedges[afebin + 1])
                ]
                medianfeh = numpy.median(data.feh)
                for jj in range(len(feh)):
                    if afe[jj] == tightbinned.afe(ii):
                        plotc[jj] = feh[jj] - medianfeh
        yrange = [150, 1200]
        xrange = [1.2, 5.0]
        bovy_plot.bovy_plot(
            hr,
            hz,
            s=ndata,
            c=plotc,
            cmap="jet",
            ylabel=r"$\mathrm{vertical\ scale\ height\ [pc]}$",
            xlabel=r"$\mathrm{radial\ scale\ length\ [kpc]}$",
            clabel=zlabel,
            xrange=xrange,
            yrange=yrange,
            vmin=vmin,
            vmax=vmax,
            scatter=True,
            edgecolors="none",
            colorbar=True,
        )
    elif options.type.lower() == "slopes":
        bovy_plot.bovy_print()
        bovy_plot.bovy_hist(
            plotthis.flatten(),
            range=[-5.0, 5.0],
            bins=11,
            histtype="step",
            color="k",
            xlabel=r"$\sigma_z(z)\ \mathrm{slope\ [km\ s}^{-1}\ \mathrm{kpc}^{-1}]$",
        )
    else:
        bovy_plot.bovy_print()
        bovy_plot.bovy_dens2d(
            plotthis.T,
            origin="lower",
            cmap="jet",
            interpolation="nearest",
            xlabel=r"$[\mathrm{Fe/H}]$",
            ylabel=r"$[\alpha/\mathrm{Fe}]$",
            zlabel=zlabel,
            xrange=xrange,
            yrange=yrange,
            vmin=vmin,
            vmax=vmax,
            contours=False,
            colorbar=True,
            shrink=0.78,
        )
    if options.observed:
        bovy_plot.bovy_text(r"$\mathrm{observed}$", top_right=True, size=18.0)
    bovy_plot.bovy_end_print(options.plotfile)
    return None
Example #3
0
def plotMass(options, args):
    if options.sample.lower() == "g":
        if options.select.lower() == "program":
            raw = read_gdwarfs(_GDWARFFILE, logg=True, ebv=True, sn=True)
        else:
            raw = read_gdwarfs(logg=True, ebv=True, sn=True)
    elif options.sample.lower() == "k":
        if options.select.lower() == "program":
            raw = read_kdwarfs(_KDWARFFILE, logg=True, ebv=True, sn=True)
        else:
            raw = read_kdwarfs(logg=True, ebv=True, sn=True)
    # Bin the data
    binned = pixelAfeFeh(raw, dfeh=options.dfeh, dafe=options.dafe)
    if options.tighten:
        tightbinned = pixelAfeFeh(
            raw, dfeh=options.dfeh, dafe=options.dafe, fehmin=-1.6, fehmax=0.5, afemin=-0.05, afemax=0.55
        )
    else:
        tightbinned = binned
    # Savefile
    if os.path.exists(args[0]):  # Load savefile
        savefile = open(args[0], "rb")
        mass = pickle.load(savefile)
        ii = pickle.load(savefile)
        jj = pickle.load(savefile)
        savefile.close()
    else:
        mass = []
        ii, jj = 0, 0
    # parameters
    if os.path.exists(args[1]):  # Load initial
        savefile = open(args[1], "rb")
        fits = pickle.load(savefile)
        savefile.close()
    else:
        print "Error: must provide parameters of best fits"
        print "Returning ..."
        return None
    # Mass uncertainties are in savefile3
    if len(args) > 2 and os.path.exists(args[2]):
        savefile = open(args[2], "rb")
        masssamples = pickle.load(savefile)
        savefile.close()
        masserrors = True
    else:
        masssamples = None
        masserrors = False
    if len(args) > 3 and os.path.exists(args[3]):  # Load savefile
        savefile = open(args[3], "rb")
        denssamples = pickle.load(savefile)
        savefile.close()
        denserrors = True
    else:
        denssamples = None
        denserrors = False
    if len(args) > 4 and os.path.exists(args[4]):  # Load savefile
        savefile = open(args[4], "rb")
        velfits = pickle.load(savefile)
        savefile.close()
        velfitsLoaded = True
    else:
        velfitsLoaded = False
    if len(args) > 5 and os.path.exists(args[5]):
        savefile = open(args[5], "rb")
        velsamples = pickle.load(savefile)
        savefile.close()
        velerrors = True
    else:
        velsamples = None
        velerrors = False
    # Now plot
    # Run through the pixels and gather
    if (
        options.type.lower() == "afe"
        or options.type.lower() == "feh"
        or options.type.lower() == "fehafe"
        or options.type.lower() == "afefeh"
    ):
        plotthis = []
    else:
        plotthis = numpy.zeros((tightbinned.npixfeh(), tightbinned.npixafe()))
    if denserrors:
        errors = []
    for ii in range(tightbinned.npixfeh()):
        for jj in range(tightbinned.npixafe()):
            data = binned(tightbinned.feh(ii), tightbinned.afe(jj))
            fehindx = binned.fehindx(tightbinned.feh(ii))  # Map onto regular binning
            afeindx = binned.afeindx(tightbinned.afe(jj))
            if afeindx + fehindx * binned.npixafe() >= len(fits):
                if (
                    options.type.lower() == "afe"
                    or options.type.lower() == "feh"
                    or options.type.lower() == "fehafe"
                    or options.type.lower() == "afefeh"
                ):
                    continue
                else:
                    plotthis[ii, jj] = numpy.nan
                    continue
            thismass = mass[afeindx + fehindx * binned.npixafe()]
            if masserrors:
                thismasssamples = masssamples[afeindx + fehindx * binned.npixafe()]
            else:
                thismasssamples = None
            thisfit = fits[afeindx + fehindx * binned.npixafe()]
            if denserrors:
                thisdenssamples = denssamples[afeindx + fehindx * binned.npixafe()]
            else:
                thisdenssamples = None
            if velfitsLoaded:
                thisvelfit = velfits[afeindx + fehindx * binned.npixafe()]
            if velerrors:
                thisvelsamples = velsamples[afeindx + fehindx * binned.npixafe()]
            if thisfit is None:
                if (
                    options.type.lower() == "afe"
                    or options.type.lower() == "feh"
                    or options.type.lower() == "fehafe"
                    or options.type.lower() == "afefeh"
                ):
                    continue
                else:
                    plotthis[ii, jj] = numpy.nan
                    continue
            if len(data) < options.minndata:
                if (
                    options.type.lower() == "afe"
                    or options.type.lower() == "feh"
                    or options.type.lower() == "fehafe"
                    or options.type.lower() == "afefeh"
                ):
                    continue
                else:
                    plotthis[ii, jj] = numpy.nan
                    continue
            if options.type == "mass":
                if not options.distzmin is None or not options.distzmax is None:
                    if options.distzmin is None and not options.distzmax is None:
                        thismass *= 1.0 - numpy.exp(-options.distzmax / numpy.exp(thisfit[0]) / 1000.0)
                    elif not options.distzmin is None and options.distzmax is None:
                        thismass *= numpy.exp(-options.distzmin / numpy.exp(thisfit[0]) / 1000.0)
                    else:
                        thismass *= numpy.exp(-options.distzmin / numpy.exp(thisfit[0]) / 1000.0) - numpy.exp(
                            -options.distzmax / numpy.exp(thisfit[0]) / 1000.0
                        )
                if options.logmass:
                    plotthis[ii, jj] = numpy.log10(thismass / 10 ** 6.0)
                else:
                    plotthis[ii, jj] = thismass / 10 ** 6.0
            elif options.type == "nstars":
                if options.logmass:
                    plotthis[ii, jj] = numpy.log10(len(data))
                else:
                    plotthis[ii, jj] = len(data)
            elif options.model.lower() == "hwr":
                if options.type == "hz":
                    plotthis[ii, jj] = numpy.exp(thisfit[0]) * 1000.0
                elif options.type == "hr":
                    plotthis[ii, jj] = numpy.exp(thisfit[1])
                elif (
                    options.type.lower() == "afe"
                    or options.type.lower() == "feh"
                    or options.type.lower() == "fehafe"
                    or options.type.lower() == "afefeh"
                ):
                    plotthis.append(
                        [
                            tightbinned.feh(ii),
                            tightbinned.afe(jj),
                            numpy.exp(thisfit[0]) * 1000.0,
                            numpy.exp(thisfit[1]),
                            len(data),
                            thismass / 10.0 ** 6.0,
                            thismasssamples,
                        ]
                    )
                    if denserrors:
                        theseerrors = []
                        thesesamples = denssamples[afeindx + fehindx * binned.npixafe()]
                        if options.model.lower() == "hwr":
                            for kk in [0, 1]:
                                xs = numpy.array([s[kk] for s in thesesamples])
                                theseerrors.append(
                                    0.5
                                    * (
                                        -numpy.exp(numpy.mean(xs) - numpy.std(xs))
                                        + numpy.exp(numpy.mean(xs) + numpy.std(xs))
                                    )
                                )
                        errors.append(theseerrors)
                    if velfitsLoaded:
                        if options.velmodel.lower() == "hwr":
                            plotthis[-1].extend(
                                [numpy.exp(thisvelfit[1]), numpy.exp(thisvelfit[4]), thisvelfit[2], thisvelfit[3]]
                            )
                            if velerrors:
                                theseerrors = []
                                thesesamples = velsamples[afeindx + fehindx * binned.npixafe()]
                                for kk in [1, 4]:
                                    xs = numpy.array([s[kk] for s in thesesamples])
                                    theseerrors.append(
                                        0.5
                                        * (
                                            numpy.exp(numpy.mean(xs))
                                            - numpy.exp(numpy.mean(xs) - numpy.std(xs))
                                            - numpy.exp(numpy.mean(xs))
                                            + numpy.exp(numpy.mean(xs) + numpy.std(xs))
                                        )
                                    )
                                xs = numpy.array([s[4] for s in thesesamples])
                                theseerrors.append(
                                    0.5
                                    * (
                                        numpy.exp(-numpy.mean(xs))
                                        - numpy.exp(numpy.mean(-xs) - numpy.std(-xs))
                                        - numpy.exp(numpy.mean(-xs))
                                        + numpy.exp(numpy.mean(-xs) + numpy.std(-xs))
                                    )
                                )
                                errors[-1].extend(theseerrors)
    # Set up plot
    # print numpy.nanmin(plotthis), numpy.nanmax(plotthis)
    if options.type == "mass":
        if options.logmass:
            vmin, vmax = numpy.log10(0.01), numpy.log10(2.0)
            zlabel = r"$\log_{10} \Sigma(R_0)\ [M_{\odot}\ \mathrm{pc}^{-2}]$"
        else:
            vmin, vmax = 0.0, 1.0
            zlabel = r"$\Sigma(R_0)\ [M_{\odot}\ \mathrm{pc}^{-2}]$"
            if not options.distzmin is None or not options.distzmax is None:
                vmin, vmax = None, None
        title = r"$\mathrm{mass\ weighted}$"
    elif options.type == "nstars":
        if options.logmass:
            vmin, vmax = 2.0, 3.0
            zlabel = r"$\log_{10} \mathrm{raw\ number\ of\ G}$-$\mathrm{type\ dwarfs}$"
        else:
            vmin, vmax = 100.0, 1000.0
            zlabel = r"$\mathrm{raw\ number\ of\ G}$-$\mathrm{type\ dwarfs}$"
        title = r"$\mathrm{raw\ sample\ counts}$"
    elif options.type == "afe":
        vmin, vmax = 0.0, 0.5
        zlabel = r"$[\alpha/\mathrm{Fe}]$"
    elif options.type == "feh":
        vmin, vmax = -1.5, 0.0
        zlabel = r"$[\mathrm{Fe/H}]$"
    elif options.type == "fehafe":
        vmin, vmax = -0.7, 0.7
        zlabel = r"$[\mathrm{Fe/H}]-[\mathrm{Fe/H}]_{1/2}([\alpha/\mathrm{Fe}])$"
    elif options.type == "afefeh":
        vmin, vmax = -0.15, 0.15
        zlabel = r"$[\alpha/\mathrm{Fe}]-[\alpha/\mathrm{Fe}]_{1/2}([\mathrm{Fe/H}])$"
    if options.tighten:
        xrange = [-1.6, 0.5]
        yrange = [-0.05, 0.55]
    else:
        xrange = [-2.0, 0.6]
        yrange = [-0.1, 0.6]
    if (
        options.type.lower() == "afe"
        or options.type.lower() == "feh"
        or options.type.lower() == "fehafe"
        or options.type.lower() == "afefeh"
    ):
        bovy_plot.bovy_print(fig_height=3.87, fig_width=5.0)
        # Gather hR and hz
        sz_err, sz, hz_err, hr_err, mass_err, mass, hz, hr, afe, feh, ndata = [], [], [], [], [], [], [], [], [], [], []
        for ii in range(len(plotthis)):
            if denserrors:
                hz_err.append(errors[ii][0] * 1000.0)
                hr_err.append(errors[ii][1])
            mass.append(plotthis[ii][5])
            hz.append(plotthis[ii][2])
            hr.append(plotthis[ii][3])
            afe.append(plotthis[ii][1])
            feh.append(plotthis[ii][0])
            ndata.append(plotthis[ii][4])
            if velfitsLoaded:
                sz.append(plotthis[ii][7])
            if velerrors:
                sz_err.append(errors[ii][2])
            if masserrors:
                mass_err.append(numpy.std(numpy.array(plotthis[ii][6]) / 10.0 ** 6.0))

                """
                if options.logmass:
                    mass_err.append(numpy.std(numpy.log10(numpy.array(plotthis[ii][6])/10.**6.)))
                else:
                    mass_err.append(numpy.std(numpy.array(plotthis[ii][6])/10.**6.))
                """
        if denserrors:
            hz_err = numpy.array(hz_err)
            hr_err = numpy.array(hr_err)
        if velfitsLoaded:
            sz = numpy.array(sz)
        if velerrors:
            sz_err = numpy.array(sz_err)
        mass = numpy.array(mass)
        if masserrors:
            mass_err = numpy.array(mass_err)
        hz = numpy.array(hz)
        hr = numpy.array(hr)
        afe = numpy.array(afe)
        feh = numpy.array(feh)
        ndata = numpy.array(ndata)
        # Process ndata
        ndata = ndata ** 0.5
        ndata = ndata / numpy.median(ndata) * 35.0
        # ndata= numpy.log(ndata)/numpy.log(numpy.median(ndata))
        # ndata= (ndata-numpy.amin(ndata))/(numpy.amax(ndata)-numpy.amin(ndata))*25+12.
        if options.type.lower() == "afe":
            plotc = afe
        elif options.type.lower() == "feh":
            plotc = feh
        elif options.type.lower() == "afefeh":
            # Go through the bins to determine whether feh is high or low for this alpha
            plotc = numpy.zeros(len(afe))
            for ii in range(tightbinned.npixfeh()):
                fehbin = ii
                data = tightbinned.data[
                    (tightbinned.data.feh > tightbinned.fehedges[fehbin])
                    * (tightbinned.data.feh <= tightbinned.fehedges[fehbin + 1])
                ]
                medianafe = numpy.median(data.afe)
                for jj in range(len(afe)):
                    if feh[jj] == tightbinned.feh(ii):
                        plotc[jj] = afe[jj] - medianafe
        else:
            # Go through the bins to determine whether feh is high or low for this alpha
            plotc = numpy.zeros(len(feh))
            for ii in range(tightbinned.npixafe()):
                afebin = ii
                data = tightbinned.data[
                    (tightbinned.data.afe > tightbinned.afeedges[afebin])
                    * (tightbinned.data.afe <= tightbinned.afeedges[afebin + 1])
                ]
                medianfeh = numpy.median(data.feh)
                for jj in range(len(feh)):
                    if afe[jj] == tightbinned.afe(ii):
                        plotc[jj] = feh[jj] - medianfeh
        xrange = [150, 1200]
        if options.cumul:
            # Print total surface mass and uncertainty
            totmass = numpy.sum(mass)
            if options.ploterrors:
                toterr = numpy.sqrt(numpy.sum(mass_err ** 2.0))
            else:
                toterr = 0.0
            print "Total surface-mass density: %4.1f +/- %4.2f" % (totmass, toterr)
            ids = numpy.argsort(hz)
            plotc = plotc[ids]
            ndata = ndata[ids]
            mass = mass[ids]
            mass = numpy.cumsum(mass)
            hz.sort()
            ylabel = r"$\mathrm{cumulative}\ \Sigma(R_0)\ [M_{\odot}\ \mathrm{pc}^{-2}]$"
            if options.logmass:
                yrange = [0.01, 30.0]
            else:
                yrange = [-0.1, 30.0]
        else:
            if options.logmass:
                yrange = [0.005 * 0.13 / 0.07, 10.0 * 0.13 / 0.07]
            else:
                yrange = [-0.1, 10.0 * 0.13 / 0.07]
            ylabel = r"$\Sigma_{R_0}(h_z)\ [M_{\odot}\ \mathrm{pc}^{-2}]$"
        if not options.vstructure and not options.hzhr:
            if options.hr:
                ploth = hr
                plotherr = hr_err
                xlabel = r"$\mathrm{radial\ scale\ length\ [kpc]}$"
                xrange = [1.2, 4.0]
                bins = 11
            elif options.sz:
                ploth = sz ** 2.0
                plotherr = 2.0 * sz_err * sz
                xlabel = r"$\sigma_z^2\ \mathrm{[km}^2\ \mathrm{s}^{-2}]$"
                xrange = [12.0 ** 2.0, 50.0 ** 2.0]
                ylabel = r"$\Sigma_{R_0}(\sigma^2_z)\ [M_{\odot}\ \mathrm{pc}^{-2}]$"
                bins = 9
            else:
                ploth = hz
                plotherr = hz_err
                xlabel = r"$\mathrm{vertical\ scale\ height}\ h_z\ \mathrm{[pc]}$"
                xrange = [165, 1200]
                bins = 12
            bovy_plot.bovy_plot(
                ploth,
                mass * 0.13 / 0.07,
                s=ndata,
                c=plotc,
                cmap="jet",
                xlabel=xlabel,
                ylabel=ylabel,
                clabel=zlabel,
                xrange=xrange,
                yrange=yrange,
                vmin=vmin,
                vmax=vmax,
                scatter=True,
                edgecolors="none",
                colorbar=True,
                zorder=2,
                semilogy=options.logmass,
            )
            if not options.cumul and masserrors and options.ploterrors:
                colormap = cm.jet
                for ii in range(len(hz)):
                    pyplot.errorbar(
                        ploth[ii],
                        mass[ii] * 0.13 / 0.07,
                        yerr=mass_err[ii] * 0.13 / 0.07,
                        color=colormap(
                            _squeeze(
                                plotc[ii], numpy.amax([vmin, numpy.amin(plotc)]), numpy.amin([vmax, numpy.amax(plotc)])
                            )
                        ),
                        elinewidth=1.0,
                        capsize=3,
                        zorder=0,
                    )
            if not options.cumul and denserrors and options.ploterrors:
                colormap = cm.jet
                for ii in range(len(hz)):
                    pyplot.errorbar(
                        ploth[ii],
                        mass[ii] * 0.13 / 0.07,
                        xerr=plotherr[ii],
                        color=colormap(
                            _squeeze(
                                plotc[ii], numpy.amax([vmin, numpy.amin(plotc)]), numpy.amin([vmax, numpy.amax(plotc)])
                            )
                        ),
                        elinewidth=1.0,
                        capsize=3,
                        zorder=0,
                    )
            # Add binsize label
            bovy_plot.bovy_text(
                r"$\mathrm{points\ use}\ \Delta [\mathrm{Fe/H}] = 0.1,$"
                + "\n"
                + r"$\Delta [\alpha/\mathrm{Fe}] = 0.05\ \mathrm{bins}$",
                bottom_left=True,
            )
            # Overplot histogram
            # ax2 = pyplot.twinx()
            pyplot.hist(
                ploth,
                range=xrange,
                weights=mass * 0.13 / 0.07,
                color="k",
                histtype="step",
                bins=bins,
                lw=3.0,
                zorder=10,
            )
            # Also XD?
            if options.xd:
                # Set up data
                ydata = numpy.zeros((len(hz), 1))
                if options.sz:
                    ydata[:, 0] = numpy.log(sz)
                else:
                    ydata[:, 0] = numpy.log(hz)
                ycovar = numpy.zeros((len(hz), 1))
                if options.sz:
                    ycovar[:, 0] = sz_err ** 2.0 / sz ** 2.0
                else:
                    ycovar[:, 0] = hz_err ** 2.0 / hz ** 2.0
                # Set up initial conditions
                xamp = numpy.ones(options.k) / float(options.k)
                xmean = numpy.zeros((options.k, 1))
                for kk in range(options.k):
                    xmean[kk, :] = numpy.mean(ydata, axis=0) + numpy.random.normal() * numpy.std(ydata, axis=0)
                xcovar = numpy.zeros((options.k, 1, 1))
                for kk in range(options.k):
                    xcovar[kk, :, :] = numpy.cov(ydata.T)
                # Run XD
                print extreme_deconvolution(ydata, ycovar, xamp, xmean, xcovar, weight=mass) * len(hz)
                print xamp, xmean, xcovar
                # Plot
                xs = numpy.linspace(xrange[0], xrange[1], 1001)
                xdys = numpy.zeros(len(xs))
                for kk in range(options.k):
                    xdys += (
                        xamp[kk]
                        / numpy.sqrt(2.0 * numpy.pi * xcovar[kk, 0, 0])
                        * numpy.exp(-0.5 * (numpy.log(xs) - xmean[kk, 0]) ** 2.0 / xcovar[kk, 0, 0])
                    )
                xdys /= xs
                bovy_plot.bovy_plot(xs, xdys, "-", color="0.5", overplot=True)
            #            ax2.set_yscale('log')
            #            ax2.set_yticklabels('')
            #            if options.hr:
            #                pyplot.ylim(10**-2.,10.**0.)
            #            if options.sz:
            #                pyplot.ylim(10**-5.,10.**-2.5)
            #            else:
            #                pyplot.ylim(10**-5.5,10.**-1.5)
            #            pyplot.xlim(xrange[0],xrange[1])
            ax = pyplot.gca()
            if options.sz:

                def my_formatter(x, pos):
                    """s^2"""
                    xs = int(round(math.sqrt(x)))
                    return r"$%i^2$" % xs

                major_formatter = FuncFormatter(my_formatter)
                ax.xaxis.set_major_formatter(major_formatter)
            xstep = ax.xaxis.get_majorticklocs()
            xstep = xstep[1] - xstep[0]
            ax.xaxis.set_minor_locator(MultipleLocator(xstep / 5.0))
        elif options.hzhr:
            # Make density plot in hR and hz
            bovy_plot.scatterplot(
                hr,
                hz,
                "k,",
                levels=[1.01],  # HACK such that outliers aren't plotted
                cmap="gist_yarg",
                bins=11,
                xrange=[1.0, 7.0],
                yrange=[150.0, 1200.0],
                ylabel=r"$\mathrm{vertical\ scale\ height\ [pc]}$",
                xlabel=r"$\mathrm{radial\ scale\ length\ [kpc]}$",
                onedhists=False,
                weights=mass,
            )
        else:
            # Make an illustrative plot of the vertical structure
            nzs = 1001
            zs = numpy.linspace(200.0, 3000.0, nzs)
            total = numpy.zeros(nzs)
            for ii in range(len(hz)):
                total += mass[ii] / 2.0 / hz[ii] * numpy.exp(-zs / hz[ii])
            bovy_plot.bovy_plot(
                zs,
                total,
                color="k",
                ls="-",
                lw=3.0,
                semilogy=True,
                xrange=[0.0, 3200.0],
                yrange=[0.000001, 0.02],
                xlabel=r"$\mathrm{vertical\ height}\ Z$",
                ylabel=r"$\rho_*(R=R_0,Z)\ [\mathrm{M}_\odot\ \mathrm{pc}^{-3}]$",
                zorder=10,
            )
            if options.vbinned:
                # Bin
                mhist, edges = numpy.histogram(hz, range=xrange, weights=mass, bins=10)
                stotal = numpy.zeros(nzs)
                for ii in range(len(mhist)):
                    hz = (edges[ii + 1] + edges[ii]) / 2.0
                    if options.vcumul:
                        if ii == 0.0:
                            pstotal = numpy.zeros(nzs) + 0.0000001
                        else:
                            pstotal = copy.copy(stotal)
                        stotal += mhist[ii] / 2.0 / hz * numpy.exp(-zs / hz)
                        pyplot.fill_between(zs, stotal, pstotal, color="%.6f" % (0.25 + 0.5 / (len(mhist) - 1) * ii))
                    else:
                        bovy_plot.bovy_plot(
                            [zs[0], zs[-1]],
                            1.0
                            * numpy.array(
                                [
                                    mhist[ii] / 2.0 / hz * numpy.exp(-zs[0] / hz),
                                    mhist[ii] / 2.0 / hz * numpy.exp(-zs[-1] / hz),
                                ]
                            ),
                            color="0.5",
                            ls="-",
                            overplot=True,
                            zorder=0,
                        )
            else:
                colormap = cm.jet
                for ii in range(len(hz)):
                    bovy_plot.bovy_plot(
                        [zs[0], zs[-1]],
                        100.0
                        * numpy.array(
                            [
                                mass[ii] / 2.0 / hz[ii] * numpy.exp(-zs[0] / hz[ii]),
                                mass[ii] / 2.0 / hz[ii] * numpy.exp(-zs[-1] / hz[ii]),
                            ]
                        ),
                        ls="-",
                        overplot=True,
                        alpha=0.5,
                        zorder=0,
                        color=colormap(
                            _squeeze(
                                plotc[ii], numpy.amax([vmin, numpy.amin(plotc)]), numpy.amin([vmax, numpy.amax(plotc)])
                            )
                        ),
                    )
    else:
        bovy_plot.bovy_print()
        bovy_plot.bovy_dens2d(
            plotthis.T,
            origin="lower",
            cmap="gist_yarg",
            interpolation="nearest",
            xlabel=r"$[\mathrm{Fe/H}]$",
            ylabel=r"$[\alpha/\mathrm{Fe}]$",
            zlabel=zlabel,
            xrange=xrange,
            yrange=yrange,
            vmin=vmin,
            vmax=vmax,
            onedhists=True,
            contours=False,
        )
        bovy_plot.bovy_text(title, top_right=True, fontsize=16)
        if not options.distzmin is None or not options.distzmax is None:
            if options.distzmin is None:
                distlabel = r"$|Z| < %i\ \mathrm{pc}$" % int(options.distzmax)
            elif options.distzmax is None:
                distlabel = r"$|Z| > %i\ \mathrm{pc}$" % int(options.distzmin)
            else:
                distlabel = r"$%i < |Z| < %i\ \mathrm{pc}$" % (int(options.distzmin), int(options.distzmax))
            bovy_plot.bovy_text(distlabel, bottom_left=True, fontsize=16)
    bovy_plot.bovy_end_print(options.plotfile)
    return None
Example #4
0
def collateFits(options, args):
    if options.sample.lower() == "g":
        if options.select.lower() == "program":
            raw = read_gdwarfs(_GDWARFFILE, logg=True, ebv=True, sn=True)
        else:
            raw = read_gdwarfs(logg=True, ebv=True, sn=True)
    elif options.sample.lower() == "k":
        if options.select.lower() == "program":
            raw = read_kdwarfs(_KDWARFFILE, logg=True, ebv=True, sn=True)
        else:
            raw = read_kdwarfs(logg=True, ebv=True, sn=True)
    # Bin the data
    binned = pixelAfeFeh(raw, dfeh=options.dfeh, dafe=options.dafe)
    # Savefiles
    if os.path.exists(args[0]):  # Load density fits
        savefile = open(args[0], "rb")
        densfits = pickle.load(savefile)
        savefile.close()
    else:
        raise IOError("density fits file not included")
    if os.path.exists(args[1]):  # Load density fits
        savefile = open(args[1], "rb")
        denssamples = pickle.load(savefile)
        savefile.close()
    else:
        raise IOError("density samples file not included")
    if os.path.exists(args[2]):  # Load density fits
        savefile = open(args[2], "rb")
        mass = pickle.load(savefile)
        savefile.close()
    else:
        raise IOError("masses file not included")
    # if os.path.exists(args[3]):#Load density fits
    #    savefile= open(args[3],'rb')
    #    masssamples= pickle.load(savefile)
    #    savefile.close()
    # else:
    #    raise IOError("mass samples file not included")
    if os.path.exists(args[4]):  # Load density fits
        savefile = open(args[4], "rb")
        velfits = pickle.load(savefile)
        savefile.close()
    else:
        raise IOError("vertical velocity file not included")
    if os.path.exists(args[5]):  # Load density fits
        savefile = open(args[5], "rb")
        velsamples = pickle.load(savefile)
        savefile.close()
    else:
        raise IOError("vertical velocity samples  file not included")
    if os.path.exists(args[6]):  # Load density fits
        savefile = open(args[6], "rb")
        velrfits = pickle.load(savefile)
        savefile.close()
    else:
        raise IOError("radial velocity file not included")
    if os.path.exists(args[7]):  # Load density fits
        savefile = open(args[7], "rb")
        velrsamples = pickle.load(savefile)
        savefile.close()
    else:
        raise IOError("radial velocity samples  file not included")
    nrecs = len([r for r in densfits if not r is None])
    out = numpy.recarray(
        nrecs,
        dtype=[
            ("feh", float),
            ("afe", float),
            ("hz", float),
            ("hr", float),
            ("bc", float),
            ("mass", float),
            ("sz", float),
            ("hsz", float),
            ("p1", float),
            ("p2", float),
            ("sr", float),
            ("hsr", float),
            ("zmin", float),
            ("zmax", float),
            ("zmedian", float),
            ("hz_err", float),
            ("hr_err", float),
            ("mass_err", float),
            ("sz_err", float),
            ("hsz_err", float),
            ("p1_err", float),
            ("p2_err", float),
            ("szp1_corr", float),
            ("szp2_corr", float),
            ("szhsz_corr", float),
            ("p1hsz_corr", float),
            ("p2hsz_corr", float),
            ("p1p2_corr", float),
            ("sr_err", float),
        ],
    )

    nout = 0
    # Start filling it up
    for ii in range(binned.npixfeh()):
        for jj in range(binned.npixafe()):
            data = binned(binned.feh(ii), binned.afe(jj))
            fehindx = binned.fehindx(binned.feh(ii))  # Map onto regular binning
            afeindx = binned.afeindx(binned.afe(jj))  # Unnecessary here
            if afeindx + fehindx * binned.npixafe() >= len(densfits):
                continue
            thisdensfit = densfits[afeindx + fehindx * binned.npixafe()]
            thisdenssamples = denssamples[afeindx + fehindx * binned.npixafe()]
            thismass = mass[afeindx + fehindx * binned.npixafe()]
            # thismasssamples= masssamples[afeindx+fehindx*binned.npixafe()]
            thisvelfit = velfits[afeindx + fehindx * binned.npixafe()]
            thesevelsamples = velsamples[afeindx + fehindx * binned.npixafe()]
            thisvelrfit = velrfits[afeindx + fehindx * binned.npixafe()]
            thesevelrsamples = velrsamples[afeindx + fehindx * binned.npixafe()]
            if thisdensfit is None:
                continue
            if len(data) < options.minndata:
                continue
            out["feh"][nout] = binned.feh(ii)
            out[nout]["afe"] = binned.afe(jj)
            if options.densmodel.lower() == "hwr" or options.densmodel.lower() == "dblexp":
                out[nout]["hz"] = numpy.exp(thisdensfit[0]) * 1000.0
                if options.densmodel.lower() == "dblexp":
                    out[nout]["hr"] = numpy.exp(-thisdensfit[1])
                else:
                    out[nout]["hr"] = numpy.exp(thisdensfit[1])
                out[nout]["bc"] = thisdensfit[2]
                theseerrors = []
                xs = numpy.array([s[0] for s in thisdenssamples])
                theseerrors.append(
                    0.5 * (-numpy.exp(numpy.mean(xs) - numpy.std(xs)) + numpy.exp(numpy.mean(xs) + numpy.std(xs)))
                )
                out[nout]["hz_err"] = theseerrors[0] * 1000.0
                if options.densmodel.lower() == "dblexp":
                    xs = numpy.array([-s[1] for s in thisdenssamples])
                else:
                    xs = numpy.array([s[1] for s in thisdenssamples])
                theseerrors.append(
                    0.5 * (-numpy.exp(numpy.mean(xs) - numpy.std(xs)) + numpy.exp(numpy.mean(xs) + numpy.std(xs)))
                )
                out[nout]["hr_err"] = theseerrors[1]
            # mass
            if options.sample.lower() == "k":
                out[nout]["mass"] = numpy.nan
            else:
                out[nout]["mass"] = thismass / 10.0 ** 6.0
            # out[nout]['mass_err']= numpy.std(numpy.array(thismasssamples)/10.**6.)
            # Velocities
            if options.velmodel.lower() == "hwr":
                out[nout]["sz"] = numpy.exp(thisvelfit[1])
                out[nout]["hsz"] = numpy.exp(thisvelfit[4])
                out[nout]["sr"] = numpy.exp(thisvelrfit[1])
                out[nout]["hsr"] = numpy.exp(thisvelrfit[4])
                out[nout]["p1"] = thisvelfit[2]
                out[nout]["p2"] = thisvelfit[3]
                zsorted = sorted(numpy.fabs(data.zc + _ZSUN))
                out[nout]["zmin"] = zsorted[int(numpy.ceil(0.16 * len(zsorted)))] * 1000.0
                out[nout]["zmax"] = zsorted[int(numpy.floor(0.84 * len(zsorted)))] * 1000.0
                out[nout]["zmedian"] = numpy.median(numpy.fabs(data.zc) - _ZSUN) * 1000.0
                # Errors
                xs = numpy.array([s[1] for s in thesevelsamples])
                out[nout]["sz_err"] = 0.5 * (
                    -numpy.exp(numpy.mean(xs) - numpy.std(xs)) + numpy.exp(numpy.mean(xs) + numpy.std(xs))
                )
                xs = numpy.array([s[4] for s in thesevelsamples])
                out[nout]["hsz_err"] = 0.5 * (
                    -numpy.exp(numpy.mean(xs) - numpy.std(xs)) + numpy.exp(numpy.mean(xs) + numpy.std(xs))
                )
                xs = numpy.array([s[2] for s in thesevelsamples])
                out[nout]["p1_err"] = numpy.std(xs)
                xs = numpy.array([s[3] for s in thesevelsamples])
                out[nout]["p2_err"] = numpy.std(xs)
                xs = numpy.exp(numpy.array([s[1] for s in thesevelsamples]))
                ys = numpy.array([s[2] for s in thesevelsamples])
                out[nout]["szp1_corr"] = numpy.corrcoef(xs, ys)[0, 1]
                ys = numpy.array([s[3] for s in thesevelsamples])
                out[nout]["szp2_corr"] = numpy.corrcoef(xs, ys)[0, 1]
                xs = numpy.array([s[2] for s in thesevelsamples])
                out[nout]["p1p2_corr"] = numpy.corrcoef(xs, ys)[0, 1]
                xs = numpy.exp(numpy.array([s[4] for s in thesevelsamples]))
                ys = numpy.exp(numpy.array([s[1] for s in thesevelsamples]))
                out[nout]["szhsz_corr"] = numpy.corrcoef(xs, ys)[0, 1]
                ys = numpy.array([s[2] for s in thesevelsamples])
                out[nout]["p1hsz_corr"] = numpy.corrcoef(xs, ys)[0, 1]
                ys = numpy.array([s[3] for s in thesevelsamples])
                out[nout]["p2hsz_corr"] = numpy.corrcoef(xs, ys)[0, 1]
                xs = numpy.array([s[1] for s in thesevelrsamples])
                out[nout]["sr_err"] = 0.5 * (
                    -numpy.exp(numpy.mean(xs) - numpy.std(xs)) + numpy.exp(numpy.mean(xs) + numpy.std(xs))
                )
            nout += 1
    # Write output
    fitsio.write(options.outfile, out, clobber=True)
Example #5
0
def pixelFitVel(options, args):
    if options.sample.lower() == "g":
        if options.select.lower() == "program":
            raw = read_gdwarfs(_GDWARFFILE, logg=True, ebv=True, sn=options.snmin, distfac=options.distfac)
        else:
            raw = read_gdwarfs(logg=True, ebv=True, sn=options.snmin, distfac=options.distfac)
    elif options.sample.lower() == "k":
        if options.select.lower() == "program":
            raw = read_kdwarfs(_KDWARFFILE, logg=True, ebv=True, sn=options.snmin, distfac=options.distfac)
        else:
            raw = read_kdwarfs(logg=True, ebv=True, sn=options.snmin, distfac=options.distfac)
    if not options.bmin is None:
        # Cut on |b|
        raw = raw[(numpy.fabs(raw.b) > options.bmin)]
    # Bin the data
    binned = pixelAfeFeh(raw, dfeh=options.dfeh, dafe=options.dafe)
    # Savefile
    if os.path.exists(args[0]):  # Load savefile
        savefile = open(args[0], "rb")
        fits = pickle.load(savefile)
        ii = pickle.load(savefile)
        jj = pickle.load(savefile)
        savefile.close()
    else:
        fits = []
        ii, jj = 0, 0
    # Sample?
    if options.mcsample:
        if ii < len(binned.fehedges) - 1 and jj < len(binned.afeedges) - 1:
            print "First do all of the fits ..."
            print "Returning ..."
            return None
        if os.path.exists(args[1]):  # Load savefile
            savefile = open(args[1], "rb")
            samples = pickle.load(savefile)
            ii = pickle.load(savefile)
            jj = pickle.load(savefile)
            savefile.close()
        else:
            samples = []
            ii, jj = 0, 0
    # Model
    if options.model.lower() == "hwr":
        like_func = _HWRLikeMinus
        pdf_func = _HWRLike
        step = [0.01, 0.3, 0.3, 0.3, 0.3]
        create_method = ["full", "step_out", "step_out", "step_out", "step_out"]
        isDomainFinite = [[True, True], [True, True], [True, True], [True, True], [False, True]]
        domain = [[0.0, 1.0], [-10.0, 10.0], [-100.0, 100.0], [-100.0, 100.0], [0.0, 4.6051701859880918]]
    elif options.model.lower() == "hwrrz":
        like_func = _HWRRZLikeMinus
        pdf_func = _HWRRZLike
        step = [0.01, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3]
        create_method = [
            "full",
            "step_out",
            "step_out",
            "step_out",
            "step_out",
            "step_out",
            "step_out",
            "step_out",
            "step_out",
            "step_out",
            "step_out",
        ]
        #                       'step_out']
        isDomainFinite = [
            [True, True],
            [True, True],
            [True, True],
            [True, True],
            [False, True],
            [True, True],
            [True, True],
            [True, True],
            [False, True],
            [True, True],
            [True, True],
        ]  # ,[True,True]]
        domain = [
            [0.0, 1.0],
            [-10.0, 10.0],
            [-100.0, 100.0],
            [-100.0, 100.0],
            [0.0, 4.6051701859880918],
            [-10.0, 10.0],
            [-100.0, 100.0],
            [-100.0, 100.0],
            [0.0, 4.6051701859880918],
            [-2.0, 2.0],
            [-10.0, 10.0],
        ]  # ,[-100.,100.]]
    elif options.model.lower() == "isotherm":
        like_func = _IsothermLikeMinus
        pdf_func = _IsothermLike
        step = [0.01, 0.05, 0.3]
        create_method = ["full", "step_out", "step_out"]
        isDomainFinite = [[True, True], [False, False], [False, True]]
        domain = [[0.0, 1.0], [0.0, 0.0], [0.0, 4.6051701859880918]]
    # Run through the bins
    while ii < len(binned.fehedges) - 1:
        while jj < len(binned.afeedges) - 1:
            data = binned(binned.feh(ii), binned.afe(jj))
            if len(data) < options.minndata:
                if options.mcsample:
                    samples.append(None)
                else:
                    fits.append(None)
                jj += 1
                if jj == len(binned.afeedges) - 1:
                    jj = 0
                    ii += 1
                    break
                continue
            print binned.feh(ii), binned.afe(jj), len(data)
            # Create XYZ and R, vxvyvz, cov_vxvyvz
            R = ((8.0 - data.xc) ** 2.0 + data.yc ** 2.0) ** 0.5
            # Confine to R-range?
            if not options.rmin is None and not options.rmax is None:
                dataindx = (R >= options.rmin) * (R < options.rmax)
                data = data[dataindx]
                R = R[dataindx]
            XYZ = numpy.zeros((len(data), 3))
            XYZ[:, 0] = data.xc
            XYZ[:, 1] = data.yc
            XYZ[:, 2] = data.zc + _ZSUN
            if options.pivotmean:
                d = numpy.fabs((XYZ[:, 2] - numpy.mean(numpy.fabs(XYZ[:, 2]))))
            else:
                d = numpy.fabs((XYZ[:, 2] - numpy.median(numpy.fabs(XYZ[:, 2]))))
            vxvyvz = numpy.zeros((len(data), 3))
            vxvyvz[:, 0] = data.vxc
            vxvyvz[:, 1] = data.vyc
            vxvyvz[:, 2] = data.vzc
            cov_vxvyvz = numpy.zeros((len(data), 3, 3))
            cov_vxvyvz[:, 0, 0] = data.vxc_err ** 2.0
            cov_vxvyvz[:, 1, 1] = data.vyc_err ** 2.0
            cov_vxvyvz[:, 2, 2] = data.vzc_err ** 2.0
            cov_vxvyvz[:, 0, 1] = data.vxvyc_rho * data.vxc_err * data.vyc_err
            cov_vxvyvz[:, 0, 2] = data.vxvzc_rho * data.vxc_err * data.vzc_err
            cov_vxvyvz[:, 1, 2] = data.vyvzc_rho * data.vyc_err * data.vzc_err
            if options.vr or options.vrz:
                # Rotate vxvyvz to vRvTvz
                cosphi = (8.0 - XYZ[:, 0]) / R
                sinphi = XYZ[:, 1] / R
                vR = -vxvyvz[:, 0] * cosphi + vxvyvz[:, 1] * sinphi
                vT = vxvyvz[:, 0] * sinphi + vxvyvz[:, 1] * cosphi
                # Subtract mean vR
                vR -= numpy.mean(vR)
                vxvyvz[:, 0] = vR
                vxvyvz[:, 1] = vT
                for rr in range(len(XYZ[:, 0])):
                    rot = numpy.array([[cosphi[rr], sinphi[rr]], [-sinphi[rr], cosphi[rr]]])
                    sxy = cov_vxvyvz[rr, 0:2, 0:2]
                    sRT = numpy.dot(rot, numpy.dot(sxy, rot.T))
                    cov_vxvyvz[rr, 0:2, 0:2] = sRT
            # Fit this data
            # Initial condition
            if options.model.lower() == "hwr":
                params = numpy.array([0.02, numpy.log(30.0), 0.0, 0.0, numpy.log(6.0)])
            elif options.model.lower() == "hwrrz":
                params = numpy.array(
                    [
                        0.02,
                        numpy.log(30.0),
                        0.0,
                        0.0,
                        numpy.log(6.0),
                        numpy.log(30.0),
                        0.0,
                        0.0,
                        numpy.log(6.0),
                        0.2,
                        0.0,
                    ]
                )  # ,0.])
            elif options.model.lower() == "isotherm":
                params = numpy.array([0.02, numpy.log(30.0), numpy.log(6.0)])
            if not options.mcsample:
                # Optimize likelihood
                params = optimize.fmin_powell(
                    like_func, params, args=(XYZ, vxvyvz, cov_vxvyvz, R, d, options.vr, options.vrz)
                )
                if options.chi2:
                    # Calculate chi2 and chi2/dof
                    chi2, dof = like_func(params, XYZ, vxvyvz, cov_vxvyvz, R, d, options.vr, options.vrz, chi2=True)
                    dof -= len(params)
                    params.resize(len(params) + 2)
                    params[-2] = chi2
                    params[-1] = chi2 / dof
                print numpy.exp(params)
                fits.append(params)
            else:
                # Load best-fit params
                params = fits[jj + ii * binned.npixafe()]
                print numpy.exp(params)
                thesesamples = bovy_mcmc.markovpy(
                    params,
                    # thesesamples= bovy_mcmc.slice(params,
                    # step,
                    0.01,
                    pdf_func,
                    (XYZ, vxvyvz, cov_vxvyvz, R, d, options.vr),  # options.vrz),
                    # create_method=create_method,
                    isDomainFinite=isDomainFinite,
                    domain=domain,
                    nsamples=options.nsamples,
                )
                # Print some helpful stuff
                printthis = []
                for kk in range(len(params)):
                    xs = numpy.array([s[kk] for s in thesesamples])
                    printthis.append(
                        0.5
                        * (
                            numpy.exp(numpy.mean(xs))
                            - numpy.exp(numpy.mean(xs) - numpy.std(xs))
                            - numpy.exp(numpy.mean(xs))
                            + numpy.exp(numpy.mean(xs) + numpy.std(xs))
                        )
                    )
                print printthis
                samples.append(thesesamples)
            jj += 1
            if jj == len(binned.afeedges) - 1:
                jj = 0
                ii += 1
            if options.mcsample:
                save_pickles(args[1], samples, ii, jj)
            else:
                save_pickles(args[0], fits, ii, jj)
            if jj == 0:  # this means we've reset the counter
                break
    if options.mcsample:
        save_pickles(args[1], samples, ii, jj)
    else:
        save_pickles(args[0], fits, ii, jj)
    return None
Example #6
0
def plot_distsystematic(options, args):
    if options.sample.lower() == "g":
        if options.select.lower() == "program":
            raw = read_gdwarfs(_GDWARFFILE, logg=True, ebv=True, sn=options.snmin)
        else:
            raw = read_gdwarfs(logg=True, ebv=True, sn=options.snmin)
    elif options.sample.lower() == "k":
        if options.select.lower() == "program":
            raw = read_kdwarfs(_KDWARFFILE, logg=True, ebv=True, sn=options.snmin)
        else:
            raw = read_kdwarfs(logg=True, ebv=True, sn=options.snmin)
    if not options.bmin is None:
        # Cut on |b|
        raw = raw[(numpy.fabs(raw.b) > options.bmin)]
    # Bin the data
    binned = pixelAfeFeh(raw, dfeh=options.dfeh, dafe=options.dafe)
    if options.tighten:
        tightbinned = pixelAfeFeh(
            raw, dfeh=options.dfeh, dafe=options.dafe, fehmin=-1.6, fehmax=0.5, afemin=-0.05, afemax=0.55
        )
    else:
        tightbinned = binned
    plotthis = numpy.zeros((tightbinned.npixfeh(), tightbinned.npixafe())) + numpy.nan
    # Run through the bins
    for ii in range(tightbinned.npixfeh()):
        for jj in range(tightbinned.npixafe()):
            data = binned(tightbinned.feh(ii), tightbinned.afe(jj))
            if len(data) < options.minndata:
                jj += 1
                if jj == len(binned.afeedges) - 1:
                    jj = 0
                    ii += 1
                    break
                continue
            # Create XYZ and R, vxvyvz, cov_vxvyvz
            R = ((8.0 - data.xc) ** 2.0 + data.yc ** 2.0) ** 0.5
            # Confine to R-range?
            if not options.rmin is None and not options.rmax is None:
                dataindx = (R >= options.rmin) * (R < options.rmax)
                data = data[dataindx]
                R = R[dataindx]
            XYZ = numpy.zeros((len(data), 3))
            XYZ[:, 0] = data.xc
            XYZ[:, 1] = data.yc
            XYZ[:, 2] = data.zc + _ZSUN
            vxvyvz = numpy.zeros((len(data), 3))
            vxvyvz[:, 0] = data.vxc
            vxvyvz[:, 1] = data.vyc
            vxvyvz[:, 2] = data.vzc
            """
            cov_vxvyvz= numpy.zeros((len(data),3,3))
            cov_vxvyvz[:,0,0]= data.vxc_err**2.
            cov_vxvyvz[:,1,1]= data.vyc_err**2.
            cov_vxvyvz[:,2,2]= data.vzc_err**2.
            cov_vxvyvz[:,0,1]= data.vxvyc_rho*data.vxc_err*data.vyc_err
            cov_vxvyvz[:,0,2]= data.vxvzc_rho*data.vxc_err*data.vzc_err
            cov_vxvyvz[:,1,2]= data.vyvzc_rho*data.vyc_err*data.vzc_err
            """
            cosphi = (8.0 - XYZ[:, 0]) / R
            sinphi = XYZ[:, 1] / R
            sinbeta = XYZ[:, 2] / numpy.sqrt(R * R + XYZ[:, 2] * XYZ[:, 2])
            cosbeta = R / numpy.sqrt(R * R + XYZ[:, 2] * XYZ[:, 2])
            ndata = len(data.ra)
            cov_pmradec = numpy.zeros((ndata, 2, 2))
            cov_pmradec[:, 0, 0] = data.pmra_err ** 2.0
            cov_pmradec[:, 1, 1] = data.pmdec_err ** 2.0
            cov_pmllbb = bovy_coords.cov_pmrapmdec_to_pmllpmbb(cov_pmradec, data.ra, data.dec, degree=True)
            """
            vR= -vxvyvz[:,0]*cosphi+vxvyvz[:,1]*sinphi
            vT= vxvyvz[:,0]*sinphi+vxvyvz[:,1]*cosphi
            vz= vxvyvz[:,2]
            vxvyvz[:,0]= vR               
            vxvyvz[:,1]= vT
            for rr in range(len(XYZ[:,0])):
                rot= numpy.array([[cosphi[rr],sinphi[rr]],
                                  [-sinphi[rr],cosphi[rr]]])
                sxy= cov_vxvyvz[rr,0:2,0:2]
                sRT= numpy.dot(rot,numpy.dot(sxy,rot.T))
                cov_vxvyvz[rr,0:2,0:2]= sRT
            """
            # calculate x and y
            lb = bovy_coords.radec_to_lb(data.ra, data.dec, degree=True)
            lb *= _DEGTORAD
            tuu = 1.0 - numpy.cos(lb[:, 1]) ** 2.0 * numpy.cos(lb[:, 0]) ** 2.0
            tuv = -0.5 * numpy.cos(lb[:, 1]) ** 2.0 * numpy.sin(2.0 * lb[:, 0])
            tuw = -0.5 * numpy.cos(lb[:, 0]) * numpy.sin(2.0 * lb[:, 1])
            tvv = 1.0 - numpy.cos(lb[:, 1]) ** 2.0 * numpy.sin(lb[:, 0]) ** 2.0
            tvw = -0.5 * numpy.sin(2.0 * lb[:, 1]) * numpy.sin(lb[:, 0])
            tww = numpy.cos(lb[:, 1]) ** 2.0
            # x= tuu*_VRSUN+tuv*vxvyvz[:,1]+tuw*vxvyvz[:,2]
            # y= -tww*_VZSUN+tuw*vxvyvz[:,0]+tvw*vxvyvz[:,1]
            x = -tuu * numpy.mean(vxvyvz[:, 0]) + tuv * vxvyvz[:, 1] + tuw * vxvyvz[:, 2]
            y = -tww * numpy.mean(vxvyvz[:, 2]) + tuw * vxvyvz[:, 0] + tvw * vxvyvz[:, 1]
            if options.type.lower() == "u":
                corcorr = 0.0
                plotthis[ii, jj] = (numpy.mean(vxvyvz[:, 0] * x) - numpy.mean(vxvyvz[:, 0]) * numpy.mean(x)) / (
                    numpy.var(x) + numpy.mean(tuv ** 2.0 + tuw ** 2.0) * numpy.var(vxvyvz[:, 0])
                )
            elif options.type.lower() == "meanu":
                plotthis[ii, jj] = numpy.mean(vxvyvz[:, 0])
            elif options.type.lower() == "meanw":
                plotthis[ii, jj] = numpy.mean(vxvyvz[:, 2])
            else:
                corcorr = (
                    0.25
                    * numpy.mean(2.0 * sinbeta * cosbeta * numpy.sin(2.0 * lb[:, 1]) * numpy.cos(lb[:, 0]) * cosphi)
                    * (numpy.var(vxvyvz[:, 0]) - numpy.var(vxvyvz[:, 2]))
                    - 0.25
                    * numpy.mean(2.0 * sinbeta * cosbeta * numpy.sin(2.0 * lb[:, 1]) * numpy.sin(lb[:, 0]) * sinphi)
                    * (numpy.var(vxvyvz[:, 0]) - numpy.var(vxvyvz[:, 2]))
                    + 0.25
                    * numpy.mean(
                        numpy.sin(lb[:, 1]) ** 2.0
                        * (cov_pmllbb[:, 1, 1] * data.dist ** 2.0 * 4.74 ** 2.0 - data.vr_err ** 2.0)
                    )
                )
                plotthis[ii, jj] = (
                    numpy.mean(vxvyvz[:, 2] * y) - numpy.mean(vxvyvz[:, 2]) * numpy.mean(y) - corcorr
                ) / (numpy.var(y) + numpy.mean(tvw ** 2.0 + tuw ** 2.0) * numpy.var(vxvyvz[:, 2]))
            # print ii, jj, plotthis[ii,jj], corcorr, numpy.mean(vxvyvz[:,2]*y)-numpy.mean(vxvyvz[:,2])*numpy.mean(y)-corcorr
            jj += 1
            if jj == len(binned.afeedges) - 1:
                jj = 0
                ii += 1
            if jj == 0:  # this means we've reset the counter
                break
    # print plotthis
    # Set up plot
    if options.type.lower() == "meanu":
        vmin, vmax = -20.0, 20.0
        zlabel = r"$\mathrm{mean}\ U$"
    elif options.type.lower() == "meanw":
        vmin, vmax = -20.0, 20.0
        zlabel = r"$\mathrm{mean}\ W$"
    else:
        vmin, vmax = -0.2, 0.2
        zlabel = r"$\mathrm{fractional\ distance\ overestimate}$"
    if options.tighten:
        xrange = [-1.6, 0.5]
        yrange = [-0.05, 0.55]
    else:
        xrange = [-2.0, 0.5]
        yrange = [-0.2, 0.6]
    bovy_plot.bovy_print()
    bovy_plot.bovy_dens2d(
        plotthis.T,
        origin="lower",
        cmap="jet",
        interpolation="nearest",
        xlabel=r"$[\mathrm{Fe/H}]$",
        ylabel=r"$[\alpha/\mathrm{Fe}]$",
        zlabel=zlabel,
        xrange=xrange,
        yrange=yrange,
        vmin=vmin,
        vmax=vmax,
        contours=False,
        colorbar=True,
        shrink=0.78,
    )
    bovy_plot.bovy_text(
        r"$\mathrm{median} = %.2f$" % (numpy.median(plotthis[numpy.isfinite(plotthis)])), bottom_left=True, size=14.0
    )
    bovy_plot.bovy_end_print(options.outfilename)
    return None
Example #7
0
def generate_fakeDFData(options, args):
    # Check whether the savefile already exists
    if os.path.exists(args[0]):
        savefile = open(args[0], "rb")
        print "Savefile already exists, not re-sampling and overwriting ..."
        return None
    # Read the data
    print "Reading the data ..."
    if options.sample.lower() == "g":
        if options.select.lower() == "program":
            raw = read_gdwarfs(_GDWARFFILE, logg=True, ebv=True, sn=options.snmin, nosolar=True, nocoords=True)
        else:
            raw = read_gdwarfs(logg=True, ebv=True, sn=options.snmin, nosolar=True, nocoords=True)
    elif options.sample.lower() == "k":
        if options.select.lower() == "program":
            raw = read_kdwarfs(_KDWARFFILE, logg=True, ebv=True, sn=options.snmin, nosolar=True, nocoords=True)
        else:
            raw = read_kdwarfs(logg=True, ebv=True, sn=options.snmin, nosolar=True, nocoords=True)
    if not options.bmin is None:
        # Cut on |b|
        raw = raw[(numpy.fabs(raw.b) > options.bmin)]
    if not options.fehmin is None:
        raw = raw[(raw.feh >= options.fehmin)]
    if not options.fehmax is None:
        raw = raw[(raw.feh < options.fehmax)]
    if not options.afemin is None:
        raw = raw[(raw.afe >= options.afemin)]
    if not options.afemax is None:
        raw = raw[(raw.afe < options.afemax)]
    if not options.plate is None and not options.loo:
        raw = raw[(raw.plate == options.plate)]
    elif not options.plate is None:
        raw = raw[(raw.plate != options.plate)]
    # Bin the data
    binned = pixelAfeFeh(raw, dfeh=options.dfeh, dafe=options.dafe)
    # Map the bins with ndata > minndata in 1D
    fehs, afes = [], []
    for ii in range(len(binned.fehedges) - 1):
        for jj in range(len(binned.afeedges) - 1):
            data = binned(binned.feh(ii), binned.afe(jj))
            if len(data) < options.minndata:
                continue
            fehs.append(binned.feh(ii))
            afes.append(binned.afe(jj))
    nabundancebins = len(fehs)
    fehs = numpy.array(fehs)
    afes = numpy.array(afes)
    if not options.singlefeh is None:
        if options.loo:
            pass
        else:
            # Set up single feh
            indx = binned.callIndx(options.singlefeh, options.singleafe)
            if numpy.sum(indx) == 0:
                raise IOError("Bin corresponding to singlefeh and singleafe is empty ...")
            data = copy.copy(binned.data[indx])
            print "Using %i data points ..." % (len(data))
            # Bin again
            binned = pixelAfeFeh(data, dfeh=options.dfeh, dafe=options.dafe)
            fehs, afes = [], []
            for ii in range(len(binned.fehedges) - 1):
                for jj in range(len(binned.afeedges) - 1):
                    data = binned(binned.feh(ii), binned.afe(jj))
                    if len(data) < options.minndata:
                        continue
                    fehs.append(binned.feh(ii))
                    afes.append(binned.afe(jj))
            nabundancebins = len(fehs)
            fehs = numpy.array(fehs)
            afes = numpy.array(afes)
    # Setup the selection function
    # Load selection function
    plates = numpy.array(list(set(list(raw.plate))), dtype="int")  # Only load plates that we use
    print "Using %i plates, %i stars ..." % (len(plates), len(raw))
    sf = segueSelect(
        plates=plates,
        type_faint="tanhrcut",
        sample=options.sample,
        type_bright="tanhrcut",
        sn=options.snmin,
        select=options.select,
        indiv_brightlims=options.indiv_brightlims,
    )
    platelb = bovy_coords.radec_to_lb(sf.platestr.ra, sf.platestr.dec, degree=True)
    if options.sample.lower() == "g":
        grmin, grmax = 0.48, 0.55
        rmin, rmax = 14.50001, 20.199999  # so we don't go out of the range
    if options.sample.lower() == "k":
        grmin, grmax = 0.55, 0.75
        rmin, rmax = 14.50001, 18.999999
    colorrange = [grmin, grmax]
    mapfehs = monoAbundanceMW.fehs()
    mapafes = monoAbundanceMW.afes()
    # Setup params
    if not options.init is None:
        # Load initial parameters from file
        savefile = open(options.init, "rb")
        tparams = pickle.load(savefile)
        savefile.close()
        # Setup the correct form
        params = initialize(options, fehs, afes)
        params[0:6] = get_dfparams(tparams, options.index, options, log=True)
        params[6:11] = tparams[-5 : len(tparams)]
    else:
        params = initialize(options, fehs, afes)
    # Setup potential
    if (
        options.potential.lower() == "flatlog" or options.potential.lower() == "flatlogdisk"
    ) and not options.flatten is None:
        # Set flattening
        potparams = list(get_potparams(params, options, len(fehs)))
        potparams[0] = options.flatten
        params = set_potparams(potparams, params, options, len(fehs))
    pot = setup_potential(params, options, len(fehs))
    aA = setup_aA(pot, options)
    if not options.multi is None:
        binned = fakeDFData_abundance_singles(binned, options, args, fehs, afes)
    else:
        for ii in range(len(fehs)):
            print "Working on population %i / %i ..." % (ii + 1, len(fehs))
            # Setup qdf
            dfparams = get_dfparams(params, ii, options, log=False)
            vo = get_vo(params, options, len(fehs))
            ro = get_ro(params, options)
            if options.dfmodel.lower() == "qdf":
                # Normalize
                hr = dfparams[0] / ro
                sr = dfparams[1] / vo
                sz = dfparams[2] / vo
                hsr = dfparams[3] / ro
                hsz = dfparams[4] / ro
            print hr, sr, sz, hsr, hsz
            qdf = quasiisothermaldf(hr, sr, sz, hsr, hsz, pot=pot, aA=aA, cutcounter=True)
            # Some more selection stuff
            data = binned(fehs[ii], afes[ii])
            # feh and color
            feh = fehs[ii]
            fehrange = [feh - options.dfeh / 2.0, feh + options.dfeh / 2.0]
            # FeH
            fehdist = DistSpline(
                *numpy.histogram(data.feh, bins=5, range=fehrange), xrange=fehrange, dontcuttorange=False
            )
            # Color
            colordist = DistSpline(
                *numpy.histogram(data.dered_g - data.dered_r, bins=9, range=colorrange), xrange=colorrange
            )
            # Re-sample
            binned = fakeDFData(
                binned,
                qdf,
                ii,
                params,
                fehs,
                afes,
                options,
                rmin,
                rmax,
                platelb,
                grmin,
                grmax,
                fehrange,
                colordist,
                fehdist,
                feh,
                sf,
                mapfehs,
                mapafes,
                ro=None,
                vo=None,
            )
    # Save to new file
    fitsio.write(args[0], binned.data)
    return None
Example #8
0
def plotTilt(options, args):
    if options.sample.lower() == "g":
        if options.select.lower() == "program":
            raw = read_gdwarfs(_GDWARFFILE, logg=True, ebv=True, sn=True)
        else:
            raw = read_gdwarfs(logg=True, ebv=True, sn=True)
    elif options.sample.lower() == "k":
        if options.select.lower() == "program":
            raw = read_kdwarfs(_KDWARFFILE, logg=True, ebv=True, sn=True)
        else:
            raw = read_kdwarfs(logg=True, ebv=True, sn=True)
    # Bin the data
    binned = pixelAfeFeh(raw, dfeh=options.dfeh, dafe=options.dafe)
    if options.tighten:
        tightbinned = pixelAfeFeh(
            raw, dfeh=options.dfeh, dafe=options.dafe, fehmin=-1.6, fehmax=0.5, afemin=-0.05, afemax=0.55
        )
    else:
        tightbinned = binned
    # Savefile1
    if os.path.exists(args[0]):  # Load savefile
        savefile = open(args[0], "rb")
        velfits = pickle.load(savefile)
        savefile.close()
    # Uncertainties are in savefile2
    if len(args) > 2 and os.path.exists(args[2]):
        savefile = open(args[2], "rb")
        velsamples = pickle.load(savefile)
        savefile.close()
        velerrors = True
    else:
        velsamples = None
        velerrors = False
    # Now plot
    # Run through the pixels and gather
    if (
        options.type.lower() == "afe"
        or options.type.lower() == "feh"
        or options.type.lower() == "fehafe"
        or options.type.lower() == "zfunc"
        or options.type.lower() == "afefeh"
    ):
        plotthis = []
        errors = []
    else:
        plotthis = numpy.zeros((tightbinned.npixfeh(), tightbinned.npixafe()))
    for ii in range(tightbinned.npixfeh()):
        for jj in range(tightbinned.npixafe()):
            data = binned(tightbinned.feh(ii), tightbinned.afe(jj))
            fehindx = binned.fehindx(tightbinned.feh(ii))  # Map onto regular binning
            afeindx = binned.afeindx(tightbinned.afe(jj))
            if afeindx + fehindx * binned.npixafe() >= len(velfits) or afeindx + fehindx * binned.npixafe() >= len(
                velfits
            ):
                if (
                    options.type.lower() == "afe"
                    or options.type.lower() == "feh"
                    or options.type.lower() == "fehafe"
                    or options.type.lower() == "zfunc"
                    or options.type.lower() == "afefeh"
                ):
                    continue
                else:
                    plotthis[ii, jj] = numpy.nan
                    continue
            thisvelfit = velfits[afeindx + fehindx * binned.npixafe()]
            if thisvelfit is None:
                if (
                    options.type.lower() == "afe"
                    or options.type.lower() == "feh"
                    or options.type.lower() == "fehafe"
                    or options.type.lower() == "zfunc"
                    or options.type.lower() == "afefeh"
                ):
                    continue
                else:
                    plotthis[ii, jj] = numpy.nan
                    continue
            if len(data) < options.minndata:
                if (
                    options.type.lower() == "afe"
                    or options.type.lower() == "feh"
                    or options.type.lower() == "fehafe"
                    or options.type.lower() == "zfunc"
                    or options.type.lower() == "afefeh"
                ):
                    continue
                else:
                    plotthis[ii, jj] = numpy.nan
                    continue
            if options.type == "tilt":
                plotthis[ii, jj] = numpy.arctan(thisvelfit[9]) / _DEGTORAD
            elif options.type == "tiltslope":
                plotthis[ii, jj] = thisvelfit[10]
            elif options.type == "srz":
                plotthis[ii, jj] = (
                    (numpy.exp(2.0 * thisvelfit[5]) - numpy.exp(2.0 * thisvelfit[1]))
                    * thisvelfit[9]
                    / (1.0 - thisvelfit[9] ** 2.0)
                )
            elif (
                options.type.lower() == "afe"
                or options.type.lower() == "feh"
                or options.type.lower() == "fehafe"
                or options.type.lower() == "zfunc"
                or options.type.lower() == "afefeh"
            ):
                thisplot = [tightbinned.feh(ii), tightbinned.afe(jj), len(data)]
                thisplot.extend(thisvelfit)
                # Als find min and max z for this data bin, and median
                if options.subtype.lower() == "rfunc":
                    zsorted = sorted(numpy.sqrt((8.0 - data.xc) ** 2.0 + data.yc ** 2.0))
                else:
                    zsorted = sorted(numpy.fabs(data.zc + _ZSUN))
                zmin = zsorted[int(numpy.ceil(0.16 * len(zsorted)))]
                zmax = zsorted[int(numpy.floor(0.84 * len(zsorted)))]
                zmin = zsorted[int(numpy.ceil(0.025 * len(zsorted)))]
                zmax = zsorted[int(numpy.floor(0.975 * len(zsorted)))]
                if options.pivotmean:
                    thisplot.extend([zmin, zmax, numpy.mean(numpy.fabs(data.zc + _ZSUN))])
                else:
                    thisplot.extend([zmin, zmax, numpy.median(numpy.fabs(data.zc + _ZSUN))])
                plotthis.append(thisplot)
                # Errors
                if velerrors:
                    theseerrors = []
                    thesesamples = velsamples[afeindx + fehindx * binned.npixafe()]
                    for kk in [1, 4, 5, 8]:
                        xs = numpy.array([s[kk] for s in thesesamples])
                        theseerrors.append(
                            0.5
                            * (
                                numpy.exp(numpy.mean(xs))
                                - numpy.exp(numpy.mean(xs) - numpy.std(xs))
                                - numpy.exp(numpy.mean(xs))
                                + numpy.exp(numpy.mean(xs) + numpy.std(xs))
                            )
                        )
                    for kk in [0, 2, 3, 6, 7, 9, 10]:  # ,11]:
                        xs = numpy.array([s[kk] for s in thesesamples])
                        theseerrors.append(numpy.std(xs))
                        errors.append(theseerrors)
    # Set up plot
    # print numpy.nanmin(plotthis), numpy.nanmax(plotthis)
    if options.type == "tilt":
        print numpy.nanmin(plotthis), numpy.nanmax(plotthis)
        vmin, vmax = -20.0, 20.0
        zlabel = r"$\mathrm{tilt\ at}\ Z = 0\ [\mathrm{degree}]$"
    elif options.type == "tiltslope":
        print numpy.nanmin(plotthis), numpy.nanmax(plotthis)
        vmin, vmax = -2.0, 2.0
        zlabel = r"$\frac{\mathrm{d}\tan \mathrm{tilt}}{\mathrm{d} (Z/R)}$"
    elif options.type == "srz":
        vmin, vmax = -100.0, 100.0
        zlabel = r"$\sigma^2_{RZ}\ [\mathrm{km}^2\, \mathrm{s}^{-2}]$"
    elif options.type == "afe":
        vmin, vmax = 0.0, 0.5
        zlabel = r"$[\alpha/\mathrm{Fe}]$"
    elif options.type == "feh":
        vmin, vmax = -1.6, 0.4
        zlabel = r"$[\mathrm{Fe/H}]$"
    if options.tighten:
        xrange = [-1.6, 0.5]
        yrange = [-0.05, 0.55]
    else:
        xrange = [-2.0, 0.6]
        yrange = [-0.1, 0.6]
    if (
        options.type.lower() == "afe"
        or options.type.lower() == "feh"
        or options.type.lower() == "fehafe"
        or options.type.lower() == "afefeh"
    ):
        bovy_plot.bovy_print(fig_height=3.87, fig_width=5.0)
        # Gather everything
        zmin, zmax, pivot, tilt, tiltp1, tiltp2, afe, feh, ndata = [], [], [], [], [], [], [], [], []
        tilt_err, tiltp1_err, tiltp2_err = [], [], []
        for ii in range(len(plotthis)):
            if velerrors:
                tilt_err.append(errors[ii][9])
                tiltp1_err.append(errors[ii][10])
            #                tiltp2_err.append(errors[ii][11])
            tilt.append(plotthis[ii][11])
            tiltp1.append(plotthis[ii][12])
            #            tiltp2.append(plotthis[ii][13])
            afe.append(plotthis[ii][1])
            feh.append(plotthis[ii][0])
            ndata.append(plotthis[ii][4])
            zmin.append(plotthis[ii][13])
            zmax.append(plotthis[ii][14])
            pivot.append(plotthis[ii][15])
        indxarray = numpy.array([True for ii in range(len(plotthis))], dtype="bool")
        tilt = numpy.array(tilt)[indxarray]
        tiltp1 = numpy.array(tiltp1)[indxarray]
        #        tiltp2= numpy.array(tiltp2)[indxarray]
        pivot = numpy.array(pivot)[indxarray]
        zmin = numpy.array(zmin)[indxarray]
        zmax = numpy.array(zmax)[indxarray]
        if velerrors:
            tilt_err = numpy.array(tilt_err)[indxarray]
            tiltp1_err = numpy.array(tiltp1_err)[indxarray]
        #            tiltp2_err= numpy.array(tiltp2_err)[indxarray]
        afe = numpy.array(afe)[indxarray]
        feh = numpy.array(feh)[indxarray]
        ndata = numpy.array(ndata)[indxarray]
        # Process ndata
        ndata = ndata ** 0.5
        ndata = ndata / numpy.median(ndata) * 35.0
        # ndata= numpy.log(ndata)/numpy.log(numpy.median(ndata))
        # ndata= (ndata-numpy.amin(ndata))/(numpy.amax(ndata)-numpy.amin(ndata))*25+12.
        if options.type.lower() == "afe":
            plotc = afe
        elif options.type.lower() == "feh":
            plotc = feh
        if options.subtype.lower() == "zfunc":
            from selectFigs import _squeeze

            colormap = cm.jet
            # Set up plot
            yrange = [-30.0, 30.0]
            ylabel = r"$\mathrm{tilt}(Z|R=8\,\mathrm{kpc})\ [\mathrm{degree}]$"
            bovy_plot.bovy_plot(
                [-100.0, -100.0],
                [100.0, 100.0],
                "k,",
                xrange=[0, 2700],
                yrange=yrange,
                xlabel=r"$|z|\ [\mathrm{pc}]$",
                ylabel=ylabel,
            )
            # Calculate and plot all zfuncs
            for ii in numpy.random.permutation(len(afe)):
                if velerrors:  # Don't plot if errors > 30%
                    if tilt_err[ii] / tilt[ii] > 0.2:
                        continue
                ds = numpy.linspace(zmin[ii] * 1000.0, zmax[ii] * 1000.0, 1001) / 8000.0
                thiszfunc = numpy.arctan(tilt[ii] + tiltp1[ii] * ds) / _DEGTORAD  # +tiltp2[ii]*ds**2.
                pyplot.plot(
                    numpy.linspace(zmin[ii] * 1000.0, 1000 * zmax[ii], 1001),
                    thiszfunc,
                    "-",
                    color=colormap(_squeeze(plotc[ii], vmin, vmax)),
                    lw=ndata[ii] / 15.0,
                )
                if not options.nofatdots:
                    # Also plot pivot
                    pyplot.plot(
                        1000.0 * pivot[ii],
                        numpy.arctan(tilt[ii] + tiltp1[ii] * pivot[ii] / 8.0 + tiltp2[ii] * (pivot[ii] / 8.0) ** 2.0)
                        / _DEGTORAD,
                        "o",
                        ms=8.0,
                        mec="none",
                        color=colormap(_squeeze(plotc[ii], vmin, vmax)),
                    )
            # Add colorbar
            m = cm.ScalarMappable(cmap=cm.jet)
            m.set_array(plotc)
            m.set_clim(vmin=vmin, vmax=vmax)
            cbar = pyplot.colorbar(m, fraction=0.15)
            cbar.set_clim((vmin, vmax))
            cbar.set_label(zlabel)
    else:
        bovy_plot.bovy_print()
        bovy_plot.bovy_dens2d(
            plotthis.T,
            origin="lower",
            cmap="jet",
            interpolation="nearest",
            xlabel=r"$[\mathrm{Fe/H}]$",
            ylabel=r"$[\alpha/\mathrm{Fe}]$",
            zlabel=zlabel,
            xrange=xrange,
            yrange=yrange,
            vmin=vmin,
            vmax=vmax,
            contours=False,
            colorbar=True,
            shrink=0.78,
        )
        bovy_plot.bovy_text(
            r"$\mathrm{median} = %.2f \pm %.2f$"
            % (
                numpy.median(plotthis[numpy.isfinite(plotthis)]),
                1.4826
                * numpy.median(
                    numpy.fabs(plotthis[numpy.isfinite(plotthis)] - numpy.median(plotthis[numpy.isfinite(plotthis)]))
                ),
            ),
            bottom_left=True,
            size=14.0,
        )
    bovy_plot.bovy_end_print(options.plotfile)
    return None
def plotOneDiskVsTwoDisks(options, args):
    if options.sample.lower() == "g":
        if options.select.lower() == "program":
            raw = read_gdwarfs(_GDWARFFILE, logg=True, ebv=True, sn=options.sn)
        else:
            raw = read_gdwarfs(logg=True, ebv=True, sn=options.sn)
    elif options.sample.lower() == "k":
        if options.select.lower() == "program":
            raw = read_kdwarfs(_KDWARFFILE, logg=True, ebv=True, sn=options.sn)
        else:
            raw = read_kdwarfs(logg=True, ebv=True, sn=options.sn)
    # Bin the data
    binned = pixelAfeFeh(raw, dfeh=options.dfeh, dafe=options.dafe)
    if options.tighten:
        tightbinned = pixelAfeFeh(
            raw, dfeh=options.dfeh, dafe=options.dafe, fehmin=-2.0, fehmax=0.3, afemin=0.0, afemax=0.45
        )
    else:
        tightbinned = binned
    # Savefile1
    if os.path.exists(args[0]):  # Load savefile
        savefile = open(args[0], "rb")
        onefits = pickle.load(savefile)
        savefile.close()
    if os.path.exists(args[1]):  # Load savefile
        savefile = open(args[1], "rb")
        twofits = pickle.load(savefile)
        savefile.close()
    # Uncertainties are in savefile3 and 4
    if len(args) > 3 and os.path.exists(args[3]):
        savefile = open(args[3], "rb")
        twosamples = pickle.load(savefile)
        savefile.close()
        twoerrors = True
    else:
        twosamples = None
        twoerrors = False
    if len(args) > 2 and os.path.exists(args[2]):
        savefile = open(args[2], "rb")
        onesamples = pickle.load(savefile)
        savefile.close()
        oneerrors = True
    else:
        onesamples = None
        oneerrors = False
    # If --mass is set to a filename, load the masses from that file
    # and use those for the symbol size
    if not options.mass is None and os.path.exists(options.mass):
        savefile = open(options.mass, "rb")
        mass = pickle.load(savefile)
        savefile.close()
        ndata = mass
        masses = True
    else:
        masses = False
    # Run through the pixels and gather
    plotthis = []
    errors = []
    for ii in range(tightbinned.npixfeh()):
        for jj in range(tightbinned.npixafe()):
            data = binned(tightbinned.feh(ii), tightbinned.afe(jj))
            fehindx = binned.fehindx(tightbinned.feh(ii))  # Map onto regular binning
            afeindx = binned.afeindx(tightbinned.afe(jj))
            if afeindx + fehindx * binned.npixafe() >= len(onefits):
                continue
            thisonefit = onefits[afeindx + fehindx * binned.npixafe()]
            thistwofit = twofits[afeindx + fehindx * binned.npixafe()]
            if thisonefit is None:
                continue
            if len(data) < options.minndata:
                continue
            # print tightbinned.feh(ii), tightbinned.afe(jj), numpy.exp(thisonefit), numpy.exp(thistwofit)
            # Which is the dominant two-exp component?
            if thistwofit[4] > 0.5:
                twoIndx = 1
            else:
                twoIndx = 0
            if options.type == "hz":
                if masses:
                    plotthis.append(
                        [
                            numpy.exp(thisonefit[0]) * 1000.0,
                            numpy.exp(thistwofit[twoIndx]) * 1000.0,
                            mass[afeindx + fehindx * binned.npixafe()],
                        ]
                    )
                else:
                    plotthis.append(
                        [numpy.exp(thisonefit[0]) * 1000.0, numpy.exp(thistwofit[twoIndx]) * 1000.0, len(data)]
                    )
                # Discrepant point
                if plotthis[-1][1] < 250.0 and plotthis[-1][0] > 500.0:
                    print "strange point: ", tightbinned.feh(ii), tightbinned.afe(jj)
            elif options.type == "hr":
                plotthis.append([numpy.exp(thisonefit[1]), numpy.exp(thistwofit[twoIndx + 2]), len(data)])
            theseerrors = []
            if oneerrors:
                theseonesamples = onesamples[afeindx + fehindx * binned.npixafe()]
                if options.type == "hz":
                    xs = numpy.array([s[0] for s in theseonesamples])
                    theseerrors.append(
                        500.0 * (-numpy.exp(numpy.mean(xs) - numpy.std(xs)) + numpy.exp(numpy.mean(xs) + numpy.std(xs)))
                    )
                elif options.type == "hr":
                    xs = numpy.array([s[1] for s in theseonesamples])
                    theseerrors.append(
                        0.5 * (-numpy.exp(numpy.mean(xs) - numpy.std(xs)) + numpy.exp(numpy.mean(xs) + numpy.std(xs)))
                    )
            if twoerrors:
                thesetwosamples = twosamples[afeindx + fehindx * binned.npixafe()]
                if options.type == "hz":
                    xs = numpy.array([s[twoIndx] for s in thesetwosamples])
                    theseerrors.append(
                        500.0 * (-numpy.exp(numpy.mean(xs) - numpy.std(xs)) + numpy.exp(numpy.mean(xs) + numpy.std(xs)))
                    )
                elif options.type == "hr":
                    xs = numpy.array([s[2 + twoIndx] for s in thesetwosamples])
                    theseerrors.append(
                        0.5 * (-numpy.exp(numpy.mean(xs) - numpy.std(xs)) + numpy.exp(numpy.mean(xs) + numpy.std(xs)))
                    )
            errors.append(theseerrors)
    x, y, ndata = [], [], []
    if oneerrors:
        x_err = []
    if twoerrors:
        y_err = []
    for ii in range(len(plotthis)):
        x.append(plotthis[ii][0])
        y.append(plotthis[ii][1])
        ndata.append(plotthis[ii][2])
        if oneerrors:
            x_err.append(errors[ii][0])
        if twoerrors:
            y_err.append(errors[ii][1])
    x = numpy.array(x)
    y = numpy.array(y)
    if oneerrors:
        x_err = numpy.array(x_err)
    if twoerrors:
        y_err = numpy.array(y_err)
    ndata = numpy.array(ndata)
    # Process ndata
    if not masses:
        ndata = ndata ** 0.5
        ndata = ndata / numpy.median(ndata) * 35.0
        ndata = 20
    else:
        ndata = _squeeze(ndata, numpy.amin(ndata), numpy.amax(ndata))
        ndata = ndata * 200.0 + 10.0
    # Now plot
    if options.type == "hz":
        xrange = [150, 1200]
        xlabel = r"$\mathrm{single-exponential\ scale\ height}$"
        ylabel = r"$\mathrm{two-exponentials\ scale\ height}$"
    elif options.type == "hr":
        xrange = [1.2, 5.0]
        xlabel = r"$\mathrm{single-exponential\ scale\ length}$"
        ylabel = r"$\mathrm{two-exponentials\ scale\ length}$"
    yrange = xrange
    bovy_plot.bovy_print()
    bovy_plot.bovy_plot(
        x,
        y,
        color="k",
        s=ndata,
        ylabel=ylabel,
        xlabel=xlabel,
        xrange=xrange,
        yrange=yrange,
        scatter=True,
        edgecolors="none",
        colorbar=False,
        zorder=2,
    )
    bovy_plot.bovy_plot([xrange[0], xrange[1]], [xrange[0], xrange[1]], color="0.5", ls="--", overplot=True)
    if oneerrors:
        # Overplot errors
        for ii in range(len(x)):
            #                if (options.type == 'hr' and x[ii] < 5.) or options.type == 'hz':
            pyplot.errorbar(x[ii], y[ii], xerr=x_err[ii], color="k", elinewidth=1.0, capsize=3, zorder=0)
    if twoerrors:
        # Overplot errors
        for ii in range(len(x)):
            #                if (options.type == 'hr' and x[ii] < 5.) or options.type == 'hz':
            pyplot.errorbar(x[ii], y[ii], yerr=y_err[ii], color="k", elinewidth=1.0, capsize=3, zorder=0)
    bovy_plot.bovy_end_print(options.plotfile)
    return None
Example #10
0
def testDFNorm(options, args):
    # Read the data
    print "Reading the data ..."
    if options.sample.lower() == "g":
        if not options.fakedata is None:
            raw = read_gdwarfs(options.fakedata, logg=True, ebv=True, sn=options.snmin, nosolar=True)
        elif options.select.lower() == "program":
            raw = read_gdwarfs(_GDWARFFILE, logg=True, ebv=True, sn=options.snmin, nosolar=True)
        else:
            raw = read_gdwarfs(logg=True, ebv=True, sn=options.snmin, nosolar=True)
    elif options.sample.lower() == "k":
        if options.select.lower() == "program":
            raw = read_kdwarfs(_KDWARFFILE, logg=True, ebv=True, sn=options.snmin, nosolar=True)
        else:
            raw = read_kdwarfs(logg=True, ebv=True, sn=options.snmin, nosolar=True)
    if not options.bmin is None:
        # Cut on |b|
        raw = raw[(numpy.fabs(raw.b) > options.bmin)]
    if not options.fehmin is None:
        raw = raw[(raw.feh >= options.fehmin)]
    if not options.fehmax is None:
        raw = raw[(raw.feh < options.fehmax)]
    if not options.afemin is None:
        raw = raw[(raw.afe >= options.afemin)]
    if not options.afemax is None:
        raw = raw[(raw.afe < options.afemax)]
    if not options.plate is None and not options.loo:
        raw = raw[(raw.plate == options.plate)]
    elif not options.plate is None:
        raw = raw[(raw.plate != options.plate)]
    # Bin the data
    binned = pixelAfeFeh(raw, dfeh=options.dfeh, dafe=options.dafe)
    # Map the bins with ndata > minndata in 1D
    fehs, afes = [], []
    for ii in range(len(binned.fehedges) - 1):
        for jj in range(len(binned.afeedges) - 1):
            data = binned(binned.feh(ii), binned.afe(jj))
            if len(data) < options.minndata:
                continue
            fehs.append(binned.feh(ii))
            afes.append(binned.afe(jj))
    nabundancebins = len(fehs)
    fehs = numpy.array(fehs)
    afes = numpy.array(afes)
    if not options.singlefeh is None:
        if options.loo:
            pass
        else:
            # Set up single feh
            indx = binned.callIndx(options.singlefeh, options.singleafe)
            if numpy.sum(indx) == 0:
                raise IOError("Bin corresponding to singlefeh and singleafe is empty ...")
            data = copy.copy(binned.data[indx])
            print "Using %i data points ..." % (len(data))
            # Bin again
            binned = pixelAfeFeh(data, dfeh=options.dfeh, dafe=options.dafe)
            fehs, afes = [], []
            for ii in range(len(binned.fehedges) - 1):
                for jj in range(len(binned.afeedges) - 1):
                    data = binned(binned.feh(ii), binned.afe(jj))
                    if len(data) < options.minndata:
                        continue
                    fehs.append(binned.feh(ii))
                    afes.append(binned.afe(jj))
            nabundancebins = len(fehs)
            fehs = numpy.array(fehs)
            afes = numpy.array(afes)
    # Setup everything for the selection function
    print "Setting up stuff for the normalization integral ..."
    normintstuff = setup_normintstuff(options, raw, binned, fehs, afes)
    if not options.init is None:
        # Load initial parameters from file
        savefile = open(options.init, "rb")
        params = pickle.load(savefile)
        savefile.close()
    else:
        # First initialization
        params = initialize(options, fehs, afes)
    # Now perform tests
    if options.type.lower() == "hr":
        testDFNormhr(params, fehs, afes, binned, options, normintstuff)
    elif options.type.lower() == "sr":
        testDFNormsr(params, fehs, afes, binned, options, normintstuff)
    elif options.type.lower() == "vo":
        testDFNormvo(params, fehs, afes, binned, options, normintstuff)
Example #11
0
def plotVelPDFs(options, args):
    if options.sample.lower() == "g":
        if options.select.lower() == "program":
            raw = read_gdwarfs(_GDWARFFILE, logg=True, ebv=True, sn=True)
        else:
            raw = read_gdwarfs(logg=True, ebv=True, sn=True)
    elif options.sample.lower() == "k":
        if options.select.lower() == "program":
            raw = read_kdwarfs(_KDWARFFILE, logg=True, ebv=True, sn=True)
        else:
            raw = read_kdwarfs(logg=True, ebv=True, sn=True)
    # Bin the data
    binned = pixelAfeFeh(raw, dfeh=options.dfeh, dafe=options.dafe)
    if options.tighten:
        tightbinned = pixelAfeFeh(
            raw, dfeh=options.dfeh, dafe=options.dafe, fehmin=-1.6, fehmax=0.5, afemin=-0.05, afemax=0.55
        )
    else:
        tightbinned = binned
    # Savefile1
    if os.path.exists(args[0]):  # Load savefile
        savefile = open(args[0], "rb")
        velfits = pickle.load(savefile)
        savefile.close()
    if os.path.exists(args[1]):  # Load savefile
        savefile = open(args[1], "rb")
        densfits = pickle.load(savefile)
        savefile.close()
    # Uncertainties are in savefile3 and 4
    if len(args) > 3 and os.path.exists(args[3]):
        savefile = open(args[3], "rb")
        denssamples = pickle.load(savefile)
        savefile.close()
        denserrors = True
    else:
        denssamples = None
        denserrors = False
    if len(args) > 2 and os.path.exists(args[2]):
        savefile = open(args[2], "rb")
        velsamples = pickle.load(savefile)
        savefile.close()
        velerrors = True
    else:
        velsamples = None
        velerrors = False
    # Now plot
    # Run through the pixels and gather
    if (
        options.type.lower() == "afe"
        or options.type.lower() == "feh"
        or options.type.lower() == "fehafe"
        or options.type.lower() == "zfunc"
        or options.type.lower() == "afefeh"
    ):
        plotthis = []
        errors = []
    else:
        plotthis = numpy.zeros((tightbinned.npixfeh(), tightbinned.npixafe()))
    if options.kde:
        allsamples = []
    sausageFehAfe = [options.feh, options.afe]  # -0.15,0.075]#[[-0.85,0.425],[-0.45,0.275],[-0.15,0.075]]
    if options.subtype.lower() == "sausage":
        sausageSamples = []
    for ii in range(tightbinned.npixfeh()):
        for jj in range(tightbinned.npixafe()):
            data = binned(tightbinned.feh(ii), tightbinned.afe(jj))
            fehindx = binned.fehindx(tightbinned.feh(ii))  # Map onto regular binning
            afeindx = binned.afeindx(tightbinned.afe(jj))
            if not (
                numpy.fabs(tightbinned.feh(ii) - sausageFehAfe[0]) < 0.01
                and numpy.fabs(tightbinned.afe(jj) - sausageFehAfe[1]) < 0.01
            ):
                continue
            thisdensfit = densfits[afeindx + fehindx * binned.npixafe()]
            thisvelfit = velfits[afeindx + fehindx * binned.npixafe()]
            if options.velmodel.lower() == "hwr":
                thisplot = [
                    tightbinned.feh(ii),
                    tightbinned.afe(jj),
                    numpy.exp(thisvelfit[1]),
                    numpy.exp(thisvelfit[4]),
                    len(data),
                    thisvelfit[2],
                    thisvelfit[3],
                ]
                # Als find min and max z for this data bin, and median
                zsorted = sorted(numpy.fabs(data.zc + _ZSUN))
                zmin = zsorted[int(numpy.ceil(0.16 * len(zsorted)))]
                zmax = zsorted[int(numpy.floor(0.84 * len(zsorted)))]
                thisplot.extend([zmin, zmax, numpy.mean(numpy.fabs(data.zc + _ZSUN))])
                # Errors
                if velerrors:
                    thesesamples = velsamples[afeindx + fehindx * binned.npixafe()]
                break
    # Now plot
    if options.type.lower() == "slopequad":
        plotx = numpy.array([thesesamples[ii][3] for ii in range(len(thesesamples))])
        ploty = numpy.array([thesesamples[ii][2] for ii in range(len(thesesamples))])
        xrange = [-10.0, 10.0]
        yrange = [-20.0, 20.0]
        xlabel = r"$\frac{\mathrm{d}^2 \sigma_z}{\mathrm{d} z^2}(z_{1/2})\ [\mathrm{km}\ \mathrm{s}^{-1}\ \mathrm{kpc}^{-2}]$"
        ylabel = r"$\frac{\mathrm{d} \sigma_z}{\mathrm{d} z}(z_{1/2})\ [\mathrm{km\ s}^{-1}\ \mathrm{kpc}^{-1}]$"
    elif options.type.lower() == "slopehsm":
        ploty = numpy.array([thesesamples[ii][2] for ii in range(len(thesesamples))])
        plotx = numpy.exp(-numpy.array([thesesamples[ii][4] for ii in range(len(thesesamples))]))
        xrange = [0.0, 0.3]
        yrange = [-20.0, 20.0]
        xlabel = r"$h^{-1}_\sigma\ [\mathrm{kpc}^{-1}]$"
        ylabel = r"$\frac{\mathrm{d} \sigma_z}{\mathrm{d} z}(z_{1/2})\ [\mathrm{km\ s}^{-1}\ \mathrm{kpc}^{-1}]$"
    elif options.type.lower() == "slopesz":
        ploty = numpy.array([thesesamples[ii][2] for ii in range(len(thesesamples))])
        plotx = numpy.exp(numpy.array([thesesamples[ii][1] for ii in range(len(thesesamples))]))
        xrange = [0.0, 60.0]
        yrange = [-20.0, 20.0]
        xlabel = r"$\sigma_z(z_{1/2}) [\mathrm{km\ s}^{-1}$"
        ylabel = r"$\frac{\mathrm{d} \sigma_z}{\mathrm{d} z}(z_{1/2})\ [\mathrm{km\ s}^{-1}\ \mathrm{kpc}^{-1}]$"
    elif options.type.lower() == "szhsm":
        plotx = numpy.exp(-numpy.array([thesesamples[ii][4] for ii in range(len(thesesamples))]))
        ploty = numpy.exp(numpy.array([thesesamples[ii][1] for ii in range(len(thesesamples))]))
        yrange = [0.0, 60.0]
        xrange = [0.0, 0.3]
        xlabel = r"$h^{-1}_\sigma\ [\mathrm{kpc}^{-1}]$"
        ylabel = r"$\sigma_z(z_{1/2}) [\mathrm{km\ s}^{-1}$"
    bovy_plot.bovy_print()
    axScatter, axHistx, axHisty = bovy_plot.scatterplot(
        plotx,
        ploty,
        "k,",
        onedhists=True,
        bins=31,
        xlabel=xlabel,
        ylabel=ylabel,
        xrange=xrange,
        onedhistynormed=True,
        yrange=yrange,
        retAxes=True,
    )
    if options.type.lower() == "slopequad":
        # Also add `quadratic term = 0' to vertical histogram
        ploty = ploty[(numpy.fabs(plotx) < 0.5)]
        histy, edges, patches = axHisty.hist(
            ploty,
            bins=51,
            orientation="horizontal",
            weights=numpy.ones(len(ploty)) / float(len(ploty)) / 2.0,
            histtype="step",
            range=sorted(yrange),
            color="0.6",
            lw=2.0,
        )
    # Label
    bovy_plot.bovy_text(
        r"$[\mathrm{Fe/H}]\ =\ %.2f$" % options.feh + "\n" + r"$[\alpha/\mathrm{Fe}]\ =\ %.3f$" % options.afe,
        top_right=True,
        size=18,
    )
    bovy_plot.bovy_end_print(options.plotfile)
Example #12
0
def readData(metal="rich", sample="G", loggmin=4.2, snmin=15.0, select="all"):
    """select= 'program', 'all', 'fakebimodal'"""
    if sample.lower() == "g":
        if select.lower() == "program":
            raw = read_gdwarfs(_GDWARFFILE, logg=loggmin, ebv=True, sn=snmin)
        elif select.lower() == "fakebimodal":
            raw = read_gdwarfs(_FAKEBIMODALGDWARFFILE, logg=loggmin, ebv=True, sn=snmin)
        elif select.lower() == "fakebimodal_allthin":
            raw = read_gdwarfs(_FAKETHINBIMODALGDWARFFILE, logg=loggmin, ebv=True, sn=snmin)
        elif select.lower() == "fakebimodal_allthick":
            raw = read_gdwarfs(_FAKETHICKBIMODALGDWARFFILE, logg=loggmin, ebv=True, sn=snmin)
        else:
            raw = read_gdwarfs(logg=loggmin, ebv=True, sn=snmin)
    elif sample.lower() == "k":
        if select.lower() == "program":
            raw = read_kdwarfs(_KDWARFFILE, logg=loggmin, ebv=True, sn=snmin)
        else:
            raw = read_kdwarfs(logg=loggmin, ebv=True, sn=snmin)
    # Select sample
    if metal == "rich":
        indx = (
            (raw.feh > _APOORFEHRANGE[0])
            * (raw.feh < _APOORFEHRANGE[1])
            * (raw.afe > _APOORAFERANGE[0])
            * (raw.afe < _APOORAFERANGE[1])
        )
    elif metal == "richdiag":
        indx = (
            (raw.feh > _APOORFEHRANGE[0])
            * (raw.feh < _APOORFEHRANGE[1])
            * (raw.afe > _APOORAFERANGE[0])
            * (raw.afe < _APOORAFERANGE[1])
            * (raw.afe > (-0.15 / 0.25 * (raw.feh + 0.25) + 0.1))
        )
    elif metal == "richlowerdiag":
        indx = (
            (raw.feh > _APOORFEHRANGE[0])
            * (raw.feh < _APOORFEHRANGE[1])
            * (raw.afe > _APOORAFERANGE[0])
            * (raw.afe < _APOORAFERANGE[1])
            * (raw.afe <= (-0.15 / 0.25 * (raw.feh + 0.25) + 0.1))
        )
    elif metal == "poor":
        indx = (
            (raw.feh > _ARICHFEHRANGE[0])
            * (raw.feh < _ARICHFEHRANGE[1])
            * (raw.afe > _ARICHAFERANGE[0])
            * (raw.afe < _ARICHAFERANGE[1])
        )
    elif metal == "poorpoor" or metal == "poorrich":
        # Sort on [Fe/H], cut down the middle
        indx = (
            (raw.feh > _ARICHFEHRANGE[0])
            * (raw.feh < _ARICHFEHRANGE[1])
            * (raw.afe > _ARICHAFERANGE[0])
            * (raw.afe < _ARICHAFERANGE[1])
        )
        raw = raw[indx]
        sfeh = sorted(raw.feh)
        cutfeh = sfeh[len(sfeh) / 2]
        # Round to nearest 0.1
        cutfeh = round(10 * cutfeh) / 10.0
        print "Cutting sample down the middle at %4.2f" % cutfeh
        if metal == "poorpoor":
            indx = raw.feh < cutfeh
        else:
            indx = raw.feh >= cutfeh
        """
    elif metal == 'richpoor' or metal == 'richrich':
    #Sort on [Fe/H], cut down the middle
    indx= (raw.feh > _APOORFEHRANGE[0])*(raw.feh < _APOORFEHRANGE[1])\
    *(raw.afe > _APOORAFERANGE[0])*(raw.afe < _APOORAFERANGE[1])
    raw= raw[indx]
    sfeh= sorted(raw.feh)
    cutfeh= sfeh[len(sfeh)/2]
    #Round to nearest 0.05
    cutfeh= round(20*cutfeh)/20.
    print 'Cutting sample down the middle at %4.2f' % cutfeh
    if metal == 'richpoor': indx= (raw.feh < cutfeh)
    else: indx= (raw.feh >= cutfeh)
    """
    elif metal == "richrich":
        indx = (
            (raw.feh < _APOORFEHRANGE[1])
            * (raw.feh > _APOORFEHRANGE[0])
            * (raw.afe > _APOORAFERANGE[0])
            * (raw.afe < _APOORAFERANGE[1])
        )
    elif metal == "richpoor":
        indx = (
            (raw.feh < _APOORFEHRANGE[0])
            * (raw.feh > -0.6)
            * (raw.afe > _APOORAFERANGE[0])
            * (raw.afe < _APOORAFERANGE[1])
        )
    elif metal == "richpoorest":
        indx = (raw.feh < -0.6) * (raw.feh > -1.5) * (raw.afe > _APOORAFERANGE[0]) * (raw.afe < _APOORAFERANGE[1])
    elif metal == "apoorpoor":
        indx = (
            (raw.feh < _APOORFEHRANGE[1])
            * (raw.feh > _APOORFEHRANGE[0])
            * (raw.afe > _APOORAFERANGE[0])
            * (raw.afe < 0.15)
        )
    elif metal == "apoorrich":
        indx = (
            (raw.feh < _APOORFEHRANGE[1])
            * (raw.feh > _APOORFEHRANGE[0])
            * (raw.afe >= 0.15)
            * (raw.afe < _APOORAFERANGE[1])
        )
    elif metal == "arichpoor":
        indx = (
            (raw.feh < _ARICHFEHRANGE[1])
            * (raw.feh > _ARICHFEHRANGE[0])
            * (raw.afe >= _ARICHAFERANGE[0])
            * (raw.afe < 0.35)
        )
    elif metal == "arichrich":
        indx = (
            (raw.feh < _ARICHFEHRANGE[1])
            * (raw.feh > _ARICHFEHRANGE[0])
            * (raw.afe >= 0.35)
            * (raw.afe < _ARICHAFERANGE[1])
        )
    elif metal == "allrichpoor":
        indx = (
            (raw.feh > _APOORFEHRANGE[0])
            * (raw.feh < _APOORFEHRANGE[1])
            * (raw.afe > _APOORAFERANGE[0])
            * (raw.afe < _APOORAFERANGE[1])
        )
        raw1 = raw[indx]
        indx = (
            (raw.feh > _ARICHFEHRANGE[0])
            * (raw.feh < _ARICHFEHRANGE[1])
            * (raw.afe > _ARICHAFERANGE[0])
            * (raw.afe < _ARICHAFERANGE[1])
        )
        raw2 = raw[indx]
        lenraw1 = len(raw1)
        raw1.resize(len(raw1) + len(raw2))
        for ii in range(len(raw2)):
            raw1[lenraw1 + ii] = raw2[ii]
        raw = raw1
        indx = numpy.array([True for ii in range(len(raw))], dtype="bool")
    elif metal == "all":
        indx = (raw.feh > -1.5) * (raw.feh < 0.5) * (raw.afe > -0.25) * (raw.afe < 0.5)
    else:
        indx = numpy.array([True for ii in range(len(raw))], dtype="bool")
    raw = raw[indx]
    ndata = len(raw.ra)
    XYZ = numpy.zeros((ndata, 3))
    vxvyvz = numpy.zeros((ndata, 3))
    cov_vxvyvz = numpy.zeros((ndata, 3, 3))
    XYZ[:, 0] = raw.xc
    XYZ[:, 1] = raw.yc
    XYZ[:, 2] = raw.zc
    vxvyvz[:, 0] = raw.vxc
    vxvyvz[:, 1] = raw.vyc
    vxvyvz[:, 2] = raw.vzc
    cov_vxvyvz[:, 0, 0] = raw.vxc_err ** 2.0
    cov_vxvyvz[:, 1, 1] = raw.vyc_err ** 2.0
    cov_vxvyvz[:, 2, 2] = raw.vzc_err ** 2.0
    cov_vxvyvz[:, 0, 1] = raw.vxvyc_rho * raw.vxc_err * raw.vyc_err
    cov_vxvyvz[:, 0, 2] = raw.vxvzc_rho * raw.vxc_err * raw.vzc_err
    cov_vxvyvz[:, 1, 2] = raw.vyvzc_rho * raw.vyc_err * raw.vzc_err
    # Load for output
    return (XYZ, vxvyvz, cov_vxvyvz, raw)