示例#1
0
def query_disc(nside, vec, radius, inclusive=False, fact=4, nest=False):
    """
    Wrapper around healpy.query_disc to deal with old healpy implementation.

    nside : int
      The nside of the Healpix map.
    vec : float, sequence of 3 elements
      The coordinates of unit vector defining the disk center.
    radius : float
      The radius (in degrees) of the disc
    inclusive : bool, optional
      If False, return the exact set of pixels whose pixel centers lie 
      within the disk; if True, return all pixels that overlap with the disk,
      and maybe a few more. Default: False
    fact : int, optional
      Only used when inclusive=True. The overlapping test will be done at
      the resolution fact*nside. For NESTED ordering, fact must be a power of 2,
      else it can be any positive integer. Default: 4.
    nest: bool, optional
      if True, assume NESTED pixel ordering, otherwise, RING pixel ordering

    """
    try: 
        # New-style call (healpy 1.6.3)
        return hp.query_disc(nside, vec, np.radians(radius), inclusive, fact, nest)
    except Exception as e: 
        print(e)
        # Old-style call (healpy 0.10.2)
        return hp.query_disc(nside, vec, np.radians(radius), nest, deg=False)
示例#2
0
    def compute_luminosity(self, SZ_map):

        self.compute_FWHM_in_degrees(SZ_map)
        NSIDE = hp.get_nside(SZ_map)

        pixels_in_disk = hp.query_disc(NSIDE,
                                       hp.pix2vec(NSIDE, self.peak_index),
                                       np.radians(self.FWHM * 1.5))
        nb_pixels_disk = len(pixels_in_disk)
        vania_luminosity = 0

        for pixel in pixels_in_disk:
            vania_luminosity += SZ_map[pixel]

        inner_ring = hp.query_disc(NSIDE, hp.pix2vec(NSIDE, self.peak_index),
                                   np.radians(self.FWHM * 3.5))
        outer_ring = hp.query_disc(NSIDE, hp.pix2vec(NSIDE, self.peak_index),
                                   np.radians(self.FWHM * 5.5))
        pixels_values_ring = list()
        nb_pixels_background = len(outer_ring) - len(inner_ring)

        for pixel in outer_ring:
            if not (pixel in inner_ring):
                pixels_values_ring.append(SZ_map[pixel])

        self.luminosity_error = np.std(pixels_values_ring)
        local_noise_ring = sum(pixels_values_ring)
        self.luminosity = vania_luminosity - local_noise_ring * (
            nb_pixels_disk / nb_pixels_background)
        print 'luminosity = %s \pm %s' % (self.luminosity,
                                          self.luminosity_error)
示例#3
0
def test_combine(tmpdir):
    """Test ligo-skymap-combine."""
    fn1 = str(tmpdir / 'skymap1.fits.gz')
    fn2 = str(tmpdir / 'skymap2.fits.gz')
    fn3 = str(tmpdir / 'joint_skymap.fits.gz')

    # generate a hemisphere of constant probability
    nside1 = 32
    npix1 = ah.nside_to_npix(nside1)
    m1 = np.zeros(npix1)
    disc_idx = hp.query_disc(nside1, (1, 0, 0), np.pi / 2)
    m1[disc_idx] = 1
    m1 /= m1.sum()
    hp.write_map(fn1,
                 m1,
                 column_names=['PROBABILITY'],
                 extra_header=[('INSTRUME', 'X1')])

    # generate another hemisphere of constant probability
    # but with higher resolution and rotated 90 degrees
    nside2 = 64
    npix2 = ah.nside_to_npix(nside2)
    m2 = np.zeros(npix2)
    disc_idx = hp.query_disc(nside2, (0, 1, 0), np.pi / 2)
    m2[disc_idx] = 1
    m2 /= m2.sum()
    hp.write_map(fn2,
                 m2,
                 column_names=['PROBABILITY'],
                 extra_header=[('INSTRUME', 'Y1')])

    run_entry_point('ligo-skymap-combine', fn1, fn2, fn3)

    m3 = hp.read_map(fn3, nest=True)
    npix3 = len(m3)
    nside3 = ah.npix_to_nside(npix3)
    pix_area3 = ah.nside_to_pixel_area(nside3).to_value(u.sr)

    # resolution must match the highest original resolution
    assert npix3 == npix2
    # probability must be normalized to 1
    assert m3.sum() == pytest.approx(1)
    # support must be ¼ of the sphere
    tolerance = 10 * ah.nside_to_pixel_area(nside1).to_value(u.sr)
    assert sum(m3 > 0) * pix_area3 == pytest.approx(np.pi, abs=tolerance)

    # generate a BAYESTAR-like map with mock distance information
    d_mu = np.zeros_like(m1)
    d_sigma = np.ones_like(m1)
    d_norm = np.ones_like(m1)
    io.write_sky_map(fn1, [m1, d_mu, d_sigma, d_norm])

    run_entry_point('ligo-skymap-combine', fn1, fn2, fn3)

    m3, meta3 = io.read_sky_map(fn3, nest=True, distances=True)

    # check that marginal distance moments match what was simulated
    mean, std, _ = distance.parameters_to_moments(d_mu[0], d_sigma[0])
    assert meta3['distmean'] == pytest.approx(mean)
    assert meta3['diststd'] == pytest.approx(std)
示例#4
0
def get_hem_Cls(skymap, direction, LMAX=256, deg=90.):
    """
    from the given healpix skymap, return Cls for two hemispheres defined by the
    direction given, useful to study the possible scale dependence of power modulation

    direction should be a unit vector
    """
    # generate hemispherical mask
    NPIX = len(skymap)
    NSIDE = hp.npix2nside(NPIX)
    maskp = np.array([0.] * NPIX)
    disc = hp.query_disc(nside=NSIDE, vec=direction, radius=0.0174532925 * deg)
    maskp[disc] = 1.
    #skymap=hp.remove_monopole(skymap)
    map1 = hp.ma(skymap)
    map1.mask = maskp
    Clsp = hp.anafast(map1, lmax=LMAX * 2.0)
    if (deg < 90.):
        maskm = np.array([0.] * NPIX)
        disc = hp.query_disc(nside=NSIDE,
                             vec=-direction,
                             radius=0.0174532925 * deg)
        maskm[disc] = 1.
        map1.mask = maskm
    else:
        map1.mask = np.logical_not(maskp)

    Clsm = hp.anafast(map1, lmax=LMAX * 2.0)

    return [Clsp[0:LMAX + 1], Clsm[0:LMAX + 1]]
示例#5
0
文件: mkcsi.py 项目: nmik/GRATools
def csi_compute(param):
    """worker function"""
    get_var_from_file(os.path.join(GRATOOLS_CONFIG, 'Csi_config.py'))
    th_bins = data.TH_BINNING
    i, veci, dI, R, nside = param
    if i%10000 == 0:
        print i
    dIi = dI[i]
    Ri = R[i]
    dIij_list = [[] for l in range(0, len(th_bins)-1)]
    counts_list = [[] for l in range(0, len(th_bins)-1)]
    Rij_list = [[] for l in range(0, len(th_bins)-1)]
    for th, (thmin, thmax) in enumerate(zip(th_bins[:-1], th_bins[1:])):
        pixintorad_min = hp.query_disc(nside, veci, thmin)
        pixintorad_max = hp.query_disc(nside, veci, thmax)
        pixintoring = np.setxor1d(pixintorad_max, pixintorad_min)
        Rj = R[pixintoring]
        Rj = Rj[Rj > hp.UNSEEN]
        dIj = dI[pixintoring]
        dIj = dIj[dIj > hp.UNSEEN]
        dIij = np.sum(dIi*dIj)#-Imean**2)
        Rij = np.sum(Ri*Rj)
        counts = len(dIj)
        dIij_list[th].append(dIij)
        counts_list[th].append(counts)
        Rij_list[th].append(Rij)
    return dIij_list, counts_list, Rij_list
示例#6
0
    def get_index_list(nside, nest, region):
        """ Returns the list of pixels indices for all the pixels in a region

        nside    : HEALPix nside parameter
        nest     : True for 'NESTED', False = 'RING'
        region   : HEALPix region string
        """

        tokens = parse_hpxregion(region)
        if tokens[0] == 'DISK':
            vec = coords_to_vec(float(tokens[1]), float(tokens[2]))
            ilist = hp.query_disc(nside, vec[0], np.radians(float(tokens[3])),
                                  inclusive=False, nest=nest)
        elif tokens[0] == 'DISK_INC':
            vec = coords_to_vec(float(tokens[1]), float(tokens[2]))
            ilist = hp.query_disc(nside, vec[0], np.radians(float(tokens[3])),
                                  inclusive=True, fact=int(tokens[4]),
                                  nest=nest)
        elif tokens[0] == 'HPX_PIXEL':
            nside_pix = int(tokens[2])
            if tokens[1] == 'NESTED':
                ipix_ring = hp.nest2ring(nside_pix, int(tokens[3]))
            elif tokens[1] == 'RING':
                ipix_ring = int(tokens[3])
            else:
                raise Exception(
                    "Did not recognize ordering scheme %s" % tokens[1])
            ilist = match_hpx_pixel(nside, nest, nside_pix, ipix_ring)
        else:
            raise Exception(
                "HPX.get_index_list did not recognize region type %s" % tokens[0])
        return ilist
