예제 #1
0
def cov_from_maps(maps0,maps1):
    sh=np.shape(maps0)
    npix=sh[1]
    nbmc=sh[0]
    covmc=np.zeros((npix,npix))
    mm0=np.mean(maps0,axis=0)
    mm1=np.mean(maps1,axis=0)
    themaps0=np.zeros((nbmc,npix))
    themaps1=np.zeros((nbmc,npix))
    for i in np.arange(npix):
        pyquad.progress_bar(i,npix)
        themaps0[:,i]=maps0[:,i]-mm0[i]
        themaps1[:,i]=maps1[:,i]-mm1[i]
    for i in np.arange(npix):
        pyquad.progress_bar(i,npix)
        for j in np.arange(npix):
            covmc[i,j]=np.mean(themaps0[:,i]*themaps1[:,j])
            #covmc[j,i]=covmc[i,j]
    return(covmc)
예제 #2
0
nbpixok=50
mask=(np.arange(12*nside**2) >= nbpixok)

#### maps simulation
nbmc=1000
npix=np.size(where(mask==False))
allmapsi1=np.zeros((nbmc,npix))
allmapsq1=np.zeros((nbmc,npix))
allmapsu1=np.zeros((nbmc,npix))
allmapsi2=np.zeros((nbmc,npix))
allmapsq2=np.zeros((nbmc,npix))
allmapsu2=np.zeros((nbmc,npix))
sigI=200.
sigQU=10.
for i in np.arange(nbmc):
    pyquad.progress_bar(i,nbmc)
    mapi,mapq,mapu=hp.synfast(spectra[1:],nside,fwhm=0,pixwin=True,new=True)
    noisei1=np.random.randn(12*nside**2)*sigI
    noiseq1=np.random.randn(12*nside**2)*sigQU
    noiseu1=np.random.randn(12*nside**2)*sigQU
    noisei2=np.random.randn(12*nside**2)*sigI
    noiseq2=np.random.randn(12*nside**2)*sigQU
    noiseu2=np.random.randn(12*nside**2)*sigQU
    allmapsi1[i,:]=mapi[~mask]+noisei1[~mask]
    allmapsq1[i,:]=mapq[~mask]+noiseq1[~mask]
    allmapsu1[i,:]=mapu[~mask]+noiseu1[~mask]
    allmapsi2[i,:]=mapi[~mask]+noisei2[~mask]
    allmapsq2[i,:]=mapq[~mask]+noiseq2[~mask]
    allmapsu2[i,:]=mapu[~mask]+noiseu2[~mask]

