def padded_wrap(map_id,map_size=a.map_size,\
sep=a.sep,N_sims=a.N_sims,N_bias=a.N_bias,noise_power=a.noise_power,FWHM=a.FWHM,\
slope=a.slope,l_step=a.l_step,lMin=a.lMin,lMax=a.lMax,rot=a.rot,freq=a.freq,\
delensing_fraction=a.delensing_fraction,useTensors=a.useTensors,f_dust=a.f_dust,\
rot_average=a.rot_average,useBias=a.useBias,padding_ratio=a.padding_ratio,unPadded=a.unPadded,flipU=a.flipU,root_dir=a.root_dir,\
KKdebiasH2=a.KKdebiasH2,cutFactor=1.25,ffp10_spectrum=a.ffp10_spectrum):
""" Compute the estimated angle, amplitude and polarisation fraction with noise, correcting for bias.
Noise model is from Hu & Okamoto 2002 and errors are estimated using MC simulations, which are all saved.
Input: map_id (tile number)
map_size (tile width in degrees)
sep (separation of tile centres in degrees)
N_sims (number of MC simulations)
N_bias (no. sims used for bias computation)
noise_power (noise power in microK-arcmin)
FWHM (noise FWHM in arcmin)
slope (fiducial slope of C_l isotropic dust dependance)
lMin / lMax (range of ell values to apply the estimators over)
l_step (step size for binning of 2D spectra)
rot (angle to rotate by before applying estimators)
freq (desired map frequency; 150 GHz for BICEP, 353 GHz for Vansyngel)
delensing_fraction (efficiency of delensing; i.e. 0.1=90% removed)
useTensors (Boolean, whether to include tensor noise from IGWs with r = 0.1)
f_dust (factor to reduce mean dust amplitude by - for null testing - default = 1 - no reduction)
rot_average (Boolean, whether to correct for pixellation error by performing (corrected) map rotations)
useBias (Boolean, whether to use bias)
padding_ratio (ratio of padded to unpadded map width >=1)
flipU (Boolean, whether to flip sign of U-map if in Planck COSMO convention)
root_dir (home directory)
Output: First 6 values: [estimate,isotropic mean, isotropic stdev] for {A,Afs,Afc,fs,fc,str,ang}
7th: full data for N_sims as a sequence of 7 lists for each estimate (each of length N_sims)
8th: full data for N_sims for the monopole bias term
9th: [estimate,isotropic mean, isotropic stdev] for Hexadecapole power
10: true monopole (from noiseless simulation) - for testing
11th: bias (isotropic estimate of <H^2>)
"""
lCut=int(cutFactor*lMax) # maximum ell for Fourier space maps
# First compute B-mode map from padded-real space map with desired padding ratio. Also compute the padded window function for later use
from .PaddedPower import MakePowerAndFourierMaps,DegradeMap,DegradeFourier
fBdust,padded_window,unpadded_window=MakePowerAndFourierMaps(map_id,padding_ratio=padding_ratio,map_size=map_size,sep=sep,freq=freq,fourier=True,power=False,returnMasks=True,flipU=flipU,root_dir=root_dir)
#if np.sum(unpadded_window.data.ravel())==0.:
# print 'no data here'
# return 1 # no data in this pixel
# Also compute unpadded map to give binning values without bias
unpadded_fBdust=MakePowerAndFourierMaps(map_id,padding_ratio=1.,map_size=map_size,sep=sep,freq=freq,fourier=True,power=False,returnMasks=False,flipU=flipU,root_dir=root_dir)
#unpadded_fBdust_large=DegradeFourier(unpadded_fBdust,lCut+200)
#unpadded_fBdust=DegradeFourier(unpadded_fBdust,lCut) # remove high ell pixels
#fBdust_large=DegradeFourier(fBdust.copy(),lCut+200)
#fBdust=DegradeFourier(fBdust,lCut) # discard high-ell pixels
bigger_window=unpadded_window.copy()
#bigger_window=DegradeMap(bigger_window.copy(),lCut+200)
#padded_window=DegradeMap(padded_window.copy(),lCut) # remove high-ell data
#unpadded_window=DegradeMap(unpadded_window.copy(),lCut)
if a.hexTest:
# TESTING - replace fourier B-mode from dust with random isotropic realisation of self
powDust=fftTools.powerFromFFT(fBdust) # compute power
from .PowerMap import oneD_binning
ll,pp=oneD_binning(powDust.copy(),10,lCut,l_step,binErr=False,exactCen=False) # compute one-D binned spectrum
from .PaddedPower import fourier_noise_test
fBdust,unpadded_fBdust=fourier_noise_test(padded_window,unpadded_window,ll,pp,padding_ratio=padding_ratio,unpadded=False,log=True)
#fBdust.kMap=fill_from_Cell(fBdust.copy(),ll,pp,fourier=True,power=False) # generate Gaussian realisation
#return powDust,fBdust,unpadded_fBdust
# Reduce dust amplitude by 'dedusting fraction'
unpadded_fBdust.kMap*=f_dust
fBdust.kMap*=f_dust
# Compute <W^2>^2 / <W^4> - this is a necessary correction for the H^2 quantities (since 4-field quantities)
wCorrection = np.mean(padded_window.data**2.)**2./np.mean(padded_window.data**4.)
# Input directory:
inDir=root_dir+'%sdeg%s/' %(map_size,sep)
# First compute the total noise (instrument+lensing+tensors)
from .NoisePower import noise_model,lensed_Cl,r_Cl
Cl_lens_func=lensed_Cl(delensing_fraction=delensing_fraction,ffp10_spectrum=ffp10_spectrum) # function for lensed Cl
if useTensors: # include r = 0.1 estimate
Cl_r_func=r_Cl()
def total_Cl_noise(l):
return Cl_lens_func(l)+noise_model(l,FWHM=FWHM,noise_power=noise_power)+Cl_r_func(l)
else:
def total_Cl_noise(l):
return Cl_lens_func(l)+noise_model(l,FWHM=FWHM,noise_power=noise_power)
# Now create a fourier space noise map
from .PaddedPower import fourier_noise_map
ellNoise=np.arange(5,lCut+200) # ell range for noise spectrum
from .RandomField import fill_from_model
#fourierNoise=fourier_noise_map
from .PaddedPower import fourier_noise_test
fourierNoise,unpadded_noise=fourier_noise_test(padded_window.copy(),unpadded_window.copy(),ellNoise,total_Cl_noise(ellNoise),padding_ratio=padding_ratio,unpadded=False,log=a.log_noise)
unpadded_noise=DegradeFourier(unpadded_noise.copy(),lCut)
fourierNoise=DegradeFourier(fourierNoise.copy(),lCut)
#print unpadded_noise.Nx,fourierNoise.Nx
padded_window=DegradeMap(padded_window.copy(),lCut)
unpadded_window=DegradeMap(unpadded_window.copy(),lCut)
#unpadded_noise=unpadded_fBdust.copy() # this map is generated completely in Fourier space to avoid errors
#unpadded_noise.kMap=fill_from_model(unpadded_fBdust.copy(),total_Cl_noise,fourier=True,power=False)
#fourierNoise=fourier_noise_map(padded_window.copy(),unpadded_window.copy(),ellNoise,total_Cl_noise(ellNoise),padding_ratio=padding_ratio,unpadded=False)
#fourierNoise,unpadded_noise=fourier_noise_map(padded_window.copy(),unpadded_window.copy(),ellNoise,total_Cl_noise(ellNoise),padding_ratio=padding_ratio,unpadded=True)
#return fourierNoise,unpadded_noise#,unpadded_noise2
#return fftTools.powerFromFFT(fourierNoise)
#return fourierNoise,unpadded_noise
# Compute total map
#ellTrial=lCut+200
#while True: # hack to ensure same sized maps
# if fourierNoise.Nx==fBdust.Nx:
# if fourierNoise.Ny==fBdust.Ny:
# break
# fourierNoise=DegradeFourier(fourierNoise.copy(),ellTrial)
# fBdust_large=DegradeFourier(fBdust_large.copy(),ellTrial)
# ellTrial-=1.
# if ellTrial<lCut-200:
# print 'failed1'
# break
# ellCut=lCut+200
# while True:
# if unpadded_noise.Nx==unpadded_fBdust_large.Nx:
### if unpadded_noise.Ny==unpadded_fBdust_large.Ny:
# break
# unpadded_noise=DegradeFourier(unpadded_noise.copy(),ellTrial)
# unpadded_fBdust_large=DegradeFourier(unpadded_fBdust_large.copy(),ellTrial)
# ellTrial-=1.
# if ellTrial<lCut:
# print 'failed2'
# break
totFmap=DegradeFourier(fBdust.copy(),lCut)
totFmap.kMap+=fourierNoise.kMap# for total B modes
unpadded_totFmap=DegradeFourier(unpadded_fBdust.copy(),lCut)
unpadded_totFmap.kMap+=unpadded_noise.kMap
# Now convert to power-space
totPow=fftTools.powerFromFFT(totFmap) # total power map
Bpow=fftTools.powerFromFFT(fBdust) # dust only map
unpadded_totPow=fftTools.powerFromFFT(unpadded_totFmap)
del fourierNoise,unpadded_noise
if unPadded: # only use unpadded maps here
totFmap=unpadded_totFmap
totPow=unpadded_totPow
padded_window=unpadded_window
#return totPow,Bpow
# Compute true amplitude using ONLY dust map
from .KKdebiased import derotated_estimator
p=derotated_estimator(Bpow.copy(),map_id,lMin=lMin,lMax=lMax,slope=slope,factor=None,FWHM=0.,\
noise_power=1.e-400,rot=rot,delensing_fraction=0.,useTensors=False,debiasAmplitude=False,rot_average=rot_average,KKdebiasH2=False)
trueA=p[0]
del Bpow
# Compute rough semi-analytic C_ell spectrum
def analytic_model(ell,A_est,slope):
"""Use the estimate for A to construct analytic model.
NB: This is just used for finding the centres of the actual binned data.
"""
return total_Cl_noise(ell)+A_est*ell**(-slope)
# Compute anisotropy parameters
A_est,fs_est,fc_est,Afs_est,Afc_est,finalFactor=derotated_estimator(totPow.copy(),map_id,lMin=lMin,\
lMax=lMax,slope=slope,factor=None,FWHM=FWHM,noise_power=noise_power,rot=rot,\
delensing_fraction=delensing_fraction,useTensors=useTensors,debiasAmplitude=True,rot_average=rot_average,KKdebiasH2=KKdebiasH2)
# (Factor is expected monopole amplitude (to speed convergence))
## Run MC Simulations
# Compute 1D power spectrum by binning in annuli
from .PowerMap import oneD_binning
l_cen,mean_pow = oneD_binning(unpadded_totPow.copy(),lMin*padding_ratio,lCut,l_step*padding_ratio,binErr=False,exactCen=a.exactCen,\
C_ell_model=analytic_model,params=[A_est,slope])
#l_cen,mean_pow=oneD_binning(totPow.copy(),lMin,lCut,l_step,binErr=False,exactCen=a.exactCen,C_ell_model=analytic_model,params=[A_est,slope])
# gives central binning l and mean power in annulus using window function corrections
# Create spline fit
from scipy.interpolate import UnivariateSpline
spl=UnivariateSpline(l_cen,np.log(mean_pow),k=5)
def spline(ell):
return np.exp(spl(ell))
#del l_cen,mean_pow
# Precompute useful data:
from hades.RandomField import precompute
precomp=precompute(padded_window.copy(),spline,lMin=lMin,lMax=lMax)
#from .RandomField import padded_fill_from_Cell
#fBias=padded_fill_from_Cell(padded_window.copy(),l_cen,mean_pow,lMin=lMin)#,padding_ratio=padding_ratio)
##bias_cross=fftTools.powerFromFFT(fBias.copy(),totFmap.copy()) # cross map
#bias_self=fftTools.powerFromFFT(fBias.copy()) # self map
#return bias_self,l_cen,mean_pow
# First compute the bias factor
from .RandomField import padded_fill_from_Cell
#all_sims=[]
if useBias:
bias_data=np.zeros(N_bias)
for n in range(N_bias):
if n%100==0:
print 'Computing bias sim %s of %s' %(n+1,N_bias)
fBias=padded_fill_from_Cell(padded_window.copy(),l_cen,mean_pow,lMin=lMin,unPadded=unPadded,precomp=precomp)#,padding_ratio=padding_ratio)
bias_cross=fftTools.powerFromFFT(fBias.copy(),totFmap.copy()) # cross map
bias_self=fftTools.powerFromFFT(fBias.copy()) # self map
# First compute estimators on cross-spectrum
cross_ests=derotated_estimator(bias_cross.copy(),map_id,lMin=lMin,lMax=lMax,slope=slope,\
factor=finalFactor,FWHM=FWHM,noise_power=noise_power,\
rot=rot,delensing_fraction=delensing_fraction,useTensors=useTensors,\
debiasAmplitude=False,rot_average=rot_average,KKdebiasH2=False) # NB: CHANGE DEBIAS_AMPLITUDE parameter here
self_ests=derotated_estimator(bias_self.copy(),map_id,lMin=lMin,lMax=lMax,slope=slope,\
factor=finalFactor,FWHM=FWHM,noise_power=noise_power,\
rot=rot,delensing_fraction=delensing_fraction,useTensors=useTensors,\
debiasAmplitude=True,rot_average=rot_average,KKdebiasH2=KKdebiasH2)
bias_data[n]=(-1.*(self_ests[3]**4.+self_ests[4]**2.)+4.*(cross_ests[3]**2.+cross_ests[4]**2.))*wCorrection
# Now compute the mean bias - this debiases the DATA only
bias=np.mean(bias_data)
del bias_self,bias_cross
else:
print 'No bias subtraction'
bias=0.
## Now run the MC sims proper:
# Initialise arrays
A_MC,fs_MC,fc_MC,Afs_MC,Afc_MC,epsilon_MC,ang_MC,HexPow2_MC=[np.zeros(N_sims) for _ in range(8)]
#MC_map=totPow.copy() # template for SIM-SIM data
for n in range(N_sims): # for each MC map
if n%100==0:
print('MapID %s: Starting simulation %s of %s' %(map_id,n+1,N_sims))
# Create the map with a random implementation of Cell
fourier_MC_map=padded_fill_from_Cell(padded_window.copy(),l_cen,mean_pow,lMin=lMin,unPadded=unPadded,precomp=precomp)
MC_map=fftTools.powerFromFFT(fourier_MC_map.copy()) # create power domain map
# Now use the estimators on the MC sims
output=derotated_estimator(MC_map.copy(),map_id,lMin=lMin,lMax=lMax,\
slope=slope,factor=finalFactor,FWHM=FWHM,noise_power=noise_power,\
rot=rot, delensing_fraction=delensing_fraction,useTensors=useTensors,\
debiasAmplitude=True,rot_average=rot_average,KKdebiasH2=KKdebiasH2)
# Compute MC anisotropy parameters
A_MC[n]=output[0]
fs_MC[n]=output[3]/output[0]
fc_MC[n]=output[4]/output[0]
Afs_MC[n]=output[3] # these are fundamental quantities here
Afc_MC[n]=output[4]
epsilon_MC[n]=np.sqrt((output[3]**2.+output[4]**2.)*wCorrection)/output[0] # NOT corrected for bias in <H^2>
ang_MC[n]=0.25*180./np.pi*np.arctan2(output[3],output[4]) # NB: this is not corrected for bias
HexPow2_MC[n]=(output[3]**2.+output[4]**2.)*wCorrection
if useBias:
isoBias=np.mean(HexPow2_MC)
HexPow2_MC-=isoBias*np.ones_like(HexPow2_MC) # remove the bias (i.e. mean of H^2 from all sims)
else:
isoBias=0.
print 'MC sims complete'
del fourier_MC_map,MC_map,totFmap,unpadded_totFmap,totPow,unpadded_totPow,padded_window,unpadded_window # delete unneeded variables
# Regroup data
allMC=[A_MC,fs_MC,fc_MC,Afs_MC,Afc_MC,epsilon_MC,ang_MC,HexPow2_MC]
# Compute anisotropy fraction and angle from data
ang_est=0.25*180./np.pi*(np.arctan2(Afs_est,Afc_est)) # in degrees (already corrected for rotation) - NB: not debiased
frac_est=np.sqrt((Afs_est**2.+Afc_est**2.)*wCorrection)/A_est # BIASED sqrt(<H^2>)/A
HexPow2_est=(Afs_est**2.+Afc_est**2.)*wCorrection-bias # estimated hexadecapolar power - debiased + corrected for <W^4>
# Compute means and standard deviations
A_mean=np.mean(A_MC)
A_std=np.std(A_MC)
fc_mean=np.mean(fc_MC)
fs_mean=np.mean(fs_MC)
fc_std=np.std(fc_MC)
fs_std=np.std(fs_MC)
frac_mean=np.mean(epsilon_MC)
frac_std=np.std(epsilon_MC)
ang_mean=np.mean(ang_MC)
ang_std=np.std(ang_MC)
HexPow2_mean=np.mean(HexPow2_MC)
HexPow2_std=np.std(HexPow2_MC)
Afs_mean=np.mean(Afs_MC)
Afc_mean=np.mean(Afc_MC)
Afs_std=np.std(Afs_MC)
Afc_std=np.std(Afc_MC)
# Regroup data
Adat=[A_est,A_mean,A_std]
fsdat=[fs_est,fs_mean,fs_std]
fcdat=[fc_est,fc_mean,fc_std]
Afsdat=[Afs_est,Afs_mean,Afs_std]
Afcdat=[Afc_est,Afc_mean,Afc_std]
fracdat=[frac_est,frac_mean,frac_std] # hexadecapolar anisotropy fraction (epsilon)
angdat=[ang_est,ang_mean,ang_std] # anisotropy angle
HexPow2dat=[HexPow2_est,HexPow2_mean,HexPow2_std] # hexadecapole amplitude
# Return all output
return Adat,fsdat,fcdat,Afsdat,Afcdat,fracdat,angdat,allMC,[],HexPow2dat,trueA,bias,wCorrection,isoBias # (empty set to avoid reordering later code)
def compute_angle(map_id,padding_ratio=a.padding_ratio,map_size=a.map_size,sep=a.sep,freq=a.freq,\
f_dust=a.f_dust,lMax=a.lMax,lMin=a.lMin,l_step=a.l_step,FWHM=a.FWHM,noise_power=a.noise_power,\
slope=a.slope,delensing_fraction=a.delensing_fraction,useQU=a.useQU,N_bias=a.N_bias):
"""Compute the polarisation angle for a specific tile, creating a model B-power spectrum + cross-spectra
in order to find the angle including the ambiguity in sin(2alpha), cos(2alpha) due to initial computation
of sin(4alpha), cos(4alpha).
Returns angle in degrees.
"""
# Step 1, create actual B-mode map
lCut=int(1.35*lMax) # maximum ell for Fourier space maps
# First compute B-mode map from padded-real space map with desired padding ratio. Also compute the padded window function for later use
from hades.PaddedPower import MakePowerAndFourierMaps,DegradeMap,DegradeFourier
fBdust,padded_window,unpadded_window=MakePowerAndFourierMaps(map_id,padding_ratio=padding_ratio,map_size=map_size,sep=sep,freq=freq,fourier=True,power=False,returnMasks=True,flipU=a.flipU)
# Also compute unpadded map to give binning values without bias
unpadded_fBdust=MakePowerAndFourierMaps(map_id,padding_ratio=1.,map_size=map_size,freq=freq,fourier=True,power=False,returnMasks=False,flipU=a.flipU)
unpadded_fBdust=DegradeFourier(unpadded_fBdust,lCut) # remove high ell pixels
fBdust=DegradeFourier(fBdust,lCut) # discard high-ell pixels
padded_window=DegradeMap(padded_window.copy(),lCut) # remove high-ell data
unpadded_window=DegradeMap(unpadded_window.copy(),lCut)
unpadded_fBdust.kMap*=f_dust
fBdust.kMap*=f_dust
wCorrection = np.mean(padded_window.data**2.)**2./np.mean(padded_window.data**4.)
from hades.NoisePower import noise_model,lensed_Cl,r_Cl
Cl_lens_func=lensed_Cl(delensing_fraction=delensing_fraction) # function for lensed Cl
def total_Cl_noise(l):
return Cl_lens_func(l)+noise_model(l,FWHM=FWHM,noise_power=noise_power)
from hades.PaddedPower import fourier_noise_map
ellNoise=np.arange(5,lCut) # ell range for noise spectrum
from hades.RandomField import fill_from_model
#fourierNoise=fourier_noise_map
from hades.PaddedPower import fourier_noise_test
fourierNoise,unpadded_noise=fourier_noise_test(padded_window,unpadded_window,ellNoise,total_Cl_noise(ellNoise),padding_ratio=padding_ratio,unpadded=False,log=True)
totFmap=fBdust.copy()
totFmap.kMap+=fourierNoise.kMap# for total B modes
unpadded_totFmap=unpadded_fBdust.copy()
unpadded_totFmap.kMap+=unpadded_noise.kMap
fBtrue=totFmap.copy()
# Step 2: Compute the I map
inDir=a.root_dir+'%sdeg%s/' %(map_size,sep)
Tmap=liteMap.liteMapFromFits(inDir+'fvsmapT_'+str(map_id).zfill(5)+'.fits')
Qmap=liteMap.liteMapFromFits(inDir+'fvsmapQ_'+str(map_id).zfill(5)+'.fits')
Umap=liteMap.liteMapFromFits(inDir+'fvsmapU_'+str(map_id).zfill(5)+'.fits')
Umap.data*=-1.
QUmap=Qmap.copy()
QUmap.data=np.sqrt(Qmap.data**2.+Umap.data**2.)
if useQU:
scaling=np.mean(QUmap.data**4.)
else:
scaling=np.mean(Tmap.data**4.)
maskMap=liteMap.liteMapFromFits(inDir+'fvsmapMaskSmoothed_'+str(map_id).zfill(5)+'.fits')
from hades.PaddedPower import zero_padding
zTmap=zero_padding(Tmap,padding_ratio)
zQUmap=zero_padding(QUmap,padding_ratio)
zWindow=zero_padding(maskMap,padding_ratio)
# Compute window factor <W^2> for padded window (since this is only region with data)
windowFactor=np.mean(zWindow.data**2.)
# Define mod(l) and ang(l) maps needed for fourier transforms
modL,angL=fp.fftPol.makeEllandAngCoordinate(zTmap) # choice of map is arbitary
# Create pure T,E,B maps using 'hybrid' method to minimize E->B leakage
zTmap.data*=zWindow.data
zQUmap.data*=zWindow.data
fT=fftTools.fftFromLiteMap(zTmap)
fQU=fftTools.fftFromLiteMap(zQUmap)
# Rescale to correct amplitude using dust SED
from hades.PowerMap import dust_emission_ratio
dust_intensity_ratio=dust_emission_ratio(freq)
fT.kMap*=dust_intensity_ratio # apply dust-reduction factor
fT.kMap/=np.sqrt(windowFactor)
fQU.kMap*=dust_intensity_ratio
fQU.kMap/=np.sqrt(windowFactor)
fImap=DegradeFourier(fT,lCut)
fQUmap=DegradeFourier(fQU,lCut)
# Step 3: Compute angle estimate
powBtrue=fftTools.powerFromFFT(fBtrue)
unpadded_powBtrue=fftTools.powerFromFFT(unpadded_totFmap)
from hades.KKdebiased import derotated_estimator
output=derotated_estimator(powBtrue,map_id,lMin=lMin,lMax=lMax,FWHM=FWHM,noise_power=noise_power,delensing_fraction=delensing_fraction,slope=slope)
A,fs,fc,Afs,Afc,_=output
HexPow2=Afs**2.+Afc**2.
if a.debias_dedust:
from .RandomField import padded_fill_from_Cell
bias_data=np.zeros(N_bias)
def analytic_model(ell,A_est,slope):
"""Use the estimate for A to construct analytic model.
NB: This is just used for finding the centres of the actual binned data.
"""
return total_Cl_noise(ell)+A_est*ell**(-slope)
from .PowerMap import oneD_binning
l_cen,mean_pow = oneD_binning(unpadded_powBtrue.copy(),lMin*padding_ratio,lCut,l_step*padding_ratio,binErr=False,exactCen=a.exactCen,\
C_ell_model=analytic_model,params=[A,slope])
#l_cen,mean_pow=oneD_binning(totPow.copy(),lMin,lCut,l_step,binErr=False,exactCen=a.exactCen,C_ell_model=analytic_model,params=[A_est,slope])
# gives central binning l and mean power in annulus using window function corrections
# Create spline fit
from scipy.interpolate import UnivariateSpline
spl=UnivariateSpline(l_cen,np.log(mean_pow),k=5)
def spline(ell):
return np.exp(spl(ell))
#del l_cen,mean_pow
# Precompute useful data:
from hades.RandomField import precompute
precomp=precompute(padded_window.copy(),spline,lMin=lMin,lMax=lMax)
for n in range(N_bias):
if n%100==0:
print 'Computing bias sim %s of %s' %(n+1,N_bias)
fBias=padded_fill_from_Cell(padded_window.copy(),l_cen,mean_pow,lMin=lMin,unPadded=a.unPadded,precomp=precomp)#,padding_ratio=padding_ratio)
bias_cross=fftTools.powerFromFFT(fBias.copy(),totFmap.copy()) # cross map
bias_self=fftTools.powerFromFFT(fBias.copy()) # self map
# First compute estimators on cross-spectrum
cross_ests=derotated_estimator(bias_cross.copy(),map_id,lMin=lMin,lMax=lMax,slope=slope,\
factor=A,FWHM=FWHM,noise_power=noise_power,\
rot=a.rot,delensing_fraction=delensing_fraction,useTensors=a.useTensors,\
debiasAmplitude=False,rot_average=a.rot_average,KKdebiasH2=False) # NB: CHANGE DEBIAS_AMPLITUDE parameter here
self_ests=derotated_estimator(bias_self.copy(),map_id,lMin=lMin,lMax=lMax,slope=slope,\
factor=A,FWHM=FWHM,noise_power=noise_power,\
rot=a.rot,delensing_fraction=delensing_fraction,useTensors=a.useTensors,\
debiasAmplitude=True,rot_average=a.rot_average,KKdebiasH2=a.KKdebiasH2)
bias_data[n]=(-1.*(self_ests[3]**4.+self_ests[4]**2.)+4.*(cross_ests[3]**2.+cross_ests[4]**2.))*wCorrection
# Now compute the mean bias - this debiases the DATA only
bias=np.mean(bias_data)
del bias_self,bias_cross
HexPow2-=bias
norm=np.sqrt(Afs**2.+Afc**2.)
fsbar,fcbar=Afs/norm,Afc/norm
sin2a=fsbar/np.sqrt(2.*(fcbar+1.))
cos2a=np.sqrt((1.+fcbar)/2.)
# Step 4: Compute B estimate
angleMap=fImap.thetaMap*np.pi/180.
fB_est=fImap.copy()
if useQU:
baseMap=fQUmap.copy()
else:
baseMap=fImap.copy()
fB_est.kMap=baseMap.kMap*(sin2a*np.cos(2.*angleMap)-cos2a*np.sin(2.*angleMap))
# Step 5: Now compute cross coefficient
crossPow=fftTools.powerFromFFT(fB_est,fBtrue)
estPow=fftTools.powerFromFFT(fB_est,fB_est)
from hades.PowerMap import oneD_binning
lC,pC=oneD_binning(crossPow,lMin,lMax/2.,l_step,exactCen=False)
lE,pE=oneD_binning(estPow,lMin,lMax/2.,l_step,exactCen=False)
lB,pB=oneD_binning(powBtrue,lMin,lMax/2.,l_step,exactCen=False)
#rho=np.array(pC)/np.sqrt(np.array(pB)*np.array(pE))
ratio=np.array(pC)/np.array(pE)
sign=np.sign(np.mean(ratio))
# Step 6: Now compute the actual angle
alpha0=0.25*np.arctan2(fsbar,fcbar) # range is [-pi/4,pi/4]
if sign==-1.0:
alpha0+=np.pi/2.
# Step 7: Compute the ratio of H^2/<I^4> for rescaling
ratio=(np.abs(HexPow2)/scaling)**0.25
alpha_deg=alpha0*180./np.pi
print 'MapID: %s Angle: %.2f Ratio: %.2e' %(map_id,alpha_deg,ratio)
return alpha_deg,ratio