def rotate_healpixmap(healpixmap, z1, y1, z2):#the three rotation angles are (fixed rotation axes and right hand convention): rotate around z axis by z1, around y axis by y1, and z axis again by z2. I think they form a set of Euler angles, but not exactly sure. nside = int((len(healpixmap)/12.)**.5) if len(healpixmap)%12 != 0 or 12*(nside**2) != len(healpixmap): raise Exception('ERROR: Input healpixmap length %i is not 12*nside**2!'%len(healpixmap)) newmapcoords_in_oldcoords = [rotatez(rotatey(rotatez(hpf.pix2ang(nside, i), -z2), -y1), -z1) for i in range(12*nside**2)] newmap = [hpf.get_interp_val(healpixmap, coord[0], coord[1]) for coord in newmapcoords_in_oldcoords] return newmap
def test_josh_gsm(self): self.result = {} colors = ['r', 'b', 'c', 'g'] for self.nside, color in zip([32, 64, 128, 256], colors): nside = self.nside pca1 = hp.fitsfunc.read_map(self.test_dir + '/../data/gsm1.fits' + str(nside)) pca2 = hp.fitsfunc.read_map(self.test_dir + '/../data/gsm2.fits' + str(nside)) pca3 = hp.fitsfunc.read_map(self.test_dir + '/../data/gsm3.fits' + str(nside)) gsm = 422.952 * (0.307706 * pca1 + -0.281772 * pca2 + 0.0123976 * pca3) equatorial_GSM = np.zeros(12 * nside**2, 'float') #rotate sky map for i in range(12 * nside**2): ang = hp.rotator.Rotator(coord='cg')(hpf.pix2ang(nside, i)) equatorial_GSM[i] = hpf.get_interp_val(gsm, ang[0], ang[1]) self.alm = sv.convert_healpy_alm( hp.sphtfunc.map2alm(equatorial_GSM), 3 * nside - 1) timer = time.time() self.result[nside] = self.vs.calculate_visibility( sv.expand_real_alm(self.alm), d=self.rot.dot(np.array([15.0, 21.0, 0.0])), freq=self.freq, nt=len(self.correct_result) - 1, L=3 * self.nside - 1, verbose=False) print(time.time() - timer) / 60., "minutes for nside = %i" % nside sys.stdout.flush() plt.plot(np.real(self.result[nside]), '%s--' % color) #plt.plot(np.real(self.correct_result), 'g--') #plt.plot(np.real(self.result32), 'r--', np.real(self.result64), 'b--', np.real(self.correct_result), 'g--') plt.show()
def ant_gain(self, coords, time): """ Returns NenuFAR antenna gain values interpolated at coordinates ``coords`` at time ``time``. :param coords: :type coords: :class:`~astropy.coordinates.ICRS` or :class:`~astropy.coordinates.SkyCoord` :param time: :type time: :class:`~astropy.time.Time` :returns: NenuFAR normalized antenna gain :rtype: `~numpy.ndarray` :Example: To get back the HEALPix ant gain: >>> from nenupy.beam import Beam >>> import numpy as np >>> import astropy.units as u >>> from astropy.coordinates import ICRS >>> from astropy.time import Time >>> from healpy.pixelfunc import nside2npix, pix2ang >>> from healpy.visufunc import mollview >>> b = Beam( freq=50, polar='NE', ) >>> npix = nside2npix(nside=32) >>> ra, dec = pix2ang( nside=32, ipix=np.arange(npix), lonlat=True ) >>> gain = b.ant_gain( coords=ICRS( ra=ra*u.deg, dec=dec*u.deg ), time=Time.now() ) >>> mollview(gain) """ if not isinstance(coords, (ICRS, SkyCoord)): raise TypeError('coords should be ICRS or SkyCoord object') if not isinstance(time, Time): raise TypeError('time should be Time object') hpxgain = nenufar_ant_gain(freq=self.freq, polar=self.polar, nside=32, time=time) log.info('NenuFAR HEALPix antenna gain loaded.') vals = get_interp_val(m=hpxgain, theta=coords.ra.deg, phi=coords.dec.deg, lonlat=True) log.info('NenuFAR antenna gain values interpolated.') return vals
def rotate_healpixmap(healpixmap, z1, y1, z2):#the three rotation angles are (fixed rotation axes and right hand convention): rotate around z axis by z1, around y axis by y1, and z axis again by z2. I think they form a set of Euler angles, but not exactly sure. nside = int((len(healpixmap)/12.)**.5) if len(healpixmap)%12 != 0 or 12*(nside**2) != len(healpixmap): raise Exception('ERROR: Input healpixmap length %i is not 12*nside**2!'%len(healpixmap)) rot_matrix = rotatez_matrix(-z1).dot(rotatey_matrix(-y1).dot(rotatez_matrix(-z2))) new_coords = hpf.pix2ang(nside, range(12*nside**2)) old_coords = hpr.rotateDirection(rot_matrix, new_coords) newmap = hpf.get_interp_val(healpixmap, old_coords[0], old_coords[1]) return newmap
def calculate_pointsource_visibility( self, ra, dec, d, freq, beam_healpix_hor=None, beam_heal_equ=None, nt=None, tlist=None, verbose=False): #d in horizontal coord, tlist in lst hours if self.initial_zenith.tolist() == [1000, 1000]: raise Exception( 'ERROR: need to set self.initial_zenith first, which is at t=0, the position of zenith in equatorial coordinate in ra dec radians.' ) if tlist is None and nt is None: raise Exception( "ERROR: neither nt nor tlist was specified. Must input what lst you want in sidereal hours" ) d_equ = stoc( np.append( la.norm(d), rotatez( rotatey( ctos(d)[1:3], (np.pi / 2 - self.initial_zenith[1])), self.initial_zenith[0]))) if beam_healpix_hor is None and beam_heal_equ is None: raise Exception( "ERROR: conversion from alm for beam to beam_healpix not yet supported, so please specify beam_healpix as a keyword directly, in horizontal coord." ) elif beam_heal_equ is None: beam_heal_equ = np.array( rotate_healpixmap(beam_healpix_hor, 0, np.pi / 2 - self.initial_zenith[1], self.initial_zenith[0])) if tlist is None: tlist = np.arange(0., 24., 24. / nt) else: tlist = np.array(tlist) angle_list = tlist / 12. * np.pi result = np.empty(len(angle_list), dtype='complex64') ps_vec = -np.array( [np.cos(dec) * np.cos(ra), np.cos(dec) * np.sin(ra), np.sin(dec)]) ik = 2.j * np.pi * freq / 299.792458 ###for i, phi in zip(range(len(angle_list)), angle_list): ####print beam_heal_equ.shape, np.pi/2 - dec, ra - phi ###result[i] = hpf.get_interp_val(beam_heal_equ, np.pi/2 - dec, ra - phi) * np.exp(ik*rotatez_matrix(phi).dot(d_equ).dot(ps_vec)) ###return result return hpf.get_interp_val(beam_heal_equ, np.pi / 2 - dec, ra - np.array(angle_list)) * np.exp( ik * (rotatez_matrix(angle_list).transpose( 2, 0, 1).dot(d_equ).dot(ps_vec)))
def calculate_pointsource_visibility(self, ra, dec, d, freq, beam_healpix_hor = None, beam_heal_equ = None, nt = None, tlist = None, verbose = False):#d in horizontal coord, tlist in lst hours, beam in unites of power if self.initial_zenith.tolist() == [1000, 1000]: raise Exception('ERROR: need to set self.initial_zenith first, which is at t=0, the position of zenith in equatorial coordinate in ra dec radians.') if tlist is None and nt is None: raise Exception("ERROR: neither nt nor tlist was specified. Must input what lst you want in sidereal hours") if np.array(d).ndim == 1: input_ndim = 1 d = np.array([d]) elif np.array(d).ndim == 2: input_ndim = 2 else: raise TypeError("Input d has incorrect dimension number of %i."%np.array(d).ndim) d_equ = d.dot(np.transpose(rotatez_matrix(self.initial_zenith[0]).dot(rotatey_matrix(np.pi/2 - self.initial_zenith[1])))) if beam_healpix_hor is None and beam_heal_equ is None: raise Exception("ERROR: conversion from alm for beam to beam_healpix not yet supported, so please specify beam_healpix as a keyword directly, in horizontal coord.") elif beam_heal_equ is None: beam_heal_equ = np.array(rotate_healpixmap(beam_healpix_hor, 0, np.pi/2 - self.initial_zenith[1], self.initial_zenith[0])) if tlist is None: tlist = np.arange(0.,24.,24./nt) else: tlist = np.array(tlist) angle_list = tlist/12.*np.pi ps_vec = -np.array([np.cos(dec)*np.cos(ra), np.cos(dec)*np.sin(ra), np.sin(dec)]) ik = 2.j*np.pi*freq/299.792458 ###for i, phi in zip(range(len(angle_list)), angle_list): ####print beam_heal_equ.shape, np.pi/2 - dec, ra - phi ###result[i] = hpf.get_interp_val(beam_heal_equ, np.pi/2 - dec, ra - phi) * np.exp(ik*rotatez_matrix(phi).dot(d_equ).dot(ps_vec)) ###return result try: result = hpf.get_interp_val(beam_heal_equ, np.pi/2 - dec, ra - np.array(angle_list)) * np.exp(ik * np.einsum('ijt,uj->uti', rotatez_matrix(angle_list), d_equ).dot(ps_vec)) except: print hpf.get_interp_val(beam_heal_equ, np.pi/2 - dec, ra - np.array(angle_list)).shape print rotatez_matrix(angle_list).shape, d_equ.shape print np.exp(ik * np.einsum('ijt,uj->uti', rotatez_matrix(angle_list), d_equ).dot(ps_vec)).shape sys.stdout.flush() if input_ndim == 1: return result[0] else: return result
def test_josh_gsm(self): self.nside = 32 nside = self.nside pca1 = hp.fitsfunc.read_map(self.test_dir + '/../data/gsm1.fits' + str(nside)) pca2 = hp.fitsfunc.read_map(self.test_dir + '/../data/gsm2.fits' + str(nside)) pca3 = hp.fitsfunc.read_map(self.test_dir + '/../data/gsm3.fits' + str(nside)) gsm = 422.952*(0.307706*pca1+-0.281772*pca2+0.0123976*pca3) equatorial_GSM = np.zeros(12*nside**2,'float') #rotate sky map for i in range(12*nside**2): ang = hp.rotator.Rotator(coord='cg')(hpf.pix2ang(nside,i)) equatorial_GSM[i] = hpf.get_interp_val(gsm, ang[0], ang[1]) self.alm = sv.convert_healpy_alm(hp.sphtfunc.map2alm(equatorial_GSM), 3 * nside - 1) self.result32 = self.vs.calculate_visibility(sv.expand_real_alm(self.alm), d=self.rot.dot(np.array([6.0,3.0,0.0])), freq=self.freq, nt=len(self.correct_result)-1, L = 3*self.nside-1, verbose = False) print self.result32[0], self.result32[-1] print self.correct_result[0], self.correct_result[-1] #self.nside = 64 #nside = self.nside #pca1 = hp.fitsfunc.read_map(self.test_dir + '/../data/gsm1.fits' + str(nside)) #pca2 = hp.fitsfunc.read_map(self.test_dir + '/../data/gsm2.fits' + str(nside)) #pca3 = hp.fitsfunc.read_map(self.test_dir + '/../data/gsm3.fits' + str(nside)) #gsm = 422.952*(0.307706*pca1+-0.281772*pca2+0.0123976*pca3) #equatorial_GSM = np.zeros(12*nside**2,'float') ##rotate sky map #for i in range(12*nside**2): #ang = hp.rotator.Rotator(coord='cg')(hpf.pix2ang(nside,i)) #pixindex, weight = hpf.get_neighbours(nside,ang[0],ang[1]) #for pix in range(len(pixindex)): #equatorial_GSM[i] += weight[pix]*gsm[pixindex[pix]] #self.alm = sv.convert_healpy_alm(hp.sphtfunc.map2alm(equatorial_GSM), 3 * nside - 1) #self.result64 = self.vs.calculate_visibility(sv.expand_real_alm(self.alm), d=self.rot.dot(np.array([6.0,3.0,0.0])), freq=self.freq, nt=len(self.correct_result)-1, L = 3*self.nside-1, verbose = False) #plt.plot(np.real(self.result32), 'r--', np.real(self.result64), 'b--', np.real(self.correct_result), 'g--') #plt.show() #plt.plot(np.imag(self.result32), 'r--', np.imag(self.result64), 'b--', np.imag(self.correct_result), 'g--') #plt.show() plt.plot(np.real(self.result32), 'r--', np.real(self.correct_result), 'g--') plt.show()
def test_josh_gsm(self): self.result = {} colors = ['r','b','c','g'] for self.nside, color in zip([32, 64, 128, 256], colors): nside = self.nside pca1 = hp.fitsfunc.read_map(self.test_dir + '/../data/gsm1.fits' + str(nside)) pca2 = hp.fitsfunc.read_map(self.test_dir + '/../data/gsm2.fits' + str(nside)) pca3 = hp.fitsfunc.read_map(self.test_dir + '/../data/gsm3.fits' + str(nside)) gsm = 422.952*(0.307706*pca1+-0.281772*pca2+0.0123976*pca3) equatorial_GSM = np.zeros(12*nside**2,'float') #rotate sky map for i in range(12*nside**2): ang = hp.rotator.Rotator(coord='cg')(hpf.pix2ang(nside,i)) equatorial_GSM[i] = hpf.get_interp_val(gsm, ang[0], ang[1]) self.alm = sv.convert_healpy_alm(hp.sphtfunc.map2alm(equatorial_GSM), 3 * nside - 1) timer = time.time() self.result[nside] = self.vs.calculate_visibility(sv.expand_real_alm(self.alm), d=self.rot.dot(np.array([15.0,21.0,0.0])), freq=self.freq, nt=len(self.correct_result)-1, L = 3*self.nside-1, verbose = False) print (time.time() - timer)/60., "minutes for nside = %i"%nside sys.stdout.flush(); plt.plot(np.real(self.result[nside]), '%s--'%color) #plt.plot(np.real(self.correct_result), 'g--') #plt.plot(np.real(self.result32), 'r--', np.real(self.result64), 'b--', np.real(self.correct_result), 'g--') plt.show()
def sky(self, sbar): healpix = self.healpix_brightness(sbar) lm_map = np.zeros((len(self.f0), self.ncells * self.ncells)) * np.nan for i,hp in enumerate(healpix): # Convert lgrid to co-lat and longitude in radians. L, M = np.meshgrid(self.lgrid[i].value, self.lgrid[i].value) lm = np.sqrt(L**2+M**2).flatten() mask = lm < 1 theta = np.arcsin(lm[mask]) phimod = np.arccos(L.flatten()[mask] / lm[mask]) phi = np.where(M.flatten()[mask] < 0, phimod, -phimod) phi[np.isnan(phi)] = 0.0 # Generate map from interpolation lm_map[i][mask] = pixelfunc.get_interp_val(hp, theta, phi) #lm_map[i] = lm_map[i].reshape((self.ncells, self.ncells)) #print i, lm.max(), L.max(), M.max(), lm_map[i][500] lm_map = lm_map.reshape((len(self.f0), self.ncells, self.ncells)) return lm_map
def calculate_pointsource_visibility(self, ra, dec, d, freq, beam_healpix_hor = None, beam_heal_equ = None, nt = None, tlist = None, verbose = False):#d in horizontal coord, tlist in lst hours if self.initial_zenith.tolist() == [1000, 1000]: raise Exception('ERROR: need to set self.initial_zenith first, which is at t=0, the position of zenith in equatorial coordinate in ra dec radians.') if tlist is None and nt is None: raise Exception("ERROR: neither nt nor tlist was specified. Must input what lst you want in sidereal hours") d_equ = stoc(np.append(la.norm(d),rotatez(rotatey(ctos(d)[1:3], (np.pi/2 - self.initial_zenith[1])), self.initial_zenith[0]))) if beam_healpix_hor is None and beam_heal_equ is None: raise Exception("ERROR: conversion from alm for beam to beam_healpix not yet supported, so please specify beam_healpix as a keyword directly, in horizontal coord.") elif beam_heal_equ is None: beam_heal_equ = np.array(rotate_healpixmap(beam_healpix_hor, 0, np.pi/2 - self.initial_zenith[1], self.initial_zenith[0])) if tlist is None: tlist = np.arange(0.,24.,24./nt) else: tlist = np.array(tlist) angle_list = tlist/12.*np.pi result = np.empty(len(angle_list), dtype='complex64') ps_vec = -np.array([np.cos(dec)*np.cos(ra), np.cos(dec)*np.sin(ra), np.sin(dec)]) ik = 2.j*np.pi*freq/299.792458 ###for i, phi in zip(range(len(angle_list)), angle_list): ####print beam_heal_equ.shape, np.pi/2 - dec, ra - phi ###result[i] = hpf.get_interp_val(beam_heal_equ, np.pi/2 - dec, ra - phi) * np.exp(ik*rotatez_matrix(phi).dot(d_equ).dot(ps_vec)) ###return result return hpf.get_interp_val(beam_heal_equ, np.pi/2 - dec, ra - np.array(angle_list)) * np.exp(ik * (rotatez_matrix(angle_list).transpose(2,0,1).dot(d_equ).dot(ps_vec)))
GSMs = {}#will store equatorial coord maps for 3 components for the key word of nside nside = MIN_GSM_NSIDE print "Loading GSMs:", while nside < 2 * 5 * np.max(la.norm(ubls, axis = 1))/(299.792458/np.max(freqs)) or nside == MIN_GSM_NSIDE: print nside, pca1 = hp.fitsfunc.read_map(datadir + 'gsm1.fits' + str(nside), verbose=False) pca2 = hp.fitsfunc.read_map(datadir + 'gsm2.fits' + str(nside), verbose=False) pca3 = hp.fitsfunc.read_map(datadir + 'gsm3.fits' + str(nside), verbose=False) equ2013_to_gal_matrix = hp.rotator.Rotator(coord='cg').mat.dot(sv.epoch_transmatrix(2000,stdtime=year)) ang0, ang1 =hp.rotator.rotateDirection(equ2013_to_gal_matrix, hpf.pix2ang(nside, range(12*nside**2))) GSMs[nside] = np.zeros((3, 12*nside**2)) GSMs[nside][0] = hpf.get_interp_val(pca1, ang0, ang1) GSMs[nside][1] = hpf.get_interp_val(pca2, ang0, ang1) GSMs[nside][2] = hpf.get_interp_val(pca3, ang0, ang1) nside = nside * 2 print "Done." ######start calculation for ubl,unit_ubl in zip(ubls,unit_ubls): result = np.zeros((nt, nf), dtype='complex64') for f in range(len(freqs)): print "Starting UBL: %s at frequency %.3f MHz, %.2f wavelengths."%(ubl, freqs[f], la.norm(ubl)/(299.792458/freqs[f])), timer = time.time() vs.import_beam(beam_healpix[f]) ######decide nside for GSM nside = MIN_GSM_NSIDE
######load beam bnside = 64 beam_freqs = np.arange(110., 195., 5.) print "Reading calfile %s..."%calfile, sys.stdout.flush() ######cal file loaded aa = ap.cal.get_aa(calfile, beam_freqs/1000.) print "Done. Antenna layout:" print aa.ant_layout sys.stdout.flush() beam_healpix = np.zeros((len(beam_freqs), 2, 12*bnside**2), dtype='float32') healpixvecs = np.array(hpf.pix2vec(bnside, range(12*bnside**2))) paper_healpixvecs = (healpixvecs[:, healpixvecs[2]>=0]).transpose().dot(sv.rotatez_matrix(-np.pi/2).transpose())#in paper's bm_response convention, (x,y) = (0,1) points north. for p, pol in enumerate(['x', 'y']): for i, paper_angle in enumerate(paper_healpixvecs): beam_healpix[:, p, i] = (aa[0].bm_response(paper_angle, pol)**2.).flatten() local_beam_unpol = si.interp1d(beam_freqs, beam_healpix, axis=0) freq = 110. for p in range(2): plt.subplot(2, 1, p+1) plt.plot(hpf.get_interp_val(local_beam_unpol(freq)[p], np.arange(0, PI/2, .01), 0)) plt.plot(hpf.get_interp_val(local_beam_unpol(freq)[p], np.arange(0, PI/2, .01), PI/2)) plt.show()
#quit() ################################################ #####################GSM########################### ############################################# #rotate sky map and converts to nest equatorial_GSM_standard_2000 = np.fromfile(datadir + 'skymap_mwacs_nside256_float32.dat', dtype='float32') print "Rotating GSM_standard and converts to nest...", sys.stdout.flush() equ2013_to_equ2000_matrix = sv.epoch_transmatrix(2000, stdtime=2013.64) ang0, ang1 = hp.rotator.rotateDirection( equ2013_to_equ2000_matrix, hpf.pix2ang(nside_standard, range(12 * nside_standard**2), nest=True)) equatorial_GSM_standard = hpf.get_interp_val(equatorial_GSM_standard_2000, ang0, ang1) print "done." sys.stdout.flush() #hpv.mollview(np.log10(equatorial_GSM_standard), min=-3.5,max=1.5, coord=plotcoord, title='GSM', nest=True) #plt.show() #quit() ######################################################################## ########################processing dynamic pixelization###################### ######################################################################## nside_distribution = np.zeros(12 * nside_standard**2) final_index = np.zeros(12 * nside_standard**2) thetas, phis, sizes = [], [], [] abs_thresh = np.mean(equatorial_GSM_standard * beam_weight) * thresh pixelize(equatorial_GSM_standard * beam_weight, nside_distribution,
plt.subplot(1, 2, 2) spectral_index_list = np.array(spectral_index_list) plt.errorbar((spectral_index_list[:, 0] - 5)%24 + 5, spectral_index_list[:, 1], fmt='g+', yerr=spectral_index_list[:, 2]) plt.xlabel('LST (hour)') plt.ylabel('Spectral index') plt.ylim(-4, -1) plt.show() print np.sum(spectral_index_list[:, 1] / spectral_index_list[:,2]**2) / np.sum(1 / spectral_index_list[:,2]**2), np.sum(1 / spectral_index_list[:,2]**2)**-.5 #gal latitudes equ2013_to_gal_matrix = hp.rotator.Rotator(coord='cg').mat.dot(sv.epoch_transmatrix(2000, stdtime=2013.58)) zen_phis = np.arange(16., 25., .1) / 24. * 2 * np.pi zen_thetas = np.ones_like(zen_phis) * 45.297728 / 180 * PI z_ang0, z_ang1 = hp.rotator.rotateDirection(equ2013_to_gal_matrix, zen_thetas, zen_phis) zen_gal_lats = hpf.get_interp_val(PI/2 - hpf.pix2ang(nside, range(hpf.nside2npix(nside)))[0], z_ang0, z_ang1) plt.errorbar((spectral_index_list[:, 0] - 5)%24 + 5, spectral_index_list[:, 1], fmt='g+', yerr=spectral_index_list[:, 2]) plt.xlabel('LST (hour)') plt.ylabel('Spectral index') plt.ylim(-4, -1) plt.plot(zen_phis / (2 * np.pi) * 24, zen_gal_lats * 180. / np.pi / 40. - 3) plt.show() ############################################## ###make pretty maps with heavy regularization AtNiA_sum = np.fromfile(AtNiA_filename, dtype='float64') AtNiA_sum.shape = (npix_nonzero, npix_nonzero) for reg in 10.**np.arange(-4.5, -2, .5): AtNiAi_filename = datadirs['miteor'] + 'mega_v%.1f_AtNiAfi_n%i_iter%i_reg%.3e'%(version, npix_nonzero, max_iter - 1, reg) + file_tag
def DBG_calculate_pol_pointsource_visibility(self, ra, dec, d_in, freq, beam_healpix_hor = None, beam_heal_equ = None, nt = None, tlist = None, verbose = False):#d_in in horizontal coord, beam is 4 by npix (xx,xy,yx,yy) in unites of Jones matrix, square root of power, tlist in lst hours, return 4 by 4 by nt numbers, where first dim of 4 is received xx xy yx yy, and second is xx xy yx yy on sky if self.initial_zenith.tolist() == [1000, 1000]: raise Exception('ERROR: need to set self.initial_zenith first, which is at t=0, the position of zenith in equatorial coordinate in ra dec radians.') if tlist is None and nt is None: raise Exception("ERROR: neither nt nor tlist was specified. Must input what lst you want in sidereal hours") if np.array(d_in).ndim == 1: d_in = [d_in] d_equ = np.array([stoc(np.append(la.norm(d),rotatez(rotatey(ctos(d)[1:3], (np.pi/2 - self.initial_zenith[1])), self.initial_zenith[0]))) for d in d_in]) if beam_healpix_hor is None and beam_heal_equ is None: raise Exception("ERROR: conversion from alm for beam to beam_healpix not yet supported, so please specify beam_healpix_hor as a keyword directly, in horizontal coord.") elif beam_heal_equ is None: beam_heal_equ = np.array([rotate_healpixmap(ibeam_healpix_hor, 0, np.pi/2 - self.initial_zenith[1], self.initial_zenith[0]) for ibeam_healpix_hor in beam_healpix_hor]) if tlist is None: tlist = np.arange(0.,24.,24./nt) else: tlist = np.array(tlist) angle_list = tlist/12.*np.pi ps_vec = -np.array([np.cos(dec)*np.cos(ra), np.cos(dec)*np.sin(ra), np.sin(dec)])#pointing towards observer ik = 2.j*np.pi*freq/299.792458 beamt = np.array([hpf.get_interp_val(ibeam_heal_equ, np.pi/2 - dec, ra - np.array(angle_list)) for ibeam_heal_equ in beam_heal_equ]) beamt.shape = (2, 2, len(tlist)) if verbose: plot_jones(beam_heal_equ) print "J" print beamt Rut = rotatez_matrix(angle_list).transpose(2,0,1)#rotation matrix for ubl over t fringe = np.exp(ik * (Rut.dot(d_equ.transpose()).transpose(2,0,1).dot(ps_vec)))#u by t local_zenith_vect = Rut.dot([np.cos(self.initial_zenith[1]) * np.cos(self.initial_zenith[0]), np.cos(self.initial_zenith[1]) * np.sin(self.initial_zenith[0]), np.sin(self.initial_zenith[1])])#over t the zenith in local coord expressed in equitorial coord #BUGGED CODE # if np.abs(ps_vec[-1]) == 1: # phi0 = np.array([0, 1, 0]) # alpha0 = np.array([-1, 0, 0]) # else: # phi0 = np.cross([0,0,1], -ps_vec) # phi0 = phi0/la.norm(phi0) # alpha0 = np.cross([0,0,1], phi0) # alpha0 = alpha0/la.norm(alpha0) # phi1t = np.cross(local_zenith_vect, -ps_vec) # if np.min(la.norm(local_zenith_vect-(-ps_vec), axis = -1)) == 0.: # if la.norm(np.cross([0,0,1], -ps_vec)) != 0: # phi1t[np.argmin(la.norm(local_zenith_vect-(-ps_vec), axis = -1))] = np.cross([0,0,1], -ps_vec) # else: # phi1t[np.argmin(la.norm(local_zenith_vect-(-ps_vec), axis = -1))] = np.array([0, 1, 0]) # phi1t = phi1t / (la.norm(phi1t, axis=-1)[:,None]) # # Ranglet = np.arctan2(phi1t.dot(alpha0), phi1t.dot(phi0))#rotation angle for polarization coord over t, from equatotial(phi0,alpha0) to local(phi1,alpha1), around vector -ps_vec if np.abs(ps_vec[-1]) == 1: ps_equ_north_plane = np.array([0, 1, 0]) else: ps_equ_north_plane = np.cross([0, 0, 1], ps_vec) ps_equ_north_plane /= la.norm(ps_equ_north_plane)#normal vector of the plane defined by point source vec and north vec in equatorial ps_local_north_plane_t = np.cross(local_zenith_vect, ps_vec) ps_local_north_plane_t /= la.norm(ps_local_north_plane_t, axis=-1)[:, None]#normal vector of the plane defined by point source vec and north vec in local coord Ranglet = -np.sign(np.cross(ps_local_north_plane_t, ps_equ_north_plane).dot(ps_vec)) * np.arccos(ps_local_north_plane_t.dot(ps_equ_north_plane)) Ranglet = rotatez_matrix(Ranglet)[:2,:2]#rotation matrix around -ps_vec for polarization coord over t, 3 by 3 by t BRt = np.array([beamt[..., i].dot(Ranglet[...,i]) for i in range(len(tlist))]) if verbose: print "R" print Ranglet print "B" print BRt result = np.empty((len(d_in), 4 * len(tlist), 4), dtype='complex64')#time is fastest changing in 4 by t for truen, (truei, truej) in enumerate([[0,0],[0,1],[1,0],[1,1]]): for measuren, (measurei, measurej) in enumerate([[0,0],[0,1],[1,0],[1,1]]): result[:, measuren*len(tlist):(measuren+1)*len(tlist), truen] = (BRt[:, measurei,truei] * np.conjugate(BRt[:, measurej,truej]))[None,:]*fringe return result
pca3 = hp.fitsfunc.read_map(script_dir + '/../data/gsm3.fits' + str(nside_standard)) components = np.loadtxt(script_dir + '/../data/components.dat') scale_loglog = si.interp1d(np.log(components[:, 0]), np.log(components[:, 1])) w1 = si.interp1d(components[:, 0], components[:, 2]) w2 = si.interp1d(components[:, 0], components[:, 3]) w3 = si.interp1d(components[:, 0], components[:, 4]) gsm_standard = np.exp(scale_loglog(np.log(freq))) * (w1(freq) * pca1 + w2(freq) * pca2 + w3(freq) * pca3) # rotate sky map and converts to nest equatorial_GSM_standard = np.zeros(12 * nside_standard ** 2, 'float') print "Rotating GSM_standard and converts to nest...", sys.stdout.flush() equ2013_to_gal_matrix = hp.rotator.Rotator(coord='cg').mat.dot(sv.epoch_transmatrix(2000, stdtime=2013.58)) ang0, ang1 = hp.rotator.rotateDirection(equ2013_to_gal_matrix, hpf.pix2ang(nside_standard, range(12 * nside_standard ** 2), nest=True)) equatorial_GSM_standard = hpf.get_interp_val(gsm_standard, ang0, ang1) print "done." sys.stdout.flush() ###UBL#### ubls = {} for p in ['x', 'y']: ubl_filename = datadir + tag + '_%s%s_%i_%i.ubl' % (p, p, nUBL, 3) ubls[p] = np.fromfile(ubl_filename, dtype='float32').reshape((nUBL, 3)) common_ubls = np.array([u for u in ubls['x'] if (u in ubls['y'] or -u in ubls['y'])]) #manually filter UBLs used_common_ubls = common_ubls#[np.argsort(la.norm(common_ubls, axis=-1))[10:]] #remove shorted 10 ubl_index = {} # stored index in each pol's ubl for the common ubls
new_phi_arr[i] = -phi_arr[i] else: new_phi_arr[i] = 360 - phi_arr[i] pix = np.zeros(len(new_theta_arr)) for i in range(len(new_theta_arr)): pix[i] = hp.ang2pix(NSIDE, new_phi_arr[i], new_theta_arr[i], lonlat=True) sky_map[int(pix[i])] = eff_area_arr[i] NSIDE_NEW = 64 all_pix_ids = np.arange(0, hp.nside2npix(NSIDE_NEW)) all_theta, all_phi = hp.pix2ang(NSIDE_NEW, all_pix_ids, lonlat=True) new_map = get_interp_val(sky_map, all_theta, all_phi, lonlat=True) print len(new_map) hp.mollview(new_map, rot=(0, 90), cmap="gist_earth_r", cbar=False) hp.graticule() hp.projtext(0, 0, "X", fontsize=15, lonlat=True) hp.projtext(-90, 0, "Y", fontsize=15, lonlat=True) plt.title("All sky sensitivity at 120keV") fig = plt.gcf() ax = plt.gca() image = ax.get_images()[0] cbar = fig.colorbar(image, ax=ax, orientation="horizontal", fraction=0.046, pad=0.04)
str(nside_standard)) pca3 = hp.fitsfunc.read_map( '/home/omniscope/simulate_visibilities/data/gsm3.fits' + str(nside_standard)) gsm_standard = 422.952 * (0.307706 * pca1 + -0.281772 * pca2 + 0.0123976 * pca3) equatorial_GSM_standard = np.zeros(12 * nside_standard**2, 'float') #rotate sky map print "Rotating GSM_standard...", sys.stdout.flush() equ2013_to_gal_matrix = hp.rotator.Rotator(coord='cg').mat.dot( sv.epoch_transmatrix(2000, stdtime=2013.8)) ang0, ang1 = hp.rotator.rotateDirection( equ2013_to_gal_matrix, hpf.pix2ang(nside_standard, range(12 * nside_standard**2))) equatorial_GSM_standard = hpf.get_interp_val(gsm_standard, ang0, ang1) print "done." sys.stdout.flush() sim_data_clean = A.dot(equatorial_GSM_standard[pix_mask]) noise_data = np.random.randn(len(data)) / Ni**.5 sim_data = sim_data_clean + noise_data sim_sol = np.zeros(12 * nside**2, dtype='float32') sim_sol[pix_mask] = AtNiAi.dot(AtNi.dot(sim_data)) noise_sol = np.zeros(12 * nside**2, dtype='float32') noise_sol[pix_mask] = AtNiAi.dot(AtNi.dot(noise_data)) sim_sol_clean = np.zeros(12 * nside**2, dtype='float32') sim_sol_clean[pix_mask] = AtNiAi.dot(AtNi.dot(sim_data_clean)) chisq = np.sum(Ni * np.abs( (A.dot(x[pix_mask]) - data))**2) / float(len(data) - npix)
str(nside_standard)) pca2 = hp.fitsfunc.read_map( '/home/omniscope/simulate_visibilities/data/gsm2.fits' + str(nside_standard)) pca3 = hp.fitsfunc.read_map( '/home/omniscope/simulate_visibilities/data/gsm3.fits' + str(nside_standard)) gsm_standard = 422.952 * (0.307706 * pca1 + -0.281772 * pca2 + 0.0123976 * pca3) equatorial_GSM_standard = np.zeros(12 * nside_standard**2, 'float') #rotate sky map print "Rotating GSM_standard...", sys.stdout.flush() for i in range(12 * nside_standard**2): ang = hp.rotator.Rotator(coord='cg')(hpf.pix2ang(nside_standard, i)) equatorial_GSM_standard[i] = hpf.get_interp_val(gsm_standard, ang[0], ang[1]) print "done." sys.stdout.flush() if nside != nside_standard: if nside > 4: pca1 = hp.fitsfunc.read_map( '/home/omniscope/simulate_visibilities/data/gsm1.fits' + str(nside)) pca2 = hp.fitsfunc.read_map( '/home/omniscope/simulate_visibilities/data/gsm2.fits' + str(nside)) pca3 = hp.fitsfunc.read_map( '/home/omniscope/simulate_visibilities/data/gsm3.fits' + str(nside)) gsm = 422.952 * (0.307706 * pca1 + -0.281772 * pca2 + 0.0123976 * pca3)
pca3 = hp.fitsfunc.read_map(script_dir + '/../data/gsm3.fits' + str(nside_standard)) components = np.loadtxt(script_dir + '/../data/components.dat') scale_loglog = si.interp1d(np.log(components[:, 0]), np.log(components[:, 1])) w1 = si.interp1d(components[:, 0], components[:, 2]) w2 = si.interp1d(components[:, 0], components[:, 3]) w3 = si.interp1d(components[:, 0], components[:, 4]) gsm_standard = np.exp(scale_loglog(np.log(freq))) * (w1(freq) * pca1 + w2(freq) * pca2 + w3(freq) * pca3) # rotate sky map and converts to nest equatorial_GSM_standard = np.zeros(12 * nside_standard ** 2, 'float') print "Rotating GSM_standard and converts to nest...", sys.stdout.flush() equ2013_to_gal_matrix = hp.rotator.Rotator(coord='cg').mat.dot(sv.epoch_transmatrix(2000, stdtime=2013.58)) ang0, ang1 = hp.rotator.rotateDirection(equ2013_to_gal_matrix, hpf.pix2ang(nside_standard, range(12 * nside_standard ** 2), nest=True)) equatorial_GSM_standard = hpf.get_interp_val(gsm_standard, ang0, ang1) print "done." sys.stdout.flush() nside_distribution = np.zeros(12 * nside_standard ** 2) final_index = np.zeros(12 * nside_standard ** 2, dtype=int) thetas, phis, sizes = [], [], [] abs_thresh = np.mean(equatorial_GSM_standard) * thresh pixelize(equatorial_GSM_standard, nside_distribution, nside_standard, nside_start, abs_thresh, final_index, thetas, phis, sizes) npix = len(thetas) valid_pix_mask = hpf.get_interp_val(equatorial_GSM_standard, thetas, phis, nest=True) > valid_pix_thresh * max(equatorial_GSM_standard) valid_npix = np.sum(valid_pix_mask) print '>>>>>>VALID NPIX =', valid_npix
nside = min(nside, 512) L = nside*3 - 1 print "Using nside = %i for GSM."%nside, sys.stdout.flush() if nside not in GSMs: print "Loading..." sys.stdout.flush() pcas = [hp.fitsfunc.read_map(datadir + '/gsm%i.fits'%(i+1) + str(nside), verbose=False) for i in range(3)] print "done.", sys.stdout.flush() ####rotate sky map and get alm print "Rotating GSM", sys.stdout.flush() GSMs[nside] = np.zeros((3,12*nside**2),'float') for i in range(12*nside**2): ang = g2e_rotator(hpf.pix2ang(nside,i)) for j in range(3): GSMs[nside][j,i] = hpf.get_interp_val(pcas[j], ang[0], ang[1]) print "Done." gsm_weights = gsm_weights_f(np.log(freqs[f])) print "GSM weights:", gsm_weights sys.stdout.flush() gsm = gsm_weights[0]*(gsm_weights[1]*GSMs[nside][0] + gsm_weights[2]*GSMs[nside][1] + gsm_weights[3]*GSMs[nside][2]) alm = sv.convert_healpy_alm(hp.sphtfunc.map2alm(gsm), 3 * nside - 1) result = vs.calculate_visibility(sv.expand_real_alm(alm), d=ubl, freq=freqs[f], nt=nt, L = 3*nside-1, verbose = True) result.astype('complex64').tofile(opdir+'/Visibilties_for_%i_south_%i_east_0_up_%s%s_pol_%.1f_MHz_%i_step.bin'%(unit_ubl[0],unit_ubl[1],pol,pol,freqs[f],nt)) print "Time taken %.4f"%(float((time.time()-timer)/60.))
print "Memory usage: %.3fMB"%(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1000) #simulate data using GSM nside_standard = nside pca1 = hp.fitsfunc.read_map('/home/omniscope/simulate_visibilities/data/gsm1.fits' + str(nside_standard)) pca2 = hp.fitsfunc.read_map('/home/omniscope/simulate_visibilities/data/gsm2.fits' + str(nside_standard)) pca3 = hp.fitsfunc.read_map('/home/omniscope/simulate_visibilities/data/gsm3.fits' + str(nside_standard)) gsm_standard = 422.952*(0.307706*pca1+-0.281772*pca2+0.0123976*pca3) equatorial_GSM_standard = np.zeros(12*nside_standard**2,'float') #rotate sky map print "Rotating GSM_standard...", sys.stdout.flush() #print hp.rotator.Rotator(coord='cg').mat for i in range(12*nside_standard**2): ang = hp.rotator.Rotator(coord='cg')(hpf.pix2ang(nside_standard,i)) equatorial_GSM_standard[i] = hpf.get_interp_val(gsm_standard, ang[0], ang[1]) print "done." sys.stdout.flush() print "Simulating GSM data...", sys.stdout.flush() sim_data = np.array([A[i].dot(equatorial_GSM_standard[pix_mask]) for i in range(len(A))]) + np.random.randn(len(data))/Ni**.5 print "done." sys.stdout.flush() #compute At.y print "Computing At.y...", sys.stdout.flush() qaz = Ni * data Atdata = np.array([A[:, i].dot(qaz) for i in range(len(A[0]))]) qaz = Ni * sim_data
sys.stdout.flush() pcas = [ hp.fitsfunc.read_map(datadir + '/gsm%i.fits' % (i + 1) + str(nside), verbose=False) for i in range(3) ] print "done.", sys.stdout.flush() ####rotate sky map and get alm print "Rotating GSM", sys.stdout.flush() GSMs[nside] = np.zeros((3, 12 * nside**2), 'float') for i in range(12 * nside**2): ang = g2e_rotator(hpf.pix2ang(nside, i)) for j in range(3): GSMs[nside][j, i] = hpf.get_interp_val( pcas[j], ang[0], ang[1]) print "Done." gsm_weights = gsm_weights_f(np.log(freqs[f])) print "GSM weights:", gsm_weights sys.stdout.flush() gsm = gsm_weights[0] * (gsm_weights[1] * GSMs[nside][0] + gsm_weights[2] * GSMs[nside][1] + gsm_weights[3] * GSMs[nside][2]) alm = sv.convert_healpy_alm(hp.sphtfunc.map2alm(gsm), 3 * nside - 1) result = vs.calculate_visibility(sv.expand_real_alm(alm), d=ubl, freq=freqs[f], nt=nt, L=3 * nside - 1, verbose=True)
x[pix_mask] = AtNiAi.dot(AtNi.dot(data)) #simulate nside_standard = nside pca1 = hp.fitsfunc.read_map('/home/omniscope/simulate_visibilities/data/gsm1.fits' + str(nside_standard)) pca2 = hp.fitsfunc.read_map('/home/omniscope/simulate_visibilities/data/gsm2.fits' + str(nside_standard)) pca3 = hp.fitsfunc.read_map('/home/omniscope/simulate_visibilities/data/gsm3.fits' + str(nside_standard)) gsm_standard = 422.952*(0.307706*pca1+-0.281772*pca2+0.0123976*pca3) equatorial_GSM_standard = np.zeros(12*nside_standard**2,'float') #rotate sky map print "Rotating GSM_standard...", sys.stdout.flush() equ2013_to_gal_matrix = hp.rotator.Rotator(coord='cg').mat.dot(sv.epoch_transmatrix(2000,stdtime=2013.8)) ang0, ang1 =hp.rotator.rotateDirection(equ2013_to_gal_matrix, hpf.pix2ang(nside_standard, range(12*nside_standard**2))) equatorial_GSM_standard = hpf.get_interp_val(gsm_standard, ang0, ang1) print "done." sys.stdout.flush() sim_data_clean = A.dot(equatorial_GSM_standard[pix_mask]) noise_data = np.random.randn(len(data))/Ni**.5 sim_data = sim_data_clean + noise_data sim_sol = np.zeros(12*nside**2, dtype='float32') sim_sol[pix_mask] = AtNiAi.dot(AtNi.dot(sim_data)) noise_sol = np.zeros(12*nside**2, dtype='float32') noise_sol[pix_mask] = AtNiAi.dot(AtNi.dot(noise_data)) sim_sol_clean = np.zeros(12*nside**2, dtype='float32') sim_sol_clean[pix_mask] = AtNiAi.dot(AtNi.dot(sim_data_clean)) chisq = np.sum(Ni * np.abs((A.dot(x[pix_mask]) - data))**2) / float(len(data) - npix) chisq_sim = np.sum(Ni * np.abs((A.dot(sim_sol[pix_mask]) - sim_data))**2) / float(len(sim_data) - npix)
if abs(dec - lat_degree * np.pi / 180) <= np.pi / 2: A[p][:, i] = vs.calculate_pointsource_visibility(ra, dec, ubls, freq, beam_heal_equ=beam_heal_equ, tlist=tlist).flatten() print "%f minutes used" % (float(time.time() - timer) / 60.) sys.stdout.flush() A[p].tofile(A_path) #################################################### ###beam weights using an equal pixel A matrix###### ################################################# print "Computing beam weight...", sys.stdout.flush() beam_weight = ((la.norm(A['x'], axis=0) ** 2 + la.norm(A['y'], axis=0) ** 2) ** .5)[hpf.nest2ring(nside_beamweight, range(12 * nside_beamweight ** 2))] beam_weight = beam_weight / np.mean(beam_weight) thetas_standard, phis_standard = hpf.pix2ang(nside_standard, range(hpf.nside2npix(nside_standard)), nest=True) beam_weight = hpf.get_interp_val(beam_weight, thetas_standard, phis_standard, nest=True) #np.array([beam_weight for i in range(nside_standard ** 2 / nside_beamweight ** 2)]).transpose().flatten() print "done." sys.stdout.flush() ################################################ #####################GSM########################### ############################################# pca1 = hp.fitsfunc.read_map(script_dir + '/../data/gsm1.fits' + str(nside_standard)) pca2 = hp.fitsfunc.read_map(script_dir + '/../data/gsm2.fits' + str(nside_standard)) pca3 = hp.fitsfunc.read_map(script_dir + '/../data/gsm3.fits' + str(nside_standard)) components = np.loadtxt(script_dir + '/../data/components.dat') scale_loglog = si.interp1d(np.log(components[:, 0]), np.log(components[:, 1])) w1 = si.interp1d(components[:, 0], components[:, 2]) w2 = si.interp1d(components[:, 0], components[:, 3]) w3 = si.interp1d(components[:, 0], components[:, 4]) gsm_standard = np.exp(scale_loglog(np.log(freq))) * (w1(freq) * pca1 + w2(freq) * pca2 + w3(freq) * pca3)
print "done." sys.stdout.flush() #hpv.mollview(beam_weight, nest=True) #plt.show() #quit() ################################################ #####################GSM########################### ############################################# #rotate sky map and converts to nest equatorial_GSM_standard_2000 = np.fromfile(datadir + 'skymap_mwacs_nside256_float32.dat', dtype='float32') print "Rotating GSM_standard and converts to nest...", sys.stdout.flush() equ2013_to_equ2000_matrix = sv.epoch_transmatrix(2000,stdtime=2013.64) ang0, ang1 =hp.rotator.rotateDirection(equ2013_to_equ2000_matrix, hpf.pix2ang(nside_standard, range(12*nside_standard**2), nest=True)) equatorial_GSM_standard = hpf.get_interp_val(equatorial_GSM_standard_2000, ang0, ang1) print "done." sys.stdout.flush() #hpv.mollview(np.log10(equatorial_GSM_standard), min=-3.5,max=1.5, coord=plotcoord, title='GSM', nest=True) #plt.show() #quit() ######################################################################## ########################processing dynamic pixelization###################### ######################################################################## nside_distribution = np.zeros(12*nside_standard**2) final_index = np.zeros(12*nside_standard**2) thetas, phis, sizes = [], [], [] abs_thresh = np.mean(equatorial_GSM_standard * beam_weight) * thresh pixelize(equatorial_GSM_standard * beam_weight, nside_distribution, nside_standard, nside_start, abs_thresh, final_index, thetas, phis, sizes)
beam_healpix={} beam_healpix['x'] = abs(local_beam(freqs[pick_f])[0])**2 + abs(local_beam(freqs[pick_f])[1])**2 beam_healpix['y'] = abs(local_beam(freqs[pick_f])[2])**2 + abs(local_beam(freqs[pick_f])[3])**2 ################################### ###########simulate## cal_sources = ['cyg', 'cas'] ps_visibilities = {} for source in cal_sources: phis = PI - southern_points[source]['pos'][:, 1] thetas = PI/2 - southern_points[source]['pos'][:, 0] ks = np.array([np.cos(phis)*np.sin(thetas), np.sin(phis)*np.sin(thetas), np.cos(thetas)]) fringes = np.exp(1.j * TPI/lambdas[pick_f] * (info['ubl'].dot(correction_mat)).dot(ks)).transpose() ps_visibilities[source] = {} for pol in ['xx', 'yy']: b_values = hpf.get_interp_val(beam_healpix[pol[0]], thetas, phis) ps_visibilities[source][pol] = b_values[:, None]*fringes*flux_func[source](freqs[pick_f])/2 ################################### ##########calibrate ################################# ##This part decides which lst_range and min ubl length to use rawdata = {} simdata = {} rawdata['xx'] = np.copy(compressed_data[0,~compr_flag[:, pick_f],pick_f]) rawdata['yy'] = np.copy(compressed_data[3,~compr_flag[:, pick_f],pick_f]) for pol in ['xx', 'yy']: simdata[pol] = np.sum([ps_visibilities[source][pol] for source in cal_sources], axis = 0)