In [1]:

    

%pylab inline

from __future__ import (division, print_function)

import os
import sys
import copy
import fnmatch
import warnings
import collections

import numpy as np
import scipy
try:
    from scipy.stats import scoreatpercentile
except:
    scoreatpercentile = False
from scipy.interpolate import interp1d
import cPickle as pickle

# Astropy
from astropy.io import fits
from astropy    import units as u
from astropy.stats import sigma_clip
from astropy.table import Table, Column
from astropy.utils.console import ProgressBar

# AstroML
from astroML.plotting import hist

# Matplotlib related
import matplotlib.pyplot as plt
from matplotlib.patches import Ellipse
from matplotlib.ticker import NullFormatter
from matplotlib.ticker import MaxNLocator
# Matplotlib default settings
rcdef = plt.rcParams.copy()
pylab.rcParams['figure.figsize'] = 12, 10
pylab.rcParams['xtick.major.size'] = 8.0
pylab.rcParams['xtick.major.width'] = 2.5
pylab.rcParams['xtick.minor.size'] = 4.0
pylab.rcParams['xtick.minor.width'] = 2.5
pylab.rcParams['ytick.major.size'] = 8.0
pylab.rcParams['ytick.major.width'] = 2.5
pylab.rcParams['ytick.minor.size'] = 4.0
pylab.rcParams['ytick.minor.width'] = 2.5

# Personal
import hscUtils as hUtil
import galSBP
import coaddCutoutGalfitSimple as gSimple 

import matplotlib.patches as mpatches
from matplotlib.patches import Ellipse
from matplotlib.collections import PatchCollection

# Color map 
from palettable.colorbrewer.sequential import Oranges_4
ORG4 = Oranges_4.mpl_colormap


    

    




Populating the interactive namespace from numpy and matplotlib






    




/usr/local/lib/python2.7/site-packages/matplotlib/__init__.py:1350: UserWarning:  This call to matplotlib.use() has no effect
because the backend has already been chosen;
matplotlib.use() must be called *before* pylab, matplotlib.pyplot,
or matplotlib.backends is imported for the first time.

  warnings.warn(_use_error_msg)

In [2]:

    

# Absolute magnitude of sun in HSC filters

# Actuall borrowed from DES filters
# Values from magsun.data in FSPS
amag_sun_des_g = 5.08
amag_sun_des_r = 4.62
amag_sun_des_i = 4.52
amag_sun_des_z = 4.52
amag_sun_des_y = 4.51

# Based on http://www.baryons.org/ezgal/filters.php
amag_sun_ukiss_y = 4.515

# Extinction correction factor for HSC 
## A\_lambda = Coeff * E(B-V) 

a_hsc_g = 3.233
a_hsc_r = 2.291 
a_hsc_i = 1.635
a_hsc_z = 1.261
a_hsc_y = 1.076

# 
SIGMA1 = 0.3173
SIGMA2 = 0.0455
SIGMA3 = 0.0027

RSMA_COMMON = np.arange(0.4, 4.2, 0.02)


    

In [3]:

    

# Code for Get Bootstrap mean or median 
def _confidence_interval_1d(A, alpha=.05, metric=np.mean, numResamples=10000, interpolate=True):
    """Calculates bootstrap confidence interval along one dimensional array"""
    
    if not isinstance(alpha, collections.Iterable):
        alpha = np.array([alpha])

    N = len(A)
    resampleInds = np.random.randint(0, N, (numResamples,N))
    metricOfResampled = metric(A[resampleInds], axis=-1)

    confidenceInterval = np.zeros(2*len(alpha),dtype='float')
    
    if interpolate:
        for thisAlphaInd, thisAlpha in enumerate(alpha):
            confidenceInterval[2*thisAlphaInd] = scoreatpercentile(metricOfResampled, 
                                                                   thisAlpha*100/2.0)
            confidenceInterval[2*thisAlphaInd+1] = scoreatpercentile(metricOfResampled, 
                                                                     100-thisAlpha*100/2.0)
    else:
        sortedMetricOfResampled = np.sort(metricOfResampled)
        for thisAlphaInd, thisAlpha in enumerate(alpha):
            confidenceInterval[2*thisAlphaInd] = sortedMetricOfResampled[int(round(thisAlpha*numResamples/2.0))]
            confidenceInterval[2*thisAlphaInd+1] = sortedMetricOfResampled[int(round(numResamples - 
                                                                                     thisAlpha*numResamples/2.0))]
    return confidenceInterval
    
def _ma_confidence_interval_1d(A, alpha=.05, metric=np.mean, numResamples=10000, interpolate=True):
    A = np.ma.masked_invalid(A, copy=True)
    A = A.compressed()
    confidenceInterval = _confidence_interval_1d(A, alpha, metric, numResamples, interpolate)
    return confidenceInterval

def confidence_interval(A, axis=None, alpha=.05, metric=np.mean, numResamples=10000, interpolate=True):
    """Return the bootstrap confidence interval of an array or along an axis ignoring NaNs and masked elements.
    
    Parameters
    ----------
    A : array_like
        Array containing numbers whose confidence interval is desired. 
    axis : int, optional
        Axis along which the confidence interval is computed.
        The default is to compute the confidence interval of the flattened array.
    alpha: float or array, optional
        confidence level of confidence interval. 100.0*(1-alpha) percent confidence 
        interval will be returned.
        If length-n array, n confidence intervals will be computed
        The default is .05
    metric : numpy function, optional
        metric to calculate confidence interval for.
        The default is numpy.mean
    numResamples : int, optional
        number of bootstrap samples. The default is 10000.
    interpolate: bool, optional
        uses scipy.stats.scoreatpercentile to interpolate between bootstrap samples 
        if alpha*numResamples/2.0 is not integer.
        The default is True
        
    Returns
    -------
    confidenceInterval : ndarray
    An array with the same shape as `A`, with the specified axis replaced by one twice the length of the alpha
    If `A` is a 0-d array, or if axis is None, a length-2 ndarray is returned.
    """
    if interpolate is True and scoreatpercentile is False:
        print("need scipy to interpolate between values")
        interpolate = False
    A = A.copy()
    if axis is None:
        A = A.ravel()
        outA = _ma_confidence_interval_1d(A, alpha, metric, numResamples, interpolate)
    else:
        outA = np.apply_along_axis(_ma_confidence_interval_1d, axis, A, alpha, 
                                   metric, numResamples, interpolate)
        
    return outA

def normProf(sma, sbp, minSma, maxSma, divide=False): 
    """
    Naive method to normalize the profile. 
    
    Parameters: 
        sbp    : Array for surface brightness profile 
        sma    : Radius range 
        minSma : Minimum SMA
        maxSma   Maximum SMA
    """
    offset = np.nanmedian(sbp[(sma >= minSma) & 
                              (sma <= maxSma)])
    if divide: 
        return (sbp / offset)
    else:
        return (sbp-offset)
    
    
def pixKpc(redshift, pix=0.168, show=True, npix=1.0):
    """
    Get the corresponding Kpc size of a pixel.  
    
    Parameters: 
    """
    pixKpc = pix * npix * hUtil.cosmoScale(redshift)

    if show:
        print("# %d pixel(s) = %6.3f Kpc" % (npix, pixKpc))
        
    return pixKpc


def logAdd(para1, para2):
    """ Useful for adding magnitudes. """
    return np.log10((10.0 ** np.asarray(para1)) + 
                    (10.0 ** np.asarray(para2)))