示例#7
0
文件: gMasks.py 项目: nmik/GRATools
def mask_extsrc(cat_file, MASK_S_RAD, NSIDE):
    """Returns the 'bad pixels' defined by the position of a source and a 
       certain radius away from that point.

       cat_file: str
           .fits file of the sorce catalog
       MASK_S_RAD: float
           radius around each source definig bad pixels to mask
       NSIDE: int
           healpix nside parameter
    """
    logger.info('Mask for extended sources activated')
    src_cat = pf.open(cat_file)
    NPIX = hp.pixelfunc.nside2npix(NSIDE)
    CAT_EXTENDED = src_cat['ExtendedSources']
    BAD_PIX_SRC = []
    EXT_SOURCES = CAT_EXTENDED.data
    src_cat.close()
    for i, src in enumerate(EXT_SOURCES):
        NAME = EXT_SOURCES.field('Source_Name')[i]
        GLON = EXT_SOURCES.field('GLON')[i]
        GLAT = EXT_SOURCES.field('GLAT')[i]
        if 'LMC' in NAME or 'CenA Lobes' in NAME:
            x, y, z = hp.rotator.dir2vec(GLON,GLAT,lonlat=True)
            b_pix= hp.pixelfunc.vec2pix(NSIDE, x, y, z)
            BAD_PIX_SRC.append(b_pix) 
            radintpix = hp.query_disc(NSIDE, (x, y, z), np.radians(10))
            BAD_PIX_SRC.extend(radintpix)
        else:
            x, y, z = hp.rotator.dir2vec(GLON,GLAT,lonlat=True)
            b_pix = hp.pixelfunc.vec2pix(NSIDE, x, y, z)
            BAD_PIX_SRC.append(b_pix) 
            radintpix = hp.query_disc(NSIDE, (x, y, z), np.radians(5))
            BAD_PIX_SRC.extend(radintpix)
    return BAD_PIX_SRC
示例#8
0
def get_disk(mask, pos_src, out_edge, in_edge, tol=1):
    '''
    Return unmasked pixel indices of disks centred at a source.
    For usage purpose the input includes two disks.
    Input: mask: mask healpix map;
           pos_src: position of source (with shape=3);
           out_edge: outer disk centred at each source(in arcmin);
           in_edge: inner disk centred at each source(in arcmin);
           tol: tolerance between 0 and 1 indicating a threshold of fraction of
                unmasked pixels in a disk
    Output: pixel indices of both disks.
    '''

    Ns = hp.npix2nside(mask.size)

    list_out = hp.query_disc(Ns, pos_src, np.radians(out_edge / 60.))
    npix_out = len(list_out)

    list_out_unmasked = list_out[mask[list_out] > 0]

    if (list_out_unmasked.size < tol * npix_out):

        return [0, 0]
    lon, lat = hp.vec2dir(pos_src, lonlat=True)
    list_in = hp.query_disc(Ns, pos_src, np.radians(in_edge / 60.))
    list_in_unmasked = list_in[mask[list_in] > 0]
    return list_out_unmasked, list_in_unmasked
def query_disc(nside, vec, radius, inclusive=False, fact=4, nest=False):
    """
    Wrapper around healpy.query_disc to deal with old healpy implementation.
    nside : int
      The nside of the Healpix map.
    vec : float, sequence of 3 elements
      The coordinates of unit vector defining the disk center.
    radius : float
      The radius (in degrees) of the disc
    inclusive : bool, optional
      If False, return the exact set of pixels whose pixel centers lie 
      within the disk; if True, return all pixels that overlap with the disk,
      and maybe a few more. Default: False
    fact : int, optional
      Only used when inclusive=True. The overlapping test will be done at
      the resolution fact*nside. For NESTED ordering, fact must be a power of 2,
      else it can be any positive integer. Default: 4.
    nest: bool, optional
      if True, assume NESTED pixel ordering, otherwise, RING pixel ordering
    """
    try: 
        # New-style call (healpy 1.6.3)
        return hp.query_disc(nside, vec, np.radians(radius), inclusive, fact, nest)
    except Exception as e: 
        print(e)
        # Old-style call (healpy 0.10.2)
        return hp.query_disc(nside, vec, np.radians(radius), nest, deg=False)
示例#10
0
    def get_index_list(nside, nest, region):
        """ Returns the list of pixels indices for all the pixels in a region

        nside    : HEALPix nside parameter
        nest     : True for 'NESTED', False = 'RING'
        region   : HEALPix region string
        """
        import healpy as hp
        tokens = re.split('\(|\)|,', region)
        if tokens[0] == 'DISK':
            vec = coords_to_vec(float(tokens[1]), float(tokens[2]))
            ilist = hp.query_disc(nside, vec[0], np.radians(float(tokens[3])),
                                  inclusive=False, nest=nest)
        elif tokens[0] == 'DISK_INC':
            vec = coords_to_vec(float(tokens[1]), float(tokens[2]))
            ilist = hp.query_disc(nside, vec[0], np.radians(float(tokens[3])),
                                  inclusive=True, fact=int(tokens[4]),
                                  nest=nest)
        elif tokens[0] == 'HPX_PIXEL':
            nside_pix = int(tokens[2])
            if tokens[1] == 'NESTED':
                ipix_ring = hp.nest2ring(nside_pix, int(tokens[3]))
            elif tokens[1] == 'RING':
                ipix_ring = int(tokens[3])
            else:
                raise Exception(
                    "Did not recognize ordering scheme %s" % tokens[1])
            ilist = match_hpx_pixel(nside, nest, nside_pix, ipix_ring)
        else:
            raise Exception(
                "HPX.get_index_list did not recognize region type %s" % tokens[0])
        return ilist
示例#11
0
def get_hem_Cls(skymap, direction, LMAX=256, deg=90.):
    """
    from the given healpix skymap, return Cls for two hemispheres defined by the
    direction given, useful to study the possible scale dependence of power modulation

    direction should be a unit vector
    """
    # generate hemispherical mask
    NPIX=len(skymap)
    NSIDE=hp.npix2nside(NPIX)
    maskp=np.array([0.]*NPIX)
    disc=hp.query_disc(nside=NSIDE, vec=direction, radius=0.0174532925*deg)
    maskp[disc]=1.
    #skymap=hp.remove_monopole(skymap)
    map1=hp.ma(skymap)
    map1.mask=maskp
    Clsp=hp.anafast(map1, lmax=LMAX)
    if (deg<90.):
        maskm=np.array([0.]*NPIX)
        disc=hp.query_disc(nside=NSIDE, vec=-direction, radius=0.0174532925*deg)
        maskm[disc]=1.
        map1.mask=maskm
    else:
        map1.mask=np.logical_not(maskp)

    Clsm=hp.anafast(map1, lmax=LMAX)

    return [Clsp, Clsm]
示例#12
0
def csi_compute(param):
    """worker function"""
    get_var_from_file(os.path.join(GRATOOLS_CONFIG, 'Csi_config.py'))
    th_bins = data.TH_BINNING
    i, veci, dI, R, nside = param
    if i % 10000 == 0:
        print i
    dIi = dI[i]
    Ri = R[i]
    dIij_list = [[] for l in range(0, len(th_bins) - 1)]
    counts_list = [[] for l in range(0, len(th_bins) - 1)]
    Rij_list = [[] for l in range(0, len(th_bins) - 1)]
    for th, (thmin, thmax) in enumerate(zip(th_bins[:-1], th_bins[1:])):
        pixintorad_min = hp.query_disc(nside, veci, thmin)
        pixintorad_max = hp.query_disc(nside, veci, thmax)
        pixintoring = np.setxor1d(pixintorad_max, pixintorad_min)
        Rj = R[pixintoring]
        Rj = Rj[Rj > hp.UNSEEN]
        dIj = dI[pixintoring]
        dIj = dIj[dIj > hp.UNSEEN]
        dIij = np.sum(dIi * dIj)  #-Imean**2)
        Rij = np.sum(Ri * Rj)
        counts = len(dIj)
        dIij_list[th].append(dIij)
        counts_list[th].append(counts)
        Rij_list[th].append(Rij)
    return dIij_list, counts_list, Rij_list
示例#13
0
    def get_disk(self, src_ind, out_edge, in_edge, tol=1):

        '''
        Return unmasked pixel indices of disks centred at a source.
        For usage purpose the input includes two disks.
        Input: src_ind: index of source;
               out_edge: outer disk centred at each source(in arcmin);
               in_edge: inner disk centred at each source(in arcmin);
               tol: tolerance between 0 and 1 indicating a threshold of 
               fraction of unmasked pixels in a disk
        Output: pixel indices of both disks.
        '''
        mask = self.mask
        Ns = self.Nside
        pos_src = self.pos_src_all[src_ind]

        list_out = hp.query_disc(Ns, pos_src, np.radians(out_edge / 60.))
        npix_out = len(list_out)

        list_out_unmasked = list_out[mask[list_out] > 0]

        if(list_out_unmasked.size < tol * npix_out):
            return [0, 0]
        lon, lat = hp.vec2dir(pos_src, lonlat=True)
        list_in = hp.query_disc(Ns, pos_src, np.radians(in_edge / 60.))
        list_in_unmasked = list_in[mask[list_in] > 0]
        return list_out_unmasked, list_in_unmasked
