def test_baryvel(self):
dat = numpy.loadtxt("testPro/baryvel.test")
err = 0
for i in range(10000):
jd = 2.4e6 + float(i)*10.37681
a, b = baryvel(jd, 0)
delta = numpy.abs(dat[i,::] - numpy.concatenate((a,b)))
if max(delta) > 1e-6:
err += 1
print "Baryvel error:", dat[i,::], a, b
print "max: ", max(delta)
self.assertEqual(err, 0)
i = 0
dat = numpy.loadtxt("testPro/baryvel2.test")
for j in range(101):
jd = 2.4e6 + float(j)*1000.37681
for k in range(11):
deq = jd + float(k-5) * 10000.0
a, b = baryvel(jd, deq)
delta = numpy.abs(dat[i,0:6] - numpy.concatenate((a,b)))
if abs(jd - dat[i,6]) > 1e-6:
print "JD problem: ", jd, dat[i,6], i, k
if abs(deq - dat[i,7]) > 1e-6:
print "deq problem: ", deq, dat[i,7], i, k
if max(delta) > 1e-6:
err += 1
print "Baryvel error:", dat[i,::], a, b
print "max: ", max(delta)
print "i, k: ", i, k
i += 1
def helcorr(obs_long, obs_lat, obs_alt, ra2000, dec2000, jd, debug=False):
#calculates heliocentric Julian date, baricentric and heliocentric radial
#velocity corrections from:
#
#INPUT:
#<OBSLON> Longitude of observatory (degrees, western direction is positive)
#<OBSLAT> Latitude of observatory (degrees)
#<OBSALT> Altitude of observatory (meters)
#<RA2000> Right ascension of object for epoch 2000.0 (hours)
#<DE2000> Declination of object for epoch 2000.0 (degrees)
#<JD> Julian date for the middle of exposure
#[DEBUG=] set keyword to get additional results for debugging
#
#OUTPUT:
#<CORRECTION> baricentric correction - correction for rotation of earth,
# rotation of earth center about the eart-moon barycenter, eart-moon
# barycenter about the center of the Sun.
#<HJD> Heliocentric Julian date for middle of exposure
#
#Algorithms used are taken from the IRAF task noao.astutils.rvcorrect
#and some procedures of the IDL Astrolib are used as well.
#Accuracy is about 0.5 seconds in time and about 1 m/s in velocity.
#
#History:
#written by Peter Mittermayer, Nov 8,2003
#2005-January-13 Kudryavtsev Made more accurate calculation of the sideral time.
# Conformity with MIDAS compute/barycorr is checked.
#2005-June-20 Kochukhov Included precession of RA2000 and DEC2000 to current epoch
#covert JD to Gregorian calendar date
xjd = array(2400000.).astype(float) + jd
year,month,day,ut=daycnv(xjd)
#current epoch
epoch = year + month / 12. + day / 365.
#precess ra2000 and dec2000 to current epoch
ra,dec=precess(ra2000*15., dec2000, 2000.0, epoch)
#calculate heliocentric julian date
hjd = array(helio_jd(jd, ra, dec)).astype(float)
#DIURNAL VELOCITY (see IRAF task noao.astutil.rvcorrect)
#convert geodetic latitude into geocentric latitude to correct
#for rotation of earth
dlat = -(11. * 60. + 32.743) * sin(2 * obs_lat / _radeg) + 1.1633 * sin(4 * obs_lat / _radeg) - 0.0026 * sin(6 * obs_lat / _radeg)
lat = obs_lat + dlat / 3600
#calculate distance of observer from earth center
r = 6378160.0 * (0.998327073 + 0.001676438 * cos(2 * lat / _radeg) - 0.00000351 * cos(4 * lat / _radeg) + 0.000000008 * cos(6 * lat / _radeg)) + obs_alt
#calculate rotational velocity (perpendicular to the radius vector) in km/s
#23.934469591229 is the siderial day in hours for 1986
v = 2. * pi * (r / 1000.) / (23.934469591229 * 3600.)
#calculating local mean siderial time (see astronomical almanach)
tu = (jd - 51545.0) / 36525
gmst = 6.697374558 + ut + (236.555367908 * (jd - 51545.0) + 0.093104 * tu ** 2 - 6.2e-6 * tu ** 3) / 3600
lmst = (gmst - obs_long / 15) % 24
#projection of rotational velocity along the line of sight
vdiurnal = v * cos(lat / _radeg) * cos(dec / _radeg) * sin((ra - lmst * 15) / _radeg)
#BARICENTRIC and HELIOCENTRIC VELOCITIES
vh,vb=baryvel(xjd, 0)
#project to line of sight
vbar = vb[0] * cos(dec / _radeg) * cos(ra / _radeg) + vb[1] * cos(dec / _radeg) * sin(ra / _radeg) + vb[2] * sin(dec / _radeg)
vhel = vh[0] * cos(dec / _radeg) * cos(ra / _radeg) + vh[1] * cos(dec / _radeg) * sin(ra / _radeg) + vh[2] * sin(dec / _radeg)
corr = (vdiurnal + vbar) #using baricentric velocity for correction
if debug:
print ''
print '----- HELCORR.PRO - DEBUG INFO - START ----'
print '(obs_long,obs_lat,obs_alt) Observatory coordinates [deg,m]: ', obs_long, obs_lat, obs_alt
print '(ra,dec) Object coordinates (for epoch 2000.0) [deg]: ', ra, dec
print '(ut) Universal time (middle of exposure) [hrs]: ', ut#, format='(A,F20.12)'
print '(jd) Julian date (middle of exposure) (JD-2400000): ', jd#, format='(A,F20.12)'
print '(hjd) Heliocentric Julian date (middle of exposure) (HJD-2400000): ', hjd#, format='(A,F20.12)'
print '(gmst) Greenwich mean siderial time [hrs]: ', gmst % 24
print '(lmst) Local mean siderial time [hrs]: ', lmst
print '(dlat) Latitude correction [deg]: ', dlat
print '(lat) Geocentric latitude of observer [deg]: ', lat
print '(r) Distance of observer from center of earth [m]: ', r
print '(v) Rotational velocity of earth at the position of the observer [km/s]: ', v
print '(vdiurnal) Projected earth rotation and earth-moon revolution [km/s]: ', vdiurnal
print '(vbar) Baricentric velocity [km/s]: ', vbar
print '(vhel) Heliocentric velocity [km/s]: ', vhel
print '(corr) Vdiurnal+vbar [km/s]: ', corr#, format='(A,F12.9)'
print '----- HELCORR.PRO - DEBUG INFO - END -----'
print ''
return (corr, hjd)
def ugdoppler(ra, dec, julday, nlat=None, wlong=None, light=False, obspos_deg=None,lst_mean=None):
"""
NAME: ugdoppler
PURPOSE:
computes the projected velocity of the telescope wrt
four coordinate systems: geo, helio, bary, lsr.
negative velocities mean approach
the standard LSR is defined as follows: the sun moves at 20.0 km/s
toward ra=18.0h, dec=30.0 deg in 1900 epoch coords
CALLING SEQUENCE:
vel = ugdoppler( ra, dec, julday, $
nlat=nlat, wlong=wlong, $
path=path, light=light, $
obspos_deg=obspos_deg, lst_mean=lst_mean)
INPUTS: fully vectorized...ALL THREE INPUTS MUST HAVE SAME DIMENSIONS!!
ra[n] - the source ra in DECIMAL HOURS, equinox 2000
dec[n] - the source dec in decimal degrees, equinox 2000
julday[n] - the full (unmodified) julian day JD. MJD = JD - 2400000.5
KEYWORD PARAMETERS
nlat, wlong - specify nlat and wlong of obs in
degrees. if you set one, you must set the other
also. For Leuschner, nlat=37.8732, wlong=+122.2573
light - returns the velocity as a fraction of c
OUTPUTS:
program returns the velocity in km/s, or as a faction of c if
the keyword /light is specified. the result is a 4-element
vector whose elements are [geo, helio, bary, lsr]. quick
comparison with phil's C doppler routines gives agreement to
better than 100 m/s one arbitrary case.
OPTIONAL OUTPUTS:
obspos_deg: observatory [lat, wlong] in degrees that was used
in the calculation. This is set by either (nlat and wlong) or
path default is Arecibo.
lst_mean: the lst at the observatory for the specified JD
REVISION HISTORY: carlh 29oct04.
from idoppler_ch changed calculation epoch to 2000
19nov04: correct bad earth spin calculation
7 jun 2005: vectorize to make faster for quantity calculations.
20 Mar 2007: CH updated documentation for chdoppler and
created this version, ugdoppler, which uses the locally-derived lst
(from ilst.pro).
5apr2011: updated documentation, tested with tst.ugdopp.idl and
tst1.ugdopp.ilprc
"""
dtor = np.pi/180.
#------------------ORBITAL SECTION-------------------------
try:
nin = len(ra)
except:
ra, dec, julday = np.array([ra]), np.array([dec]), np.array([julday])
nin = 1
#GET THE COMPONENTS OF RA AND DEC, 2000u EPOCH
rasource=ra*15.*dtor
decsource=dec*dtor
xxsource = np.zeros((3, nin))
xxsource[0, :] = np.cos(decsource) * np.cos(rasource)
xxsource[1, :] = np.cos(decsource) * np.sin(rasource)
xxsource[2, :] = np.sin(decsource)
pvorbit_helio= np.zeros( nin)
pvorbit_bary= np.zeros( nin)
pvlsr= np.zeros( nin)
# GET THE EARTH VELOCITY WRT THE SUN CENTER
# THEN MULTIPLY BY SOURCE TO GET PROJECTED VELOCITY
# OF EARTH CENTER WRT SUN TO THE SOURCE
for NR in range(nin):
vvorbit, velb = baryvel(julday[NR], 2000.)
pvorbit_helio[NR]= np.sum(vvorbit* xxsource[:,NR])
pvorbit_bary[NR]= np.sum(velb* xxsource[:,NR])
#-----------------------LSR SECTION-------------------------
# THE STANDARD LSR IS DEFINED AS FOLLOWS: THE SUN MOVES AT 20.0 KM/S
# TOWARD RA=18.0H, DEC=30.0 DEG IN 1900 EPOCH COORDS
# using PRECESS, this works out to ra=18.063955 dec=30.004661 in 2000 coords.
ralsr_rad= 2.*np.pi*18./24.
declsr_rad= dtor*30.
ralsr_rad, declsr_rad = precess(ralsr_rad, declsr_rad, 1900., 2000.,radian=True)
#FIND THE COMPONENTS OF THE VELOCITY OF THE SUN WRT THE LSR FRAME
xxlsr = np.zeros(3)
xxlsr[0] = np.cos(declsr_rad) * np.cos(np.pi+ralsr_rad) #additional pi because Python and IDL just...
xxlsr[1] = np.cos(declsr_rad) * np.sin(ralsr_rad)
xxlsr[2] = np.sin(declsr_rad)
vvlsr = 20.*xxlsr
#PROJECTED VELOCITY OF THE SUN WRT LSR TO THE SOURCE
for NR in range(nin): pvlsr[NR]=np.sum(vvlsr*xxsource[:, NR])
#---------------------EARTH SPIN SECTION------------------------
#NOTE: THE ORIGINAL VERSION WAS FLAWED. WE comment out those bad statements...
# LEUSCHNER LAB COORDINATES...
northlat = 37.91934
westlong = 122.15385
obspos_deg= [ northlat, westlong]
# COORDS FROM NLAT, WLONG INPUT...
if nlat and wlong:
obspos_deg= [nlat, wlong]
# GET THE LATITUDE...
lat= obspos_deg[0]
# GET THE LST
lst_mean= rlab.getLST(juldate=julday, lon=-obspos_deg[1])
# MODIFIED EARTH SPIN FROM GREEN PAGE 270
pvspin= -0.465* np.cos(dtor* lat) * np.cos( decsource) * np.sin(( lst_mean- ra)* 15.*dtor)
#---------------------NOW PUT IT ALL TOGETHER------------------
vtotal= np.zeros((4, nin))
vtotal[ 0,:]= -pvspin
vtotal[ 1,:]= -pvspin- pvorbit_helio
vtotal[ 2,:]= -pvspin- pvorbit_bary
vtotal[ 3,:]= -pvspin- pvorbit_bary- pvlsr
if light: vtotal=vtotal/(2.99792458e5)
return vtotal
