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 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.]))