def visibility(ra, dec, observatory, time): source = SkyCoord(ra=Angle(ra * u.deg), dec=(dec * u.deg)) location = observatory.position time = Time(time) altaz = source.transform_to(AltAz(obstime=time, location=location)) altaz_sun = get_sun(time).transform_to( AltAz(obstime=time, location=location)) altaz_moon = get_moon(time).transform_to( AltAz(obstime=time, location=location)) delta_time = np.linspace(0, 24, 200) * u.hour frame = AltAz(obstime=time + delta_time, location=location) frame_night = source.transform_to(frame) frame_sun_night = get_sun(time + delta_time).transform_to(frame) frame_moon_night = get_moon(time + delta_time).transform_to(frame) moon_distance = np.mean( source.separation( SkyCoord( get_moon(time + delta_time).ra, get_moon(time + delta_time).dec))) sun_distance = np.mean( source.separation( SkyCoord( get_sun(time + delta_time).ra, get_sun(time + delta_time).dec))) date = ephem.Date(time.value) moon_phase = (date - ephem.previous_new_moon(date)) / ( ephem.next_new_moon(date) - ephem.previous_new_moon(date)) return altaz, delta_time, frame_night, frame_sun_night, moon_distance, sun_distance, moon_phase
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 s2l(solarDate: ephem.Date, location: ephem.Observer, timezone: int) -> LUNAR_contract: solarDate += timezone * ephem.hour # so we are working in the correct timezone lunar_leap = False previousNewMoon = ephem.previous_new_moon(solarDate) lunarDay = solarDate.day - ephem.Date(previousNewMoon).datetime().day + 1 # Dong chi nam truoc previousWinterSolstice = ephem.previous_winter_solstice(solarDate) # Dong chi nam sau nextWinterSolstice = ephem.next_winter_solstice(solarDate) dayInLunarYear = ephem.previous_new_moon( nextWinterSolstice) - ephem.previous_new_moon(previousWinterSolstice) diff = int(dayInLunarYear / 29.) lunarMonth = diff + 11 lunarYear = solarDate.year if dayInLunarYear > 365: lunar_leap = (lunarMonth == find_lunar_month_between( previousWinterSolstice, nextWinterSolstice)) print(dayInLunarYear, previousWinterSolstice, nextWinterSolstice) return tuple(date(lunarYear, lunarMonth, lunarDay), lunar_leap)
def make_moon_stuff(outer_canv, inner_canv, begin_day, no_days, chart, obs): small_moon_rad = 0.12 large_moon_rad = 0.16 moon = ephem.Moon() moon2 = ephem.Moon() for doy in range(no_days) : obs.date = begin_day + doy mpc = obs.date + 0.5 # moon phase check moon_set = obs.next_setting(moon) moon2.compute(moon_set) X = moon2.moon_phase # Waxing moon (moonsets) x, y = to_chart_coord(moon_set, chart) if (fabs(ephem.next_full_moon(mpc) - mpc) < 0.5 or fabs(ephem.previous_full_moon(mpc) - mpc) < 0.5) : # full moon outer_canv.stroke(path.circle(x,y,large_moon_rad),[mooncolorlight,pyx.deco.filled([mooncolorlight])]) elif ((X < 0.55 and X > 0.45) or fabs(ephem.next_first_quarter_moon(mpc) - mpc) < 0.5 or fabs(ephem.previous_first_quarter_moon(mpc) - mpc) < 0.5) : # first quarter outer_canv.stroke(first_quarter_moon(large_moon_rad, x,y),[mooncolordark,pyx.deco.filled([mooncolordark])]) elif (fabs(ephem.next_new_moon(mpc) - mpc) < 0.5 or fabs(ephem.previous_new_moon(mpc) - mpc) < 0.5): # new moon outer_canv.stroke(path.circle(x,y,large_moon_rad),[mooncolorlight,pyx.deco.filled([mooncolordark])]) else : inner_canv.fill(waxing_moon(X, small_moon_rad, x, y), [style.linejoin.bevel,mooncolordark]) # Waning moon (moonrises) moon_rise = obs.next_rising(moon) moon2.compute(moon_rise) X = moon2.moon_phase x, y = to_chart_coord(moon_rise, chart) if (fabs(ephem.next_full_moon(mpc) - mpc) < 0.5 or fabs(ephem.previous_full_moon(mpc) - mpc) < 0.5) : # full moon outer_canv.stroke(path.circle(x,y,large_moon_rad),[mooncolorlight,pyx.deco.filled([mooncolorlight])]) elif ((X < 0.55 and X > 0.45) or fabs(ephem.next_last_quarter_moon(mpc) - mpc) < 0.5 or fabs(ephem.previous_last_quarter_moon(mpc) - mpc) < 0.5) : # last quarter outer_canv.stroke(last_quarter_moon(large_moon_rad, x,y),[mooncolorlight,pyx.deco.filled([mooncolorlight])]) elif (fabs(ephem.next_new_moon(mpc) - mpc) < 0.5 or fabs(ephem.previous_new_moon(mpc) - mpc) < 0.5): # new moon outer_canv.stroke(path.circle(x,y,large_moon_rad),[mooncolorlight,pyx.deco.filled([mooncolordark])]) else : inner_canv.fill(waning_moon(X, small_moon_rad, x, y), [style.linejoin.bevel,mooncolorlight])
def moon_age(now=None): if now is None: now = ephem.now() pmoon = ephem.previous_new_moon(now) nmoon = ephem.next_new_moon(now) deltamoon = nmoon - pmoon since_new = now - ephem.previous_new_moon(now) till_new = now - ephem.next_new_moon(now) print(since_new, deltamoon / 2.0) if since_new > deltamoon / 2.0: age = till_new else: age = since_new return age
def age(self): ''' This function returns the age of the Moon (time since New). @return: The age of the Moon in days. ''' prev_new = ephem.previous_new_moon(self._observer.date) return self._observer.date - prev_new
def moon_info(): "A bit more useful information about the Moon" now = ephem.now() previous_new = ephem.previous_new_moon(now) moon_age = 24 * (now - previous_new) if moon_age <= 72: yield "☽ Young Moon: {:.1f} hours".format(moon_age) else: next_new = ephem.next_new_moon(now) moon_age = 24 * (next_new - now) if moon_age <= 72: yield "☽ Old Moon {:.1f} hours".format(moon_age) # where is the moon now moon.compute(now) distance = miles_from_au(moon.earth_distance) phase = moon.phase # where is the Moon one minute later now += ephem.minute moon.compute(now) ps = "⬆" if moon.phase > phase else "⬇" moved = miles_from_au(moon.earth_distance) - distance ds = "⬆" if moved > 0 else "⬇" mph = abs(60 * moved) yield "☽Phase {:.2f}%{}, {:,.1f} miles, {}{:.1f}mph".format( phase, ps, distance, ds, mph)
def equation_of_time(date): """returns equation of time, the suns transit time, the moons transit-, antitransittime, age and percent illumination """ obs = ephem.Observer() obs.date = date s = ephem.Sun() m = ephem.Moon() s.compute(date) m.compute(date) transs = str(obs.next_transit(s, start=date))[-8:-3] antim = str(obs.next_antitransit(m, start=date))[-8:-3] transm = str(obs.next_transit(m, start=date))[-8:-3] m.compute(date + 0.5) phase = int(round(m.phase)) age = int(round((date + 0.5) - ephem.previous_new_moon(date + 0.5))) s.compute(date - 0.1) obs.date = date - 0.1 eqt00 = ephem.hours(round((obs.next_antitransit(s) - date) * 86400) / 86400 * 2 * math.pi) eqt00 = str(eqt00)[-8:-3] eqt12 = ephem.hours(round((obs.next_transit(s) - (date + 0.5)) * 86400) / 86400 * 2 * math.pi) eqt12 = str(eqt12)[-8:-3] return eqt00, eqt12, transs, transm, antim, age, phase
def get_moon_phase(observer): target_date_utc = observer.date target_date_local = ephem.localtime(target_date_utc).date() next_full = ephem.localtime(ephem.next_full_moon(target_date_utc)).date() next_new = ephem.localtime(ephem.next_new_moon(target_date_utc)).date() next_last_quarter = ephem.localtime( ephem.next_last_quarter_moon(target_date_utc)).date() next_first_quarter = ephem.localtime( ephem.next_first_quarter_moon(target_date_utc)).date() previous_full = ephem.localtime( ephem.previous_full_moon(target_date_utc)).date() previous_new = ephem.localtime( ephem.previous_new_moon(target_date_utc)).date() previous_last_quarter = ephem.localtime( ephem.previous_last_quarter_moon(target_date_utc)).date() previous_first_quarter = ephem.localtime( ephem.previous_first_quarter_moon(target_date_utc)).date() if target_date_local in (next_full, previous_full): return 'Full' elif target_date_local in (next_new, previous_new): return 'New' elif target_date_local in (next_first_quarter, previous_first_quarter): return 'First Quarter' elif target_date_local in (next_last_quarter, previous_last_quarter): return 'Last Quarter' elif previous_new < next_first_quarter < next_full < next_last_quarter < next_new: return 'Waxing Crescent' elif previous_first_quarter < next_full < next_last_quarter < next_new < next_first_quarter: return 'Waxing Gibbous' elif previous_full < next_last_quarter < next_new < next_first_quarter < next_full: return 'Waning Gibbous' elif previous_last_quarter < next_new < next_first_quarter < next_full < next_last_quarter: return 'Waning Crescent'
def phase_on_day(date): nnm = ephem.next_new_moon(date) pnm = ephem.previous_new_moon(date) lunation = (date - pnm) / (nnm - pnm) return lunation
def equation_of_time(date): """returns equation of time, the suns transit time, the moons transit-, antitransittime, age and percent illumination """ obs = ephem.Observer() obs.date = date s = ephem.Sun() m = ephem.Moon() s.compute(date) m.compute(date) transs = str(obs.next_transit(s,start=date))[-8:-3] antim = str(obs.next_antitransit(m,start=date))[-8:-3] transm = str(obs.next_transit(m,start=date))[-8:-3] m.compute(date+0.5) phase = int(round(m.phase)) age = int(round((date+0.5)-ephem.previous_new_moon(date+0.5))) s.compute(date-0.1) obs.date = date-0.1 eqt00 = ephem.hours(round((obs.next_antitransit(s)-date)*86400)/86400*2*math.pi) eqt00 = str(eqt00)[-8:-3] eqt12 = ephem.hours(round((obs.next_transit(s)-(date+0.5))*86400)/86400*2*math.pi) eqt12 = str(eqt12)[-8:-3] return eqt00,eqt12,transs,transm,antim,age,phase
def timeFromNewMoon(self): ''' This function calculates the time from the previous new moon. @returns: The time from new moon in decimal hours. ''' prev_new_moon = ephem.previous_new_moon(self._observer.date) return MoonInfo.DAYS_TO_HOURS * (self._observer.date - prev_new_moon)
def getSunMoon(locationInfo): night = False meteoLocation = ephem.Observer() meteoLocation.lon = str(locationInfo['longitude']) meteoLocation.lat = str(locationInfo['latitude']) meteoLocation.elevation = locationInfo['elevation'] d = datetime.datetime.utcnow() localTime = ephem.localtime(ephem.Date(d)) information("local time: " + str(localTime)) information("universal time: " + str(d)) meteoLocation.date = ephem.Date(d) sun = ephem.Sun(meteoLocation) moon = ephem.Moon(meteoLocation) # information("Sun azimuth: %s altitude: %s"%(sun.az, sun.alt)) altitude = sun.alt * 180 / 3.14125 information("Sun elevation is: %.2f" % altitude) currentDate = ephem.Date(d) timeToNewMoon = ephem.next_new_moon(currentDate) - currentDate timeSinceLastNewMoon = currentDate - ephem.previous_new_moon(currentDate) period = timeToNewMoon + timeSinceLastNewMoon phase = timeSinceLastNewMoon / period information("Moon elevation is: %.2f and illumination is: %.2f" % (moon.alt * 180 / 3.14125, moon.phase)) if altitude < -5: # information("will take night exposure...") night = True results = { "night": night, "sunElevation": altitude, "moonIllumination": moon.phase, "moonElevation": (moon.alt * 180 / 3.14125) } return results
def get_phase_on_day(): """Returns a symbolic value and name for the current moon phase""" date=ephem.Date(datetime.datetime.now()) nnm = ephem.next_new_moon (date) pnm = ephem.previous_new_moon(date) lunation=(date-pnm)/(nnm-pnm) if lunation >= 0 and lunation <= 0.125: return "🌚 new" elif lunation >= 0.126 and lunation <= 0.25: return "🌒 waxing crescent" elif lunation >= 0.26 and lunation <= 0.375: return "🌓 first quarter" elif lunation >= 0.376 and lunation <= 0.5: return "🌔 waxing gibbous" elif lunation >= 0.51 and lunation <= 0.625: return lunation return "� full" elif lunation >= 0.626 and lunation <= 0.75: return "🌖 waning gibbous" elif lunation >= 0.76 and lunation <= 0.875: return "🌗 last quarter" elif lunation >= 0.876 and lunation <= 1.0: return "🌘 waning crescent"
def get_phase_on_day(year, month, day): date = ephem.Date(datetime.date(year, month, day)) nnm = ephem.next_new_moon(date) pnm = ephem.previous_new_moon(date) lunation = (date - pnm) / (nnm - pnm) return lunation
def __init__(self): self.__logger = logging.getLogger(self.__class__.__name__) #find current moon phase now = ephem.now() new_date = ephem.next_new_moon(now) first_quarter_date = ephem.next_first_quarter_moon(now) full_date = ephem.next_full_moon(now) last_quarter_date = ephem.next_last_quarter_moon(now) delta = float('inf') if new_date - now < delta: delta = new_date - now self.__current_phase = MoonUpdater.LAST_QUARTER_MOON self.__current_phase_date = ephem.previous_last_quarter_moon( now).datetime() if first_quarter_date - now < delta: delta = first_quarter_date - now self.__current_phase = MoonUpdater.NEW_MOON self.__current_phase_date = ephem.previous_new_moon(now).datetime() if full_date - now < delta: delta = full_date - now self.__current_phase = MoonUpdater.FIRST_QUARTER_MOON self.__current_phase_date = ephem.previous_first_quarter_moon( now).datetime() if last_quarter_date - now < delta: delta = last_quarter_date - now self.__current_phase = MoonUpdater.FULL_MOON self.__current_phase_date = ephem.previous_full_moon( now).datetime()
def SunMoonInfo(Long, Lat, Elev, GMT_hours, f): #lookup coords from table Observatories #todo: add observatory elevation moon = ephem.Moon() moon.compute(ephem.now()) observer = ephem.Observer() observer.lon, observer.lat, observer.elevation = Long, Lat, Elev #'-87:49:55','42:08:09' #calc twilight by specifying below true horizon observer.horizon = '-9' #value I use for sky brightness cutoff t1 = observer.previous_rising(ephem.Sun()) + (GMT_hours / 24.) t2 = observer.next_setting(ephem.Sun()) + (GMT_hours / 24.) twilight_morn = cleanup(str(ephem.Date(t1))) twilight_eve = cleanup(str(ephem.Date(t2))) #calc actual sunrise/set using true horizon observer.horizon = '0' s1 = observer.previous_rising(ephem.Sun()) + (GMT_hours / 24.) s2 = observer.next_setting(ephem.Sun()) + (GMT_hours / 24.) sunrise = cleanup(str(ephem.Date(s1))) sunset = cleanup(str(ephem.Date(s2))) #CHANGE ALL THIS TO WRITE TO FILE FOR THIS OBSERVATORY: use f.write(html stuff) ************************ f.write("<p> </p>\n") f.write('<p class="courier">' + HardSpaces("Twilight: " + twilight_morn) + "</p>\n") f.write('<p class="courier">' + HardSpaces("Sunrise: " + sunrise) + "</p>\n") f.write('<p class="courier">' + HardSpaces("Sunset: " + sunset) + "</p>\n") f.write('<p class="courier">' + HardSpaces("Twilight: " + twilight_eve) + "</p>\n") f.write("<p> </p>\n") m1 = observer.previous_rising(ephem.Moon()) + (GMT_hours / 24.) m2 = observer.next_setting(ephem.Moon()) + (GMT_hours / 24.) m3 = ephem.previous_new_moon(ephem.now()) + (GMT_hours / 24.) f.write('<p class="courier">' + HardSpaces("Moonrise: " + cleanup(str(ephem.Date(m1)))) + "\n") f.write('<p class="courier">' + HardSpaces("Moonset: " + cleanup(str(ephem.Date(m2)))) + "\n") f.write('<p class="courier">' + "Moon age: " + str(ephem.now() - ephem.previous_new_moon(ephem.now()))[0:4] + " days, %2.0f%% illuminated" % moon.phase + "</p>\n") #f.write( "New Moon: " + str(ephem.Date(m3))[0:10] + "\n") f.write("<p> </p>\n")
def age(self): ''' This function returns the age of the Moon (time since New). @return: The age of the Moon in days. ''' prev_new = ephem.previous_new_moon(self._observer.date) age = self._observer.date - prev_new return utils.StrFmt.floatString(age, 2)
def getStart(self, year): start = ephem.date(str(year) + '/1/1') start = ephem.next_vernal_equinox(start) start = ephem.previous_new_moon(start) self.location.date = start moon.compute(self.location) start = self.location.next_rising(moon) return start
def moonphase(self, MJD): ephemdate = ephem.Date((Time(MJD, format = 'mjd', scale = 'utc').isot).replace("T", " ")) ephemnextnewmoon = ephem.next_new_moon(ephemdate) ephempreviousnewmoon = ephem.previous_new_moon(ephemdate) moonphase = min(ephemnextnewmoon - ephemdate, ephemdate - ephempreviousnewmoon) return moonphase
def age(self): """The moon's age in days. Returns ------- float """ prev_new = ephem.previous_new_moon(self.observer.date) return self.observer.date - prev_new
def equation_of_time(date): # used in twilighttab (section 3) # returns equation of time, the sun's transit time, # the moon's transit-, antitransit-time, age and percent illumination. # (Equation of Time = Mean solar time - Apparent solar time) py_date = date.tuple() py_obsdate = datetime.date(py_date[0], py_date[1], py_date[2]) d = ephem.date(date - 30 * ephem.second) obs = ephem.Observer() obs.date = d ephem_sun.compute(d) ephem_moon.compute(d) transs = '--:--' antim = '--:--' transm = '--:--' next_s_tr = obs.next_transit(ephem_sun, start=d) if next_s_tr - obs.date < 1: transs = hhmm(next_s_tr) next_m_atr = obs.next_antitransit(ephem_moon, start=d) if next_m_atr - obs.date < 1: antim = hhmm(next_m_atr) next_m_tr = obs.next_transit(ephem_moon, start=d) if next_m_tr - obs.date < 1: transm = hhmm(next_m_tr) #----------------------------- obs = ephem.Observer() obs.date = date ephem_moon.compute(date + 0.5) pct = int(round(ephem_moon.phase)) # percent of moon surface illuminated age = int(round((date + 0.5) - ephem.previous_new_moon(date + 0.5))) phase = ephem_moon.elong.norm + 0.0 # moon phase as float (0:new to π:full to 2π:new) ephem_sun.compute(date - 0.1) obs.date = date - 0.1 # round to the second; convert back to days x = round( (obs.next_antitransit(ephem_sun) - date) * 86400) * 2 * math.pi / 86400 eqt00 = ephem.hours(x) eqt00 = str(eqt00)[-8:-3] if x >= 0: eqt00 = r"\colorbox{{lightgray!80}}{{{}}}".format(eqt00) y = round((obs.next_transit(ephem_sun) - (date + 0.5)) * 86400) * 2 * math.pi / 86400 eqt12 = ephem.hours(y) eqt12 = str(eqt12)[-8:-3] if y >= 0: eqt12 = r"\colorbox{{lightgray!80}}{{{}}}".format(eqt12) return eqt00, eqt12, transs, transm, antim, age, pct
def extract_year(target_year, point, lat, lon): url = "https://www.data.jma.go.jp/gmd/kaiyou/data/db/tide/suisan/txt/" + \ str(target_year) + "/" + point + ".txt" data = {} with urllib.request.urlopen(url) as response: for line in response: strline = line.decode("utf-8") date_data = {} month = int(strline[74:76].strip()) year = int("20" + strline[72:74].strip()) day = int(strline[76:78].strip()) # point = strline[78:80] tidedata = strline[0:72] date_data["tide"] = [ int(tidedata[i * 3:i * 3 + 3]) for i in range(len(tidedata) // 3) ] high_data = strline[80:108] high_time = [ high_data[i * 7:i * 7 + 2] + ":" + high_data[i * 7 + 2:i * 7 + 4] for i in range(2) ] date_data["high_time"] = [ "--:--" if i == "99:99" else i.replace(" ", "0") for i in high_time ] high_tide = [high_data[i * 7 + 4:i * 7 + 7] for i in range(2)] date_data["high_tide"] = [ "--" if i == "999" else int(i) for i in high_tide ] low_data = strline[108:136] low_time = [ low_data[i * 7:i * 7 + 2] + ":" + low_data[i * 7 + 2:i * 7 + 4] for i in range(2) ] date_data["low_time"] = [ "--:--" if i == "99:99" else i.replace(" ", "0") for i in low_time ] low_tide = [low_data[i * 7 + 4:i * 7 + 7] for i in range(2)] date_data["low_tide"] = [ "--" if i == "999" else int(i) for i in low_tide ] here = ephem.Observer() here.lat, here.lon = str(lat), str(lon) here.date = datetime(year, month, day, 3) # noon JST sun = ephem.Sun() date_data["sunrise"] = ephem.localtime( here.previous_rising(sun)).strftime("%H:%M") date_data["sunset"] = ephem.localtime( here.next_setting(sun)).strftime("%H:%M") moon_age = here.date - ephem.previous_new_moon(here.date) date_data["tidetype"] = convert_tidetype_into_moonage(moon_age) date_data["date"] = datetime(year, month, day).strftime("%m/%d") data[datetime(year, month, day).strftime("%Y/%m/%d")] = date_data return data
def _phase(self, offset=None): # offset in minutes date = datetime.datetime.utcnow() cycle = 29.530588861 if offset: date += dateutil.relativedelta.relativedelta(minutes=offset) self._obs.date = date self._orb.compute(self._obs) last = ephem.previous_new_moon(self._obs.date) frac = (self._obs.date - last) / cycle return int(round(frac * 8))
def fractional_age(self): """The moon's fractional age. Always less than 1.0. Returns ------- float """ prev_new = ephem.previous_new_moon(self.observer.date) next_new = ephem.next_new_moon(self.observer.date) return (self.observer.date - prev_new) / (next_new - prev_new)
def time_from_new_moon(self): """The time (hours) from the previous new moon. This function calculates the time from the previous new moon. Returns ------- float """ previous_new_moon = ephem.previous_new_moon(self.observer.date) return MoonInfo.DAYS_TO_HOURS * (self.observer.date - previous_new_moon)
def getMoonPhase( n ): '''Returns the current moon phase as a percentage, starting from the new moon.''' datetime = n.format( ) previous = RPNDateTime.convertFromEphemDate( ephem.previous_new_moon( datetime ) ) next = RPNDateTime.convertFromEphemDate( ephem.next_new_moon( datetime ) ) cycle = next - previous current = n - previous return current.total_seconds( ) / cycle.total_seconds( )
def get_phase_on_day(year, month, day): """Returns a floating-point number from 0-1. where 0=new, 0.25 = first_quarter, 0.5=full, 0.75 = last_quarter, 1=new""" date = ephem.Date(datetime.date(year, month, day)) nnm = ephem.next_new_moon(date) pnm = ephem.previous_new_moon(date) lunation = (date - pnm) / (nnm - pnm) return lunation
def process_plan (target_list, time_string=''): #declare observing sites observatory = ephem.Observer() observatory.lat = observer_latitude observatory.lon = observer_logitude observatory.elev = observer_elevation observatory.pressure = 0 if time_string != '': observatory.date = ephem.Date(time_string)- (observer_timezone * ephem.hour) moon = ephem.Moon() moon.compute(observatory) ###### Reporting Section print "Report for: %s " %(ut_to_local_string(observatory.date)) print "---------------------------------" observatory.horizon = '-18' moon_days = observatory.date - ephem.previous_new_moon(observatory.date) print "Astronomical twilight:\n\tNext ending: %s" %(ut_to_local_string(observatory.next_setting(ephem.Sun(),use_center=True))) print "\tNext beginning: %s" %(ut_to_local_string(observatory.next_rising(ephem.Sun(),use_center=True))) print "Moon age: %3.2f days -- Ilumination: %3.1f%%" % (moon_days, moon.phase) print "\tNext Moon rise: %s" % (ut_to_local_string(observatory.next_rising(moon))) print "\tNext Moon set: %s" % (ut_to_local_string(observatory.next_setting(moon))) observatory.horizon = '0' print "---------------------------------\n" for target in target_list: varstar = plan_to_ephem(target) varstar.compute(observatory) print "Target: %s" %(varstar.name) try: print "Altitude: %3.2f" % (math.degrees(varstar.alt)) print "Azimuth: %3.2f" % (math.degrees(varstar.az)) print "Next rise: %s" % (ut_to_local_string(observatory.next_rising(varstar))) print "Next set: %s" % (ut_to_local_string(observatory.next_setting(varstar))) except ephem.AlwaysUpError: print "Object is circumpolar" except ephem.NeverUpError: print "*** Transit is below horizon ***" transit = observatory.next_transit(varstar) print "Next transit: %s " % (ut_to_local_string(transit)) temp_date = observatory.date observatory.date = transit varstar.compute(observatory) moon.compute(observatory) print "Transit altitude: %3.2f deg" % (math.degrees(varstar.alt)) print "Lunar separation: %s" % (ephem.separation(varstar, moon)) observatory.date = temp_date print "\n"
def _generate_moon(self, year, month, day): date = ephem.Date(datetime.date(year, month, day)) preceding_new_moon = ephem.previous_new_moon(date) following_new_moon = ephem.next_new_moon(date) lunation = (date - preceding_new_moon) / (following_new_moon - preceding_new_moon) VIEW_BOX_SIZE = 100 return '<svg width="100%" viewBox="0 0 {0} {0}">{1}</svg>'.format( VIEW_BOX_SIZE, self._make_path(lunation, VIEW_BOX_SIZE))
def get_moon_phase_on_day(dtime): '''Returns a floating-point number from 0-1. where 0=new, 0.5=full, 1=new''' date = ephem.Date(dtime) #print(date) nnm = ephem.next_new_moon(date) pnm = ephem.previous_new_moon(date) #print("Prev ", pnm) #print("Next ", nnm) lunation = (date - pnm) / (nnm - pnm) return lunation
def compute_ephem(line1, line2, line3, time, time_step): #This function returns the time of the ephemeris (dtime), the ephemeris #of the satellite (Sc.ra.deg, Sc.dec.deg) (RA, DEC, elevation), whether the #satellite is in eclipse (e) (0=no,1=yes), the ephemeris of the moon #(Mc.ra.deg, Mc.dec.deg) (RA, DEC), the ephemeris of the sun (Suc.ra.deg, #Suc.dec.deg) (RA, DEC), and lunar phase (mp) (radians; 0=full, +/-pi = #new). All ephemerides are given in geocentric coordinates. import numpy as np from datetime import datetime, timedelta import math import ephem from astropy import units as u from astropy.coordinates import SkyCoord dt = time + timedelta(minutes = time_step) #Compute satellite and moon ephemerides sat_ephem = ephem.readtle(line1, line2, line3) sat_ephem.compute(dt) m = ephem.Moon(dt) m.compute(dt) su = ephem.Sun(dt) su.compute(dt) #Print ephemerides for manual checking. #print('Moon: %s %s' % (m.g_ra, m.g_dec)) #print('Sun: %s %s' % (su.g_ra, su.g_dec)) #print('Sat: %s %s' % (sat_ephem.a_ra, sat_ephem.a_dec)) #Convert ephemeris to degrees Sc = SkyCoord(str(sat_ephem.a_ra) + ' ' + str(sat_ephem.a_dec), unit=(u.hourangle, u.deg)) Mc = SkyCoord(str(m.g_ra) + ' ' + str(m.g_dec), unit=(u.hourangle, u.deg)) Suc = SkyCoord(str(su.g_ra) + ' ' + str(su.g_dec), unit=(u.hourangle, u.deg)) #Compute lunar phase in absolute phase angle (radians) dtime = ephem.Date(dt) nnm = ephem.next_new_moon (dtime) pnm = ephem.previous_new_moon(dtime) lunation=(dtime-pnm)/(nnm-pnm) mp = abs(lunation - 0.5)*2*math.pi #Determine if satellite is in eclipse if sat_ephem.eclipsed == False: e = 0 if sat_ephem.eclipsed == True: e = 1 #Returnt calculated values as a 10-element list return([dtime, Sc.ra.deg, Sc.dec.deg, sat_ephem.elevation, e, Mc.ra.deg, Mc.dec.deg, Suc.ra.deg, Suc.dec.deg, mp])
def getMoonPhase( n ): if not isinstance( n, RPNDateTime ): raise ValueError( '\'moon_phase\' expects a date-time argument' ) datetime = n.to( 'utc' ).format( ) previous = RPNDateTime.convertFromEphemDate( ephem.previous_new_moon( datetime ) ).getLocalTime( ) next = RPNDateTime.convertFromEphemDate( ephem.next_new_moon( datetime ) ).getLocalTime( ) cycle = next - previous current = n - previous return current.total_seconds( ) / cycle.total_seconds( )
def cycle_pour_jour(date_string): """ In: une date sous forme de string Out: la place du jour dans un cycle lunaire sur 28 jours """ splitted_date_string = date_string.split("/") jour = int(splitted_date_string[0]) mois = int(splitted_date_string[1]) an = int(splitted_date_string[2]) date = ephem.Date(datetime.date(an, mois, jour)) nnm = ephem.next_new_moon(date) pnm = ephem.previous_new_moon(date) lunation = (date - pnm) / (nnm - pnm) return lunation * 28
def moon_age(self, timestamp): """Return the age of the moon at the given time.""" d1 = pyEphem.next_new_moon(timestamp).datetime() d2 = pyEphem.previous_new_moon(timestamp).datetime() # Check format of provided time. If it wasn't a timestamp, make it one. if isinstance(timestamp, datetime.datetime) is False: timestamp = timestamp.datetime() # Find the total time since new moon and then convert to days if (d1 - timestamp) < (timestamp - d2): return (timestamp - d1).total_seconds() / 3600. / 24. else: return (timestamp - d2).total_seconds() / 3600. / 24.
def getMoonPhase( n ): '''Returns the current moon phase as a percentage, starting from the new moon.''' if not isinstance( n, RPNDateTime ): raise ValueError( '\'moon_phase\' expects a date-time argument' ) datetime = n.format( ) previous = RPNDateTime.convertFromEphemDate( ephem.previous_new_moon( datetime ) ) next = RPNDateTime.convertFromEphemDate( ephem.next_new_moon( datetime ) ) cycle = next - previous current = n - previous return current.total_seconds( ) / cycle.total_seconds( )
def moonAge(time): """Return the age of the moon at the given time.""" d1 = pyEphem.next_new_moon(time).datetime() d2 = pyEphem.previous_new_moon(time).datetime() # Check to see if the time was already a datetime. If not, # make it one if isinstance(time, datetime.datetime) is False: time = time.datetime() if (d1 - time) < (time - d2): return abs((d1 - time).total_seconds() / 3600. / 24.) else: return ((time - d2).total_seconds() / 3600. / 24.)
def _phase(self, offset=None): """ Applies only for moon, returns the moon phase related to a cycle of approx. 29.5 days for the current time plus an offset :param offset: an offset given in minutes """ date = datetime.datetime.utcnow() cycle = 29.530588861 if offset: date += dateutil.relativedelta.relativedelta(minutes=offset) self._obs.date = date self._orb.compute(self._obs) last = ephem.previous_new_moon(self._obs.date) frac = (self._obs.date - last) / cycle return int(round(frac * 8))
def PrintGeneralInfo(): moon = ephem.Moon() moon.compute(ephem.now()) observer = ephem.Observer() observer.lon, observer.lat = '-87:49:55', '42:08:09' observer.horizon = '-9' #value I use for sky brightness cutoff twilight_morn = cleanup( str(ephem.localtime(observer.previous_rising(ephem.Sun())))) twilight_eve = cleanup( str(ephem.localtime(observer.next_setting(ephem.Sun())))) observer.horizon = '0' sunrise = cleanup( str(ephem.localtime(observer.previous_rising(ephem.Sun())))) sunset = cleanup(str(ephem.localtime(observer.next_setting(ephem.Sun())))) print(" ") print("Twilight: " + twilight_morn) print("Sunrise: " + sunrise) print("Sunset: " + sunset) print("Twilight: " + twilight_eve) print(" ") print( "Moonrise: " + cleanup(str(ephem.localtime(observer.previous_rising(ephem.Moon()))))) print("Moonset: " + cleanup(str(ephem.localtime(observer.next_setting(ephem.Moon()))))) print("Moon age: " + str(ephem.now() - ephem.previous_new_moon(ephem.now()))[0:4] + " days, %2.0f%% illuminated" % moon.phase) print("New Moon: " + str(ephem.localtime(ephem.previous_new_moon(ephem.now())))[0:10]) print('(all times local Chgo)\n\n')
def _get_phase_on_day(self, date = datetime.date.today()): '''Returns a floating-point number from 0-1. where 0=new, 0.5=full, 1=new''' #Ephem stores its date numbers as floating points, which the following uses #to conveniently extract the percent time between one new moon and the next #This corresponds (somewhat roughly) to the phase of the moon. #Use Year, Month, Day as arguments date=ephem.Date(date) nnm = ephem.next_new_moon (date) pnm = ephem.previous_new_moon(date) lunation=(date-pnm)/(nnm-pnm) #Note that there is a ephem.Moon().phase() command, but this returns the #percentage of the moon which is illuminated. This is not really what we want. return lunation
def get_current_moon_phase(): """ Get the current moon phase """ # get the dates of the last and next new moon moon_observer.date = datetime.now() phase_end = ephem.next_new_moon(moon_observer.date) phase_start = ephem.previous_new_moon(moon_observer.date) # based on that figure out what part of the phase we are in. Phase goes from [0,1) phase = (moon_observer.date - phase_start) / (phase_end - phase_start) # 8 moon phases, so do this for easy indexing phase *= 8 # round to the nearest phase and wrap aroudn for the 7.5-7.9 range mapping to 0 phase = round(phase) % 8 return "The current moon phase is {0}".format(moon_phases[int(phase)])
def calculate_moon_phase(self): m = ephem.Moon() m.compute(self.observer) nnm = ephem.next_new_moon(self.observer.date) pnm = ephem.previous_new_moon(self.observer.date) # for use w. moon_phases.ttf A -> just past newmoon, # Z just before newmoon # '0' is full, '1' is new # note that we cannot use m.phase as this is the percentage of the moon # that is illuminated which is not the same as the phase! lunation = (self.observer.date - pnm) / (nnm - pnm) symbol = lunation * 26 # print("Lunation as a 1/26 is: %f" % symbol) if symbol < 0.5 or symbol > 25.5: symbol = '*' # new moon else: symbol = chr(ord('A') + int(symbol + 0.5) - 1) return symbol
def get_lunation_day(today, number_of_phase_ids=28): '''Given a date (of type ephem.Date), return a lunar cycle day ID number (integer in [0:(number_of_phase_ids - 1)]), corresponding to the lunation for the given date. 0 = new moon. Arguments: today (ephem.date): the date for which to get the lunation day number Optional: number_of_phase_ids (integer, default = 28): the number of unique lunar cycle day identifiers, e.g. the number of moon phase icons available to display the lunation each day. Returns: integer in range(0, number_of_phase_ids - 1), today's lunation phase ID number. The lunation day is calibrated to the quarter phases calculated by pyephem, but it does not always agree exactly with percent illumination, which is a different calculation entirely.''' last_new = ephem.previous_new_moon(today) next_new = ephem.next_new_moon(today) num = number_of_phase_ids - 1 first_approx = round((today - last_new) / (next_new - last_new) * num) if first_approx < np.ceil(num / 4): next_fq = ephem.next_first_quarter_moon(last_new) if today < next_fq: return round((today - last_new) / (next_fq - last_new) * (num / 4)) if first_approx < np.ceil(num / 2): next_full = ephem.next_full_moon(last_new) if today < next_full: return round((today - last_new) / (next_full - last_new) * (num / 2)) if first_approx < np.ceil(num * 3 / 4): next_lq = ephem.next_last_quarter_moon(last_new) if today < next_lq: return round((today - last_new) / (next_lq - last_new) * (num * 3 / 4)) return first_approx
def main(observer): date = ephem.now() moon = ephem.Moon(date) # Young or old Moon (within 72 hours of new) previous_new = ephem.previous_new_moon(date) age = 24 * (date - previous_new) if age <= 72: print("Young Moon: {:.1f} hours".format(age)) else: next_new = ephem.next_new_moon(date) age = 24 * (next_new - date) if age <= 72: print("Old Moon: {:.1f} hours".format(age)) print("Phase {0.moon_phase:.2%}".format(moon)) distance = miles_from_au(moon.earth_distance) moon.compute(ephem.Date(date + ephem.hour)) moved = miles_from_au(moon.earth_distance) - distance print( 'Earth distance: {:13,.0f} miles, {:+5.0f} mph'.format( distance, moved)) observer.date = date moon.compute(observer) m2 = moon.copy() distance = miles_from_au(moon.earth_distance) observer.date = ephem.Date(date + ephem.hour) moon.compute(observer) moved = miles_from_au(moon.earth_distance) - distance print( 'Observer distance: {:13,.0f} miles, {:+5.0f} mph'.format( distance, moved)) print("Azimuth {}".format(_(m2.az))) print("Altitude {}".format(_(m2.alt))) print("Declination {}".format(_(m2.dec))) print("\n") for event in moon_phase_events(): print(str(event))
def sf_sun_moon(date): sf = ep.Observer() #sf.pressure = 0 #sf.horizon = '-0:34' sf.lat, sf.lon = '37.46', '-122.26' sf.date = date + ' 20:00' # noon PST sun_rise = (sf.previous_rising(ep.Sun())) sun_set = (sf.next_setting(ep.Sun())) sf.date = date + ' 09:00' # 1am PST moon_rise = (sf.previous_rising(ep.Moon())) # print 'mrise', moon_rise moon_set = (sf.next_setting(ep.Moon())) # print 'mset', moon_set sun = ep.localtime(sun_set) - ep.localtime(sun_rise) sun_min = sun.total_seconds() / 60 moon = ep.localtime(moon_set) - ep.localtime(moon_rise) # print 'moon', moon moon_min = moon.total_seconds() / 60 # print 'moonmin', moon_min nnm = ep.next_new_moon(date) pnm = ep.previous_new_moon(nnm) lunation=(sf.date-pnm)/(nnm-pnm) return sun_min, lunation
gatech = ephem.Observer() gatech.lon = '-84.39733' gatech.lat = '33.775867' gatech.elevation = 320 gatech.date = '1984/5/30 16:22:56' v = ephem.Venus(gatech) print v.alt, v.az m = ephem.Moon('1980/6/1') print ephem.constellation(m) print ephem.delta_t('1980') ephem.julian_date('2000/1/1') print ephem.previous_new_moon(ephem.now()) print ephem.next_new_moon(ephem.now()) # localtime print ephem.localtime(ephem.next_new_moon(ephem.now())) print ephem.previous_full_moon(ephem.now()) print ephem.next_full_moon(ephem.now()) # localtime print ephem.localtime(ephem.next_full_moon(ephem.now())) rigel = ephem.star('Rigel') print rigel._ra, rigel._dec # astronomical constants print ephem.meters_per_au print ephem.earth_radius
output = True JSON = False if arg.json: output = False JSON = True if arg.date == 'now': currentDate = ephem.Date(datetime.datetime.utcnow()) else: currentDate = ephem.Date(arg.date) if output: print currentDate moon.compute(currentDate) if output: print "Illuminated:", moon.phase if output: print "Next new moon:", ephem.next_new_moon(currentDate) timeToNewMoon = ephem.next_new_moon(currentDate) - currentDate timeSinceLastNewMoon = currentDate - ephem.previous_new_moon(currentDate) period = timeToNewMoon + timeSinceLastNewMoon phase = timeSinceLastNewMoon / period if output: print timeSinceLastNewMoon, phase print timeToNewMoon if phase>0.5: mode = "waning" else: mode = "waxing" if output: print "%1.0f%% illuminated, %s"%(moon.phase, mode) if JSON: response = {} response['illuminated'] = moon.phase
sunset = observer.next_setting (ephem.Sun()) #Sunset data['sunrise'] = str(ephem.localtime(sunrise)) data['noon'] = str(ephem.localtime(noon)) data['sunset'] = str(ephem.localtime(sunset)) # observer.horizon = '-6' # civil twilight # civilian_twilight_start = observer.previous_rising(ephem.Sun()) # civilian_twilight_end = observer.next_setting(ephem.Sun()) # observer.horizon = '-12' # nautical twilight # nautical_twilight_start = observer.previous_rising(ephem.Sun()) # nautical_twilight_end = observer.next_setting(ephem.Sun()) # observer.horizon = '-18' # astronomical twilight # astronomical_twilight_start = observer.previous_rising(ephem.Sun()) # astronomical_twilight_end = observer.next_setting(ephem.Sun()) data['moon'] = {} data['moon']['radius'] = ephem.moon_radius data['moon']['previous_new_moon'] = str(ephem.localtime(ephem.previous_new_moon(time))) data['moon']['next_new_moon'] = str(ephem.localtime(ephem.next_new_moon(time))) data['moon']['previous_first_quarter_moon'] = str(ephem.localtime(ephem.previous_first_quarter_moon(time))) data['moon']['next_first_quarter_moon'] = str(ephem.localtime(ephem.next_first_quarter_moon(time))) data['moon']['previous_full_moon'] = str(ephem.localtime(ephem.previous_full_moon(time))) data['moon']['next_full_moon'] = str(ephem.localtime(ephem.next_full_moon(time))) data['moon']['previous_last_quarter_moon'] = str(ephem.localtime(ephem.previous_last_quarter_moon(time))) data['moon']['next_last_quarter_moon'] = str(ephem.localtime(ephem.next_last_quarter_moon(time))) print json.dumps(data)
def moonphase(year, month, day, do_print=False): h = year // 100 # integer division for the century yy = year % 100 # year within the century # The "golden number" for this year is the year modulo 19, but # adjusted to be centered around 0 -- i.e., -9 to 9 instead # of 0 to 19. This improves the accuracy of the approximation # to within +/- 1 day. g = (yy + 9) % 19 - 9 # There is an interesting 6 century near-repetition in the # century correction. It would be interesting to find a # algorithm that handles the different corrections between # centuries 17|23|29, 20|26, 21|27, and 24|30. try: c = {17:7, 18:1, 19:-4, 20:-8, 21:16, 22:11, 23:6, 24:1, 25:-4, 26:-9, 27:15, 28:11, 29:6, 30:0}[h] except KeyError: print("No century correction available for {}00-{}99".format(h,h)) return # Golden number correction: modulo 30, from -29 to 29. gc = g * 11 while ( gc < -29 ): gc += 30; if (gc > 0): gc %= 30; # January/February correction: if month < 3: mc = 2 else: mc = 0 phase = (month + mc + day + gc + c + 30 ) % 30 if (do_print): # It's nice to see what the Golden correction for the year # plus the century correction is. This lets us quickly calculate the # correction for any other date in the same year. gcpc = (gc + c) % 30 if gcpc <= 0: gcpc_alt = gcpc + 30 else: gcpc_alt = gcpc - 30 print("yy =", yy) print("g =", g) print("month + day + mc =", month + day + mc) print("gc =", gc) print("c =", c) print("Dates in the year", year, "have moon phase correction gc + c =", gcpc, "or", gcpc_alt) print(("\n\t{:04}/{:02}/{:02} has " "estimated moon phase = {}\n").format(year, month, day, phase)) if phase < 2: print("\tNew moon [or slightly after]") elif phase < 7: print("\tWaxing crescent") elif phase < 9: print("\tFirst quarter") elif phase < 14: print("\tWaxing gibbous") elif phase < 16: print("\tFull moon") elif phase < 22: print("\tWaning gibbous") elif phase < 24: print("\tLast quarter") elif phase < 29: print("\tWaning (de)crescent") elif phase < 31: print("\tNew moon [or slightly before]") try: # If you have the ephem package installed, you # can compare the estimate to the actual lunar phase import ephem thisdate = ephem.Date('{:04}/{:02}/{:02} 00:00:01'.format(year, month, day)) prevmoon = ephem.previous_new_moon(thisdate) nextmoon = ephem.next_new_moon(thisdate) prevfull = ephem.previous_full_moon(thisdate) nextfull = ephem.next_full_moon(thisdate) prevymd = prevmoon.tuple()[:3] nextymd = nextmoon.tuple()[:3] pfymd = prevfull.tuple()[:3] nfymd = nextfull.tuple()[:3] print("\n\t{}".format(prevmoon), "UTC = Previous New Moon") print("\t{}".format(nextmoon), "UTC = Next New Moon") print("\t{}".format(prevfull), "UTC = Previous Full Moon") print("\t{}".format(nextfull), "UTC = Next Full Moon") try: from convertdate import julianday thisjdc = julianday.from_gregorian(year, month, day) prevjdc = julianday.from_gregorian(*prevymd) nextjdc = julianday.from_gregorian(*nextymd) pfjdc = julianday.from_gregorian(*pfymd) nfjdc = julianday.from_gregorian(*nfymd) print("\t{:2} days since prev new moon".format(int(thisjdc - prevjdc))) print("\t{:2} days until next new moon".format(int(nextjdc - thisjdc))) print("\t{:2} days since prev full moon".format(int(thisjdc - pfjdc))) print("\t{:2} days until next full moon".format(int(nfjdc - thisjdc))) except: print("julianday doesn't work") pass except: pass try: # If you have convertdate installed, you can compare the lunar # phase to the hebrew calendar date: from convertdate import hebrew hyear, hmonth, hday = hebrew.from_gregorian(year, month, day) print("\n\tHebrew date = {} {}, {}\n".format( hday, hmonths[hmonth], hyear )) except: pass return phase
def main(): sun = ephem.Sun() moon = ephem.Moon() # define observer home = ephem.Observer() home.date = ephem.date(datetime.utcnow()) home.lat, home.lon = '50.46', '9.61' sun.compute(home) sunrise, sunset = (home.next_rising(sun), home.next_setting(sun)) moon.compute(home) moonrise, moonset = (home.next_rising(moon), home.next_setting(moon)) home.horizon = '-6' m6_start, m6_end = (home.next_rising(sun, use_center=True), home.next_setting(sun, use_center=True)) home.horizon = '-12' m12_start, m12_end = (home.next_rising(sun, use_center=True), home.next_setting(sun, use_center=True)) home.horizon = '-18' m18_start, m18_end = (home.next_rising(sun, use_center=True), home.next_setting(sun, use_center=True)) print home.date e = {} e[sunrise] = " Sunrise: " e[sunset] = " Sunset: " e[moonrise] = " Moonrise: " e[moonset] = " Moonset: " e[m6_start] = " Civil twilight starts: " e[m6_end] = " Civil twilight ends: " e[m12_start] = " Nautical twilight starts: " e[m12_end] = " Nautical twilight ends: " e[m18_start] = " Astronomical twilight starts: " e[m18_end] = " Astronomical twilight ends: " for time in sorted(e.keys()): print e[time], ephem.localtime(time).ctime() # Here start the moon specific data print " ---" print " Moon phase: %d%% " % moon.phase e = {} e1 = ephem.previous_new_moon(home.date) e[e1] = " Previous new moon: " e1 = ephem.previous_first_quarter_moon(home.date) e[e1] = " Previous first quarter moon: " e1 = ephem.previous_full_moon(home.date) e[e1] = " Previous full moon: " e1 = ephem.previous_last_quarter_moon(home.date) e[e1] = " Previous last quarter moon: " e1 = ephem.next_new_moon(home.date) e[e1] = " Next new moon: " e1 = ephem.next_first_quarter_moon(home.date) e[e1] = " Next first quarter moon: " e1 = ephem.next_full_moon(home.date) e[e1] = " Next full moon: " e1 = ephem.next_last_quarter_moon(home.date) e[e1] = " Next last quarter moon: " for time in sorted(e.keys()): print e[time], ephem.localtime(time).ctime()
def add_ephem_data_to_header(hdr, time_overwrite, debug=False): logger = logging.getLogger("SunMoonData") logger_debug = logger.debug if (debug): logger_debug = logger.info # # Read in the target coordinates # ra = hdr['RA'] dec = hdr['DEC'] target = ephem.Equatorial(hdr['RA'], hdr['DEC']) # # Convert the timing information from the header # into a format that pyephem understands # date_format = "%Y-%m-%dT%H:%M:%S.%f" ephem_format = "%Y/%m/%d %H:%M:%S" time_format = "%H:%M:%S.%f" expmeas = hdr['EXPMEAS'] if 'EXPMEAS' in hdr \ else hdr['EXPTIME'] date_string = hdr['DATE-OBS'] if time_overwrite is None else time_overwrite date_obs = datetime.datetime.strptime(date_string, date_format) date_mid = date_obs + datetime.timedelta(seconds=(0.5*expmeas)) date_end = date_obs + datetime.timedelta(seconds=expmeas) mjd = hdr['MJD-OBS'] time_difference = 7*ephem.hour # # Create objects for sun, moon, and WIYN # sun = ephem.Sun() moon = ephem.Moon() wiyn = ephem.Observer() wiyn.lat = wiyn_lat wiyn.lon = wiyn_lon wiyn.elevation = wiyn_elevation wiyn.date = datetime.datetime.strftime(date_mid, ephem_format) logger_debug("Current time (UTC): %s" % (wiyn.date)) logger_debug("Current coordinates: %s %s" % (target.ra, target.dec)) # # # # Compute some stats for astronomical twilight # # # wiyn_astrotwilight = ephem.Observer() # wiyn_astrotwilight.lat = wiyn_lat # wiyn_astrotwilight.lon = wiyn_lon # wiyn_astrotwilight.elevation = wiyn_elevation # wiyn_astrotwilight.horizon = '-18.' # # wiyn_astrotwilight.date = datetime.datetime.strftime(date_mid, ephem_format) # sun_astrotwi = ephem.Sun() # sun_astrotwi.compute(wiyn_astrotwilight) # logger_debug("next sunrise: %s" % (ephem.localtime(wiyn.next_rising(ephem.Sun())))) # logger_debug("next sunset : %s" % (ephem.localtime(wiyn.next_setting(ephem.Sun())))) # logger_debug("last sunset : %s" % (ephem.localtime(wiyn.previous_setting(ephem.Sun())))) # logger_debug("next transit: %s" % (ephem.localtime(wiyn.next_transit(ephem.Sun())))) logger_debug("next sunrise (UT/WIYN): %19s / %19s" % ( wiyn.next_rising(ephem.Sun()), ephem.date(wiyn.next_rising(ephem.Sun())-time_difference))) logger_debug("next sunset (UT/WIYN): %19s / %19s" % ( wiyn.next_setting(ephem.Sun()), ephem.date(wiyn.next_setting(ephem.Sun())-time_difference))) logger_debug("last sunset (UT/WIYN): %19s / %19s" % ( wiyn.previous_setting(ephem.Sun()), ephem.date(wiyn.previous_setting(ephem.Sun())-time_difference))) logger_debug("next transit (UT/WIYN): %19s / %19s" % ( wiyn.next_transit(ephem.Sun()), ephem.date(wiyn.next_transit(ephem.Sun())-time_difference))) # logger_debug("next sunrise (WIYN): %s" % (ephem.date(wiyn.next_rising(ephem.Sun())-time_difference))) # logger_debug("next sunset (WIYN): %s" % (ephem.date(wiyn.next_setting(ephem.Sun())-time_difference))) # logger_debug("last sunset (WIYN): %s" % (ephem.date(wiyn.previous_setting(ephem.Sun())-time_difference))) # logger_debug("next transit (WIYN): %s" % (ephem.date(wiyn.next_transit(ephem.Sun())-time_difference))) # Compute the sun's position at WIYN sun.compute(wiyn) logger_debug("SUN: alt=%-10s az=%-10s RA=%-10s DEC=%-10s" % ( sun.alt, sun.az, sun.ra, sun.dec)) #, " alt/az=", numpy.degrees(sun.alt) # and the Moon's position at WIYN moon.compute(wiyn) logger_debug("MOON: alt=%-10s az=%-10s RA=%-10s DEC=%-10s PHASE:%s" % ( moon.alt, moon.az, moon.ra, moon.dec, moon.moon_phase)) # Compute the position of the target on sky body = ephem.FixedBody(target) body._ra = target.ra body._dec = target.dec body._epoch = target.epoch body.compute(wiyn) # print "object-moon", ephem.separation(body, moon) # print "object-sun", ephem.separation(body, sun) # print "sun-sun", ephem.separation(sun, sun) # print "body-eq", ephem.separation(body, body2), hdr['DEC'] logger_debug("Writing data to FITS header") # # Compute positions for sun and moon, and separation to the target # # positions for the sun hdr['SUN__RA'] = (numpy.degrees(sun.ra), "R.A. of Sun during obs [deg]") hdr['SUN__DEC'] = (numpy.degrees(sun.dec), "declination of Sun during obs [deg]") hdr['SUN__ALT'] = (numpy.degrees(sun.alt), "altitude of Sun during obs [deg]") hdr['SUN__AZ'] = (numpy.degrees(sun.az), "azimuth of Sun during obs [deg]") # Positions for the moon hdr['MOON_RA'] = (numpy.degrees(moon.ra), "R.A. of Moon during obs [deg]") hdr['MOON_DEC'] = (numpy.degrees(moon.dec), "declination of Moon during obs [deg]") hdr['MOON_ALT'] = (numpy.degrees(moon.alt), "altitude of Moon during obs [deg]") hdr['MOON_AZ'] = (numpy.degrees(moon.az), "azimuth of Moon during obs [deg]") # separation between sun/moon and target hdr['SUN__D'] = (numpy.degrees(ephem.separation(body, sun)), "angle between target and sun [deg]") hdr['MOON_D'] = (numpy.degrees(ephem.separation(body, moon)), "angle between target and moon [deg]") logger_debug("Distance object-moon (sun): %7.3f (%7.3f)" % ( ephem.separation(body, moon), ephem.separation(body, sun))) # print # print "last sun transit ", wiyn.previous_transit(ephem.Sun()) # print "last sun rise ", wiyn.previous_rising(ephem.Sun()) # print "last sun set ", wiyn.previous_setting(ephem.Sun()) # print "next sun transit ", wiyn.next_transit(ephem.Sun()) # print "next sun rise ", wiyn.next_rising(ephem.Sun()) # print "next sun set ", wiyn.next_setting(ephem.Sun()) # print "next sun rise (-18) ", wiyn_astrotwilight.next_rising(ephem.Sun()) # print "next sun set (-18) ", wiyn_astrotwilight.next_setting(ephem.Sun()) # print "current ", wiyn.date, float(wiyn.date) # print "time to sunset: ", (wiyn.next_setting(ephem.Sun())-wiyn.date)*24.,"hours" # # print "time since sunrise: ", wiyn.date-wiyn.previous_rising(sun), (wiyn.date-wiyn.previous_rising(sun))*24. # # print "time to sunset: ", (wiyn.next_setting(sun)-wiyn.date)*24.,"hours" # # print "time since sunrise: ", (wiyn.date-wiyn.previous_rising(sun))*24.,"hours" # print "sun altitude: ", sun.alt, float(sun.alt), float(sun.az) # print # # Compute times since/until sunset and sunrise # Make sure to compute times to the closest sunrise and sunset, i.e. # computations are different for the morning and afternoon # if (sun.alt > 0): # The sun is up, let's figure out if we are just beyond sunrise # or just before sunset (i.e. it's morning or afternoon) time_since_last_noon = wiyn.previous_transit(ephem.Sun()) time_to_next_noon = wiyn.next_transit(ephem.Sun()) time_to_sunset = wiyn.next_setting(ephem.Sun())-wiyn.date time_since_sunrise = wiyn.date-wiyn.previous_rising(ephem.Sun()) if (time_to_sunset < time_since_sunrise): # We are close to sunset hdr['SUN_RISE'] = (24.*(wiyn.next_rising(ephem.Sun())-wiyn.date), 'time until sunrise [hours]') hdr['SUN_SET'] = (24.*(wiyn.date-wiyn.next_setting(ephem.Sun())), 'time since sunset [hours]') else: # We are still before noon hdr['SUN_RISE'] = (24.*(wiyn.previous_rising(ephem.Sun())-wiyn.date), 'time until sunrise [hours]') hdr['SUN_SET'] = (24.*(wiyn.date-wiyn.previous_setting(ephem.Sun())), 'time since sunset [hours]') else: # Sun is below the horizon hdr['SUN_RISE'] = (24.*(wiyn.next_rising(ephem.Sun())-wiyn.date), 'time until sunrise [hours]') hdr['SUN_SET'] = (24.*(wiyn.previous_setting(ephem.Sun())-wiyn.date), 'time since sunset [hours]') # # Compute times since/until moon rise and set # if (moon.alt > 0): # Moon is up hdr['MOON_RSE'] = (24.*(wiyn.previous_rising(moon)-wiyn.date), 'time since moon rise [hours]') hdr['MOON_SET'] = (24.*(wiyn.next_setting(moon)-wiyn.date), 'time until moon set [hours]') else: # Moon is down hdr['MOON_RSE'] = (24.*(wiyn.next_rising(moon)-wiyn.date), 'time until moon rise [hours]') hdr['MOON_SET'] = (24.*(wiyn.previous_setting(moon)-wiyn.date), 'time since moon set [hours]') # time_since_ast_twilight = 24.*(wiyn.date-wiyn_astrotwilight.previous_setting(ephem.Sun())) # time_until_ast_twilight = 24.*(wiyn_astrotwilight.next_rising(ephem.Sun())-wiyn.date) # # if (numpy.degrees(sun.alt) > -18. and time_since_ast_twilight > 12.): # # time_since_ast_twilight = 24.*(wiyn.date-wiyn_astrotwilight.next_setting(ephem.Sun())) # # if (numpy.degrees(sun.alt) > -18. and time_since_to_twilight > 16.): # # time_until_ast_twilight = 24.*(wiyn_astrotwilight.previous_rising(ephem.Sun())-wiyn.date) # hdr['SUN_RS18'] = (time_until_ast_twilight, # 'time until astronomical twilight [hours]') # hdr['SUN_ST18'] = (time_since_ast_twilight, # 'time since astronomical twilight [hours]') # # Determine sky brightness # moon.compute(wiyn) sun.compute(wiyn) skybrite = None sun_alt = numpy.degrees(sun.alt) if (sun_alt < -18.): if (numpy.degrees(moon.alt) < -18): skybrite = 'dark' else: if (moon.moon_phase > 0.5): skybrite = "bright" else: skybrite = "grey" elif (sun_alt >= -18 and sun_alt < -12): skybrite = "astro.twilight" elif (sun_alt >= -12 and sun_alt < -6): skybrite = "naut.twilight" elif (sun_alt >= -6 and sun_alt < 0): skybrite = "civil.twilight" else: skybrite = 'daytime' hdr['SKYBRITE'] = (skybrite, "sky brightness quality") # # Compute lunar age, i.e. days since/until new moon # lunar_age = wiyn.date - ephem.previous_new_moon(wiyn.date) moon_phase = moon.moon_phase moon_month = ephem.next_new_moon(wiyn.date) - ephem.previous_new_moon(wiyn.date) if (moon_phase <= 0.02): moon_phase_string = "new moon" elif (moon_phase < 0.47 and lunar_age < 0.5 * moon_month): moon_phase_string = "waxing crescent" elif (moon_phase < 0.47 and lunar_age >= 0.5 * moon_month): moon_phase_string = "waning crescent" elif (moon_phase < 0.53 and lunar_age < 0.5 * moon_month): moon_phase_string = "first quarter" elif (moon_phase < 0.53 and lunar_age >= 0.5 * moon_month): moon_phase_string = "last quarter" elif (moon_phase < 0.98 and lunar_age < 0.5 * moon_month): moon_phase_string = "waxing gibbous" elif (moon_phase < 0.98 and lunar_age >= 0.5 * moon_month): moon_phase_string = "waning gibbous" elif (moon_phase >= 0.98): moon_phase_string = "full moon" #if (ephem.previous_full_moon(wiyn.date) > ephem.previous_new_moon(wiyn.date)): # lunar_age = wiyn.date - ephem.next_new_moon(wiyn.date) hdr['LUNARAGE'] = (lunar_age, "days since last new moon") add_fits_header_title(hdr, "Almanach data", 'SUN__RA') # Moon phase: fraction of moon that's illuminated by the sun lunar_age = wiyn.date - ephem.previous_new_moon(wiyn.date) hdr['MOONILUM'] = (moon.moon_phase, "Fraction of moon illuminated") hdr['MOONPHSE'] = (moon_phase_string, "Moon phase")
#!/usr/bin/env python # -*- coding: utf-8 -*- from datetime import datetime import ephem now = datetime.now() #Past Moon phases d5 = ephem.previous_new_moon(now) d6 = ephem.previous_first_quarter_moon(now) d7 = ephem.previous_full_moon(now) d8 = ephem.previous_last_quarter_moon(now) print print (d5), " | Previous new Moon" print (d6), " | Previous quarter Moon" print (d7), " | Previous full Moon" print (d8), " | Previous last quarter Moon" print #Next Moon phases d1 = ephem.next_full_moon(now) d2 = ephem.next_new_moon(now) d3 = ephem.next_first_quarter_moon(now) d4 = ephem.next_last_quarter_moon(now) print (d2), " | Next new Moon" print (d3), " | Next quarter Moon" print (d1), " | Next full Moon" print (d4), " | Next last quarter Moon" print m=ephem.Moon(now)
sun = ephem.Sun() sun.compute(observer) data['sun']['altitude'] = sun.alt data['sun']['azimuth'] = sun.az # MOON DATA moonrise = observer.previous_rising(ephem.Moon()) moonnoon = observer.next_transit (ephem.Moon()) moonset = observer.next_setting (ephem.Moon()) data['moon']['rise'] = calendar.timegm(moonrise.datetime().utctimetuple()) data['moon']['noon'] = calendar.timegm(moonnoon.datetime().utctimetuple()) data['moon']['set'] = calendar.timegm(moonset.datetime().utctimetuple()) data['moon']['radius'] = ephem.moon_radius previous_new_moon = ephem.previous_new_moon(time) next_new_moon = ephem.next_new_moon(time) previous_first_quarter_moon = ephem.previous_first_quarter_moon(time) next_first_quarter_moon = ephem.next_first_quarter_moon(time) previous_full_moon = ephem.previous_full_moon(time) next_full_moon = ephem.next_full_moon(time) previous_last_quarter_moon = ephem.previous_last_quarter_moon(time) next_last_quarter_moon = ephem.next_last_quarter_moon(time) data['moon']['previous_new_moon'] = calendar.timegm(previous_new_moon.datetime().utctimetuple()) data['moon']['next_new_moon'] = calendar.timegm(next_new_moon.datetime().utctimetuple()) data['moon']['previous_first_quarter_moon'] = calendar.timegm(previous_first_quarter_moon.datetime().utctimetuple()) data['moon']['next_first_quarter_moon'] = calendar.timegm(next_first_quarter_moon.datetime().utctimetuple()) data['moon']['previous_full_moon'] = calendar.timegm(previous_full_moon.datetime().utctimetuple()) data['moon']['next_full_moon'] = calendar.timegm(next_full_moon.datetime().utctimetuple()) data['moon']['previous_last_quarter_moon'] = calendar.timegm(previous_last_quarter_moon.datetime().utctimetuple())
print "target_day_hours:",datetime.timedelta(hours=12) #print "last :",datetime.timedelta(hours=12)-day_time print "light on :",t2+datetime.timedelta(minutes=30) print "lihgt off:",t2+datetime.timedelta(hours=12.5)-day_time print "" print "MOON DATA" moon.compute(gifu) moon_rize= gifu.next_rising(moon) print ephem.localtime(moon_rize) print moon.az moon_noon= gifu.next_transit(moon) print ephem.localtime(moon_noon) print moon.alt print moon.az moon_set= gifu.next_setting(moon) print ephem.localtime(moon_set) print moon.az print #d = ephem.date(datetime.datetime.today()) today= ephem.date(datetime.datetime.today()) new_moon= ephem.previous_new_moon(today) print "previous_new_moon" print new_moon print "moon_age" print today-new_moon next_new_moon= ephem.next_new_moon(today) print next_new_moon
m = ephem.Moon(site) # Observer-based rise/set calculations modifies the body involved, so need to create # 'disposable' ones we don't mind having modififed s_loc = ephem.Sun(site) m_loc = ephem.Moon(site) print "\n*** Sun and Moon ***" print " BODY | VIS | ALT | AZ | RISE | SET | MAG |" print "-------------------+-----+--------+--------+-------------+-------------+-------+" print_visinfo(s_loc,site) print_visinfo(m_loc,site) print "-------------------+-----+--------+--------+-------------+-------------+-------+" print "\n*** Lunar Phase information: ***" prev_new = ephem.previous_new_moon(now) next_new = ephem.next_new_moon(now) next_first = ephem.next_first_quarter_moon(now) next_full = ephem.next_full_moon(now) next_last = ephem.next_last_quarter_moon(now) phase = m.moon_phase lunation = (now-prev_new)/(next_new-prev_new) # Elaborate on most recent lunar phase print "Current lunar illumination is {:0.1f}%, lunation is {:0.4f}".format(phase*100,lunation) if lunation < 0.25: print "Was just New Moon at {} UT".format(fmt_date(ephem.previous_new_moon(now))) elif lunation < 0.5: print "Was just First Quarter at {} UT".format(fmt_date(ephem.previous_first_quarter_moon(now))) elif lunation < 0.75: