示例#1
0
    def plotCls(self,saveFile,keys=None,xlimits=None,ylimits=None,transform=True,showBinnedTheory=False,scaleX='linear',scaleY='linear'):

        nsigma = 2.
        
        binCenters = self.binner.getBinCenters()

        if transform:
            ylab = "$\ell C_{\ell}$"
            mult = binCenters
            multTh = 1.#binCenters*0.+1.
        else:
            ylab = "$C_{\ell}$"
            mult = binCenters*0.+1.
            multTh = 0.#binCenters*0.
            
        pl = Plotter(labelX="$\ell$",labelY=ylab,scaleX=scaleX,scaleY=scaleY)


        
        if keys is None: keys = self.datas.keys()
        for key in keys:

            dat = self.datas[key]

            if dat['covmat'] is None:
                #This is a theory curve
                ells = np.array(range(len(dat['unbinned'])))
                if dat['isFit']:
                    ls="--"
                    lw=1
                else:
                    ls="-"
                    lw=2
                    
                base_line, = pl.add(ells,(multTh*(ells-1)+1.)*dat['unbinned'],label=dat['label'],lw=lw,ls=ls)
                if dat['isFit']:
                    pl._ax.fill_between(ells,(multTh*(ells-1)+1.)*dat['unbinned']*(1.-nsigma*dat['amp'][1]/dat['amp'][0]),(multTh*(ells-1)+1.)*dat['unbinned']*(1.+nsigma*dat['amp'][1]/dat['amp'][0]),alpha=0.3, facecolor=base_line.get_color())
                    
                if showBinnedTheory:
                    pl.add(binCenters[:len(dat['binned'])],mult[:len(dat['binned'])]*dat['binned'],
                           ls='none',marker='x',mew=2,markersize=10,label=dat['label']+' binned')
                  
            else:
                errs = np.sqrt(np.diagonal(dat['covmat']))
                print dat['label']
                pl.addErr(binCenters[:len(dat['binned'])],mult[:len(dat['binned'])]*dat['binned'],mult[:len(dat['binned'])]*errs,label=dat['label'],marker='o',elinewidth=2,markersize=10,mew=2,)


        [i.set_linewidth(2.0) for i in pl._ax.spines.itervalues()]
        pl._ax.tick_params(which='major',width=2)
        pl._ax.tick_params(which='minor',width=2)
        pl._ax.axhline(y=0.,ls='--')
    
        if not(xlimits is None):
            pl._ax.set_xlim(*xlimits)
        else:
            pl._ax.set_xlim(self.binner.bin_edges[0],self.binner.bin_edges[-1])    
        if not(ylimits is None): pl._ax.set_ylim(*ylimits)
        pl.legendOn(loc='lower left',labsize=10)
        pl.done(saveFile)
示例#2
0
    def fit(self,keyData,keyTheory,amplitudeRange=np.arange(0.1,2.0,0.01),debug=False,numbins=-1):
        # evaluate likelihood on a 1d grid and fit to a gaussian
        # store fit as new theory curve

        width = amplitudeRange[1]-amplitudeRange[0]
        Likelihood = lambda x: np.exp(-0.5*self.chisq(keyData,keyTheory,amp=x,numbins=numbins))
        Likes = np.array([Likelihood(x) for x in amplitudeRange])
        Likes = Likes / (Likes.sum()*width) #normalize

        ampBest,ampErr = cfit(norm.pdf,amplitudeRange,Likes,p0=[1.0,0.5])[0]

        
        
        if debug:
            fitVals = np.array([norm.pdf(x,ampBest,ampErr) for x in amplitudeRange])
            pl = Plotter()
            pl.add(amplitudeRange,Likes,label="likes")
            pl.add(amplitudeRange,fitVals,label="fit")
            pl.legendOn()
            pl.done("output/debug_coreFit.png")

        fitKey = keyData+"_fitTo_"+keyTheory
        self.datas[fitKey] = {}
        self.datas[fitKey]['covmat'] = None
        self.datas[fitKey]['binned'] = self.datas[keyTheory]['binned']*ampBest
        self.datas[fitKey]['unbinned'] = self.datas[keyTheory]['unbinned']*ampBest
        self.datas[fitKey]['label'] = keyData+" fit to "+keyTheory+" with amp "+'{0:.2f}'.format(ampBest)+"+-"+'{0:.2f}'.format(ampErr)
        self.datas[fitKey]['amp']=(ampBest,ampErr)
        self.datas[fitKey]['isFit'] = True

        return fitKey
