def time_now():
rho.date = ephem.now() # Calculate now at rho
s_time.set(str(ephem.localtime(ephem.now()).strftime("%H:%M:%S")))
s_utc.set(str(ephem.date(ephem.now()).datetime().strftime("%H:%M:%S")))
s_lst.set(str(rho.sidereal_time()))
s.after(500,
time_now) # Call the function after 500 ms to update the time.
def observing_run(obs, target, startstr, stopstr, fname, log, errlog, flags):
# Set up observation logging
stdout = TeeStdout(log, 'a+')
stderr = TeeStderr(errlog, 'a+')
start = date_from_pdt(startstr)
stop = date_from_pdt(stopstr)
record_time = 24*3600*(stop-start) # Not started until start
logger = Thread(target=ral.recordDVM,
args=(fname, flags[0], flags[1], record_time))
logger.daemon=True
print '\nTracking times (PDT):'
print 'Start: %s' % pdt(start)
print 'Stop: %s' % pdt(stop)
print '\nCurrent time (PDT): %s' % pdt(ephem.now())
print 'Record length (s): %s' % record_time
# Start interferometer tracking!
interf_track(logger, obs, target, start, stop)
# Not going to explicitly kill logger, let the daemon thread expire
# But, recordDVM(...) should stop anyways!
del stdout
del stderr
print 'Done collecting data: %s' % pdt(ephem.now())
def dLocation(self):
self.s = ephem.Sun()
self.s.compute(epoch=ephem.now())
if self.nameEdit.text():
self.text1.setText(self.nameEdit.text())
font03 = QFont("Arial", 16)
font03.setBold(True)
self.text1.setFont(font03)
if not self.dateandtimeEdit.text():
self.o.date = ephem.now() # 00:22:07 EDT 06:22:07 UT+1
else:
if self.dateandtimeEdit.text():
self.o.date = self.dateandtimeEdit.text()
self.text1.setText("<b>Obliczenia dla:</b><br/> " +
self.dateandtimeEdit.text())
font03 = QFont("Arial", 16)
font03.setBold(True)
self.text1.setFont(font03)
else:
self.o.date = ephem.now() # 00:22:07 EDT 06:22:07 UT+1
#self.o.date = ephem.now() # 00:22:07 EDT 06:22:07 UT+1
self.s.compute(self.o)
hour_angle = self.o.sidereal_time() - self.s.ra
t = ephem.hours(hour_angle +
ephem.hours('12:00')).norm # .norm for 0..24
self.rad = str(ephem.hours(hour_angle + ephem.hours('12:00')).norm)
# self.result.setText("R.A.: " + str(self.s.a_ra) + " DEC.: " + str(self.s.a_dec))
# self.result2.setText("HOUR ANGLE: " + str(self.rad) + " SIDERAL TIME: " + str(self.o.sidereal_time()))
# self.result3.setText("SUN Altitude: " + str(self.s.alt) + " SUN Azimuth: " + str(self.s.az))
self.result4.setText("R.A.: " + str(self.s.a_ra))
self.result5.setText("DEC.: " + str(self.s.a_dec))
self.result6.setText("HOUR ANGLE: " + str(self.rad))
self.result7.setText("SIDERAL TIME: " + str(self.o.sidereal_time()))
self.result8.setText("SUN Altitude: " + str(self.s.alt))
self.result9.setText("SUN Azimuth: " + str(self.s.az))
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 mouseReleaseEvent(self, evt):
if self.editing is not None:
rect = self.rx[self.editing].rect()
pos = evt.pos()
self.rx[self.editing].setRect(rect.x(), rect.y(), rect.width(), pos.y()-rect.y()+ self.verticalScrollBar().value())
rect = self.rx[self.editing].rect()
print 'release', self.rx[self.editing].rect()
if rect.height() / self.scale_y > 0.1:
print 'Start time', str(ephem.date(ephem.now() + ((rect.y() - self.orig_y) / self.scale_y) * ephem.minute))
print 'Duration', rect.height() / self.scale_y
print 'Centre Frequency', (rect.x() + rect.width()/2 - self.orig_x) / self.scale_x + (self.fx0 * 1e6)
self.rx[self.editing].setParams(ephem.date(ephem.now() + ((rect.y() - self.orig_y) / self.scale_y) * ephem.minute),
rect.height() / self.scale_y,
(rect.x() + rect.width()/2 - self.orig_x) / self.scale_x + (self.fx0 * 1e6))
for f in self.scene().items(rect):
print f
if isinstance(f, PlannerSat):
print f.name, f.mode, f.freq, f.params
self.rx[self.editing].addChannel(f.name, f.mode, f.freq, f.tle, f.params)
else:
self.rx[self.editing].hide()
self.rx[self.editing] = None
self.rx = self.rx[:-1]
self.editing = None
else:
QtGui.QGraphicsView.mouseReleaseEvent(self, evt)
def compute_day_directory(loud=False):
global DAY_Directory, dayNow, Day_tomorrow
intDay = int(ephem.now())
dayFrac = ephem.now() - intDay
if dayFrac < 0.20833:
dayNow = intDay - 0.55
else:
dayNow = intDay + 0.45
ephem.date = ephem.Date(dayNow)
ephem.tomorrow = ephem.Date(dayNow + 1)
dayStr = str(ephem.date).split()[0]
dayStr = dayStr.split('/')
#print('Day String', dayStr)
if len(dayStr[1]) == 1:
dayStr[1] = '0' + dayStr[1]
if len(dayStr[2]) == 1:
dayStr[2] = '0' + dayStr[2]
#print('Day String', dayStr)
DAY_Directory = dayStr[0] + dayStr[1] + dayStr[2]
if loud: print('DaDIR: ', DAY_Directory)
dayStr = str(ephem.tomorrow).split()[0]
dayStr = dayStr.split('/')
#print('Day String', dayStr)
if len(dayStr[1]) == 1:
dayStr[1] = '0' + dayStr[1]
if len(dayStr[2]) == 1:
dayStr[2] = '0' + dayStr[2]
#print('Day String', dayStr)
Day_tomorrow = dayStr[0] + dayStr[1] + dayStr[2]
if loud: print('DaDIR: ', DAY_Directory)
return DAY_Directory
def header():
import ephem
from obztak.utils.date import datestring
now = ephem.now()
header = "# author: %s@%s\n" % (get_username(), get_hostname())
header += "# date: %s UTC\n" % (datestring(ephem.now(), 0))
header += "# version: obztak v%s\n" % (__version__)
return header
def main(): lat = '60.6754' long = '17.1509' print 'lat: ' + lat + ' | long: ' + long print 'Sunrise: ' + str(sunrise(lat,long)) + ' / ' + str(sunrise(lat,long).real) print 'Sunset: ' + str(sunset(lat,long)) + ' / ' + str(sunset(lat,long).real) print 'Now: ' + str(ephem.now()) + ' / ' + str(ephem.now().real) print 'Sun is up: ' + str(daylight(lat,long))
def sunset_time_response():
gemsouth.date = ephem.now()
gemsouth_twi.date = ephem.now()
settime = gemsouth.next_setting(ephem.Sun())
twitime = gemsouth_twi.next_setting(ephem.Sun(), use_center=True)
return ("Next sunset at Gemini South is {}, which is {} h {} m from now.".format(utc_to_multizone(settime.datetime()), *delta_to_now(settime)) +
"\nAnd 12 deg twilight is at {}".format(utc_to_multizone(twitime.datetime()) ) )
def pnt_obj(obs, target, dishobj):
"""Point to current object location (doesn't respect obs.date)
Prints point status with each pointing operation"""
obs.date = ephem.now()
target.compute(obs)
print '\nStart pnt: %s (JD: %s)' % (pdt(obs.date), ral.getJulDay())
print 'New pos (alt,az): %s, %s' % (target.alt, target.az)
dishobj.point(rad2deg(target.alt), rad2deg(target.az))
print 'Finish pnt: %s (JD: %s)' % (pdt(ephem.now()), ral.getJulDay())
def update(self, fx0, scale_x, scale_y, off_x, off_y):
y = ((self.start_time - ephem.now()) * 24.0 * 60.0) * scale_y + off_y
h = min(((self.stop_time - max(self.start_time, ephem.now())) * 24.0 * 60.0) * scale_y, 25 * 60 * scale_y - y)
# Calculate the width from the mode - one day!
w = 6
x = (self.freq - (fx0 * 1e6)) * scale_x + off_x - w/2
self.setRect(x, max(y, off_y), w, h)
self.setZValue(self.z)
def update(self, fx0, scale_x, scale_y, off_x, off_y):
y = ((self.start_time - ephem.now()) * 24.0 * 60.0) * scale_y + off_y
h = min(((self.stop_time - max(self.start_time, ephem.now())) * 24.0 *
60.0) * scale_y, 25 * 60 * scale_y - y)
# Calculate the width from the mode - one day!
w = 6
x = (self.freq - (fx0 * 1e6)) * scale_x + off_x - w / 2
self.setRect(x, max(y, off_y), w, h)
self.setZValue(self.z)
def planet(update, context):
user_planet = update.message.text.split()
user_planet = user_planet[1].lower()
if user_planet == 'jupiter':
result = ephem.Jupiter(ephem.now())
update.message.reply_text(
f'Юпитер находится в созвездии {ephem.constellation(result)}')
elif user_planet == 'saturn':
result = ephem.Saturn(ephem.now())
update.message.reply_text(
f'Сатурн находится в созвездии {ephem.constellation(result)}')
def update(self, satellite):
self.drawAxis()
for passes in xrange(len(satellite.passList)):
tr, azr, tt, altt, ts, azs, lat, lon, alt = satellite.passList[
passes]
if math.degrees(altt) > 15.0 and (tr - ephem.now()) < 1.0:
for f in xrange(len(satellite.freq)):
if satellite.freq[f] > (self.fx0 * 1e6) and satellite.freq[
f] < (self.fx0 + self.bw) * 1e6:
if tr < ephem.now():
tr = ephem.now()
y = ((tr - ephem.now()) * 24.0 *
60.0) * self.scale_y + self.orig_y
h = min(((ts - tr) * 24.0 * 60.0) * self.scale_y,
25 * 60 * self.scale_y - y)
# Calculate the width from the mode - one day!
w = 16
x = (satellite.freq[f] - (self.fx0 * 1e6)
) * self.scale_x + self.orig_x - w / 2
i = passes * len(satellite.freq) + f
satellite.passListPlan[i].setIndex(f)
satellite.passListPlan[i].setRect(
x, max(y, self.orig_y), w, h)
satellite.passListPlan[i].setParams(
(tr, azr, tt, altt, ts, azs, lat, lon, alt))
if satellite.passListPlan[i].scene() == None:
self.scene().addItem(satellite.passListPlan[i])
satellite.passListPlan[i].show()
else:
for f in xrange(len(satellite.freq)):
satellite.passListPlan[passes * len(satellite.freq) +
f].hide()
for passes in xrange(
len(satellite.passListPlan) -
(len(satellite.passList) * len(satellite.freq))):
#print 'hiding', passes+(len(satellite.passList) * len(satellite.freq)), len(satellite.passListPlan)
satellite.passListPlan[passes + (len(satellite.passList) *
len(satellite.freq))].hide()
nw = datetime.datetime.now()
for x in xrange(len(self.time_labels)):
self.time_labels[str(x)].setToolTip(nw.strftime('%H:%M:%S'))
nw += datetime.timedelta(hours=1)
for x in xrange(len(self.rx)):
self.rx[x].update(self.fx0, self.scale_x, self.scale_y,
self.orig_x, self.orig_y)
def read_db(name):
rho.date = ephem.now()
with open('objects.txt', 'r') as f:
lines = f.readlines()
for line in lines:
if line[0:len(name.get())] == name.get():
obj = ephem.readdb(line)
rho.date = ephem.now()
obj.compute(rho)
search(obj, 'GET User Object')
break
def __init__(self,
parent,
coord,
coord_type="RADEC",
slew_rate=0.23,
update_rate=1.0,
update_display_rate=5.0):
"""
Must supply coords in degrees, not radians.
This is the form that APCA accepts.
"""
super(PointThread, self).__init__()
self.parent = parent
self.initial_coord = coord
self.update_rate = update_rate
self.update_display_rate = update_display_rate
self.slew_rate = slew_rate
observer = parent.copy()
convert = 180. / math.pi
calc_commanded_azel = None
if coord_type not in ["AZEL", "RADEC"]:
raise RuntimeError(
"Need to specify a coordinate type that is either RADEC or AZEL"
)
if coord_type == "AZEL":
raise NotImplementedError("AZEL not implemented at the moment")
elif coord_type == "RADEC":
body = SerializableBody()
body._ra = float(
coord[0]) / convert # covnert from degrees to radians
body._dec = float(coord[1]) / convert
body._epoch = ephem.now()
observer.epoch = ephem.now()
self.parent.logger.debug(
"PointThread.__init__: body._ra: {}, body._dec: {}".format(
convert * body._ra, convert * body._dec))
def calc_commanded_azel():
"""The values calculated by this function are actually slighty off what they should be"""
observer.date = ephem.now()
body.compute(observer)
return body.az * convert, body.alt * convert
if calc_commanded_azel is not None:
self.calc_commanded_azel = calc_commanded_azel
else:
raise RuntimeError(
"Need means of calculating current source Az/El")
self.current_time = time.time()
def read_db(name):
rho.date = ephem.now()
with open('objects.txt', 'r') as f:
lines = f.readlines()
for line in lines:
if line[0:len(name.get())] == name.get():
obj = ephem.readdb(line)
rho.date = ephem.now()
obj.compute(rho)
st = rho.sidereal_time()
ha = '%s' % ephem.hours(st - obj.ra)
search(obj, 'User Object')
break
def next_moondark(self): # this is producing an off by one error: fix!
mn = ephem.Moon()
mp = []
for n in range(0,29*4):
mn.compute(ephem.now()+(n/4.))
mp.append((ephem.now()+(n/4.), mn.moon_phase))
next_new_moon = ephem.Date(min(mp, key=lambda x:x[1])[0]).datetime()
# next_new_moon = pytz.utc.localize(next_new_moon) # it's calculated in UTC
# hst = pytz.timezone('HST')
retval = next_new_moon #.astimezone(hst)
return retval
def next_moondark(self): # this is producing an off by one error: fix!
mn = ephem.Moon()
mp = []
for n in range(0, 29 * 4):
mn.compute(ephem.now() + (n / 4.))
mp.append((ephem.now() + (n / 4.), mn.moon_phase))
next_new_moon = ephem.Date(min(mp, key=lambda x: x[1])[0]).datetime()
# next_new_moon = pytz.utc.localize(next_new_moon) # it's calculated in UTC
# hst = pytz.timezone('HST')
retval = next_new_moon #.astimezone(hst)
return retval
def dLocation(self):
s = ephem.Sun()
s.compute(epoch=ephem.now())
print("R.A.: %s DEC.: %s" % (s.a_ra, s.a_dec))
o = ephem.Observer()
o.lon, o.lat = '17.03333', '51.100000' # Współrzędne Wrocławia
o.date = ephem.now() # 00:22:07 EDT 06:22:07 UT+1
s.compute(o)
hour_angle = o.sidereal_time() - s.ra
t = ephem.hours(hour_angle +
ephem.hours('12:00')).norm # .norm for 0..24
rad = str(ephem.hours(hour_angle + ephem.hours('12:00')).norm)
print("HOUR ANGLE: %s SIDERAL TIME: %s" % (rad, o.sidereal_time()))
def plan_tiles(self, J, Nahead=10, exptime=None):
'''
Nahead: int: How many exposures ahead should we plan?
'''
# Set observing conditions for computing exposure time
now = ephem.now()
self.obs.date = now
self.upcoming = []
iahead = 0
for ii,jplan in enumerate(J):
if iahead >= Nahead:
break
tilename = str(jplan['object'])
nextseq = self.seqnum + iahead
print('Considering planning tile %s for exp %i' %
(tilename, nextseq))
if tilename in self.observed_tiles:
oldfn = self.observed_tiles[tilename]
print('Tile %s was observed in file %s' % (tilename, oldfn))
continue
# Check all planned tiles before this one for a duplicate tile.
dup = False
for s in range(nextseq-1, 0, -1):
t = self.planned_tiles[s]
if t['object'] == tilename:
dup = True
print('Wanted to plan tile %s for exp %i '
% (tilename, nextseq),
'but it was already planned for exp %i' % s)
break
if dup:
continue
iahead += 1
if exptime is not None:
jplan['expTime'] = exptime
print('%s: updating exposure %i to tile %s' %
(str(ephem.now()), nextseq, tilename))
self.planned_tiles[nextseq] = jplan
self.upcoming.append(jplan)
self.obs.date += (jplan['expTime'] + self.nom.overhead) / 86400.
self.write_plans()
def solve_coordinates(self, satellites, lines1, lines2): from ephem import Observer, degrees, now self.observer = Observer() (lon, lat, ele) = self.get_location() self.observer.lon = degrees(lon) self.observer.lat = degrees(lat) self.observer.elevation = ele self.observer.date = now() self.observer.epoch = now() for i in range(self.index): self.pyephem_routine(satellites[i], lines1[i], lines2[i])
def gen_observer(self):
observer = ephem.Observer()
(lon, lat, ele) = self.get_location()
observer.lon = ephem.degrees(lon)
observer.lat = ephem.degrees(lat)
observer.elevation = ele
observer.date = ephem.now()
observer.epoch = ephem.now()
observer.horizon = '0'
return observer
def update(self, fx0, scale_x, scale_y, off_x, off_y):
if self.ready:
y = ((self.start_time - ephem.now()) * 24.0 * 60.0) * scale_y + off_y
h = min(min(self.duration, (self.start_time - ephem.now()) * 24 * 60 + self.duration) * scale_y, 25 * 60 * scale_y - y)
# Calculate the width from the mode - one day!
w = self.rx_bw * scale_x
x = (self.freq - (fx0 * 1e6)) * scale_x + off_x - w/2
self.setRect(x, max(y, off_y), w, h)
self.setZValue(self.z)
for x in xrange(len(self.channels)):
if ephem.now() > self.channels[x].stop_time:
self.channels[x].hide()
else:
self.channels[x].update(fx0, scale_x, scale_y, off_x, off_y)
def setUp(self):
self.testdatadir = os.path.join(os.path.dirname(__file__),
'testdata')
import tempfile
fn1 = os.path.join(self.testdatadir, 'pass1.json')
fn2 = os.path.join(self.testdatadir, 'pass2.json')
fn3 = os.path.join(self.testdatadir, 'pass3.json')
tmpfn1 = fn1 + '.tmp'
tmpfn2 = fn2 + '.tmp'
tmpfn3 = fn3 + '.tmp'
for fn,tmpfn in ((fn1,tmpfn1),(fn2,tmpfn2),(fn3,tmpfn3)):
import json
import ephem
J = json.loads(open(fn, 'r').read())
t0 = ephem.Date(str(J[0]['approx_datetime']))
print('First exposure:', t0)
now = ephem.now()
print('Now:', now)
for j in J:
tnew = now + ephem.Date(str(j['approx_datetime'])) - t0
tnew = str(ephem.Date(tnew))
j['approx_datetime'] = tnew
print('Updated datetime to', tnew)
f = open(tmpfn, 'w')
json.dump(J, f, sort_keys=True, indent=4, separators=(',', ': '))
f.close()
self.jsonfiles = [tmpfn1, tmpfn2, tmpfn3]
def __init__(self,lon,lat,antpos,freqs,df=40e3,date=ephem.now(),driftMode=True,beam=Beam(mwabeam,[None,[0.,0.]])):
self.driftMode=driftMode
self.obs=ephem.Observer()
self.lat=lat
self.lon=lon
self.obs.lat=str(lat)
self.obs.lon=str(lon)
self.obs.date=date
self.antpos=antpos
#convert from n-s,e-w coords to XYZ coords where Y points to -6 hours, X to 0 hours and Z along the earth's rotation axis.
self.lst=np.degrees(float(repr(self.obs.sidereal_time())))
self.xyz=nsew2xyz(antpos,self.lst,lat)
self.nant=self.xyz.shape[0]
self.freqs=freqs
df=df
nf=len(freqs)
self.delays=np.arange(-nf/2,nf/2)/(nf*df)
self.nvis=(self.nant-1)*self.nant/2
self.model=np.zeros((len(freqs),self.nvis)).astype(complex)
self.pcentre=np.array([self.lst,lat])
if(self.driftMode):
self.nunique,self.unique_map,self.unique_uvw,self.uvw=self.getUnique(self.pcentre)
# print self.uvw
# print len(freqs),self.nunique
self.model_true=np.zeros((len(freqs),self.nunique)).astype(complex)
# print self.unique_map
self.modelspace='freq'
self.data=np.zeros((len(freqs),self.nvis)).astype(complex)
self.datastate='freq'
#fifteen degrees at lowest frequency
self.beam=beam
self.bandpass=[Bandpass(flatband,[1]) for mm in range(self.xyz.shape[0])]#instantiate all antennae to same bandpass
def compute_min_property(self, prop):
ephemeride = self.ephem_object
def compute_min(time):
ephemeride.compute(time)
return getattr(ephemeride, prop)
if ephemeride:
now = ephem.now()
# 100 year from now bounds
bounds = [ephem.Date(now - ephem.hour * 24 * 365 * 100),
ephem.Date(now + ephem.hour * 24 * 365 * 100)]
result = optimize.minimize_scalar(
compute_min,
method='Bounded',
bounds=bounds
)
if result['message'] == 'Solution found.':
ephemeride.compute(result['x'])
data = {
'ephemeride': ephemeride,
'date': ephem.Date(result['x']).datetime()
}
data[prop] = getattr(ephemeride, prop)
return data
else:
return None
else:
return None
def sunPhaseAngle(offsetHrs=0.0):
dayNow = ephem.now()
ptr = ephem.Observer() #Photon Ranch
ptr.lat = str(siteLatitude)
ptr.lon = str(siteLongitude)
ptr.elev = siteElevation
ptr.compute_pressure()
ptr.temp = siteRefTemp
ptr.date = ephem.Date(dayNow + offsetHrs * ephem.hour)
sun = ephem.Sun()
sun.compute(ptr)
moon = ephem.Moon()
moon.compute(ptr)
saz = reduceAz(degrees(sun.az) + 180)
sal = degrees(sun.alt)
if sal > 0.5:
saz = 0
#NBNBNB this needs to be improved to implement sun earth eclipse shadow.
maz = degrees(moon.az)
mal = degrees(moon.alt)
if loud: print('Sun Now: ', saz, degrees(sun.alt))
moon.compute(ptr)
if loud: print('Moon Now: ', degrees(moon.az), degrees(moon.alt))
return round(saz, 2)
def show(coords, time):
if time:
dt = (datetime.datetime.strptime(time, "%m-%d-%Y %H:%M:%S") - datetime.datetime.now()).total_seconds()
else:
dt = 0.0
obs.date = ephem.now()
obs.date += dt / 86164.
az = []
alt = []
for ra, dec in zip(coords["ra"], coords["dec"]):
point = ephem.FixedBody()
point._ra = np.deg2rad(ra)
point._dec = np.deg2rad(dec)
point._epoch = ephem.J2000
point.compute(obs)
az.append(point.az)
alt.append(point.alt)
az = np.array(az)
alt = np.array(alt)
plt.cla()
plt.plot(np.rad2deg(az), np.rad2deg(alt), "-", marker="o")
plt.fill_between(range(361), -45. * np.ones(361), ALT_LIMITS, color="Gray", alpha=0.2)
plt.xlim(0, 360)
plt.ylim(-15, 90)
plt.show()
def __init__(self,location='hilo'):
self.observation = Session()
# Add more locations as needed
self.observer_locations = {
'hilo': {
'lon': '-155:05:23:99',
'lat': '19:42:00:00',
'elevation': 88 , # meters
'temp': 23, # celsius
'pressure': 1010 # This is default but also a guess
},
'vis': {
'lon': '-155:27:52:35',
'lat': '19:45:42:96',
'elevation': 2848.5, # meters
'temp': 15, # celsius - this is a guess
'pressure': 700 #this is a guess
},
}
# Building an Observer to watch the moon. Shouldn't need to change anything here. Move along.
self.observer = ephem.Observer()
# Get the settings for our location
location_settings = self.observer_locations[location]
self.observer.lat = location_settings['lat']
self.observer.lon = location_settings['lon']
self.observer.elevation = location_settings['elevation']
self.observer.temp = location_settings['temp']
self.observer.pressure = location_settings['pressure']
self.observer.date = ephem.now()
# Create our Moon and look at it from our observer location
self.moon = ephem.Moon(self.observer)
def __init__(self, tle_name, tle_url, frequency, output_prefix):
self.tle_name = tle_name
self.output_prefix = output_prefix
self.frequency = frequency
self.next_check_time = ephem.now()
# download TLE list
tle_fd = urllib2.urlopen(self.tle_url_base + tle_url)
tle_list = []
for line, i in zip(tle_fd, itertools.cycle(xrange(3))):
if i == 0:
tle_list.append([])
tle_list[-1].append(line.strip())
# scan TLEs for this satellite
self.tle = None
for tle in tle_list:
if tle[0] == tle_name:
self.tle = tle[1:]
break
if self.tle is None:
raise RuntimeError('TLE "%s" not found' % tle_name)
# init ephem body object
self.body = ephem.readtle(tle_name, self.tle[0], self.tle[1])
def measure_tot_pow(self):
#If dumpfile exists remove it
try:
os.remove('/tmp/ramdisk/dump1')
os.remove('/tmp/ramdisk/dump2')
except OSError:
pass
self.date = ephem.now().tuple()
self.receiver.lock()
self.receiver.signal_file_sink_1.open("/tmp/ramdisk/totPow")
self.receiver.unlock()
print self.measureTimeTotPow
t_end = time.time() + self.measureTimeTotPow
start = time.time()
while time.time() <= t_end:
if int(self.config.get('CTRL','abort')) == 1:
break
self.receiver.blks2_selector_0.set_output_index(1) #Stream to signal sink
end = time.time()
self.totpowTime += end-start
self.receiver.blks2_selector_0.set_output_index(0) #Null sink, shouldnt be necessary but just in case
self.receiver.lock()
self.receiver.signal_file_sink_1.close()
self.receiver.unlock()
def setObserverData(station, predictionDate, verbose):
"""
setObserverData sets the info for the station from which the info is calculated
Parameters:
station: info over the observation station (name, lat, lon)
predictionDate: date for doing the prediction
Returns:
observer contains all info about location and date for prediction
"""
# read in the station info (name, latitude, longitude) in degrees
observer = Station()
if station is None:
observer = RMA
else:
observer.parse(station)
# read in the predDate
if predictionDate is None:
observer.date = ephem.date(ephem.now()) # today at midnight for default start
else:
observer.date = ephem.Date(predictionDate)
# print('observer.date: %04d/%02d/%02d\n' % ephem.date(observer.date).triple())
if verbose:
observer.statPrint()
return observer
def __init__(self, data, bandwidth, nchans, cfreq, site, alt, az, int_time, username, config, offset_alt, offset_az):
# All units shall be S.I. (Hz, etc. not MHz)
self.rest_freq = 1420.40575177e6 # Hz, from Wiki.
self.obs_freq = float(cfreq)
self.data = data[:]
self.bandwidth = float(bandwidth)
self.nchans = int(nchans)
self.int_time = int(int_time)
# Copy relevant properties from input site
self.site = ephem.Observer()
self.site.name = site.name
self.site.lat = site.lat
self.site.long = site.long
self.site.elevation = site.elevation
self.site.pressure = site.pressure
self.site.date = ephem.Date(site.date) # Make sure we do not keep reference to old time
self.alt = alt # deg
self.az = az # deg
alt_rad = self.alt*np.pi/180.0
az_rad = self.az*np.pi/180.0
(ra, dec) = self.site.radec_of(az_rad, alt_rad)
pointing = ephem.FixedBody()
pointing._ra = ra
pointing._dec = dec
pointing._epoch = ephem.now()
pointing.compute(self.site)
# NOTE: This will not be true for a long measurement
self.target = ephem.Galactic(pointing)
self.observer = username
self.uploaded = False
self.freq_vlsr_corr = 0
self.vlsr_corr = 0
self.config = config
self.offset_alt = offset_alt
self.offset_az = offset_az
def planet_name(bot, update, user_data):
planet_name = update.message.text.split()[1]
date = ephem.now()
planet = getattr(ephem, planet_name)(date)
const = ephem.constellation(planet)
text = f'Сегодня планета {planet_name} находится в созвездии {const[1]}'
update.message.reply_text(text, reply_markup=get_keyboard())
def getMoonPhases():
date = ephem.now()
new_moon = str(ephem.next_new_moon(date))
first_quarter_moon = str(ephem.next_first_quarter_moon(date))
full_moon = str(ephem.next_full_moon(date))
last_quarter_moon = str(ephem.next_last_quarter_moon(date))
return new_moon, first_quarter_moon, full_moon, last_quarter_moon
def setObserverData(station, predictionDate, verbose):
"""
setObserverData sets the info for the station from which the info is calculated
Parameters:
station: info over the observation station (name, lat, lon)
predictionDate: date for doing the prediction
Returns:
observer contains all info about location and date for prediction
"""
# read in the station info (name, latitude, longitude) in degrees
observer = Station()
if station is None:
observer = RMA
else:
observer.parse(station)
# read in the predDate
if predictionDate is None:
observer.date = ephem.date(
ephem.now()) # today at midnight for default start
else:
observer.date = ephem.Date(predictionDate)
# print('observer.date: %04d/%02d/%02d\n' % ephem.date(observer.date).triple())
if verbose:
observer.statPrint()
return observer
def get_phase_name(location: Optional[ephem.Observer] = None, wiggle_room: float = 1.5) -> str:
"""Return name of the phase of the moon."""
if location:
date = location.date
else:
date = ephem.now()
if abs(ephem.next_first_quarter_moon(date) - date) < wiggle_room or \
abs(ephem.previous_first_quarter_moon(date) - date) < wiggle_room:
return 'first quarter moon'
elif abs(ephem.next_full_moon(date) - date) < wiggle_room or \
abs(ephem.previous_full_moon(date) - date) < wiggle_room:
return 'full moon'
elif abs(ephem.next_last_quarter_moon(date) - date) < wiggle_room or \
abs(ephem.previous_last_quarter_moon(date) - date) < wiggle_room:
return 'last quarter moon'
elif abs(ephem.next_new_moon(date) - date) < wiggle_room or \
abs(ephem.previous_new_moon(date) - date) < wiggle_room:
return 'new moon'
elif ephem.next_first_quarter_moon(date) - ephem.previous_new_moon(date) < 29:
return 'waxing crescent'
elif ephem.next_full_moon(date) - ephem.previous_first_quarter_moon(date) < 29:
return 'waxing gibbous'
elif ephem.next_last_quarter_moon(date) - ephem.previous_full_moon(date) < 29:
return 'waning gibbous'
elif ephem.next_new_moon(date) - ephem.previous_last_quarter_moon(date) < 29:
return 'waning crescent'
return ''
def hourAngle(self, ra):
self.observer.date = ephem.now()
self.sideral = self.observer.sidereal_time()
ra_ = ephem.hours(ra - self.sideral).znorm
if ra_ == ephem.hours("24:00:00"):
ra = ephem.hours("00:00:00")
return ra_
def setUp(self):
self.testdatadir = os.path.join(os.path.dirname(__file__), 'testdata')
self.server = TestServer()
print('URL type:', type(self.server.url))
fn1 = os.path.join(self.testdatadir, 'decals-pass1.json')
fn2 = os.path.join(self.testdatadir, 'decals-pass2.json')
fn3 = os.path.join(self.testdatadir, 'decals-pass3.json')
tmpfn1 = fn1 + '.tmp'
tmpfn2 = fn2 + '.tmp'
tmpfn3 = fn3 + '.tmp'
for fn, tmpfn in ((fn1, tmpfn1), (fn2, tmpfn2), (fn3, tmpfn3)):
import json
import ephem
J = json.loads(open(fn, 'r').read())
t0 = ephem.Date(str(J[0]['approx_datetime']))
print('First exposure:', t0)
now = ephem.now()
print('Now:', now)
for j in J:
tnew = now + ephem.Date(str(j['approx_datetime'])) - t0
tnew = str(ephem.Date(tnew))
j['approx_datetime'] = tnew
#print('Updated datetime to', tnew)
f = open(tmpfn, 'w')
json.dump(J, f, sort_keys=True, indent=4, separators=(',', ': '))
f.close()
self.jsonfiles = [tmpfn1, tmpfn2, tmpfn3]
def __init__(self, tle_name, tle_url, frequency, output_prefix):
self.tle_name = tle_name
self.output_prefix = output_prefix
self.frequency = frequency
self.next_check_time = ephem.now()
# download TLE list
tle_fd = urllib2.urlopen(self.tle_url_base + tle_url)
tle_list = []
for line, i in zip(tle_fd, itertools.cycle(xrange(3))):
if i == 0:
tle_list.append([])
tle_list[-1].append(line.strip())
# scan TLEs for this satellite
self.tle = None
for tle in tle_list:
if tle[0] == tle_name:
self.tle = tle[1:]
break
if self.tle is None:
raise RuntimeError('TLE "%s" not found' % tle_name)
# init ephem body object
self.body = ephem.readtle(tle_name, self.tle[0], self.tle[1])
def ParallacticAngle(AR, DEC, lat = '28.775867', lon = '-17.89733', date = 'now'):
# Definition of the observatory place
observatory = ephem.Observer()
observatory.lon = str(lon)
observatory.lat = str(lat)
if date == 'now':
observatory.date = ephem.now()
else:
observatory.date = ephem.Date(date)
# Definition of the target
target = ephem.Equatorial(AR, DEC, epoch = ephem.J2000)
# Computing the target from and observation point and moment.
body = ephem.FixedBody()
body._ra = target.ra
body._dec = target.dec
body._epoch = target.epoch
body.compute(observatory)
# Determining the parallactic_angle()
# ParaAngle = body.parallactic_angle()
# Just if there is some problem with this attribute in ephem, try:
HA=observatory.sidereal_time()- target.ra
ParaAngle=atan(cos(observatory.lat)*sin(HA) / (sin(observatory.lat)*cos(DEC) - cos(observatory.lat)*sin(DEC)*cos(HA)))
if ParaAngle < 0:
ParaAngle += (2 * pi)
return degrees(ParaAngle), degrees(body.az), degrees(body.alt)
def till_rise(self):
self.time_till = (self.next_contact[0] - ephem.now()) * 86400
hh = int(self.time_till/(60*60))
tmp = self.time_till - hh*60*60
mm = int(tmp/60)
ss = tmp - mm*60
self.NextLcd.display("%d" %hh + ":%.2d" % mm + ":%.2d" % ss)
def astro_moonnextnew(DATETIME=None):
if DATETIME == None:
eventdate = ephem.localtime(ephem.next_new_moon(ephem.now()))
return "FM: " + eventdate.strftime('%b %d %H:%M')
else:
return ephem.next_new_moon(DATETIME)
def repoint(d, point, duration=300, repoint_freq=30.0):
"""Updates position and re-point telescope every t seconds.
Args:
d (dish.Dish): an interface to the Leuschner dish
point (ephem.FixedBody): PyEphem fixed body object representing the
coordinate on the sky to be observed
repoint_freq (float, optional): number of seconds between updates.
Defaults to 30.0 seconds.
"""
logger = logging.getLogger('leuschner')
t = 0
while(t < duration):
# Update the time and recompute position
OBS.date = ephem.now()
point.compute(OBS)
logger.debug('Move to telescope to (alt, az): (%s,%s)',
str(point.alt), str(point.az))
try:
d.point(np.rad2deg(point.alt), np.rad2deg(point.az))
except ValueError, e:
logger.error('Re-pointing failed for (alt,az): (%s,%s)',
str(getAlt(source)),
str(source.az))
logger.error(str(e))
except Exception, e:
logger.error('Re-pointing failed for (alt,az): (%s,%s)',
str(getAlt(source)),
str(source.az))
logger.error('Repointing failed: %s', str(e))
def measure_tot_pow(self):
try:
os.remove('/tmp/ramdisk/dump1')
os.remove('/tmp/ramdisk/dump2')
os.remove('/tmp/ramdisk/dump3')
os.remove('/tmp/ramdisk/dump4')
except OSError:
pass
self.date = ephem.now().tuple()
self.receiver.signal_file_sink_1.open("/tmp/ramdisk/sig0_0" +
self.index)
self.receiver.signal_file_sink_3.open("/tmp/ramdisk/sig1_0" +
self.index)
print self.measureTimeTotPow
t_end = time.time() + self.measureTimeTotPow
start = time.time()
while time.time() <= t_end and int(self.config.get('CTRL',
'abort')) != 1:
continue
self.receiver.signal_file_sink_1.close()
self.receiver.signal_file_sink_3.close()
end = time.time()
self.totpowTime += end - start
def get_next_transition(self): """ Returns the next transition to occur (RISES or SETS) and the number of seconds until that time. """ # Goodness knows why this library wants a string observer = ephem.Observer() observer.lat = str(self.lat) observer.long = str(self.long) # This is the body we care about sun = ephem.Sun() def ephem_to_unix(t): return time.mktime(ephem.localtime(t).timetuple()) sun.compute() rises = ephem_to_unix(observer.next_rising(sun)) + self.leeway sets = ephem_to_unix(observer.next_setting(sun)) - self.leeway now = ephem_to_unix(ephem.now()) # If sunset (with leeway) has already happened (unbenonced to ephem) then it # is not the next transition so just push it past the rise time so that it # is picked if sets < now: sets = rises + 1 return (DaylightController.RISES if rises < sets else DaylightController.SETS, min(rises, sets) - now)
def schedule_chunk(self,
tstart=None,
chunk=60,
clip=False,
plot=False,
mode=None):
"""
Schedule a chunk of exposures.
Parameters:
-----------
tstart : Start time (UTC); in `None` use `ephem.now()`
chunk : Chunk of time to schedule.
plot : Dynamically plot each scheduled exposure
mode : Mode for scheduler tactician
Returns:
--------
fields : Scheduled fields
"""
# If no tstop, run for 90 minutes
if tstart is None: tstart = ephem.now()
tstop = tstart + chunk * ephem.minute
return self.run(tstart, tstop, clip, plot, mode)
def display_stats(orient, position, obs):
try:
print("\n"*65)
print(''' _.:::::._
.:::'_|_':::.
/::' --|-- '::\\
|:" .---"---. ':|
|: ( O R E O ) :|
|:: `-------' ::|
\:::.......:::/
':::::::::::'
`'"""'`\n\n''')
print("Time: {}\n".format(ephem.now()))
print("Sensor\n===")
print('Heading: {heading:.2f}, Pitch: {pitch:.2f}, '\
'Roll: {roll:.2f}\n---'.format(heading = orient.get_heading(),
pitch = orient.get_pitch(),
roll = orient.get_roll()))
print('CALIBRATION Sys: {cal[0]}, Gyr: {cal[1]},'\
' Acc: {cal[2]}, Mag: {cal[3]}\n'
.format(cal=orient.get_calibration()))
print('GPS\n===\nFix: {fix}, Lat: {lat}, Lon: {lon}'
.format(fix = position.is_fixed(), lat = float(obs.lat), lon = float(obs.lon)))
print(position.unparsed)
except:
pass
def get_footprints_kml():
footprint_placemarks = ''
color = _config.get('tracking','footprint_color')
for kep in _keps.values():
kep_ephem = ephem.readtle(kep[0], kep[1], kep[2])
kep_ephem.compute(ephem.now())
lon = kep_ephem.sublong
lat = kep_ephem.sublat
elevation = kep_ephem.elevation
coords = ''
for point in get_footprint_points(lat, lon, elevation):
coords += '%lf,%lf\n' % (point[0], point[1])
tokens = {
'[NAME]':kep[0],
'[DESCRIPTION]':'%s' % (kep[0]),
'[COLOR]':color,
'[COORDS]': coords
}
footprint_placemarks += swap(_satellite_footprint_polygon_template, tokens)
tokens = {
'[PLACEMARKS]':footprint_placemarks,
}
return swap(_satellite_footprint_template_main, tokens)
def __init__(self, data):
"""
"""
self.data = data
self.tau = pd.read_csv(
self.data._wto_path + 'conf/tau.csv', sep=',', header=0).set_index(
'freq')
self.tsky = pd.read_csv(
self.data._wto_path + 'conf/tskyR.csv', sep=',',
header=0).set_index(
'freq')
self.pwvdata = pd.read_pickle(
self.data._wto_path + 'conf/pwvdata2.pandas') # .set_index('freq')
# self.pwvdata.index = pd.Float64Index(
# pd.np.round(self.pwvdata.index.values, decimals=1), name=u'freq')
self._pwv = None
self._array_res = []
self._date = ephem.now()
self._availableobs = False
self._time_astropy = TIME
self._ALMA_ephem = ALMA1
self._static_calculated = False
self.schedblocks = self.data.schedblocks.copy()
def get_sunset(self):
self.meadows.date = ephem.now()
if self.sunup() is True:
sunset = self.meadows.next_setting(ephem.Sun(), use_center=True)
else:
sunset = self.meadows.previous_setting(ephem.Sun(), use_center=True)
return ephem.localtime(sunset)
def compare_sun_altaz(obs, pressure = 1010):
"""Compare homebrewed and PyEphem calculations of sun alt-az
Prints out results of:
my method using RA/dec values from Karto's method and PyEphem
PyEphem's computation of alt/az
It appears that the refraction correction gives the biggest discrepancy.
Without refraction (pressure = 0), the computations agree to within
10-20 arcsec or so.
"""
eph_sun = ephem.Sun()
obs.date = ephem.now()
if pressure != 1010:
obs.pressure = pressure
eph_sun.compute(obs)
if pressure != 1010:
obs.pressure = 1010
ral_sun = ral.sunPos()
sun_ra = ephem.hours(hrs2rad( ral_sun[0] ))
sun_dec = ephem.degrees(deg2rad( ral_sun[1] ))
print 'Sun alt-az, my matrix + kartp\'s ra, dec: (%s, %s)' % \
radec2altaz(obs, sun_ra, sun_dec)
print 'Sun alt-az, my matrix + PyEphem ra, dec: (%s, %s)' % \
radec2altaz(obs, eph_sun.ra, eph_sun.dec)
print 'Sun alt-az, PyEphem + PyEphem alt, az: (%s, %s)' % \
(eph_sun.alt, eph_sun.az)
def sky(self, **kwargs):
observer = config.observer
observer.date = ephem.now()
positions = [
SkyPosition(body)
for body in body_computer(
observer, 'Sun', 'Moon', PLANETS,
config.as_list('stars'),
config.as_list('asteroids'),
config.as_list('satellites'),
config.as_list('comets')
)
]
sort_key = kwargs.get('sort', 'alt')
sort_reverse = sort_key == 'alt'
positions.sort(
key=lambda x: getattr(x.body, sort_key),
reverse=sort_reverse)
return render('sky.html', {
'observer': observer,
'positions': positions,
'date': observer.date,
'local': ephem.localtime(observer.date),
'refresh_seconds': 6,
})
def rescheduler():
""" After an event happens, it's added to the reschedule queue
so that the next time it occurs can be added to the event queue.
For example, after Moon rise, this function calculates the date
of the next Moon rise and puts it on the event queue.
"""
logger.debug("Startup")
while True:
logger.debug("{:4d} {:4d} get".format(
reschedule_queue.qsize(), len(events)))
ev = reschedule_queue.get()
logger.debug("Rescheduling:{}".format(ev))
del events[ev.key]
observer = ephem.city(CITY)
next_method = {
'rise_time': observer.next_rising,
'transit_time': observer.next_transit,
'set_time': observer.next_setting,
}[ev.event_name]
body = bodies[ev.body_name] # should I make a copy?
body.compute(ephem.now())
start_date = ephem.Date(ev.date + ephem.minute)
date = next_method(body, start=start_date)
if date is not None:
altaz = getattr(body, {
'rise_time': 'rise_az',
'transit_time': 'transit_alt',
'set_time': 'set_az',
}[ev.event_name])
new_ev = Event(ev.body_name, date, ev.event_name, altaz)
event_queue.put(new_ev)
events[new_ev.key] = new_ev
logger.debug("Rescheduled: {}".format(new_ev))
reschedule_queue.task_done()
def log(self, *args, **kwargs):
'''
Keyword args:
uniq: if True, do not print a log message if it repeats the last printed
log message.
kwargs: passed to print().
'''
from io import StringIO, BytesIO
uniq = kwargs.pop('uniq', False)
if py2:
f = BytesIO()
else:
f = StringIO()
pkw = kwargs.copy()
pkw.update(file=f)
print(*args, **pkw)
#print(*args, file=f, **kwargs)
s = f.getvalue()
if uniq and s == self.last_printed:
return
self.last_printed = s
if self.timestamp:
import ephem
now = str(ephem.now())
print('%s: %s' % (now, s), end='')
else:
print(s, end='')
def find_constellation(best_planet_choice):
time_now = ephem.now()
planet_obj = getattr(ephem, best_planet_choice)
user_find_planet = planet_obj()
user_find_planet.compute(time_now)
_, full_name = ephem.constellation(user_find_planet)
return full_name
def set_ephemtime(self, t=None):
"""Set current time as derived from the ephem package. Recalculates
matrix for projecting baselines into current positions."""
if t is None: t = ephem.now()
self.date, self.epoch = t, t
self._eq2now = coord.rot_m(-self.sidereal_time(),
np.array([0., 0., 1.]))
