Example #1
0
def calc_ang_dist(ra1, dec1, ra2, dec2, units='degrees',
                  safe=True, keeparray=False):
    DPIBY2 = 0.5 * pi
    
    if safe:
        ra1, dec1, ra2, dec2 = [checkarray(i, double=True)
                                for i in (ra1, dec1, ra2, dec2)]
    
    if units == "hrdeg":
        convRA = pi / 12.0
        convDEC = pi / 180.0
    elif units == "radians":
        convRA = 1.0
        convDEC = 1.0
    else: # degrees
        convRA = pi / 180.0
        convDEC = pi / 180.0
        
    theta1 = dec1*convDEC + DPIBY2
    theta2 = dec2*convDEC + DPIBY2
    cosgamma = (N.sin(theta1) * N.sin(theta2) * N.cos((ra1-ra2)*convRA) + 
               N.cos(theta1) * N.cos(theta2))
    adist = 0.0 * cosgamma
    ivalid = (cosgamma < 1.0).nonzero()[0]
    if len(ivalid) > 0:
        adist[ivalid] = N.arccos(cosgamma[ivalid]) / convDEC
    if (not keeparray) and (adist.shape == (1,)):
        return adist[0]
    else:
        return adist
Example #2
0
def zmax_sb(sbabs, sbapplim, zlow, zhigh, nz=None):
    sbabs = checkarray(sbabs)
    if nz is None:
        deltaz = 0.001
        nz = int((zhigh-zlow)/deltaz)
    deltaz = (zhigh-zlow)/float(nz)
    zlist = N.arange(zhigh+deltaz/10, zlow, -deltaz)
    dmodlist = dmod_flat(zlist)
    angscalelist = ang_scale_flat(zlist)
    sbabslist = sbapplim - dmodlist + 2.5*N.log10(angscalelist**2)
    i = N.searchsorted(sbabslist, sbabs)
    ihigh = i == nz+1
    N.putmask(i, ihigh, nz)
    ilow = i == 0
    N.putmask(i, ilow, 1)
    z1 = zlist[i-1]
    z2 = zlist[i]
    sb1 = sbabslist[i-1]
    sb2 = sbabslist[i]
    s = (z2-z1)/(sb2-sb1)
    zmax = z1 + s*(sbabs-sb1)
    N.putmask(zmax, ilow, zhigh)
    N.putmask(zmax, ihigh, zlow)
    if zmax.shape == (1,):
       zmax = zmax[0]
    return zmax
Example #3
0
def zmax_size(rkpc, raslim, zlow, zhigh, nz=None):
    rkpc = checkarray(rkpc)
    if nz is None:
        deltaz = 0.001
        nz = int((zhigh-zlow)/deltaz)
    deltaz = (zhigh-zlow)/float(nz)
    zlist = N.arange(zlow, zhigh+deltaz/10, deltaz)
    angscalelist = ang_scale_flat(zlist)
    rkpclist = raslim * angscalelist
    i = N.searchsorted(rkpclist, rkpc)
    ihigh = i == nz+1
    N.putmask(i, ihigh, nz)
    ilow = i == 0
    N.putmask(i, ilow, 1)
    z1 = zlist[i-1]
    z2 = zlist[i]
    r1 = rkpclist[i-1]
    r2 = rkpclist[i]
    s = (z2-z1)/(r2-r1)
    zmax = z1 + s*(rkpc-r1)
    N.putmask(zmax, ilow, zlow)
    N.putmask(zmax, ihigh, zhigh)
    if zmax.shape == (1,):
       zmax = zmax[0]
    return zmax