def errAdd(err1, err2):
    """Add error quadral..."""
    return np.sqrt((err1 ** 2.0) + 
                   (err2 ** 2.0))


def toColorArr(data, bottom=None, top=None):
    """ 
    Convert a data array to "color array" (between 0 and 1). 
    
    Parameters:
        bottom, top  : 
    """
    if top is not None:
        data[data >= top] = top
    if bottom is not None:
        data[data <= bottom] = bottom
        
    return ((data - np.nanmin(data)) / 
            (np.nanmax(data) - np.nanmin(data))) * 255.0


def getLuminosity(mag, redshift, extinction=None, 
                  amag_sun=None):
    """Get the absolute magnitude or luminosity."""
    distmod = hUtil.cosmoDistMod(redshift)
    absMag = (mag - distmod)
    if extinction is not None: 
        absMag -= extinction 
    if amag_sun is not None: 
        absMag = ((amag_sun - absMag) / 2.5)
    
    return absMag

def getStackProfiles(sample, loc, name='GAMA', 
                     idCol='ID_USE', tabCol='sum_tab', save=True):
    """Get the stacks of the profiles."""
    print("## Sample %s : Will deal with %d galaxies" % (name, len(sample)))
    profiles = []
    with ProgressBar(len(sample), ipython_widget=True) as bar:
        for g in sample:
            try:
                gFile = os.path.join(loc, g['sum_tab'].replace('./', '')).strip()
                gProf = Table.read(gFile, format='fits')
                """ Add extra information """
                try: 
                    gProf.meta['KCORRECT_I'] = g['KCORRECT_I']
                    gProf.meta['KCORRECT_b_I'] = g['KCORRECT_b_I']
                    gProf.meta['KCORRECT_c_I'] = g['KCORRECT_c_I']
                    gProf.meta['KCORRECT_G'] = g['KCORRECT_G']
                    gProf.meta['KCORRECT_b_G'] = g['KCORRECT_b_G']
                    gProf.meta['KCORRECT_c_G'] = g['KCORRECT_c_G']
                    gProf.meta['KCORRECT_R'] = g['KCORRECT_R']
                    gProf.meta['KCORRECT_b_R'] = g['KCORRECT_b_R']
                    gProf.meta['KCORRECT_c_R'] = g['KCORRECT_c_R']
                    gProf.meta['KCORRECT_Z'] = g['KCORRECT_Z']
                    gProf.meta['KCORRECT_b_Z'] = g['KCORRECT_b_Z']
                    gProf.meta['KCORRECT_c_Z'] = g['KCORRECT_c_Z']
                    gProf.meta['KCORRECT_Y'] = g['KCORRECT_Y']
                    gProf.meta['KCORRECT_b_Y'] = g['KCORRECT_b_Y']
                    gProf.meta['KCORRECT_c_Y'] = g['KCORRECT_c_Y']
                    gProf.meta['LOGM2LI_A'] = g['logm2lI_A']
                    gProf.meta['LOGM2LI_B'] = g['logm2lI_B']
                    gProf.meta['LOGM2LI_C'] = g['logm2lI_C']
                    gProf.meta['LUM_100'] = g['lum_100']
                    gProf.meta['LUM_120'] = g['lum_120']
                except Exception:
                    print("## WARNING: Some metadata may not be available !")
                    continue
            except Exception:
                print("## Missing: %s" % gFile)
                continue 
            profiles.append(gProf)
            bar.update()
    
    if save: 
        outPkl = os.path.join(loc, (name + '_profs.pkl'))
        hUtil.saveToPickle(profiles, outPkl)
        print("## Save %s to %s" % (name, outPkl))
        
    return profiles


def organizeSbp(profiles, col1='muI1', col2='KCORRECT_c_I', 
                kind='sbp', norm=False, r1=9.9, r2=10.1, divide=False,
                col3=None, col4=None, justStack=False,
                sun1=amag_sun_des_g, sun2=amag_sun_des_r):
    """ Get the stack of individual profiels, and their med/avg. """
    if kind.strip() == 'sbp':
        if col2 is not None: 
            if norm:
                stack = np.vstack(normProf(p['rKpc'], 
                                           np.asarray(p[col1] + (p.meta[col2] / 2.5)), 
                                           r1, r2, divide=divide) 
                                  for p in profiles)
            else:
                stack = np.vstack(np.asarray(p[col1] + (p.meta[col2] / 2.5)) 
                                  for p in profiles)
        else: 
            print("## NO KCORRECTION APPLIED !!")            
            if norm:
                stack = np.vstack(normProf(p['rKpc'], p[col1], 
                                           r1, r2, divide=divide) 
                                  for p in profiles)
            else:
                stack = np.vstack(np.asarray(p[col1]) for p in profiles)
    elif kind.strip() == 'mass':
        if norm:
            stack = np.vstack(normProf(p['rKpc'], 
                                       np.asarray(p[col1] + p.meta[col2]), 
                                       r1, r2, divide=divide) for p in profiles)
        else: 
            stack = np.vstack(np.asarray(p[col1] + p.meta[col2]) for p in profiles)
    elif kind.strip() == 'color':
        cSun = (sun1 - sun2)
        if col3 is None or col4 is None:
            print("## NO KCORRECTION APPLIED !!")
            if norm:
                stack = np.vstack(normProf(p['rKpc'], 
                                           np.asarray(cSun - 2.5 * (p[col1] - p[col2])), 
                                           r1, r2, divide=divide) for p in profiles)
            else: 
                stack = np.vstack(np.asarray(cSun - 2.5 *(p[col1] - p[col2])) for p in profiles)
        else:
            if norm:
                stack = np.vstack(normProf(p['rKpc'], 
                                           np.asarray(cSun - 2.5 * (p[col1] - p[col2]) -
                                                      (p.meta[col3] - p.meta[col4])), 
                                           r1, r2, divide=divide) for p in profiles)
            else: 
                stack = np.vstack(np.asarray(cSun - 2.5 * (p[col1] - p[col2]) -
                                             (p.meta[col3] - p.meta[col4])) 
                                  for p in profiles)
    elif kind.strip() == 'lum':
        if col2 is None:
            stack = np.vstack(np.asarray(p[col1]) for p in profiles)
        else:
            stack = np.vstack(np.asarray(p[col1] - p.meta[col2]) for p in profiles)
    else: 
        raise Exception("## WRONG KIND !!")
        
    if not justStack:
        """ Get the median and 1-sigma confidence range """
        medProf = confidence_interval(stack, axis=0, alpha=np.asarray([SIGMA1, 1.0]), 
                                      metric=np.nanmedian, numResamples=1000, 
                                      interpolate=True) 
        avgProf = confidence_interval(stack, axis=0, alpha=np.asarray([SIGMA1, 1.0]), 
                                      metric=np.nanmean, numResamples=1000, 
                                      interpolate=True) 
        stdProf = confidence_interval(stack, axis=0, alpha=np.asarray([SIGMA1, 1.0]), 
                                      metric=np.nanstd, numResamples=1000, 
                                      interpolate=True) 
        return stack, medProf, avgProf, stdProf
    else: 
        return stack
    

def loadPkl(filename):
    try:
        import cPickle as pickle
    except:
        warnings.warn("## cPickle is not available!!")
        import pickle
    
    if os.path.isfile(filename):
        pklFile = open(filename, 'rb')
        data = pickle.load(pklFile)    
        pklFile.close()
    
        return data
    else: 
        warnings.warn("## Can not find %s, return None" % filename)
        return None


    