示例#3
0
def plotstat(hmin,hmax,hwide,stat,label,fit=False,scale=1.):    

    histthis = stat
    hist, bin_edges = np.histogram(histthis,bins=np.arange(hmin,hmax,hwide))

    if fit:
        mu, sigma = norm.fit(histthis)
        #print mu, sigma, mu*scale/sigma
        print "Detection significance , " , mu*scale/sigma , " sigma."
        print "Mass sensitivity , " , sigma*100./scale, "%."
        return sigma*100./scale

    pl = Plotter()
    pl._ax.bar(bin_edges[:-1], hist, width = np.diff(bin_edges))
    pl._ax.set_xlim(hmin,hmax)
    pl.done('hist'+label+'.png')
示例#4
0
def main(argv):
    try:
        iniFile = argv[0]
    except:
        iniFile = os.environ['HALOLENS_DIR']+'/input/haloLikelihood.ini'
    
    hCovMat = HaloLensCovMat(iniFile)
    covMat = hCovMat.getCovMat()
    corrMat = hCovMat.getCorrMat()

    print covMat,corrMat
    pl = Plotter()
    pl.plot2d(covMat)
    pl.done('halolenscovmat1.png')
    pl = Plotter()
    pl.plot2d(corrMat)
    pl.done('halolenscorrmat1.png')
示例#5
0
        pl.add

        print index+1 , " / " , numcores
        

    print myCls
    print myCls.shape

    pl = Plotter()

    # for b,Cls in zip(brange,myCls):
    #     pl.add(ells,ells*Cls,label=str(b))

    # pl.legendOn(labsize=8)

    pl.add(brange,myCls[:,500])
    pl.done("brange500.png")

    pl = Plotter()
    pl.add(brange,myCls[:,100])
    pl.done("brange100.png")

    pl = Plotter()
    pl.add(brange,myCls[:,1000])
    pl.done("brange1000.png")


    pl = Plotter()
    pl.add(brange,myCls[:,2000])
    pl.done("brange2000.png")
示例#6
0
fileList = glob.glob("output/"+derivRoot+"*.csv")
farr = np.loadtxt("output/"+derivRoot[:-5]+"fCls.csv",delimiter=',')

arrs = {}
for fileN in fileList:
    lab = fileN[len("output/"+derivRoot):-4]
    arrs[lab] = np.loadtxt(fileN,delimiter=',')


specList = ['TT','EE','BB','TE','KK','KT']
for spec in specList:
    if spec=='BB': continue
    pls = Plotter(scaleY='log',scaleX='log')

    

    ind = specList.index(spec)
    
    for lab in arrs:
        arr = arrs[lab]
        y = arr[:,ind]**2./farr[:,ind]**2.
        if lab=='tau': ls = '--'
        else: ls = "-"
        pls.add(range(arr.shape[0]),y,label=lab,ls=ls)


    pls.legendOn(loc='upper right',labsize=8)
    pls._ax.set_xlim(20.,4000.)
    pls.done("output/d"+spec+".png")