Example #4
0
def zmax(mabs, mapplim, zlow, zhigh, nz=None):
    mabs = checkarray(mabs)
    if nz is None:
        deltaz = 0.001
        nz = int((zhigh-zlow)/deltaz)
    deltaz = (zhigh-zlow)/float(nz)
    zlist = N.arange(zhigh+deltaz/10, zlow, -deltaz)
    dmodlist = dmod_flat(zlist)
    mabslist = mapplim - dmodlist
    i = N.searchsorted(mabslist, mabs, side='left')
    ihigh = i == nz+1
    N.putmask(i, ihigh, nz)
    ilow = i == 0
    N.putmask(i, ilow, 1)
    z1 = zlist[i-1]
    z2 = zlist[i]
    m1 = mabslist[i-1]
    m2 = mabslist[i]
    s = (z2-z1)/(m2-m1)
    zmax = z1 + s*(mabs-m1)
    N.putmask(zmax, ilow, zhigh)
    N.putmask(zmax, ihigh, zlow)
    if zmax.shape == (1,):
       zmax = zmax[0]
    return zmax
Example #5
0
def vol(zmin, zmax, H0=H0_std, omega_m0=omega_m0_std, omega_lambda0=omega_lambda0_std):
    zmax = checkarray(zmax)
    zmin = checkarray(zmin)
    v = N.zeros(zmax.shape)
    # function to integrate
    def intfn(z):
        return 4 * pi * dA_flat(z, H0, omega_m0) ** 2 * (1 + z) ** 2 * c0 / H(z, H0, omega_m0, omega_lambda0)

    for i in range(len(zmax)):
        zmini = zmin[i]
        zmaxi = zmax[i]
        vi, vierr = scipy.integrate.quadrature(intfn, zmini, zmaxi, tol=1.0e-3, maxiter=100)
        # this tol is easily sufficient for any reasonable zmin, zmax
        v[i] = vi
    if len(v) == 1:
        v = v[0]
    return v
Example #6
0
def rahms_decdms_to_deg(ra_h, ra_m, ra_s, dec_d, dec_m, dec_s, safe=True):
    if safe:
        ra_h, ra_m, ra_s = [checkarray(i, double=True)
                            for i in (ra_h, ra_m, ra_s)]
        dec_d, dec_m, dec_s = [checkarray(i, double=True)
                               for i in (dec_d, dec_m, dec_s)]
    ra_sign = (ra_h+0.5) / abs(ra_h+0.5)
    ra_h = N.absolute(ra_h)
    ra_hours = ra_sign * (ra_h + ra_m / 60.0 + ra_s / 3600.0)
    ra_deg = ra_hours * 15.0
    dec_sign = (dec_d+0.5) / abs(dec_d+0.5)
    dec_d = N.absolute(dec_d)
    dec_deg = dec_sign * (dec_d + dec_m / 60.0 + dec_s / 3600.0)
    # put onto ranges RA: 0..360 deg, Dec: -90..90
    while (dec_deg >= 360.0).any():
        dec_deg[decdeg >= 360.0] -= 360.0
    while (dec_deg < 0.0).any():
        dec_deg[decdeg < 0.0] += 360.0
    select = (dec_deg < 270.0)&(dec_deg > 90.0)
    ra_deg[select] += 180.0
    dec_deg[select] *= -1
    dec_deg[select] += 180
    select = (dec_deg > -270.0)&(dec_deg < -90.0)
    ra_deg[select] += 180.0
    dec_deg[select] *= -1
    dec_deg[select] -= 180
    select = (dec_deg >= 270.0)
    dec_deg[select] -= 360
    select = (dec_deg <= -270.0)
    dec_deg[select] += 360
    while (ra_deg >= 360.0).any():
        ra_deg[radeg >= 360.0] -= 360.0
    while (ra_deg < 0.0).any():
        ra_deg[radeg < 0.0] += 360.0
    if len(ra_deg) == 1:
        ra_deg = ra_deg[0]
        dec_deg = dec_deg[0]
    return ra_deg, dec_deg