In [4]:

    

newDir = '/Users/songhuang/work/hscs/gama_massive/sbp/'

bcgFile = 'redbcg_1d_160211.fits'
memFile = 'redmem_1d_160211.fits'
gamaFile = 'gama_1d_160211.fits'

try:
    bcgTab
except NameError:
    pass
else:
    del bcgTab
    
try:
    memTab
except NameError:
    pass
else:
    del memTab    
    
try:
    gamaTab
except NameError:
    pass
else:
    del gamaTab

# Two summary catalogs
bcgCat = os.path.join(newDir, bcgFile)
memCat = os.path.join(newDir, memFile)
gamaCat = os.path.join(newDir, gamaFile)

if not os.path.isfile(bcgCat):
    raise Exception("## Can not find catalog for BCGs : %s" % bcgCat)
else: 
    bcgTab = Table.read(bcgCat, format='fits')

if not os.path.isfile(memCat):
    raise Exception("## Can not find catalog for cluster members : %s" % memCat)
else: 
    memTab = Table.read(memCat, format='fits')
    
if not os.path.isfile(gamaCat):
    raise Exception("## Can not find catalog for GAMA galaxies : %s" % gamaCat)
else: 
    gamaTab = Table.read(gamaCat, format='fits')
    
print("## Deal with %i galaxies in redBCH sample" % len(bcgTab))
print("## Deal with %i galaxies in redMEM sample" % len(memTab))
print("## Deal with %i galaxies in GAMA sample" % len(gamaTab))


    

    




WARNING: UnitsWarning: 'dex' did not parse as fits unit: At col 0, Unit 'dex' not supported by the FITS standard.  [astropy.units.core]
WARNING:astropy:UnitsWarning: 'dex' did not parse as fits unit: At col 0, Unit 'dex' not supported by the FITS standard. 






    




## Deal with 219 galaxies in redBCH sample
## Deal with 1542 galaxies in redMEM sample
## Deal with 8898 galaxies in GAMA sample

In [5]:

    

# Redshift Bins
z0 = 0.2
zBinW1, zBinW2, zBinW3 = 0.2, 0.2, 0.3

# Luminosity Bins
lumBin1, lumBin2, lumBin3 = 11.0, 11.2, 11.4
lumBinW1, lumBinW2, lumBinW3 = 0.2, 0.2, 0.3

# Color 

BLUE0 = "#92c5de"
BLUE1 = "#0571b0"

RED0 = "#f4a582"
RED1 = "#ca0020"

PURPLE0 = '#af8dc3'
PURPLE1 = '#762a83'

BROWN0 = '#bf812d'
BROWN1 = '#543005'

GREEN0 = '#7fbf7b'
GREEN1 = '#1b7837'


    

In [6]:

    

fig = plt.figure(figsize=(12, 12))
#fig.subplots_adjust(left=0.1, right=0.95, bottom=0.15)
rec = [0.12, 0.11, 0.87, 0.87]
ax1 = plt.axes(rec)

# ---------------------------------------------------------------------------
# Scatter plot

# Luminosity bins
#regL1 = mpatches.Rectangle([z0, lumBin1], zBinW1, lumBinW1, ec="k", 
#                           facecolor="y", linewidth=2.0, 
#                           linestyle='solid', alpha=0.06, zorder=0)
#ax1.add_patch(regL1)
#regL2 = mpatches.Rectangle([z0, lumBin2], zBinW2, lumBinW2, ec="k", 
#                           facecolor="y", linewidth=2.0, 
#                           linestyle='solid', alpha=0.06, zorder=0)
#ax1.add_patch(regL2)
#regL3 = mpatches.Rectangle([z0, lumBin3], zBinW3, lumBinW3, ec="k", 
#                           facecolor="y", linewidth=2.0, 
#                           linestyle='solid', alpha=0.06, zorder=0)
#ax1.add_patch(regL3)

#ax1.axvline(0.2, linewidth=2, c='k', alpha=0.2)
#ax1.axvline(0.4, linewidth=2, c='k', alpha=0.2)

# Matched ones 

p1 = ax1.scatter(gamaTab['z_use'], 
                 gamaTab['lumI_kC_cmodel'], s=35.0, 
                 alpha=0.20, facecolor=BLUE0, edgecolor='none', 
                 label='$\Lambda \leq 20\ \mathrm{Central}$')
p2 = ax1.scatter(bcgTab['z_use'], 
                 bcgTab['lumI_kC_cmodel'], edgecolor=ORG4(0.8),
                 s=((bcgTab['z_use'] - 0.10) * 600.0), cmap=ORG4, alpha=0.90, 
                 c=toColorArr(bcgTab['LAMBDA_CLUSTER'], bottom=20.0, top=70.0), 
                 label='$\Lambda > 20\ \mathrm{Central}$', marker='s')

#ax1.scatter(memTab['Z'], memTab['lumI_kC_cmodel'], s=50.0, marker='h',
#            alpha=0.40, c='g', label='$\Lambda > 20\mathrm{/Sat}$')

# Axes setup
#  Minor Ticks on 
ax1.minorticks_on()

#  Axes Thickness
for axis in ['top','bottom','left','right']:
  ax1.spines[axis].set_linewidth(3.5)
#  Tick Label Size 
for tick in ax1.xaxis.get_major_ticks():
    tick.label.set_fontsize(24) 
for tick in ax1.yaxis.get_major_ticks():
    tick.label.set_fontsize(24) 
#  Tick Length and Width
ax1.tick_params('both', length=10, width=3.0, which='major')
ax1.tick_params('both', length=6, width=2.5, which='minor')

# Label
ax1.set_xlabel('$\mathrm{Redshift}$',  size=40)
ax1.set_ylabel('$\log\ (L_{\star}/L_{\odot})\ (\mathrm{cModel})$', size=40)
# Axis limits
ax1.set_xlim(0.11, 0.59)
ax1.set_ylim(10.31, 11.99)

ax1.legend(loc=(0.70, 0.05), shadow=True, fancybox=True, 
           numpoints=1, fontsize=22, scatterpoints=1, 
           markerscale=1.2, borderpad=0.3, handletextpad=0.2)
legend = ax1.get_legend()
legend.legendHandles[0].set_color(BLUE0)
legend.legendHandles[1].set_color(ORG4(0.8))

#ax1.text(0.10, 10.35, '$\mathrm{Size:}\ {\Lambda}_{\mathrm{Cluster}}$',
#         fontsize=24, color='r')

plt.show()
fig.savefig('../figure/hscMassive_z_lumI_cmodel.png', dpi=300)


    

In [7]:

    

fig = plt.figure(figsize=(12, 12))
#fig.subplots_adjust(left=0.1, right=0.95, bottom=0.15)
rec = [0.12, 0.11, 0.87, 0.87]
ax1 = plt.axes(rec)

# ---------------------------------------------------------------------------
# Scatter plot

# Luminosity bins
#regL1 = mpatches.Rectangle([z0, lumBin1], zBinW1, lumBinW1, ec="k", 
#                           facecolor="y", linewidth=2.0, 
#                           linestyle='solid', alpha=0.06, zorder=0)
#ax1.add_patch(regL1)
#regL2 = mpatches.Rectangle([z0, lumBin2], zBinW2, lumBinW2, ec="k", 
#                           facecolor="y", linewidth=2.0, 
#                           linestyle='solid', alpha=0.06, zorder=0)
#ax1.add_patch(regL2)
#regL3 = mpatches.Rectangle([z0, lumBin3], zBinW3, lumBinW3, ec="k", 
#                           facecolor="y", linewidth=2.0, 
#                           linestyle='solid', alpha=0.06, zorder=0)
#ax1.add_patch(regL3)