示例#7
0
def main(argv):
    
    iniFile = 'input/noise.ini'

    config = ConfigParser()
    config.read(iniFile)

    
    mass = 1.E14
    conc = 3.0
    z = 1.0

    #noiseT = 1.0
    #beam = 5.0
    #ellbeam = 7000.
    Nclus = 1000.
    arcupto = 10.

    mss = []
    #beams = np.arange(1.0,7.0,0.1)

    beams = [float(argv[0])]
    noiseT = float(argv[1])
    xy = argv[2]
    print beams
    #sys.exit()
    
    
    for beam in beams:

        ellbeam = 7000
        #ellbeam = int(np.sqrt(8.*np.log(2.)) / beam *60. * 180./np.pi)
        print "Ellbeam, ", ellbeam

        Nsupp = 10000.


        px = 0.1
        arc = 20.
        #xy = 'TT'
        bin_width = 10 #int(beam/px)
        Nreals = 5000
        Nbins = int(arcupto/bin_width)
        scale = px
        thetas = np.arange(bin_width*scale/2.,arcupto,scale*bin_width)

        lensedClFile = "../cmb-lensing-projections/data/TheorySpectra/ell28k_highacc_lensedCls.dat"
        unlensedClFile = "../cmb-lensing-projections/data/TheorySpectra/ell28k_highacc_scalCls.dat"

        cmbells,cltt,clee,clbb,clte = Lens.loadCls(lensedClFile)
        ucmbells,ucltt,uclee,uclte,dummy = Lens.loadCls(unlensedClFile)
        uclbb = clbb.copy()[:len(ucmbells)]
        uClsNow = [ucltt,uclee,uclbb,uclte]
        uClsFid = [ucltt,uclee,uclbb,uclte]
        lClsFid = [cltt,clee,clbb,clte]


        template = "../DerivGen/data/order5_lensedCMB_T_beam_cutout_3.fits"
        templateMap = liteMap.liteMapFromFits(template)


        Lens.makeBinfile("../cmb-lensing-projections/data/bintemp.dat",first=2,last=9000,width=20)

        lmin = 2.
        lmax = 8000.

        if xy=='mv':
            NormGen = Lens.AL(templateMap,'TT',ucmbells,uClsNow,ucmbells,uClsFid,cmbells,lClsFid,lmax,lmax,gradCut=2000.)
            NormGen.addWhiteNoise(noiseT,np.sqrt(2.)*noiseT,beam,(0,0,lmin,lmax),(lmin,lmax,lmin,lmax))
            L1,Nl1,ph = NormGen.binnedNLkk("../cmb-lensing-projections/data/bintemp.dat",inverted=False,halo=True)
            NormGen = Lens.AL(templateMap,'EB',ucmbells,uClsNow,ucmbells,uClsFid,cmbells,lClsFid,lmax,lmax,gradCut=2000.)
            NormGen.addWhiteNoise(noiseT,np.sqrt(2.)*noiseT,beam,(0,0,lmin,lmax),(lmin,lmax,lmin,lmax))
            L2,Nl2,ph = NormGen.binnedNLkk("../cmb-lensing-projections/data/bintemp.dat",inverted=False,halo=True)
            assert np.all(L1==L2)
            L = L1.copy()
            Nl = 1./(1./Nl1+1./Nl2)
            
            
        else:
            NormGen = Lens.AL(templateMap,xy,ucmbells,uClsNow,ucmbells,uClsFid,cmbells,lClsFid,lmax,lmax,gradCut=2000.)
            NormGen.addWhiteNoise(noiseT,np.sqrt(2.)*noiseT,beam,(0,0,lmin,lmax),(lmin,lmax,lmin,lmax))
            L,Nl,ph = NormGen.binnedNLkk("../cmb-lensing-projections/data/bintemp.dat",inverted=False,halo=True)
                

        pl = Plotter(scaleX='log',scaleY='log')
        pl.add(L,Nl)
        pl.done('stampNl.png')

        #sys.exit()


        rads = []
        print "Making stamps to determine profile covmat..."
        for i in range(Nreals):
            #print i
            lm = liteMap.makeEmptyCEATemplate(raSizeDeg=arc/60., decSizeDeg=arc/60.,pixScaleXarcmin = px, pixScaleYarcmin=px)

            if i==0:
                #print lm.data.shape
                Npix = lm.data.shape[0]
                lfilt = stepFunctionFilterFromLiteMap(lm,ellbeam)
                kapmaker = kappaMaker(Cosmology(defaultLCDM),mass,conc,z,storeKap=False)
                kapstamp,kaprad = kapmaker.getKappaAndProfile(Npix,scale=px,beam=None,bin_width=bin_width)
                # pl = Plotter()
                # pl.plot2d(kapstamp)
                # pl.done('kappa.png')
                # sys.exit()


            lm.fillWithGaussianRandomField(L,Nl/Nsupp,bufferFactor = 1)
            stamp = lm.data.copy()
            stamp = stamp+kapstamp.copy()
            stamp = np.nan_to_num(filterDataFromTemplate(stamp,lfilt))
            prof = radial_data(stamp,annulus_width=bin_width).mean
            #print prof
            rads.append(prof)
            if i%1000==0: print i

        radmeans, covMean, cov, errMean,err,corrcoef = getStats(rads,Nreals)

        thstamp = np.nan_to_num(filterDataFromTemplate(kapstamp,lfilt))
        thprof = radial_data(thstamp,annulus_width=bin_width).mean


        siginv = np.linalg.pinv(cov[:len(thetas),:len(thetas)])
        #print siginv
        #print radmeans[:len(thetas)]
        b = np.dot(siginv,radmeans[:len(thetas)])
        chisq = np.dot(radmeans[:len(thetas)],b)

        print np.sqrt(chisq*Nclus/Nsupp)


        #print radmeans
        #print err

        pl = Plotter()
        pl.addErr(thetas,radmeans[:len(thetas)],yerr=err[:len(thetas)])
        pl.add(thetas,kapmaker.kappa(thetas))
        pl._ax.set_ylim(-0.01,0.25)
        pl._ax.set_xlim(0.0,arcupto)
        pl.done('profile.png')


        pl = Plotter()
        pl.plot2d(corrcoef)
        pl.done('corrcoef.png')




        pl = Plotter()
        pl.plot2d(stamp)
        pl.done('stamp.png')


        amplitudeRange = np.arange(-1.,2.,0.01)
        width = amplitudeRange[1]-amplitudeRange[0]
        amplist = []
        print "Fitting amplitudes..."
        for i in range(Nreals):
            prof = rads[i][:len(thetas)]
            Likelihood = lambda x: np.exp(-0.5*fchisq(prof,siginv,thprof[:len(thetas)],amp=x))
            Likes = np.array([Likelihood(x) for x in amplitudeRange])
            Likes = Likes / (Likes.sum()*width) #normalize
            ampBest,ampErr = cfit(norm.pdf,amplitudeRange,Likes,p0=[1.0,0.5])[0]

            #print ampBest,ampErr
            amplist.append(ampBest)


        ms = plotstat( -1.,2.,0.01 , (np.array(amplist)) , "amps",fit=True,scale=np.sqrt(Nclus/Nsupp))

        mss.append(ms)

    pl = Plotter()
    pl.add(beams,mss)
    pl.done('beam.png')

    np.savetxt("output/m1beamsms"+xy+argv[0]+"_noise"+str(noiseT)+".txt",np.vstack((beams,mss)).transpose())