Example #7
0
def radec_deg_to_hms_dms(ra_deg, dec_deg, sec_precision=3, safe=True,
                         asstring=True):
    if safe:
        ra_deg = checkarray(ra_deg, double=True)
        dec_deg = checkarray(dec_deg, double=True)
    ra_abs = N.absolute(ra_deg)
    ra_signval = ra_deg/ra_abs
    ra_sign = N.where(ra_signval > 0, '', '-')
    ra_hfull = ra_abs / 15.0
    ra_h = ra_hfull.astype(N.int)
    ra_mfull = (ra_hfull - ra_h) * 60.0
    ra_m = ra_mfull.astype(N.int)
    ra_s = (ra_mfull - ra_m) * 60.0
    dec_abs = N.absolute(dec_deg) 
    dec_signval = dec_deg/dec_abs
    dec_sign = N.where(dec_signval > 0, '+', '-')
    dec_d = dec_abs.astype(N.int)
    dec_mfull = (dec_abs - dec_d) * 60.0
    dec_m = dec_mfull.astype(N.int)
    dec_s = (dec_mfull - dec_m) * 60.0
    ra_sec_precision = max(0,sec_precision-1)
    dec_sec_precision = max(0,sec_precision)
    ra_format = '%s%02i:%02i:%'+'0%i.%i'%(3+ra_sec_precision, ra_sec_precision)+'f'
    dec_format = '%s%02i:%02i:%'+'0%i.%i'%(3+dec_sec_precision, dec_sec_precision)+'f'
    n = len(ra_deg)
    if asstring:
        ra = N.zeros(n, dtype='S%i'%(10+sec_precision))
        dec = N.zeros(n, dtype='S%i'%(10+sec_precision))
        for i in range(n):
            ra[i] = ra_format%(ra_sign[i], ra_h[i], ra_m[i], ra_s[i])
            dec[i] = dec_format%(dec_sign[i], dec_d[i], dec_m[i], dec_s[i])
            if n == 1:
                ra = ra[0]
                dec = dec[0]
        return ra, dec
    else:
        return ra_signval*ra_h, ra_m, ra_s, dec_signval*dec_d, dec_m, dec_s
Example #8
0
def matchpos(ra1,dec1,ra2,dec2,tol):
    """ Match two sets of ra,dec within a tolerance.
        Longer catalog should go first
        Arguments:
          ra1 - Right Ascension decimal degrees (numpy array)
          dec1 - Declination decimal degrees (numpy array)
          ra2 - Right Ascension decimal degrees (numpy array)
          dec2 - Declination decimal degrees (numpy array)
          tol - Matching tolerance in degrees. 
        Returns:
          ibest - indices of the best matches within tol; -1 if no match within tol
          sep - separations (defaults to tol if no match within tol)
    """
    ra1, dec1, ra2, dec2 = [checkarray(i, double=True)
                            for i in (ra1, dec1, ra2, dec2)]
    indices = N.argsort(ra1)
    rasorted = ra1[indices]
    decsorted = dec1[indices]
    ibest = []
    sep = []
    m = len(ra1)
    n = len(ra2)
    print '%i rows in catalog 1,  %i rows in catalog 2'%(m, n)
    if n > 1000:
        npc = n//100
        print '%:',
    for i in range(n):
        if n > 1000:
            if i%npc == 0:
                print i//npc,
                sys.stdout.flush()
        j, s = matchsorted(rasorted,decsorted,ra2[i],dec2[i],tol)
        if j < 0:
            ibest += [j]
        else:
            ibest += [indices[j]]
        sep += [s]
    if n > 1000: print
    return N.array(ibest), N.array(sep)
Example #9
0
def pgerrbx(x, y, xerr, cap=1.0):
    x = checkarray(x)
    y = checkarray(y)
    xerr = checkarray(xerr)
    pgerrb(5, x, y, xerr, cap)
Example #10
0
def pgerrby(x, y, yerr, cap=1.0):
    x = checkarray(x)
    y = checkarray(y)
    yerr = checkarray(yerr)
    pgerrb(6, x, y, yerr, cap)