def find_biggest_pixel(ra, dec, radius, root_nside=1, max_nside=32):
    from astropy.coordinates import SkyCoord
    from astropy import units as u
    import healpy as hp
    import numpy as np

    nside = root_nside
    radius = np.radians(radius)
    sc = SkyCoord(ra=ra * u.degree, dec=dec * u.degree, frame='icrs')
    theta = sc.galactic.l.degree
    phi = sc.galactic.b.degree
    vec = hp.ang2vec(theta=theta, phi=phi, lonlat=True)

    pixels = hp.query_disc(vec=vec,
                           nside=nside,
                           radius=radius,
                           inclusive=False,
                           nest=True)
    while len(pixels) <= 1:
        if nside == max_nside:
            break
        nside *= 2
        pixels = hp.query_disc(vec=vec,
                               nside=nside,
                               radius=radius,
                               inclusive=False,
                               nest=True)
    if nside > 1:
        nside //= 2
    return nside, hp.vec2pix(nside, *vec, nest=True)
def CreateAnafastPartialSky_(cl,
                             nside,
                             lmin,
                             lmax,
                             delta_ell,
                             f_sky=2 / 100,
                             plot_results=False,
                             noise_rms=200):
    import NamasterLib as nam
    # Determine SEEN pixels from f_sky using query_disc
    vec = hp.pixelfunc.ang2vec(np.pi / 2, np.pi * 3 / 4)
    radius = f_sky * np.pi

    #print(np.array([cl.T[0,:]]).shape)

    ipix_disc = hp.query_disc(nside=nside, vec=vec, radius=radius, nest=False)
    while len(ipix_disc) < f_sky * 12 * nside**2:
        radius += 0.01 * np.pi
        ipix_disc = hp.query_disc(nside=nside,
                                  vec=vec,
                                  radius=radius,
                                  nest=False)
    #print("npix_partial_sky: ", len(ipix_disc))

    m = np.arange(12 * nside**2)
    m = np.delete(m, ipix_disc, axis=None)

    # Define the seen pixels
    seenpix = ipix_disc

    ### Making mask - it will be automaticall apodized when instanciating the object with default (tunable) parameters
    mask = np.zeros(12 * nside**2)
    mask[seenpix] = 1
    Namaster = nam.Namaster(mask, lmin=lmin, lmax=lmax, delta_ell=delta_ell)

    ell_binned, b = Namaster.get_binning(nside)
    # Get binned input spectra
    cl_theo_binned = np.zeros(shape=(4, ell_binned.shape[0]))
    for i in range(4):
        cl_theo_binned[i, :] = Namaster.bin_spectra(np.array([cl.T[i, :]]),
                                                    nside)

    map_ = hp.synfast(cl.T, nside, pixwin=False, verbose=False, new=True)
    npix = 12 * nside**2
    noise = np.random.randn(npix) * noise_rms
    map_partial = map_ + noise

    # Anafast spectrum of this map
    # Set UNSEEN pixels to hp.UNSEEN for Anafast
    map_partial[:, m] = hp.UNSEEN
    cl_ana, alm_ana = hp.anafast(map_partial, alm=True, lmax=lmax)

    # Get binned input spectra
    cl_ana_binned = np.zeros(shape=(4, ell_binned.shape[0]))
    for i in range(4):
        cl_ana_binned[i, :] = Namaster.bin_spectra(np.array([cl_ana[i, :]]),
                                                   nside)

    return alm_ana, cl_ana_binned, cl_theo_binned
示例#16
0
     def getAMatrix(self):
#         A = lil_matrix((self.Nd, self.Np), dtype=np.float32)
        data = []
        rows = []
        columns = []
        start = time.time()
        pixarea = hp.nside2pixarea(self.Nside, False)
        # get relevant pair of pixels
#         for j in range(1000):
        for j in range(self.Nd):
            qtheta1=self.q.theta[self.d.i1[j]]
            qphi1=self.q.phi[self.d.i1[j]]
            qtheta2=self.q.theta[self.d.i2[j]]
            qphi2=self.q.phi[self.d.i2[j]]
            
            q1 = self.Ang2Vec(qtheta1, qphi1)
            q2 = self.Ang2Vec(qtheta2, qphi2)
            #  rad = np.arccos(np.dot(q1,q2))
            #  if(rad <= self.resolution):
                #  s = np.array([self.d.hi1[j]])
            #  else:
            neipixels1=hp.query_disc(self.Nside, q1, self.sradius)
            neipixels2=hp.query_disc(self.Nside, q2, self.sradius)
            s = np.union1d(neipixels1, neipixels2)
            ss = set(s)
            smols = np.array([*ss.intersection(self.setpix)])
            jthrow = [self.pixdict[l] for l in smols]
            if (smols.shape[0] == 0):
                continue
            ms = np.array([self.hpix[x] for x in smols])
            
            d1 = q1 - ms
            d2 = q2 - ms

            norm1 = np.sqrt(np.einsum('ij,ij->i', d1, d1))       #Faster way to calculate norms
            norm2 = np.sqrt(np.einsum('ij,ij->i', d2, d2))

            resp1=1/norm1*(1-np.exp(-norm1**2/(self.sigweight)))
            resp2=1/norm2*(1-np.exp(-norm2**2/(self.sigweight)))
            
            drr = (d1.T*resp1).T - (d2.T*resp2).T
            dr = d1 - d2

            totresponse = 2*pixarea*np.einsum('ij,ij->i', drr, drr)/np.einsum('ij,ij->i',dr,dr)
            totresponse *= np.sqrt(self.d.weight[j])
            data += list(totresponse)
            rows += [j]*len(jthrow)
            columns += jthrow
            
#             A[j,jthrow] = totresponse
            if(j%1000==0):
                iteration = time.time()
                print("%i/%i with time: %f" % (j,self.Nd, iteration - start))
            
        print("Creating A matrix...")
#         A = scipy.sparse.csr_matrix((data, (rows, columns)), shape=(self.Nd, self.Np))
        A = csr_matrix((data, (rows, columns)), shape=(self.Nd, self.Np))
        return A
示例#17
0
    def get_index_list(nside, nest, region):
        """Get list of pixels indices for all the pixels in a region.

        Parameters
        ----------
        nside : int
            HEALPIX nside parameter
        nest : bool
            True for 'NESTED', False = 'RING'
        region : str
            HEALPIX region string

        Returns
        -------
        ilist : `~numpy.ndarray`
            List of pixel indices.
        """
        import healpy as hp

        # TODO: this should return something more friendly than a tuple
        # e.g. a namedtuple or a dict
        tokens = parse_hpxregion(region)

        reg_type = tokens[0]
        if reg_type == "DISK":
            lon, lat = float(tokens[1]), float(tokens[2])
            radius = np.radians(float(tokens[3]))
            vec = coords_to_vec(lon, lat)[0]
            ilist = hp.query_disc(nside,
                                  vec,
                                  radius,
                                  inclusive=False,
                                  nest=nest)
        elif reg_type == "DISK_INC":
            lon, lat = float(tokens[1]), float(tokens[2])
            radius = np.radians(float(tokens[3]))
            vec = coords_to_vec(lon, lat)[0]
            fact = int(tokens[4])
            ilist = hp.query_disc(nside,
                                  vec,
                                  radius,
                                  inclusive=True,
                                  nest=nest,
                                  fact=fact)
        elif reg_type == "HPX_PIXEL":
            nside_pix = int(tokens[2])
            if tokens[1] == "NESTED":
                ipix_ring = hp.nest2ring(nside_pix, int(tokens[3]))
            elif tokens[1] == "RING":
                ipix_ring = int(tokens[3])
            else:
                raise ValueError(f"Invalid ordering scheme: {tokens[1]!r}")
            ilist = match_hpx_pix(nside, nest, nside_pix, ipix_ring)
        else:
            raise ValueError(f"Invalid region type: {reg_type!r}")

        return ilist
示例#18
0
def get_annulus_galactic(phi,theta,R,hp_map,nside):
    vec = hp.ang2vec(theta,phi)
    R_rad_inner = (np.pi/180.)*R
    R_rad_outer = R_rad_inner*np.sqrt(2)
    pix_disc_out = hp.query_disc(nside,vec,R_rad_outer,inclusive = True)
    pix_disc_inner = hp.query_disc(nside,vec,R_rad_inner, inclusive = True)
    pix_annulus = np.setdiff1d(pix_disc_out,pix_disc_inner)
    vals_annulus = hp_map[pix_annulus]
    return pix_annulus, vals_annulus
示例#19
0
def get_annulus(RA, Dec, R, hp_map, nside):
    theta, phi = DeclRaToThetaPhi(Dec, RA)
    vec = hp.ang2vec(theta, phi)
    R_rad_inner = (np.pi / 180.) * R
    R_rad_outer = R_rad_inner * np.sqrt(2)
    pix_disc_out = hp.query_disc(nside, vec, R_rad_outer, inclusive=True)
    pix_disc_inner = hp.query_disc(nside, vec, R_rad_inner, inclusive=True)
    pix_annulus = np.setdiff1d(pix_disc_out, pix_disc_inner)
    vals_annulus = hp_map[pix_annulus]
    return pix_annulus, vals_annulus
