def correct4magnification(xvals, Fobs, Ferrobs, mu, muerr, Nsigma=5.0, Npoints=100, verbose=True): """ Returning a gaussian corrected for lensing magnification. Magnification is accounted for by determining the intrinsic true flux by Ftrue = Fobs/mu Ferrtrue = 1/mu * sqrt[ Fobs**2 * muerr**2 / mu**2 + Ferrobs**2 ] --- INPUT --- xvals xrange for non-corrected Guassian representation of measurement Fobs Mean of measurement Gaussian Ferrobs Standard deviation of measurement Gaussian mu Magnification to apply to measurement. Used to determine mean of Gaussian representation muerr Symmetric uncertainty on the magnification. Used to determine standard deviation of Gaussian representation Nsigma Number of sigmas with of gaussian to return verbose Toggle verbosity """ if verbose: print " - Correcting fluxes for magnification " p_obs = Fobs, Ferrobs, 0.0 gauss_obs = cgp.gauss_skew(xvals, *p_obs) Ftrue = float(Fobs) / float(mu) Ferrtrue = 1 / mu * np.sqrt(Fobs ** 2 * muerr ** 2 / mu ** 2 + Ferrobs ** 2) p_true = Ftrue, Ferrtrue, 0.0 xlow_true = Ftrue - Ferrtrue * Nsigma xhigh_true = Ftrue + Ferrtrue * Nsigma xvals_true = np.linspace(xlow_true, xhigh_true, Npoints) gauss_true = cgp.gauss_skew(xvals_true, *p_true) return xvals_true, gauss_true, gauss_obs
def correct4magnification_convolve(xvals, mean, sigma, alpha, mu, muerr, apply=False, verbose=True): """ returning a skewed gaussian corrected for lensing magnification. Magnification is modeled as x x x the convolution of the measurement Gaussian with a non-skewed Gaussian for the magnification to account for uncetainties in magnification --- INPUT --- mean Mean of measurement Gaussian sigma Standard deviation of measurement Gaussian alpha Skewness paramter of measurement Gaussian mu Magnification to apply to measurement. Used as mean of Gaussian representation muerr Approximate symmetric uncertainty on the magnification. Used as standard deviation of Gaussian representation apply If apply is True the magnification provided will be _applied_ to the measurement. I.e., instead of deconvolving the two signals, they will be convolved. In the case of Gaussians this means: mean_conv = mean1 + mean2; sigma_conv = sqrt(sigma1**2 + sigma2**2) (see http://www.tina-vision.net/docs/memos/2003-003.pdf) verbose """ p_measurement = mean, sigma, alpha gauss_measurement = cgp.gauss_skew(xvals, *p_measurement) p_magnification = mu, muerr, 0.0 xlow_mag = mu - muerr * 5.0 xhigh_mag = mu + muerr * 5.0 xvals_mag = np.linspace(xlow_mag, xhigh_mag, 100) gauss_magnification = cgp.gauss_skew(xvals_mag, *p_magnification) if apply: gauss_exvl_mag = np.convolve(gauss_measurement, gauss_magnification) else: gauss_exvl_mag = scipy.signal.deconvolve(gauss_measurement, gauss_magnification) pdb.set_trace() gauss_interp = si.interp1d(xvals, gauss, bounds_error=False, fill_value=0.0)(xvals_comb) return gaussskew_pdf_exvl_mag
def deconvolvetest(): """ """ import scipy.stats xvals1 = np.linspace(0, 5, 1000) xvals2 = np.linspace(0, 10, 100) p1 = 2.5, 0.2, 0.0 p2 = 4.0, 1.0, 0.0 flux_init = cgp.gauss_skew(xvals1, *p1) mag = cgp.gauss_skew(xvals2, *p2) flux_obs = np.convolve(flux_init, mag, 'same') flux_init_sp = scipy.stats.norm(2.5, 0.2).pdf(xvals1) mag_sp = scipy.stats.norm(4.0, 1.0).pdf(xvals2) flux_obs_sp = np.convolve(flux_init_sp, mag_sp, 'same') flux_init_rec, residual = scipy.signal.deconvolve(flux_obs, mag) plt.axis([0, 10, 0, 1.25 * np.max(flux_obs)]) plt.plot(xvals2, mag, label='magnification', lw=3, c='b') plt.plot(xvals1, flux_init, label='intrinsic flux', lw=3, c='r') plt.plot(xvals1, flux_obs, label='observed flux', lw=3, c='g') plt.plot(flux_init_rec, label='intrinsic flux recovered', lw=3, ls='--', c='k') plt.plot(xvals1, flux_init_sp, ls=':', label='intrinsic flux (SciPy)', lw=2) plt.plot(xvals2, mag_sp, ls=':', label='magnification (SciPy)', lw=2) plt.plot(xvals1, flux_obs_sp, ls=':', label='observed flux (SciPy)', lw=2) plt.legend() plt.show()
def correct4magnification(xvals, Fobs, Ferrobs, mu, muerr, Nsigma=5.0, Npoints=100, verbose=True): """ Returning a gaussian corrected for lensing magnification. Magnification is accounted for by determining the intrinsic true flux by Ftrue = Fobs/mu Ferrtrue = 1/mu * sqrt[ Fobs**2 * muerr**2 / mu**2 + Ferrobs**2 ] --- INPUT --- xvals xrange for non-corrected Guassian representation of measurement Fobs Mean of measurement Gaussian Ferrobs Standard deviation of measurement Gaussian mu Magnification to apply to measurement. Used to determine mean of Gaussian representation muerr Symmetric uncertainty on the magnification. Used to determine standard deviation of Gaussian representation Nsigma Number of sigmas with of gaussian to return verbose Toggle verbosity """ if verbose: print ' - Correcting fluxes for magnification ' p_obs = Fobs, Ferrobs, 0.0 gauss_obs = cgp.gauss_skew(xvals, *p_obs) Ftrue = float(Fobs) / float(mu) Ferrtrue = 1 / mu * np.sqrt(Fobs**2 * muerr**2 / mu**2 + Ferrobs**2) p_true = Ftrue, Ferrtrue, 0.0 xlow_true = Ftrue - Ferrtrue * Nsigma xhigh_true = Ftrue + Ferrtrue * Nsigma xvals_true = np.linspace(xlow_true, xhigh_true, Npoints) gauss_true = cgp.gauss_skew(xvals_true, *p_true) return xvals_true, gauss_true, gauss_obs
def deconvolvetest(): """ """ import scipy.stats xvals1 = np.linspace(0, 5, 1000) xvals2 = np.linspace(0, 10, 100) p1 = 2.5, 0.2, 0.0 p2 = 4.0, 1.0, 0.0 flux_init = cgp.gauss_skew(xvals1, *p1) mag = cgp.gauss_skew(xvals2, *p2) flux_obs = np.convolve(flux_init, mag, "same") flux_init_sp = scipy.stats.norm(2.5, 0.2).pdf(xvals1) mag_sp = scipy.stats.norm(4.0, 1.0).pdf(xvals2) flux_obs_sp = np.convolve(flux_init_sp, mag_sp, "same") flux_init_rec, residual = scipy.signal.deconvolve(flux_obs, mag) plt.axis([0, 10, 0, 1.25 * np.max(flux_obs)]) plt.plot(xvals2, mag, label="magnification", lw=3, c="b") plt.plot(xvals1, flux_init, label="intrinsic flux", lw=3, c="r") plt.plot(xvals1, flux_obs, label="observed flux", lw=3, c="g") plt.plot(flux_init_rec, label="intrinsic flux recovered", lw=3, ls="--", c="k") plt.plot(xvals1, flux_init_sp, ls=":", label="intrinsic flux (SciPy)", lw=2) plt.plot(xvals2, mag_sp, ls=":", label="magnification (SciPy)", lw=2) plt.plot(xvals1, flux_obs_sp, ls=":", label="observed flux (SciPy)", lw=2) plt.legend() plt.show()
def plotGauss1DRepresentation( values, errors, Nsigma=1, axislabel="line flux", Npoints=1000, outputname="gaussvaluerep.pdf", skewparam=0, sigrange=5.0, xpriorhat=False, legendlocation="upper left", usexlog=False, logxlow=1e-3, magnifications=False, magerrors=False, fixxrange=False, verbose=True, ): """ Plot measurements in 1D using Gaussians to represent the measureents and their uncertainties. Upper/lower lilmits should be given as fluxe measurements and uncertainty estimate as well. This gives a first of whether the independent measurements are in agreement with each other. The code will also return the best values from the combined profiles (product and sum) of these measurements and the corresponding standard deviation and sample 68% and 95% uncertainties. --- INPUT --- values The actual measurements. For upper/lower limits a flux measurement should also be provided. At the very least use the 1sigma uncertaintiy to indicate a 1sigma detection. errors The estiamted uncertainteis on the measurements Nsigma The number of sigma the errors represent axislabel Label to put on x-axis of plot Npoints Number of points to generate for each gaussian. Will be generate out to +/-sigrange sigma outputname Name of output figure to stor plot to sewparam To plot skewed Gaussians, provide list of skewness parameters sigrange Range of sigmas to consider around gaussian means, i.e., mean+/-sigrange. This is also the range considered to be 'within agreement' with each other, i.e., if any of the measurements differ by more than sigrange it will drive the combined product to 0. xpriorhat Use this keyword to put a top-hat prior on the gaussians by restricting the axxepted xvalues to a range [xmingood,xmaxgood]. This is useful for, for instance restrcting fluxes to be postive definit, by setting xpriorhat=[0,1e5] legendlocation Providing the location of the legend within the plot. If False no legend will be plotted usexlog To plot the x-axis in log set usexlog=True. logxlow If usexlog=True use this keyword to provide the lower bound of the log-axes magnifications Provide a list of lens magnifications if the measurements should be corrected for this. magerrors The estimated uncertainty on the lensing magnifications. fixxrange FOr instance for larger magnification errors the automatically set xrange for plottig (set to include all gaussian representations) might not be ideal. To overwrite this for plottin purposes provide the deisred x-range to this keyword. logxlow overwrite the lower bound. versose Toggle verbosity --- OUTPUT --- sumvals The best estimates and corresponding uncertainties estimated on the "PDF" from summing the individual Gaussian representations. The output is a list: sumvals = [valmed,valmean,valstd,m2sig,m1sig,center,p1sig,p2sig] contianing the following values: valmed Median of distribution sample valmean Mean of distribution sample valstd Standard deviation of distribution sample m2sig 95% confindence interval (1sigma) lower bound around the central value m1sig 68% confindence interval (1sigma) lower bound around the central value center Central value of distribution sample p1sig 68% confindence interval (1sigma) upper bound around the central value p2sig 95% confindence interval (2sigma) upper bound around the central value prodvals The same as 'sumvals' but for the product "PDF" of the individual Gaussian representations. --- EXAMPLE OF USE --- import combineGaussianPDFs as cgp values = [0.7,2,2.2,4] errors = [1.2,1.3,1.25,1.5] sumvals, prodvals = cgp.plotGauss1DRepresentation(values,errors,axislabel='test',xpriorhat=[0,8]) errors = [0.2,0.3,0.25,0.5] sumvals, prodvals = cgp.plotGauss1DRepresentation(values,errors,axislabel='test',sigrange=3) values = [2,2] errors = [1.2,1.2] mags = [1,10] magerrs = [0,3] sumvals, prodvals = cgp.plotGauss1DRepresentation(values,errors,magnifications=mags,magerrors=magerrs,sigrange=3,xpriorhat=[0,8],outputname='gaussvaluerep_161115.pdf',usexlog=False,logxlow=1e-2,legendlocation='upper right') """ values = np.asarray(values) # make sure values is a numpy array errors = np.asarray(errors) # make sure errors is a numpy array Nmeasurements = len(values) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - if verbose: print " - Building dictionary with Guassian representations " gaussreps = {} # intitale xrange limits xmin = np.min(values) xmax = np.max(values) for vv, val in enumerate(values): xlow = val - errors[vv] / Nsigma * sigrange xhigh = val + errors[vv] / Nsigma * sigrange xvals_obs = np.linspace(xlow, xhigh, Npoints) param = val, errors[vv], skewparam if not magnifications: gaussvals = cgp.gauss_skew(xvals_obs, *param) xvals = xvals_obs else: if len(np.atleast_1d(magnifications)) == 1: magnifications = np.atleast_1d(magnifications).tolist() * Nmeasurements if len(np.atleast_1d(magerrors)) == 1: magerrors = np.atleast_1d(magerrors).tolist() * Nmeasurements xvals_true, gaussvals, gaussobs = cgp.correct4magnification( xvals_obs, val, errors[vv], magnifications[vv], magerrors[vv], Nsigma=sigrange, Npoints=Npoints ) xvals = xvals_true if xpriorhat: gaussvals[xvals < xpriorhat[0]] = 0.0 gaussvals[xvals > xpriorhat[1]] = 0.0 gaussreps[str(vv)] = xvals, gaussvals xmin = np.min([xmin, np.min(xvals)]) xmax = np.max([xmax, np.max(xvals)]) xrange = [xmin, xmax] # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - if verbose: print " - Generating combined profile of all gaussians " Npointscomb = Npoints xvals_comb = np.linspace(xrange[0], xrange[1], Npointscomb) gaussarray = np.zeros([Nmeasurements, Npointscomb]) for vv, val in enumerate(values): xvals, gauss = gaussreps[str(vv)] gauss_interp = si.interp1d(xvals, gauss, bounds_error=False, fill_value=0.0)(xvals_comb) # gauss_interp = kbs.interp(xvals,gauss,xvals_comb) # not set up to deal with xnew outside xold gaussarray[vv, :] = gauss_interp gauss_comb_sum = np.sum(gaussarray, axis=0) gauss_comb_prod = np.prod(gaussarray, axis=0) maxprod = np.max(gauss_comb_prod) # gauss_comb_sum = gauss_comb_sum/np.sum(gauss_comb_sum) # gauss_comb_prod = gauss_comb_prod/np.sum(gauss_comb_prod) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - if verbose: print " - Get measurement and uncertainty from sum- and product-combined PDFs" if verbose: print ' sampling "sum" distribution' Nsample = 10000 probabilities = gauss_comb_sum / np.sum(gauss_comb_sum) sum_sampled = np.random.choice(xvals_comb, Nsample, p=probabilities) if verbose: print ' sampling "product" distribution' if verbose: print " getting best values and uncertainties for output " valarr = sum_sampled goodval = valarr[(valarr != -99) & (valarr != 0)] valmed = np.median(goodval) valmean = np.mean(goodval) valstd = np.std(goodval) Ngoodval = len(goodval) p2sig = np.sort(goodval)[int(np.floor(0.975 * Ngoodval))] # 95% conf upper bound p1sig = np.sort(goodval)[int(np.floor(0.84 * Ngoodval))] # 68% conf upper bound center = np.sort(goodval)[int(np.round(0.50 * Ngoodval))] m1sig = np.sort(goodval)[int(np.ceil(0.16 * Ngoodval))] # 68% conf lower bound m2sig = np.sort(goodval)[int(np.ceil(0.025 * Ngoodval))] # 95% conf lower bound sumvals = [valmed, valmean, valstd, m2sig, m1sig, center, p1sig, p2sig] if maxprod != 0.0: probabilities = gauss_comb_prod / np.sum(gauss_comb_prod) prod_sampled = np.random.choice(xvals_comb, Nsample, p=probabilities) valarr = prod_sampled goodval = valarr[(valarr != -99) & (valarr != 0)] valmed = np.median(goodval) valmean = np.mean(goodval) valstd = np.std(goodval) Ngoodval = len(goodval) p2sig = np.sort(goodval)[int(np.floor(0.975 * Ngoodval))] # 95% conf upper bound p1sig = np.sort(goodval)[int(np.floor(0.84 * Ngoodval))] # 68% conf upper bound center = np.sort(goodval)[int(np.round(0.50 * Ngoodval))] m1sig = np.sort(goodval)[int(np.ceil(0.16 * Ngoodval))] # 68% conf lower bound m2sig = np.sort(goodval)[int(np.ceil(0.025 * Ngoodval))] # 95% conf lower bound prodvals = [valmed, valmean, valstd, m2sig, m1sig, center, p1sig, p2sig] else: prodvals = [0.0, 0.0, -99.0, -99.0, -99.0, 0.0, -99.0, -99.0] # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - if verbose: print " - Setting up and generating plot " + outputname fig = plt.figure(figsize=(6, 3)) fig.subplots_adjust(wspace=0.1, hspace=0.1, left=0.1, right=0.98, bottom=0.13, top=0.96) Fsize = 9 lthick = 2 marksize = 4 capsize = 0 plt.rc("text", usetex=True) plt.rc("font", family="serif", size=Fsize) plt.rc("xtick", labelsize=Fsize) plt.rc("ytick", labelsize=Fsize) plt.clf() plt.ioff() # plt.title(plotname.split('/')[-1].replace('_','\_'),fontsize=Fsize) # ------------------------------------------------------- if verbose: print " plot sample histograms of sum and product distributions " Nbin = 200 histvals, binvals, patches = plt.hist( sum_sampled, bins=Nbin, range=xrange, normed=True, facecolor="green", alpha=0.4, histtype="stepfilled", label="Sample from sum", ) if maxprod != 0: histvals, binvals, patches = plt.hist( prod_sampled, bins=Nbin, range=xrange, normed=True, facecolor="red", alpha=0.4, histtype="stepfilled", label="Sample from product", ) prodscale = np.max(gauss_comb_sum) / maxprod scalestr = "\nscaled to max(sum)" else: prodscale = 1.0 scalestr = "\n(All 0s: No overlap for sigrange=" + str(sigrange) + ")" # ------------------------------------------------------- if verbose: print " plot sum and product distributions " plt.plot(xvals_comb, gauss_comb_sum, ls="-", color="green", lw=lthick * 2, label="Sum of Gaussians") plt.plot( xvals_comb, gauss_comb_prod * prodscale, ls="-", color="red", lw=lthick * 2, label="Product of Gaussians" + scalestr, ) # ------------------------------------------------------- if verbose: print ' "best value" points above sum and product distributions' # [valmed,valmean,valstd,m2sig,m1sig,center,p1sig,p2sig] plt.errorbar( sumvals[0], np.max(gauss_comb_sum) * 1.23, xerr=None, yerr=None, fmt="*", lw=lthick, markersize=marksize, capsize=capsize, markerfacecolor="green", ecolor="green", markeredgecolor="k", label="Median", ) plt.errorbar( sumvals[1], np.max(gauss_comb_sum) * 1.18, xerr=sumvals[2], yerr=None, fmt="D", lw=lthick, markersize=marksize, capsize=capsize, markerfacecolor="green", ecolor="green", markeredgecolor="k", label="Mean $\pm$ STD", ) xerrlow = np.asarray([sumvals[5] - sumvals[4]]) xerrhigh = np.asarray([sumvals[6] - sumvals[5]]) plt.errorbar( sumvals[5], np.max(gauss_comb_sum) * 1.08, xerr=[xerrlow, xerrhigh], yerr=None, fmt="o", lw=lthick, markersize=marksize, capsize=capsize, markerfacecolor="green", ecolor="green", markeredgecolor="k", label="Center $\pm$ 68\%,95\% CI", ) xerrlow = np.asarray([sumvals[5] - sumvals[3]]) xerrhigh = np.asarray([sumvals[7] - sumvals[5]]) plt.errorbar( sumvals[5], np.max(gauss_comb_sum) * 1.13, xerr=[xerrlow, xerrhigh], yerr=None, fmt="o", lw=lthick, markersize=marksize, capsize=capsize, markerfacecolor="green", ecolor="green", markeredgecolor="k", ) plt.errorbar( prodvals[1], np.max(gauss_comb_prod) * prodscale * 1.155, xerr=prodvals[2], yerr=None, fmt="D", lw=lthick, markersize=marksize, capsize=capsize, markerfacecolor="red", ecolor="red", markeredgecolor="k", ) plt.errorbar( prodvals[0], np.max(gauss_comb_prod) * prodscale * 1.205, xerr=None, yerr=None, fmt="*", lw=lthick, markersize=marksize, capsize=capsize, markerfacecolor="red", ecolor="red", markeredgecolor="k", ) xerrlow = np.asarray([prodvals[5] - prodvals[4]]) xerrhigh = np.asarray([prodvals[6] - prodvals[5]]) plt.errorbar( prodvals[5], np.max(gauss_comb_prod) * prodscale * 1.055, xerr=[xerrlow, xerrhigh], yerr=None, fmt="o", lw=lthick, markersize=marksize, capsize=capsize, markerfacecolor="red", ecolor="red", markeredgecolor="k", ) xerrlow = np.asarray([prodvals[5] - prodvals[3]]) xerrhigh = np.asarray([prodvals[7] - prodvals[5]]) plt.errorbar( prodvals[5], np.max(gauss_comb_prod) * prodscale * 1.105, xerr=[xerrlow, xerrhigh], yerr=None, fmt="o", lw=lthick, markersize=marksize, capsize=capsize, markerfacecolor="red", ecolor="red", markeredgecolor="k", ) # ------------------------------------------------------- if verbose: print " plot individual Gaussian representations " for vv, val in enumerate(values): xvals, gauss = gaussreps[str(vv)] if vv == 0: plt.plot( xvals, gauss, ls="-", color="k", lw=lthick * 1, label="Gauss rep.: $\mu$ $\pm$ " + str(sigrange) + "$\sigma$", ) else: plt.plot(xvals, gauss, ls="-", color="k", lw=lthick * 1) plt.xlabel(axislabel, fontsize=Fsize) ylab = "Guassian representation of measurements " if skewparam != 0: ylab = "Skewed " + ylab plt.ylabel(ylab, fontsize=Fsize) if fixxrange: xrange = fixxrange if usexlog: plt.xlim([logxlow, xrange[1]]) plt.xscale("log") else: plt.xlim(xrange) plt.ylim([0, np.max(gauss_comb_sum) * 1.3]) # ------------------------------------------------------- if verbose: print " plot legend " if legendlocation: # plt.errorbar(-20,-20,xerr=None,yerr=None,fmt='o',lw=lthick,ecolor='white', markersize=marksize, # markerfacecolor='white',markeredgecolor = 'k',label='PA = '+str(PAstrings[0])) # # leg = plt.legend(fancybox=True, loc=legendlocation, prop={"size": Fsize - 1}, ncol=1, numpoints=1) # , # bbox_to_anchor=(0.48, 1.)) # add the legend leg.get_frame().set_alpha(0.7) # ------------------------------------------------------- if verbose: print " Saving plot... " plt.savefig(outputname) plt.clf() plt.close("all") # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - if verbose: print ' - Returning the mean, median, and cetral values and uncertainties for sum and product "PDFs"' if verbose: print " ( [valmed,valmean,valstd,m2sig,m1sig,center,p1sig,p2sig] )" return sumvals, prodvals
def plotGauss1DRepresentation(values, errors, Nsigma=1, axislabel='line flux', Npoints=1000, outputname='gaussvaluerep.pdf', skewparam=0, sigrange=5.0, xpriorhat=False, legendlocation='upper left', usexlog=False, logxlow=1e-3, magnifications=False, magerrors=False, fixxrange=False, verbose=True): """ Plot measurements in 1D using Gaussians to represent the measureents and their uncertainties. Upper/lower lilmits should be given as fluxe measurements and uncertainty estimate as well. This gives a first of whether the independent measurements are in agreement with each other. The code will also return the best values from the combined profiles (product and sum) of these measurements and the corresponding standard deviation and sample 68% and 95% uncertainties. --- INPUT --- values The actual measurements. For upper/lower limits a flux measurement should also be provided. At the very least use the 1sigma uncertaintiy to indicate a 1sigma detection. errors The estiamted uncertainteis on the measurements Nsigma The number of sigma the errors represent axislabel Label to put on x-axis of plot Npoints Number of points to generate for each gaussian. Will be generate out to +/-sigrange sigma outputname Name of output figure to stor plot to sewparam To plot skewed Gaussians, provide list of skewness parameters sigrange Range of sigmas to consider around gaussian means, i.e., mean+/-sigrange. This is also the range considered to be 'within agreement' with each other, i.e., if any of the measurements differ by more than sigrange it will drive the combined product to 0. xpriorhat Use this keyword to put a top-hat prior on the gaussians by restricting the axxepted xvalues to a range [xmingood,xmaxgood]. This is useful for, for instance restrcting fluxes to be postive definit, by setting xpriorhat=[0,1e5] legendlocation Providing the location of the legend within the plot. If False no legend will be plotted usexlog To plot the x-axis in log set usexlog=True. logxlow If usexlog=True use this keyword to provide the lower bound of the log-axes magnifications Provide a list of lens magnifications if the measurements should be corrected for this. magerrors The estimated uncertainty on the lensing magnifications. fixxrange FOr instance for larger magnification errors the automatically set xrange for plottig (set to include all gaussian representations) might not be ideal. To overwrite this for plottin purposes provide the deisred x-range to this keyword. logxlow overwrite the lower bound. versose Toggle verbosity --- OUTPUT --- sumvals The best estimates and corresponding uncertainties estimated on the "PDF" from summing the individual Gaussian representations. The output is a list: sumvals = [valmed,valmean,valstd,m2sig,m1sig,center,p1sig,p2sig] contianing the following values: valmed Median of distribution sample valmean Mean of distribution sample valstd Standard deviation of distribution sample m2sig 95% confindence interval (1sigma) lower bound around the central value m1sig 68% confindence interval (1sigma) lower bound around the central value center Central value of distribution sample p1sig 68% confindence interval (1sigma) upper bound around the central value p2sig 95% confindence interval (2sigma) upper bound around the central value prodvals The same as 'sumvals' but for the product "PDF" of the individual Gaussian representations. --- EXAMPLE OF USE --- import combineGaussianPDFs as cgp values = [0.7,2,2.2,4] errors = [1.2,1.3,1.25,1.5] sumvals, prodvals = cgp.plotGauss1DRepresentation(values,errors,axislabel='test',xpriorhat=[0,8]) errors = [0.2,0.3,0.25,0.5] sumvals, prodvals = cgp.plotGauss1DRepresentation(values,errors,axislabel='test',sigrange=3) values = [2,2] errors = [1.2,1.2] mags = [1,10] magerrs = [0,3] sumvals, prodvals = cgp.plotGauss1DRepresentation(values,errors,magnifications=mags,magerrors=magerrs,sigrange=3,xpriorhat=[0,8],outputname='gaussvaluerep_161115.pdf',usexlog=False,logxlow=1e-2,legendlocation='upper right') """ values = np.asarray(values) # make sure values is a numpy array errors = np.asarray(errors) # make sure errors is a numpy array Nmeasurements = len(values) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - if verbose: print ' - Building dictionary with Guassian representations ' gaussreps = {} # intitale xrange limits xmin = np.min(values) xmax = np.max(values) for vv, val in enumerate(values): xlow = val - errors[vv] / Nsigma * sigrange xhigh = val + errors[vv] / Nsigma * sigrange xvals_obs = np.linspace(xlow, xhigh, Npoints) param = val, errors[vv], skewparam if not magnifications: gaussvals = cgp.gauss_skew(xvals_obs, *param) xvals = xvals_obs else: if len(np.atleast_1d(magnifications)) == 1: magnifications = np.atleast_1d( magnifications).tolist() * Nmeasurements if len(np.atleast_1d(magerrors)) == 1: magerrors = np.atleast_1d(magerrors).tolist() * Nmeasurements xvals_true, gaussvals, gaussobs = cgp.correct4magnification( xvals_obs, val, errors[vv], magnifications[vv], magerrors[vv], Nsigma=sigrange, Npoints=Npoints) xvals = xvals_true if xpriorhat: gaussvals[xvals < xpriorhat[0]] = 0.0 gaussvals[xvals > xpriorhat[1]] = 0.0 gaussreps[str(vv)] = xvals, gaussvals xmin = np.min([xmin, np.min(xvals)]) xmax = np.max([xmax, np.max(xvals)]) xrange = [xmin, xmax] # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - if verbose: print ' - Generating combined profile of all gaussians ' Npointscomb = Npoints xvals_comb = np.linspace(xrange[0], xrange[1], Npointscomb) gaussarray = np.zeros([Nmeasurements, Npointscomb]) for vv, val in enumerate(values): xvals, gauss = gaussreps[str(vv)] gauss_interp = si.interp1d(xvals, gauss, bounds_error=False, fill_value=0.0)(xvals_comb) #gauss_interp = kbs.interp(xvals,gauss,xvals_comb) # not set up to deal with xnew outside xold gaussarray[vv, :] = gauss_interp gauss_comb_sum = np.sum(gaussarray, axis=0) gauss_comb_prod = np.prod(gaussarray, axis=0) maxprod = np.max(gauss_comb_prod) # gauss_comb_sum = gauss_comb_sum/np.sum(gauss_comb_sum) # gauss_comb_prod = gauss_comb_prod/np.sum(gauss_comb_prod) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - if verbose: print ' - Get measurement and uncertainty from sum- and product-combined PDFs' if verbose: print ' sampling "sum" distribution' Nsample = 10000 probabilities = gauss_comb_sum / np.sum(gauss_comb_sum) sum_sampled = np.random.choice(xvals_comb, Nsample, p=probabilities) if verbose: print ' sampling "product" distribution' if verbose: print ' getting best values and uncertainties for output ' valarr = sum_sampled goodval = valarr[(valarr != -99) & (valarr != 0)] valmed = np.median(goodval) valmean = np.mean(goodval) valstd = np.std(goodval) Ngoodval = len(goodval) p2sig = np.sort(goodval)[int(np.floor(0.975 * Ngoodval))] # 95% conf upper bound p1sig = np.sort(goodval)[int(np.floor(0.84 * Ngoodval))] # 68% conf upper bound center = np.sort(goodval)[int(np.round(0.50 * Ngoodval))] m1sig = np.sort(goodval)[int(np.ceil(0.16 * Ngoodval))] # 68% conf lower bound m2sig = np.sort(goodval)[int(np.ceil(0.025 * Ngoodval))] # 95% conf lower bound sumvals = [valmed, valmean, valstd, m2sig, m1sig, center, p1sig, p2sig] if maxprod != 0.0: probabilities = gauss_comb_prod / np.sum(gauss_comb_prod) prod_sampled = np.random.choice(xvals_comb, Nsample, p=probabilities) valarr = prod_sampled goodval = valarr[(valarr != -99) & (valarr != 0)] valmed = np.median(goodval) valmean = np.mean(goodval) valstd = np.std(goodval) Ngoodval = len(goodval) p2sig = np.sort(goodval)[int(np.floor( 0.975 * Ngoodval))] # 95% conf upper bound p1sig = np.sort(goodval)[int(np.floor( 0.84 * Ngoodval))] # 68% conf upper bound center = np.sort(goodval)[int(np.round(0.50 * Ngoodval))] m1sig = np.sort(goodval)[int(np.ceil( 0.16 * Ngoodval))] # 68% conf lower bound m2sig = np.sort(goodval)[int(np.ceil( 0.025 * Ngoodval))] # 95% conf lower bound prodvals = [ valmed, valmean, valstd, m2sig, m1sig, center, p1sig, p2sig ] else: prodvals = [0.0, 0.0, -99.0, -99.0, -99.0, 0.0, -99.0, -99.0] # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - if verbose: print ' - Setting up and generating plot ' + outputname fig = plt.figure(figsize=(6, 3)) fig.subplots_adjust(wspace=0.1, hspace=0.1, left=0.1, right=0.98, bottom=0.13, top=0.96) Fsize = 9 lthick = 2 marksize = 4 capsize = 0 plt.rc('text', usetex=True) plt.rc('font', family='serif', size=Fsize) plt.rc('xtick', labelsize=Fsize) plt.rc('ytick', labelsize=Fsize) plt.clf() plt.ioff() #plt.title(plotname.split('/')[-1].replace('_','\_'),fontsize=Fsize) #------------------------------------------------------- if verbose: print ' plot sample histograms of sum and product distributions ' Nbin = 200 histvals, binvals, patches = plt.hist(sum_sampled, bins=Nbin, range=xrange, normed=True, facecolor='green', alpha=0.4, histtype='stepfilled', label='Sample from sum') if maxprod != 0: histvals, binvals, patches = plt.hist(prod_sampled, bins=Nbin, range=xrange, normed=True, facecolor='red', alpha=0.4, histtype='stepfilled', label='Sample from product') prodscale = np.max(gauss_comb_sum) / maxprod scalestr = '\nscaled to max(sum)' else: prodscale = 1.0 scalestr = '\n(All 0s: No overlap for sigrange=' + str(sigrange) + ')' #------------------------------------------------------- if verbose: print ' plot sum and product distributions ' plt.plot(xvals_comb, gauss_comb_sum, ls='-', color='green', lw=lthick * 2, label='Sum of Gaussians') plt.plot(xvals_comb, gauss_comb_prod * prodscale, ls='-', color='red', lw=lthick * 2, label='Product of Gaussians' + scalestr) #------------------------------------------------------- if verbose: print ' "best value" points above sum and product distributions' #[valmed,valmean,valstd,m2sig,m1sig,center,p1sig,p2sig] plt.errorbar(sumvals[0], np.max(gauss_comb_sum) * 1.23, xerr=None, yerr=None, fmt='*', lw=lthick, markersize=marksize, capsize=capsize, markerfacecolor='green', ecolor='green', markeredgecolor='k', label='Median') plt.errorbar(sumvals[1], np.max(gauss_comb_sum) * 1.18, xerr=sumvals[2], yerr=None, fmt='D', lw=lthick, markersize=marksize, capsize=capsize, markerfacecolor='green', ecolor='green', markeredgecolor='k', label='Mean $\pm$ STD') xerrlow = np.asarray([sumvals[5] - sumvals[4]]) xerrhigh = np.asarray([sumvals[6] - sumvals[5]]) plt.errorbar(sumvals[5], np.max(gauss_comb_sum) * 1.08, xerr=[xerrlow, xerrhigh], yerr=None, fmt='o', lw=lthick, markersize=marksize, capsize=capsize, markerfacecolor='green', ecolor='green', markeredgecolor='k', label='Center $\pm$ 68\%,95\% CI') xerrlow = np.asarray([sumvals[5] - sumvals[3]]) xerrhigh = np.asarray([sumvals[7] - sumvals[5]]) plt.errorbar(sumvals[5], np.max(gauss_comb_sum) * 1.13, xerr=[xerrlow, xerrhigh], yerr=None, fmt='o', lw=lthick, markersize=marksize, capsize=capsize, markerfacecolor='green', ecolor='green', markeredgecolor='k') plt.errorbar(prodvals[1], np.max(gauss_comb_prod) * prodscale * 1.155, xerr=prodvals[2], yerr=None, fmt='D', lw=lthick, markersize=marksize, capsize=capsize, markerfacecolor='red', ecolor='red', markeredgecolor='k') plt.errorbar(prodvals[0], np.max(gauss_comb_prod) * prodscale * 1.205, xerr=None, yerr=None, fmt='*', lw=lthick, markersize=marksize, capsize=capsize, markerfacecolor='red', ecolor='red', markeredgecolor='k') xerrlow = np.asarray([prodvals[5] - prodvals[4]]) xerrhigh = np.asarray([prodvals[6] - prodvals[5]]) plt.errorbar(prodvals[5], np.max(gauss_comb_prod) * prodscale * 1.055, xerr=[xerrlow, xerrhigh], yerr=None, fmt='o', lw=lthick, markersize=marksize, capsize=capsize, markerfacecolor='red', ecolor='red', markeredgecolor='k') xerrlow = np.asarray([prodvals[5] - prodvals[3]]) xerrhigh = np.asarray([prodvals[7] - prodvals[5]]) plt.errorbar(prodvals[5], np.max(gauss_comb_prod) * prodscale * 1.105, xerr=[xerrlow, xerrhigh], yerr=None, fmt='o', lw=lthick, markersize=marksize, capsize=capsize, markerfacecolor='red', ecolor='red', markeredgecolor='k') #------------------------------------------------------- if verbose: print ' plot individual Gaussian representations ' for vv, val in enumerate(values): xvals, gauss = gaussreps[str(vv)] if vv == 0: plt.plot(xvals, gauss, ls='-', color='k', lw=lthick * 1, label='Gauss rep.: $\mu$ $\pm$ ' + str(sigrange) + '$\sigma$') else: plt.plot(xvals, gauss, ls='-', color='k', lw=lthick * 1) plt.xlabel(axislabel, fontsize=Fsize) ylab = "Guassian representation of measurements " if skewparam != 0: ylab = 'Skewed ' + ylab plt.ylabel(ylab, fontsize=Fsize) if fixxrange: xrange = fixxrange if usexlog: plt.xlim([logxlow, xrange[1]]) plt.xscale('log') else: plt.xlim(xrange) plt.ylim([0, np.max(gauss_comb_sum) * 1.3]) #------------------------------------------------------- if verbose: print ' plot legend ' if legendlocation: # plt.errorbar(-20,-20,xerr=None,yerr=None,fmt='o',lw=lthick,ecolor='white', markersize=marksize, # markerfacecolor='white',markeredgecolor = 'k',label='PA = '+str(PAstrings[0])) # # leg = plt.legend(fancybox=True, loc=legendlocation, prop={'size': Fsize - 1}, ncol=1, numpoints=1) #, # bbox_to_anchor=(0.48, 1.)) # add the legend leg.get_frame().set_alpha(0.7) #------------------------------------------------------- if verbose: print ' Saving plot... ' plt.savefig(outputname) plt.clf() plt.close('all') # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - if verbose: print ' - Returning the mean, median, and cetral values and uncertainties for sum and product "PDFs"' if verbose: print ' ( [valmed,valmean,valstd,m2sig,m1sig,center,p1sig,p2sig] )' return sumvals, prodvals