#ax1.axvline(0.2, linewidth=2, c='k', alpha=0.2)
#ax1.axvline(0.4, linewidth=2, c='k', alpha=0.2)

# Matched ones 

p1 = ax1.scatter(gamaTab['z_use'], 
                 (gamaTab['lum_120'] + (gamaTab['KCORRECT_c_I'] / 2.5)), s=35.0, 
                 alpha=0.20, facecolor=BLUE0, edgecolor='none', 
                 label='$\Lambda \leq 20\ \mathrm{Central}$')
p2 = ax1.scatter(bcgTab['z_use'], 
                 (bcgTab['lum_120'] + (bcgTab['KCORRECT_c_I'] / 2.5)), edgecolor=ORG4(0.8),
                 s=((bcgTab['z_use'] - 0.10) * 600.0), cmap=ORG4, alpha=0.90, 
                 c=toColorArr(bcgTab['LAMBDA_CLUSTER'], bottom=20.0, top=70.0), 
                 label='$\Lambda > 20\ \mathrm{Central}$', marker='s')

#ax1.scatter(memTab['Z'], memTab['lumI_kC_cmodel'], s=50.0, marker='h',
#            alpha=0.40, c='g', label='$\Lambda > 20\mathrm{/Sat}$')

# Axes setup
#  Minor Ticks on 
ax1.minorticks_on()

#  Axes Thickness
for axis in ['top','bottom','left','right']:
  ax1.spines[axis].set_linewidth(3.5)
#  Tick Label Size 
for tick in ax1.xaxis.get_major_ticks():
    tick.label.set_fontsize(24) 
for tick in ax1.yaxis.get_major_ticks():
    tick.label.set_fontsize(24) 
#  Tick Length and Width
ax1.tick_params('both', length=10, width=3.0, which='major')
ax1.tick_params('both', length=6, width=2.5, which='minor')

# Label
ax1.set_xlabel('$\mathrm{Redshift}$',  size=40)
ax1.set_ylabel('$\log\ (L_{\star}/L_{\odot})\ (\mathrm{120\ kpc})$', size=40)

                 # Axis limits
ax1.set_xlim(0.11, 0.59)
ax1.set_ylim(10.31, 11.99)

ax1.legend(loc=(0.70, 0.05), shadow=True, fancybox=True, 
           numpoints=1, fontsize=22, scatterpoints=1, 
           markerscale=1.2, borderpad=0.3, handletextpad=0.2)
legend = ax1.get_legend()
legend.legendHandles[0].set_color(BLUE0)
legend.legendHandles[1].set_color(ORG4(0.8))

#ax1.text(0.10, 10.35, '$\mathrm{Size:}\ {\Lambda}_{\mathrm{Cluster}}$',
#         fontsize=24, color='r')

plt.show()
fig.savefig('../figure/hscMassive_z_lumI_120.png', dpi=300)


    

In [8]:

    

fig = plt.figure(figsize=(12, 12))
#fig.subplots_adjust(left=0.1, right=0.95, bottom=0.15)
rec = [0.12, 0.11, 0.87, 0.87]
ax1 = plt.axes(rec)

# ---------------------------------------------------------------------------
# Scatter plot

# Luminosity bins
#regL1 = mpatches.Rectangle([z0, lumBin1], zBinW1, lumBinW1, ec="k", 
#                           facecolor="y", linewidth=2.0, 
#                           linestyle='solid', alpha=0.06, zorder=0)
#ax1.add_patch(regL1)
#regL2 = mpatches.Rectangle([z0, lumBin2], zBinW2, lumBinW2, ec="k", 
#                           facecolor="y", linewidth=2.0, 
#                           linestyle='solid', alpha=0.06, zorder=0)
#ax1.add_patch(regL2)
#regL3 = mpatches.Rectangle([z0, lumBin3], zBinW3, lumBinW3, ec="k", 
#                           facecolor="y", linewidth=2.0, 
#                           linestyle='solid', alpha=0.06, zorder=0)
#ax1.add_patch(regL3)

#ax1.axvline(0.2, linewidth=2, c='k', alpha=0.2)
#ax1.axvline(0.4, linewidth=2, c='k', alpha=0.2)

# Matched ones 

p1 = ax1.scatter(gamaTab['z_use'], 
                 (gamaTab['lum_max'] + (gamaTab['KCORRECT_c_I'] / 2.5)), s=35.0, 
                 alpha=0.20, facecolor=BLUE0, edgecolor='none', 
                 label='$\Lambda \leq 20\ \mathrm{Central}$')
p2 = ax1.scatter(bcgTab['z_use'], 
                 (bcgTab['lum_max'] + (bcgTab['KCORRECT_c_I'] / 2.5)), edgecolor=ORG4(0.8),
                 s=((bcgTab['z_use'] - 0.10) * 600.0), cmap=ORG4, alpha=0.90, 
                 c=toColorArr(bcgTab['LAMBDA_CLUSTER'], bottom=20.0, top=70.0), 
                 label='$\Lambda > 20\ \mathrm{Central}$', marker='s')

# Axes setup
#  Minor Ticks on 
ax1.minorticks_on()

#  Axes Thickness
for axis in ['top','bottom','left','right']:
  ax1.spines[axis].set_linewidth(3.5)
#  Tick Label Size 
for tick in ax1.xaxis.get_major_ticks():
    tick.label.set_fontsize(24) 
for tick in ax1.yaxis.get_major_ticks():
    tick.label.set_fontsize(24) 
#  Tick Length and Width
ax1.tick_params('both', length=10, width=3.0, which='major')
ax1.tick_params('both', length=6, width=2.5, which='minor')

# Label
ax1.set_xlabel('$\mathrm{Redshift}$',  size=40)
ax1.set_ylabel('$\log\ (L_{\star}/L_{\odot})\ (\mathrm{Max})$', size=40)

                 # Axis limits
ax1.set_xlim(0.11, 0.59)
ax1.set_ylim(10.31, 11.99)

ax1.legend(loc=(0.70, 0.05), shadow=True, fancybox=True, 
           numpoints=1, fontsize=22, scatterpoints=1, 
           markerscale=1.2, borderpad=0.3, handletextpad=0.2)
legend = ax1.get_legend()
legend.legendHandles[0].set_color(BLUE0)
legend.legendHandles[1].set_color(ORG4(0.8))

#ax1.text(0.10, 10.35, '$\mathrm{Size:}\ {\Lambda}_{\mathrm{Cluster}}$',
#         fontsize=24, color='r')

plt.show()
fig.savefig('../figure/hscMassive_z_lumI_max.png', dpi=300)


    

In [142]:

    

fig = plt.figure(figsize=(12, 9))
#fig.subplots_adjust(left=0.1, right=0.95, bottom=0.15)
rec = [0.12, 0.11, 0.87, 0.87]
ax1 = plt.axes(rec)

# ---------------------------------------------------------------------------
# Scatter plot

# Luminosity bins
regL1 = mpatches.Rectangle([z0, lumBin1], zBinW1, lumBinW1, ec="k", 
                           facecolor="y", linewidth=2.0, 
                           linestyle='solid', alpha=0.06, zorder=0)