示例#20
0
def get_probability_coverage(ft2file, ligo_map_file, met_t1, met_t2, theta_cut,
                             zenith_cut):

    ft2data = pyfits.getdata(ft2file)

    ligo_map = hp.read_map(ligo_map_file)

    # Probe NSIDE
    nside = hp.get_nside(ligo_map)

    # Get entries from the FT2 file every 10 s (cadence)

    start, ra_scz, dec_scz, ra_zenith, dec_zenith = _gtmktime(ft2data,
                                                              met_t1,
                                                              met_t2,
                                                              cadence=30)

    coverage = np.zeros_like(start)

    for i, (t, rz, dz, rz2, dz2) in enumerate(
            zip(start, ra_scz, dec_scz, ra_zenith, dec_zenith)):

        # Find the pixels inside the LAT FoV (theta < theta_cut)

        vec = hp.rotator.dir2vec(rz, dz, lonlat=True)
        idx_z = hp.query_disc(nside,
                              vec,
                              np.deg2rad(theta_cut),
                              inclusive=False)

        # Find the pixels at Zenith angles less
        # than zenith_cut

        vec = hp.rotator.dir2vec(rz2, dz2, lonlat=True)
        idx_z2 = hp.query_disc(nside,
                               vec,
                               np.deg2rad(zenith_cut),
                               inclusive=False)

        # Intersect the two lists of pixels to find pixels which are at the same time
        # inside the FoV and at Zenith < zenith_cut

        idx = np.intersect1d(idx_z, idx_z2)

        # Compute the incremental probability coverage

        coverage[i] = np.sum(ligo_map[idx])

        # Now put the pixel I counted to zero so I don't count them twice
        ligo_map[idx] = 0

        sys.stdout.write("\r%.1f percent completed" %
                         ((i + 1) / float(coverage.shape[0]) * 100.0))

    return start, coverage
示例#21
0
def makeMasks(nside=64, nested=False, ISWDir='/Data/PSG/hundred_point/'):
    """
  Purpose:
      Makes a set of masks around GNS coordinates of various apertures
  Args:
      nside:
      nested:
      ISWDir:

  Returns:
      writes healpix files to ISWDir containing masks
  """

    # load HEALpix coordinates file
    print 'NSIDE=', nside, ' NESTED=', nested
    longitudes, latitudes = getMapCoords(nside, nested)

    # load GNS catalog coordinates
    cgl, cgb, vgl, vgb = getGNScoords()

    # set radii for apertures around coordinate locations
    radiiDeg = np.array([
        4, 4.5, 5, 5.5, 6, 6.5, 7, 7.5, 8, 8.5, 9, 9.5, 10, 10.5, 11, 11.5, 12
    ])  #degrees
    #radiiDeg = np.array([5.0])
    radii = radiiDeg * np.pi / 180.  # converted to radians

    numCV = 50  # number of clusters and voids in catalog
    for radNum, radius in enumerate(radii):
        print 'starting radius ', radiiDeg[radNum], ' degrees: '
        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 (cluster,void) number ',cvNum+1
            # cluster
            myPixels = hp.query_disc(nside,
                                     cCentralVec[cvNum],
                                     radius,
                                     nest=nested)
            mask[myPixels] = 1
            # void
            myPixels = hp.query_disc(nside,
                                     vCentralVec[cvNum],
                                     radius,
                                     nest=nested)
            mask[myPixels] = 1
        radString = str("%04.1f" % radiiDeg[radNum])
        pixNumStr = str(int(np.sum(mask)))
        print 'number of pixels for radius ' + radString + ': ' + pixNumStr
        maskFile = 'ISWmask_' + radString + 'deg_' + pixNumStr + 'pix.fits'
        hp.write_map(ISWDir + maskFile, mask, nest=nested, coord='GALACTIC')
示例#22
0
def plot_exposures(pointings,
                   Aeff_fact,
                   index=1,
                   lat=0.,
                   lon=np.radians(260.),
                   Earth=True,
                   antiEarth=False,
                   NSIDE=32,
                   doplot=True):
    npointings = len(pointings)
    sc = Spacecraft(pointings, lat=lat, lon=lon)
    exposure_positions_hp = np.arange(hp.nside2npix(NSIDE))
    exposure_positions_pix = hp.pix2ang(NSIDE,
                                        exposure_positions_hp,
                                        lonlat=True)
    exposure_positions = np.vstack(exposure_positions_pix)
    exposures = np.array([[
        detector.exposure(position[0], position[1], alt=-90., index=index)
        for position in exposure_positions.T
    ] for detector in sc.detectors])

    exps = exposures.sum(axis=0) * Aeff_fact
    fs = exps  #-min(gbm_exps))/max(gbm_exps)

    if Earth:
        vec = hp.ang2vec(180, 0, lonlat=True)
        i = hp.query_disc(NSIDE, vec, 67 * np.pi / 180.)
        fs[i] = 0
        exposures[:, i] = 0
    if antiEarth:
        vec = hp.ang2vec(np.degrees(lon) - 260. + 180., 0, lonlat=True)
        i = hp.query_disc(NSIDE, vec, 67 * np.pi / 180.)
        fs[i] = 0
        exposures[:, i] = 0

    if doplot:
        plot.figure(figsize=(20, npointings))
        s = np.argsort(pointings.keys())
        for j in range(npointings):
            i = s[j]
            hp.mollview(exposures[i]/max(exposures[i])*Aeff_fact,title='Detector ',\
                        sub = [np.round(npointings/3.+0.5),3,int(str(j+1))])
            #+pointings.keys()[i],\

        hp.mollview(fs, title='Sum of All Detectors')


#    plot.savefig(biadir+'exposure_maps_'+str(ang)+'.png')
    return sc, fs, exposure_positions, pointings, exposures
def addring(nside, ra, dec, anga, angb):
    """
    take a map, and add 1 to elements between anga and angb from ra, dec
    """
    theta = np.deg2rad(90-dec)
    phi = np.deg2rad(ra)
    temp_map = np.zeros(hp.nside2npix(nside))
    assert angb > anga # else error
    # Everything from 0 to angb = 1
    pixlist = hp.query_disc(nside, hp.ang2vec(theta, phi), np.deg2rad(angb))
    temp_map[pixlist] += 1
    # now delete everything from 0 to anga
    pixlist = hp.query_disc(nside, hp.ang2vec(theta, phi), np.deg2rad(anga))
    temp_map[pixlist] -= 1
    return temp_map
示例#24
0
def gen_map_disc(radec_cen, rad, nside):
    '''Generates a Healpix map with the only non-zero values in the
    pixels inside the input disc.

    Parameters
    ----------
    radec_cen : array-like with shape (2,)
        The center ra,dec of the disc in degrees

    rad : float
        The radius of the disc in degrees

    nside : int
        The nside of the output Healpix map

    Returns
    -------
    hpx_map : array-like
        A Healpix map with non-zero values inside the disc
    '''

    theta = np.pi / 2 - np.radians(radec_cen[1])
    phi = np.radians(radec_cen[0])

    vec = H.ang2vec(theta, phi)

    ipix = H.query_disc(nside, vec, np.radians(rad))

    hpx_map = np.zeros(H.nside2npix(nside))
    hpx_map[ipix] = 1.0

    return hpx_map
示例#25
0
def grow_hp(inmap, hpids, radius=1.75, replace_val=np.nan):
    """
    grow a healpix mask

    Parameters
    ----------
    inmap : np.array
        A HEALpix map
    hpids : array
        The healpixel values to grow around
    radius : float (1.75)
        The radius to grow around each point (degrees)
    replace_val : float (np.nan)
        The value to plug into the grown areas
    """
    nside = hp.npix2nside(np.size(inmap))
    theta, phi = hp.pix2ang(nside=nside, ipix=hpids)
    vec = hp.ang2vec(theta, phi)
    ipix_disc = [
        hp.query_disc(nside=nside, vec=vector, radius=np.radians(radius))
        for vector in vec
    ]
    ipix_disc = np.unique(np.concatenate(ipix_disc))
    outmap = inmap + 0
    outmap[ipix_disc] = replace_val
    return outmap
示例#26
0
	def query_disc(self, lon, lat, radius, fact=4):
		""" Find pixels that overlap with discs centered at (lon,lat)

		Inputs
		------
		lon : float, ndarray
			longitude (degr)
		lat : float, ndarray
			latitude (degr)
		radius : float, ndarray
			radius of disk (degrees)
		fact : float
			supersampling factor to find overlapping pixels
			(see healpy.query_disc doc)

		Returns
		------
		ndarray : pixel indices
		"""
		phi = np.array(lon) * self.deg2rad
		theta = (90 - np.array(lat)) * self.deg2rad
		vec = healpy.ang2vec(theta, phi)
		pix = healpy.query_disc(self.nside, vec, radius * self.deg2rad,
								inclusive=True, fact=fact, nest=self.nest)
		return pix