############ Auto
예제 #3
0
def qml(maps,mask,covmap,ellbins,fwhmrad,guess,ds_dcb,spectra,itmax=20,plot=False,cholesky=True,polar=True,temp=True,EBTB=False):
    print('QML Estimator')
    ###### What will be calculated ?
    print('Temp='+str(temp))
    print('Polar='+str(polar))
    print('EBTB='+str(EBTB))
    all=['I','Q','U']
    if EBTB:
        xx=['TT','EE','BB','TE','EB','TB']
        ind=[1,2,3,4,5,6]
    else:
        xx=['TT','EE','BB','TE']
        ind=[1,2,3,4]
        
    if  not temp:
        all=['Q','U']
        if EBTB:
            xx=['EE','BB','EB']
            ind=[2,3,5]
        else:
            xx=['EE','BB']
            ind=[2,3]
    if not polar:
        all=['I']
        xx=['TT']
        ind=[1]
    print('Number of maps :',len(maps))
    print('Stokes parameters :',all)
    print('Spectra considered. :',xx)
    nspec=len(xx)

    if len(maps) != len(all):
        print('Inconstitent number of maps and Stokes parameters: Exiting !')
        return -1

    ### maps information
    nside=hp.npix2nside(len(maps[0]))
    ip=np.arange(12*nside**2)
    ipok=ip[~mask]
    npix=len(ipok)
    npixtot=len(all)*npix
    masktot=np.zeros(len(all)*len(mask),dtype=bool)
    map=np.zeros(len(all)*npix)
    for i in np.arange(len(all)):
        map[i*npix:(i+1)*npix]=maps[i][~mask]
        masktot[i*len(mask):(i+1)*len(mask)]=mask

    ### ell binning
    nbins=len(ellbins)-1
    ellmin=np.array(ellbins[0:nbins])
    ellmax=np.array(ellbins[1:nbins+1])-1
    ellval=(ellmin+ellmax)*1./2
    ll=np.arange(int(np.max(ellbins))+1)
    bl=np.exp(-0.5*ll**2*(fwhmrad/2.35)**2)

    ### Initial guess
    nbinstot=nspec*nbins
    specinit=np.zeros(nbinstot)
    for s in np.arange(nspec):
        specinit[s*nbins:(s+1)*nbins]=guess[ind[s]]
    thespectrum=np.zeros((nbinstot,itmax+1))
    thespectrum[:,0]=specinit

    ####################### P1 dS/dC Calculation #################################
    if ds_dcb is 0:
        ds_dcb=compute_ds_dcb_par(ellbins,nside,ipok,bl,polar=polar,temp=temp,EBTB=EBTB)
    ##############################################################################
    stop
    ### Start iterations
    num=0
    convergence=0
    lk=np.zeros(itmax)

    while convergence==0:
        ##########################################################################
        ## P2 pixpix covariance matrix for maps and solving z=M-1.m and likelihood
        print('    P2')
        matsky=np.zeros((npixtot,npixtot))
        for s in np.arange(nspec):
            for i in np.arange(nbins):
                matsky += thespectrum[s*nbins+i,num]*ds_dcb[s,i,:,:]
        print('       - Done matsky')
        matcov=covmap+matsky
        
        if cholesky is True:
            print('      Doing Cholesky decomposition')
            U=scipy.linalg.cho_factor(matcov)
            z=scipy.linalg.cho_solve(U,map)
        else:
            print('      Brute force inversion (No Cholesky)')
            minv=scipy.linalg.inv(matcov)
            z=np.dot(minv,map)
                
        mapw=np.zeros(map.size)
        mapw=z
        lk[num]=-0.5*(np.dot(z,map)+np.sum(np.log(np.diag(matcov))))
        ##########################################################################

        ########################################################################
        # P3 Solve the equations Wb=M^(-1).ds_dcb ##############################
        print('    P3')
        wb=np.zeros((nbinstot,npixtot,npixtot))
        for s in np.arange(nspec):
            pyquad.progress_bar(s,nspec)
            for i in np.arange(nbins):
                if cholesky is True:
                    wb[s*nbins+i,:,:]=scipy.linalg.cho_solve(U,ds_dcb[s,i,:,:])
                else:
                    wb[s*nbins+i,:,:]=np.dot(minv,ds_dcb[s,i,:,:])
        ########################################################################

        ########################################################################
        # P4 First derivatives of the likelihood ##############################
        print('    P4')
        dldcb=np.zeros(nspec*nbins)
        for i in np.arange(nbinstot):
            pyquad.progress_bar(i,nbinstot)
            dldcb[i]=0.5*(np.dot(map,np.dot(wb[i,:,:],z))-np.trace(wb[i,:,:]))
        #######################################################################
         
        ##########################################################################
        # P5 second derivatives of the likelihood ################################
        print('    P5')
        d2ldcbdcb=np.zeros((nspec*nbins,nspec*nbins))
        fisher=np.zeros((nspec*nbins,nspec*nbins))
        kk=0
        for i in np.arange(nbinstot):
            for j in np.arange(i,nbinstot):
                pyquad.progress_bar(kk,(nbinstot+1)*nbinstot/2)
                wbwb=np.dot(wb[i,:,:],wb[j,:,:])
                fisher[i,j]=np.trace(wbwb)
                d2ldcbdcb[i,j]=-np.dot(map,np.dot(wbwb,z))+0.5*fisher[i,j]
                fisher[j,i]=fisher[i,j]
                d2ldcbdcb[j,i]=d2ldcbdcb[i,j]
                kk+=1
        ###########################################################################
        
        ###########################################################################
        # P6 Correction to be applied to the spectrum #############################
        print('    P6')
        invfisher=(np.linalg.inv(fisher))
        err=np.sqrt(np.diag(invfisher))
        deltac=-np.dot(np.linalg.inv(d2ldcbdcb),dldcb)
        print('    Result for iteration',num)
        print('      C : ',min(thespectrum[:,num]),max(thespectrum[:,num]))
        print('     dC : ',min(deltac),max(deltac))
        newspectrum=(thespectrum[:,num]+deltac)
        deltac[newspectrum < 0]=0
        thespectrum[:,num+1]=(thespectrum[:,num]+deltac)
        ############################################################################
    
        spec=thespectrum[:,num]
        finalspectrum=[ellval,0,0,0,0,0,0]
        error=[ellval,0,0,0,0,0,0]
        for s in np.arange(nspec):
            finalspectrum[ind[s]]=spec[s*nbins:(s+1)*nbins]
            error[ind[s]]=err[s*nbins:(s+1)*nbins]
            
        ############################################################################
        # Critere de convergence ###################################################
        conv=deltac/np.sqrt(np.abs(np.diag(invfisher)))
        print('     Conv : ',max(abs(conv)))
        print('     Likelihood : ',lk[num])
        nplot_tot=1+nspec
        sqrn=int(np.sqrt(nplot_tot))
        if sqrn**2==nplot_tot:
            nr=sqrn
            nc=sqrn
        else:
            nr=sqrn+1
            nc=sqrn

        iplot=0
        if plot is True:
            mp.clf()
            mp.subplot(nr,nc,iplot+1)
            for s in np.arange(nspec):
                mp.xlim(0,np.max(ellmax)*1.2)
                ell=spectra[0]
                cl=spectra[ind[s]]
                ellb=finalspectrum[0]
                mp.plot(ell,cl*(ell*(ell+1))/(2*np.pi),lw=3)
                mp.plot(ellb,guess[ind[s]]*ellb*(ellb+1)/(2*np.pi),'go',alpha=0.5)
                mp.xlabel('$\ell$')
                mp.ylabel('$\ell(\ell+1)C_\ell/(2\pi)$')
                mp.errorbar(ellb,finalspectrum[ind[s]]*ellb*(ellb+1)/(2*np.pi),error[ind[s]]*ellb*(ellb+1)/(2*np.pi),xerr=(ellmax+1-ellmin)/2,label=str(i),fmt='ro')
                mp.draw()
                mp.title(xx[s])
                iplot+=1
                
            mp.subplot(nr,nc,iplot+1)
            if num>0: mp.plot(lk[:num],'o-')
            mp.xlabel('Iteration')
            mp.ylabel('Likelihood')
            mp.draw()
        if np.max(np.abs(conv)) <= 0.01 or num==itmax-1:
            convergence=1
        else:
            num=num+1
        ###########################################################################

    return finalspectrum,error,invfisher,lk,num,ds_dcb