示例#8
0
    def fitAuto(self,keyData,keyTheory,amplitudeRange=np.arange(0.1,2.0,0.01),constRange=np.arange(0.1,2.0,0.01),debug=False,store=False):
        # evaluate likelihood on a 2d grid and fit to a gaussian
        # store fit as new theory curve

        width = amplitudeRange[1]-amplitudeRange[0]
        height = constRange[1]-constRange[0]
        Likelihood = lambda x,y: np.exp(-0.5*self.chisqAuto(keyData,keyTheory,amp=x,const=y))
        #Likelihood = lambda x,y: -0.5*self.chisqAuto(keyData,keyTheory,amp=x,const=y)

        Likes = np.array([[Likelihood(x,y) for x in amplitudeRange] for y in constRange])

        ampLike = np.sum(Likes,axis=0)    
        constLike = np.sum(Likes,axis=1)

        ampLike = ampLike / (ampLike.sum()*width) #normalize
        constLike = constLike / (constLike.sum()*height) #normalize
                

        ampBest,ampErr = cfit(norm.pdf,amplitudeRange,ampLike,p0=[amplitudeRange.mean(),0.1*amplitudeRange.mean()])[0]
        constBest,constErr = cfit(norm.pdf,constRange,constLike,p0=[constRange.mean(),0.1*constRange.mean()])[0]


        if debug:
            pl = Plotter()
            pl.plot2d(Likes)
            pl.done("output/like2d.png")
                        
            pl = Plotter()
            fitVals = np.array([norm.pdf(x,ampBest,ampErr) for x in amplitudeRange])
            pl.add(amplitudeRange,ampLike,label="amplikes")
            pl.add(amplitudeRange,fitVals,label="fit")
            pl.legendOn()
            pl.done("output/amplike1d.png")

            pl = Plotter()
            fitVals = np.array([norm.pdf(x,constBest,constErr) for x in constRange])
            pl.add(constRange,constLike,label="constlikes")
            pl.add(constRange,fitVals,label="fit")
            pl.legendOn()
            pl.done("output/constlike1d.png")

            #sys.exit()
            
        if not(store):
            return constBest,constErr
        else:
            
            self.datas[keyData]['binned'] -= constBest
            self.datas[keyData]['unbinned'] -= constBest
            
            fitKey = keyData+"_fitTo_"+keyTheory
            self.datas[fitKey] = {}
            self.datas[fitKey]['covmat'] = None
            self.datas[fitKey]['binned'] = self.datas[keyTheory]['binned']*ampBest
            self.datas[fitKey]['unbinned'] = self.datas[keyTheory]['unbinned']*ampBest
            self.datas[fitKey]['label'] = keyData+" fit to "+keyTheory+" with amp "+'{0:.2f}'.format(ampBest)+"+-"+'{0:.2f}'.format(ampErr)
            self.datas[fitKey]['amp']=(ampBest,ampErr)
            self.datas[fitKey]['const']=(constBest,constErr)
            self.datas[fitKey]['isFit'] = True
    
            return fitKey