示例#27
0
def find_field_visits(visits, ra, decl, nside=512, field_radius_deg=1.75):
    """Return visits centered near a pointing

    Parameters
    ----------
    visits : `pandas.DataFrame`
        The visits in which to look for fields
    ra : `float`
        The RA around which to search.
    decl : `float`
        The declination around which to search
    nside : `int`
        The nside for the healpix search
    field_radious_deg : `float`
        The radious round which to search, in degrees

    Returns
    -------
    field_visits : `pandas.DataFrame`
        The visits on the field.
    """
    field_hpxs = healpy.query_disc(
        nside,
        healpy.ang2vec(ra, decl, lonlat=True),
        np.radians(field_radius_deg),
    )
    visit_hpxs = healpy.ang2pix(nside,
                                visits["fieldRA"].values,
                                visits["fieldDec"].values,
                                lonlat=True)
    field_visits = visits.loc[np.isin(visit_hpxs, field_hpxs)]
    return field_visits
示例#28
0
    def pencil(self, theta, phi, angrad, **kwargs):
        """Query a pencil beam from this `SkyMap`

        Returns the subset of this `SkyMap` that covers an angular disc on
        the sky (i.e., a pencil beam)

        Parameters
        ----------
        theta : `float`
            zenith angle (radians) at the center of the disc

        phi : `float`
            azimuth angle (radians) at the center of the disc

        angrad : `float` or `~astropy.units.Quantity`
            angular radius (radians) subtended by the disc

        **kwargs : `dict`, optional
            additional keyword arguments to `~healpy.query_disc`

        Returns
        -------
        out : `SkyMap`
            the subset of `SkyMap` subtended by this pencil beam
        """
        if isinstance(angrad, units.Quantity):
            angrad = angrad.to("rad").value
        direction = healpy.ang2vec(theta, phi)
        indices = healpy.query_disc(self.nside,
                                    direction,
                                    angrad,
                                    nest=self.nest,
                                    **kwargs)
        return self[indices]
示例#29
0
def handling_exception(params, constraints):
    NSIDEmax = params['NSIDE max']
    vec = hp.ang2vec(params["ang"][0], params["ang"][1], lonlat=True)
    pixels = hp.query_disc(NSIDEmax,
                           vec,
                           np.radians(params['r'] / 3600.),
                           inclusive=True)
    subjobs = mastcasjobs.MastCasJobs(context="PanSTARRS_DR2")

    for pixel in pixels:
        ang, r = qr.parameters(NSIDEmax, pixel)
        subquery = sub_query_string(ang[0], ang[1], r)
        accept = True

        while accept:
            try:
                subtab = subjobs.quick(subquery,
                                       task_name="python cone search")
                accept = False
            except Exception:
                from time import sleep
                sleep(60)
                pass

        subtab = qr.fixcolnames(ascii.read(subtab))
        subtab = qr.query_constraints(subtab, constraints)

        if pixel == pixels[0]:
            table = subtab
        else:
            table = vstack([table, subtab])

    return table
示例#30
0
文件: gMasks.py 项目: nmik/GRATools
def mask_src(cat_file, MASK_S_RAD, NSIDE):
    """Returns the 'bad pixels' defined by the position of a source and a 
       certain radius away from that point.

       cat_file: str
           .fits file of the sorce catalog
       MASK_S_RAD: float
           radius around each source definig bad pixels to mask
       NSIDE: int
           healpix nside parameter
    """
    logger.info('Mask for sources activated')
    src_cat = pf.open(cat_file)
    NPIX = hp.pixelfunc.nside2npix(NSIDE)
    CAT = src_cat['LAT_Point_Source_Catalog']
    BAD_PIX_SRC = []
    SOURCES = CAT.data
    RADrad = MASK_S_RAD*np.pi/180.
    for i in range (0,len(SOURCES)-1):
        GLON = SOURCES.field('GLON')[i]
        GLAT = SOURCES.field('GLAT')[i]
        x, y, z = hp.rotator.dir2vec(GLON,GLAT,lonlat=True)
        b_pix= hp.pixelfunc.vec2pix(NSIDE, x, y, z)
        BAD_PIX_SRC.append(b_pix) 
    BAD_PIX_inrad = []
    for bn in BAD_PIX_SRC:
        pixVec = hp.pix2vec(NSIDE,bn)
        radintpix = hp.query_disc(NSIDE, pixVec, RADrad)
        BAD_PIX_inrad.extend(radintpix)  
    BAD_PIX_SRC.extend(BAD_PIX_inrad)
    src_cat.close()
    return BAD_PIX_SRC
示例#31
0
    def generate_inmaskcat(self, out_edge, tol=1):

        '''
        Return unmasked sources.
        Input: out_edge: out edge of the disk centred at each source(in arcmin);
               tol: tolerance between 0 and 1 indicating a threshold of fraction of
                unmasked pixels in a disk
        Output: indices of unmasked sources.
        '''
        mask = self.mask
        Ns = self.Nside
        Nsource = self.Nsource
        pos_src_all = self.pos_src_all
        inmask_ind = np.zeros(Nsource)
        for i in range(Nsource):
            if i % 10000 == 0:
                print i
            list_out = hp.query_disc(Ns, pos_src_all[i], np.radians(out_edge / 60.))
            npix_out = list_out.size
            neff_out = np.sum(mask[list_out])

            if(neff_out < tol * npix_out):
                continue
            else:
                inmask_ind[i] = 1

        print str(inmask_ind.sum()) + ' sources in mask.'
        return inmask_ind
示例#32
0
def get_hpmask_subpix_indices(submask_nside, submask_hpix, submask_border, nside_mask, hpix):
    """
    """

    nside_cutref = np.clip(submask_nside * 4, 256, nside_mask)

    # Find out which cutref pixels are inside the main pixel
    theta, phi = hp.pix2ang(nside_cutref, np.arange(hp.nside2npix(nside_cutref)))
    ipring_coarse = hp.ang2pix(submask_nside, theta, phi)
    inhpix, = np.where(ipring_coarse == submask_hpix)

    # If there is a border, we need to find the boundary pixels
    if submask_border > 0.0:
        boundaries = hp.boundaries(submask_nside, submask_hpix, step=nside_cutref/submask_nside)
        # These are all the pixels that touch the boundary
        for i in xrange(boundaries.shape[1]):
            pixint = hp.query_disc(nside_cutref, boundaries[:, i],
                                   np.radians(submask_border), inclusive=True, fact=8)
            inhpix = np.append(inhpix, pixint)
            # Need to uniqify here because of overlapping pixels
            inhpix = np.unique(inhpix)

    # And now choose just those depthmap pixels that are in the inhpix region
    theta, phi = hp.pix2ang(nside_mask, hpix)
    ipring = hp.ang2pix(nside_cutref, theta, phi)

    _, use = esutil.numpy_util.match(inhpix, ipring)

    return use
示例#33
0
def calculate_efficiency(hpx, d0, s0, s1, nfields, fieldop):
    '''This function determines the score of a given set of tiling parameters for the optimization.
    The figure of merit is the sum value of the for the <nfields> higher fields of the tiling'''
    nside = hp.npix2nside(len(hpx))

    keptfields = build_fields(hpx, d0, s0, s1, nfields, fieldop)
    #    totaldots = np.sum(keptfields["prob"])
    total = 0
    prob_integral = []
    for indec in range(0, len(keptfields)):
        #        cornerra, cornerdec = getcorners(keptfields["ra"][indec],keptfields["dec"][indec],field=4.2)
        #        xyz = hp.ang2vec(checktheta(dectotheta(cornerdec)),checkphi(ratophi(cornerdec)))
        #        hp.query_polygon(nside,xyz)
        xyz = hp.ang2vec(dectotheta(keptfields["dec"][indec]),
                         ratophi(keptfields["ra"][indec]))
        ipix_disc = hp.query_disc(nside, xyz, np.deg2rad(
            fieldop))  #here radius seems to be a diameter instead * (sq2+1)/4)
        totdisc = hpx[ipix_disc].sum()
        prob_integral.append(totdisc)
        total += totdisc


#    efficiency = total / nfields
#print (total)
    return total, prob_integral
def disk_plot(value, dir_vec, ang_size, nside_var):
    coord = hp.query_disc(nside=nside_var,
                          vec=dir_vec,
                          radius=np.deg2rad(ang_size),
                          inclusive=True,
                          fact=16)
    m[coord] = value
示例#35
0
def label_visits(visits, wfd_footprint, nside=64):
    # Set up DD names.
    d = set()
    for p in visits['note'].unique():
        if p.startswith('DD'):
            d.add(define_ddname(p))
    # Define dictionary of proposal tags.
    propTags = {'Other': 0, 'WFD': 1}
    for i, field in enumerate(d):
        propTags[field] = i + 2
    # Identify Healpixels associated with each visit.
    vec = hp.dir2vec(visits['fieldRA'], visits['fieldDec'], lonlat=True)
    vec = vec.swapaxes(0, 1)
    radius = np.radians(1.75)  # fov radius
    #pointings = []
    propId = np.zeros(len(visits), int)
    for i, (v, note) in enumerate(zip(vec, visits['note'])):
        # Identify the healpixels which would be inside this pointing
        pointing_healpix = hp.query_disc(nside, v, radius, inclusive=False)
        # This can be useful for debugging/plotting
        #pointings.append(pointing_healpix)
        # The wfd_footprint consists of values of 0/1 if out/in WFD footprint
        in_wfd = wfd_footprint[pointing_healpix].sum()
        # So in_wfd = the number of healpixels which were in the WFD footprint
        # .. in the # in / total # > limit (0.4) then "yes" it's in WFD
        propId[i] = np.where(in_wfd / len(pointing_healpix) > 0.4,
                             propTags['WFD'], 0)
        # BUT override - if the visit was taken for DD, use that flag instead.
        if note.startswith('DD'):
            propId[i] = propTags[define_ddname(note)]
    return visits, propTags, propId