ax1.add_patch(regL1)
regL2 = mpatches.Rectangle([z0, lumBin2], zBinW2, lumBinW2, ec="k", 
                           facecolor="y", linewidth=2.0, 
                           linestyle='solid', alpha=0.06, zorder=0)
ax1.add_patch(regL2)
regL3 = mpatches.Rectangle([z0, lumBin3], zBinW3, lumBinW3, ec="k", 
                           facecolor="y", linewidth=2.0, 
                           linestyle='solid', alpha=0.06, zorder=0)
ax1.add_patch(regL3)

#ax1.axvline(0.2, linewidth=2, c='k', alpha=0.2)
#ax1.axvline(0.4, linewidth=2, c='k', alpha=0.2)

# Matched ones 
ax1.scatter(gamaTab['Z'], (gamaTab['lum_100'] + (gamaTab['KCORRECT_c_I'] / 2.5)), 
            s=30.0, alpha=0.06, c='k', label='$\Lambda \leq 20\mathrm{/Cen}$')

ax1.scatter(memTab['Z'], (memTab['lum_100'] + (memTab['KCORRECT_c_I'] / 2.5)), 
            s=50.0, marker='h', alpha=0.40, c='g', label='$\Lambda > 20\mathrm{/Sat}$')

ax1.scatter(bcgTab['Z'], (bcgTab['lum_100'] + (bcgTab['KCORRECT_c_I'] / 2.5)), 
            alpha=0.75, c='r', label='$\Lambda > 20\mathrm{/Cen}$', marker='s',
            s=((bcgTab['LAMBDA_CLUSTER'] - 10) * 5.2))

# Axes setup
#  Minor Ticks on 
ax1.minorticks_on()
#  Axes Thickness
for axis in ['top','bottom','left','right']:
  ax1.spines[axis].set_linewidth(3.5)
#  Tick Label Size 
for tick in ax1.xaxis.get_major_ticks():
    tick.label.set_fontsize(24) 
for tick in ax1.yaxis.get_major_ticks():
    tick.label.set_fontsize(24) 
#  Tick Length and Width
ax1.tick_params('both', length=10, width=3.0, which='major')
ax1.tick_params('both', length=6, width=2.5, which='minor')

# Label
ax1.set_xlabel('$\mathrm{Redshift}$',  size=40)
ax1.set_ylabel('$\log\ (L_{\star}/L_{\odot})\ (\mathrm{SBP,\ 100\ kpc})$', size=40)

# Axis limits
ax1.set_xlim(0.08, 0.61)
ax1.set_ylim(10.21, 11.99)

ax1.legend(loc=(0.75, 0.05), shadow=True, fancybox=True, 
           numpoints=1, fontsize=22, scatterpoints=1, 
           markerscale=1.2, borderpad=0.3, handletextpad=0.2)

ax1.text(0.10, 10.35, '$\mathrm{Size:}\ {\Lambda}_{\mathrm{Cluster}}$',
         fontsize=24, color='r')

plt.show()
fig.savefig('../figure/hscMassive_z_lumI_100.png', dpi=230)


    

In [141]:

    

fig = plt.figure(figsize=(12, 9))
#fig.subplots_adjust(left=0.1, right=0.95, bottom=0.15)
rec = [0.12, 0.11, 0.87, 0.87]
ax1 = plt.axes(rec)

# ---------------------------------------------------------------------------
# Scatter plot

# Luminosity bins
regL1 = mpatches.Rectangle([z0, lumBin1], zBinW1, lumBinW1, ec="k", 
                           facecolor="y", linewidth=2.0, 
                           linestyle='solid', alpha=0.06, zorder=0)
ax1.add_patch(regL1)
regL2 = mpatches.Rectangle([z0, lumBin2], zBinW2, lumBinW2, ec="k", 
                           facecolor="y", linewidth=2.0, 
                           linestyle='solid', alpha=0.06, zorder=0)
ax1.add_patch(regL2)
regL3 = mpatches.Rectangle([z0, lumBin3], zBinW3, lumBinW3, ec="k", 
                           facecolor="y", linewidth=2.0, 
                           linestyle='solid', alpha=0.06, zorder=0)
ax1.add_patch(regL3)

#ax1.axvline(0.2, linewidth=2, c='k', alpha=0.2)
#ax1.axvline(0.4, linewidth=2, c='k', alpha=0.2)

# Matched ones 
ax1.scatter(gamaTab['Z'], (gamaTab['lum_75'] + (gamaTab['KCORRECT_c_I'] / 2.5)), 
            s=30.0, alpha=0.06, c='k', label='$\Lambda \leq 20\mathrm{/Cen}$')

ax1.scatter(memTab['Z'], (memTab['lum_75'] + (memTab['KCORRECT_c_I'] / 2.5)), 
            s=50.0, marker='h', alpha=0.40, c='g', label='$\Lambda > 20\mathrm{/Sat}$')

ax1.scatter(bcgTab['Z'], (bcgTab['lum_75'] + (bcgTab['KCORRECT_c_I'] / 2.5)), 
            alpha=0.75, c='r', label='$\Lambda > 20\mathrm{/Cen}$', marker='s',
            s=((bcgTab['LAMBDA_CLUSTER'] - 10) * 5.2))

# Axes setup
#  Minor Ticks on 
ax1.minorticks_on()
#  Axes Thickness
for axis in ['top','bottom','left','right']:
  ax1.spines[axis].set_linewidth(3.5)
#  Tick Label Size 
for tick in ax1.xaxis.get_major_ticks():
    tick.label.set_fontsize(24) 
for tick in ax1.yaxis.get_major_ticks():
    tick.label.set_fontsize(24) 
#  Tick Length and Width
ax1.tick_params('both', length=10, width=3.0, which='major')
ax1.tick_params('both', length=6, width=2.5, which='minor')

# Label
ax1.set_xlabel('$\mathrm{Redshift}$',  size=40)
ax1.set_ylabel('$\log\ (L_{\star}/L_{\odot})\ (\mathrm{SBP,\ 75\ kpc})$', size=40)

# Axis limits
ax1.set_xlim(0.08, 0.61)
ax1.set_ylim(10.21, 11.99)

ax1.legend(loc=(0.75, 0.05), shadow=True, fancybox=True, 
           numpoints=1, fontsize=22, scatterpoints=1, 
           markerscale=1.2, borderpad=0.3, handletextpad=0.2)

ax1.text(0.10, 10.35, '$\mathrm{Size:}\ {\Lambda}_{\mathrm{Cluster}}$',
         fontsize=24, color='r')

plt.show()
fig.savefig('../figure/hscMassive_z_lumI_75.png', dpi=230)


    

In [140]:

    

fig = plt.figure(figsize=(12, 9))
#fig.subplots_adjust(left=0.1, right=0.95, bottom=0.15)
rec = [0.12, 0.11, 0.87, 0.87]
ax1 = plt.axes(rec)

# ---------------------------------------------------------------------------
# Scatter plot

# Luminosity bins
regL1 = mpatches.Rectangle([z0, lumBin1], zBinW1, lumBinW1, ec="k", 
                           facecolor="y", linewidth=2.0, 
                           linestyle='solid', alpha=0.06, zorder=0)
ax1.add_patch(regL1)
regL2 = mpatches.Rectangle([z0, lumBin2], zBinW2, lumBinW2, ec="k", 
                           facecolor="y", linewidth=2.0, 
                           linestyle='solid', alpha=0.06, zorder=0)