示例#9
0
zsource = 1.0

myInt.addDeltaNz('delta', zsource)
for i, zwidth in enumerate(np.arange(0.01, 0.1, 0.01)):
    myInt.addStepNz('step' + str(i), zsource - zwidth / 2.,
                    zsource + zwidth / 2.)

print("getting cls..")
pl = Plotter(scaleY='log', scaleX='log')

ellrange = list(range(2, ellmax, 1))
myInt.generateCls(ellrange)
for i, tag in enumerate(sorted(myInt.kernels.keys())):
    if tag == "cmb": continue
    retcl = myInt.getCl("cmb", tag)
    if tag == "delta":
        compcl = retcl.copy()
        lw = 2
        ls = "--"
    else:
        lw = 1
        ls = "-"

    pl.add(ellrange, retcl, label=tag, ls=ls, lw=lw)
    rat = (retcl / compcl)
    ratio = (np.abs(rat[np.logical_and(ellrange > 100., ellrange < 2000.)] -
                    1.)).max() * 100.
    print((tag, ratio, " %"))
pl.legendOn(loc='upper right', labsize=10)
pl.done("output/estcls.png")
示例#10
0
        
        print xy,beam
        if files==[]:
            print "skipping"
            continue
        print files[0]
        
        noises = []
        mss = []
        for filen in files:

            beam,ms = np.loadtxt(filen,unpack=True)
            noise = float(filen[-7:-4])
            noises.append(noise)
            mss.append(ms)



    
        print "last noise ", noises[-1]
        #print mss[-1]
        #pl.add(noises,mss,lw=3,label=xy+" "+str(beam) + " arcmin",ls='--',color=col)
        pl.add(noises,np.array(mss)*0.01,lw=3,label=str(beam) + " arcmin",ls='-',color=col1)


pl._ax.set_xlim(1.,5.)
#pl._ax.set_ylim(0.,10.)
pl._ax.set_ylim(0.,4.*0.01)
pl.legendOn()
pl.done("beam.png")
示例#11
0
cells = LF.theory.gCl("ss", ells)
pl.add(ellrange, retclsss, label="MMss", color='green', ls='-')
pl.add(ells, cells, label="CAMBss", color='green', ls='--')

cells = LF.theory.gCl("kg", ells)
pl.add(ellrange, retclkgs, label="MMkg", color='purple', ls='-')
pl.add(ellrange, retclgks, label="MMgk", color='purple', ls='-.', lw=2)
pl.add(ells, cells, label="CAMBkg", color='purple', ls='--')

cells = LF.theory.gCl("gg", ells)
pl.add(ellrange, retclggs, label="MMgg", color='orange', ls='-')
pl.add(ells, cells, label="CAMBgg", color='orange', ls='--')