示例#36
0
 def dust_vals_disk(self,lcen,bcen,dist,radius):
     """
     NAME:
        dust_vals_disk
     PURPOSE:
        return the distribution of extinction within a small disk as samples
     INPUT:
        lcen, bcen - Galactic longitude and latitude of the center of the disk (deg)
        dist - distance in kpc
        radius - radius of the disk (deg)
     OUTPUT:
        (pixarea,extinction) - arrays of pixel-area in sq rad and extinction value
     HISTORY:
        2015-03-07 - Written - Bovy (IAS)
     """
     # Convert the disk center to a HEALPIX vector
     vec= healpy.pixelfunc.ang2vec((90.-bcen)*_DEGTORAD,lcen*_DEGTORAD)
     # We pixelize the map with a HEALPIX grid with nside=256, to somewhat
     # oversample the Drimmel resolution
     nside= 256
     # Find the pixels at this resolution that fall within the disk
     ipixs= healpy.query_disc(nside,vec,radius*_DEGTORAD,
                              inclusive=False,nest=False)
     # Query the HEALPIX map for pixels that lie within the disk
     pixarea= healpy.pixelfunc.nside2pixarea(nside)+numpy.zeros(len(ipixs))
     extinction= []
     for ii, ipix in enumerate(ipixs):
         # Get glon and glat
         b9, l= healpy.pixelfunc.pix2ang(nside,ipix,nest=False)
         b= 90.-b9/_DEGTORAD
         l/= _DEGTORAD
         # Now evaluate
         extinction.append(self._evaluate(l,b,dist))
     extinction= numpy.array(extinction)
     return (pixarea,extinction)
示例#37
0
def gen_map_disc(radec_cen, rad, nside):
    '''Generates a Healpix map with the only non-zero values in the
    pixels inside the input disc.

    Parameters
    ----------
    radec_cen : array-like with shape (2,)
        The center ra,dec of the disc in degrees

    rad : float
        The radius of the disc in degrees

    nside : int
        The nside of the output Healpix map

    Returns
    -------
    hpx_map : array-like
        A Healpix map with non-zero values inside the disc
    '''

    theta = np.pi/2 - np.radians(radec_cen[1])
    phi = np.radians(radec_cen[0])

    vec = H.ang2vec(theta, phi)

    ipix = H.query_disc(nside, vec, np.radians(rad))

    hpx_map = np.zeros(H.nside2npix(nside))
    hpx_map[ipix] = 1.0

    return hpx_map
示例#38
0
 def _get_mask(self):
     if self.config.get('mask_file', None) is not None:
         mask = hp.read_map(self.config['mask_file'])
         mask = hp.ud_grade(rotate_mask(mask, self.rot),
                            nside_out=self.nside)
         mask[mask > 0.5] = 1.
         mask[mask <= 0.5] = 0.
     else:
         mask = np.ones(self.npix)
         r = hp.Rotator(coord=['C', 'G'])
         RApix, DEpix = hp.pix2ang(self.nside,
                                   np.arange(self.npix),
                                   lonlat=True)
         lpix, bpix = r(RApix, DEpix, lonlat=True)
         # angular conditions
         mask[(DEpix < self.config.get('DEC_min_deg', -40)) |
              (np.fabs(bpix) < self.config.get('GLAT_max_deg', 5))] = 0
         if self.file_sourcemask is not None:
             # holes catalog
             RAmask, DEmask, radmask = np.loadtxt(self.file_sourcemask,
                                                  unpack=True)
             vecmask = hp.ang2vec(RAmask, DEmask, lonlat=True)
             for vec, radius in zip(vecmask, radmask):
                 ipix_hole = hp.query_disc(self.nside,
                                           vec,
                                           np.radians(radius),
                                           inclusive=True)
                 mask[ipix_hole] = 0
         mask = rotate_mask(mask, self.rot, binarize=True)
     return mask
def compute_circle(N, t, p, r, r_in):
    # Compute query (outer circle) and query_in (inner circle)
    query = hp.query_disc(nside=N,
                          vec=hp.ang2vec(np.pi / 2 - t, p),
                          radius=r,
                          inclusive=False,
                          nest=False)
    query_in = hp.query_disc(nside=N,
                             vec=hp.ang2vec(np.pi / 2 - t, p),
                             radius=r_in,
                             inclusive=False,
                             nest=False)

    # Inverse intersection of query (outer circle) and query_in (inner circle)
    inner = minus(query, query_in)
    return inner
示例#40
0
 def test_inclusive(self):
     #HIDL> query_disc, 8, [ 0.17101007,  0.03015369,  0.98480775],6,listpix,/DEG,NESTED=0,/inclusive
     #HIDL> print,listpix
     #           0           3           4           5          11          12          13          23
     np.testing.assert_array_equal(
             query_disc(self.NSIDE, self.vec, self.radius, inclusive=True),
             np.array([ 0, 3, 4, 5, 11, 12, 13, 23 ])
         )
示例#41
0
 def test_not_inclusive(self):
     #HIDL> query_disc, 8, [ 0.17101007,  0.03015369,  0.98480775],6,listpix,/DEG,NESTED=0           
     #HIDL> print,listpix
     #           4
     np.testing.assert_array_equal(
             query_disc(self.NSIDE, self.vec, self.radius, inclusive=False),
             np.array([4])
         )
示例#42
0
def get_disc(pix, disc_size, nside):
    vec = hp.pix2vec(nside, pix, nest=False)
    in_disc = hp.query_disc(
        nside=nside,
        vec=vec,
        radius=np.deg2rad(disc_size),
        nest=False)

    return in_disc
示例#43
0
文件: utils.py 项目: jjdmol/LOFAR
def get_pixels(centr_ra, centr_decl, fov_radius):
    """
    Get a list of HEALPIX zones that contain a given image.
    """
    vector = healpy.ang2vec(radians(90.0 - centr_decl),
                            radians(centr_ra))
    pixels = healpy.query_disc(32, vector, radians(fov_radius),
                               inclusive=True, nest=True)
    return str(pixels.tolist())[1:-1]
示例#44
0
        def gaussian_on_a_sphere(mean_th, mean_phi, sigma):
            """
            This function returns a 2D normal pdf on a discretized healpy grid.
            To chose the function values correctly in spherical coordinates,
            the true angular distances to the mean are used.

            Pixels farther away from the mean than clip * sigma are clipped
            because the normal distribution falls quickly to zero. The error
            made by this can be easily estimated and a discussion can be found
            in [arXiv:1005.1929](https://arxiv.org/abs/1005.1929v2).

            Parameters
            ----------
            mean_th : float
                Position of the mean in healpy coordinate `theta`. `theta` is in
                [0, pi] going from north to south pole.
            mean_phi : float
                Position of the mean in healpy coordinate `phi`. `phi` is in [0, 2pi]
                and is equivalent to the azimuth angle.
            sigma : float
                Standard deviation of the 2D normal distribution. Only symmetric
                normal pdfs are used here.

            Returns
            -------
            kernel : array
                Values of the 2D normal distribution at the selected pixels. If clip
                False, kernel is a valid healpy map with resolution NSIDE.
            keep_idx : array
                Pixel indices that are kept from the full healpy map after clipping.
                If clip is False this is a sorted integer array with values
                [0, 1, ..., NPIX-1] with NPIX tha number of pixels in the full healpy
                map with resolution NSIDE.
            """
            # Clip unneccessary pixels, just keep clip*sigma (radians)
            # around the mean. Using inlusive=True to make sure at least
            # one pixel gets returned.
            # Always returns a list, so no manual np.array() required.
            keep_idx = hp.query_disc(
                self._nside, hp.ang2vec(mean_th, mean_phi),
                self._clip * sigma, inclusive=True)

            # Create only the needed the pixel healpy coordinates
            th, phi = hp.pix2ang(self._nside, keep_idx)
            sinTh = np.sin(th)

            # For each pixel get the distance to (mean_th, mean_phi) direction
            dist = angdist(mean_phi, mean_th, phi, sinTh)

            # Get the 2D gaussian values at those distances -> kernel function
            # Because the kernel is radial symmetric we use a simplified
            # version -> 1D gaussian, properly normed
            sigma2 = 2 * sigma**2
            kernel = np.exp(-dist**2 / sigma2) / (np.pi * sigma2)

            return kernel, keep_idx
