Exemplo n.º 1
0
Arquivo: pz.py Projeto: esheldon/espy
    def make_chunk(self):
        """
        make the chunk
        """
        from lensing.sigmacrit import ScinvCalculator
        outfile=get_scinv_file(self.pz_vers, self.pz_type, self.cosmo_vers, chunk=self.chunk)
        print("will write to:",outfile)

        data=self.data
        out=self._get_output()

        zs=self.zsvals

        conf=self.cosmo_conf
        print("using H0:",conf['H0'],"omega_m:",conf['omega_m'])
        scalc=ScinvCalculator(self.zlmin, self.zlmax, self.nzl, zs[0], zs[-1],
                              H0=conf['H0'],
                              omega_m=conf['omega_m'])

        nobj=data.size
        printstep=nobj//10
        for i in xrange(nobj):
            if (i==0) or ((i+1) % printstep) == 0:
                print("    %d/%d" % (i+1,nobj))

            w,=where(isnan(data['pofz'][i,:]))
            if w.size > 0:
                print("    found nan in pofz: %d (absolute %d)" % (i,self.beg + i))
                out['flags'][i] = NAN_IN_POFZ
                continue

            out['scinv'][i,:]=scalc.calc_mean_scinv(zs, data['pofz'][i,:])

            w,=where(isnan(out['scinv'][i,:]))
            if w.size > 0:
                print("    found nan in scinv: %d (absolute %d)" % (i,self.beg + i))
                out['flags'][i] = NAN_IN_SCINV

        self._write_data(outfile, scalc.zlvals, out)
Exemplo n.º 2
0
def make_summed_scinv(scat_vers):
    """
    Create the 1/sigma_crit(zl) for the summed p(z)

    parameters
    ----------
    scat_vers: string
        name of a source catalog version e.g. scat-006
    """
    from lensing.sigmacrit import ScinvCalculator

    conf = read_config(scat_vers)
    cosmo_conf = read_config(conf["cosmo_vers"])

    cols = pz.open_pz_columns(conf["pz_vers"], conf["pz_type"])
    colname = get_pz_sum_colname(scat_vers)

    scinv_colname = get_scinv_sum_colname(scat_vers)
    zlgrid_colname = get_scinv_zl_colname(scat_vers)
    print("writing to columns:", zlgrid_colname, scinv_colname)

    data = cols.read_columns(["zgrid", colname])

    scalc = ScinvCalculator(
        conf["zlmin"],
        conf["zlmax"],
        conf["nzl"],
        data["zgrid"][0],
        data["zgrid"][-1],
        H0=cosmo_conf["H0"],
        omega_m=cosmo_conf["omega_m"],
    )

    scinv = scalc.calc_mean_scinv(data["zgrid"], data[colname])

    cols.write_column(zlgrid_colname, scalc.zlvals, create=True)
    cols.write_column(scinv_colname, scinv, create=True)