pl.legendOn(loc='upper right', labsize=10)
pl.done("output/estcls.png")

intmmks = interp1d(ellrange, retclkss, bounds_error=False, fill_value=0.)(ells)
intmmkk = interp1d(ellrange, retclkks, bounds_error=False, fill_value=0.)(ells)
intmmss = interp1d(ellrange, retclsss, bounds_error=False, fill_value=0.)(ells)
intmmkg = interp1d(ellrange, retclkgs, bounds_error=False, fill_value=0.)(ells)
intmmgg = interp1d(ellrange, retclggs, bounds_error=False, fill_value=0.)(ells)
pl = Plotter()
pl.add(ells, intmmks / LF.theory.gCl("ks", ells))
pl.add(ells, intmmkk / LF.theory.gCl("kk", ells))
pl.add(ells, intmmss / LF.theory.gCl("ss", ells))
pl.add(ells, intmmkg / LF.theory.gCl("kg", ells))
pl.add(ells, intmmgg / LF.theory.gCl("gg", ells))
pl.legendOn(loc='upper right', labsize=10)
pl._ax.set_ylim(0., 1.5)
pl.done("output/int.png")
示例#12
0
def main(argv):
    
    ras,decs = getCatalogRADecsPlanck()

    pixScale = 0.5
    widthArc = 70.
    width = widthArc/60.
    Np = np.int(width/pixScale*60.+0.5)

    saveRoot = "/astro/astronfs01/workarea/msyriac/SkyData/"
    planckRoot = saveRoot+'cmb/'
    planckMaskPath = planckRoot+'planck2015_mask.fits'

    mask15 = hp.read_map(planckMaskPath,verbose=False)

    saveRoot = "/astro/astronfs01/workarea/msyriac/SkyData/"
    planckRoot = saveRoot+'cmb/'    
    pl15lm = hp.read_alm(planckRoot+'dat_klm.fits')
    hpPlanckK = hp.sphtfunc.alm2map(pl15lm,2048,pol=False)
    

    outN = argv[0]
    tfact = 1.

    if outN=='143':
        p143Loc = '/astro/astronfs01/workarea/msyriac/PlanckClusters/HFI_SkyMap_143_2048_R2.02_full.fits'
        
    elif outN=='com':
        p143Loc = '/astro/astronfs01/workarea/msyriac/PlanckClusters/COM_CMB_IQU-commander-field-Int_2048_R2.00.fits'
    elif outN=='217':    
        p143Loc = '/astro/astronfs01/workarea/msyriac/PlanckClusters/HFI_SkyMap_217_2048_R2.02_full.fits'
    elif outN=='wpr2':
        p143Loc = '/astro/astronfs01/workarea/msyriac/PlanckClusters/WPR2_CMB_muK.fits'
        tfact = 1.e-6
    else:
        print 'invalid input'
        sys.exit()

    Npix = 12.*2048**2.
    print mask15.sum()/Npix
    hpPlanck = hp.read_map(p143Loc)
    hpPlanckCopy = hpPlanck.copy()
    hpPlanckCopy[mask15<0.5]=np.nan
    print np.nanmean(hpPlanckCopy)
    lim = np.nanstd(hpPlanckCopy*tfact)
    print lim
    #sys.exit()

    stack = 0.
    stackK = 0.

    maxN = None
    #maxN = 10
    i=0
    for ra,dec in zip(ras[:maxN],decs[:maxN]):
        i+=1
        print i,ra,dec

        # ra = np.random.uniform(5.,350.)
        # dec = np.random.uniform(-80.,10.)

        raLeft = ra - width/2.
        raRight = ra + width/2.
        decLeft = dec - width/2.
        decRight = dec + width/2.

        fieldCoords = (raLeft,decLeft,raRight,decRight)
        smap = lm.makeEmptyCEATemplateAdvanced(*fieldCoords)
        smapK = lm.makeEmptyCEATemplateAdvanced(*fieldCoords)
        smap.loadDataFromHealpixMap(hpPlanck,hpCoords="GALACTIC")
        smapK.loadDataFromHealpixMap(hpPlanckK,hpCoords="GALACTIC")


        stamp = smap.data.copy() * tfact
        stamp = zoom(stamp,zoom=(float(Np)/stamp.shape[0],float(Np)/stamp.shape[1]))

        stampK = smapK.data.copy() 
        stampK = zoom(stampK,zoom=(float(Np)/stampK.shape[0],float(Np)/stampK.shape[1]))
        
        stack += stamp[:,:]
        stackK += stampK[:,:]



    pl = Plotter()
    pl.plot2d(stack/i)#,lim=lim*3.)
    pl.done("stack"+outN+"6.png")

    pl = Plotter()
    pl.plot2d(stackK/i)#,lim=lim*3.)
    pl.done("stackK6.png")