示例#45
0
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])
示例#46
0
 def dust_vals_disk(self,lcen,bcen,dist,radius):
     """
     NAME:
        dust_vals_disk
     PURPOSE:
        return the distribution of extinction within a small disk as samples
     INPUT:
        lcen, bcen - Galactic longitude and latitude of the center of the disk (deg)
        dist - distance in kpc
        radius - radius of the disk (deg)
     OUTPUT:
        (pixarea,extinction) - arrays of pixel-area in sq rad and extinction value
     HISTORY:
        2015-03-06 - Written - Bovy (IAS)
     """
     # Convert the disk center to a HEALPIX vector
     vec= healpy.pixelfunc.ang2vec((90.-bcen)*_DEGTORAD,lcen*_DEGTORAD)
     distmod= 5.*numpy.log10(dist)+10.
     # Query the HEALPIX map for pixels that lie within the disk
     pixarea= []
     extinction= []
     for nside in self._nsides:
         # Find the pixels at this resolution that fall within the disk
         ipixs= healpy.query_disc(nside,vec,radius*_DEGTORAD,
                                 inclusive=False,nest=True)
         # Get indices of all pixels within the disk at current nside level
         nsideindx= self._pix_info['nside'] == nside
         potenIndxs= self._indexArray[nsideindx]
         nsidepix= self._pix_info['healpix_index'][nsideindx]
         # Loop through the pixels in the (small) disk
         tout= []
         for ii,ipix in enumerate(ipixs):
             lbIndx= potenIndxs[ipix == nsidepix]
             if numpy.sum(lbIndx) == 0: continue
             if self._intps[lbIndx] != 0:
                 tout.append(self._intps[lbIndx][0](distmod))
             else:
                 interpData=\
                     interpolate.InterpolatedUnivariateSpline(self._distmods,
                                                              self._best_fit[lbIndx],
                                                              k=self._interpk)
                 tout.append(interpData(distmod))
                 self._intps[lbIndx]= interpData
         tarea= healpy.pixelfunc.nside2pixarea(nside)
         tarea= [tarea for ii in range(len(tout))]
         pixarea.extend(tarea)
         extinction.extend(tout)
     pixarea= numpy.array(pixarea)
     extinction= numpy.array(extinction)
     if not self._filter is None:
         extinction= extinction*aebv(self._filter,sf10=self._sf10)        
     return (pixarea,extinction)
示例#47
0
def get_healsparse_subpix_indices(subpix_nside, subpix_hpix, subpix_border, coverage_nside):
    """
    Retrieve the coverage pixels that intersect the region, with a border.

    Parameters
    ----------
    subpix_nside: `int`
       Nside for the subregion
    subpix_hpix: `int`
       Pixel number for the subregion (ring format)
    subpix_border: `float`
       Border radius to cover outside subpix_hpix
    coverage_nside: `int`
       Nside of the healsparse coverage map
    """

    # First, we need to know which pixel(s) from nside_coverage are covered by
    # subpix_hpix

    if subpix_nside == coverage_nside:
        # simply convert to nest
        covpix = hp.ring2nest(subpix_nside, subpix_hpix)
    elif subpix_nside > coverage_nside:
        # what pixel is this contained in?
        theta, phi = hp.pix2ang(subpix_nside, subpix_hpix, nest=False)
        covpix = hp.ang2pix(coverage_nside, theta, phi, nest=True)
    else:
        # This is subpix_nside < coverage_nside
        # what coverage pixels are contained in subpix_hpix?
        subpix_hpix_nest = hp.ring2nest(subpix_nside, subpix_hpix)
        bit_shift = 2 * int(np.round(np.log(coverage_nside / subpix_nside) / np.log(2)))
        n_pix = 2**bit_shift
        covpix = np.left_shift(subpix_hpix_nest, bit_shift) + np.arange(n_pix)

    # And now if we have a border...
    if subpix_border > 0.0:
        nside_testing = max([coverage_nside * 4, subpix_nside * 4])
        boundaries = hp.boundaries(subpix_nside, subpix_hpix, step=nside_testing/subpix_nside)

        extrapix = np.zeros(0, dtype=np.int64)

        # These are pixels that touch the boundary
        for i in xrange(boundaries.shape[1]):
            pixint = hp.query_disc(nside_testing, boundaries[:, i],
                                   np.radians(subpix_border), inclusive=True, fact=8)
            extrapix = np.append(extrapix, pixint)

        extrapix = np.unique(extrapix)
        theta, phi = hp.pix2ang(nside_testing, extrapix)
        covpix = np.unique(np.append(covpix, hp.ang2pix(coverage_nside, theta, phi, nest=True)))

    return covpix
示例#48
0
def local_mean_map(map1, mask1, deg):
    """ return the local mean map for map1 with mask mask1
    """
    mp1=hp.ma(map1)
    mp1.mask=np.logical_not(mask1)
    NSIDE1=hp.npix2nside(len(map1))
    NSIDE2=nside(deg)
    NPIX2=hp.nside2npix(NSIDE2)
    mp2=np.array([0.]*NPIX2)
    for pix2 in range(0, NPIX2):
        disc1=hp.query_disc(nside=NSIDE1, vec=hp.pix2vec(NSIDE2, pix2), radius=deg2rad(deg))
        mp2[pix2]=np.mean(mp1[disc1])
    return mp2
示例#49
0
def find_available_galaxies(fiber_set, tile_set, object_set, 
                            tile_ID, filename="available_galaxies"):
    
    assert tile_set.healpix_n_side==object_set.healpix_n_side, "healpix n_side is different for tiles and objects"
    assert tile_set.healpix_n_side>0, "healpix n_side is negative"
    
    tile_theta = tile_set.theta[tile_ID]
    tile_phi = tile_set.phi[tile_ID]  
    tile_center = np.array([tile_theta,tile_phi])
    tile_vector = hp.rotator.dir2vec(tile_center)
    pix = hp.query_disc(tile_set.healpix_n_side, tile_vector, fiber_set.plate_radius, inclusive=True) 
    
    # stores the galaxies that fall into the tile 
    objects_in_id = np.empty((0))
    
    for i_pix in pix:
        tmp_id_in = np.where(object_set.healpix_pixels==i_pix)
        tmp_id_in = tmp_id_in[0]
        objects_in_id = np.append(objects_in_id, tmp_id_in)
        
    objects_in_id = np.int_(objects_in_id)
    #if(not(i_tiling%(n_tilings/20))):
        
    selected_objects = object_set.select(objects_in_id)

    #these selected objects must have new a x,y coordinates in the focal plane
    selected_x, selected_y = radec2xy(selected_objects.ra, selected_objects.dec, tile_set.ra[tile_ID], tile_set.dec[tile_ID])
    
    n_fibers = np.size(fiber_set.x)
    fiber_list = np.arange(n_fibers)
    #np.random.shuffle(fiber_list)
    #print fiber_list

    out = open("tile_%d_%s.dat"%(tile_ID, filename), "w")
    
    for fiber_i in fiber_list:
        fiber_x = fiber_set.x[fiber_i]
        fiber_y = fiber_set.y[fiber_i]
        radius = np.sqrt((selected_x - fiber_x)**2 + (selected_y-fiber_y)**2)
        inside = np.where((radius>fiber_set.patrol_radius_min) & (radius<fiber_set.patrol_radius_max))
        inside = inside[0]
        n_available = np.size(inside)
        if(n_available):
            out.write("%d %d %d "%(tile_ID, fiber_i, n_available))
            id_available = ''.join('%d ' % i for i in selected_objects.ID[inside])
            out.write("%s\n"%(id_available))
        else:
            out.write("%d %d %d \n"%(tile_ID, fiber_i, n_available))
    out.close()
    return selected_x, selected_y
示例#50
0
    def probability_inside_circle(self, ra, dec, radius):
        """Return the probability inside a circle."""

        prob = hp.read_map(self.skymap, verbose=False)

        theta = 0.5 * np.pi - np.deg2rad(dec)
        phi = np.deg2rad(ra)
        radius = np.deg2rad(radius)

        xyz = hp.ang2vec(theta, phi)
        ipix_disc = hp.query_disc(self.nside, xyz, radius)
        probability_inside_disc = prob[ipix_disc].sum()

        return "%.1e" % probability_inside_disc
示例#51
0
def correlations(i_ang):
	
	ang_low = (pi / 180) * (ang[i_ang] - (ang_res / 2))
	ang_high = (pi / 180) * (ang[i_ang] + (ang_res / 2))

	n = np.zeros(N_jkmpix)	
	c = np.zeros((n_corr, N_jkmpix))
	c_out = np.zeros((n_corr, N_jkmpix))
	#c_gal = 0
	#n_gal = 0
	
	for i in range(N_mpix):
		i_vec = hp.pix2vec(nside, mpix2hpix[i])
		disc_low = hp.query_disc(nside, i_vec, ang_low, inclusive = False)
		disc_high = hp.query_disc(nside, i_vec, ang_high, inclusive = False)
		disc = hpix2mpix[np.setdiff1d(disc_high, disc_low)]
		disc = disc[disc >= 0]
		
		k = hp.vec2pix(nside_jk, i_vec[0], i_vec[1], i_vec[2])
		k = jkhpix2jkmpix[k]

		for l in range(n_corr):		
			dmap1 = dmap[l][0]	
			dmap2 = dmap[l][1]	
			c[l][k] += dmap1[i] * dmap2[disc].sum()

		n[k] += len(disc) 

		#c_gal += dmap[0][0][i] * dmap[0][1][disc].sum()
		#n_gal += len(disc)

	for l in range(n_corr): 
		for k in range(N_jkmpix):
			c_out[l][k] = (c[l].sum() - c[l][k]) / (n.sum() - n[k])

	print "theta = %.2f Done!" % ang[i_ang]
	return c_out
