Python ephem.now函数代码示例

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 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 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 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 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 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 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 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 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, 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 __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 __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)