示例#13
0
def getTaperedMap(lkk,clkk,templateMapLoc = "../DerivGen/data/order5_lensedCMB_T_beam_cutout_3.fits",bufferFactor=2,taperWidth = 120,jackknife=36):
    # jackknife = (number of jackknife regions)
    
    assert is_square(jackknife)
    

    templateMap = liteMap.liteMapFromFits(templateMapLoc)
    templateMap.data[:,:] = 0.
    templateMap.fillWithGaussianRandomField(lkk,clkk,bufferFactor = bufferFactor)
    retMap = templateMap.copy()

    xa,xb = (templateMap.x0,templateMap.x1)
    ya,yb = (templateMap.y0,templateMap.y1)
    x0 = min(xa,xb)
    x1 = max(xa,xb)
    y0 = min(ya,yb)
    y1 = max(ya,yb)

    xl = x1-x0
    yl = y1-y0

    Neach = int(np.sqrt(jackknife))
    xeach = xl/Neach
    yeach = yl/Neach

    bufferx = 0.001
    buffery = 0.001

    smaps = []
    stapers = []
    for i in range(Neach):
        
        tx0 = x0+i*xeach
        tx1 = x0+(i+1)*xeach

        if i==0: tx0 += bufferx
        if i==Neach-1: tx1 -= bufferx
            
        for j in range(Neach):
            ty0 = y0+j*yeach
            ty1 = y0+(j+1)*yeach

            if j==0: ty0 += buffery
            if j==Neach-1: ty1 -= buffery
            
            
            print((tx0,tx1,ty0,ty1))
            smap = templateMap.selectSubMap(tx0,tx1,ty0,ty1, safe = False)
            #print smap.info()
            
            subtaper = lpol.initializeCosineWindow(smap,int(taperWidth/Neach),0)
            smap.data[:] = smap.data[:]*subtaper.data[:]
            pl = Plotter()
            pl.plot2d(smap.data)
            pl.done("kappa"+str(i)+str(j)+".png")

            smaps.append(smap)
            stapers.append(subtaper)
            
    #sys.exit()



    taper = lpol.initializeCosineWindow(retMap,taperWidth,0)
    retMap.data[:] = retMap.data[:]*taper.data[:]


    pl = Plotter()
    pl.plot2d(templateMap.data)
    pl.done("kappa.png")

    return retMap,taper,smaps,stapers
示例#14
0
dummy = makeBinfile(tempBinfile,2.,4000.,100.,redundant=True)

clkkFile = "../actpLens/data/fidkk.dat"
clkk = np.loadtxt(clkkFile)
lkk = np.arange(2,len(clkk)+2)

N = 20

estcls = []
for i in range(N):

    kappaMap,taperMap = getTaperedMap(lkk,clkk)
    print((kappaMap.data.shape))
    print((kappaMap.info()))
    sys.exit()
    lower, upper, center, bin_means = getBinnedPower(kappaMap,tempBinfile,taperMap)
    estcls.append(bin_means)
    print(i)

clmeans, covMean, cov, errMean,err,corrcoef = getStats(estcls,N)

        


pl = Plotter()
pl.add(lkk,lkk*clkk)
#pl.add(center,center*bin_means,ls="none",marker="x",color='red',markersize=8,mew=3)
pl.addErr(center,center*clmeans,yerr=center*errMean,ls="none",marker="o",color='red',markersize=8,mew=3)
pl._ax.set_xlim(0.,3500.)
pl.done("clpower.png")