示例#52
0
文件: plot.py 项目: tamasgal/km3pipe
def make_dom_map(pmt_directions, values, nside=512, d=0.2, smoothing=0.1):
    """Create a mollweide projection of a DOM with given PMTs.

    The output can be used to call the `healpy.mollview` function.
    """
    import healpy as hp
    discs = [hp.query_disc(nside, dir, 0.2) for dir in pmt_directions]
    npix = hp.nside2npix(nside)
    pixels = np.zeros(npix)
    for disc, value in zip(discs, values):
        for d in disc:
            pixels[d] = value
    if smoothing > 0:
        return hp.sphtfunc.smoothing(pixels, fwhm=smoothing, iter=1)
    return pixels
示例#53
0
def local_variance_map(map1, mask1, deg):
    """ return the local variance map for map1 with mask mask1, given the error tolerance tol for mask2
    """
    mp1=hp.ma(map1)
    mp1.mask=np.logical_not(mask1)

    NSIDE1=hp.npix2nside(len(map1))
    NSIDE2=nside(deg)
    NPIX2=hp.nside2npix(NSIDE2)
    #mask2=np.round(hp.ud_grade(mask1, nside_out=NSIDE2)+tol)
    mp2=np.array([0.]*NPIX2)
    for pix2 in range(0, NPIX2):
        disc1=hp.query_disc(nside=NSIDE1, vec=hp.pix2vec(NSIDE2, pix2), radius=deg2rad(deg))
        mp2[pix2]=np.var(mp1[disc1])
    #varmp2.mask=np.logical_not(mask2)
    return mp2
示例#54
0
def smoothMap(map, smooth=5.):

    if smooth == 0:
        return map

    npix = len(map)
    nside = hp.npix2nside(npix)
    smooth_rad = smooth * np.pi/180.
    smooth_map = np.zeros(map.shape)

    vec = np.transpose(hp.pix2vec(nside, np.arange(npix)))
    for i in range(npix):
        neighbors = hp.query_disc(nside, vec[i], smooth_rad)
        smooth_map[i] += np.sum(map[neighbors], axis=0)

    return smooth_map
示例#55
0
def hp_interpolator(map_, el, az, n_pix=4):
    NSide = hp.pixelfunc.get_nside(map_)
    direction = np.array([np.pi/2.-el.to_rad(),az.to_rad()])
    steplength = hp.pixelfunc.max_pixrad(NSide)
    for i, r in enumerate(np.arange(steplength, np.pi, steplength)):
        pixels = np.array(hp.query_disc(NSide,hp.ang2vec(direction[0], direction[1]), r))
        filled = np.where(map_[pixels] > -1.)[0]
        l = len(filled)
        if l >= n_pix:
            # print(i, l)
            filled_pixel = pixels[filled]
            filled_pixel_directions = hp.pix2vec(NSide, filled_pixel)
            angular_distance = hp.rotator.angdist(direction, filled_pixel_directions)
            if angular_distance.min() == 0.: # do we really want this?
                return map_[filled_pixel[angular_distance.argmin()]]
            return np.average(map_[filled_pixel], weights=np.power(1./angular_distance, 2))
示例#56
0
 def doPreCalcs(self):
     """
     Perform the precalculations necessary to set up the sparse matrix.
     """
     self.opsimdf['hids'] = [hp.query_disc(self.nside, vec, self._fieldRadius,
                                           inclusive=self.inclusive,
                                           fact=self.fact,
                                           nest=self.nest)
                             for vec in self.opsimdf[self.vecColName]]
     lens = map(len, self.opsimdf.hids.values)
     rowdata = []
     _ = list(rowdata.extend(repeat(i, lens[i]))
              for i in xrange(len(self.opsimdf)))
     coldata = np.concatenate(self.opsimdf.hids.values)
     self._rowdata = rowdata
     self._coldata = coldata
示例#57
0
文件: gMasks.py 项目: nmik/GRATools
def mask_src_weighted_custom(cat_file, ENERGY, NSIDE):
    """Returns the 'bad pixels' defined by the position of a source and a 
       certain radius away from that point. The radii increase with the 
       brightness and rescaled by a factor between 1 and 0.3 shaped as the PSF.

       cat_file: str
          .fits file with the sorce catalog
       ENERGY: float
          Mean energy of the map to be masked
       NSIDE: int
          healpix nside parameter
    """
    psf_ref_file = os.path.join(GRATOOLS_CONFIG, 'ascii/PSF_UCV_PSF1.txt')
    src_cat = pf.open(cat_file)
    NPIX = hp.pixelfunc.nside2npix(NSIDE)
    CAT = src_cat[1]
    BAD_PIX_SRC = []
    SOURCES = CAT.data
    src_cat.close()
    psf_ref = get_psf_ref(psf_ref_file)
    psf_en = psf_ref(ENERGY)
    psf_min, psf_max =  psf_ref.y[5], psf_ref.y[-1] 
    norm_min, norm_max = 1, 0.3
    norm = norm_min + psf_en*((norm_max - norm_min)/(psf_max - psf_min)) -\
        psf_min*((norm_max - norm_min)/(psf_max - psf_min))
    logger.info('Normalization of radii due to energy: %.3f'%norm)
    logger.info('Psf(%.2f)= %.2f'%(ENERGY, psf_en))
    FLUX = np.log10(SOURCES.field('eflux1000'))
    flux_min, flux_max = min(FLUX), max(FLUX)
    rad_min, rad_max = 1, 5.
    RADdeg = rad_min + FLUX*((rad_max - rad_min)/(flux_max - flux_min)) -\
        flux_min*((rad_max - rad_min)/(flux_max - flux_min))
    RADrad = np.radians(RADdeg)
    logger.info('Flux-weighted mask for sources activated')
    TS = SOURCES.field('ts') 
    indTS25 = TS > 25.
    GLON = SOURCES.field('GLON')[indTS25]
    GLAT = SOURCES.field('GLAT')[indTS25]
    logger.info('Num Src: %i'%len(TS))
    logger.info('Num Src TS>25: %i'%len(TS[indTS25]))
    for i, src in enumerate(SOURCES[indTS25]):
        x, y, z = hp.rotator.dir2vec(GLON[i],GLAT[i],lonlat=True)
        b_pix= hp.pixelfunc.vec2pix(NSIDE, x, y, z)
        BAD_PIX_SRC.append(b_pix)
        radintpix = hp.query_disc(NSIDE, (x, y, z), RADrad[i]*norm)
        BAD_PIX_SRC.extend(radintpix)
    return BAD_PIX_SRC
示例#58
0
def local_power_spectrum(map1, mask1, deg, LMAX=256):
    """ return the local power spectrum for each disk given by the radius [deg]
    """
    mp1=hp.ma(map1)
    mp1.mask=np.logical_not(mask1)
    NSIDE1=hp.npix2nside(len(map1))
    NSIDE2=nside(deg)
    NPIX2=hp.nside2npix(NSIDE2)
    NPIX1=hp.nside2npix(NSIDE1)
    mp2=[0]*NPIX2
    for pix2 in range(0, NPIX2):
        newmask=np.array([0.]*NPIX1)
        disc1=hp.query_disc(nside=NSIDE1, vec=hp.pix2vec(NSIDE2, pix2), radius=deg2rad(deg))
        newmask[disc1]=1.
        newmask=newmask*mask1
        mp1.mask=np.logical_not(mask1)
        mp2[pix2]=hp.anafast(mp1, lmax=LMAX)
    return mp2
示例#59
0
def get_subpixel_indices(galtable, hpix=None, border=0.0, nside=0):
    """
    Routine to get subpixel indices from a galaxy table.

    Parameters
    ----------
    galtable: `redmapper.Catalog`
       A redmapper galaxy table master catalog
    hpix: `int`, optional
       Healpix number (ring format) of sub-region.  Default is 0 (full catalog).
    border: `float`, optional
       Border around hpix (in degrees) to find pixels.  Default is 0.0.
    nside: `int`, optional
       Nside of healpix subregion.  Default is 0 (full catalog).

    Returns
    -------
    indices: `np.array`
       Integer array of indices of galaxy table pixels in the subregion.
    """

    if hpix is None or nside == 0:
        return np.arange(galtable.filenames.size)

    theta, phi = hp.pix2ang(galtable.nside, galtable.hpix)
    ipring_big = hp.ang2pix(nside, theta, phi)
    indices, = np.where(ipring_big == hpix)
    if border > 0.0:
        # now we need to find the extra boundary...
        boundaries = hp.boundaries(nside, hpix, step=galtable.nside/nside)
        inhpix = galtable.hpix[indices]
        for i in xrange(boundaries.shape[1]):
            pixint = hp.query_disc(galtable.nside, boundaries[:, i],
                                   border*np.pi/180., inclusive=True, fact=8)
            inhpix = np.append(inhpix, pixint)
        inhpix = np.unique(inhpix)
        _, indices = esutil.numpy_util.match(inhpix, galtable.hpix)

    return indices
示例#60
0
def make_disc( nside, radius, direction=[1,0,0], radians=False, minus=False):

	import numpy as np
	import healpy as hp
	
	info_message( 'nside  = ' + str(nside) )
	info_message( 'radius = ' + str(radius) )
	npix = 12l*nside**2

	mask = np.zeros( npix )
	d2r = np.pi / 180.
	if not radians:
		radius *= d2r

	listpix = hp.query_disc( nside, direction, radius )

	mask[listpix] = 1.

	if minus:
		mask = 1. - mask

	return mask