예제 #4
0
def covth(nside,ipok,lmax,bl,spectra,polar=True,temp=True,allinone=True):
    all=['I','Q','U']
    if  not temp:
        all=['Q','U']
    if not polar:
        all=['I']
    rpix=np.array(hp.pix2vec(nside,ipok))
    allcosang=np.dot(np.transpose(rpix),rpix)
    pixwin=hp.pixwin(nside)[0:lmax+1]
    nspec,nell=np.shape(spectra)
    ell=spectra[0]
    maskl=ell<(lmax+1)
    ell=ell[maskl]
    ctt=spectra[1][maskl]
    cee=spectra[2][maskl]
    cbb=spectra[3][maskl]
    cte=spectra[4][maskl]
    if nspec==5:
        print('Assuming EB and TB are zero')
        ceb=0
        ctb=0
    else:
        ceb=spectra[5][maskl]
        ctb=spectra[6][maskl]
    norm=(2*ell+1)/(4*np.pi)*(pixwin**2)*(bl[maskl]**2)
    effctt=norm*ctt
    effcte=norm*cte
    effcee=norm*cee
    effcbb=norm*cbb
    effceb=norm*ceb
    effctb=norm*ctb
    nbpixok=ipok.size
    nstokes=np.size(all)
    print(nstokes)
    cov=np.zeros((nstokes,nstokes,nbpixok,nbpixok))
    for i in np.arange(nbpixok):
        pyquad.progress_bar(i,nbpixok)
        for j in np.arange(i,nbpixok):
            if nstokes==1:
                pl=pl0(allcosang[i,j],lmax)
                TT=effctt*pl
                cov[0,0,i,j]=np.sum(TT)
                cov[0,0,j,i]=cov[0,0,i,j]
            if nstokes==2:
                cij,sij=polrotangle(rpix[:,i],rpix[:,j])
                cji,sji=polrotangle(rpix[:,j],rpix[:,i])
                f12=F1l2(allcosang[i,j],lmax)
                f22=F2l2(allcosang[i,j],lmax)
                QQ=f12*effcee-f22*effcbb
                UU=f12*effcbb-f22*effcee
                QU=(f12+f22)*effceb
                cQQpsQU = ( cij*QQ + sij*QU )
                cQUpsUU = ( cij*QU + sij*UU )
                cQUmsQQ = ( cij*QU - sij*QQ )
                cUUmsQU = ( cij*UU - sij*QU )
                cov[0,0,i,j] = np.sum( cji*cQQpsQU + sji*cQUpsUU )
                cov[0,0,j,i] = cov[0,0,i,j]
                cov[0,1,i,j] = np.sum(-sji*cQQpsQU + cji*cQUpsUU )
                cov[1,0,j,i] = cov[0,1,i,j]
                cov[1,1,i,j] = np.sum(-sji*cQUmsQQ + cji*cUUmsQU )
                cov[1,1,j,i] = cov[1,1,i,j]
                cov[0,1,j,i] = np.sum( cji*cQUmsQQ + sji*cUUmsQU )
                cov[1,0,i,j] = cov[0,1,j,i]
            if nstokes==3:
                cij,sij=polrotangle(rpix[:,i],rpix[:,j])
                cji,sji=polrotangle(rpix[:,j],rpix[:,i])
                pl=pl0(allcosang[i,j],lmax)
                f10=F1l0(allcosang[i,j],lmax)
                f12=F1l2(allcosang[i,j],lmax)
                f22=F2l2(allcosang[i,j],lmax)
                TT=effctt*pl
                QQ=f12*effcee-f22*effcbb
                UU=f12*effcbb-f22*effcee
                TQ=-f10*effcte
                TU=-f10*effctb
                QU=(f12+f22)*effceb
                cQQpsQU = ( cij*QQ + sij*QU )
                cQUpsUU = ( cij*QU + sij*UU )
                cQUmsQQ = ( cij*QU - sij*QQ )
                cUUmsQU = ( cij*UU - sij*QU )
                cov[0,0,i,j] = np.sum( TT )
                cov[0,0,j,i] = cov[0,0,i,j]                
                cov[0,1,i,j] = np.sum( cji*TQ + sji*TU )
                cov[1,0,j,i] = cov[0,1,i,j]
                cov[1,0,i,j] = np.sum( cij*TQ + sij*TU )
                cov[0,1,j,i] = cov[1,0,i,j]
                cov[0,2,i,j] = np.sum(-sji*TQ + cij*TU )
                cov[2,0,j,i] = cov[0,2,i,j]
                cov[2,0,i,j] = np.sum(-sij*TQ + cij*TU )
                cov[0,2,j,i] = cov[2,0,i,j]
                cov[1,1,i,j] = np.sum( cji*cQQpsQU + sji*cQUpsUU )
                cov[1,1,j,i] = cov[1,1,i,j]
                cov[1,2,i,j] = np.sum(-sji*cQQpsQU + cji*cQUpsUU )
                cov[2,1,j,i] = cov[1,2,i,j]
                cov[2,1,i,j] = np.sum( cji*cQUmsQQ + sji*cUUmsQU )
                cov[1,2,j,i] = cov[2,1,i,j]
                cov[2,2,i,j] = np.sum(-sji*cQUmsQQ + cji*cUUmsQU )
                cov[2,2,j,i] = cov[2,2,i,j]
    if allinone==True:
        return(allmat2bigmat(cov))
    else:
        return cov
