def freq_interp_hpm(inmap, infreq, outfreq, spectral_index=(), curverture=()):
inmap = hp.read_map(inmap)
basefreq = infreq
print 'Read base map from {0:s}'.format(inmap)
print 'Frequency of inmap: {0:f} MHz'.format(infreq)
if isinstance(outfreq, float):
nu = np.array([outfreq])
elif isinstance(outfreq, np.ndarray):
nu = outfreq
else:
raise Exception("Check outfreq format")
print 'Output frequencie(s):'
print nu
if not spectral_index:
beta = np.ones(inmap.size) * -2.5
print 'beta is asuume to be -2.5'
elif isinstance(spectral_index, str):
if spectral_index.rsplit('.')[-1] == 'fits':
beta = hp.read_map(spectral_index)
print 'read beta map from {0:s}'.format(beta)
if not curverture:
gamma = np.zeros(inmap.size)
print 'gamma is asuume to be 0'
elif isinstance(curverture, str):
if curverture.rsplit('.')[-1] == 'fits':
gamma = hp.read_map(curverture)
print 'read gamma map from {0:s}'.format(gamma)
outname = ['{0:s}_{1:.3f}MHz.fits'.format(inmap.rsplit('.', 1)[0], nu[i])
for i in range(nu.size)]
for f, name in zip(nu, outname):
print 'Scaling base map to {0:.3f}MHz and save output to {1:s}'\
.format(f, name)
T = np.exp(np.log(inmap) + beta * np.log(f / basefreq)
+ gamma * (np.log(f / basefreq)) ** 2)
hp.write_map(name, T, coord='G')
def MakeMap(fitsfile,output=None,nside=256,nest=True,norm=True,masked=False):
#
# Save map as healpy format from fits input
#
import numpy as np
import pyfits as pf
import healpy as hp
hdulist = pf.open(fitsfile)
Cat = hdulist[1].data
hdulist.close()
pixarea = hp.nside2pixarea(nside,degrees=True)
print 'nside = ',nside,' --> Pixel area (deg2) = ',pixarea
tiles = hp.ang2pix(nside,-Cat['dec']*np.pi/180.+np.pi/2.,Cat['ra']*np.pi/180.,nest)
npix = hp.nside2npix(nside)
n_hit_selec = np.zeros(npix)
for itile in tiles:
if norm:
n_hit_selec[itile]+=1./pixarea
else:
n_hit_selec[itile]+=1
if masked == True:
n_hit_selec = MaskBorders(n_hit_selec)
if output == None:
return n_hit_selec
else:
hp.write_map(output,n_hit_selec,nest)
return
def ComputeSystCorrectionM1(syst_maps,syst_params,syst_limits,syst_i,output=None,nside=256,nest=True):
#
# Create a healpy map of the expected fluctuation density per pixel but for syst_i, given the value of the syst in the pixels
# and the value of the linear parameters for each systmatics.
#
import healpy as hp
import numpy as np
maps = []
for i,isyst in enumerate(syst_maps):
map = hp.read_map(isyst,nest=nest)
map[map<syst_limits[i][0]] = 0
map[map>syst_limits[i][1]] = 0
map/=map[map>0].mean()
maps.append(map)
predicted_fluc = np.zeros(len(maps[0]))
for i,ipar in enumerate(syst_params):
if i==syst_i:
continue
predicted_fluc+= ipar*maps[i]
for i,imap in enumerate(maps):
if i==syst_i:
continue
predicted_fluc[imap==0] = 0
if output == None:
return predicted_fluc
else:
hp.write_map(output,predicted_fluc,nest=nest)
return
def ComputeFullSystCorrection(syst_maps,syst_params,syst_limits=None,output=None,nside=256,nest=True):
#
# Create a healpy map of the expected fluctuation density per pixel given the value of the syst in the pixels
# and the value of the linear parameters for each systmatics.
#
import healpy as hp
import numpy as np
import copy
cop_maps = copy.deepcopy(syst_maps)
maps = []
for i,map in enumerate(cop_maps):
if syst_limits is not None:
map[map<syst_limits[i][0]] = 0
map[map>syst_limits[i][1]] = 0
map/=map[map>0].mean()
maps.append(map)
predicted_fluc = np.zeros(len(maps[0]))
for i,ipar in enumerate(syst_params):
predicted_fluc+= ipar*(maps[i]-1)
for imap in maps:
predicted_fluc[imap==0] = 0
if output == None:
return predicted_fluc
else:
hp.write_map(output,predicted_fluc,nest=nest)
return
def ascii2fits(file_1,nside_1,file_2,nside_2):
"""
A function for converting ascii map to fits with a mask.
@param file_1 input ascii file with useful pixel numbers
@param nside_1 nside of the input ascii file
@param file_2 output file path
@param nside_2 nside of the output map
"""
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
if(nside_2 > nside_1):
raise RuntimeError("nside of the input should be greater than the output")
logger.info("Reading data from "+file_1)
pixs = np.loadtxt(file_1,skiprows=1)
logger.info("Creating healpix mask with nside "+str(nside_2))
mask = np.zeros(hp.nside2npix(nside_1))
for pix in pixs:
mask[int(pix)] = 1
ud_mask = hp.ud_grade(mask,nside_2)
logger.info("Writing output to "+file_2)
hp.write_map(file_2,ud_mask)
def write_CMB_T_map(self, from_this=None, to_this='my_map'):
if from_this is None:
print "No CMB T map supplied"
else:
self.Tmapfile=to_this+".fits"
hp.write_map(self.Tmapfile, from_this)
return
def main(nsim=0):
nl = h._nl
# Load map, mask, mll
print ""
print "Loading map, mask, mll, and calculating mll_inv..."
map_data = hp.read_map(h._fn_map)
mask = hp.read_map(h._fn_mask)
mll = np.load(h._fn_mll)
mll_inv = np.linalg.inv(mll)
# Read in Planck map: normalize, remove mono-/dipole, mask
print "Normalizing, removing mono-/dipole, and masking map..."
map_masked = map_data * mask
# Create cltt (cltt_data_masked) and correct it (cltt_data_corrected)
print "Calculating cltt_data_masked, cltt_data_corrected..."
cltt_data_masked = hp.anafast(map_masked)
cltt_data_masked = cltt_data_masked[:nl]
cltt_data_corrected = np.dot(mll_inv, cltt_data_masked)
# Create simulation of map (map_sim) from cltt_data_corrected
print "Creating and saving map_sim_%i..." % nsim
map_sim = hp.synfast(cltt_data_corrected, h._nside)
hp.write_map('output/map_sim_%i.fits' % nsim, map_sim)
def MakePredictedDensityMap(syst_maps,syst_params,syst_limits,mean_dens,output,nside=256,nest=True):
#
# Create a healpy map of the expected density per pixel given the value of the syst in the pixels
# and the value of the linear parameters for each systmatics. Must also give mean depth.
#
import healpy as hp
import numpy as np
import copy
cop_maps = copy.deepcopy(syst_maps)
maps = []
for i,map in enumerate(cop_maps):
map[map<syst_limits[i][0]] = 0
map[map>syst_limits[i][1]] = 0
map/=map[map>0].mean()
maps.append(map)
predicted_dens = np.zeros(len(maps[0]))
predicted_dens+= mean_dens
for i,ipar in enumerate(syst_params):
predicted_dens+= ipar*(maps[i]-1)
for imap in maps:
predicted_dens[imap==0] = 0
hp.write_map(output,predicted_dens,nest=nest)
def main(fname_config):
#Read configuration into classes
Config = ConfigParser.ConfigParser()
Config.read(fname_config)
out = output(Config._sections['GlobalParameters'])
Config.read('./ConfigFiles/'+Config.get('FreeFree','model')+'_config.ini')
freefree = component(Config._sections['FreeFree'],out.nside)
with open(out.output_dir+out.output_prefix+'freefree_config.ini','w') as configfile\
: Config.write(configfile)
print('Computing free-free maps.')
print '----------------------------------------------------- \n'
if out.debug == True:
print ''.join("%s: %s \n" % item for item in vars(freefree).items())
print '----------------------------------------------------- \n'
conv_I = convert_units(freefree.template_units,out.output_units,out.output_frequency)
scaled_map_ff = scale_freqs(freefree,out)*conv_I[...,np.newaxis]*freefree.em_template
scaled_map_ff_pol = np.zeros((2,np.asarray(out.output_frequency).size,hp.nside2npix(out.nside)))
if out.debug == True:
ff = np.concatenate([scaled_map_ff[np.newaxis,...],scaled_map_ff_pol])
for i in range(0,len(out.output_frequency)):
hp.write_map(out.output_dir+out.output_prefix+'ff_%d'%(out.output_frequency[i])+'_'+str(out.nside)+'.fits',ff[:,i,:],coord='G',column_units=out.output_units)
return np.concatenate([scaled_map_ff[np.newaxis,...],scaled_map_ff_pol])
def mapper1(catalog, nside, out_map):
# create empty map
npix = hp.nside2npix(nside)
# read catalog
c = pandas.read_csv(catalog, sep=',', header=0, dtype={'ra' : np.float64, 'dec' : np.float64}, engine=None, usecols=['ra', 'dec'])
ra = c["ra"]
dec = c["dec"]
# galaxy count
num_gal = len(ra)
# generate theta/phi vectors
theta = np.deg2rad(90.0 - dec)
phi = np.deg2rad(ra)
# generate corresponding pixel_IDs
pix_IDs = hp.ang2pix(nside, theta, phi, nest=False)
# distribute galaxies according to pixel_ID
cmap = np.bincount(pix_IDs, minlength=npix)
assert len(cmap) == npix, ("pixel numbers mismatched")
# write to file
hp.write_map(out_map, cmap)
print("num_gal =", num_gal)
return None
def main(nsim=1, fnl=0.0):
nl = 1024
nside_fnl = 512
# Load map, mll
print ""
print "Loading alm_g, alm_ng and creating map..."
fn_almg = ('data/fnl_sims/alm_l_%04d_v3.fits' % (nsim,))
#fn_almg = ('data/fnl_sims/alm_l_%i.fits' % (nsim,))
almg = hp.read_alm(fn_almg)
#almg = almg[:hp.Alm.getsize(nl)]
fn_almng = ('data/fnl_sims/alm_nl_%04d_v3.fits' % (nsim,))
#fn_almng = ('data/fnl_sims/alm_nl_%i.fits' % (nsim,))
almng = hp.read_alm(fn_almng)
#almng = almng[:hp.Alm.getsize(nl)]
alm = almg * (2.7e6) + fnl * almng * (2.7e6) # convert to units of uK to be consistent with other maps
map_sim_fnl = hp.alm2map(alm, nside=nside_fnl)
#print "Normalizing map..."
#map_sim_fnl *= (1e6 * 2.7) # convert to units of uK to be consistent with other maps
fn_map = 'data/fnl_sims/map_fnl_%i_sim_%i.fits' % (int(fnl), nsim)
print "Writing map: %s" % fn_map
hp.write_map(fn_map, map_sim_fnl)
def merger(config, params, avoids=False):
# Collect all fits files
prefix = '/net/user/fmcnally/ShowerLLH/maps/'
masterList = glob.glob(prefix + 'raw/'+config+'*.fits')
masterList.sort()
# Refine to files containing every parameter in params
fList = []
for f in masterList:
f_params = basename(f).split('_')
if all(x in f_params for x in params):
fList.append(f)
# Refine to files containing no parameter in avoids
if avoids:
fList = [f for f in fList if not any(x in basename(f) for x in avoids)]
# Merge files
if len(fList) == 0:
print 'No files found'
return
for i in range(len(fList)):
temp = hp.read_map(fList[i])
if i == 0:
combined_map = np.zeros(temp.shape)
combined_map += temp
# Write to file
outBase = '_'.join(params)
outFile = prefix + 'merged/'+config+'_'+outBase
hp.write_map(outFile, combined_map)
def compute_distance(msk,saveto=None,process_mask="./process_mask"):
if isinstance(msk,str):
mskfile = msk
delmskfile=""
else:
mskfile = tempfile.mktemp(prefix="input_mask_",suffix=".fits")
delmskfile = mskfile
hp.write_map(mskfile,msk)
delsaveto = ""
if not saveto:
saveto = tempfile.mktemp(prefix="output_dist_",suffix=".fits")
delsaveto = saveto
parfile = tempfile.mktemp(prefix="mask_",suffix=".par")
f=open(parfile,"w")
print("mask_file = ",mskfile,file=f)
print("distance_file = ",saveto,file=f)
f.close()
sbp.call([process_mask,parfile])
dist = hp.read_map(saveto)
os.remove(parfile)
if delmskfile:
os.remove(delmskfile)
if delsaveto:
os.remove(delsaveto)
return dist
def simulate_cmb(nside=2048, lmax=3000,
frequency=100,smear=False,
nomap = False, beam=None, beamP=None,
save=False, filename='testcmb.fits',
cl_file='bf_base_cmbonly_plikHMv18_TT_lowTEB_lmax4000.minimum.theory_cl'):
ls, cltt, clte, clee, clbb = get_theory_cls(lmax=lmax, cl_file=cl_file)
Tlm, Elm, Blm = hp.synalm( (cltt, clee, clbb, clte), new=True, lmax=lmax)
if smear:
if (beam is None) or (beamP is None) :
hdulist = fits.open(data_path + 'HFI_RIMO_Beams-100pc_R2.00.fits')
beam = hdulist[beam_index['{}'.format(frequency)]].data.NOMINAL[0][:lmax+1]
beamP = hdulist[beam_index['{}P'.format(frequency)]].data.NOMINAL[0][:lmax+1]
hp.sphtfunc.almxfl(Tlm, beam, inplace=True)
hp.sphtfunc.almxfl(Elm, beamP, inplace=True)
hp.sphtfunc.almxfl(Blm, beamP, inplace=True)
if nomap:
return Tlm,Elm,Blm
Tmap = hp.alm2map( Tlm, nside )
Qmap, Umap = hp.alm2map_spin( (Elm, Blm), nside, 2, lmax=lmax)
if save:
hp.write_map([Tmap,Qmap,Umap],data_path + filename)
return Tmap, Qmap, Umap
def make_healpix_map_for_energy_band(energy_band, order):
log.info(f'Making HEALPix map for energy band: {energy_band} and order: {order}')
# Select events in energy band
table = Table.read('input_data/fermi_hgps_events_selected.fits.gz', hdu=1)
energy = table['ENERGY'].quantity.to('GeV').value
mask = (energy_band['min'] <= energy) & (energy < energy_band['max'])
table = table[mask]
log.info(f'Number of events: {len(table)}')
# Bin the events into a HEALPix counts map
nside = hp.order2nside(order + shift_order)
ipix = hp.ang2pix(
nside=nside, nest=True, lonlat=True,
theta=table['L'], phi=table['B'],
)
npix = hp.nside2npix(nside)
log.debug(f'Number of pixels: {npix}')
resolution = np.rad2deg(hp.nside2resol(nside))
log.debug(f'Pixel resolution: {resolution} deg')
image = np.bincount(ipix, minlength=npix)
image = image.astype('float32')
# TODO: smoothing the HEALPix map with default setting is very slow.
# Maybe chunk the data into local WCS maps and then stitch back together?
# For now: no smoothing
# image = hp.smoothing(image, sigma=np.deg2rad(0.1))
path = DATA_DIR / 'maps' / 'Fermi10GeV_healpix_maps' / 'energy_{min}_{max}.fits.gz'.format_map(energy_band)
path.parent.mkdir(exist_ok=True, parents=True)
log.info(f'Writing {path}')
hp.write_map(str(path), image, coord='G', nest=True)
def anafast(m, m2=None, gal_cut = 30, lmax = None):
'''Utility to run anafast by Healpix'''
healpy.write_map('tempmap.fits', m, nest = False)
config_filename = 'anafastconfig.txt'
config = ConfigObj()
config.filename = config_filename
config['simul_type'] = 1
if gal_cut:
config['theta_cut_deg'] = gal_cut
if lmax:
config['nlmax'] = lmax
config['infile'] = 'tempmap.fits'
if not m2 is None:
healpy.write_map('tempmap2.fits', m2, nest = False)
config['infile2'] = 'tempmap2.fits'
config['outfile'] = 'tempcl.fits'
config['won'] = 0
config.write()
if os.path.exists('tempcl.fits'):
os.remove('tempcl.fits')
callstring = 'anafast --double %s' % config_filename
subprocess.call(callstring, shell=True)
cl = pyfits.open('tempcl.fits')[1].data.field('TEMPERATURE')
os.remove('tempcl.fits')
return cl
def obspix2mask(obspix, nside, fname=None):
"""
From the observed pixels to a binary mask, (``mask[obspix]=1 , 0 elsewhere``)
**Parameters**
- ``osbpix``:{array}
pixels observed during the scanning of the telescope and considered
as not pathological (ordering in the HEALPIX pixelization).
- ``nside``: {int}
Healpix parameter to define the pixelization grid of the map
- ``fname``:{str}
path to the fits file to write the map, if set it writes onto the file
**Returns**
- mask :{array}
"""
mask = np.zeros(hp.nside2npix(nside))
mask[obspix] = 1
if not fname is None:
hp.write_map(fname, mask)
return mask
def see_mapper(catalog_dir, nside, out_map):
# create empty map
hmap = np.zeros(hp.nside2npix(nside))
npix = hp.nside2npix(nside)
pix_seeing = np.zeros(npix)
pix_totalcounts = np.zeros(npix)
for cat in listdir(catalog_dir):
if cat.endswith(".csv") and cat.startswith("with"):
# read catalog, cols [ra,dec,psffwhm_i]
c = pandas.read_csv(join(catalog_dir, cat), sep=',', header=0, dtype={'ra' : np.float64, 'dec' : np.float64, "psffwhm_i" : np.float64}, engine=None, usecols=[1,2,292])
ra = c["ra"]
dec = c["dec"]
seeing = c["psffwhm_i"]
# generate object pixel_IDs & pixel_counts
theta = np.deg2rad(90.0 - dec)
phi = np.deg2rad(ra)
pix_IDs = np.array(hp.ang2pix(nside, theta, phi, nest=False))
pix_counts = np.bincount(pix_IDs, minlength=npix)
assert len(pix_counts) == npix, ("pixel numbers mismatched")
# calculate "total" seeing in each pixel
for (i, pix) in enumerate(pix_IDs):
pix_seeing[pix] += seeing[i]
pix_totalcounts[pix] += 1
del c, ra, dec, seeing, pix_counts, pix_IDs
gc.collect()
pix_avg_seeing = pix_seeing/pix_totalcounts
# map seeing
hp.write_map(out_map, pix_avg_seeing) # CHANGE FILENAMES????
def main(catalog_dir, nside, out_dir):
# define map resolution, create map of zeros
assert hp.isnsideok(nside), ("nside must be a power of 2")
npix = hp.nside2npix(nside)
hmap = np.zeros(npix)
# create destination directory
if not isdir(out_dir):
mkdir(out_dir)
else:
assert listdir(out_dir) == [], ("out_dir already exists/has content, choose a new destination directory")
# create count maps
mapper1(catalog_dir, nside, out_dir)
# merge count maps
for cmap in listdir(out_dir):
if cmap.endswith(".fits"):
m = hp.read_map(join(out_dir, cmap))
hmap += m
# assign filename & write final map
if not all(x == 0 for x in hmap):
out_filename = basename(normpath(catalog_dir)) + "_" + str(nside) + "cmap.fits"
hp.write_map(join(out_dir, out_filename), hmap)
else:
print("empty map")
return None
def generate_gsm2016_map(args):
filename, freq = args
gsm_2016 = GlobalSkyModel2016(freq_unit='MHz', unit='MJysr')
gsm_2016.generate(freq)
generatged_map_data_k = jysr2k(gsm_2016.generated_map_data * 1e6, 150)
hp.write_map(filename, generatged_map_data_k, coord='G',
column_units='K', fits_IDL=False, overwrite=True)
def plot_coldgas(z):
#firstfile = 0
#lastfile = 127
config = {}
try:
gal
except NameError:
gal = {}
nTrees = {}
nGals = {}
nTreeGals = {}
r = {}
theta = {}
phi = {}
for i in range(len(model_names)):
index = model_names[i]
if index[:4] == "lgal":
zz = "%10.2f"%(z)
elif index[:4] == "sage":
zz = "%10.3f"%(z)
file_prefix = "model_z"+zz.strip()
if not index in gal:
(nTrees[index],nGals[index],nTreeGals[index],gal[index]) = read_lgal.readsnap_lgal_advance(model_paths[i],file_prefix,0,511,filter[i],dt[i],1)
R = numpy.empty(nGals[index]*8,dtype=c_float)
pix = numpy.empty(nGals[index]*8,dtype=numpy.int64)
pixmap = numpy.zeros(healpy.nside2npix(NSIDE),dtype=numpy.float64)
# I want the array to be Fortran-like array
# to be used as ([x],[y],[z]) in Fortran code
pos = numpy.ascontiguousarray(gal[index]['Pos'])
pos_sphere = numpy.empty((nGals[index]*8,3),dtype=numpy.float32,order='C')
print pos.flags
print pos_sphere.flags
print pos
index_out = 0
N = nGals[index]
print N
mymodule.make_sphere(c_int(nGals[index]),c_float(500.0),pos,pos_sphere)
print pos_sphere
return
for i in range(2):
for j in range(2):
for k in range(2):
index_in = 0
while (index_in < N):
#print pos_tmp[index][0:3] , pos[index_in][0:3]
pos_tmp = pos[index_in,0:3]-500.*numpy.array([i,j,k])
R[index_out] = numpy.sqrt(pos_tmp[0]*pos_tmp[0]+pos_tmp[1]*pos_tmp[1]+pos_tmp[2]*pos_tmp[2])
pix[index_out] = healpy.pixelfunc.vec2pix(NSIDE,pos_tmp[0],pos_tmp[1],pos_tmp[2])
if ((R[index_out] >1) & (R[index_out] < 500.0)):
pixmap[pix[index_out]] += 1.0
index_in += 1
index_out += 1
healpy.write_map("my_map_full_500.fits", pixmap/numpy.sum(pixmap))
def main():
"""
This is the main routine.
"""
h_nside=512 # The same value a bayesstar.fits
smoothing=0.01 # Smooth the resulting map to 0.01 radians with a Gaussian
hubbleconstant=72
speedoflight=3E5
filenameCat = 'XSC_Completed.tbl.gz'
RA,DEC,JMAG,HMAG,KMAG = np.loadtxt(filenameCat,skiprows= 50,
usecols = (0,1,3,4,5),
dtype=[('f0',float),
('f1',float),
('f2',float),
('f3',float),
('f4',float)], unpack = True)
MK_Star = -24.0
DIST = np.power(10,(KMAG-MK_Star)/5)*1E-05
REDSHIFT = (DIST*hubbleconstant)/speedoflight
print("Interval of K MAG = ",min(KMAG)," - ",max(KMAG))
print("Interval of distances [Mpc] = ",min(DIST)," - ",max(DIST))
print("Interval of redshift = ",min(REDSHIFT)," - ",max(REDSHIFT))
# Select Galaxies by redshift under the assumption of MK=MK_Star
for rmin in np.arange(4)*0.01:
rmax=rmin+0.01
if rmin == 0:
kmin=0
else:
kmin=5*np.log10(rmin/hubbleconstant*speedoflight*1E5)+MK_Star
kmax=5*np.log10(rmax/hubbleconstant*speedoflight*1E5)+MK_Star
galpixels_Range= np.zeros(hp.nside2npix(h_nside))
include_me = np.logical_and((REDSHIFT > rmin),
np.logical_and((REDSHIFT<rmax),
(KMAG != 0.0)))
ra_Range = RA[include_me]
dec_Range = DEC[include_me]
pix_num_Range = (DeclRaToIndex(dec_Range,ra_Range,h_nside))
galpixels_Range[pix_num_Range]+=1
print("Number of objects with %g < z < %g : %d" % (rmin,rmax,len(ra_Range)))
map = hp.sphtfunc.smoothing(galpixels_Range,sigma = smoothing)
hp.write_map("%g-%g_raw.fits" % (rmin,rmax),galpixels_Range)
hp.write_map("%g-%g.fits" % (rmin,rmax),map)
hp.mollview(map,coord='C',rot = [0,0.3], title='Relative Surface Density of Galaxies: %0.1f < K < %0.1f (%g < z < %g)' % (kmin,kmax,rmin,rmax), unit='prob',xsize = 2048)
hp.graticule()
plt.savefig("%g-%g.png" % (rmin,rmax))
plt.show()
def func(nwrite, nread):
with tempfile.TemporaryFile('a+b') as tmpfile:
write_map(tmpfile, np.arange(12*16), nest=nwrite)
tmpfile.seek(0)
actual = read_map(tmpfile, nest=nread)
with tempfile.NamedTemporaryFile('a+b') as tmpfile:
hp.write_map(tmpfile.name, np.arange(12*16), nest=nwrite)
expected = hp.read_map(tmpfile.name, nest=nread)
assert_equal(expected, actual)
def write_fits(self, filename):
""" Write out map data as FITS file.
Parameters
----------
filename: str
file name for output FITS file
"""
hp.write_map(filename, self.generated_map_data, column_units=self.unit)
def get_fore_integral_flux_map(fore_files_list, e_min, e_max):
"""Returns the foreground map integrated between e_min and e_max
A powerlaw is assumed fore the foregriunf energy spectrum, hence
the interpolation between 2 given maps at given energies (given
by the model) is done in logarithmic scales.
fore_files_list: list of str
Ordered list of the foreground files (one for each energy)
e_min: float
the min of the energy bin
e_max: float
the max of the energy bin
"""
input_file = os.path.join(FT_DATA_FOLDER, 'models/gll_iem_v06.fits')
if not os.path.exists(input_file):
abort("Map %s not found!"%input_file)
frmaps = pf.open(input_file)
fore_en = []#np.array([x[0] for x in frmaps['ENERGIES'].data])
for ff in fore_files_list:
m = re.search(FORE_EN, ff)
en = int(m.group(0).replace('_', '').replace('.', ''))
fore_en.append(en)
fore_en = np.array(fore_en)
out_name = fore_files_list[0].replace('_%i.fits'%fore_en[0],
'_%d-%d.fits'%(e_min, e_max))
if os.path.exists(out_name):
logger.info('ATT: file %s already exists and returned...'%out_name)
fore_map = hp.read_map(out_name)
return fore_map
else:
logger.info('Computing the integral flux of the foreground model...')
logger.info('...between %.2f - %.2f'%(e_min, e_max))
fore_emin_sx, fore_emin_dx = find_outer_energies(e_min, fore_en)
fore_emax_sx, fore_emax_dx = find_outer_energies(e_max, fore_en)
fore_emin_sx_ind = np.where(fore_en == fore_emin_sx)[0]
fore_emin_dx_ind = np.where(fore_en == fore_emin_dx)[0]
fore_emax_sx_ind = np.where(fore_en == fore_emax_sx)[0]
fore_emax_dx_ind = np.where(fore_en == fore_emax_dx)[0]
fore_fmin_sx = hp.read_map(fore_files_list[fore_emin_sx_ind])
fore_fmin_dx = hp.read_map(fore_files_list[fore_emin_dx_ind])
fore_fmax_sx = hp.read_map(fore_files_list[fore_emax_sx_ind])
fore_fmax_dx = hp.read_map(fore_files_list[fore_emax_dx_ind])
m1 = (np.log10(fore_fmin_sx)-np.log10(fore_fmin_dx))/ \
(np.log10(fore_emin_sx)-np.log10(fore_emin_dx))
m2 = (np.log10(fore_fmax_sx)-np.log10(fore_fmax_dx))/ \
(np.log10(fore_emax_sx)-np.log10(fore_emax_dx))
logfore1 = m1*(np.log10(e_min)-np.log10(fore_emin_sx))+ \
np.log10(fore_fmin_sx)
logfore2 = m2*(np.log10(e_max)-np.log10(fore_emax_sx))+ \
np.log10(fore_fmax_sx)
fore1 = 10**(logfore1)
fore2 = 10**(logfore2)
fore_integ = np.sqrt(fore1*fore2)*(e_max - e_min)
hp.write_map(out_name, fore_integ)
logger.info('Created file %s'%out_name)
return fore_integ
def reorganize_map(mapin, obspix, npix, nside, pol, fname=None):
"""
From the solution map of the preconditioner to a Healpix map.
It specially splits the input array ``mapin`` which is a IQU
for a polarization analysis in to 3 arrays ``i,q,u``.
**Parameters**
- ``mapin``:{array}
solution array map (``size=npix*pol``);
- ``obspix``:{array}
array containing the observed pixels in the Healpix ordering;
- ``npix``:{int}
- ``nside``: {int}
the same as in ``obspix2mask``;
- ``pol``:{int}
- ``fname``:{str}
**Returns**
- healpix_map:{list of arrays}
pixelized map with Healpix.
"""
healpix_npix = hp.nside2npix(nside)
if pol == 3:
healpix_map = np.zeros(healpix_npix * pol).reshape((healpix_npix, pol))
i = mapin[np.arange(0, npix * 3, 3)]
q, u = mapin[np.arange(1, npix * 3, 3)], mapin[np.arange(2, npix * 3, 3)]
m = np.where(q != 0.0)[0]
healpix_map[obspix, 0] = i
healpix_map[obspix, 1] = q
healpix_map[obspix, 2] = u
hp_list = [healpix_map[:, 0], healpix_map[:, 1], healpix_map[:, 2]]
if pol == 2:
healpix_map = np.zeros(healpix_npix * pol).reshape((healpix_npix, pol))
q, u = mapin[np.arange(0, npix * pol, 2)], mapin[np.arange(1, npix * pol, pol)]
healpix_map[obspix, 0] = q
healpix_map[obspix, 1] = u
hp_list = [healpix_map[:, 0], healpix_map[:, 1]]
elif pol == 1:
healpix_map = np.zeros(healpix_npix)
healpix_map[obspix] = mapin
hp_list = healpix_map
if not fname is None:
hp.write_map(fname, hp_list)
return hp_list
def remove_dipole(m, gal_cut = 30):
#module abs path
abspath = os.path.dirname(__file__)
if os.path.exists('tempmap.fits'):
os.remove('tempmap.fits')
healpy.write_map('tempmap.fits',m,nest = False)
callstring = 'idl %s/fixmap.pro -IDL_QUIET 1 -quiet -args tempmap.fits %d' % (abspath,gal_cut)
subprocess.call(callstring, shell=True)
out = healpy.read_map('no_dipole_tempmap.fits', nest=True)
os.remove('no_dipole_tempmap.fits')
return out
def map_generator():
#Constructing maps...............................
#if not os.path.exists('./map'):
# os.makedirs('./map')
#Star map
if(map_list['star'] == True): map['star'] = hp.read_map(star_map_file)[mpix2hpix]
#Galaxy map
if((map_list['gal'] == True) or (map_list['odds'] == True)):
for bin in zbin:
map['gal'][zbintag(bin)] = {}
i_eff = 0
for od in od_cut:
gal_map = np.zeros(N_mpix)
mask = cut(bin, od, cat['p']['val']['zp'], cat['p']['val']['od'])
mpix = cat['p']['val']['mpix'][mask]
for i in mpix:
if(i >= 0): gal_map[i] += 1
map['gal'][zbintag(bin)][odtag(eff_cut[i_eff])] = gal_map
if(map_list['gal'] == True): hp.write_map(folder_out + 'map/map_gal' + nside_tag + '_' + zbintag(bin) + '_' + odtag(eff_cut[i_eff]) + '.fits', np.append(gal_map, 0)[hpix2mpix])
i_eff += 1
#Odds map
if(map_list['odds'] == True):
for bin in zbin:
mask = cut(bin, 0., cat['p']['val']['zp'], cat['p']['val']['od'])
od_map = np.zeros(N_mpix)
n_map = map['gal'][zbintag(bin)][odtag(0.0)]
mpix = cat['p']['val']['mpix'][mask]
odds = cat['p']['val']['od'][mask]
for i in range(len(mpix)):
if(mpix[i] >= 0): od_map[mpix[i]] += odds[i]
for i in range(N_mpix):
if(n_map[i] != 0): od_map[i] /= n_map[i]
od_map_corr = np.copy(od_map)
for i in range(N_mpix):
if(n_map[i] == 0):
i_vec = hp.pix2vec(nside, mpix2hpix[i])
nest = hpix2mpix[hp.query_disc(nside, i_vec, 1 * (np.pi/ 180))]
nest = nest[nest >= 0]
o = 0
n = 0
for j in nest:
o += od_map[j]
if (od_map[j] > 0.00000001): n += 1
o /= float(n)
od_map_corr[i] = o
map['odds'][zbintag(bin)] = od_map_corr
hp.write_map(folder_out + 'Map/od_map' + nside_tag + zbintag(bin) + '.fits', np.append(od_map_corr,0)[hpix2mpix])
def simulate_noise(npix=50331648, frequency=100,
save=True, filename='test_noise100.fits'):
I = np.random.standard_normal(npix)
Q = np.random.standard_normal(npix)
U = np.random.standard_normal(npix)
L = np.load(data_path + 'HFI_SkyMap_{}_2048_R2.02_full_cholesky.npy'.format(frequency), 'r')
I, Q, U = L_dot_rand_map(L,I,Q,U,npix)
if save:
hp.write_map(filename,[I,Q,U])
return I, Q, U
def mapper1(catalog_dir, nside, out_dir):
# create empty map
hmap = np.zeros(hp.nside2npix(nside))
npix = hp.nside2npix(nside)
num_s = 0
for cat in listdir(catalog_dir):
if cat.endswith(".csv") and cat.startswith("with"):
# read catalog
c = pandas.read_csv(join(catalog_dir, cat), sep=',', header=0, dtype={'ra' : np.float64, 'dec' : np.float64, 'modelMag_i' : np.float64, 'modelMag_r' : np.float64, 'extinction_i' : np.float64, 'extinction_r' : np.float64}, engine=None, usecols=['ra', 'dec', 'clean', 'type', 'modelMag_i', 'modelMag_r', 'extinction_i'. 'extinction_r'])
ra = c["ra"]
dec = c["dec"]
i = np.array(c["modelMag_i"] - c["extinction_i"])
r = np.array(c["modelMag_r"] - c["extinction_r"])
r_cut = np.where((r > 18.0) & (r < 18.5), True, False)
i_cut = i < 21.3
cleancut = c["clean"] == True
typecut = c["type"] == 6
totalcut = cleancut & typecut & r_cut & i_cut
ra = ra[totalcut]
dec = dec[totalcut]
# ifib2 = np.array(ifib2[totalcut])
# star count
num_s += len(ra)
# generate theta/phi vectors
theta = np.deg2rad(90.0 - dec)
phi = np.deg2rad(ra)
# generate corresponding pixel_IDs
pix_IDs = hp.ang2pix(nside, theta, phi, nest=False)
# distribute stars according to pixel_ID
cmap = np.bincount(pix_IDs, minlength=npix)
assert len(cmap) == npix, ("pixel numbers mismatched")
# sum to hmap
hmap = cmap
# assign filenames & write to file
out_filename = "countmap_" + cat[:-4] + ".fits"
hp.write_map(join(out_dir, out_filename), hmap)
del c, ra, dec, cleancut, typecut, r_cut, i_cut
gc.collect()
# print("num_s =", num_s)
# count = open(join(out_dir, "count.txt"), "w")
# count.write(str(num_s))
# count.close()
return None
outbase += '_gaia_%(version)s'%kwargs
elif opts.type == 'rms':
func = rms_photometry
outbase += '_rms'
else:
msg = "Unrecognized type: %s"%args.type
raise Exception(msg)
results = utils.multiproc(func,args,kwargs)
#results = [func(*a,**kwargs) for a in args]
hpxmap = blank(nside)
if None in results:
print("WARNING: %i processes failed..."%results.count(None))
for pix,stat in [r for r in results if r is not None]:
hpxmap[pix] = stat
hpxmap = np.ma.MaskedArray(hpxmap,np.isnan(hpxmap),fill_value=np.nan)
hpxmaps[band] = hpxmap
outfile = join(outdir,outbase+'_%s_n%i.fits'%(band,nside))
print("Writing %s..."%outfile)
hp.write_map(outfile,hpxmap,overwrite=True)
q = [5,50,95]
p = np.percentile(hpxmap.compressed(),q)
print("Global Median Photometry:")
print('%s (%s%%)'%(p,q))
plt.ion()
def clean_maps(k, fn, sdir):
testmap = hp.read_map(f'{fn}maps_sky_signal.fits', field=np.arange(12), verbose=False)
Qs = testmap[::2, sat_mask>0]
Us = testmap[1::2, sat_mask>0]
skymaps = np.array([np.transpose(Qs), np.transpose(Us)])
nu_ref_sync_p=23.
beta_sync_fid=-3.
curv_sync_fid=0.
nu_ref_dust_p=353.
beta_dust_fid=1.5
temp_dust_fid=19.6
spec_i=np.zeros([2, npix]);
spec_o=np.zeros([2, npix]);
amps_o=np.zeros([3, 2, npix]);
cova_o=np.zeros([6, 2, npix]);
bs=beta_sync_fid; bd=beta_dust_fid; td=temp_dust_fid; cs=curv_sync_fid;
sbs=3.0; sbd=3.0;
spec_i[0]=bs; spec_i[1]=bd
fixed_pars={'nu_ref_d':nu_ref_dust_p,'nu_ref_s':nu_ref_sync_p,'T_d':td}
var_pars=['beta_s','beta_d']
var_prior_mean=[bs,bd]
var_prior_width=[sbs,sbd]
sky_true=sky.SkyModel(['syncpl', 'dustmbb', 'unit_response'])
nus = [27., 39., 93., 145., 225., 280.]
bps=np.array([{'nu':np.array([n-0.5,n+0.5]),'bps':np.array([1])} for n in nus])
instrument=ins.InstrumentModel(bps)
ml=mpl.MapLike({'data': skymaps,
'noisevar':np.ones_like(skymaps),
'fixed_pars':fixed_pars,
'var_pars':var_pars,
'var_prior_mean':var_prior_mean,
'var_prior_width':var_prior_width,
'var_prior_type':['tophat' for b in var_pars]},
sky_true,
instrument)
sampler_args = {
"method" : 'Powell',
"tol" : None,
"callback" : None,
"options" : {'xtol':1E-4,'ftol':1E-4,'maxiter':None,'maxfev':None,'direc':None}
}
rdict = clean_pixels(ml, run_minimize, **sampler_args)
Sbar = ml.f_matrix(rdict['params_ML']).T
Sninv = np.linalg.inv(np.dot(Sbar.T, Sbar))
P = np.diag([1., 1., 0.])
Q = np.identity(6) - Sbar.dot(P).dot(Sninv).dot(Sbar.T)
reducedmaps = np.einsum('ab, cdb', Q, skymaps).reshape((12, -1))
filled_maps = np.zeros((12, hp.nside2npix(nside)))
filled_maps[:, sat_mask>0] = reducedmaps
np.savez(f'{sdir}{sname}_hybrid_params_{k}', params=rdict['params_ML'], Sbar=Sbar, Q=Q)
hp.write_map(f'{sdir}{sname}_residualmaps_{k}.fits', filled_maps, overwrite=True)
return
args = p.parse_args()
if args.infiles is None:
raise ValueError('Input files must be specified')
if args.outfile is None:
raise ValueError('Outfile must be specified')
else:
comp.check_output_dir(args.outfile)
# Read in all the input maps
data_maps = []
ref_maps = []
local_maps = []
for f in args.infiles:
data_map, ref_map, local_map = hp.read_map(f, range(3), verbose=False)
data_maps.append(data_map)
ref_maps.append(ref_map)
local_maps.append(local_map)
# Merge maps
merged_data = np.sum(data_maps, axis=0)
merged_ref = np.sum(ref_maps, axis=0)
merged_local = np.sum(local_maps, axis=0)
hp.write_map(args.outfile, (merged_data, merged_ref, merged_local),
coord='C')
print('Merged maps successfully saved, deleting unmerged maps')
for f in args.infiles:
os.remove(f)
'simCMB01.fits', 'simCMB02.fits', 'simCMB03.fits', 'simCMB04.fits',
'simCMB05.fits', 'simCMB06.fits', 'simCMB07.fits', 'simCMB08.fits',
'simCMB09.fits', 'simCMB10.fits'
] #all NSIDE=1024
#iswFile='/shared/Data/PSG/hundred_point/ISWmap1024_RING_din1_R010.fits' #NSIDE=1024, DeltaT/T
iswFile = '/shared/Data/PSG/hundred_point/ISWmap_RING_R010.fits' #NSIDE=64, DeltaT
nAmps = 10
amplitudes = np.logspace(-1, 2, nAmps)
ampTags = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
nested = False
print 'reading map ', iswFile
isw = hp.read_map(iswFile, nest=nest)
for cmbFile in cmbFiles:
print 'reading map ', cmbFile
cmb = hp.read_map(mapDirectory + cmbFile, nest=nested)
# rebin to NSIDE=64
if nested:
cmb = hp.ud_grade(cmb, 64, order_in='NESTED', order_out='NESTED')
else:
cmb = hp.ud_grade(cmb, 64, order_in='RING', order_out='RING')
for ampNum in range(nAmps):
myCMB = cmb + isw * amplitudes[ampNum]
hp.write_map(mapDirectory + cmbFile[:-5] + ampTags[ampNum] + '.fits',
myCMB,
nest=nested,
coord='G')
print 'done'
data = comm.bcast(data, root=0)
n2zeros = data * 0 #0,0,nan,nan......
index = np.arange(len(data))
nIQU = np.zeros((3, len(data)))
#a = np.random.rand()
for i in index[n2zeros == 0]: #full_ali map, without mask out the edge.
nIQU[0][i] = np.random.normal(0, data[i])
nIQU[1][i] = np.random.normal(0, data[i] * np.sqrt(2))
nIQU[2][i] = np.random.normal(0, data[i] * np.sqrt(2))
#print(nIQU)
hp.write_map(
'/smc/jianyao/Ali_maps/mpitest/noise_realizations_95GHz_%s.fits' % (rank),
nIQU)
'''
### calculate the mean value and standard deviation of the noise power spectrum from different noise realizations.
lmax = 2000
noise_map = hp.read_map('/smc/jianyao/Ali_maps/Noise_realizations/95GHz/noise_realizations_95GHz_%s.fits'%(rank), field = None)
ali_ma = hp.read_map('/smc/jianyao/Ali_maps/ali_mask_wo_edge.fits')
noise_mask = Mask(noise_map)
nl = hp.anafast(noise_mask, nspec = 3, lmax = lmax)
if rank == 0:
def catsimPopulation(config,
tag,
mc_source_id_start=1,
n=5000,
n_chunk=100,
known_dwarfs=False):
""" Create a population of satellites and then simulate the stellar distributions for each.
Parameters
----------
config : configuration file or dictionary
tag : output name
mc_source_id_start : starting value of source id
n : number of satellites to simulate [5000]
n_chunk : number of satellites written in a file chunk
Returns
-------
None
"""
assert mc_source_id_start >= 1, "Starting mc_source_id must be >= 1"
assert n % n_chunk == 0, "Total number of satellites must be divisible by the chunk size"
nside_pix = 256 # NSIDE = 128 -> 27.5 arcmin, NSIDE = 256 -> 13.7 arcmin
if not os.path.exists(tag): os.makedirs(tag)
if isinstance(config, str): config = yaml.load(open(config))
assert config['survey'] in ['des', 'ps1', 'lsst']
infile_ebv = config['ebv']
infile_fracdet = config['fracdet']
infile_maglim_g = config['maglim_g']
infile_maglim_r = config['maglim_r']
infile_density = config['stellar_density']
range_distance = config.get('range_distance', [5., 500.])
range_stellar_mass = config.get('range_stellar_mass', [1.e1, 1.e6])
range_r_physical = config.get('range_r_physical', [1.e-3, 2.0])
range_ellipticity = config.get('range_ellipticity', [0.1, 0.8])
range_position_angle = config.get('range_position_angle', [0.0, 180.0])
choice_age = config.get('choice_age', [10., 12.0, 13.5])
choice_metal = config.get('choice_metal', [0.00010, 0.00020])
dwarf_file = config.get('known_dwarfs', None)
m_density = np.load(infile_density)
nside_density = hp.npix2nside(len(m_density))
m_fracdet = read_map(infile_fracdet, nest=False) #.astype(np.float16)
nside_fracdet = hp.npix2nside(len(m_fracdet))
m_maglim_g = read_map(infile_maglim_g, nest=False) #.astype(np.float16)
m_maglim_r = read_map(infile_maglim_r, nest=False) #.astype(np.float16)
m_ebv = read_map(infile_ebv, nest=False) #.astype(np.float16)
#m_foreground = healpy.read_map(infile_foreground)
mask = (m_fracdet > 0.5)
if known_dwarfs:
# Simulate from known dwarfs
if dwarf_file is None: raise Exception("Must provide known_dwarf file")
print("Simulating dwarfs from: %s" % dwarf_file)
area, population = ugali.simulation.population.knownPopulation(
dwarf_file, mask, nside_pix, n)
else:
# r_physical is azimuthally-averaged half-light radius, kpc
kwargs = dict(range_distance=range_distance,
range_stellar_mass=range_stellar_mass,
range_r_physical=range_r_physical,
range_ellipticity=[0.1, 0.8],
range_position_angle=[0.0, 180.0],
choice_age=[10., 12.0, 13.5],
choice_metal=[0.00010, 0.00020],
plot=False)
area, population = ugali.simulation.population.satellitePopulation(
mask, nside_pix, n, **kwargs)
population['id'] += mc_source_id_start
simulation_area = area
n_g22_population = np.tile(np.nan, n)
n_g24_population = np.tile(np.nan, n)
abs_mag_population = np.tile(np.nan, n)
surface_brightness_population = np.tile(np.nan, n)
extension_population = np.tile(np.nan, n)
difficulty_population = np.tile(0, n)
lon_array = []
lat_array = []
mag_1_array = []
mag_2_array = []
mag_1_error_array = []
mag_2_error_array = []
mag_extinction_1_array = []
mag_extinction_2_array = []
mc_source_id_array = []
for ii, mc_source_id in enumerate(population['id']):
print 'Simulating satellite (%i/%i) ... mc_source_id = %i' % (
ii + 1, n, mc_source_id)
print ' distance=%(distance).2e, stellar_mass=%(stellar_mass).2e, r_physical=%(r_physical).2e' % (
population[ii])
satellite = catsimSatellite(
config, population[ii]['lon'], population[ii]['lat'],
population[ii]['distance'], population[ii]['stellar_mass'],
population[ii]['r_physical'], population[ii]['ellipticity'],
population[ii]['position_angle'], population[ii]['age'],
population[ii]['metallicity'], m_maglim_g, m_maglim_r, m_ebv)
n_g22_population[ii] = satellite['n_g22']
n_g24_population[ii] = satellite['n_g24']
abs_mag_population[ii] = satellite['abs_mag']
extension_population[ii] = satellite['extension']
surface_brightness_population[ii] = satellite['surface_brightness']
# These objects are too extended and are not simulated
if (satellite['flag_too_extended']):
difficulty_population[ii] |= 0b0001
# We assume that these objects would be easily detected and
# remove them to reduce data volume
if (surface_brightness_population[ii] < 23.5) & (n_g22_population[ii] >
1e3):
difficulty_population[ii] |= 0b0010
# ADW 2019-08-31: I don't think these were implmented
#if (surface_brightness_population[ii]<25.)&(n_g22_population[ii]>1e2):
# difficulty_population[ii] |= 0b0010
#if (surface_brightness_population[ii]<28.)&(n_g22_population[ii]>1e4):
# difficulty_population[ii] |= 0b0100
#if (surface_brightness_population[ii]<30.)&(n_g22_population[ii]>1e5):
# difficulty_population[ii] |= 0b1000
# ADW: 2019-08-31: These were Keith's original cuts, which were too aggressive
#cut_easy = (surface_brightness_population[ii]<25.)&(n_g22_population[ii]>1.e2) \
# | ((surface_brightness_population[ii] < 30.) & (n_g24_population[ii] > 1.e4)) \
# | ((surface_brightness_population[ii] < 31.) & (n_g24_population[ii] > 1.e5))
#cut_hard = (surface_brightness_population[ii] > 35.) | (n_g24_population[ii] < 1.)
#cut_difficulty_population[ii] = ~cut_easy & ~cut_hard
#if cut_easy:
# difficulty_population[ii] += 1 # TOO EASY
#if cut_hard:
# difficulty_population[ii] += 2 # TOO HARD
#if flag_too_extended:
# difficulty_population[ii] += 3 # TOO EXTENDED
# Only write satellites that aren't flagged
if difficulty_population[ii] == 0:
lon_array.append(satellite['lon'])
lat_array.append(satellite['lat'])
mag_1_array.append(satellite['mag_1'])
mag_2_array.append(satellite['mag_2'])
mag_1_error_array.append(satellite['mag_1_error'])
mag_2_error_array.append(satellite['mag_2_error'])
mag_extinction_1_array.append(satellite['mag_extinction_1'])
mag_extinction_2_array.append(satellite['mag_extinction_2'])
mc_source_id_array.append(
np.tile(mc_source_id, len(satellite['lon'])))
else:
print ' difficulty=%i; satellite not simulated...' % difficulty_population[
ii]
# Concatenate the arrays
print("Concatenating arrays...")
lon_array = np.concatenate(lon_array)
lat_array = np.concatenate(lat_array)
mag_1_array = np.concatenate(mag_1_array)
mag_2_array = np.concatenate(mag_2_array)
mag_1_error_array = np.concatenate(mag_1_error_array)
mag_2_error_array = np.concatenate(mag_2_error_array)
mag_extinction_1_array = np.concatenate(mag_extinction_1_array)
mag_extinction_2_array = np.concatenate(mag_extinction_2_array)
mc_source_id_array = np.concatenate(mc_source_id_array)
# Now do the masking all at once
print("Fracdet masking...")
pix_array = ugali.utils.healpix.ang2pix(nside_fracdet, lon_array,
lat_array)
cut_fracdet = (np.random.uniform(size=len(lon_array)) <
m_fracdet[pix_array])
lon_array = lon_array[cut_fracdet]
lat_array = lat_array[cut_fracdet]
mag_1_array = mag_1_array[cut_fracdet]
mag_2_array = mag_2_array[cut_fracdet]
mag_1_error_array = mag_1_error_array[cut_fracdet]
mag_2_error_array = mag_2_error_array[cut_fracdet]
mag_extinction_1_array = mag_extinction_1_array[cut_fracdet]
mag_extinction_2_array = mag_extinction_2_array[cut_fracdet]
mc_source_id_array = mc_source_id_array[cut_fracdet]
# Create bonus columns
print("Creating bonus columns...")
distance_modulus_population = ugali.utils.projector.dist2mod(
population['distance'])
hpix_32_population = ugali.utils.healpix.ang2pix(
32, population['lon'],
population['lat']) # Make sure this matches the dataset
# Local stellar density
pixarea = hp.nside2pixarea(nside_density,
degrees=True) * 60.**2 # arcmin^2
density_population = m_density[ugali.utils.healpix.ang2pix(
nside_density, population['lon'],
population['lat'])] / pixarea # arcmin^-2
# Average fracdet within the azimuthally averaged half-light radius
#m_fracdet_zero = np.where(m_fracdet >= 0., m_fracdet, 0.)
#m_fracdet_zero = m_fracdet
# Azimuthally averaged half-light radius in degrees
r_half = np.degrees(
np.arctan2(population['r_physical'], population['distance']))
fracdet_half_population = meanFracdet(m_fracdet, population['lon'],
population['lat'], r_half)
fracdet_core_population = meanFracdet(m_fracdet, population['lon'],
population['lat'], 0.1)
fracdet_wide_population = meanFracdet(m_fracdet, population['lon'],
population['lat'], 0.5)
# Magnitude limits
nside_maglim = hp.npix2nside(len(m_maglim_g))
pix_population = ugali.utils.healpix.ang2pix(nside_maglim,
population['lon'],
population['lat'])
maglim_g_population = m_maglim_g[pix_population]
maglim_r_population = m_maglim_r[pix_population]
# E(B-V)
nside_ebv = hp.npix2nside(len(m_ebv))
pix_population = ugali.utils.healpix.ang2pix(nside_ebv, population['lon'],
population['lat'])
ebv_population = m_ebv[pix_population]
# Survey
survey_population = np.tile(config['survey'], len(population))
# Number of surviving catalog stars
n_catalog_population = np.histogram(mc_source_id_array,
bins=np.arange(
population['id'][0] - 0.5,
population['id'][-1] + 0.51))[0]
# Faked-up coadd_object_ids
coadd_object_id_array = []
for mc_source_id in population['id']:
coadd_object_id_array.append(
(1000000 * mc_source_id) + 1 +
np.arange(np.sum(mc_source_id == mc_source_id_array)))
# Assign negative numbers to distinguish from real objects
coadd_object_id_array = -1 * np.concatenate(coadd_object_id_array)
# Object ID assignment can get messed up if there are duplicate population ids
assert len(coadd_object_id_array) == len(mc_source_id_array)
# Population metadata output file
tbhdu = pyfits.BinTableHDU.from_columns([
pyfits.Column(name='RA',
format='E',
array=population['lon'],
unit='deg'),
pyfits.Column(name='DEC',
format='E',
array=population['lat'],
unit='deg'),
pyfits.Column(name='DISTANCE',
format='E',
array=population['distance'],
unit='kpc'),
pyfits.Column(name='DISTANCE_MODULUS',
format='E',
array=distance_modulus_population,
unit='kpc'),
pyfits.Column(name='STELLAR_MASS',
format='E',
array=population['stellar_mass'],
unit='Msun'),
pyfits.Column(name='R_PHYSICAL',
format='E',
array=population['r_physical'],
unit='kpc'),
pyfits.Column(name='N_G22',
format='J',
array=n_g22_population,
unit=''),
pyfits.Column(name='N_G24',
format='J',
array=n_g24_population,
unit=''),
pyfits.Column(name='N_CATALOG',
format='J',
array=n_catalog_population,
unit=''),
pyfits.Column(name='DIFFICULTY',
format='J',
array=difficulty_population,
unit=''),
pyfits.Column(name='ABS_MAG',
format='E',
array=abs_mag_population,
unit='mag'),
pyfits.Column(name='SURFACE_BRIGHTNESS',
format='E',
array=surface_brightness_population,
unit='mag arcsec^-2'),
pyfits.Column(name='EXTENSION',
format='E',
array=extension_population,
unit='deg'),
pyfits.Column(name='ELLIPTICITY',
format='E',
array=population['ellipticity'],
unit=''),
pyfits.Column(name='POSITION_ANGLE',
format='E',
array=population['position_angle'],
unit='deg'),
pyfits.Column(name='AGE',
format='E',
array=population['age'],
unit='Gyr'),
pyfits.Column(name='METAL_Z',
format='E',
array=population['metallicity'],
unit=''),
pyfits.Column(name='MC_SOURCE_ID',
format='K',
array=population['id'],
unit=''),
pyfits.Column(name='HPIX_32',
format='E',
array=hpix_32_population,
unit=''),
pyfits.Column(name='DENSITY',
format='E',
array=density_population,
unit='arcmin^-2'),
pyfits.Column(name='FRACDET_HALF',
format='E',
array=fracdet_half_population,
unit=''),
pyfits.Column(name='FRACDET_CORE',
format='E',
array=fracdet_core_population,
unit=''),
pyfits.Column(name='FRACDET_WIDE',
format='E',
array=fracdet_wide_population,
unit=''),
pyfits.Column(name='MAGLIM_G',
format='E',
array=maglim_g_population,
unit='mag'),
pyfits.Column(name='MAGLIM_R',
format='E',
array=maglim_r_population,
unit='mag'),
pyfits.Column(name='EBV', format='E', array=ebv_population,
unit='mag'),
pyfits.Column(name='SURVEY',
format='A12',
array=survey_population,
unit=''),
])
tbhdu.header.set('AREA', simulation_area, 'Simulation area (deg^2)')
print("Writing population metadata file...")
filename = '%s/sim_population_%s_mc_source_id_%07i-%07i.fits' % (
tag, tag, mc_source_id_start, mc_source_id_start + n - 1)
tbhdu.writeto(filename, overwrite=True)
# Write simulated catalogs
# Simulated catalog output needs to match the real data
# https://github.com/sidneymau/simple/blob/master/search_algorithm.py
# https://github.com/sidneymau/simple/blob/master/config.yaml
# /home/s1/kadrlica/projects/y3a2/dsphs/v2/skim/
# e.g., /home/s1/kadrlica/projects/y3a2/dsphs/v2/skim/y3a2_ngmix_cm_11755.fits
# for ii in range(0, len(d.formats)): print '\'%s\': [ , \'%s\'],'%(d.names[ii], d.formats[ii])
default_array = np.tile(-9999., len(mc_source_id_array))
if config['survey'] == 'des':
# Y3 Gold v2.0
key_map = odict([
('COADD_OBJECT_ID', [coadd_object_id_array, 'K']),
('RA', [lon_array, 'D']),
('DEC', [lat_array, 'D']),
('SOF_PSF_MAG_CORRECTED_G', [mag_1_array, 'D']),
('SOF_PSF_MAG_CORRECTED_R', [mag_2_array, 'D']),
('SOF_PSF_MAG_ERR_G', [mag_1_error_array, 'D']),
('SOF_PSF_MAG_ERR_R', [mag_2_error_array, 'D']),
('A_SED_SFD98_G', [mag_extinction_1_array, 'E']),
('A_SED_SFD98_R', [mag_extinction_2_array, 'E']),
('WAVG_MAG_PSF_G', [mag_1_array + mag_extinction_1_array, 'E']),
('WAVG_MAG_PSF_R', [mag_2_array + mag_extinction_2_array, 'E']),
('WAVG_MAGERR_PSF_G', [mag_1_error_array, 'E']),
('WAVG_MAGERR_PSF_R', [mag_2_error_array, 'E']),
('WAVG_SPREAD_MODEL_I', [default_array, 'E']),
('WAVG_SPREADERR_MODEL_I', [default_array, 'E']),
('SOF_CM_T', [default_array, 'D']),
('SOF_CM_T_ERR', [default_array, 'D']),
('FLAGS_GOLD', [np.tile(0, len(mc_source_id_array)), 'J']),
('EXTENDED_CLASS_MASH_SOF',
[np.tile(0, len(mc_source_id_array)), 'I']),
])
elif config['survey'] == 'ps1':
# PS1
key_map = odict([
('OBJID', [coadd_object_id_array, 'K']),
('RA', [lon_array, 'D']),
('DEC', [lat_array, 'D']),
#('UNIQUEPSPSOBID', [coadd_object_id_array, 'K']),
#('OBJINFOFLAG', [default_array, 'E']),
#('QUALITYFLAG', [np.tile(16, len(mc_source_id_array)), 'I']),
#('NSTACKDETECTIONS', [np.tile(99, len(mc_source_id_array)), 'I']),
#('NDETECTIONS', [np.tile(99, len(mc_source_id_array)), 'I']),
#('NG', [default_array, 'E']),
#('NR', [default_array, 'E']),
#('NI', [default_array, 'E']),
('GFPSFMAG', [mag_1_array + mag_extinction_1_array, 'E']),
('RFPSFMAG', [mag_2_array + mag_extinction_2_array, 'E']),
#('IFPSFMAG', [np.tile(0., len(mc_source_id_array)), 'E'], # Pass star selection
('GFPSFMAGERR', [mag_1_error_array, 'E']),
('RFPSFMAGERR', [mag_2_error_array, 'E']),
#('IFPSFMAGERR', [default_array, 'E']),
#('GFKRONMAG', [mag_1_array, 'E']),
#('RFKRONMAG', [mag_2_array, 'E']),
#('IFKRONMAG', [np.tile(0., len(mc_source_id_array)), 'E'], # Pass star selection
#('GFKRONMAGERR', [mag_1_error_array, 'E']),
#('RFKRONMAGERR', [mag_2_error_array, 'E']),
#('IFKRONMAGERR', [default_array, 'E']),
#('GFLAGS', [np.tile(0, len(mc_source_id_array)), 'I']),
#('RFLAGS', [np.tile(0, len(mc_source_id_array)), 'I']),
#('IFLAGS', [np.tile(0, len(mc_source_id_array)), 'I']),
#('GINFOFLAG', [np.tile(0, len(mc_source_id_array)), 'I']),
#('RINFOFLAG', [np.tile(0, len(mc_source_id_array)), 'I']),
#('IINFOFLAG', [np.tile(0, len(mc_source_id_array)), 'I']),
#('GINFOFLAG2', [np.tile(0, len(mc_source_id_array)), 'I']),
#('RINFOFLAG2', [np.tile(0, len(mc_source_id_array)), 'I']),
#('IINFOFLAG2', [np.tile(0, len(mc_source_id_array)), 'I']),
#('GINFOFLAG3', [np.tile(0, len(mc_source_id_array)), 'I']),
#('RINFOFLAG3', [np.tile(0, len(mc_source_id_array)), 'I']),
#('IINFOFLAG3', [np.tile(0, len(mc_source_id_array)), 'I']),
#('PRIMARYDETECTION', [default_array, 'E']),
#('BESTDETECTION', [default_array, 'E']),
#('EBV', [default_array, 'E']),
#('EXTSFD_G', [mag_extinction_1_array 'E']),
#('EXTSFD_R', [mag_extinction_2_array, 'E']),
#('EXTSFD_I', [default_array, 'E']),
('GFPSFMAG_SFD', [mag_1_array, 'E']),
('RFPSFMAG_SFD', [mag_2_array, 'E']),
('EXTENDED_CLASS', [np.tile(0, len(mc_source_id_array)), 'I']),
])
elif config[
'survey'] == 'lsst': # Keys make to match those in the GCRCatalog native_quantities
key_map = odict([
('objectId', [coadd_object_id_array, 'K']),
('coord_ra', [lon_array, 'D']),
('coord_dec', [lat_array, 'D']),
('mag_g', [mag_1_array + mag_extinction_1_array, 'E']),
('mag_r', [mag_2_array + mag_extinction_2_array, 'E']),
('magerr_g', [mag_1_error_array, 'D']),
('magerr_r', [mag_2_error_array, 'D']),
('mag_corrected_g', [mag_1_array, 'D']),
('mag_corrected_r', [mag_2_array, 'D']),
('extended_class', [np.tile(0, len(mc_source_id_array)), 'I']),
])
key_map['MC_SOURCE_ID'] = [mc_source_id_array, 'K']
print("Writing catalog files...")
for mc_source_id_chunk in np.split(
np.arange(mc_source_id_start, mc_source_id_start + n),
n // n_chunk):
outfile = '%s/sim_catalog_%s_mc_source_id_%07i-%07i.fits' % (
tag, tag, mc_source_id_chunk[0], mc_source_id_chunk[-1])
print(' ' + outfile)
sel = np.in1d(mc_source_id_array, mc_source_id_chunk)
columns = [
pyfits.Column(name=k, format=v[1], array=v[0][sel])
for k, v in key_map.items()
]
tbhdu = pyfits.BinTableHDU.from_columns(columns)
tbhdu.header.set('AREA', simulation_area, 'Simulation area (deg^2)')
tbhdu.header.set('IDMIN', mc_source_id_chunk[0],
'Minimum MC_SOURCE_ID')
tbhdu.header.set('IDMAX', mc_source_id_chunk[-1],
'Maximum MC_SOURCE_ID')
tbhdu.writeto(outfile, overwrite=True)
# Mask output file
print("Writing population mask file...")
outfile_mask = '%s/sim_mask_%s_cel_nside_%i.fits' % (
tag, tag, hp.npix2nside(len(mask)))
if not os.path.exists(outfile_mask):
hp.write_map(outfile_mask,
mask.astype(int),
nest=True,
coord='C',
overwrite=True)
os.system('gzip -f %s' % (outfile_mask))
def make_synch_diff_maps():
scale_to_30 = (30./28.4)**(-3.1)
scale_to_spass = (2.305/28.4)**(-3.1)
joint_synch_Q = hp.read_map('../'+dir+'/synch_Q_030_mean.fits')
joint_synch_U = hp.read_map('../'+dir+'/synch_U_030_mean.fits')
joint_Q_30 = scale_to_30*joint_synch_Q
joint_U_30 = scale_to_30*joint_synch_U
joint_Q_spass = scale_to_spass*joint_synch_Q
joint_U_spass = scale_to_spass*joint_synch_U
bp_030_Q = hp.read_map('../data/BP_synch_Q_n0064.fits')
bp_030_U = hp.read_map('../data/BP_synch_U_n0064.fits')
npipe_30_Q = hp.read_map('../data/npipe6v20_comm_synch_n0064_60arc_Q_rc1.fits')
npipe_30_U = hp.read_map('../data/npipe6v20_comm_synch_n0064_60arc_U_rc1.fits')
spass_Q = hp.read_map('../data/spass_rmrot_n0064_ring_masked.fits',field=1)
spass_U = hp.read_map('../data/spass_rmrot_n0064_ring_masked.fits',field=2)
bp_min_joint_Q = bp_030_Q - joint_Q_30
bp_min_joint_U = bp_030_U - joint_U_30
np_min_joint_Q = npipe_30_Q - joint_Q_30
np_min_joint_U = npipe_30_U - joint_U_30
spass_min_joint_Q = spass_Q - joint_Q_spass
spass_min_joint_U = spass_U - joint_U_spass
hp.write_map('../'+dir+'/npipe_minus_joint_Q_60arcmin_n0064.fits',np_min_joint_Q)
hp.write_map('../'+dir+'/npipe_minus_joint_U_60arcmin_n0064.fits',np_min_joint_U)
hp.write_map('../'+dir+'/BP_minus_joint_Q_60arcmin_n0064.fits',bp_min_joint_Q)
hp.write_map('../'+dir+'/BP_minus_joint_U_60arcmin_n0064.fits',bp_min_joint_U)
hp.write_map('../'+dir+'/spass_minus_joint_Q_60arcmin_n0064.fits',spass_min_joint_Q)
hp.write_map('../'+dir+'/spass_minus_joint_U_60arcmin_n0064.fits',spass_min_joint_U)
#!/usr/bin/env python
#
# hpm_np_to_fits.py
#
#
# Created by Danny Jacobs on 3/19/10.
# PAPER Project
#
"""
convert a txt file with a list of healpix values into a healpix fits format
"""
import aipy as a, numpy as n, pylab as p, math as m
import sys, optparse, healpy as hp
o = optparse.OptionParser()
#a.scripting.add_standard_options(o, cal=True)
o.add_option('--nest',
dest='nest',
action='store_true',
help="Switch from default ring mode to nest.")
opts, args = o.parse_args(sys.argv[1:])
for file in args:
outfile = '.'.join(file.split('.')[:-1]) + '.fits'
hpm = n.loadtxt(file, comments='#')
print file + ' > ' + outfile
hp.write_map(outfile, hpm, nest=opts.nest)
def test(nested=False, doPlot=False, nside=64, doTangent=False):
"""
Note that this is not a rigorous testing function
Purpose:
reads overmass files from overmass directory and creates ISW maps and masks
using overmass profiles
Args:
nested:
doPlot:
NSIDE: must be 64 or 1024
doTangent: set this to approximate arc lengths using tangent lines.
Default: false. Arc lengths are properly accounted for.
Returns:
writes ISW maps and masks to disk
"""
CMBtemp = 2.7260 # +-0.0013 K (WMAP) Fixen, 2009
# create comoving distance function
zVals, comDists = getComDist(zMax=1.0, nSteps=5000)
comovInterp = interp1d(zVals, comDists)
# load HEALpix coordinates file
print 'NSIDE=', nside, ' NESTED=', nested
longitudes, latitudes = getMapCoords(nside, nested)
# load GNS catalog coordinates
cgl, cgb, vgl, vgb = getGNScoords()
# collect filenames
overmassDirectory = '/Data/PSG/'
ISWDirectory = '/Data/PSG/hundred_point/'
directoryFiles = listdir(overmassDirectory)
overmassFiles = [file for file in directoryFiles if 'overmass' in file]
# just do one file for now
#overmassFiles = [file for file in overmassFiles if 'PSGplot060' in file]
#overmassFiles = [file for file in overmassFiles if 'PSGplot100' in file]
#overmassFiles = [file for file in overmassFiles if 'R010' in file]
#overmassFiles = [file for file in overmassFiles if 'R020' in file]
#overmassFiles = [file for file in overmassFiles if 'R030' in file]
#overmassFiles = [file for file in overmassFiles if 'R040' in file]
#overmassFiles = [file for file in overmassFiles if 'R050' in file]
#overmassFiles = [file for file in overmassFiles if 'R060' in file]
#overmassFiles = [file for file in overmassFiles if 'R070' in file]
#overmassFiles = [file for file in overmassFiles if 'R080' in file]
#overmassFiles = [file for file in overmassFiles if 'R090' in file]
#overmassFiles = [file for file in overmassFiles if 'R100' in file]
#overmassFiles = [file for file in overmassFiles if 'R110' in file]
#overmassFiles = [file for file in overmassFiles if 'R120' in file]
#overmassFiles = [file for file in overmassFiles if 'R130' in file]
#overmassFiles = [file for file in overmassFiles if 'R140' in file]
#overmassFiles = [file for file in overmassFiles if 'R150' in file]
#overmassFiles = [file for file in overmassFiles if 'R160' in file]
newProfile = False #True
newMap = True #False
# create healpix maps
#zList = [0.4,0.45,0.5,0.55,0.6,0.65,0.7,0.75]
zList = [0.52] # used by PSG for median of GNS catalog
rmax = 800 # Mpc, 2x PSGplot max
#rmax = 1200 # Mpc, twice the rmax of overmass profiles
npoints = 101 # number of points in the ISW profile
delta_z = 0.3 # for limits of integration when making ISW profile
cutoff = 0.02 # Maps extend to radius where amplitude = maxAmp*cutoff
# loop over zList to create maps at each redshift
for zCent in zList:
zStr = str(
zCent) # this is sloppy formatting. eg: Want "0.40", not "0.4"
print 'starting with z_cent = ' + zStr
D_comov = comovInterp(zCent)
print 'redshift: ', zCent, ', comoving dist: ', D_comov, ' Mpc'
for omFile in overmassFiles:
# get ISW profile
ISWProfileFile = 'ISWprofile_z' + zStr + omFile[
8:] # 'overmass' is at start of omFile and has 8 characters
if newProfile:
print 'reading file ', omFile
impactDomain, ISWRange = makeISWProfile(
overmassDirectory + omFile,
zCent,
ISWDirectory + ISWProfileFile,
rmax=rmax,
npoints=npoints,
delta_z=delta_z)
else:
print 'loading file ', ISWProfileFile
impactDomain, ISWRange = np.loadtxt(ISWDirectory +
ISWProfileFile,
unpack=True)
print 'impactDomain: ', impactDomain, ' Mpc'
print 'ISWRange: ', ISWRange, ' DeltaT/T'
if newMap:
# add point in outer region for kludgy extrapolation, just as in ISWprofile.clusterVoid.__init__
impactDomain = np.concatenate(
[impactDomain, [2 * impactDomain[-1]]])
ISWRange = np.concatenate(
[ISWRange,
[0]]) # ramps down to zero at r=2*impactDomain[-1]
# find cutoff radius at cutoff*100% of maximum amplitude
maxAmp = ISWRange[0]
impactLookup = interp1d(ISWRange,
impactDomain) #,kind='cubic')
print 'maxAmp, cutoff, product: ', maxAmp, cutoff, maxAmp * cutoff
maxRadius = impactLookup(maxAmp * cutoff)
print 'max radius: ', maxRadius, ' Mpc'
#doTangent = False
if doTangent: # for easier calculations, use maxRadius as arc length instead of tangential length
maxAngle = maxRadius / D_comov #radians
else: # use maxRadius as a chord length
maxAngle = 2 * np.arcsin(maxRadius / (2 * D_comov))
print 'radius for disc: ', maxAngle * 180 / np.pi, ' degrees'
# visually check accuracy of interpolation function
if doPlot:
# create ISW signal interpolation function
ISWinterp = interp1d(impactDomain,
ISWRange) # same line as in getCVmap
impactTest = np.linspace(0, maxRadius, 100)
ISWTest = ISWinterp(impactTest)
plt.plot(
impactDomain,
ISWRange) # data points used to make interpolation
plt.plot(impactTest,
ISWTest) # from interpolation function
plt.xlabel('r [Mpc]')
plt.ylabel('ISW: DeltaT / T')
plt.show()
numCV = 50
#numCV = 2
mapArray = np.zeros(hp.nside2npix(nside))
mask = np.zeros(hp.nside2npix(nside))
cCentralVec = glgb2vec(cgl,
cgb) #returns array of unit vectors
vCentralVec = glgb2vec(vgl,
vgb) #returns array of unit vectors
for cvNum in np.arange(numCV):
print 'starting cv number ', cvNum + 1
cIndices, cISW = getCVmap(nside,
cCentralVec[cvNum],
maxAngle,
latitudes,
longitudes,
impactDomain,
ISWRange,
D_comov,
nest=nested,
isVoid=False,
doTangent=doTangent)
mapArray[cIndices] += cISW
mask[cIndices] = 1
vIndices, vISW = getCVmap(nside,
vCentralVec[cvNum],
maxAngle,
latitudes,
longitudes,
impactDomain,
ISWRange,
D_comov,
nest=nested,
isVoid=True,
doTangent=doTangent)
mapArray[vIndices] += vISW
mask[vIndices] = 1
# 'overmass' is at start of omFile and has 8 characters; 'txt' is at end
if nside == 64:
ISWMap = 'ISWmap_RING_z' + zStr + omFile[8:-3] + 'fits'
hp.write_map(ISWDirectory + ISWMap,
mapArray * CMBtemp,
nest=nested,
coord='GALACTIC')
ISWMask = 'ISWmask_RING_z' + zStr + omFile[8:-3] + 'fits'
hp.write_map(ISWDirectory + ISWMask,
mask,
nest=nested,
coord='GALACTIC')
elif nside == 1024:
ISWMap = 'ISWmap_RING_1024_z' + zStr + omFile[8:-3] + 'fits'
hp.write_map(ISWDirectory + ISWMap,
mapArray * CMBtemp,
nest=nested,
coord='GALACTIC')
ISWMask = 'ISWmask_RING_1024_z' + zStr + omFile[
8:-3] + 'fits'
hp.write_map(ISWDirectory + ISWMask,
mask,
nest=nested,
coord='GALACTIC')
# cls are multiplied by l(l+1)/(2pi) so need to get rid of this constant [units are muK^2] cl *= 2. * np.pi / (l * (l + 1.)) # need to add cls for l = 0, 1 (i.e. l=0 => constant background and l=1 => dipole) l = np.concatenate([np.array([0., 1.]), l]) cl = np.concatenate([np.zeros(2), cl]) # see https://healpy.readthedocs.io/en/latest/generated/healpy.sphtfunc.synfast.html#healpy.sphtfunc.synfast # for additional parameters (such as adding a Gaussian smoothing, etc) nside, lmax = 2048, 1500 map_sim = hp.synfast(cl, nside, lmax=lmax) # saving maps as a fits file using healpy function, of course you could save this in anyway you want. filsize = 192Mb filename = 'maps/test_map.fits' hp.write_map(filename, map_sim) # opening maps (checking this works) map_sim = hp.read_map(filename) # plot simulated map hp.mollview(map_sim) plt.show() # measure cls from the simulated map cl_sim = hp.anafast(map_sim, lmax=lmax) cl_sim *= (l[:len(cl_sim)] * (l[:len(cl_sim)] + 1.)) / (2. * np.pi) cl *= (l * (l + 1.)) / (2. * np.pi) # plot input cls vs cls from simulated map plt.figure(figsize=(8, 6))
def save_jk_map(jk_map, fn):
'''Save jackknife map to fits file.'''
hp.write_map(fn, jk_map, overwrite=True)
print(':: Jackknife map saved to file: {}'.format(fn))
print "writing", outfile
#load the input CST txt file
#find the healpix indices corresponding to the theta/phi
#make a healpix map
D = n.loadtxt(args[0], skiprows=3)
theta = D[:, 0] * n.pi / 180
#CST will output either elev or phi. phi is zero at beam x=y=0, elev is zero at x=0,phi=0
if open(args[0]).readlines()[0].startswith('Elev'): theta += n.pi / 2
phi = D[:, 1] * n.pi / 180
#account for stupid CST full circle cuts
phi[theta < 0] += np.pi
theta[theta < 0] = np.abs(theta[theta < 0])
beam = D[:, 2] #beam amplitude in dB
if opts.rot90:
phi += n.pi / 2
if opts.flup:
theta = np.pi - theta
healpix_indexes = hpy.ang2pix(opts.nside, theta, phi)
hp_map = n.zeros(hpy.nside2npix(opts.nside))
hp_map[healpix_indexes] = beam
hp_map -= hp_map[0]
if opts.voltage:
hp_map = 10**(hp_map / 20.)
print "max/min", hp_map.max(), hp_map.min()
hpy.write_map(outfile, hp_map, fits_IDL=False)
print "Write successfull"
def make_cmb_sims(params):
""" Write cmb maps on disk
Parameters
----------
params: module contating all the simulation parameters
"""
nmc_cmb = params.nmc_cmb
nside = params.nside
smooth = params.gaussian_smooth
ch_name = [
'SO_SAT_27', 'SO_SAT_39', 'SO_SAT_93', 'SO_SAT_145', 'SO_SAT_225',
'SO_SAT_280'
]
freqs = sonc.Simons_Observatory_V3_SA_bands()
beams = sonc.Simons_Observatory_V3_SA_beams()
band_int = params.band_int
parallel = params.parallel
root_dir = params.out_dir
out_dir = f'{root_dir}/cmb/'
file_str = params.file_string
seed_cmb = params.seed_cmb
cmb_ps_file = params.cmb_ps_file
rank = 0
size = 1
if params.parallel:
from mpi4py import MPI
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
size = comm.Get_size()
if not os.path.exists(out_dir) and rank == 0:
os.makedirs(out_dir)
if cmb_ps_file:
print(cmb_ps_file)
cl_cmb = hp.read_cl(cmb_ps_file)
else:
cmb_ps_scalar_file = os.path.join(os.path.dirname(__file__),
'datautils/Cls_Planck2018_r0.fits')
cl_cmb_scalar = hp.read_cl(cmb_ps_scalar_file)
cmb_ps_tensor_r1_file = os.path.join(
os.path.dirname(__file__),
'datautils/Cls_Planck2018_tensor_r1.fits')
cmb_r = params.cmb_r
cl_cmb_tensor = hp.read_cl(cmb_ps_tensor_r1_file) * cmb_r
cl_cmb = cl_cmb_scalar + cl_cmb_tensor
nmc_cmb = math.ceil(nmc_cmb / size) * size
if nmc_cmb != params.nmc_cmb:
print_rnk0(f'WARNING: setting nmc_cmb = {nmc_cmb}', rank)
perrank = nmc_cmb // size
for nmc in range(rank * perrank, (rank + 1) * perrank):
if seed_cmb:
np.random.seed(seed_cmb + nmc)
nmc_str = str(nmc).zfill(4)
if not os.path.exists(out_dir + nmc_str):
os.makedirs(out_dir + nmc_str)
cmb_temp = hp.synfast(cl_cmb, nside, new=True, verbose=False)
file_name = f'cmb_{nmc_str}_{file_str}.fits'
file_tot_path = f'{out_dir}{nmc_str}/{file_name}'
hp.write_map(file_tot_path, cmb_temp, overwrite=True, dtype=np.float32)
os.environ["PYSM_LOCAL_DATA"] = f'{out_dir}'
sky = pysm3.Sky(nside=nside,
component_objects=[
pysm3.CMBMap(nside,
map_IQU=f'{nmc_str}/{file_name}')
])
for nch, chnl in enumerate(ch_name):
freq = freqs[nch]
fwhm = beams[nch]
cmb_map = sky.get_emission(freq * u.GHz)
cmb_map = cmb_map.to(u.uK_CMB,
equivalencies=u.cmb_equivalencies(freq *
u.GHz))
if smooth:
cmb_map_smt = hp.smoothing(cmb_map,
fwhm=np.radians(fwhm / 60.),
verbose=False)
else:
cmb_map_smt = cmb_map
file_name = f'{chnl}_cmb_{nmc_str}_{file_str}.fits'
file_tot_path = f'{out_dir}{nmc_str}/{file_name}'
hp.write_map(file_tot_path,
cmb_map_smt,
overwrite=True,
dtype=np.float32)
m[goodpix] /= np.sqrt(nh_LA[goodpix])
np.random.seed(seed)
t_SA, q_SA, u_SA = hp.synfast(
[
Nl_SA_T[channel], Nl_SA_P[channel], Nl_SA_P[channel], zeros, zeros,
zeros
],
nside=nside,
pol=True,
new=True,
verbose=False,
)
goodpix = np.where(nh_SA > 0)
badpix = np.where(nh_SA <= 0)
for m in [t_SA, q_SA, u_SA]:
m[badpix] = 0
m[goodpix] /= np.sqrt(nh_SA[goodpix])
# Write maps
hp.write_map(
"noise_SA_uKCMB_classical_nside%d_channel%d_seed%d.fits" %
(nside, channel, seed),
[t_SA, q_SA, u_SA],
)
hp.write_map(
"noise_LA_uKCMB_classical_nside%d_channel%d_seed%d.fits" %
(nside, channel, seed),
[t_LA, q_LA, u_LA],
)
# a low Nside.
from __future__ import division
import healpy as hp
import numpy as np
Ns = 1024 # Nside of origional map
mapsample = np.arange(hp.nside2npix(Ns))
masksample = np.ones_like(mapsample)
Ns_out = 32 # mask out pixels with Nside=32 in turn to creat Jackknife samples
mask_dg = hp.ud_grade(masksample, Ns_out)
jid = 0
for j in range(hp.nside2npix(Ns_out)):
if mask_dg[j] == 0:
continue
else:
print('Jack: ' + str(jid))
jackmask = np.ones(hp.nside2npix(Ns_out))
jackmask[j] = 0
jackmask_ud = hp.ud_grade(jackmask, Ns)
mask_jack = jackmask_ud * masksample
print jid
hp.write_map('mask_jack' + str(jid) + '_' + str(Ns) + '.fits',
mask_jack,
overwrite=True)
jid += 1
)
e_hp_hdu = fits.ImageHDU(DL07_paras, fits.Header(hp_header))
e_hp_hdu.header['UNIT'] = r"$M_{sun}/kpc^2$"
#-------------------------------------------------
# Draw the map
'''
hp.mollview(
DL07_paras/e_DL07_paras,
unit="S/N",
#norm = 'log',
nest=True,
min = 0,
max = 10,
)
hp.graticule()
plt.show()
'''
#-------------------------------------------------
# Save the SNR all-sky map
hp.write_map(
"SNR.fits",
DL07_paras / e_DL07_paras,
nest=True,
coord='G',
overwrite=True,
)
#-----------------------------------
# Measure time
elapsed_time = time.time() - start_time
print("Exiting Main Program, spending ", elapsed_time, "seconds.")
mps_no2 = np.transpose(mps_no2[:, 1:, :], axes=[1, 2, 0])
mps_nv = np.transpose(mps_nv[:, 1:, :], axes=[1, 2, 0])
if W_FWHM:
mps_d = np.zeros([2, 2, hp.nside2npix(NSIDE_DEFAULT), nnu])
for inu in np.arange(nnu):
for ip in [0, 1]:
mp_sky = hp.smoothing((mpfg + mpc)[ip, :, inu],
fwhm=beam_max,
verbose=False)
mps_d[0, ip, :, inu] = mp_sky + mps_no1[ip, :, inu]
mps_d[1, ip, :, inu] = mp_sky + mps_no2[ip, :, inu]
mps_d_rw = np.array([mps_no1, mps_no2]) + (mpfg + mpc)[None, :, :, :]
else:
mps_d = np.array([mps_no1, mps_no2]) + (mpfg + mpc)[None, :, :, :]
if OUTPUT_LEVEL > 0:
hp.write_map(predir + 'cmb_true.fits', amc, overwrite=True)
#Domain decomposition
ipnest_sub = hp.ring2nest(NSIDE_SPEC_DEFAULT,
np.arange(hp.nside2npix(NSIDE_SPEC_DEFAULT)))
ipring = hp.nest2ring(NSIDE_DEFAULT, np.arange(hp.nside2npix(NSIDE_DEFAULT)))
ip_patches_good = []
for ip_sub_ring in np.arange(hp.nside2npix(NSIDE_SPEC_DEFAULT)):
ips_ring = ipring[ipnest_sub[ip_sub_ring] * NSIDE_RATIO**2 +
np.arange(NSIDE_RATIO**2)]
if np.sum(msk[ips_ring] > ZER0) > 0:
ip_patches_good.append(ips_ring[msk[ips_ring] > ZER0])
plotmap = -1. * np.ones(hp.nside2npix(NSIDE_DEFAULT))
for i, ips in enumerate(ip_patches_good):
plotmap[ips] = i
cl_extravar *= norm
#This yields <10% variations
depth_factor = 1 + hp.synfast(
cl_extravar, o.nside_out, new=True, verbose=False)
#This total map corresponds to the relative variation in the shot-noise variance
snvmap = shotnoise_factor * depth_factor * msk
if o.plot_stuff:
hp.mollview(snvmap,
min=0.9,
title='Relative local shot noise variance')
plt.show()
hp.write_map("cont_lss_nvar_ns%d.fits" % o.nside_out,
snvmap,
overwrite=True)
if not os.path.isfile("cont_lss_star_ns%d.fits" % o.nside_out):
starmap = hp.ud_grade(hp.read_map("star_template.fits", verbose=False),
nside_out=o.nside_out)
starmap[starmap <= 0] = 1E-15
starmap = -np.log(
starmap) #Contaminant will be proportional to log(n_star)
mean = np.sum(starmap * msk) / np.sum(msk)
clcont = hp.anafast((starmap - mean) * msk) / fsky
nflat = np.mean(clcont[max(2, o.nside_out // 3 - 50):o.nside_out // 3 +
50]) * np.ones_like(clcont)
#Add extra fluctuations beyond ell~nside/3 with flat power spectrum
dstar = hp.synfast(nflat, o.nside_out, new=True, verbose=False)
data = self._get_galaxy_data(zbin)
mask = np.bincount(data['ipix'],
weights=data['weight'],
minlength=self.npix)
return mask
def _read_nzdz(self, zbin):
return np.loadtxt(self.dndz_list[zbin], unpack=True)
if __name__ == "__main__":
from glob import glob
from matplotlib import pyplot as plt
lsfiles = glob(
'/mnt/extraspace/damonge/S8z_data/KiDS_data/shear_KV450_catalog/*')
kv450 = KV450(lsfiles, 1024)
outdir = '/mnt/extraspace/gravityls_3/S8z/data/KV450/maps_1024/'
for i in range(5):
we1, we2, w2s2 = kv450.get_shear_map(i)
w = kv450.get_mask(i)
hp.write_map(outdir + 'kv450_we1_bin{}.fits'.format(i), we1)
hp.write_map(outdir + 'kv450_we2_bin{}.fits'.format(i), we2)
hp.write_map(outdir + 'kv450_w2s2_bin{}.fits'.format(i), w2s2)
hp.write_map(outdir + 'kv450_w_bin{}.fits'.format(i), w)
np.savez_compressed(outdir + 'kv450_sums_bin{}.npz'.format(i),
w2s2=np.sum(w2s2))
# hp.mollview(we1 / w, title='KV450 - 1st zbin - e1', min=-0.5, max=0.5)
# plt.savefig('kv450_e1_bin{}.png'.format(i))
# hp.mollview(we2 / w, title='KV450 - 1st zbin - e2', min=-0.5, max=0.5)
# plt.savefig('kv450_e2_bin{}.png'.format(i))
#-------------------------------------------------
# For debugging
# Draw the map
'''
hp.mollview(
mdust_DL07_paras,
unit="Msun/pc2",
#norm = 'log',
nest=True,
min = 0,
max = 10,
)
hp.graticule()
plt.show()
'''
#-------------------------------------------------
# Save the SIGMA_MDUST as a all-sky map
hp.write_map(
"mdust.fits",
[mdust_DL07_paras, e_mdust_DL07_paras],
nest=True,
coord='G',
overwrite=True,
fits_IDL=False,
column_names=['NORM', 'UNC'],
)
#-----------------------------------
# Measure time
elapsed_time = time.time() - start_time
print("Exiting Main Program, spending ", elapsed_time, "seconds.")
def write_healpix_fits(self, path, comm_bytes=None):
"""
Write data to a HEALPix format FITS table.
The data across all processes is assumed to be synchronized (the
data for a given submap shared between processes is identical). The
lowest rank process sharing each submap sends their copy to the root
process for writing.
Args:
path (str): The path to the FITS file.
comm_bytes (int): The approximate message size to use.
"""
if comm_bytes is None:
comm_bytes = self._commsize
autotimer = timing.auto_timer(type(self).__name__)
# We will reduce some number of whole submaps at a time.
# Find the number of submaps that fit into the requested
# communication size.
dbytes = self._dtype(1).itemsize
comm_submap = int(comm_bytes / (dbytes * self._submap * self._nnz))
if comm_submap == 0:
comm_submap = 1
nsubmap = int(self._size / self._submap)
if nsubmap * self._submap < self._size:
nsubmap += 1
# Determine which processes "own" each submap.
owners = np.zeros(nsubmap, dtype=np.int32)
owners.fill(self._comm.size)
for m in self._local:
owners[m] = self._comm.rank
allowners = np.zeros_like(owners)
self._comm.Allreduce(owners, allowners, op=MPI.MIN)
# this function requires lots of RAM, since it accumulates the
# full map on one process before writing.
# use a cache to store the local map, so that we can be sure to
# free the memory afterwards
fdata = None
temp = None
if self._comm.rank == 0:
fdata = []
temp = Cache()
for col in range(self._nnz):
name = "col{}".format(col)
temp.create(name, self._dtype, (self._size,))
fdata.append(temp.reference(name))
sendbuf = np.zeros(comm_submap * self._submap * self._nnz,
dtype=self._dtype)
sendview = sendbuf.reshape(comm_submap, self._submap, self._nnz)
recvbuf = None
recvview = None
if self._comm.rank == 0:
recvbuf = np.zeros(comm_submap * self._submap * self._nnz,
dtype=self._dtype)
recvview = recvbuf.reshape(comm_submap, self._submap, self._nnz)
submap_off = 0
ncomm = comm_submap
while submap_off < nsubmap:
if submap_off + ncomm > nsubmap:
ncomm = nsubmap - submap_off
if np.sum(allowners[submap_off:submap_off+ncomm]) \
!= ncomm * self._comm.size:
# at least one submap has some hits. reduce.
for c in range(ncomm):
if allowners[submap_off + c] == self._comm.rank:
sendview[c,:,:] \
= self.data[self._glob2loc[submap_off + c],:,:]
self._comm.Reduce(sendbuf, recvbuf, op=MPI.SUM, root=0)
if self._comm.rank == 0:
# copy into FITS buffers
for c in range(ncomm):
sampoff = (submap_off + c) * self._submap
for col in range(self._nnz):
fdata[col][sampoff:sampoff+self._submap] \
= recvview[c,:,col]
sendbuf.fill(0)
if self._comm.rank == 0:
recvbuf.fill(0)
submap_off += ncomm
if self._comm.rank == 0:
if os.path.isfile(path):
os.remove(path)
hp.write_map(path, fdata, dtype=self._dtype, fits_IDL=False,
nest=self._nest)
return
# #print(n.split('/')[-1])
# mapi = hp.read_map(n, verbose=False).astype('bool')
# mask_neg |= mapi
# noneg = (mask & (~mask_neg))
# print('original mask: ', mask.sum(), 'after removing negative pixels :', noneg.sum())
# hp.write_map('/Volumes/TimeMachine/data/mocks/mask.cut.hp.256.fits', noneg, dtype=np.float64, overwrite=True)
filename = '/Volumes/TimeMachine/data/mocks/mask.cut.hp.256.fits'
filename2 = '/Volumes/TimeMachine/data/mocks/mask.cut.w.hp.256.fits'
weights = glob(
'/Volumes/TimeMachine/data/mocks/3dbox/*/results/regression/*/*weights.hp256.fits'
)
weights += glob(
'/Volumes/TimeMachine/data/mocks/3dbox/*/cp2p/results/regression/*/*weights.hp256.fits'
)
print('total number of weights : %d' % len(weights))
mask = hp.read_map(filename, verbose=False).astype('bool')
for n in weights:
wi = hp.read_map(n, verbose=False)
maski = (wi > 0.5) & (wi < 2.0)
mask &= maski
hp.write_map(filename2, mask, overwrite=True, fits_IDL=False)
# test
#mask2 = hp.read_map(filename2, verbose=False).astype('bool')
#print(mask.sum(), mask2.sum(), np.array_equal(mask, mask2))
import copy as cp
if __name__ == "__main__":
niter = 20000
old_map = hp.read_map(
'/Users/kwame/Documents/s2let_ilc_data/s2let_ilc_covar15_planck_diffuse_deconv_tapered_thresh_lmax3600_3600_hybridC_6_1_recon_inpaint800.fits'
)
mask = np.load(
'/Users/kwame/Documents/s2let_ilc_data/nilc_pr1_builtmask_holes_ring_800.npy'
) #0 where holes
new_map = cp.deepcopy(old_map)
#nside = hp.get_nside(mask)
#hole_pixs = np.where(mask == 0)[0]
nside = 2048
hole_pixs = mask[0]
'''theta = mh.pi / 2.
phi = 0.
rad_arcmin = 21
hole_pixs = hp.query_disc(nside,hp.ang2vec(theta,phi),np.radians(rad_arcmin/60.))'''
hole_neighbours = hp.get_all_neighbours(nside, hole_pixs) #8 x N_pix_holes
new_map[hole_pixs] = np.mean(old_map) #Start with mean map value
for i in xrange(niter):
print "Iteration no.", i + 1, "/", niter
new_map[hole_pixs] = np.mean(new_map[hole_neighbours], axis=0)
resid_map = new_map - old_map
hp.write_map(
'/Users/kwame/Documents/s2let_ilc_data/s2let_ilc_covar15_planck_diffuse_deconv_tapered_thresh_lmax3600_3600_hybridC_6_1_recon_inpaint800GD20000.fits',
new_map)
def release(ctx, chain, burnin, procver, resamp, copy_, freqmaps, ame, ff, cmb,
synch, dust, br, diff, diffcmb, goodness, chisq, res, all_, plot):
"""
Creates a release file-set on the BeyondPlanck format.
https://gitlab.com/BeyondPlanck/repo/-/wikis/BeyondPlanck-Release-Candidate-2
ex. c3pp release chains_v1_c{1,2}/chain_c000{1,2}.h5 30 BP_r1
Will output formatted files using all chains specified,
with a burnin of 30 to a directory called BP_r1
This function outputs the following files to the {procver} directory:
BP_chain01_full_{procver}.h5
BP_resamp_chain01_full_Cl_{procver}.h5
BP_resamp_chain01_full_noCl_{procver}.h5
BP_param_full_v1.txt
BP_param_resamp_Cl_v1.txt
BP_param_resamp_noCl_v1.txt
BP_030_IQU_full_n0512_{procver}.fits
BP_044_IQU_full_n0512_{procver}.fits
BP_070_IQU_full_n1024_{procver}.fits
BP_cmb_IQU_full_n1024_{procver}.fits
BP_synch_IQU_full_n1024_{procver}.fits
BP_freefree_I_full_n1024_{procver}.fits
BP_ame_I_full_n1024_{procver}.fits
BP_cmb_GBRlike_{procver}.fits
"""
# TODO
# Use proper masks for output of CMB component
# Use inpainted data as well in CMB component
from src.fitsformatter import format_fits, get_data, get_header
from pathlib import Path
import shutil
if all_: # sets all other flags to true
copy_ = not copy_
freqmaps = not freqmaps
ame = not ame
ff = not ff
cmb = not cmb
synch = not synch
dust = not dust
br = not br
diff = not diff
diffcmb = not diffcmb
goodness = not goodness
res = not res
chisq = not chisq
if goodness:
chisq = res = True
elif chisq or res:
goodness = True
# Make procver directory if not exists
click.echo("{:#^80}".format(""))
click.echo(f"Creating directory {procver}")
Path(procver).mkdir(parents=True, exist_ok=True)
chains = chain
maxchain = len(chains)
"""
Copying chains files
"""
if copy_:
# Commander3 parameter file for main chain
for i, chainfile in enumerate(chains, 1):
path = os.path.split(chainfile)[0]
for file in os.listdir(path):
if file.startswith("param") and i == 1: # Copy only first
click.echo(
f"Copying {path}/{file} to {procver}/BP_param_full_c" +
str(i).zfill(4) + ".txt")
if resamp:
shutil.copyfile(
f"{path}/{file}",
f"{procver}/BP_param_resamp_Cl_c" +
str(i).zfill(4) + ".txt",
)
else:
shutil.copyfile(
f"{path}/{file}",
f"{procver}/BP_param_full_c" + str(i).zfill(4) +
".txt",
)
if resamp:
# Resampled CMB-only full-mission Gibbs chain file with Cls (for BR estimator)
click.echo(f"Copying {chainfile} to {procver}/BP_resamp_c" +
str(i).zfill(4) + f"_full_Cl_{procver}.h5")
shutil.copyfile(
chainfile,
f"{procver}/BP_resamp_c" + str(i).zfill(4) +
f"_full_Cl_{procver}.h5",
)
else:
# Full-mission Gibbs chain file
click.echo(f"Copying {chainfile} to {procver}/BP_c" +
str(i).zfill(4) + f"_full_{procver}.h5")
shutil.copyfile(
chainfile,
f"{procver}/BP_c" + str(i).zfill(4) +
f"_full_{procver}.h5",
)
#if halfring:
# # Copy halfring files
# for i, chainfile in enumerate([halfring], 1):
# # Copy halfring files
# click.echo(f"Copying {resamp} to {procver}/BP_halfring_c" + str(i).zfill(4) + f"_full_Cl_{procver}.h5")
# shutil.copyfile(halfring, f"{procver}/BP_halfring_c" + str(i).zfill(4) + f"_full_Cl_{procver}.h5",)
"""
IQU mean, IQU stdev, (Masks for cmb)
Run mean and stddev from min to max sample (Choose min manually or start at 1?)
"""
if resamp:
chain = f"{procver}/BP_resamp_c0001_full_Cl_{procver}.h5"
else:
chain = f"{procver}/BP_c0001_full_{procver}.h5"
if freqmaps:
try:
# Full-mission 30 GHz IQU frequency map
# BP_030_IQU_full_n0512_{procver}.fits
format_fits(
chain=chain,
extname="FREQMAP",
types=[
"I_MEAN",
"Q_MEAN",
"U_MEAN",
"I_RMS",
"Q_RMS",
"U_RMS",
"I_STDDEV",
"Q_STDDEV",
"U_STDDEV",
],
units=[
"uK",
"uK",
"uK",
"uK",
"uK",
"uK",
"uK",
"uK",
"uK",
],
nside=512,
burnin=burnin,
maxchain=maxchain,
polar=True,
component="030",
fwhm=0.0,
nu_ref_t="30.0 GHz",
nu_ref_p="30.0 GHz",
procver=procver,
filename=f"BP_030_IQU_full_n0512_{procver}.fits",
bndctr=30,
restfreq=28.456,
bndwid=9.899,
)
# Full-mission 44 GHz IQU frequency map
format_fits(
chain=chain,
extname="FREQMAP",
types=[
"I_MEAN",
"Q_MEAN",
"U_MEAN",
"I_RMS",
"Q_RMS",
"U_RMS",
"I_STDDEV",
"Q_STDDEV",
"U_STDDEV",
],
units=[
"uK",
"uK",
"uK",
"uK",
"uK",
"uK",
"uK",
"uK",
"uK",
],
nside=512,
burnin=burnin,
maxchain=maxchain,
polar=True,
component="044",
fwhm=0.0,
nu_ref_t="44.0 GHz",
nu_ref_p="44.0 GHz",
procver=procver,
filename=f"BP_044_IQU_full_n0512_{procver}.fits",
bndctr=44,
restfreq=44.121,
bndwid=10.719,
)
# Full-mission 70 GHz IQU frequency map
format_fits(
chain=chain,
extname="FREQMAP",
types=[
"I_MEAN",
"Q_MEAN",
"U_MEAN",
"I_RMS",
"Q_RMS",
"U_RMS",
"I_STDDEV",
"Q_STDDEV",
"U_STDDEV",
],
units=[
"uK",
"uK",
"uK",
"uK",
"uK",
"uK",
"uK",
"uK",
"uK",
],
nside=1024,
burnin=burnin,
maxchain=maxchain,
polar=True,
component="070",
fwhm=0.0,
nu_ref_t="70.0 GHz",
nu_ref_p="70.0 GHz",
procver=procver,
filename=f"BP_070_IQU_full_n1024_{procver}.fits",
bndctr=70,
restfreq=70.467,
bndwid=14.909,
)
except Exception as e:
print(e)
click.secho("Continuing...", fg="yellow")
"""
FOREGROUND MAPS
"""
# Full-mission CMB IQU map
if cmb:
if resamp:
try:
format_fits(
chain,
extname="COMP-MAP-CMB-RESAMP",
types=[
"I_MEAN",
"I_STDDEV",
],
units=[
"uK_cmb",
"uK_cmb",
],
nside=1024,
burnin=burnin,
maxchain=maxchain,
polar=True,
component="CMB",
fwhm=14.0,
nu_ref_t="NONE",
nu_ref_p="NONE",
procver=procver,
filename=f"BP_cmb_resamp_IQU_full_n1024_{procver}.fits",
bndctr=None,
restfreq=None,
bndwid=None,
)
except Exception as e:
print(e)
click.secho("Continuing...", fg="yellow")
else:
try:
format_fits(
chain,
extname="COMP-MAP-CMB",
types=[
"I_MEAN",
"Q_MEAN",
"U_MEAN",
"I_STDDEV",
"Q_STDDEV",
"U_STDDEV",
"mask1",
"mask2",
],
units=[
"uK_cmb",
"uK_cmb",
"uK",
"uK",
"NONE",
"NONE",
],
nside=1024,
burnin=burnin,
maxchain=maxchain,
polar=True,
component="CMB",
fwhm=14.0,
nu_ref_t="NONE",
nu_ref_p="NONE",
procver=procver,
filename=f"BP_cmb_IQU_full_n1024_{procver}.fits",
bndctr=None,
restfreq=None,
bndwid=None,
)
except Exception as e:
print(e)
click.secho("Continuing...", fg="yellow")
if ff:
try:
# Full-mission free-free I map
format_fits(
chain,
extname="COMP-MAP-FREE-FREE",
types=[
"I_MEAN",
"I_TE_MEAN",
"I_STDDEV",
"I_TE_STDDEV",
],
units=[
"uK_RJ",
"K",
"uK_RJ",
"K",
],
nside=1024,
burnin=burnin,
maxchain=maxchain,
polar=False,
component="FREE-FREE",
fwhm=30.0,
nu_ref_t="40.0 GHz",
nu_ref_p="40.0 GHz",
procver=procver,
filename=f"BP_freefree_I_full_n1024_{procver}.fits",
bndctr=None,
restfreq=None,
bndwid=None,
)
except Exception as e:
print(e)
click.secho("Continuing...", fg="yellow")
if ame:
try:
# Full-mission AME I map
format_fits(
chain,
extname="COMP-MAP-AME",
types=[
"I_MEAN",
"I_NU_P_MEAN",
"I_STDDEV",
"I_NU_P_STDDEV",
],
units=[
"uK_RJ",
"GHz",
"uK_RJ",
"GHz",
],
nside=1024,
burnin=burnin,
maxchain=maxchain,
polar=False,
component="AME",
fwhm=120.0,
nu_ref_t="22.0 GHz",
nu_ref_p="22.0 GHz",
procver=procver,
filename=f"BP_ame_I_full_n1024_{procver}.fits",
bndctr=None,
restfreq=None,
bndwid=None,
)
except Exception as e:
print(e)
click.secho("Continuing...", fg="yellow")
if synch:
try:
# Full-mission synchrotron IQU map
format_fits(
chain,
extname="COMP-MAP-SYNCHROTRON",
types=[
"I_MEAN",
"Q_MEAN",
"U_MEAN",
"P_MEAN",
"I_BETA_MEAN",
"QU_BETA_MEAN",
"I_STDDEV",
"Q_STDDEV",
"U_STDDEV",
"P_STDDEV",
"I_BETA_STDDEV",
"QU_BETA_STDDEV",
],
units=[
"uK_RJ",
"uK_RJ",
"uK_RJ",
"uK_RJ",
"NONE",
"NONE",
"uK_RJ",
"uK_RJ",
"uK_RJ",
"uK_RJ",
"NONE",
"NONE",
],
nside=1024,
burnin=burnin,
maxchain=maxchain,
polar=True,
component="SYNCHROTRON",
fwhm=60.0, # 60.0,
nu_ref_t="30.0 GHz",
nu_ref_p="30.0 GHz",
procver=procver,
filename=f"BP_synch_IQU_full_n1024_{procver}.fits",
bndctr=None,
restfreq=None,
bndwid=None,
)
except Exception as e:
print(e)
click.secho("Continuing...", fg="yellow")
if dust:
try:
# Full-mission thermal dust IQU map
format_fits(
chain,
extname="COMP-MAP-DUST",
types=[
"I_MEAN",
"Q_MEAN",
"U_MEAN",
"P_MEAN",
"I_BETA_MEAN",
"QU_BETA_MEAN",
"I_T_MEAN",
"QU_T_MEAN",
"I_STDDEV",
"Q_STDDEV",
"U_STDDEV",
"P_STDDEV",
"I_BETA_STDDEV",
"QU_BETA_STDDEV",
"I_T_STDDEV",
"QU_T_STDDEV",
],
units=[
"uK_RJ",
"uK_RJ",
"uK_RJ",
"uK_RJ",
"NONE",
"NONE",
"K",
"K",
"uK_RJ",
"uK_RJ",
"uK_RJ",
"uK_RJ",
"NONE",
"NONE",
"K",
"K",
],
nside=1024,
burnin=burnin,
maxchain=maxchain,
polar=True,
component="DUST",
fwhm=10.0, # 60.0,
nu_ref_t="545 GHz",
nu_ref_p="353 GHz",
procver=procver,
filename=f"BP_dust_IQU_full_n1024_{procver}.fits",
bndctr=None,
restfreq=None,
bndwid=None,
)
except Exception as e:
print(e)
click.secho("Continuing...", fg="yellow")
if diff:
import healpy as hp
try:
click.echo("Creating frequency difference maps")
path_dx12 = "/mn/stornext/u3/trygvels/compsep/cdata/like/BP_releases/dx12"
path_npipe = "/mn/stornext/u3/trygvels/compsep/cdata/like/BP_releases/npipe"
maps_dx12 = [
"30ghz_2018_n1024_beamscaled_dip.fits",
"44ghz_2018_n1024_beamscaled_dip.fits",
"70ghz_2018_n1024_beamscaled_dip.fits"
]
maps_npipe = [
"npipe6v20_030_map_uK.fits",
"npipe6v20_044_map_uK.fits",
"npipe6v20_070_map_uK.fits",
]
maps_BP = [
f"BP_030_IQU_full_n0512_{procver}.fits",
f"BP_044_IQU_full_n0512_{procver}.fits",
f"BP_070_IQU_full_n1024_{procver}.fits",
]
beamscaling = [9.8961854E-01, 9.9757886E-01, 9.9113965E-01]
for i, freq in enumerate([
"030",
"044",
"070",
]):
map_BP = hp.read_map(f"{procver}/{maps_BP[i]}",
field=(0, 1, 2),
verbose=False,
dtype=None)
map_npipe = hp.read_map(f"{path_npipe}/{maps_npipe[i]}",
field=(0, 1, 2),
verbose=False,
dtype=None)
map_dx12 = hp.read_map(f"{path_dx12}/{maps_dx12[i]}",
field=(0, 1, 2),
verbose=False,
dtype=None)
#dx12 dipole values:
# 3362.08 pm 0.99, 264.021 pm 0.011, 48.253 ± 0.005
# 233.18308357 2226.43833645 -2508.42179665
#dipole_dx12 = -3362.08*hp.dir2vec(264.021, 48.253, lonlat=True)
#map_dx12 = map_dx12/beamscaling[i]
# Smooth to 60 arcmin
map_BP = hp.smoothing(map_BP,
fwhm=arcmin2rad(60.0),
verbose=False)
map_npipe = hp.smoothing(map_npipe,
fwhm=arcmin2rad(60.0),
verbose=False)
map_dx12 = hp.smoothing(map_dx12,
fwhm=arcmin2rad(60.0),
verbose=False)
#ud_grade 30 and 44ghz
if i < 2:
map_npipe = hp.ud_grade(
map_npipe,
nside_out=512,
)
map_dx12 = hp.ud_grade(
map_dx12,
nside_out=512,
)
# Remove monopoles
map_BP -= np.mean(map_BP, axis=1).reshape(-1, 1)
map_npipe -= np.mean(map_npipe, axis=1).reshape(-1, 1)
map_dx12 -= np.mean(map_dx12, axis=1).reshape(-1, 1)
hp.write_map(f"{procver}/BP_{freq}_diff_npipe_{procver}.fits",
np.array(map_BP - map_npipe),
overwrite=True,
column_names=["I_DIFF", "Q_DIFF", "U_DIFF"],
dtype=None)
hp.write_map(f"{procver}/BP_{freq}_diff_dx12_{procver}.fits",
np.array(map_BP - map_dx12),
overwrite=True,
column_names=["I_DIFF", "Q_DIFF", "U_DIFF"],
dtype=None)
except Exception as e:
print(e)
click.secho("Continuing...", fg="yellow")
if diffcmb:
import healpy as hp
try:
click.echo("Creating cmb difference maps")
path_cmblegacy = "/mn/stornext/u3/trygvels/compsep/cdata/like/BP_releases/cmb-legacy"
mask_ = hp.read_map(
"/mn/stornext/u3/trygvels/compsep/cdata/like/BP_releases/masks/dx12_v3_common_mask_int_005a_1024_TQU.fits",
verbose=False,
dtype=np.bool,
)
map_BP = hp.read_map(
f"{procver}/BP_cmb_IQU_full_n1024_{procver}.fits",
field=(0, 1, 2),
verbose=False,
dtype=None,
)
map_BP_masked = hp.ma(map_BP[0])
map_BP_masked.mask = np.logical_not(mask_)
mono, dip = hp.fit_dipole(map_BP_masked)
nside = 1024
ray = range(hp.nside2npix(nside))
vecs = hp.pix2vec(nside, ray)
dipole = np.dot(dip, vecs)
map_BP[0] = map_BP[0] - dipole - mono
map_BP = hp.smoothing(map_BP,
fwhm=arcmin2rad(np.sqrt(60.0**2 - 14**2)),
verbose=False)
#map_BP -= np.mean(map_BP,axis=1).reshape(-1,1)
for i, method in enumerate([
"commander",
"sevem",
"nilc",
"smica",
]):
data = f"COM_CMB_IQU-{method}_2048_R3.00_full.fits"
click.echo(f"making difference map with {data}")
map_cmblegacy = hp.read_map(f"{path_cmblegacy}/{data}",
field=(0, 1, 2),
verbose=False,
dtype=None)
map_cmblegacy = hp.smoothing(map_cmblegacy,
fwhm=arcmin2rad(60.0),
verbose=False)
map_cmblegacy = hp.ud_grade(
map_cmblegacy,
nside_out=1024,
)
map_cmblegacy = map_cmblegacy * 1e6
# Remove monopoles
map_cmblegacy_masked = hp.ma(map_cmblegacy[0])
map_cmblegacy_masked.mask = np.logical_not(mask_)
mono = hp.fit_monopole(map_cmblegacy_masked)
click.echo(f"{method} subtracting monopole {mono}")
map_cmblegacy[0] = map_cmblegacy[
0] - mono #np.mean(map_cmblegacy,axis=1).reshape(-1,1)
hp.write_map(f"{procver}/BP_cmb_diff_{method}_{procver}.fits",
np.array(map_BP - map_cmblegacy),
overwrite=True,
column_names=["I_DIFF", "Q_DIFF", "U_DIFF"],
dtype=None)
except Exception as e:
print(e)
click.secho("Continuing...", fg="yellow")
if goodness:
import healpy as hp
path_goodness = procver + "/goodness"
Path(path_goodness).mkdir(parents=True, exist_ok=True)
print("PATH", path_goodness)
cmin = int(os.path.split(chains[0])[0].rsplit("_c")[-1])
cmax = int(os.path.split(chains[-1])[0].rsplit("_c")[-1])
chdir = os.path.split(chains[0])[0].rsplit("_", 1)[0]
if chisq:
try:
format_fits(
chains,
extname="CHISQ",
types=[
"I_MEAN",
"P_MEAN",
],
units=[
"NONE",
"NONE",
],
nside=16,
burnin=burnin,
maxchain=maxchain,
polar=True,
component="CHISQ",
fwhm=0.0,
nu_ref_t="NONE",
nu_ref_p="NONE",
procver=procver,
filename=f'goodness/BP_chisq_n16_{procver}.fits',
bndctr=None,
restfreq=None,
bndwid=None,
cmin=cmin,
cmax=cmax,
chdir=chdir,
)
except Exception as e:
print(e)
click.secho("Continuing...", fg="yellow")
if res:
click.echo("Save and format chisq map and residual maps")
bands = {
"030": {
"nside": 512,
"fwhm": 120,
"sig": "IQU",
"fields": (0, 1, 2),
"unit": "uK",
"scale": 1.,
},
"044": {
"nside": 512,
"fwhm": 120,
"sig": "IQU",
"fields": (0, 1, 2),
"unit": "uK",
"scale": 1.,
},
"070": {
"nside": 1024,
"fwhm": 120,
"sig": "IQU",
"fields": (0, 1, 2),
"unit": "uK",
"scale": 1.,
},
"030-WMAP_Ka": {
"nside": 512,
"fwhm": 120,
"sig": "I",
"fields": (0, ),
"unit": "uK",
"scale": 1e3,
},
"040-WMAP_Q1": {
"nside": 512,
"fwhm": 120,
"sig": "I",
"fields": (0, ),
"unit": "uK",
"scale": 1.,
},
"040-WMAP_Q2": {
"nside": 512,
"fwhm": 120,
"sig": "I",
"fields": (0, ),
"unit": "uK",
"scale": 1.,
},
"060-WMAP_V1": {
"nside": 512,
"fwhm": 120,
"sig": "I",
"fields": (0, ),
"unit": "uK",
"scale": 1.,
},
"060-WMAP_V2": {
"nside": 512,
"fwhm": 120,
"sig": "I",
"fields": (0, ),
"unit": "uK",
"scale": 1.,
},
"0.4-Haslam": {
"nside": 512,
"fwhm": 120,
"sig": "I",
"fields": (0, ),
"unit": "uK",
"scale": 1.,
},
"857": {
"nside": 1024,
"fwhm": 120,
"sig": "I",
"fields": (0, ),
"unit": "uK",
"scale": 1.,
},
"033-WMAP_Ka_P": {
"nside": 16,
"fwhm": 0,
"sig": "QU",
"fields": (1, 2),
"unit": "uK",
"scale": 1e3,
},
"041-WMAP_Q_P": {
"nside": 16,
"fwhm": 0,
"sig": "QU",
"fields": (1, 2),
"unit": "uK",
"scale": 1e3,
},
"061-WMAP_V_P": {
"nside": 16,
"fwhm": 0,
"sig": "QU",
"fields": (1, 2),
"unit": "uK",
"scale": 1e3,
},
"353": {
"nside": 1024,
"fwhm": 120,
"sig": "QU",
"fields": (1, 2),
"unit": "uK",
"scale": 1.,
},
}
for label, b in bands.items():
types = []
units = []
for l in b["sig"]:
types.append(f'{l}_MEAN')
units.append(b["unit"])
for l in b["sig"]:
types.append(f'{l}_STDDEV')
units.append(b["unit"])
try:
format_fits(
chains,
extname="FREQBAND_RES",
types=types,
units=units,
nside=b["nside"],
burnin=burnin,
maxchain=maxchain,
polar=True,
component=label,
fwhm=b["fwhm"],
nu_ref_t="NONE",
nu_ref_p="NONE",
procver=procver,
filename=
f'goodness/BP_res_{label}_{b["sig"]}_full_n{b["nside"]}_{b["fwhm"]}arcmin_{b["unit"]}_{procver}.fits',
bndctr=None,
restfreq=None,
bndwid=None,
cmin=cmin,
cmax=cmax,
chdir=chdir,
fields=b["fields"],
scale=b["scale"],
)
except Exception as e:
print(e)
click.secho("Continuing...", fg="yellow")
""" As implemented by Simone
"""
if br and resamp:
# Gaussianized TT Blackwell-Rao input file
click.echo("{:-^50}".format("CMB GBR"))
ctx.invoke(
sigma_l2fits,
filename=resamp,
nchains=1,
burnin=burnin,
path="cmb/sigma_l",
outname=f"{procver}/BP_cmb_GBRlike_{procver}.fits",
save=True,
)
"""
TODO Generalize this so that they can be generated by Elina and Anna-Stiina
"""
# Full-mission 30 GHz IQU beam symmetrized frequency map
# BP_030_IQUdeconv_full_n0512_{procver}.fits
# Full-mission 44 GHz IQU beam symmetrized frequency map
# BP_044_IQUdeconv_full_n0512_{procver}.fits
# Full-mission 70 GHz IQU beam symmetrized frequency map
# BP_070_IQUdeconv_full_n1024_{procver}.fits
""" Both sigma_l's and Dl's re in the h5. (Which one do we use?)
"""
# CMB TT, TE, EE power spectrum
# BP_cmb_Cl_{procver}.txt
""" Just get this from somewhere
"""
# Best-fit LCDM CMB TT, TE, EE power spectrum
# BP_cmb_bfLCDM_{procver}.txt
if plot:
os.chdir(procver)
ctx.invoke(plotrelease, procver=procver, all_=True)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--config', help='CATCH configuration file.')
parser.add_argument('--source',
default='observation',
help=('limit analysis to this data source '
'(default: show all data)'))
parser.add_argument('--nside',
default=2048,
help=('Healpix nside parameter, default is 2048'
' for 1.7 arcmin resolution'))
parser.add_argument(
'-o',
default=None,
help='output file name prefix, default based on --source')
parser.add_argument('--format', default='png', help='plot file format')
parser.add_argument('--dpi', type=int, default=200)
args = parser.parse_args()
prefix = args.source if args.o is None else args.o
config = Config.from_file(args.config)
with Catch.with_config(config) as catch:
catch.source = args.source
source_name = catch.source.__data_source_name__
cov = make_sky_coverage_map(catch, args.nside)
hp.write_map('.'.join((prefix, 'fits')), cov, overwrite=True)
plot(cov, source_name)
plt.savefig('.'.join((prefix, args.format)), dpi=args.dpi)
fig, ax = SWHT.display.disp3D(img, phi, theta, dmode='abs', cmap='jet')
# save complex image to pickle file
print 'Writing image to file %s ...' % outFn,
SWHT.fileio.writeSWHTImgPkl(outFn, [img, phi, theta], fDict, mode='3D')
print 'done'
elif opts.imageMode.startswith(
'heal'
): # plot healpix and save healpix file using the opts.pkl name
print 'Generating HEALPix Image with %i NSIDE' % (opts.pixels)
# use the healpy.alm2map function as it is much faster, there is a ~1% difference between the 2 functions, this is probably due to the inner workings of healpy
#m = SWHT.swht.makeHEALPix(imgCoeffs, nside=opts.pixels) # TODO: a rotation issue
m = hp.alm2map(SWHT.util.array2almVec(imgCoeffs),
opts.pixels) # TODO: a rotation issue
# save complex image to HEALPix file
print 'Writing image to file %s ...' % outFn,
hp.write_map(
outFn, m.real, coord='C'
) # only writing the real component, this should be fine, maybe missing some details, but you know, the sky should be real.
print 'done'
elif opts.imageMode.startswith('coeff'): # plot the complex coefficients
fig, ax = SWHT.display.dispCoeffs(imgCoeffs, zeroDC=True, vis=False)
if not (opts.savefig is None): plt.savefig(opts.savefig)
if not opts.nodisplay:
if opts.imageMode.startswith('heal'): hp.mollview(m.real, coord='CG')
plt.show()
print(" Construct Sky...", flush=True)
sky = pysm.Sky(nside=args.nside, preset_strings=["d1", "s1", "f1", "a1"])
freqs = (np.array([
args.bandcenter_ghz - 0.5 * args.bandwidth_ghz,
args.bandcenter_ghz,
args.bandcenter_ghz + 0.5 * args.bandwidth_ghz,
]) * u.GHz)
print(" Get Emission...", flush=True)
map_data = sky.get_emission(freqs)
if args.coord == "G":
print(" Smoothing...", flush=True)
smoothed = pysm.apply_smoothing_and_coord_transform(map_data,
fwhm=args.beam_arcmin *
u.arcmin)
else:
to_coord = "G{}".format(args.coord)
print(" Smoothing and rotating...", flush=True)
smoothed = pysm.apply_smoothing_and_coord_transform(
map_data,
fwhm=args.beam_arcmin * u.arcmin,
rot=hp.Rotator(coord=to_coord))
print(" Converting to NEST")
nested = hp.ud_grade(smoothed, args.nside, order_in="RING", order_out="NEST")
print(" Writing output...", flush=True)
hp.write_map(outfile, nested, nest=True)
nPixels = hp.nside2npix(nsides)
hz = n.zeros(nPixels)
hcounts = n.zeros(nPixels)
hrms = n.zeros(nPixels)
# Find pixel # for a given theta and phi
pixInd = hp.ang2pix(nsides, thetas, phis, nest=False)
# Set pixel values at pixInd to power values
hz[pixInd] = z
hcounts[pixInd] = gcounts
hrms[pixInd] = grms
# Grey out pixels with no measurements
hz[hz == 0] = n.nan
hcounts[hcounts == 0] = n.nan
hrms[hrms == 0] = n.nan
# Write healpix maps to fits files
hp.write_map(str(nsides) + '_power_' + outfilename + '.fits', hz)
hp.write_map(str(nsides) + '_rms_' + outfilename + '.fits', hrms)
hp.write_map(str(nsides) + '_counts_' + outfilename + '.fits', hcounts)
######################## Plotting ###########################
# Obtain bounds for plotting window
extent = (x.min(), x.max(), y.min(), y.max())
# Compute quartiles for scaling of colorbar
fq = n.percentile(z, 10)
uq = n.percentile(z, 80)
# Change colormap for Healpix colorbars
bonemap = cm.bone_r
bonemap.set_under('0.75')
gnuplotmap = cm.gnuplot
gnuplotmap.set_under('0.75')
f'/fs/ess/PHS0336/data/tanveer/dr9/v4/elg_dnnp/{region}_clean_1024/windows/window_model_*fits'
)
print(region)
nwindows = 1000
nside = 1024
for i in range(nwindows):
count_i = np.zeros(12 * nside * nside)
wind_i = np.zeros(12 * nside * nside)
for region in windows:
d_ = ft.read(windows[region][i])
wind_i[d_['hpix']] += d_['weight']
count_i[d_['hpix']] += 1.0
output_path = f'/fs/ess/PHS0336/data/tanveer/dr9/v4/elg_dnnp/windows_clean/nnwindow_{i}.hp{nside}.fits'
output_dir = os.path.dirname(output_path)
if not os.path.exists(output_dir):
os.makedirs(output_dir)
is_good = count_i > 0.0
wind_i[is_good] = wind_i[is_good] / count_i[is_good]
wind_i[~is_good] = hp.UNSEEN
print(f'wrote {output_path}')
hp.write_map(output_path,
wind_i,
dtype=np.float64,
fits_IDL=False,
overwrite=True)
fac) / np.square(np.radians(
catalog[:, 4][catalog[:, -1] == 1])) #Using GAUFLUX if EXTENDED
#catalog[:,2:] * fluxfacs[:,None].T * 0.001 #mK
sigmas = np.radians(catalog[:, 4] / 60.) / (
2. * mh.sqrt(2. * mh.log(2.))
) #np.radians(fwhms) / (2.*mh.sqrt(2.*mh.log(2.))) #sigma in radians
sigmas[catalog[:, -1] == 0] = fwhms_rad[j] / (
2. * mh.sqrt(2. * mh.log(2.))) #Use beamFWHM if not EXTENDED
for i in xrange(len(coords)): #Loop over point sources
print 'Subtracting Gaussian profile for point source', i + 1, '/', len(
coords), 'map', j
samppixs = hp.query_disc(hp.get_nside(maps[j]),
hp.ang2vec(coords[i, 1], coords[i, 0]),
5. * sigmas[i])
maps[j] = gauss_source(maps[j], temps[i], sigmas[i],
(coords[i, 1], coords[i, 0]), samppixs)
#samppixsall = np.concatenate((samppixsall,samppixs)) #Slows program down
#Save point source residuals
resid[j] = origmaps[j] - maps[j]
'''testmap = cp.deepcopy(maps[j])
testmap[:] = 0.
testmap[samppixsall[1:]] = 1.'''
#Write new maps to FITS files
for i in xrange(len(maps)):
hp.write_map(outfits[i], maps[i])
hp.write_map(residfits[i], resid[i])
