def calculate_julian_century(datetime):
"""
Given a datetime object return the julian century from the 2000 epoch.
:param datetime:
A datetime object containing the date to be converted to a
Julian centuries since 2000/01/01 12:00.
:return:
A floating point value representing the Julian centuries since
the 2000/01/01 12:00 epoch.
"""
# Convert the scene timestamp to a julian date
d = ephem.date(datetime)
jdate = ephem.julian_date(d)
# Get the J2000 epoch
epoch = ephem.date((2000, 1, 1, 12.00))
j2_epoch = ephem.julian_date(epoch)
# Note:
# This differes from online sources such as
# http://www.pietro.org/astro_util_staticdemo/FDetailDateConversions.htm
# http://en.wikipedia.org/wiki/Equinox_(celestial_coordinates)
# which use:
# 2000 + (jdate - epoch) / 365.25
century = (jdate - j2_epoch) / 36525
return century
def LunarCalendar(nian, type=1): # type=1时截止到次年冬至朔，=0时截止到次年冬至朔次月
dzs = findDZS(nian)
shuo = dzs # 计算用朔，date格式
shuoJD = [ephem.julian_date(dzs)] # 存储ut+8 JD，起冬至朔
next_dzsJD = ephem.julian_date(findDZS(nian + 1)) # 次年冬至朔
i = -1 # 中气序，从0起计
j = -1 # 计算连续两个冬至月中的合朔次数，从0起计
zry = 0
flag = False
# 查找所在月及判断置闰
while not DateCompare(shuoJD[j + type], next_dzsJD): # 从冬至月起查找，截止到次年冬至朔
i += 1
j += 1
shuo = ephem.next_new_moon(shuo) # 次月朔
shuoJD.append(ephem.julian_date(shuo))
# 查找本月中气，若无则置闰
if j == 0: continue # 冬至月一定含中气，从次月开始查找
angle = (-90 + 30 * i) % 360 # 本月应含中气，起冬至
qJD = SolarTerms(nian, angle)
# 不判断气在上月而后气在后月的情况，该月起的合朔次数不超过气数，可省去
if DateCompare(qJD, shuoJD[j + 1]) and flag == False: # 中气在次月，则本月无中气
zry = j + 1 # 置闰月
i -= 1
flag = True # 仅第一个无中气月置闰
# 生成农历月序表
ymb = []
for k in range(len(shuoJD)):
ymb.append(yuefen[(k - 2) % 12]) # 默认月序
if j + type == 13: # 仅12次合朔不闰，有闰时修改月名
if k + 1 == zry:
ymb[k] = '闰' + yuefen[(k - 1 - 2) % 12]
elif k + 1 > zry:
ymb[k] = yuefen[(k - 1 - 2) % 12]
return ymb, shuoJD # 月名表，合朔JD日期表
def set_datetime(self, D=1, v=0):
""" set and compute all times for observatory
v = 'v' for verbose """
k = '{:0=+3.0f}'.format(int(D))
k = int(k)
t = datetime.date.today() + datetime.timedelta(+k)
tt = datetime.time(0, 0)
self.comp_date = datetime.datetime.combine(t, tt)
self.oadm.date = self.comp_date
self.Dat1 = self.oadm.next_rising(ep.Sun(), use_center=True)
self.Dat0 = self.oadm.previous_setting(ep.Sun(), use_center=True)
self.start_night = self.Dat0.datetime()
self.end_night = self.Dat1.datetime()
self.night_len = (self.end_night - self.start_night)
self.lst = self.oadm.sidereal_time()
self.utc = ep.now().datetime()
self.jd0 = ep.julian_date(0)
self.jd_now = ep.julian_date(ep.now())
self.jd_comp = ep.julian_date(self.comp_date)
self.jd_start = ep.julian_date(self.start_night)
self.jd_end = ep.julian_date(self.end_night)
if v == 'v':
D = str(D)
print '> set_datetime > d' + D, ' > ', self.oadm.date, '-', self.jd_comp #self.print_date()
return
def convertToJulianTuple(timestamp):
""" Convert a list of timestamps into DATE and TIME since julian midnight
FITS-IDI requires DATE parameter is set to Julian date @ midnight. TIME is
then indexed against this DATE.
timestamp (float): timestamp of type 'float' is preferred, but this should
handle time tuples, strings and datetime objects too.
"""
# Figure out exactly what type of timestamp we've got.
if type(timestamp) in (str, unicode):
tt = parse_timestring(timestamp)
ts = calendar.timegm(tt)
elif type(timestamp) is float:
ts = timestamp
elif type(timestamp) is tuple:
ts = calendar.timegm(timestamp)
elif type(timestamp) is type(datetime.now):
date_str = timestamp.strftime("%Y-%m-%dT%H:%M:%S")
tt = time.strptime(date_str, "%Y-%m-%dT%H:%M:%S")
ts = calendar.timegm(tt)
else:
raise TypeError("Unknown timestamp type '%s'" % str(type(timestamp)))
# DATE is julian date at midnight that day
# TIME is in DAYS since midnight
julian = ephem.julian_date(time.gmtime(ts)[:6])
# Ephem returns julian date at NOON, we need at MIDNIGHT
julian_midnight = int(julian) - 0.5
time_elapsed = ephem.julian_date(time.gmtime(ts)[:6]) - julian_midnight
return julian_midnight, time_elapsed
def get_time_range(start_time,end_time,timestep,time_in_sec,TIME_OFFSET=0):
if HAS_PYRAP:
try:
start_time = qu.quantity(start_time).get_value()
end_time = qu.quantity(end_time).get_value()
print ('**** specified start and end time ', start_time, end_time)
reference_time = start_time * 86400.0 - TIME_OFFSET
st = reference_time - timestep
et = end_time * 86400.0 + timestep + TIME_OFFSET
#print "getting string",reference_time
str_start_time = obtain_observation_year_month_day_hms(reference_time)
timerange= [st, et]
except:
print ('no time range given')
print ('exiting')
return -1,-1,-1
elif HAS_EPHEM:
if time_in_sec:
dublin_start = start_time / 86400.0 -15019.5
dublin_end = end_time / 86400.0 -15019.5
start_time = ephem.julian_date(ephem.Date(dublin_start)) - 2400000.5
end_time = ephem.julian_date(ephem.Date(dublin_end)) - 2400000.5
else:
start_time = ephem.julian_date(ephem.Date(start_time)) - 2400000.5
end_time = ephem.julian_date(ephem.Date(end_time)) - 2400000.5
print ('ephem start and end time ', start_time, end_time)
reference_time = start_time * 86400.0 - TIME_OFFSET
st = reference_time - timestep
et = end_time * 86400.0 + timestep + TIME_OFFSET
str_start_time = obtain_observation_year_month_day_hms(reference_time)
timerange= [st, et]
else:
print ('unable to get time range so exiting!')
return -1,-1,-1
return timerange,str_start_time,reference_time
def create_ascii_table(observation_table, outfile):
"""Given a table of observations create an ascii log file for easy parsing.
Store the result in outfile (could/should be a vospace dataNode)
observation_table: astropy.votable.array object
outfile: str (name of the vospace dataNode to store the result to)
"""
logging.info("writing text log to %s" % outfile)
stamp = "#\n# Last Updated: " + time.asctime() + "\n#\n"
header = "| %20s | %20s | %20s | %20s | %20s | %20s | %20s |\n" % (
"EXPNUM", "OBS-DATE", "FIELD", "EXPTIME(s)", "RA", "DEC", "RUNID")
bar = "=" * (len(header) - 1) + "\n"
if outfile[0:4] == "vos:":
temp_file = tempfile.NamedTemporaryFile(suffix='.txt')
fout = temp_file
else:
fout = open(outfile, 'w')
t2 = None
fout.write(bar + stamp + bar + header)
populated = storage.list_dbimages()
for i in range(len(observation_table) - 1, -1, -1):
row = observation_table.data[i]
if row['dataset_name'] not in populated:
storage.populate(row['dataset_name'])
str_date = str(
ephem.date(row.StartDate + 2400000.5 -
ephem.julian_date(ephem.date(0))))[:20]
t1 = time.strptime(str_date, "%Y/%m/%d %H:%M:%S")
if t2 is None or math.fabs(time.mktime(t2) -
time.mktime(t1)) > 3 * 3600.0:
fout.write(bar)
t2 = t1
ra = str(ephem.hours(math.radians(row.RA)))
dec = str(ephem.degrees(math.radians(row.DEC)))
line = "| %20s | %20s | %20s | %20.1f | %20s | %20s | %20s |\n" % (
str(row.dataset_name),
str(
ephem.date(row.StartDate + 2400000.5 -
ephem.julian_date(ephem.date(0))))[:20],
row.TargetName[:20], row.ExposureTime, ra[:20], dec[:20],
row.ProposalID[:20])
fout.write(line)
fout.write(bar)
if outfile[0:4] == "vos:":
fout.flush()
storage.copy(fout.name, outfile)
fout.close()
return
def create_ascii_table(observation_table, outfile):
"""Given a table of observations create an ascii log file for easy parsing.
Store the result in outfile (could/should be a vospace dataNode)
observation_table: astropy.votable.array object
outfile: str (name of the vospace dataNode to store the result to)
"""
logging.info("writing text log to %s" % outfile)
stamp = "#\n# Last Updated: " + time.asctime() + "\n#\n"
header = "| %20s | %20s | %20s | %20s | %20s | %20s | %20s |\n" % (
"EXPNUM", "OBS-DATE", "FIELD", "EXPTIME(s)", "RA", "DEC", "RUNID")
bar = "=" * (len(header) - 1) + "\n"
if outfile[0:4] == "vos:":
temp_file = tempfile.NamedTemporaryFile(suffix='.txt')
fout = temp_file
else:
fout = open(outfile, 'w')
t2 = None
fout.write(bar + stamp + bar + header)
populated = storage.list_dbimages()
for i in range(len(observation_table) - 1, -1, -1):
row = observation_table.data[i]
if row['dataset_name'] not in populated:
storage.populate(row['dataset_name'])
str_date = str(ephem.date(row.StartDate +
2400000.5 -
ephem.julian_date(ephem.date(0))))[:20]
t1 = time.strptime(str_date, "%Y/%m/%d %H:%M:%S")
if t2 is None or math.fabs(time.mktime(t2) - time.mktime(t1)) > 3 * 3600.0:
fout.write(bar)
t2 = t1
ra = str(ephem.hours(math.radians(row.RA)))
dec = str(ephem.degrees(math.radians(row.DEC)))
line = "| %20s | %20s | %20s | %20.1f | %20s | %20s | %20s |\n" % (
str(row.dataset_name),
str(ephem.date(row.StartDate + 2400000.5 -
ephem.julian_date(ephem.date(0))))[:20],
row.TargetName[:20],
row.ExposureTime, ra[:20], dec[:20], row.ProposalID[:20])
fout.write(line)
fout.write(bar)
if outfile[0:4] == "vos:":
fout.flush()
storage.copy(fout.name, outfile)
fout.close()
return
def record_night(self):
self.__NightSummary[0] = self.t_start
self.__NightSummary[1] = self.t_end
self.__NightSummary[2] = self.init_id
np.save(
"Output/Schedule{}.npy".format(int(ephem.julian_date(self.Date))),
self.__NightOutput)
np.save(
"Output/Summary{}.npy".format(int(ephem.julian_date(self.Date))),
self.__NightSummary)
np.save("Output/Watch{}.npy".format(int(ephem.julian_date(self.Date))),
self.tonight_telescope.watch)
def cp_transit(self,
ob,
x,
k='+'): #TODO: revisar transits next i previous!
""" returns the JD of previous/next object transit
ob = coordinate line in ephem format """
obj = ep.readdb(ob)
self.Transit = ep.julian_date(self.oadm.previous_transit(obj))
if self.Transit < self.jd_start:
self.Transit = ep.julian_date(self.oadm.next_transit(obj))
if k == '+':
x['transit'] = self.Transit
return self.Transit
def cp_obs_time_airm(self, x, ob, t1, t2, k='+'):
"""compute visibility time (from airmass req. A)
ob = coordinates line in ephem format
x = {toi} data
t1,t2 = start/end time to compute
k = '+' to set values of V,NV,WV periods in {toi}"""
self.V_period, self.WV_period, self.NV_period = [], [], []
obj = ep.readdb(ob)
td = datetime.timedelta(seconds=self.time_acc)
obsv = []
period = []
i = 0
#t1 = t1-td
while t1 <= t2:
self.oadm.date = t1
obj.compute(self.oadm)
air0 = self.comp_air(ob, t1)
if air0 > float(x['airmass_max']) or air0 < float(
x['airmass_min']):
obsv0 = 0
else:
obsv0 = 1
obsv.append([obsv0, t1])
t1 += td
period.append([0, obsv[0]])
period.append([obsv.index(obsv[-1]), obsv[-1]])
for i in range(len(obsv) - 1):
if obsv[i][0] != obsv[i + 1][0]:
period.append([obsv.index(obsv[i]), obsv[i]])
sort_period = sorted(period)
for i in range(len(sort_period) - 1):
kk = [
sort_period[i + 1][1][0], x['id'],
ep.julian_date(sort_period[i][1][1]),
ep.julian_date(sort_period[i + 1][1][1])
]
self.V_period.append(kk)
if kk[0] == 0:
self.NV_period.append(kk)
else:
self.WV_period.append(kk)
self.oadm.date = self.comp_date
if k == '+':
x['V_period'] = self.V_period
x['WV_period'] = self.WV_period
x['NV_period'] = self.NV_period
return self.V_period, self.WV_period, self.NV_period
def _kbos_from_survey_sym_model_input_file(model_file):
"""
Load a Survey Simulator model file as an array of ephem EllipticalBody objects.
@param model_file:
@return:
"""
lines = storage.open_vos_or_local(model_file).read().split('\n')
kbos = []
for line in lines:
if len(line) == 0 or line[
0] == '#': # skip initial column descriptors and the final blank line
continue
kbo = ephem.EllipticalBody()
values = line.split()
kbo.name = values[8]
kbo.j = values[9]
kbo.k = values[10]
kbo._a = float(values[0])
kbo._e = float(values[1])
kbo._inc = float(values[2])
kbo._Om = float(values[3])
kbo._om = float(values[4])
kbo._M = float(values[5])
kbo._H = float(values[6])
epoch = ephem.date(2453157.50000 - ephem.julian_date(0))
kbo._epoch_M = epoch
kbo._epoch = epoch
kbos.append(kbo)
return kbos
def test_JulianDate_reduce_datetime(date, expected):
d = datetime.datetime(*date)
jd = JulianDate.from_datetime(d, reduced=True)
assert jd.reduced
assert np.allclose(jd.jd, expected)
assert np.allclose(jd.jd, ephem.julian_date(d) - 2400000)
def _kbos_from_survey_sym_model_input_file(model_file):
"""
Load a Survey Simulator model file as an array of ephem EllipticalBody objects.
@param model_file:
@return:
"""
lines = storage.open_vos_or_local(model_file).read().split('\n')
kbos = []
for line in lines:
if len(line) == 0 or line[0] == '#': # skip initial column descriptors and the final blank line
continue
kbo = ephem.EllipticalBody()
values = line.split()
kbo.name = values[8]
kbo.j = values[9]
kbo.k = values[10]
kbo._a = float(values[0])
kbo._e = float(values[1])
kbo._inc = float(values[2])
kbo._Om = float(values[3])
kbo._om = float(values[4])
kbo._M = float(values[5])
kbo._H = float(values[6])
epoch = ephem.date(2453157.50000 - ephem.julian_date(0))
kbo._epoch_M = epoch
kbo._epoch = epoch
kbos.append(kbo)
return kbos
def gen_ha_axis(timestamps, scale, offset, RA):
""" Return a list of real times from the timestamp vector"""
# get the timestamps
timestamps = numpy.array(timestamps, dtype=float)
t = numpy.zeros(len(timestamps), dtype=numpy.float64)
t = numpy.array(offset + timestamps / scale,
dtype=numpy.float64) #UNIX times
gmt_ref = time.gmtime(t[0]) # Start time in UTC
jd_ref = ephem.julian_date(gmt_ref[0:6])
ha = numpy.zeros_like(t)
for i, ti in enumerate(t):
obs.date = ephem.Date(time.gmtime(ti)[0:6])
#print "time is", obs.date
ha[i] = obs.sidereal_time() - RA
#print obs.sidereal_time(), RA, obs.sidereal_time()-RA
# Unwrap the phases, otherwise weird things can happen
# When the lst crosses midnight
ha = numpy.unwrap(ha)
ha = numpy.rad2deg(ha)
if RA == 0:
scale = 'Local Sidereal Time'
else:
scale = 'Hour Angle'
return {
'times': ha,
'scale': scale,
'ref': RA,
'gmtref': gmt_ref,
'jd_ref': jd_ref,
'unit': ''
}
def gen_time_axis(timestamps, scale, offset):
""" Return a list of real times from the timestamp vector"""
# get the timestamps
timestamps = numpy.array(timestamps, dtype=float)
t = numpy.zeros(len(timestamps), dtype=numpy.float64)
t = numpy.array(offset + timestamps / scale,
dtype=numpy.float64) #UNIX times
t_range = t[-1] - t[0]
gmt_ref = time.gmtime(t[0]) # Start time in UTC
jd_ref = ephem.julian_date(gmt_ref[0:6])
if t_range < 300:
scale = 'Seconds since %.4d/%.2d/%.2d %.2d:%.2d:%.2d UTC' % (
gmt_ref[0:6])
t = (t - t[0])
elif t_range < 60 * 60 * 3:
scale = 'Minutes since %.2d/%.2d/%.2d %.2d:%.2d:%.2d UTC' % (
gmt_ref[0:6])
t = (t - t[0]) / 60
else:
scale = 'Hours since %.2d/%.2d/%.2d %.2d:%.2d:%.2d UTC' % (
gmt_ref[0:6])
t = (t - t[0]) / 60 / 60
return {
'times': t,
'scale': scale,
'ref': t[0],
'gmtref': gmt_ref,
'jd_ref': jd_ref,
'unit': ''
}
def calculate_airmass(file_name):
"""
Calculates AIRMASS for the FITS file and appends respective details in the header of the file 'file_name'
Args:
file_name : FITS file whose header has to be edited
Returns:
None
"""
hdulist = fits.open(file_name, mode='update')
file_header = hdulist[0].header
date_obs = file_header[str(date_keyword)]
time_start = file_header[str(time_start_keyword)]
if str(RA_keyword) in file_header.keys():
object_ra = file_header[str(RA_keyword)]
else:
object_ra = RA_object
if str(DEC_keyword) in file_header.keys():
object_dec = file_header[str(DEC_keyword)]
else:
object_dec = DEC_object
time_utc = str(datetime.timedelta(seconds=int(time_start)))
datetime_utc = str(date_obs) + ' ' + str(time_utc)
julian_day = ephem.julian_date(datetime_utc)
telescope = ephem.Observer()
telescope.lon = OBS_LONG
telescope.lat = OBS_LAT
telescope.elevation = OBS_ALT
telescope.pressure = 0
telescope.epoch = ephem.J2000
telescope.date = datetime_utc
obj_pos = ephem.FixedBody()
obj_pos._ra = object_ra
obj_pos._dec = object_dec
obj_pos._epoch = ephem.J2000
obj_pos.compute(telescope)
time_sidereal = telescope.sidereal_time()
object_alt = Angle(str(obj_pos.alt) + ' degrees').degree
airmass = 1 / math.cos(math.radians(90 - object_alt))
list_keywords = ['OBSERVAT', 'OBS_LAT', 'OBS_LONG', 'OBS_ALT', 'TIMEZONE', 'DATE_OBS', 'UT', 'JD', 'ST', 'RA',
'DEC', 'ALT', 'AZ', 'AIRMASS']
dict_header = {'OBSERVAT': str(OBS_NAME), 'OBS_LAT': str(OBS_LAT), 'OBS_LONG': str(OBS_LONG),
'OBS_ALT': str(OBS_ALT), 'TIMEZONE': str(OBS_TIMEZONE), 'DATE_OBS': str(date_obs),
'UT': str(time_utc), 'JD': str(julian_day), 'ST': str(time_sidereal), 'RA': str(object_ra),
'DEC': str(object_dec), 'ALT': str(obj_pos.alt), 'AZ': str(obj_pos.az), 'AIRMASS': str(airmass)}
for keyword in list_keywords:
if keyword in file_header.keys():
file_header.remove(str(keyword), remove_all=True)
file_header.append(card=(keyword, dict_header[keyword]))
hdulist.flush()
hdulist.close()
def update_local_googledex(intime,googledex_file="googledex.dat", observed_file="observed_targets"):
"""
Update the local copy of the googledex with the last observed star time.
update_local_googledex(time,googledex_file="googledex.dat", observed_file="observed_targets")
opens googledex_file and inputs date of last observation from observed_file
in principle can use timestamps as well as scriptobs uth and utm values
"""
names, times = ObservedLog.getObserved(observed_file)
try:
g = open(googledex_file, 'rb')
full_codex = pickle.load(g)
g.close()
except IOError:
apflog("googledex file did not exist, so can't be updated",echo=True)
return names,times
except EOFError:
apflog("googledex file corrupt, so can't be updated",echo=True)
return names,times
codex_cols = full_codex[0]
starNameIdx = codex_cols.index("Star Name")
lastObsIdx = codex_cols.index("lastobs")
try:
nObsIdx = codex_cols.index("nObsIdx")
except:
nObsIdx = -1
for i in range(1, len(full_codex)):
row = full_codex[i]
if row[starNameIdx] in names:
# We have observed this star, so lets update the last obs field
obstime = times[names.index(row[starNameIdx])]
if isinstance(obstime,float):
t = datetime.utcfromtimestamp(obstime)
else:
hr, min = obstime
if type(intime) != datetime:
ctime = datetime.now()
td = timedelta(0,3600.*7)
intime = ctime + td
t = datetime(intime.year, intime.month, intime.day, hr, min)
# This keeps the JD precision to one decimal point. There is no real reason for this other than
# the googledex currently only stores the lastObs field to one decimal precision. Legacy styles FTW.
jd = round(float(ephem.julian_date(t)), 2)
apflog( "Updating local googledex star %s from time %s to %s" % (row[starNameIdx], row[lastObsIdx], str(jd)),echo=True)
row[lastObsIdx] = str(jd)
if nObsIdx > 0:
row[nObsIdx] = row[nObsIdx] + 1
full_codex[i] = row
with open(googledex_file, 'wb') as f:
pickle.dump(full_codex, f)
f.close()
return names, times
def gmst(self):
if self._gmst is None:
jd = ephem.julian_date(self.ut)
T = (jd - 2451545.0)/36525.0
gmstdeg = 280.46061837+(360.98564736629*(jd-2451545.0))+(0.000387933*T*T)-(T*T*T/38710000.0)
self._gmst = ephem.degrees(gmstdeg*numpy.pi/180.0)
return self._gmst
def synthetic_model_kbos(date, maglimit=24.5, kbotype='resonant'):
ra = []
dist = []
hlat = []
for line in open('L7SyntheticModel-v09.txt'):
if line[0]=='#':
continue
kbo = ephem.EllipticalBody()
values = line.split()
kbo._a = float(values[0])
kbo._e = float(values[1])
kbo._inc = float(values[2])
kbo._Om = float(values[3])
kbo._om = float(values[4])
kbo._M = float(values[5])
kbo._H = float(values[6])
kbo._epoch_M = ephem.date(2453157.50000 - ephem.julian_date(0))
kbo._epoch = kbo._epoch_M
kbo.name = values[8] # values[9] and [10] encode the type of resonance eg. 2:1 - add that if wanted
kbo.compute(ephem.date(date))
if (kbo.mag < maglimit):# and (kbo.name == kbotype):
ra.append(kbo.ra)
dist.append(kbo.sun_distance)
hlat.append(kbo.hlat)
return ra, dist, hlat
def init_night(self):
# Reset Nights outputs
self.__NightOutput = np.zeros(
(1200, ),
dtype=[('Field_id', np.int), ('ephemDate', np.float),
('Filter', np.int), ('n_ton', np.int), ('n_last', np.int),
('Cost', np.float), ('Slew_t', np.float),
('t_since_v_ton', np.float), ('t_since_v_last', np.float),
('Alt', np.float), ('HA', np.float),
('t_to_invis', np.float), ('Sky_bri', np.float),
('Temp_coverage', np.int)]) # at most 1200 visits per night
self.__NightSummary = np.zeros(3) # t_start and t_end for now
# Reset time
self.clock(0, True)
# Reset fields' state
self.reset_fields_state()
# Reset telescope
init_state = self.init_state(self.manual_init_state, False)
init_filter = self.init_filter()
init_state.update_visit_var(self.__t)
self.tonight_telescope.update(self.t_start, self.n_start, self.__step,
init_state, init_filter)
self.minimum_cost = 0.
self.reset_feedback()
# Record initial condition
self.op_log = open(
"Output/log{}.lis".format(int(ephem.julian_date(self.Date))), "w")
self.record_visit()
def epochString(self):
if self.epoch == Epoch.J2000:
return "J2000.0"
elif self.epoch == Epoch.B1950:
return "B1950.0"
else:
return "J%.2f" % (2000.0 + (ephem.julian_date() - 2451545.0) / 365.25)
def getGST(year, month, day, hour, minute, secunde):
"""
Function calculates the GST0 in degrees for a current year. This is a constans
needed for eci2ecef function.
"""
stream = open("inputs.yaml", 'r')
inputs = yaml.load(stream)
longitude = float(inputs.get('input lon'))
julian_date = ephem.julian_date(
str(year) + '/' + str(month) + '/' + str(day))
julian_centuries = (julian_date - 2451545) / 36525
GST0 = 100.4606184 + (36000.77005361 * julian_centuries) + \
(0.00038793 * julian_centuries**2) - (2.583*10**-8 * julian_centuries**3)
GST0 = GST0 % 360
#print "Julian date: ", julian_date
#print "GMST0: ", GST0
#Greenwich sidereal time
GST = GST0 + 0.25068447733746215 * (hour * 60 + minute + secunde / 60)
GST = GST % 360
#print "GST: ", GST
#Local sidereal time
LST = GST + longitude
LST = LST % 360
#print "LST: ", LST
return GST
def test_JulianDate_reduce_datetime(date, expected):
d = datetime.datetime(*date)
jd = JulianDate.from_datetime(d, reduced=True)
assert jd.reduced
assert np.allclose(jd.jd, expected)
assert np.allclose(jd.jd, ephem.julian_date(d) - 2400000)
def calc_GMST(self, date):
"""Compute Greenwich Mean Sidereal Time"""
jd = ephem.julian_date(date)
T = (jd - 2451545.0)/36525.0
gmstdeg = 280.46061837+(360.98564736629*(jd-2451545.0))+(0.000387933*T*T)-(T*T*T/38710000.0)
gmst = ephem.degrees(gmstdeg*numpy.pi/180.0)
return gmst
def epochString(self):
if self.epoch == Epoch.J2000:
return "J2000.0"
elif self.epoch == Epoch.B1950:
return "B1950.0"
else:
return "J%.2f" % (2000.0 + (ephem.julian_date() - 2451545.0) / 365.25)
def import_lastrun_data(opt):
mjd_yesterday = ephem.date(ephem.julian_date(ephem.date(
opt.date))) - 2400000.5
data_to_date = query_for_observations(mjd_yesterday, opt.cal, OSSOS_RUNIDS)
for row in data_to_date:
storage.populate(row['dataset_name'])
def calculate_airmass(textlist_files):
"""
Calculates AIRMASS for the list of all FITS files and appends respective details in the headers.
Args:
textlist_files : List of all FITS files whose headers have to be edited
Returns:
None
"""
list_files = text_list_to_python_list(textlist_files)
for file_name in list_files:
hdulist = fits.open(file_name, mode='update')
file_header = hdulist[0].header
date_obs = file_header[DATE_keyword]
if RA_keyword in file_header.keys():
object_ra = file_header[RA_keyword]
else:
object_ra = OBJECT_RA
if DEC_keyword in file_header.keys():
object_dec = file_header[DEC_keyword]
else:
object_dec = OBJECT_DEC
datetime_utc = date_obs + '00:00:00'
jd = ephem.julian_date(datetime_utc)
telescope = ephem.Observer()
telescope.lon = OBS_LONG
telescope.lat = OBS_LAT
telescope.elevation = OBS_ALT
telescope.pressure = 0
telescope.epoch = ephem.J2000
telescope.date = datetime_utc
obj_pos = ephem.FixedBody()
obj_pos._ra = object_ra
obj_pos._dec = object_dec
obj_pos._epoch = ephem.J2000
obj_pos.compute(telescope)
time_sidereal = telescope.sidereal_time()
object_alt = Angle(str(obj_pos.alt) + ' degrees').degree
airmass = 1 / math.cos(math.radians(90 - object_alt))
list_keywords = ['OBSERVAT', 'OBS_LAT', 'OBS_LONG', 'OBS_ALT', 'TIMEZONE', 'DATE_OBS', 'JD', 'ST', 'RA',
'DEC', 'ALT', 'AZ', 'AIRMASS']
dict_header = {'OBSERVAT': OBS_NAME, 'OBS_LAT': OBS_LAT, 'OBS_LONG': OBS_LONG, 'OBS_ALT': OBS_ALT,
'TIMEZONE': OBS_TIMEZONE, 'DATE_OBS': date_obs, 'JD': jd, 'ST': time_sidereal,
'RA': object_ra, 'DEC': object_dec, 'ALT': obj_pos.alt, 'AZ': obj_pos.az, 'AIRMASS': airmass}
for keyword in list_keywords:
if keyword in file_header.keys():
file_header.remove(keyword, remove_all=True)
file_header.append(card=(keyword, dict_header[keyword]))
hdulist.flush()
hdulist.close()
def gen_test_dates(obs):
"""Generate test dates"""
greenwich = ephem.Observer()
greenwich.lat = '51:28:38'
str_dates = [
'1978/11/13 04:34:00',
'1984/05/30 02:20:00',
'2000/01/01 00:00:00',
'2003/05/06 08:03:01',
'2004/02/29 12:59:11',
'2014/12/31 16:10:22',
'2017/12/11 22:02:33',
'2050/05/11 20:01:44',
]
dates = []
for str_date in str_dates:
greenwich.date = str_date
obs.date = str_date
date = {
'str': str_date,
'jd': ephem.julian_date(str_date),
'gmst': greenwich.sidereal_time(),
'lst': obs.sidereal_time(),
}
dates.append(date)
return dates
def __init__(self, julianOffset=None):
'''
Initialise class
options:
julianOffset: set to report Julian day with an offset subtracted
Format, 'YYYY/M/D' e.g. '2012/1/1'
'''
# use the python library ephem
try:
import ephem
except:
import pyephem as ephem
self.gatech = ephem.Observer()
if julianOffset != None:
self.julianOffset = ephem.julian_date(julianOffset)
else:
self.julianOffset = 0.
# http://acrim.com/TSI%20Monitoring.htm
self.solar = 1361 #W/m2
# PPFD is measured in micromoles/m2/sec
# (Photosynthetic Photon Flux Density)
# astronomical unit
# http://neo.jpl.nasa.gov/glossary/au.html
# we dont need this, but its interesting to know
self.AU = 149597870.691 * 1e3 # m
# energy content of PAR quanta
self.EPAR = 220.e-3 # MJmol-1
def run(self):
self.transit_dict = {}
for src in self.srclist:
self.transit_dict.update({src: []})
for index, filein in enumerate(self.files):
with h5.File(filein, 'r') as data:
self.obser.date = ephem.Date(
data.attrs['obstime']) - 8 * ephem.hour
tstart = data.attrs['sec1970'] # + 8*3600.
# print('=========================================')
# print('observer time: %s'%data.attrs['obstime'])
# print('start time: %s'%datetime.utcfromtimestamp(tstart))
tend = tstart + (data['vis'].shape[0] -
1) * data.attrs['inttime']
# print('end time: %s'%datetime.utcfromtimestamp(tend))
tend = ephem.julian_date(datetime.utcfromtimestamp(tend))
# tephem = aipy.phs.juldate2ephem(tend)
# print(ephem.Date(tephem))
for src, fb in self.srcdict.items():
next_tran = self.obser.next_transit(fb)
if index == 1:
print(src + ':', ephem.Date(next_tran))
next_tran = aipy.phs.ephem2juldate(next_tran)
if next_tran < tend:
self.transit_dict[src].append((index, filein))
def obs_params(longitude_deg, latitude_deg, mid_azimuth_deg, mid_elevation_deg,
mid_date_string, obs_length_sec):
"""Evaluate the observation parameters (RA, Dec, MJD start) for the
requested azimuth, elevation and time.
Args:
longitude_deg (float): Telescope longitude, in degrees.
latitude_deg (float): Telescope latitude, in degrees.
mid_azimuth_deg (float): Azimuth at mid-point, in degrees.
mid_elevation_deg (float): Elevation at mid-point, in degrees.
mid_date_string (str): Date and time of mid-point, as a string.
obs_length_sec (float): Target observation length, in seconds.
Returns:
Tuple containing RA, Dec and MJD start for the given parameters.
"""
obs = ephem.Observer()
obs.lon, obs.lat, obs.elevation = \
math.radians(longitude_deg), math.radians(latitude_deg), 0.0
obs.date = mid_date_string
ra, dec = obs.radec_of(math.radians(mid_azimuth_deg),
math.radians(mid_elevation_deg))
ra, dec = math.degrees(ra), math.degrees(dec)
mjd_mid = ephem.julian_date(obs.date) - 2400000.5
mjd_start = mjd_mid - obs_length_sec / (2 * 86400.0)
return ra, dec, mjd_start
def calculate_airmass(file_name):
"""
Calculates AIRMASS for the FITS file and appends respective details in the header of the file 'file_name'
Args:
file_name : FITS file whose header has to be edited
Returns:
None
"""
for file_name in list_files:
hdulist = fits.open(file_name, mode='update')
file_header = hdulist[0].header
if str(RA_keyword) in file_header.keys():
object_ra = file_header[str(RA_keyword)]
else:
object_ra = OBJECT_RA
if str(DEC_keyword) in file_header.keys():
object_dec = file_header[str(DEC_keyword)]
else:
object_dec = OBJECT_DEC
date_avg = file_header[str(DATEAVG_keyword)]
date_obs, time_utc = date_avg.split('T')
datetime_utc = str(date_obs) + ' ' + str(time_utc)
julian_day = ephem.julian_date(datetime_utc)
telescope = ephem.Observer()
telescope.lon = OBS_LONG
telescope.lat = OBS_LAT
telescope.elevation = OBS_ALT
telescope.pressure = 0
telescope.epoch = ephem.J2000
telescope.date = datetime_utc
time_sidereal = telescope.sidereal_time()
object_pos = ephem.FixedBody()
object_pos._ra = object_ra
object_pos._dec = object_dec
object_pos._epoch = ephem.J2000
object_pos.compute(telescope)
object_alt = Angle(str(object_pos.alt) + ' degrees').degree
airmass = 1 / math.cos(math.radians(90 - object_alt))
list_keywords = ['LAT', 'LONG', 'ALT', 'TIMEZONE', RA_keyword, DEC_keyword, UT_keyword,
DATE_keyword, 'JD', 'ST', 'ELE', 'AZ', 'AIRMASS']
dict_header = {'LAT': str(OBS_LAT), 'LONG': str(OBS_LONG), 'ALT': str(OBS_ALT), 'TIMEZONE': str(OBS_TIMEZONE),
RA_keyword: str(object_ra), DEC_keyword: str(object_dec), DATE_keyword: str(date_obs),
UT_keyword: str(time_utc), 'JD': str(julian_day), 'ST': str(time_sidereal),
'ELE': str(object_pos.alt), 'AZ': str(object_pos.az), 'AIRMASS': str(airmass)}
for keyword in list_keywords:
if keyword in file_header.keys():
file_header.remove(keyword, remove_all=True)
file_header.append(card=(keyword, dict_header[keyword]))
hdulist.flush()
hdulist.close()
def gmst(self):
if self._gmst is None:
jd = ephem.julian_date(self.ut)
T = (jd - 2451545.0) / 36525.0
gmstdeg = 280.46061837 + (360.98564736629 * (jd - 2451545.0)) + (
0.000387933 * T * T) - (T * T * T / 38710000.0)
self._gmst = ephem.degrees(gmstdeg * numpy.pi / 180.0)
return self._gmst
def dzs_search(year): # 寻找年前冬至月朔日
if year == 1: year -= 1 # 公元0改为公元前1
dz = ephem.next_solstice((year - 1, 12)) # 年前冬至
jd = ephem.julian_date(dz)
# 可能的三种朔日
date1 = ephem.next_new_moon(ephem.Date(jd - 2415020 - 0))
jd1 = ephem.julian_date(date1)
date2 = ephem.next_new_moon(ephem.Date(jd - 2415020 - 29))
jd2 = ephem.julian_date(date2)
date3 = ephem.next_new_moon(ephem.Date(jd - 2415020 - 31))
jd3 = ephem.julian_date(date3)
if DateCompare(jd, jd1): # 冬至合朔在同一日或下月
return date1
elif DateCompare(jd, jd2) and (not DateCompare(jd, jd1)):
return date2
elif DateCompare(jd, jd3): # 冬至在上月
return date3
def test_jd_conversions(jd):
"""Test JulianDate.to_datetime and JulianDate.from_datetime are reversible."""
assert np.allclose(jd,
JulianDate(jd).jd)
assert np.allclose(JulianDate(jd).jd,
JulianDate.from_datetime(JulianDate(jd).to_datetime()).jd)
assert np.allclose(ephem.julian_date(JulianDate(jd).to_datetime()),
JulianDate.from_datetime(JulianDate(jd).to_datetime()).jd)
def findDZS(year): # 寻找年前冬至月朔日
if year == 1: year -= 1 # 公元元年前冬至在公元前1年
dz = ephem.next_solstice((year - 1, 12)) # 年前冬至
jd = ephem.julian_date(dz)
# 可能的三种朔日
date1 = ephem.next_new_moon(JD2date(jd - 0))
jd1 = ephem.julian_date(date1)
date2 = ephem.next_new_moon(JD2date(jd - 29))
jd2 = ephem.julian_date(date2)
date3 = ephem.next_new_moon(JD2date(jd - 31))
jd3 = ephem.julian_date(date3)
if DateCompare(jd, jd1): # 冬至合朔在同一日或下月
return date1
elif DateCompare(jd, jd2) and (not DateCompare(jd, jd1)):
return date2
elif DateCompare(jd, jd3): # 冬至在上月
return date3
def jd2pyephemdate( jd ):
"""
Converts a Julian date to a pyephem date object by first
subtracting the difference between the pyephem zero date
and the JD zero date.
"""
pyephem_zero = ephem.julian_date( ephem.Date( 0 ) )
return ephem.Date( jd - pyephem_zero )
def GMST(self, date):
"""Compute Greenwich Mean Sidereal Time"""
jd = E.julian_date(date)
T = (jd - 2451545.0) / 36525.0
gmstdeg = 280.46061837 + (360.98564736629 * (jd - 2451545.0)) + (
0.000387933 * T * T) - (T * T * T / 38710000.0)
gmst = E.degrees(gmstdeg * N.pi / 180.0)
return gmst
def cp_obs_time_skybright(self, x, ob, t1, t2, k='+'):
"""compute visibility time (from skybrightness req. S)
ob = coordinates line in ephem format
x = {toi} data
t1,t2 = start/end time to compute
k = '+' to set values of V,NV,WV periods in {toi}"""
self.SkyV_period = []
sky = x['skybright'].split(',')
obj = ep.readdb(ob)
obsv = []
period = []
i = 0
skybright = 0
td = datetime.timedelta(seconds=self.time_acc)
#t1 = t1 - td
while t1 <= t2:
self.oadm.date = t1
obj.compute(self.oadm)
moon = ep.Moon(self.oadm)
if moon.phase < float(sky[1]):
skybright = 1
elif float(sky[2]) <= moon.alt * 180 / ep.pi <= float(sky[3]):
skybright = 1
else:
skybright = 0
obsv.append([skybright, t1])
t1 += td
period.append([0, obsv[0]])
period.append([obsv.index(obsv[-1]), obsv[-1]])
for i in range(len(obsv) - 1):
if obsv[i][0] != obsv[i + 1][0]:
period.append([obsv.index(obsv[i]), obsv[i]])
sort_period = sorted(period)
for i in range(len(sort_period) - 1):
kk = [
sort_period[i + 1][1][0], x['id'],
ep.julian_date(sort_period[i][1][1]),
ep.julian_date(sort_period[i + 1][1][1])
]
if kk[0] != 0:
self.SkyV_period.append(kk)
self.oadm.date = self.comp_date
if k == '+':
x['SkyV_period'] = self.SkyV_period
return self.SkyV_period
def __init__(self, date, site):
self.Date = date
self.Site = site
''' Predictable data '''
# 3 by n_fields matrix of ID, RA, Dec
self.all_fields = np.loadtxt("NightDataInLIS/Constants/fieldID.lis",
dtype="i4, f8, f8",
unpack=True)
self.time_slots = np.loadtxt("NightDataInLIS/TimeSlots{}.lis".format(
int(ephem.julian_date(self.Date))),
unpack=True)
self.altitudes = np.loadtxt("NightDataInLIS/Altitudes{}.lis".format(
int(ephem.julian_date(self.Date))),
unpack=True)
self.hour_angs = np.loadtxt("NightDataInLIS/HourAngs{}.lis".format(
int(ephem.julian_date(self.Date))),
unpack=True)
#self.Moon_seps = np.loadtxt("MoonSeps{}.lis".format(int(ephem.julian_date(self.Date))), unpack = True)
self.amass_cstr = np.loadtxt(
"NightDataInLIS/AirmassConstraints{}.lis".format(
int(ephem.julian_date(self.Date))),
unpack=True)
self.all_n_tot_visits = np.loadtxt(
"NightDataInLIS/tot_N_visit{}.lis".format(
int(ephem.julian_date(self.Date))),
dtype="i4",
unpack=True)
self.t_last_v_last = np.loadtxt(
"NightDataInLIS/t_last_visit{}.lis".format(
int(ephem.julian_date(self.Date))),
unpack=True)
self.coad_depth = self.all_n_tot_visits / (
np.max(self.all_n_tot_visits) + 1
) #!!!!! temporarily!!!!!!!! # TODO Add coadded depth module instead of visit count
self.vis_of_year = np.zeros(
len(self.all_fields[0])
) #!!!!! temporarily!!!!!!!! # TODO Visibility of the year is currently all zero
self.sci_prog = np.zeros(
len(self.all_fields[0]), dtype='int'
) #!!!!! temporarily!!!!!!!! # TODO Science program is not considered yet
self.moon_sep = np.loadtxt("NightDataInLIS/MoonSeps{}.lis".format(
int(ephem.julian_date(self.Date))),
unpack=True)
# n_fields by n_fields symmetric matrix, slew time from field i to j
self.slew_t = np.loadtxt("NightDataInLIS/Constants/slewMatrix.dat",
unpack=True) * ephem.second
self.n_all_fields = len(self.all_fields[0])
self.n_time_slots = len(self.time_slots)
self.t_start = self.time_slots[0]
self.t_end = self.time_slots[self.n_time_slots - 1]
self.n_start = find_n(self.t_start, self.t_start, self.t_end,
self.n_time_slots, self.time_slots)
''' Unpredictable data '''
self.sky_brightness = np.zeros(
len(self.all_fields[0]), dtype='int'
) #!!!!! temporarily!!!!!!!! # current sky brightness
self.temp_coverage = np.zeros(
len(self.all_fields[0]), dtype='int'
) #!!!!! temporarily!!!!!!!! # temporary 0/1 coverage of the sky including clouds
def julian_date(date=None):
"""
This function converts seconds since the epoch to a julian date.
Input:
- ``date``: Date in seconds since the Epoch (Jan 1, 1970 UTC).
"""
return _ephem.julian_date(ephem_time(date))
def julian_date(date=None):
"""
This function converts seconds since the epoch to a julian date.
Input:
- ``date``: Date in seconds since the Epoch (Jan 1, 1970 UTC).
"""
return _ephem.julian_date(ephem_time(date))
def jd2lst(jd):
"""
Calculates local sideral time in radians from right ascension and julian date
jd : julian date
"""
j0 = ephem.julian_date(0)
hera.date = jd - j0
lst = hera.sidereal_time()
return lst
def update_googledex_lastobs(filename, sheetns=["2018B"],ctime=None,certificate='UCSC Dynamic Scheduler-5b98d1283a95.json'):
"""
Update the online googledex lastobs column assuming things in filename have been observed.
update_googledex_lastobs(filename, sheetn="The Googledex",time=None,certificate='UCSC Dynamic Scheduler-5b98d1283a95.json')
filename - where the observations are logged
"""
names, times = ObservedLog.getObserved(filename)
if len(names) == 0:
return
if ctime is None:
ctime = datetime.utcfromtimestamp(int(time.time()))
for sheetn in sheetns:
ws = get_spreadsheet(sheetn=sheetn,certificate=certificate)
if ws:
vals = ws.get_all_values()
else:
next
col = vals[0].index("lastobs")
nobscol = vals[0].index("Nobs")
for i, v in enumerate(vals):
# Did we observe this target tonight?
if v[0] in names:
# We observed this target, so update the cell in the worksheet
# update_cell(row, col, val) - col and row are 1 indexed
otime = times[names.index(v[0])]
if isinstance(otime,float):
t = datetime.utcfromtimestamp(otime)
else:
hr, mn = otime
t = datetime(ctime.year, ctime.month, ctime.day, hr, mn)
jd = float(ephem.julian_date(t))
try:
pastdate = float(v[col])
try:
n = int(v[nobscol])
except:
n = 0
if jd > pastdate:
ws.update_cell(i+1, col+1, round(jd, 2) )
ws.update_cell(i+1, nobscol+1, n + 1 )
except:
print (v[0], v[col])
ws.update_cell(i+1, col+1, round(jd,2) )
apflog( "Updated %s" % (sheetn),echo=True)
return
def do_objs(kbos):
"""Draw the actual plot"""
import orbfit, ephem, math
import re
re_string=w.FilterVar.get()
vlist=[]
for name in kbos:
if not re.search(re_string,name):
continue
vlist.append(name)
if type(kbos[name])==type(ephem.EllipticalBody()):
kbos[name].compute(w.date.get())
ra=kbos[name].ra
dec=kbos[name].dec
a=math.radians(10.0/3600.0)
b=a
ang=0.0
color='blue'
yoffset=+10
xoffset=+10
else:
yoffset=-10
xoffset=-10
file=kbos[name]
jdate=ephem.julian_date(w.date.get())
obs=568
try:
position=orbfit.predict(file,jdate,obs)
except:
continue
ra=math.radians(position[0])
dec=math.radians(position[1])
a=math.radians(position[2]/3600.0)
b=math.radians(position[3]/3600.0)
ang=math.radians(position[4])
if ( a> math.radians(1.0) ):
color='green'
else:
color='black'
if w.show_ellipse.get()==1 :
if ( a < math.radians(5.0) ):
w.create_ellipse(ra,dec,a,b,ang)
if ( a < math.radians(1.0) ):
w.create_point(ra,dec,size=2,color=color)
if w.show_labels.get()==1:
w.label(ra,dec,name,offset=[xoffset,yoffset])
vlist.sort()
for v in vlist:
w.objList.insert(END,v)
w.plot_pointings()
def __getitem__(self, name):
if name not in self.satellites:
q = callhorizons.query(name, smallbody=False)
q.set_discreteepochs(ephem.julian_date(self.epoch))
try:
sats = q.export2pyephem()
except ValueError as e:
if e.message.startswith('Unknown target'):
raise KeyError('%s not found in %s' % (name, repr(self)))
raise
self.satellites[name] = sats[0]
return self.satellites[name]
def getLST(date, longitude):
"""Take a datetime and longitude and calculate the Local Sidereal Time."""
# Assumes date is a datetime object, and that the longitude is formatted as in PyEphem
ll = [float(v) for v in longitude.split(':')]
if ll[0] > 0:
sign = 1
else:
sign = -1
ut = date.hour + date.minute/60. + date.second/3600.
lng = ll[0] + sign*ll[1]/60. + sign*ll[2]/3600.
d = ephem.julian_date() - 2451545.0
lst = 100.46 + 0.985647 * d + lng + 15*ut
return lst % 360.
def relocate(self):
"""Move to the postion of self.SearchVar"""
name=self.SearchVar.get()
if kbos.has_key(name):
import orbfit,ephem,math
jdate=ephem.julian_date(w.date.get())
try:
(ra,dec,a,b,ang)=orbfit.predict(kbos[name],jdate,568)
except:
return
ra=math.radians(ra)
dec=math.radians(dec)
elif mpc_objs.has_key(name):
ra=mpc_objs[name].ra
dec=mpc_objs[name].dec
self.recenter(ra,dec)
self.create_point(ra,dec,color='blue',size=4)
def readin_lastobs(filename,ctime):
codex = False
try:
fp = open(filename,'rb')
full_codex = pickle.load(fp)
fp.close()
codex = True
colhead = full_codex[0]
codex = full_codex[1:]
# These are the columns we need for scheduling
req_cols = ["Star Name", "lastobs", "Template", "Nobs"]
didx = findColumns(colhead,req_cols)
except :
codex = False
names, times = ObservedLog.getObserved(filename)
if len(names) == 0:
return
if ctime is None:
ctime = datetime.utcfromtimestamp(int(time.time()))
lastjds = []
fnames = []
nobs = []
if codex:
for cline in codex:
lastjds.append(float(cline[didx['lastobs']]))
fnames.append(cline[didx['Star Name']])
nobs.append(int(cline[didx['Nobs']]))
else:
for i in range(0,len(names)):
fnames.append(names[i])
otime = times[i]
if isinstance(otime,float):
t = datetime.utcfromtimestamp(otime)
else:
hr, mn = otime
t = datetime(ctime.year, ctime.month, ctime.day, hr, mn)
lastjds.append(float(ephem.julian_date(t)))
return fnames, lastjds
def gen_time_axis(timestamps,scale,offset):
""" Return a list of real times from the timestamp vector"""
# get the timestamps
timestamps = numpy.array(timestamps, dtype=float)
t = numpy.zeros(len(timestamps),dtype=numpy.float64)
t = numpy.array(offset + timestamps/scale,dtype=numpy.float64) #UNIX times
t_range = t[-1] - t[0]
gmt_ref = time.gmtime(t[0]) # Start time in UTC
jd_ref = ephem.julian_date(gmt_ref[0:6])
if t_range < 300:
scale = 'Seconds since %.4d/%.2d/%.2d %.2d:%.2d:%.2d UTC' %(gmt_ref[0:6])
t = (t-t[0])
elif t_range < 60*60*3:
scale = 'Minutes since %.2d/%.2d/%.2d %.2d:%.2d:%.2d UTC' %(gmt_ref[0:6])
t = (t-t[0])/60
else:
scale = 'Hours since %.2d/%.2d/%.2d %.2d:%.2d:%.2d UTC' %(gmt_ref[0:6])
t = (t-t[0])/60/60
return {'times':t, 'scale':scale, 'ref':t[0], 'gmtref':gmt_ref, 'jd_ref':jd_ref, 'unit':''}
def opposition(coordinate):
ec = ephem.Ecliptic(0, 0)
ra = ephem.hours(coordinate.ra.radians)
dec = ephem.degrees(coordinate.dec.radians)
ec.from_radec(ra, dec)
opp_angle = math.pi
opp_date = -1
start_date = ephem.date('2013/01/01')
sun = ephem.Sun()
for day in range(365):
d = ephem.date(start_date + day)
sun.compute(d)
opp = math.fabs(ephem.degrees(ec.lon - sun.hlon))
if opp < opp_angle:
opp_angle = opp
opp_date = ephem.date(start_date + day)
sun.compute(opp_date)
print sun.ra, coordinate.ra, opp_date
return ephem.julian_date(opp_date)
def get_juldate(local_time, tzone='UTC+08h'):
"""Convert `local_time` to Julian date.
Parameters
----------
local_time : string, python date or datetime object, etc.
Local time that can be passed to ephem.Date function.
Refer to http://rhodesmill.org/pyephem/date.html
tzone : string, optional
Time zone in format 'UTC[+/-]xxh'. Defaut: UTC+08h.
Returns
-------
julian_date : float
A float number representation of a Julian date.
See Also
--------
`get_ephdate`
"""
return ephem.julian_date(get_ephdate(local_time, tzone))
def cur_sidereal(longitude,val):
global doephem
if doephem == False:
return (("12:00:00","9999999999"))
longstr = "%02d" % int(longitude)
longstr = longstr + ":"
longitude = abs(longitude)
frac = longitude - int(longitude)
frac *= 60
mins = int(frac)
longstr += "%02d" % mins
longstr += ":00"
x = ephem.Observer()
x.date = ephem.now()
x.long = longstr
jdate = ephem.julian_date(x)
tokens=str(x.sidereal_time()).split(":")
hours=int(tokens[0])
minutes=int(tokens[1])
seconds=int(float(tokens[2]))
sidt = "%02d:%02d:%02d" % (hours, minutes, seconds)
return ((sidt,jdate))
def updateHeaderTime(infile,outfile):
'''
outputs a file containing the corrected times based on the start time
of the observation and not the time the file was written
v1.0 Kieran O'Brien - Aug 2011
'''
inh5file=openFile(infile,mode='r')
inh5file.copyFile(outfile,overwrite=True)
inh5file.close()
outh5file=openFile(outfile,mode='a')
# try:
timestamp=int(outh5file.root.r0.p0._v_children.keys()[0].strip('t'))
dt=datetime.datetime.utcfromtimestamp(timestamp)
jd=np.float64(ephem.julian_date(dt))
table=outh5file.root.header.header
table.cols.jd[0]=jd
table.cols.ut[0]=timestamp
table.flush()
# outfile.copyNode(infile.root.header,newparent=outfile.root,recursive=True)
# except:
# print 'no header'
# pass
outh5file.close()
def gen_ha_axis(timestamps,scale,offset,RA):
""" Return a list of real times from the timestamp vector"""
# get the timestamps
timestamps = numpy.array(timestamps, dtype=float)
t = numpy.zeros(len(timestamps),dtype=numpy.float64)
t = numpy.array(offset + timestamps/scale,dtype=numpy.float64) #UNIX times
gmt_ref = time.gmtime(t[0]) # Start time in UTC
jd_ref = ephem.julian_date(gmt_ref[0:6])
ha = numpy.zeros_like(t)
for i,ti in enumerate(t):
obs.date = ephem.Date(time.gmtime(ti)[0:6])
#print "time is", obs.date
ha[i] = obs.sidereal_time() - RA
#print obs.sidereal_time(), RA, obs.sidereal_time()-RA
# Unwrap the phases, otherwise weird things can happen
# When the lst crosses midnight
ha = numpy.unwrap(ha)
ha = numpy.rad2deg(ha)
if RA == 0:
scale = 'Local Sidereal Time'
else:
scale = 'Hour Angle'
return {'times':ha, 'scale':scale, 'ref':RA, 'gmtref':gmt_ref, 'jd_ref':jd_ref, 'unit':''}
def main(): obsfile_name = "/nfs/eor-00/h1/rbyrne/sidelobe_survey_obsIDs.txt" obsfile = open(obsfile_name, "r") obsids = [line.split( ) for line in obsfile.readlines()] obsids = [obs[0] for obs in obsids] obsfile.close() #t = Time([int(obsid) for obsid in obsids], format="gps", scale="utc") t = Time([1130772904], format = "gps", scale = "utc") jdates = t.jd jdate = jdates[0] az = np.radians(198.435) el = np.radians(67.98) #approximate values, fix these: lon = np.radians(116.6) lat = np.radians(-26.75) alt = 378 jdate0 = ephem.julian_date(0) observer = ephem.Observer() observer.lon = lon observer.lat = lat observer.elevation = alt observer.date = jdate - jdate0 lst = observer.sidereal_time() lst_hrs = float(lst)*23.9344699/(2*math.pi) print lst_hrs print lst ra,dec = observer.radec_of(az, el) print "EPHEM: %f %f" % (np.degrees(ra),np.degrees(dec))
def synthetic_model_kbos(coverage, input_date=newMoons['Oct13']):
## build a list of KBOs that will be in the discovery fields.
ra=[]
dec=[]
kbos = []
for line in open('L7SyntheticModel-v09.txt'):
if line[0]=='#':
continue
kbo = ephem.EllipticalBody()
values = line.split()
kbo._a = float(values[0])
kbo._e = float(values[1])
kbo._inc = float(values[2])
kbo._Om = float(values[3])
kbo._om = float(values[4])
kbo._M = float(values[5])
kbo._H = float(values[6])
kbo._epoch_M = ephem.date(2453157.50000 - ephem.julian_date(0))
kbo._epoch = kbo._epoch_M
kbo.name = values[8]
date = ephem.date(input_date)
kbo.compute(date)
### only keep objects that are brighter than limit
if kbo.mag > 25.0:
continue
ra.append(math.degrees(float(kbo.ra)))
dec.append(math.degrees(float(kbo.dec)))
## keep a list of KBOs that are in the discovery pointings
for field in coverage:
if field.isInside(ra[-1],dec[-1]):
kbos.append(kbo)
break
return ra, dec, kbos
def compute_simulation(curtime,result,star,apf_obs,slowdowns,fwhms,star_tab,owner):
actel,actaz = ns.compute_el(curtime,star,apf_obs)
actslow, actfwhm = ns.rand_obs_sample(slowdowns,fwhms)
if actslow < 0.3:
actslow = 0.3
actfwhm = ns.gen_seeing_el(actfwhm,actel)
lastfwhm = actfwhm
lastslow = actslow
metersig = np.random.randn(1)
specsig = np.random.randn(1)
if abs(specsig) > 3:
specsig = 3.
if abs(metersig) > 3:
metersig = 3.
meterrate = ec.getEXPMeter_Rate(result['VMAG'],result['BV'],actel,actfwhm,result['DECKER'])
meterrate *= 1 + 0.11*metersig
meterrate /= actslow
specrate = ec.getSpec_Rate(result['VMAG'],result['BV'],actel,actfwhm,result['DECKER'])
specrate *= 1 + 0.11*specsig
specrate /= actslow
metertime = result['COUNTS'] / meterrate
exp_time = result['EXP_TIME']
barycentertime = curtime
if metertime < exp_time:
fexptime = metertime
else:
fexptime = exp_time
curtime += (fexptime+40.)/86400
barycentertime += fexptime/(2.*86400)
totcounts = fexptime * specrate
outstr = "%s %s %.5f %.1f %.1f %.2f %.2f %.2f %.2f %s" %(result['NAME'] , ephem.Date(curtime), ephem.julian_date(ephem.Date(barycentertime)), fexptime, totcounts, actel,actaz, actfwhm, actslow, owner)
return curtime, lastfwhm, lastslow, outstr
# # line1 contains commented fermi data
# # line2 is an xephem database entry
if re.match("#",line1) == None: continue
error = float(re.search('(\d+.\d\d)\n$',line1).group(1))
# if the error is greater than 10 degrees, throw away
if error > 10: continue
noqsi.date = re.search(r"..../../.. ..:..:......",line1).group()
# if the date is before 2010/4/1, quit
# since we don't have measurements as early as that
if noqsi.date < ephem.date('2010/4/1'):
exit()
line2 = sys.stdin.readline()
entry = ephem.readdb(line2)
entry.name = re.search(r"^..(\w+)",line1).group(1)
entry.compute(noqsi)
entry_alt_degrees = entry.alt/pi*180
sun = ephem.Sun()
sun.compute(noqsi)
sun_alt_degrees = sun.alt/pi*180
if 0 < entry.alt: # if the entry is above the horizon, print
print "%s\t%s\t%f\t%d\t%f\t%f\t%f" % \
(entry.name, noqsi.date, ephem.julian_date(noqsi),\
ephem2unix(noqsi.date), sun_alt_degrees, entry_alt_degrees, error)
def config_uv_data(h5fh, tbl_uv_data, antpos, obs, src, ti, verbose=False):
if verbose:
print('\nGenerating file metadata')
print('--------------------------')
# Data is stored in multidimensional array called xeng_raw0
# time, channels, baselines, polarisation, then data=(real, imaginary)
(t_len, chan_len, bl_len, pol_len, ri_len) = h5fh['xeng_raw0'].shape
int_time = h5fh.attrs['int_time']
h5data = h5fh['xeng_raw0'][ti]
timestamps = []
baselines = []
#weights = [1 in range(0,chan_len*2)]
if verbose: print('Retrieving timestamps...')
timestamps = h5fh['timestamp0'][ti]
# Date and time
# Date is julian date at midnight that day
# The time is DAYS since midnight
firststamp = timestamps[0]
julian = ephem.julian_date(time.gmtime(firststamp)[:6])
midnight = int(firststamp)
# Ephem returns julian date at NOON, we need at MIDNIGHT
julian_midnight = int(julian)+1
elapsed = []
for timestamp in timestamps:
elapsed.append((ephem.julian_date(time.gmtime(timestamp)[:6]) - julian_midnight))
if verbose: print('Creating baseline IDs...')
bl_order = h5fh['bl_order'].value
#WARNING: hardcore the antenna position frequency (GHz)
cfreq=.408
for bl in range(0,bl_len):
# Baseline is in stupid 256*baseline1 + baseline2 format
ant1, ant2 = bl_order[bl][0], bl_order[bl][1]
bl_id = 256*ant1 + ant2
# Generate the XYZ vectors too
# From CASA measurement set definition
# uvw coordinates for the baseline from ANTENNE2 to ANTENNA1,
# i.e. the baseline is equal to the difference POSITION2 - POSITION1.
bl_vector = (antpos[ant2] - antpos[ant1])*cfreq
#print bl_vector, antpos[ant2], antpos[ant1]
baselines.append((bl_id,bl_vector))
if verbose: print('Computing UVW coordinates...\n')
# Extract the timestamps and use these to make source our phase centre
uvws = []
for timestamp in timestamps:
t = datetime.datetime.utcfromtimestamp(timestamp)
if verbose: print t
obs.date=t
src.compute(obs)
for baseline in baselines:
vector = baseline[1]
H, d = (obs.sidereal_time() - src._ra, src._dec)
uvws.append(computeUVW(vector,H,d))
# This array has shape t_len, num_ants, 3
# and units of SECONDS
uvws = np.array(uvws)
uvws = uvws.reshape(uvws.size/bl_len/3,bl_len,3) / ephem.c
if verbose:
print('\nReformatting HDF5 format -> FITS IDI UV_DATA')
print('--------------------------------------------')
# The actual data matrix is stored per row as a multidimensional matrix
# with the following mandatory axes:
# COMPLEX Real, imaginary, (weight)
# STOKES Stokes parameter
# FREQ Frequency (spectral channel)
# RA Right ascension of the phase center
# DEC Declination of the phase center
flux = np.ndarray(shape=(chan_len,1,ri_len))
# This step takes ages.
# I imagine there is some way to massage the hdf5 array
# to do this a lot quicker than iterating over the indexes
if verbose: print('\nCreating multidimensional UV matrix...')
for t in range(0,len(ti)):
if verbose: print('processing time sample set %i/%i'%(t+1,len(ti)))
# The time is seconds since midnight
tbl_uv_data.data['TIME'][t*bl_len:(t+1)*bl_len] = np.ones(bl_len)*elapsed[t]
tbl_uv_data.data['DATE'][t*bl_len:(t+1)*bl_len] = julian_midnight
tbl_uv_data.data['INTTIM'][t*bl_len:(t+1)*bl_len] = np.ones(bl_len)*int_time
#tbl_uv_data.data['SOURCE'][t*bl_len:(t+1)*bl_len]= np.ones(bl_len,dtype=np.int32)*1
tbl_uv_data.data['SOURCE_ID'][t*bl_len:(t+1)*bl_len]= np.ones(bl_len,dtype=np.int32)*1
tbl_uv_data.data['FREQID'][t*bl_len:(t+1)*bl_len] = np.ones(bl_len,dtype=np.int32)*1
tbl_uv_data.data['UU'][t*bl_len:(t+1)*bl_len] = uvws[t,:,0]
tbl_uv_data.data['VV'][t*bl_len:(t+1)*bl_len] = uvws[t,:,1]
tbl_uv_data.data['WW'][t*bl_len:(t+1)*bl_len] = uvws[t,:,2]
for bl in range(0,bl_len):
# Create a 1D index for the uv_data table
i = t*bl_len + bl
# Swap real and imaginary
flux[:,0,0] = h5data[t,:,bl,0,1]
flux[:,0,1] = h5data[t,:,bl,0,0]
tbl_uv_data.data[i]['FLUX'] = flux.ravel()
tbl_uv_data.data[i]['BASELINE'] = baselines[bl][0]
if verbose:
print('\nData reformatting complete')
print('DONE.')
return tbl_uv_data