ax1.add_patch(regL2)
regL3 = mpatches.Rectangle([z0, lumBin3], zBinW3, lumBinW3, ec="k", 
                           facecolor="y", linewidth=2.0, 
                           linestyle='solid', alpha=0.06, zorder=0)
ax1.add_patch(regL3)

#ax1.axvline(0.2, linewidth=2, c='k', alpha=0.2)
#ax1.axvline(0.4, linewidth=2, c='k', alpha=0.2)

# Matched ones 
ax1.scatter(gamaTab['Z'], (gamaTab['lum_50'] + (gamaTab['KCORRECT_c_I'] / 2.5)), 
            s=30.0, alpha=0.06, c='k', label='$\Lambda \leq 20\mathrm{/Cen}$')

ax1.scatter(memTab['Z'], (memTab['lum_50'] + (memTab['KCORRECT_c_I'] / 2.5)), 
            s=50.0, marker='h', alpha=0.40, c='g', label='$\Lambda > 20\mathrm{/Sat}$')

ax1.scatter(bcgTab['Z'], (bcgTab['lum_50'] + (bcgTab['KCORRECT_c_I'] / 2.5)), 
            alpha=0.75, c='r', label='$\Lambda > 20\mathrm{/Cen}$', marker='s',
            s=((bcgTab['LAMBDA_CLUSTER'] - 10) * 5.2))

# Axes setup
#  Minor Ticks on 
ax1.minorticks_on()
#  Axes Thickness
for axis in ['top','bottom','left','right']:
  ax1.spines[axis].set_linewidth(3.5)
#  Tick Label Size 
for tick in ax1.xaxis.get_major_ticks():
    tick.label.set_fontsize(24) 
for tick in ax1.yaxis.get_major_ticks():
    tick.label.set_fontsize(24) 
#  Tick Length and Width
ax1.tick_params('both', length=10, width=3.0, which='major')
ax1.tick_params('both', length=6, width=2.5, which='minor')

# Label
ax1.set_xlabel('$\mathrm{Redshift}$',  size=40)
ax1.set_ylabel('$\log\ (L_{\star}/L_{\odot})\ (\mathrm{SBP,\ 50\ kpc})$', size=40)

# Axis limits
ax1.set_xlim(0.08, 0.61)
ax1.set_ylim(10.21, 11.99)

ax1.legend(loc=(0.75, 0.05), shadow=True, fancybox=True, 
           numpoints=1, fontsize=22, scatterpoints=1, 
           markerscale=1.2, borderpad=0.3, handletextpad=0.2)

ax1.text(0.10, 10.35, '$\mathrm{Size:}\ {\Lambda}_{\mathrm{Cluster}}$',
         fontsize=24, color='r')

plt.show()
fig.savefig('../figure/hscMassive_z_lumI_50.png', dpi=230)


    

In [139]:

    

fig = plt.figure(figsize=(12, 9))
#fig.subplots_adjust(left=0.1, right=0.95, bottom=0.15)
rec = [0.12, 0.11, 0.87, 0.87]
ax1 = plt.axes(rec)

# ---------------------------------------------------------------------------
# Scatter plot

# Luminosity bins
regL1 = mpatches.Rectangle([z0, lumBin1], zBinW1, lumBinW1, ec="k", 
                           facecolor="y", linewidth=2.0, 
                           linestyle='solid', alpha=0.06, zorder=0)
ax1.add_patch(regL1)
regL2 = mpatches.Rectangle([z0, lumBin2], zBinW2, lumBinW2, ec="k", 
                           facecolor="y", linewidth=2.0, 
                           linestyle='solid', alpha=0.06, zorder=0)
ax1.add_patch(regL2)
regL3 = mpatches.Rectangle([z0, lumBin3], zBinW3, lumBinW3, ec="k", 
                           facecolor="y", linewidth=2.0, 
                           linestyle='solid', alpha=0.06, zorder=0)
ax1.add_patch(regL3)

#ax1.axvline(0.2, linewidth=2, c='k', alpha=0.2)
#ax1.axvline(0.4, linewidth=2, c='k', alpha=0.2)

# Matched ones 
ax1.scatter(gamaTab['Z'], (gamaTab['lum_10'] + (gamaTab['KCORRECT_c_I'] / 2.5)), 
            s=30.0, alpha=0.06, c='k', label='$\Lambda \leq 20\mathrm{/Cen}$')

ax1.scatter(memTab['Z'], (memTab['lum_10'] + (memTab['KCORRECT_c_I'] / 2.5)), 
            s=50.0, marker='h', alpha=0.40, c='g', label='$\Lambda > 20\mathrm{/Sat}$')

ax1.scatter(bcgTab['Z'], (bcgTab['lum_10'] + (bcgTab['KCORRECT_c_I'] / 2.5)), 
            alpha=0.75, c='r', label='$\Lambda > 20\mathrm{/Cen}$', marker='s',
            s=((bcgTab['LAMBDA_CLUSTER'] - 10) * 5.2))

# Axes setup
#  Minor Ticks on 
ax1.minorticks_on()
#  Axes Thickness
for axis in ['top','bottom','left','right']:
  ax1.spines[axis].set_linewidth(3.5)
#  Tick Label Size 
for tick in ax1.xaxis.get_major_ticks():
    tick.label.set_fontsize(24) 
for tick in ax1.yaxis.get_major_ticks():
    tick.label.set_fontsize(24) 
#  Tick Length and Width
ax1.tick_params('both', length=10, width=3.0, which='major')
ax1.tick_params('both', length=6, width=2.5, which='minor')

# Label
ax1.set_xlabel('$\mathrm{Redshift}$',  size=40)
ax1.set_ylabel('$\log\ (L_{\star}/L_{\odot})\ (\mathrm{SBP,\ 10\ kpc})$', size=40)

# Axis limits
ax1.set_xlim(0.08, 0.61)
ax1.set_ylim(10.21, 11.99)

ax1.legend(loc=(0.75, 0.05), shadow=True, fancybox=True, 
           numpoints=1, fontsize=22, scatterpoints=1, 
           markerscale=1.2, borderpad=0.3, handletextpad=0.2)

ax1.text(0.10, 10.35, '$\mathrm{Size:}\ {\Lambda}_{\mathrm{Cluster}}$',
         fontsize=24, color='r')

plt.show()
fig.savefig('../figure/hscMassive_z_lumI_10.png', dpi=230)


    

In [136]:

    

# Redshift Bins
z0 = 0.2
zBinW1, zBinW2, zBinW3 = 0.2, 0.2, 0.3

# Luminosity Bins
massBin1, massBin2, massBin3 = 11.4, 11.6, 11.8
massBinW1, massBinW2, massBinW3 = 0.2, 0.2, 0.3


    

In [138]:

    

fig = plt.figure(figsize=(12, 9))
#fig.subplots_adjust(left=0.1, right=0.95, bottom=0.15)
rec = [0.12, 0.11, 0.87, 0.87]
ax1 = plt.axes(rec)

# ---------------------------------------------------------------------------
# Scatter plot

# Luminosity bins
regL1 = mpatches.Rectangle([z0, massBin1], zBinW1, massBinW1, ec="k", 
                           facecolor="y", linewidth=2.0, 
                           linestyle='solid', alpha=0.06, zorder=0)
ax1.add_patch(regL1)
regL2 = mpatches.Rectangle([z0, massBin2], zBinW2, massBinW2, ec="k", 
                           facecolor="y", linewidth=2.0, 
                           linestyle='solid', alpha=0.06, zorder=0)
