def make_plot(ax, featbin, showlegend=False):
ax.axhline(0.0, color='gray', lw=0.5)
if weights is True:
momentsml.plot.mcbin.mcbin(ax,
cat,
Feature("tru_s1"),
Feature("pre_s1", rea="all"),
featbin,
featprew=Feature("pre_s1w", rea="all"),
comp=1,
regressmethod=regressmethod)
momentsml.plot.mcbin.mcbin(ax,
cat,
Feature("tru_s2"),
Feature("pre_s2", rea="all"),
featbin,
featprew=Feature("pre_s2w", rea="all"),
comp=2,
showbins=False,
showlegend=showlegend,
regressmethod=regressmethod)
else:
momentsml.plot.mcbin.mcbin(ax,
cat,
Feature("tru_s1"),
Feature("pre_s1", rea="all"),
featbin,
comp=1,
regressmethod=regressmethod)
momentsml.plot.mcbin.mcbin(ax,
cat,
Feature("tru_s2"),
Feature("pre_s2", rea="all"),
featbin,
comp=2,
showbins=False,
showlegend=showlegend,
regressmethod=regressmethod)
momentsml.plot.mcbin.make_symlog(ax, featbin, lim=lim)
ax.set_xlabel(featbin.nicename)
import os
from momentsml.tools.feature import Feature
import config
import matplotlib
import matplotlib.pyplot as plt
import numpy as np
cat = momentsml.tools.io.readpickle(
os.path.join(config.simmeasdir, config.datasets["tp"], "groupmeascat.pkl"))
#print momentsml.tools.table.info(cat)
fig = plt.figure(figsize=(8, 8))
ax = fig.add_subplot(2, 2, 1)
momentsml.plot.scatter.scatter(ax,
cat,
Feature("snr", rea=1),
Feature("adamom_failfrac"),
sidehists=True)
ax = fig.add_subplot(2, 2, 2)
momentsml.plot.scatter.scatter(ax, cat, Feature("tru_sb"), Feature("tru_rad"),
Feature("adamom_failfrac"))
plt.tight_layout()
plt.show()
plt.close(fig) # Helps releasing memory when calling in large loops.
import config
import numpy as np
from momentsml.tools.feature import Feature
import matplotlib
import matplotlib.pyplot as plt
cat = momentsml.tools.io.readpickle(
os.path.join(config.simmeasdir, config.datasets["si"], "groupmeascat.pkl"))
#print momentsml.tools.table.info(cat)
fig = plt.figure(figsize=(20, 13))
snr = Feature("snr", 0, 50, nicename="Measured S/N")
tru_rad = Feature("tru_rad", nicename="True half-light radius [pixel]")
tru_mag = Feature("tru_mag", 20, 26.5, nicename="Magnitude")
tru_sersicn = Feature("tru_sersicn", 0, 7, nicename="True Sersic index")
#snr = Feature("snr", nicename="Measured S/N")
#tru_rad = Feature("tru_rad", nicename="True half-light radius [pixel]")
#tru_mag = Feature("tru_mag", nicename="Magnitude")
#tru_sersicn = Feature("tru_sersicn", nicename="True Sersic index")
ax = fig.add_subplot(2, 3, 1)
momentsml.plot.scatter.scatter(ax,
cat,
tru_sersicn,
tru_rad,
sidehists=True,
# First putting all weights to 1.0:
cat["pre_s{}w".format(comp)] = np.ones(cat["adamom_g1"].shape)
logger.info("Setting weights to one")
cat["pre_s{}w_norm".format(comp)] = cat["pre_s{}w".format(comp)] / np.max(cat["pre_s{}w".format(comp)])
momentsml.tools.table.addrmsd(cat, "pre_s{}".format(comp), "tru_s{}".format(comp))
momentsml.tools.table.addstats(cat, "pre_s{}".format(comp), "pre_s{}w".format(comp))
cat["pre_s{}_wbias".format(comp)] = cat["pre_s{}_wmean".format(comp)] - cat["tru_s{}".format(comp)]
resr = 0.01
symthres = 0.002
wplotrea = -10
snr = Feature("snr", nicename="S/N", rea=wplotrea)
#tru_rad = Feature("tru_rad", nicename=r"$R$ [pix]", rea=wplotrea)
tru_sb = Feature("tru_sb", 0, 16, nicename=r"Surface brightness $S$ [pix$^{-2}$]", rea=wplotrea)
tru_rad = Feature("tru_rad", 1.5, 8.5, nicename=r"Half-light radius $R$ [pix]", rea=wplotrea)
adamom_flux = Feature("adamom_flux", 0, 1000, nicename="adamom\_flux", rea=wplotrea)
adamom_sigma = Feature("adamom_sigma", 0, 8, nicename="adamom\_sigma", rea=wplotrea)
adamom_g2 = Feature("adamom_g2", nicename="adamom\_g2", rea=wplotrea)
adamom_rho4 = Feature("adamom_rho4", nicename="adamom\_rho4", rea=wplotrea)
tru_s1 = Feature("tru_s1", nicename=r"$g_1^{\mathrm{true}}$")
tru_s2 = Feature("tru_s2", nicename=r"$g_2^{\mathrm{true}}$")
pre_s1_bias = Feature("pre_s1_bias", -resr, resr, nicename=r"$\langle \hat{g}_{1} \rangle - g_{1}^{\mathrm{true}} $")
import config
import numpy as np
from momentsml.tools.feature import Feature
import matplotlib
import matplotlib.pyplot as plt
cat = momentsml.tools.io.readpickle(
os.path.join(config.simmeasdir, config.datasets["si"], "groupmeascat.pkl"))
#print momentsml.tools.table.info(cat)
fig = plt.figure(figsize=(20, 13))
snr = Feature("snr", 0, 50, nicename="Measured S/N")
tru_rad = Feature("tru_rad", nicename="True half-light radius [pixel]")
tru_mag = Feature("tru_mag", 20, 26.5, nicename="Magnitude")
tru_sersicn = Feature("tru_sersicn", 0, 7, nicename="True Sersic index")
adamom_x = Feature("adamom_x")
adamom_y = Feature("adamom_y")
adamom_flux = Feature("adamom_flux")
adamom_sigma = Feature("adamom_sigma")
adamom_rho4 = Feature("adamom_rho4")
adamom_g1 = Feature("adamom_g1")
adamom_g2 = Feature("adamom_g2")
fit_x = Feature("fit_x")
fit_y = Feature("fit_y")
fit_flux = Feature("fit_flux")
bestsub = momentsml.tools.table.Selector("bestsub",
[("is", "subfield", subfield)])
simcat = bestsub.select(simcat)
#print momentsml.tools.table.info(simcat)
#print simcat
obscat = momentsml.tools.io.readpickle(
run.path("obs", "img_%i_meascat.pkl" % subfield))
#print momentsml.tools.table.info(obscat)
rea = None
adamom_flux = Feature("adamom_flux", rea=rea)
adamom_sigma = Feature("adamom_sigma", 0, 10, rea=rea)
adamom_rho4 = Feature("adamom_rho4", 1.3, 2.6, rea=rea)
adamom_g1 = Feature("adamom_g1", -0.7, 0.7, rea=rea)
adamom_g2 = Feature("adamom_g2", -0.7, 0.7, rea=rea)
snr = Feature("snr", -3, 30, rea=rea)
aperphot_sb2 = Feature("aperphot_sb2", rea=rea)
aperphot_sb3 = Feature("aperphot_sb3", rea=rea)
aperphot_sb5 = Feature("aperphot_sb5", rea=rea)
aperphot_sb8 = Feature("aperphot_sb8", rea=rea)
skymad = Feature("skymad", rea=rea)
skystd = Feature("skystd", rea=rea)
skymed = Feature("skymed", rea=rea)
#print momentsml.tools.table.info(cat)
for comp in ["1","2"]:
#cat["pre_s{}w_norm".format(comp)] = cat["pre_s{}w".format(comp)] / np.max(cat["pre_s{}w".format(comp)])
#momentsml.tools.table.addrmsd(cat, "pre_s{}".format(comp), "tru_s{}".format(comp))
momentsml.tools.table.addstats(cat, "pre_s{}".format(comp), "pre_s{}w".format(comp))
cat["pre_s{}_wbias".format(comp)] = cat["pre_s{}_wmean".format(comp)] - cat["tru_s{}".format(comp)]
resr = 0.01
wplotrea = -10
snr = Feature("snr", 3.0, 150.0, nicename="S/N", rea=wplotrea)
tru_mag = Feature("tru_mag", 20, 25.7, nicename="Magnitude", rea=wplotrea)
tru_rad = Feature("tru_rad", 0.0, 13.0, nicename=r"Half-light radius $R$ [pix]", rea=wplotrea)
tru_s1 = Feature("tru_s1", nicename=r"$g_1^{\mathrm{true}}$")
tru_s2 = Feature("tru_s2", nicename=r"$g_2^{\mathrm{true}}$")
pre_s1_bias = Feature("pre_s1_bias", -resr, resr, nicename=r"$\langle \hat{g}_{1} \rangle - g_{1}^{\mathrm{true}} $")
pre_s2_bias = Feature("pre_s2_bias", -resr, resr, nicename=r"$\langle \hat{g}_{2} \rangle - g_{2}^{\mathrm{true}} $")
pre_s1_wbias = Feature("pre_s1_wbias", -resr, resr, nicename=r"$\left(\sum\hat{g}_1 w_1 / \sum w_1 \right) - g_{1}^{\mathrm{true}}$")
pre_s2_wbias = Feature("pre_s2_wbias", -resr, resr, nicename=r"$\left(\sum\hat{g}_2 w_2 / \sum w_2 \right) - g_{2}^{\mathrm{true}}$")
def addmetrics(ax, xfeat, yfeat):
rc('font', **{'family': 'sans-serif', 'sans-serif': ['Helvetica']})
## for Palatino and other serif fonts use:
#rc('font',**{'family':'serif','serif':['Palatino']})
rc('text', usetex=True)
valcat = os.path.join(config.valdir, config.valname + ".pkl")
cat = momentsml.tools.io.readpickle(valcat)
#print momentsml.tools.table.info(cat)
cat = momentsml.tools.table.shuffle(
cat) # otherwise scatter plots look weird as they got sorted by tru s1 s2
momentsml.tools.table.addstats(cat, "snr")
tru_rad = Feature("tru_rad", -1, 13, nicename=r"Half-light radius $R$ [pix]")
tru_rad_zoom = Feature("tru_rad",
0,
5,
nicename=r"Half-light radius $R$ [pix]")
adamom_sigma = Feature("adamom_sigma", 0, 5, rea=1, nicename=r"adamom\_sigma")
snr_mean = Feature("snr_mean",
nicename="$\\langle \mathrm{S}/\mathrm{N}\\rangle$")
#for comp in ["1","2"]:
for comp in ["1"]:
momentsml.tools.table.addrmsd(cat, "pre_s{}".format(comp),
logger.info("Setting weights to one")
cat["pre_s{}w_norm".format(comp)] = cat["pre_s{}w".format(comp)] / np.max(
cat["pre_s{}w".format(comp)])
momentsml.tools.table.addrmsd(cat, "pre_s{}".format(comp),
"tru_s{}".format(comp))
momentsml.tools.table.addstats(cat, "pre_s{}".format(comp),
"pre_s{}w".format(comp))
cat["pre_s{}_wbias".format(comp)] = cat["pre_s{}_wmean".format(
comp)] - cat["tru_s{}".format(comp)]
resr = 0.01
symthres = 0.002
wplotrea = -10
snr = Feature("snr", nicename="S/N", rea=wplotrea)
#tru_rad = Feature("tru_rad", nicename=r"$R$ [pix]", rea=wplotrea)
tru_mag = Feature("tru_mag", 20, 26, nicename="Magnitude", rea=wplotrea)
tru_rad = Feature("tru_rad",
1.5,
8.5,
nicename=r"Half-light radius $R$ [pix]",
rea=wplotrea)
adamom_flux = Feature("adamom_flux",
0,
1000,
nicename="adamom\_flux",
rea=wplotrea)
def plot(cat, component, filepath=None):
rea = "all"
#rea = -20
#ebarmode = "scatter"
if component == 1:
if "pre_s1w" in cat.colnames:
cat["pre_s1w_norm"] = cat["pre_s1w"] / np.max(cat["pre_s1w"])
momentsml.tools.table.addstats(cat, "pre_s1", "pre_s1w")
pre_sc_wmean = Feature("pre_s1_wmean", -0.13, 0.13)
pre_scw = Feature("pre_s1w", rea=rea)
pre_scw_norm = Feature("pre_s1w_norm", rea=rea)
else:
momentsml.tools.table.addstats(cat, "pre_s1")
momentsml.tools.table.addrmsd(cat, "pre_s1", "tru_s1")
pre_sc = Feature("pre_s1", rea=rea)
pre_sc_bias = Feature("pre_s1_bias", -0.05, 0.05)
pre_sc_mean = Feature("pre_s1_mean", -0.13, 0.13)
tru_sc = Feature("tru_s1", -0.13, 0.13)
tru_sc2 = Feature("tru_s2", -0.13, 0.13)
elif component == 2:
pass
print momentsml.tools.table.info(cat)
fig = plt.figure(figsize=(24, 12))
ax = fig.add_subplot(3, 5, 1)
momentsml.plot.bin.bin(ax, cat, tru_sc, pre_sc_bias, metrics=True)
ax.set_title(trainspname)
ax = fig.add_subplot(3, 5, 2)
momentsml.plot.scatter.scatter(ax,
cat,
tru_sc,
pre_sc_bias,
showidline=True,
metrics=True,
yisres=True)
ax.set_title(predname)
ax = fig.add_subplot(3, 5, 3)
momentsml.plot.scatter.scatter(ax,
cat,
tru_sc,
Feature("pre_s1_wmean"),
tru_sc2,
showidline=True,
metrics=True,
yisres=False)
ax.set_title(predname)
ax = fig.add_subplot(3, 5, 4)
momentsml.plot.hist.hist(ax, cat, pre_scw)
ax.set_title(predname)
rea = -400
ax = fig.add_subplot(3, 5, 6)
momentsml.plot.scatter.scatter(ax, cat[0:1], Feature("tru_sb", rea=rea),
Feature("tru_sersicn", rea=rea))
ax.set_title("First case")
ax = fig.add_subplot(3, 5, 7)
momentsml.plot.scatter.scatter(ax, cat[0:1], Feature("tru_g1", rea=rea),
Feature("tru_g2", rea=rea))
ax.set_title("First case")
ax = fig.add_subplot(3, 5, 8)
momentsml.plot.scatter.scatter(ax, cat[0:1], Feature("tru_flux", rea=rea),
Feature("tru_rad", rea=rea))
ax.set_title("First case")
ax = fig.add_subplot(3, 5, 9)
momentsml.plot.scatter.scatter(ax, cat[0:1], Feature("tru_s1", rea=rea),
Feature("tru_s2", rea=rea))
ax.set_title("First case")
#print cat[0:1]
"""
ax = fig.add_subplot(3, 5, 7)
momentsml.plot.scatter.scatter(ax, cat, tru_sc, pre_sc_wmean, showidline=True, metrics=True)
ax.set_title("With weights")
ax = fig.add_subplot(3, 5, 8)
momentsml.plot.hist.hist(ax, cat, pre_scw)
#ax = fig.add_subplot(3, 5, 3)
#momentsml.plot.scatter.scatter(ax, cat, Feature("tru_rad", rea=rea), Feature("tru_flux", rea=rea), featc=Feature("pre_g1w", rea=rea))
"""
"""
ax = fig.add_subplot(3, 5, 1)
momentsml.plot.scatter.scatter(ax, cat, tru_sc, pre_gc_mean, featc=snr_mean, showidline=True, metrics=True)
ax = fig.add_subplot(3, 5, 2)
momentsml.plot.scatter.scatter(ax, cat, tru_sc, Feature("snr_mean"), pre_gc_bias)
ax = fig.add_subplot(3, 5, 3)
momentsml.plot.scatter.scatter(ax, cat, tru_sc, Feature("tru_rad"), pre_gc_bias)
ax = fig.add_subplot(3, 5, 4)
momentsml.plot.scatter.scatter(ax, cat, tru_sc, Feature("tru_sersicn"), pre_gc_bias)
ax = fig.add_subplot(3, 5, 5)
momentsml.plot.scatter.scatter(ax, cat, tru_sc, Feature("tru_g"), pre_gc_bias)
ax = fig.add_subplot(3, 5, 6)
momentsml.plot.scatter.scatter(ax, cat, tru_sc, Feature("tru_sb"), pre_gc_bias)
ax = fig.add_subplot(3, 5, 7)
momentsml.plot.scatter.scatter(ax, cat, tru_sc, Feature("adamom_frac"), pre_gc_bias)
ax = fig.add_subplot(3, 5, 8)
momentsml.plot.scatter.scatter(ax, cat, tru_sc, Feature("tru_flux"), pre_gc_bias)
ax = fig.add_subplot(3, 5, 9)
momentsml.plot.scatter.scatter(ax, cat, tru_sc, Feature("adamom_flux", rea=1), pre_gc_bias)
#momentsml.plot.scatter.scatter(ax, cat, tru_sc, Feature("adamom_flux_mean"), pre_gc_bias)
ax = fig.add_subplot(3, 5, 10)
momentsml.plot.scatter.scatter(ax, cat, tru_sc, Feature("adamom_sigma", rea=1), pre_gc_bias)
ax = fig.add_subplot(3, 5, 11)
momentsml.plot.bin.res(ax, cat, tru_sc, pre_gc_mean, Feature("tru_sb"), ncbins=3, equalcount=True, ebarmode=ebarmode)
ax = fig.add_subplot(3, 5, 12)
momentsml.plot.bin.res(ax, cat, tru_sc, pre_gc_mean, Feature("tru_flux"), ncbins=3, equalcount=True, ebarmode=ebarmode)
ax = fig.add_subplot(3, 5, 13)
momentsml.plot.bin.res(ax, cat, tru_sc, pre_gc_mean, Feature("tru_rad"), ncbins=3, equalcount=True, ebarmode=ebarmode)
ax = fig.add_subplot(3, 5, 14)
momentsml.plot.bin.res(ax, cat, tru_sc, pre_gc_mean, Feature("tru_sersicn"), ncbins=3, equalcount=True, ebarmode=ebarmode)
ax = fig.add_subplot(3, 5, 15)
momentsml.plot.bin.res(ax, cat, tru_sc, pre_gc_mean, Feature("tru_g"), ncbins=3, equalcount=True, ebarmode=ebarmode)
"""
plt.tight_layout()
if filepath:
plt.savefig(filepath)
else:
plt.show()
plt.close(fig) # Helps releasing memory when calling in large loops.
def plot(simcat, obscat, filepath=None):
# Some computations
simcat["aperphot_sbr1"] = simcat["aperphot_sb2"] / simcat["aperphot_sb5"]
obscat["aperphot_sbr1"] = obscat["aperphot_sb2"] / obscat["aperphot_sb5"]
simcat["aperphot_sbr2"] = simcat["aperphot_sb3"] / simcat["aperphot_sb8"]
obscat["aperphot_sbr2"] = obscat["aperphot_sb3"] / obscat["aperphot_sb8"]
simcat["aperphot_log_sb2"] = np.log10(simcat["aperphot_sb2"])
simcat["aperphot_log_sb5"] = np.log10(simcat["aperphot_sb5"])
obscat["aperphot_log_sb2"] = np.log10(obscat["aperphot_sb2"])
obscat["aperphot_log_sb5"] = np.log10(obscat["aperphot_sb5"])
simcat["adamom_log_flux"] = np.log10(simcat["adamom_flux"])
obscat["adamom_log_flux"] = np.log10(obscat["adamom_flux"])
rea = None
adamom_flux = Feature("adamom_flux", rea=rea)
adamom_sigma = Feature("adamom_sigma", 0, 10, rea=rea)
adamom_rho4 = Feature("adamom_rho4", 1.3, 3.0, rea=rea)
adamom_g1 = Feature("adamom_g1", -0.7, 0.7, rea=rea)
adamom_g2 = Feature("adamom_g2", -0.7, 0.7, rea=rea)
adamom_log_flux = Feature("adamom_log_flux", rea=rea)
aperphot_sbr1 = Feature("aperphot_sbr1", rea=rea)
aperphot_sbr2 = Feature("aperphot_sbr2", rea=rea)
snr = Feature("snr", -3, 30, rea=rea)
aperphot_sb2 = Feature("aperphot_sb2", 0, 5, rea=rea)
aperphot_sb3 = Feature("aperphot_sb3", 0, 5, rea=rea)
aperphot_sb5 = Feature("aperphot_sb5", 0, 5, rea=rea)
aperphot_sb8 = Feature("aperphot_sb8", 0, 5, rea=rea)
aperphot_log_sb5 = Feature("aperphot_log_sb5", rea=rea)
aperphot_log_sb2 = Feature("aperphot_log_sb2", rea=rea)
skymad = Feature("skymad", rea=rea)
skystd = Feature("skystd", rea=rea)
skymed = Feature("skymed", rea=rea)
skymean = Feature("skymean", rea=rea)
#psf_adamom_g1 = Feature("psf_adamom_g1", -0.06, 0.06, rea=rea)
#psf_adamom_g2 = Feature("psf_adamom_g2", -0.06, 0.06, rea=rea)
#psf_adamom_sigma = Feature("psf_adamom_sigma", rea=rea)
fig = plt.figure(figsize=(24, 14))
#fig = plt.figure(figsize=(8, 8))
ax = fig.add_subplot(3, 5, 1)
momentsml.plot.contour.simobs(ax, simcat, obscat, adamom_g1, adamom_g2, plotpoints=False, nlines=2)
#momentsml.plot.hist.hist(ax, simcat, snr, color="red", label="Training", normed=True)
#momentsml.plot.hist.hist(ax, obscat, snr, color="blue", label="GREAT3", normed=True)
ax = fig.add_subplot(3, 5, 2)
momentsml.plot.scatter.simobs(ax, simcat, obscat, adamom_g1, adamom_g2)
ax = fig.add_subplot(3, 5, 3)
momentsml.plot.scatter.simobs(ax, simcat, obscat, snr, adamom_sigma, legend=True)
ax = fig.add_subplot(3, 5, 4)
momentsml.plot.scatter.simobs(ax, simcat, obscat, adamom_flux, adamom_sigma)
ax = fig.add_subplot(3, 5, 5)
momentsml.plot.scatter.simobs(ax, simcat, obscat, Feature("adamom_flux", 0, 80, rea=rea), Feature("adamom_sigma", 0.5, 3.5, rea=rea))
ax = fig.add_subplot(3, 5, 6)
momentsml.plot.scatter.simobs(ax, simcat, obscat, aperphot_sb2, aperphot_sb3)
ax = fig.add_subplot(3, 5, 7)
momentsml.plot.scatter.simobs(ax, simcat, obscat, aperphot_sb5, aperphot_sb8)
ax = fig.add_subplot(3, 5, 8)
momentsml.plot.scatter.simobs(ax, simcat, obscat, aperphot_sbr1, aperphot_sbr2)
ax = fig.add_subplot(3, 5, 9)
momentsml.plot.scatter.simobs(ax, simcat, obscat, adamom_log_flux, adamom_sigma)
ax = fig.add_subplot(3, 5, 11)
momentsml.plot.contour.simobs(ax, simcat, obscat, skymad, skymean, plotpoints=False)
ax = fig.add_subplot(3, 5, 12)
momentsml.plot.scatter.simobs(ax, simcat, obscat, aperphot_log_sb2, aperphot_log_sb5)
ax = fig.add_subplot(3, 5, 13)
momentsml.plot.scatter.simobs(ax, simcat, obscat, adamom_rho4, adamom_sigma)
ax = fig.add_subplot(3, 5, 14)
momentsml.plot.scatter.simobs(ax, simcat, obscat, adamom_log_flux, adamom_rho4)
#ax.set_xscale("log", nonposx='clip')
#ax = fig.add_subplot(3, 4, 12)
#momentsml.plot.scatter.simobs(ax, simcat, obscat, psf_adamom_g1, psf_adamom_g2)
#ax = fig.add_subplot(3, 4, 2)
#momentsml.plot.scatter.scatter(ax, cat, Feature("tru_s1"), Feature("tru_s2"))
plt.tight_layout()
if filepath:
plt.savefig(filepath)
else:
plt.show()
plt.close(fig) # Helps releasing memory when calling in large loops.
cat["offset"] = cat[pre] - cat[tru]
for row in cat:
if np.fabs(row["offset"]) > thr:
#print row[tru], row[pre], str(row["subfield"])
ax.text(row[tru], row[pre] - row[tru], str(row["subfield"]))
sr = 0.07 # shear range
srp = 0.2 # shear range predictions
swrp = 0.02
fig = plt.figure(figsize=(22, 13))
ax = fig.add_subplot(3, 4, 1)
momentsml.plot.scatter.scatter(ax, cat, Feature("tru_s1", -sr, sr), Feature("pre_s1_res", -srp, srp), Feature("psf_adamom_sigma"), yisres=True, metrics=True, showidline=True, idlinekwargs={"color":"black"})
labeloutliers(ax, cat, "pre_s1", "tru_s1")
ax.set_title("Unweighted, wide")
ax = fig.add_subplot(3, 4, 2)
momentsml.plot.scatter.scatter(ax, cat, Feature("tru_s2", -sr, sr), Feature("pre_s2_res", -srp, srp), Feature("psf_adamom_sigma"), yisres=True, metrics=True, showidline=True, idlinekwargs={"color":"black"})
labeloutliers(ax, cat, "pre_s2", "tru_s2")
ax = fig.add_subplot(3, 4, 3)
momentsml.plot.scatter.scatter(ax, cat, Feature("tru_s1", -sr, sr), Feature("pre_s1_res", -srp, srp), Feature("psf_adamom_g1"), yisres=True, showidline=True, idlinekwargs={"color":"black"})
ax = fig.add_subplot(3, 4, 4)
momentsml.plot.scatter.scatter(ax, cat, Feature("tru_s2", -sr, sr), Feature("pre_s2_res", -srp, srp), Feature("psf_adamom_g2"), yisres=True, showidline=True, idlinekwargs={"color":"black"})
ax = fig.add_subplot(3, 4, 5)
from momentsml.tools.feature import Feature
import matplotlib
import matplotlib.pyplot as plt
cat = momentsml.tools.io.readpickle(os.path.join(config.simmeasdir, config.datasets["si"], "groupmeascat.pkl"))
print momentsml.tools.table.info(cat)
fig = plt.figure(figsize=(20, 13))
ax = fig.add_subplot(2, 3, 1)
momentsml.plot.scatter.scatter(ax, cat, Feature("tru_psf_x"), Feature("tru_psf_y"), Feature("tru_psf_g1"))
ax = fig.add_subplot(2, 3, 2)
momentsml.plot.scatter.scatter(ax, cat, Feature("tru_psf_x"), Feature("tru_psf_y"), Feature("tru_psf_g2"))
ax = fig.add_subplot(2, 3, 3)
momentsml.plot.scatter.scatter(ax, cat, Feature("tru_psf_x"), Feature("tru_psf_y"), Feature("tru_psf_sigma"))
ax = fig.add_subplot(2, 3, 4)
momentsml.plot.scatter.scatter(ax, cat, Feature("tru_psf_x"), Feature("tru_psf_y"), Feature("adamom_g1"))
ax = fig.add_subplot(2, 3, 5)
momentsml.plot.scatter.scatter(ax, cat, Feature("tru_psf_x"), Feature("tru_psf_y"), Feature("adamom_g2"))
ax = fig.add_subplot(2, 3, 6)
momentsml.plot.scatter.scatter(ax, cat, Feature("tru_psf_x"), Feature("tru_psf_y"), Feature("adamom_sigma"))
#rc('font',**{'family':'serif','serif':['Palatino']})
rc('text', usetex=True)
rasterized=True
valcat = os.path.join(config.simmeasdir, config.datasets["vp"], "groupmeascat.pkl")
cat = momentsml.tools.io.readpickle(valcat)
#print momentsml.tools.table.info(cat)
momentsml.tools.table.addstats(cat, "snr")
cat["adamom_goodfrac"] = 1.0 - cat["adamom_failfrac"]
tru_sb = Feature("tru_sb", 0, 16, nicename=r"Surface brightness $S$ [pix$^{-2}$]")
tru_rad = Feature("tru_rad", 1.5, 8.5, nicename=r"Half-light radius $R$ [pix]")
snr_mean = Feature("snr_mean", nicename="$\\langle \mathrm{S}/\mathrm{N}\\rangle$")
successfrac = Feature("adamom_goodfrac", nicename="Measurement success fraction")
for comp in ["1"]:
fig = plt.figure(figsize=(3.5, 6))
ax = fig.add_subplot(2, 1, 1)
cb = momentsml.plot.scatter.scatter(ax, cat, tru_sb, tru_rad, featc=snr_mean, cmap="plasma_r", norm=matplotlib.colors.PowerNorm(gamma=1./2.), rasterized=rasterized)
cb.set_ticks([2, 5, 10, 20, 30, 40, 50, 60])
print momentsml.tools.table.info(cat)
for col in ["pre_s1", "pre_s2", "snr"]:
momentsml.tools.table.addstats(cat, col)
momentsml.tools.table.addrmsd(cat, "pre_s1", "tru_s1")
momentsml.tools.table.addrmsd(cat, "pre_s2", "tru_s2")
print momentsml.tools.table.info(cat)
fig = plt.figure(figsize=(20, 13))
ax = fig.add_subplot(3, 4, 1)
momentsml.plot.scatter.scatter(ax,
cat,
Feature("tru_rad", rea=1),
Feature("tru_sersicn", rea="full"),
sidehists=True,
sidehistkwargs={"bins": 20})
ax = fig.add_subplot(3, 4, 2)
momentsml.plot.scatter.scatter(ax, cat, Feature("adamom_sigma", rea="full"),
Feature("tru_rad", rea="full"))
ax = fig.add_subplot(3, 4, 3)
momentsml.plot.scatter.scatter(ax, cat, Feature("tru_s2"),
Feature("tru_rad", rea="full"),
Feature("pre_s2_bias"))
ax = fig.add_subplot(3, 4, 4)
momentsml.plot.scatter.scatter(ax, cat, Feature("tru_s1"),
Feature("tru_rad", rea="full"),
Feature("pre_s1_bias"))
from momentsml.tools.feature import Feature
import matplotlib
import matplotlib.pyplot as plt
cat = momentsml.tools.io.readpickle(
os.path.join(config.simmeasdir, "tp-1-pretrain", "groupmeascat.pkl"))
momentsml.tools.table.addstats(cat, "snr")
#print momentsml.tools.table.info(cat)
#exit()
fig = plt.figure(figsize=(20, 13))
snr_mean = Feature("snr_mean")
snr = Feature("snr")
tru_rad = Feature("tru_rad")
tru_mag = Feature("tru_mag")
tru_sersicn = Feature("tru_sersicn")
skystd = Feature("skystd")
skymed = Feature("skymed")
adamom_flux = Feature("adamom_flux")
adamom_logflux = Feature("adamom_logflux")
adamom_sigma = Feature("adamom_sigma")
adamom_g1 = Feature("adamom_g1")
adamom_g2 = Feature("adamom_g2")
adamom_g = Feature("adamom_g")
from momentsml.tools.feature import Feature
import matplotlib
import matplotlib.pyplot as plt
cat = momentsml.tools.io.readpickle(os.path.join(config.workdir, "cat.pkl"))
print momentsml.tools.table.info(cat)
fig = plt.figure(figsize=(20, 13))
#tru_rad = Feature("tru_rad", nicename="True half-light radius [pixel]")
#tru_mag = Feature("tru_mag", 20, 25, nicename="Magnitude")
#tru_sersicn = Feature("tru_sersicn", 0, 7, nicename="True Sersic index")
tru_rad = Feature("tru_rad")
tru_mag = Feature("tru_mag")
tru_sersicn = Feature("tru_sersicn")
ax = fig.add_subplot(2, 3, 1)
momentsml.plot.scatter.scatter(ax,
cat,
tru_sersicn,
tru_rad,
sidehists=True,
sidehistkwargs={"bins": 20})
ax = fig.add_subplot(2, 3, 2)
momentsml.plot.scatter.scatter(ax,
cat,
tru_mag,
tru_rad,
select = False
valcat = os.path.join(config.valdir, valname + ".pkl")
cat = momentsml.tools.io.readpickle(valcat)
momentsml.tools.table.addstats(
cat, "snr") # We need this even without select, to show the snr_mean axis
if select:
s = momentsml.tools.table.Selector("snr_mean > 10", [
("min", "snr_mean", 10.0),
])
cat = s.select(cat)
if select:
snr_mean = Feature("snr_mean", 5, 75, nicename=r"$\langle$S/N$\rangle$")
else:
snr_mean = Feature("snr_mean", 0, 75, nicename=r"$\langle$S/N$\rangle$")
tru_flux = Feature("tru_flux", nicename=r"$F$ [counts]")
tru_rad = Feature("tru_rad", 1.8, 8.5, nicename=r"Half-light radius $R$ [pix]")
tru_radwrtPSF = Feature("tru_radwrtPSF",
0.5,
3.5,
nicename=r"$R/R_\mathrm{PSF}$")
tru_sersicn = Feature("tru_sersicn", 0.5, 4.5, nicename=r"S\'ersic index $n$")
tru_g = Feature("tru_g",
-0.02,
0.62,
nicename=r"Galaxy ellipticity $|\varepsilon|$")
cat["tru_radwrtPSF"] = cat["tru_rad"] / (cat["tru_psf_sigma"] * 1.1774)
def main():
assert len(config.great3.subfields) == 1
subfield = config.great3.subfields[0]
plotpath = config.great3.path("fig_1_{}_{}.pdf".format(
config.great3.get_branchacronym(), subfield))
measdir = config.great3.subpath(subfield, "simmeas")
simcatg3 = momentsml.tools.io.readpickle(
os.path.join(measdir, "simobscompa-G3", "groupmeascat.pkl"))
#print momentsml.tools.table.info(simcat)
simcattrain = momentsml.tools.io.readpickle(
os.path.join(measdir, "simobscompa-train", "groupmeascat.pkl"))
#print momentsml.tools.table.info(simcat)
obscat = momentsml.tools.io.readpickle(
config.great3.subpath(subfield, "obs", "img_meascat.pkl"))
#print momentsml.tools.table.info(obscat)
#obscat = obscat[:1000]
for cat in [simcatg3, simcattrain, obscat]:
cat["adamom_log_flux"] = np.log10(cat["adamom_flux"])
cat["adamom_g"] = np.hypot(cat["adamom_g1"], cat["adamom_g2"])
fig = plt.figure(figsize=(9, 3))
#fig = plt.figure(figsize=(8, 8))
subfieldstr = str(subfield)
if len(subfieldstr) == 4: # We cut the "1000"
subfieldstr = subfieldstr[1:]
fig.text(.02,
.58,
config.great3.get_branchacronym().upper(),
fontdict={"fontsize": 22})
fig.text(.02,
.5,
"Subfield {}".format(subfieldstr),
fontdict={"fontsize": 10})
#fig.text(.05, .7, "GREAT3".format(subfieldstr), fontdict={"fontsize":10, "color":"red"})
#fig.text(.05, .65, "Mock".format(subfieldstr), fontdict={"fontsize":10, "color":"blue"})
#fig.text(.05, .6, "Uniform".format(subfieldstr), fontdict={"fontsize":10, "color":"green"})
ax = plt.axes([.3, .2, .29, .78])
#ax = fig.add_subplot(1, 2, 1)
if config.great3.obstype == "space":
simobs(ax,
obscat,
simcatg3,
simcattrain,
Feature("adamom_log_flux",
0.3,
2.5,
nicename=r"$log_{10}(\mathtt{adamom\_flux})$"),
Feature("adamom_sigma",
0,
10,
nicename=r"$\mathtt{adamom\_sigma} [\mathrm{pix}]$"),
legend=True,
plotpoints=False)
elif config.great3.obstype == "ground":
simobs(ax,
obscat,
simcatg3,
simcattrain,
Feature("adamom_log_flux",
0.3,
2.5,
nicename=r"$log_{10}(\mathtt{adamom\_flux})$"),
Feature("adamom_sigma",
1.,
3.,
nicename=r"$\mathtt{adamom\_sigma} [\mathrm{pix}]$"),
legend=True,
plotpoints=False)
#ax = fig.add_subplot(1, 2, 2)
ax = plt.axes([.7, .2, .29, .78])
simobs(ax,
obscat,
simcatg3,
simcattrain,
Feature("adamom_g", -0.09, 0.6, nicename=r"$\mathtt{adamom\_g}$"),
Feature("adamom_rho4",
1.8,
2.8,
nicename=r"$\mathtt{adamom\_rho4}$"),
plotpoints=False)
ax.xaxis.set_major_locator(plticker.MultipleLocator(base=0.2))
obsline = mlines.Line2D([], [],
color='red',
ls="-",
marker=None,
label='GREAT3')
simg3line = mlines.Line2D([], [],
color='blue',
ls=":",
marker=None,
label='Mock sims')
simtrainline = mlines.Line2D([], [],
color='green',
ls="--",
marker=None,
label='Uniform sims')
#plt.legend(handles=[obsline])
plt.legend(handles=[obsline, simg3line, simtrainline],
bbox_to_anchor=(0.16, 0.999),
bbox_transform=plt.gcf().transFigure,
fontsize=10)
#plt.tight_layout()
plt.savefig(plotpath)
SMALL_SIZE = 14
MEDIUM_SIZE = 16
BIGGER_SIZE = 30
plt.rc('font', size=SMALL_SIZE) # controls default text sizes
plt.rc('axes', titlesize=SMALL_SIZE) # fontsize of the axes title
plt.rc('axes', labelsize=MEDIUM_SIZE) # fontsize of the x and y labels
plt.rc('xtick', labelsize=SMALL_SIZE) # fontsize of the tick labels
plt.rc('ytick', labelsize=SMALL_SIZE) # fontsize of the tick labels
plt.rc('legend', fontsize=SMALL_SIZE) # legend fontsize
plt.rc('figure', titlesize=BIGGER_SIZE) # fontsize of the figure title
#print momentsml.tools.table.info(cat)
#mets = momentsmlgreat3.utils.metrics(cat, ("tru_s1", "tru_s2"), ("pre_s1w", "pre_s2w"), psfgcols=("tru_psf_g1", "tru_psf_g2"))
"""
featc = Feature("psf_adamom_sigma",
nicename=r"PSF $\mathtt{adamom\_sigma}$ [pix]")
cmap = "plasma_r"
#fig = plt.figure(figsize=(8, 7))
#fig = plt.figure(figsize=(9, 4.5))
fig = plt.figure(figsize=(7.5, 6.4))
fig.text(.005,
.94,
config.great3.get_branchacronym().upper(),
fontdict={"fontsize": 22})
#ax = plt.axes([.09, paneltoplevel, panelxw, panelyw])
resr = 0.039
symthres = 0.004
print momentsml.tools.table.info(cat)
for col in ["pre_g1", "snr"]:
momentsml.tools.table.addstats(cat, col)
momentsml.tools.table.addrmsd(cat, "pre_g1", "tru_g1")
print momentsml.tools.table.info(cat)
fig = plt.figure(figsize=(20, 13))
ax = fig.add_subplot(3, 4, 1)
momentsml.plot.scatter.scatter(ax, cat, Feature("tru_g", rea=1), Feature("tru_sersicn"), sidehists=True, sidehistkwargs={"bins":20})
ax = fig.add_subplot(3, 4, 2)
momentsml.plot.scatter.scatter(ax, cat, Feature("tru_flux", rea=1), Feature("tru_rad"), sidehists=True, sidehistkwargs={"bins":20})
ax = fig.add_subplot(3, 4, 3)
momentsml.plot.scatter.scatter(ax, cat, Feature("adamom_sigma", rea="full"), Feature("tru_rad"))
ax = fig.add_subplot(3, 4, 4)
momentsml.plot.scatter.scatter(ax, cat, Feature("tru_g1"), Feature("tru_rad"), Feature("pre_g1_bias"))
ax = fig.add_subplot(3, 4, 5)
momentsml.plot.bin.res(ax, cat, Feature("tru_g1"), Feature("pre_g1", rea="full"), ebarmode="scatter")
ax = fig.add_subplot(3, 4, 6)
momentsml.plot.bin.res(ax, cat, Feature("tru_g1"), Feature("pre_g1", rea="full"), Feature("tru_flux"), ncbins=3, equalcount=True, ebarmode="scatter")
ax = fig.add_subplot(3, 4, 7)
momentsml.plot.bin.res(ax, cat, Feature("tru_g1"), Feature("pre_g1", rea="full"), Feature("tru_rad"), ncbins=3, equalcount=True, ebarmode="scatter")
ax = fig.add_subplot(3, 4, 8)
cat["tru_rad"] = (0.03 / 0.1) * cat[
"ST_RE_GALFIT"] # GEMS is 0.03 arcsec per pixel, and we want VIS pixels of 0.1 arcsec
cat["tru_mag"] = cat["ST_MAG_GALFIT"]
cat["tru_sersicn"] = cat["ST_N_GALFIT"]
# We reject any nans in the field that we want
s = momentsml.tools.table.Selector("nonan", [
("nomask", "tru_rad"),
("nomask", "tru_mag"),
("nomask", "tru_sersicn"),
])
cat = s.select(cat)
fig = plt.figure(figsize=(20, 10))
maggal = Feature("ST_MAG_GALFIT")
magsex = Feature("ST_MAG_BEST")
sersicn = Feature("ST_N_GALFIT")
radsex = Feature("ST_FLUX_RADIUS")
radgal = Feature("ST_RE_GALFIT")
tru_mag = Feature("tru_mag", nicename="VIS magnitude")
tru_rad = Feature("tru_rad", nicename="Half-light radius [VIS pix]")
tru_sersicn = Feature("tru_sersicn", nicename="Sersic index")
ax = fig.add_subplot(2, 4, 1)
momentsml.plot.scatter.scatter(ax, cat, magsex, maggal, radsex, sidehists=True)
ax = fig.add_subplot(2, 4, 2)
momentsml.plot.scatter.scatter(ax, cat, radsex, radgal, maggal)
from momentsml.tools.feature import Feature
import matplotlib
import matplotlib.pyplot as plt
cat = momentsml.tools.io.readpickle(
os.path.join(config.simmeasdir, config.datasets["si"], "groupmeascat.pkl"))
print momentsml.tools.table.info(cat)
fig = plt.figure(figsize=(20, 13))
ax = fig.add_subplot(2, 3, 1)
momentsml.plot.scatter.scatter(ax,
cat,
Feature("tru_g"),
Feature("tru_sersicn"),
sidehists=True,
sidehistkwargs={"bins": 20})
ax = fig.add_subplot(2, 3, 2)
momentsml.plot.scatter.scatter(ax,
cat,
Feature("tru_flux"),
Feature("tru_rad"),
sidehists=True,
sidehistkwargs={"bins": 20})
ax = fig.add_subplot(2, 3, 3)
momentsml.plot.scatter.scatter(ax, cat, Feature("tru_sb"), Feature("tru_rad"),
Feature("snr"))
ax = fig.add_subplot(2, 3, 4)
cat = momentsml.tools.io.readpickle(valcat)
momentsml.tools.table.addstats(cat, "snr") # We need this even without select, to show the snr_mean axis
#print momentsml.tools.table.info(cat)
if select:
s = momentsml.tools.table.Selector("snr_mean > 10", [
("min", "snr_mean", 10.0),
])
cat = s.select(cat)
if select:
snr_mean = Feature("snr_mean", 5, 200, nicename=r"$\langle$S/N$\rangle$")
else:
snr_mean = Feature("snr_mean", 0, 200, nicename=r"$\langle$S/N$\rangle$")
tru_flux = Feature("tru_flux", nicename=r"$F$ [counts]")
tru_rad = Feature("tru_rad", 0, 11, nicename=r"Half-light radius $R$ [pix]")
#tru_radwrtPSF = Feature("tru_radwrtPSF", 0.5, 3.5, nicename=r"$R/R_\mathrm{PSF}$")
tru_sersicn = Feature("tru_sersicn", 0, 7, nicename=r"S\'ersic index $n$")
tru_g = Feature("tru_g", -0.02, 0.72, nicename=r"Galaxy ellipticity $|\varepsilon|$")
cat["tru_radwrtPSF"] = cat["tru_rad"] / (cat["tru_psf_sigma"] * 1.1774)
tru_s1 = Feature("tru_s1")
tru_s2 = Feature("tru_s2")
pre_s1 = Feature("pre_s1", rea="all")
pre_s2 = Feature("pre_s2", rea="all")
import matplotlib.pyplot as plt
#### Parameters ###################
genworkdir = "/vol/fohlen11/fohlen11_1/mtewes/snr_study/"
name = "v1"
####################################
workdir = os.path.join(genworkdir, name)
catpath = os.path.join(workdir, "cat.pkl")
cat = momentsml.tools.io.readpickle(catpath)
tru_flux = Feature("tru_flux", 0, 55000)
tru_cropper_snr = Feature("tru_cropper_snr")
gain1_snr_mean = Feature("gain1_snr_mean")
gain1_aper3hlr_snr_mean = Feature("gain1_aper3hlr_snr_mean")
sex_snr_iso_mean = Feature("sex_snr_iso_mean")
sex_snr_auto_mean = Feature("sex_snr_auto_mean", 0, 90)
fig = plt.figure(figsize=(8, 8))
ax = fig.add_subplot(1, 1, 1)
momentsml.plot.scatter.scatter(ax,
cat,
tru_flux,
tru_cropper_snr,
sidehists=False,
color="black",
print momentsml.tools.table.info(cat)
fig = plt.figure(figsize=(4, 2.5))
plt.subplots_adjust(
left=0.15, # the left side of the subplots of the figure
right=0.95, # the right side of the subplots of the figure
bottom=0.2, # the bottom of the subplots of the figure
top=0.95, # the top of the subplots of the figure
wspace=0.1, # the amount of width reserved for blank space between subplots,
# expressed as a fraction of the average axis width
hspace=
0.25, # the amount of height reserved for white space between subplots,
# expressed as a fraction of the average axis heightbottom=0.1, right=0.8, top=0.9)
)
tru_rad = Feature("tru_rad", -1, 13, nicename="Half-light radius [VIS pix]")
tru_mag = Feature("tru_mag", 20, 25.5, nicename="Magnitude")
tru_sersicn = Feature("tru_sersicn",
0,
6.5,
nicename=r"${\textrm{S\'ersic}$ index")
ax = fig.add_subplot(1, 1, 1)
momentsml.plot.hist.hist(ax, cat, tru_sersicn, normed=True)
ax.set_ylabel("Relative frequency")
#ax.set_yticklabels([])
momentsml.plot.figures.savefig(os.path.join(config.valdir, "sourcecat2"),
fig,
fancy=True,
pdf_transparence=True,
# First putting all weights to 1.0:
cat["pre_s{}w".format(comp)] = np.ones(cat["adamom_g1"].shape)
cat["pre_s{}w_norm".format(comp)] = cat["pre_s{}w".format(comp)] / np.max(cat["pre_s{}w".format(comp)])
momentsml.tools.table.addrmsd(cat, "pre_s{}".format(comp), "tru_s{}".format(comp))
momentsml.tools.table.addstats(cat, "pre_s{}".format(comp), "pre_s{}w".format(comp))
cat["pre_s{}_wbias".format(comp)] = cat["pre_s{}_wmean".format(comp)] - cat["tru_s{}".format(comp)]
"""
fwhmpersigma = 2.3548
cat["tru_psf_fwhm"] = cat["tru_psf_sigma"] * fwhmpersigma
tru_psf_g1 = Feature("tru_psf_g1",
-0.27,
0.27,
nicename=r"PSF $\varepsilon_1$")
tru_psf_g2 = Feature("tru_psf_g2",
-0.02,
0.27,
nicename=r"PSF $\varepsilon_2$")
tru_psf_fwhm = Feature("tru_psf_fwhm", 4.1, 5.35, nicename=r"PSF FWHM [pix]")
def make_plot(ax, featbin, showlegend=False):
ax.axhline(0.0, color='gray', lw=0.5)
if weights is True:
momentsml.plot.mcbin.mcbin(ax,
cat,
Feature("tru_s1"),
Feature("pre_s1", rea="all"),
def plot(cat,
component,
mode="s",
filepath=None,
select=None,
withweights=False):
logger.info("Running on component {} with mode {}".format(component, mode))
#cat["adamom_log_flux"] = np.log10(cat["adamom_flux"])
#cat["adamom_frac"] = np.sum(cat["adamom_g1"].mask, axis=1)/float(cat["adamom_g1"].shape[1])
prename = "pre_s{}".format(component)
cat["pre_maskedfrac"] = np.sum(cat[prename].mask, axis=1) / float(
cat[prename].shape[1])
#cat["pre_frac"] = (float(cat[prename].shape[1]) - np.sum(cat[prename].mask, axis=1)) / float(cat[prename].shape[1])
#b = cat["tru_s1", "pre_maskedfrac", "adamom_failfrac"]
#b.show_in_browser()
#exit()
#assert np.allclose(["pre_maskedfrac"], cat["adamom_failfrac"])
pre_maskedfrac = Feature("pre_maskedfrac")
momentsml.tools.table.addstats(cat, "adamom_flux")
momentsml.tools.table.addstats(cat, "adamom_sigma")
momentsml.tools.table.addstats(cat, "snr")
snr_mean = Feature("snr_mean")
#print min(cat["adamom_frac"]), max(cat["adamom_frac"]), np.median(cat["adamom_frac"])
if select is not None:
cat = select.select(cat)
#print min(cat["snr_mean"]), max(cat["snr_mean"]), np.median(cat["snr_mean"])
momentsml.tools.table.addrmsd(cat, "pre_s{}".format(component),
"tru_{}{}".format(mode, component))
if withweights == False:
momentsml.tools.table.addstats(cat, "pre_s{}".format(component))
pre_sc_bias = Feature("pre_s{}_bias".format(component))
pre_sc_mean = Feature("pre_s{}_mean".format(component))
else: # Then we use weights if available)
if not "pre_s{}w".format(component) in cat.colnames:
# It doesn't make sense to fake them for this plot, just skip it!
logger.warning("No weights available, skipping")
return
momentsml.tools.table.addstats(cat,
"pre_s{}".format(component),
wcol="pre_s{}w".format(component))
cat["pre_s{}_wbias".format(component)] = cat["pre_s{}_wmean".format(
component)] - cat["tru_{}{}".format(mode, component)]
pre_sc_bias = Feature("pre_s{}_wbias".format(component))
pre_sc_mean = Feature("pre_s{}_wmean".format(component))
tru_sc = Feature("tru_{}{}".format(mode, component))
ebarmode = "scatter"
fig = plt.figure(figsize=(24, 12))
ax = fig.add_subplot(3, 5, 1)
momentsml.plot.scatter.scatter(ax,
cat,
tru_sc,
pre_sc_mean,
featc=snr_mean,
showidline=True,
metrics=True)
ax = fig.add_subplot(3, 5, 2)
#momentsml.plot.scatter.scatter(ax, cat, tru_sc, Feature("snr_mean"), pre_sc_bias)
momentsml.plot.scatter.scatter(ax, cat, tru_sc, Feature("snr", rea=1),
pre_sc_bias)
ax = fig.add_subplot(3, 5, 3)
cnorm = matplotlib.colors.SymLogNorm(linthresh=0.01)
momentsml.plot.scatter.scatter(ax,
cat,
tru_sc,
Feature("tru_rad"),
pre_sc_bias,
norm=cnorm)
ax = fig.add_subplot(3, 5, 4)
momentsml.plot.scatter.scatter(ax, cat, tru_sc, Feature("tru_sersicn"),
pre_sc_bias)
ax = fig.add_subplot(3, 5, 5)
momentsml.plot.scatter.scatter(ax, cat, tru_sc, Feature("tru_g"),
pre_sc_bias)
ax = fig.add_subplot(3, 5, 6)
momentsml.plot.scatter.scatter(ax, cat, Feature("tru_flux"), pre_sc_bias,
Feature("tru_rad"))
ax = fig.add_subplot(3, 5, 7)
#momentsml.plot.scatter.scatter(ax, cat, tru_sc, Feature("adamom_frac"), pre_sc_bias)
momentsml.plot.scatter.scatter(ax,
cat,
pre_maskedfrac,
pre_sc_bias,
sidehists=True)
#ax.set_xscale("log", nonposy='clip')
ax = fig.add_subplot(3, 5, 8)
#momentsml.plot.scatter.scatter(ax, cat, tru_sc, Feature("tru_flux"), pre_sc_bias, norm=cnorm)
momentsml.plot.scatter.scatter(ax, cat, tru_sc, Feature("tru_rad"),
pre_sc_bias)
ax = fig.add_subplot(3, 5, 9)
#momentsml.plot.scatter.scatter(ax, cat, Feature("tru_flux"), pre_sc_bias, Feature("tru_rad"))
#momentsml.plot.scatter.scatter(ax, cat, tru_sc, Feature("adamom_flux_mean"), pre_gc_bias)
momentsml.plot.scatter.scatter(ax, cat, tru_sc, Feature("tru_flux"),
pre_sc_bias)
ax = fig.add_subplot(3, 5, 10)
#momentsml.plot.scatter.scatter(ax, cat, tru_sc, Feature("adamom_sigma", rea=1), pre_sc_bias)
#momentsml.plot.scatter.scatter(ax, cat, tru_sc, Feature("tru_sb"), pre_sc_bias)
momentsml.plot.scatter.scatter(ax, cat, Feature("tru_flux"),
Feature("pre_s{}".format(component), rea=1),
Feature("tru_rad"))
ax = fig.add_subplot(3, 5, 11)
momentsml.plot.bin.res(ax,
cat,
tru_sc,
pre_sc_mean,
Feature("tru_sb"),
ncbins=3,
equalcount=True,
ebarmode=ebarmode)
ax = fig.add_subplot(3, 5, 12)
momentsml.plot.bin.res(ax,
cat,
tru_sc,
pre_sc_mean,
Feature("tru_flux"),
ncbins=3,
equalcount=True,
ebarmode=ebarmode)
ax = fig.add_subplot(3, 5, 13)
momentsml.plot.bin.res(ax,
cat,
tru_sc,
pre_sc_mean,
Feature("tru_rad"),
ncbins=3,
equalcount=True,
ebarmode=ebarmode)
ax = fig.add_subplot(3, 5, 14)
momentsml.plot.bin.res(ax,
cat,
tru_sc,
pre_sc_mean,
Feature("tru_sersicn"),
ncbins=3,
equalcount=True,
ebarmode=ebarmode)
ax = fig.add_subplot(3, 5, 15)
momentsml.plot.bin.res(ax,
cat,
tru_sc,
pre_sc_mean,
Feature("tru_g"),
ncbins=3,
equalcount=True,
ebarmode=ebarmode)
plt.tight_layout()
if filepath:
logger.info("Writing plot to '{}'...".format(filepath))
plt.savefig(filepath)
else:
plt.show()
plt.close(fig) # Helps releasing memory when calling in large loops.
for col in ["pre_s1", "pre_s2", "snr"]:
momentsml.tools.table.addstats(cat, col)
momentsml.tools.table.addrmsd(cat, "pre_s1", "tru_s1")
momentsml.tools.table.addrmsd(cat, "pre_s2", "tru_s2")
print momentsml.tools.table.info(cat)
fig = plt.figure(figsize=(20, 13))
ebarmode="bias"
ax = fig.add_subplot(3, 4, 1)
momentsml.plot.scatter.scatter(ax, cat, Feature("tru_rad", rea=1), Feature("tru_sersicn", rea="full"), sidehists=True, sidehistkwargs={"bins":20})
ax = fig.add_subplot(3, 4, 2)
momentsml.plot.scatter.scatter(ax, cat, Feature("adamom_sigma", rea="full"), Feature("tru_rad", rea="full"))
ax = fig.add_subplot(3, 4, 3)
momentsml.plot.scatter.scatter(ax, cat, Feature("tru_s2"), Feature("tru_rad", rea="full"), Feature("pre_s2_bias"))
ax = fig.add_subplot(3, 4, 4)
momentsml.plot.scatter.scatter(ax, cat, Feature("tru_s1"), Feature("tru_rad", rea="full"), Feature("pre_s1_bias"))
ax = fig.add_subplot(3, 4, 5)
momentsml.plot.bin.res(ax, cat, Feature("tru_s1"), Feature("pre_s1", rea="full"), ebarmode=ebarmode)
ax = fig.add_subplot(3, 4, 6)
momentsml.plot.bin.res(ax, cat, Feature("tru_s1"), Feature("pre_s1", rea="full"), Feature("tru_flux"), ncbins=3, equalcount=True, ebarmode=ebarmode)
ax = fig.add_subplot(3, 4, 7)
momentsml.plot.bin.res(ax, cat, Feature("tru_s1"), Feature("pre_s1", rea="full"), Feature("tru_rad", rea="full"), ncbins=3, equalcount=True, ebarmode=ebarmode)
ax = fig.add_subplot(3, 4, 8)
momentsml.plot.bin.res(ax, cat, Feature("tru_s1"), Feature("pre_s1", rea="full"), Feature("tru_g", rea="full"), ncbins=3, equalcount=True, ebarmode=ebarmode)
import matplotlib
import matplotlib.pyplot as plt
#####
catgems = momentsml.tools.io.readpickle(
os.path.join(config.simmeasdir, "si-1-gems", "groupmeascat.pkl"))
catuni = momentsml.tools.io.readpickle(
os.path.join(config.simmeasdir, "si-1-uni", "groupmeascat.pkl"))
#####
fig = plt.figure(figsize=(12, 12))
snr = Feature("snr", 0, 50, nicename="Measured S/N")
tru_rad = Feature("tru_rad", nicename="True half-light radius [pixel]")
tru_mag = Feature("tru_mag", 20, 25, nicename="Magnitude")
tru_sersicn = Feature("tru_sersicn", 0, 7, nicename="True Sersic index")
skystd = Feature("skystd")
skymed = Feature("skymed")
adamom_flux = Feature("adamom_flux")
adamom_logflux = Feature("adamom_logflux")
adamom_sigma = Feature("adamom_sigma")
adamom_g1 = Feature("adamom_g1")
adamom_g2 = Feature("adamom_g2")
adamom_g = Feature("adamom_g")
adamom_rho4 = Feature("adamom_rho4")
#snr = Feature("snr", nicename="Measured S/N")
