Fe = euclid.planck_prior_full
            F_eucl = euclid.euclid_to_rf(Fe, cosmo)
            Fpl, lbls = rf.add_fisher_matrices(F,
                                               F_eucl,
                                               lbls,
                                               l2,
                                               expand=True)

        # Get indices of w0, wa
        pw0 = lbls.index('w0')
        pwa = lbls.index('wa')
        pA = lbls.index('A')

        # Calculate FOM
        cov_pl = np.linalg.inv(Fpl)
        fom = rf.figure_of_merit(pw0, pwa, None, cov=cov_pl)
        fom_values_expt.append(fom)
        #fom_values_expt.append(1./np.sqrt(cov_pl[pA,pA])) # FIXME
        print "%s: FOM = %3.2f, sig(A) = %3.3f" % (names[k], fom,
                                                   np.sqrt(cov_pl[pA, pA]))
        print ">>> Paramname:", snames[j], " -- val:", param_values_expt[v]

    # Sort values
    idxs = param_values_expt.argsort()
    param_values_expt = param_values_expt[idxs]
    fom_values_expt = np.array(fom_values_expt)[idxs]

    # Plot line for this parameter
    line = ax.plot(param_values_expt / fac[j],
                   fom_values_expt / np.max(fom_values_expt),
                   label=names[k],
Esempio n. 2
0
                                              exclude=fixed_params)
    # Get indices of w0, wa
    pw0 = lbls.index('w0')
    pwa = lbls.index('wa')

    print "-" * 50
    print names[k]
    print "-" * 50

    # Invert matrix
    cov_pl = np.linalg.inv(Fpl)

    # Print 1D marginals
    print "1D sigma(w_0) = %3.4f" % np.sqrt(cov_pl[pw0, pw0])
    print "1D sigma(w_a) = %3.4f" % np.sqrt(cov_pl[pwa, pwa])
    print "FOM:", rf.figure_of_merit(pw0, pwa, Fpl, cov=cov_pl)
    print lbls

    x = rf.experiments.cosmo['w0']
    y = rf.experiments.cosmo['wa']
    print "FOM:", rf.figure_of_merit(pw0, pwa, Fpl, cov=cov_pl)

    # Plot contours for gamma, w0
    transp = [1., 0.85]
    w, h, ang, alpha = rf.ellipse_for_fisher_params(pw0,
                                                    pwa,
                                                    None,
                                                    Finv=cov_pl)
    ellipses = [
        matplotlib.patches.Ellipse(xy=(x, y),
                                   width=alpha[kk] * w,
        
        if len(fixed_params) > 0:
            Fpl, lbls = rf.combined_fisher_matrix( [Fpl,], expand=[], 
                         names=lbls, exclude=fixed_params )
        
        # Really hopeful H0 prior
        #ph = lbls.index('h')
        #Fpl[ph, ph] += 1./(0.012)**2.
        
        # Invert matrix
        cov_pl = np.linalg.inv(Fpl)
        
        # Plot improvement in chosen parameter
        if param1 == 'fom':
            p1 = lbls.index('w0'); p2 = lbls.index('wa')
            _fom = rf.figure_of_merit(p1, p2, None, cov=cov_pl)
        else:
            pp = lbls.index(param1)
            _fom = 1. / np.sqrt(cov_pl[pp, pp])
        zmax.append(zc[:l][-1])
        fom.append(_fom)
    
    # Plot curve for this experiment
    line = ax.plot(zmax, fom, color=colours[k], ls='solid', lw=1.8, 
                   marker='o', label=labels[k])
    line[0].set_dashes(linestyle[k])


# Report on what options were used
print "-"*50
s1 = "Marginalised over Omega_K" if MARGINALISE_CURVATURE else "Fixed Omega_K"
Esempio n. 4
0
                                        exclude=excl)
    # Add Planck prior
    Fpl = euclid.add_planck_prior(F, lbls, info=False)

    print "-" * 50
    print names[k]
    print "-" * 50

    # Invert matrices
    pns = rf.indexes_for_sampled_fns(3, zc.size, zfns)
    pmnu = rf.indexes_for_sampled_fns(6, zc.size, zfns)
    cov_pl = np.linalg.inv(Fpl)

    print lbls[pns], lbls[pmnu]

    fom = rf.figure_of_merit(pns, pmnu, None, cov=cov_pl)
    print "%s: FOM = %3.2f" % (names[k], fom)

    x = rf.experiments.cosmo['n']
    y = 0.1  #rf.experiments.cosmo['wa']

    # Plot contours for n_s, Mnu
    w, h, ang, alpha = rf.ellipse_for_fisher_params(pns,
                                                    pmnu,
                                                    None,
                                                    Finv=cov_pl)
    ellipses = [
        matplotlib.patches.Ellipse(xy=(x, y),
                                   width=alpha[kk] * w,
                                   height=alpha[kk] * h,
                                   angle=ang,