ax1.add_patch(regL2)
regL3 = mpatches.Rectangle([z0, massBin3], zBinW3, massBinW3, ec="k", 
                           facecolor="y", linewidth=2.0, 
                           linestyle='solid', alpha=0.06, zorder=0)
ax1.add_patch(regL3)

#ax1.axvline(0.2, linewidth=2, c='k', alpha=0.2)
#ax1.axvline(0.4, linewidth=2, c='k', alpha=0.2)

# Matched ones 
ax1.scatter(gamaTab['Z'], gamaTab['lumI_cmodel'] + gamaTab['logm2lI_C'], 
            s=30.0, alpha=0.06, c='k', label='$\Lambda \leq 20\mathrm{/Cen}$')

ax1.scatter(memTab['Z'], memTab['lumI_cmodel'] + memTab['logm2lI_C'], 
            s=50.0, marker='h', alpha=0.40, c='g', 
            label='$\Lambda > 20\mathrm{/Sat}$')

ax1.scatter(bcgTab['Z'], bcgTab['lumI_cmodel'] + bcgTab['logm2lI_C'], 
            alpha=0.75, c='r', label='$\Lambda > 20\mathrm{/Cen}$', 
            marker='s', s=((bcgTab['LAMBDA_CLUSTER'] - 10) * 5.2))

# Axes setup
#  Minor Ticks on 
ax1.minorticks_on()
#  Axes Thickness
for axis in ['top','bottom','left','right']:
  ax1.spines[axis].set_linewidth(3.5)
#  Tick Label Size 
for tick in ax1.xaxis.get_major_ticks():
    tick.label.set_fontsize(24) 
for tick in ax1.yaxis.get_major_ticks():
    tick.label.set_fontsize(24) 
#  Tick Length and Width
ax1.tick_params('both', length=10, width=3.0, which='major')
ax1.tick_params('both', length=6, width=2.5, which='minor')

# Label
ax1.set_xlabel('$\mathrm{Redshift}$',  size=40)
ax1.set_ylabel('$\log\ (M_{\star}/M_{\odot})\ (\mathrm{cModel})$', size=40)
# Axis limits
ax1.set_xlim(0.08, 0.61)
ax1.set_ylim(10.61, 12.59)

ax1.legend(loc=(0.02, 0.77), shadow=True, fancybox=True, 
           numpoints=1, fontsize=22, scatterpoints=1, 
           markerscale=1.2, borderpad=0.3, handletextpad=0.2)

ax1.text(0.50, 10.72, '$\mathrm{Size:}\ {\Lambda}_{\mathrm{Cluster}}$',
         fontsize=24, color='r')

plt.show()

fig.savefig('../figure/hscMassive_z_mass_cmodel.png', dpi=230)


    

In [146]:

    

fig = plt.figure(figsize=(12, 9))
#fig.subplots_adjust(left=0.1, right=0.95, bottom=0.15)
rec = [0.12, 0.11, 0.87, 0.87]
ax1 = plt.axes(rec)

# ---------------------------------------------------------------------------
# Scatter plot

# Luminosity bins
regL1 = mpatches.Rectangle([z0, massBin1], zBinW1, massBinW1, ec="k", 
                           facecolor="y", linewidth=2.0, 
                           linestyle='solid', alpha=0.06, zorder=0)
ax1.add_patch(regL1)
regL2 = mpatches.Rectangle([z0, massBin2], zBinW2, massBinW2, ec="k", 
                           facecolor="y", linewidth=2.0, 
                           linestyle='solid', alpha=0.06, zorder=0)
ax1.add_patch(regL2)
regL3 = mpatches.Rectangle([z0, massBin3], zBinW3, massBinW3, ec="k", 
                           facecolor="y", linewidth=2.0, 
                           linestyle='solid', alpha=0.06, zorder=0)
ax1.add_patch(regL3)

#ax1.axvline(0.2, linewidth=2, c='k', alpha=0.2)
#ax1.axvline(0.4, linewidth=2, c='k', alpha=0.2)

# Matched ones 
a = ax1.scatter(gamaTab['Z'], gamaTab['logms_gama'] + np.log10(gamaTab['fluxscale_gama']), 
                s=30.0, alpha=0.06, c='k', label='$\Lambda \leq 20\mathrm{/Cen}$')

b = ax1.scatter(memTab['Z'], memTab['logms_gama'] + np.log10(memTab['fluxscale_gama']), 
                s=50.0, marker='h', alpha=0.40, c='g', 
                label='$\Lambda > 20\mathrm{/Sat}$')

ax1.errorbar(bcgTab['Z'], bcgTab['logms_gama'] + np.log10(bcgTab['fluxscale_gama']), 
             yerr=bcgTab['logms_err_gama'], ecolor='r', capthick=2, fmt='.', 
             linewidth=2.0, color='none', label=None, alpha=0.6)
c= ax1.scatter(bcgTab['Z'], bcgTab['logms_gama'] + np.log10(bcgTab['fluxscale_gama']), 
               alpha=0.75, c='r', label='$\Lambda > 20\mathrm{/Cen}$', 
               marker='s', s=((bcgTab['LAMBDA_CLUSTER'] - 10) * 5.2))

# Axes setup
#  Minor Ticks on 
ax1.minorticks_on()
#  Axes Thickness
for axis in ['top','bottom','left','right']:
  ax1.spines[axis].set_linewidth(3.5)
#  Tick Label Size 
for tick in ax1.xaxis.get_major_ticks():
    tick.label.set_fontsize(24) 
for tick in ax1.yaxis.get_major_ticks():
    tick.label.set_fontsize(24) 
#  Tick Length and Width
ax1.tick_params('both', length=10, width=3.0, which='major')
ax1.tick_params('both', length=6, width=2.5, which='minor')

# Label
ax1.set_xlabel('$\mathrm{Redshift}$',  size=40)
ax1.set_ylabel('$\log\ (M_{\star}/M_{\odot})\ (\mathrm{GAMA})$', size=40)
# Axis limits
ax1.set_xlim(0.08, 0.61)
ax1.set_ylim(10.61, 12.59)

ax1.legend([a, b, c], ['$\Lambda \leq 20\mathrm{/Cen}$', 
                       '$\Lambda > 20\mathrm{/Sat}$',
                       '$\Lambda > 20\mathrm{/Cen}$'],
           loc=(0.02, 0.77), shadow=True, fancybox=True, 
           numpoints=1, fontsize=22, scatterpoints=1, 
           markerscale=1.2, borderpad=0.3, handletextpad=0.2)

ax1.text(0.50, 10.72, '$\mathrm{Size:}\ {\Lambda}_{\mathrm{Cluster}}$',
         fontsize=24, color='r')

plt.show()

fig.savefig('../figure/hscMassive_z_mass_gama.png', dpi=230)


    

In [118]:

    

bcgMErr = np.sqrt(((bcgTab['MSTAR'] - bcgTab['MSTAR_c']) / 4.0 ** 2.0) + (bcgTab['MSTAR_ERR'] ** 2.0))
bcgMErr = np.asarray(bcgMErr)
bcgMErr[bcgMErr <= 0.05] = 0.15


    

    




/usr/local/lib/python2.7/site-packages/ipykernel/__main__.py:1: RuntimeWarning: invalid value encountered in sqrt
  if __name__ == '__main__':

In [147]:

    

fig = plt.figure(figsize=(12, 9))
#fig.subplots_adjust(left=0.1, right=0.95, bottom=0.15)
rec = [0.12, 0.11, 0.87, 0.87]
ax1 = plt.axes(rec)