예제 #5
0
def covth_bins(ellbins,nside,ipok,bl,spectra,polar=True,temp=True,allinone=True):
    #### define bins in ell
    nbins=len(ellbins)-1
    minell=np.array(ellbins[0:nbins])
    maxell=np.array(ellbins[1:nbins+1])-1
    ellval=(minell+maxell)*0.5
    lmax=np.max(ellbins)
    #maxell[nbins-1]=lmax
    print('minell:',minell)
    print('maxell:',maxell)
    #### define Stokes
    all=['I','Q','U']
    if  not temp:
        all=['Q','U']
    if not polar:
        all=['I']

    #### define pixels
    print('rpix calculation')
    rpix=np.array(hp.pix2vec(nside,ipok))
    print('rpix done: ',rpix.shape)
    allcosang=np.dot(np.transpose(rpix),rpix)
    print('cosang done')
    
    #### define Pixel window function
    pixwin=hp.pixwin(nside)[0:lmax+1]

    #### get ell values from spectra and restrict spectra to good values
    nspec,nell=np.shape(spectra)
    ell=spectra[0]
    maskl=ell<(lmax+1)
    ell=ell[maskl]
    ctt=spectra[1][maskl]
    cee=spectra[2][maskl]
    cbb=spectra[3][maskl]
    cte=spectra[4][maskl]
    if nspec==5:
        print('Assuming EB and TB are zero')
        ceb=0
        ctb=0
    else:
        ceb=spectra[5][maskl]
        ctb=spectra[6][maskl]

    # Effective spectra
    print('Calculating effective spectra')
    norm=(2*ell+1)/(4*np.pi)*(pixwin**2)*(bl[maskl]**2)
    norm[1:]=norm[1:]/(ell[1:]*(ell[1:]+1))
    effctt=norm*ctt
    effcte=norm*cte
    effcee=norm*cee
    effcbb=norm*cbb
    effceb=norm*ceb
    effctb=norm*ctb

    #### define masks for ell bins
    masks=[]
    for i in np.arange(nbins):
        masks.append((ell>=minell[i]) & (ell<=maxell[i]))

    ### Create array for covariances matrices per bin
    nbpixok=ipok.size
    nstokes=np.size(all)
    print('creating array')
    cov=np.zeros((nbins,nstokes,nstokes,nbpixok,nbpixok))
    for i in np.arange(nbpixok):
        print(i)
        pyquad.progress_bar(i,nbpixok)
        for j in np.arange(i,nbpixok):
            if nstokes==1:
                pl=pl0(allcosang[i,j],lmax)
                TT=effctt*pl
                for b in np.arange(nbins):
                    cov[b,0,0,i,j]=np.sum(TT[masks[b]])*ellval[b]*(ellval[b]+1)
                    cov[b,0,0,j,i]=cov[b,0,0,i,j]
            if nstokes==2:
                cij,sij=polrotangle(rpix[:,i],rpix[:,j])
                cji,sji=polrotangle(rpix[:,j],rpix[:,i])
                f12=F1l2(allcosang[i,j],lmax)
                f22=F2l2(allcosang[i,j],lmax)
                QQ=f12*effcee-f22*effcbb
                UU=f12*effcbb-f22*effcee
                QU=(f12+f22)*effceb
                cQQpsQU = ( cij*QQ + sij*QU )
                cQUpsUU = ( cij*QU + sij*UU )
                cQUmsQQ = ( cij*QU - sij*QQ )
                cUUmsQU = ( cij*UU - sij*QU )
                for b in np.arange(nbins):
                    cov[b,0,0,i,j] = np.sum( cji*cQQpsQU[masks[b]] + sji*cQUpsUU[masks[b]] )*ellval[b]*(ellval[b]+1)
                    cov[b,0,0,j,i] = cov[b,0,0,i,j]
                    cov[b,0,1,i,j] = np.sum(-sji*cQQpsQU[masks[b]] + cji*cQUpsUU[masks[b]] )*ellval[b]*(ellval[b]+1)
                    cov[b,1,0,j,i] = cov[b,0,1,i,j]
                    cov[b,1,1,i,j] = np.sum(-sji*cQUmsQQ[masks[b]] + cji*cUUmsQU[masks[b]] )*ellval[b]*(ellval[b]+1)
                    cov[b,1,1,j,i] = cov[b,1,1,i,j]
                    cov[b,0,1,j,i] = np.sum( cji*cQUmsQQ[masks[b]] + sji*cUUmsQU[masks[b]] )*ellval[b]*(ellval[b]+1)
                    cov[b,1,0,i,j] = cov[b,0,1,j,i]
            if nstokes==3:
                cij,sij=polrotangle(rpix[:,i],rpix[:,j])
                cji,sji=polrotangle(rpix[:,j],rpix[:,i])
                pl=pl0(allcosang[i,j],lmax)
                f10=F1l0(allcosang[i,j],lmax)
                f12=F1l2(allcosang[i,j],lmax)
                f22=F2l2(allcosang[i,j],lmax)
                TT=effctt*pl
                QQ=f12*effcee-f22*effcbb
                UU=f12*effcbb-f22*effcee
                TQ=-f10*effcte
                TU=-f10*effctb
                QU=(f12+f22)*effceb
                cQQpsQU = ( cij*QQ + sij*QU )
                cQUpsUU = ( cij*QU + sij*UU )
                cQUmsQQ = ( cij*QU - sij*QQ )
                cUUmsQU = ( cij*UU - sij*QU )
                for b in np.arange(nbins):
                    cov[b,0,0,i,j] = np.sum( TT[masks[b]] )*ellval[b]*(ellval[b]+1)
                    cov[b,0,0,j,i] = cov[b,0,0,i,j]                
                    cov[b,0,1,i,j] = np.sum( cji*TQ[masks[b]] + sji*TU[masks[b]] )*ellval[b]*(ellval[b]+1)
                    cov[b,1,0,j,i] = cov[b,0,1,i,j]
                    cov[b,1,0,i,j] = np.sum( cij*TQ[masks[b]] + sij*TU[masks[b]] )*ellval[b]*(ellval[b]+1)
                    cov[b,0,1,j,i] = cov[b,1,0,i,j]
                    cov[b,0,2,i,j] = np.sum(-sji*TQ[masks[b]] + cij*TU[masks[b]] )*ellval[b]*(ellval[b]+1)
                    cov[b,2,0,j,i] = cov[b,0,2,i,j]
                    cov[b,2,0,i,j] = np.sum(-sij*TQ[masks[b]] + cij*TU[masks[b]] )*ellval[b]*(ellval[b]+1)
                    cov[b,0,2,j,i] = cov[b,2,0,i,j]
                    cov[b,1,1,i,j] = np.sum( cji*cQQpsQU[masks[b]] + sji*cQUpsUU[masks[b]] )*ellval[b]*(ellval[b]+1)
                    cov[b,1,1,j,i] = cov[b,1,1,i,j]
                    cov[b,1,2,i,j] = np.sum(-sji*cQQpsQU[masks[b]] + cji*cQUpsUU[masks[b]] )*ellval[b]*(ellval[b]+1)
                    cov[b,2,1,j,i] = cov[b,1,2,i,j]
                    cov[b,2,1,i,j] = np.sum( cji*cQUmsQQ[masks[b]] + sji*cUUmsQU[masks[b]] )*ellval[b]*(ellval[b]+1)
                    cov[b,1,2,j,i] = cov[b,2,1,i,j]
                    cov[b,2,2,i,j] = np.sum(-sji*cQUmsQQ[masks[b]] + cji*cUUmsQU[masks[b]] )*ellval[b]*(ellval[b]+1)
                    cov[b,2,2,j,i] = cov[b,2,2,i,j]
    if allinone:
        newcov=np.zeros((nbins,nstokes*nbpixok,nstokes*nbpixok))
        for i in np.arange(nbins):
            for si in np.arange(nstokes):
                for sj in np.arange(nstokes):
                    newcov[i,si*nbpixok:(si+1)*nbpixok,sj*nbpixok:(sj+1)*nbpixok]=cov[i,si,sj,:,:]
        return(newcov)
    else:
        return(cov)
예제 #6
0
print(npix)

#### noise covariance matrix
# get it through MC
nbmc=10000
allnoisemaps=np.zeros((npix,nbmc))
for i in np.arange(nbmc):
    print(i,nbmc)
    todnoise = tod*0 + np.random.randn(ndet,nsamples)*signoise
    solution = pcg(P_packed.T * P_packed, P_packed.T(todnoise), M=DiagonalOperator(1/coverage[~mask]))
    allnoisemaps[:,i]=unpack(solution['x'])[~mask]

covmc=np.zeros((npix,npix))
mm=np.mean(allnoisemaps,axis=-1)
for i in np.arange(npix):
    pyquad.progress_bar(i,npix)
    mm0=allnoisemaps[i,:]-mm[i]
    for j in np.arange(i,npix):
        covmc[i,j]=np.mean( mm0*(allnoisemaps[j,:]-mm[j]))
        covmc[j,i]=covmc[i,j]

cormc=pyquad.cov2cor(covmc)

from pysimulators import FitsArray 
FitsArray(covmc,copy=False).save('covmc'+str(signoise)+'_'+str(nbmc)+'.dat')
FitsArray(cormc,copy=False).save('cormc'+str(signoise)+'_'+str(nbmc)+'.dat')