# ---------------------------------------------------------------------------
# Scatter plot

# Luminosity bins
regL1 = mpatches.Rectangle([z0, massBin1], zBinW1, massBinW1, ec="k", 
                           facecolor="y", linewidth=2.0, 
                           linestyle='solid', alpha=0.06, zorder=0)
ax1.add_patch(regL1)
regL2 = mpatches.Rectangle([z0, massBin2], zBinW2, massBinW2, ec="k", 
                           facecolor="y", linewidth=2.0, 
                           linestyle='solid', alpha=0.06, zorder=0)
ax1.add_patch(regL2)
regL3 = mpatches.Rectangle([z0, massBin3], zBinW3, massBinW3, ec="k", 
                           facecolor="y", linewidth=2.0, 
                           linestyle='solid', alpha=0.06, zorder=0)
ax1.add_patch(regL3)

#ax1.axvline(0.2, linewidth=2, c='k', alpha=0.2)
#ax1.axvline(0.4, linewidth=2, c='k', alpha=0.2)

# Matched ones 
a = ax1.scatter(gamaTab['Z'], gamaTab['mmax_c'], 
                s=30.0, alpha=0.06, c='k', label='$\Lambda \leq 20\mathrm{/Cen}$')

b = ax1.scatter(memTab['Z'], memTab['mmax_c'], 
                s=50.0, marker='h', alpha=0.40, c='g', 
                label='$\Lambda > 20\mathrm{/Sat}$')

ax1.errorbar(bcgTab['Z'], bcgTab['mmax_c'], 
             yerr=bcgMErr, ecolor='r', capthick=2, fmt='.', 
             linewidth=2.0, color='none', label=None, alpha=0.6)
c= ax1.scatter(bcgTab['Z'], bcgTab['mmax_c'], 
               alpha=0.75, c='r', label='$\Lambda > 20\mathrm{/Cen}$', 
               marker='s', s=((bcgTab['LAMBDA_CLUSTER'] - 10) * 5.2))

# Axes setup
#  Minor Ticks on 
ax1.minorticks_on()
#  Axes Thickness
for axis in ['top','bottom','left','right']:
  ax1.spines[axis].set_linewidth(3.5)
#  Tick Label Size 
for tick in ax1.xaxis.get_major_ticks():
    tick.label.set_fontsize(24) 
for tick in ax1.yaxis.get_major_ticks():
    tick.label.set_fontsize(24) 
#  Tick Length and Width
ax1.tick_params('both', length=10, width=3.0, which='major')
ax1.tick_params('both', length=6, width=2.5, which='minor')

# Label
ax1.set_xlabel('$\mathrm{Redshift}$',  size=40)
ax1.set_ylabel('$\log\ (M_{\star}/M_{\odot})\ (\mathrm{Max})$', size=40)
# Axis limits
ax1.set_xlim(0.08, 0.61)
ax1.set_ylim(10.61, 12.59)

ax1.legend([a, b, c], ['$\Lambda \leq 20\mathrm{/Cen}$', 
                       '$\Lambda > 20\mathrm{/Sat}$',
                       '$\Lambda > 20\mathrm{/Cen}$'],
           loc=(0.02, 0.77), shadow=True, fancybox=True, 
           numpoints=1, fontsize=22, scatterpoints=1, 
           markerscale=1.2, borderpad=0.3, handletextpad=0.2)

ax1.text(0.50, 10.72, '$\mathrm{Size:}\ {\Lambda}_{\mathrm{Cluster}}$',
         fontsize=24, color='r')

plt.show()

fig.savefig('../figure/hscMassive_z_mass_max.png', dpi=230)


    

In [112]:

    

fig = plt.figure(figsize=(12, 9))
#fig.subplots_adjust(left=0.1, right=0.95, bottom=0.15)
rec = [0.12, 0.11, 0.87, 0.87]
ax1 = plt.axes(rec)

# ---------------------------------------------------------------------------
# Scatter plot

# Luminosity bins
regL1 = mpatches.Rectangle([z0, massBin1], zBinW1, massBinW1, ec="k", 
                           facecolor="y", linewidth=2.0, 
                           linestyle='solid', alpha=0.06, zorder=0)
ax1.add_patch(regL1)
regL2 = mpatches.Rectangle([z0, massBin2], zBinW2, massBinW2, ec="k", 
                           facecolor="y", linewidth=2.0, 
                           linestyle='solid', alpha=0.06, zorder=0)
ax1.add_patch(regL2)
regL3 = mpatches.Rectangle([z0, massBin3], zBinW3, massBinW3, ec="k", 
                           facecolor="y", linewidth=2.0, 
                           linestyle='solid', alpha=0.06, zorder=0)
ax1.add_patch(regL3)

#ax1.axvline(0.2, linewidth=2, c='k', alpha=0.2)
#ax1.axvline(0.4, linewidth=2, c='k', alpha=0.2)

# Matched ones 
a = ax1.scatter(gamaTab['Z'], gamaTab['m120_c'], 
                s=30.0, alpha=0.06, c='k', label='$\Lambda \leq 20\mathrm{/Cen}$')

b = ax1.scatter(memTab['Z'], memTab['m120_c'], 
                s=50.0, marker='h', alpha=0.40, c='g', 
                label='$\Lambda > 20\mathrm{/Sat}$')

ax1.errorbar(bcgTab['Z'], bcgTab['m120_c'], 
             yerr=bcgMErr, ecolor='r', capthick=2, fmt='.', 
             linewidth=2.0, color='none', label=None, alpha=0.6)
c= ax1.scatter(bcgTab['Z'], bcgTab['m120_c'], 
               alpha=0.75, c='r', label='$\Lambda > 20\mathrm{/Cen}$', 
               marker='s', s=((bcgTab['LAMBDA_CLUSTER'] - 10) * 5.2))

# Axes setup
#  Minor Ticks on 
ax1.minorticks_on()
#  Axes Thickness
for axis in ['top','bottom','left','right']:
  ax1.spines[axis].set_linewidth(3.5)
#  Tick Label Size 
for tick in ax1.xaxis.get_major_ticks():
    tick.label.set_fontsize(24) 
for tick in ax1.yaxis.get_major_ticks():
    tick.label.set_fontsize(24) 
#  Tick Length and Width
ax1.tick_params('both', length=10, width=3.0, which='major')
ax1.tick_params('both', length=6, width=2.5, which='minor')

# Label
ax1.set_xlabel('$\mathrm{Redshift}$',  size=40)
ax1.set_ylabel('$\log\ (M_{\star}/M_{\odot})\ (\mathrm{120\ Kpc})$', size=40)
# Axis limits
ax1.set_xlim(0.08, 0.61)
ax1.set_ylim(10.61, 12.59)

ax1.legend([a, b, c], ['$\Lambda \leq 20\mathrm{/Cen}$', 
                       '$\Lambda > 20\mathrm{/Sat}$',
                       '$\Lambda > 20\mathrm{/Cen}$'],
           loc=(0.02, 0.77), shadow=True, fancybox=True, 
           numpoints=1, fontsize=22, scatterpoints=1, 
           markerscale=1.2, borderpad=0.3, handletextpad=0.2)

ax1.text(0.50, 10.72, '$\mathrm{Size:}\ {\Lambda}_{\mathrm{Cluster}}$',
         fontsize=24, color='r')

plt.show()

fig.savefig('../figure/hscMassive_z_lumI_120.png', dpi=230)