def colortemp():
s = sun()
sunrise = datetime.combine(date.today(), s.sunrise(when=datetime.now()))
solarnoon = datetime.combine(date.today(),
s.solarnoon(when=datetime.now()))
sunset = datetime.combine(date.today(), s.sunset(when=datetime.now()))
if (datetime.now() - sunrise).seconds < 0 or (datetime.now() -
sunrise).days < 0:
#print("It is before sunrise")
return "bluehour"
elif (datetime.now() - solarnoon).seconds < 0 or (datetime.now() -
solarnoon).days < 0:
#print("it is between sunrise and solar noon")
percent = (datetime.now() - sunrise).seconds / (solarnoon -
sunrise).seconds
index = int(percent * 20)
return str(ct_lookup[index])
elif (datetime.now() - sunset).seconds < 0 or (datetime.now() -
sunset).days < 0:
#print("it is between solar noon and sunset")
percent = (datetime.now() - solarnoon).seconds / (sunset -
solarnoon).seconds
index = int((1 - percent) * 20)
return str(ct_lookup[index])
else:
#print("It is after sunset")
return "bluehour"
def sunrise_sunset(self,lat, lon, delta_hours):
s = sunrise.sun( lat, 360- lon)
if self.which == 'train':
date_start = datetime.datetime(1994,1,1)
elif self.which == 'test':
date_start = datetime.datetime(2007,1,1, 2)
else: date_start = datetime.datetime(2009,1,1,2)
utc_time = date_start + datetime.timedelta( delta_hours/24)
srise, sset = s.sunrise(when = utc_time), s.sunset(when = utc_time)
return srise, sset
def sunrise_sunset(self, lat, lon, delta_hours):
s = sunrise.sun(lat, 360 - lon)
if self.which == 'train':
date_start = datetime.datetime(1994, 1, 1)
elif self.which == 'test':
date_start = datetime.datetime(2007, 1, 1, 2)
else:
date_start = datetime.datetime(2009, 1, 1, 2)
utc_time = date_start + datetime.timedelta(delta_hours / 24)
srise, sset = s.sunrise(when=utc_time), s.sunset(when=utc_time)
return srise, sset
def sunrise_sunset(loc, date, utcoffset):
sunsun = sun(lat=loc.latitude, long=loc.longitude)
t_sunrise = sunsun.sunrise(when=date)
t_sunset = sunsun.sunset(when=date)
# convert from time to datetime object
t_sunrise = datetime.datetime(2000, 1, 1, t_sunrise.hour, t_sunrise.minute)
t_sunset = datetime.datetime(2000, 1, 1, t_sunset.hour, t_sunset.minute)
# add utcoffset
t_sunrise = (t_sunrise + utcoffset).time()
t_sunset = (t_sunset + utcoffset).time()
return t_sunrise, t_sunset
def __init__(self, board, switchIndex, lat, long, sensor=None):
DeskLamp.lamp_count += 1
self.sun = sun(lat=lat, long=long)
self.board = board
self.switchIndex = switchIndex
self.lamp_should_be_on = False
self.sensor = None
self.last_motion_time = int(0)
if sensor is not None:
self.sensor = Sensor(sensor)
self.sensor.on_motion = self.on_motion
schedule.every(1).minutes.do(self.check_lamp_state)
self.check_lamp_state()
if DeskLamp.t is None:
t = Thread(target=run_schedule)
t.daemon = True
t.start()
def sunrise_sunset(loc,date):
# find timezone first
timezone_str = tz.tzNameAt(loc.latitude,loc.longitude)
timezone = pytz.timezone(timezone_str)
dt = timezone.utcoffset(date)
sunsun = sun(lat=loc.latitude,long=loc.longitude)
t_sunrise = sunsun.sunrise(when=date)
t_sunset = sunsun.sunset(when=date)
# convert from time to datetime object
t_sunrise = datetime.datetime(2000,1,1,t_sunrise.hour,t_sunrise.minute)
t_sunset = datetime.datetime(2000,1,1,t_sunset.hour,t_sunset.minute)
# add utcoffset
t_sunrise = (t_sunrise+dt).time()
t_sunset = (t_sunset+dt).time()
return t_sunrise,t_sunset
def setSunperiod(timestamp):
#Starting the daylight saving time:
dst1 = datetime(2017, 3, 26)
dst2 = datetime(2017, 10, 29)
sunrisetime = []
sunsettime = []
sunperiod = np.zeros(len(timestamp))
s = sunrise.sun()
for i in range(len(timestamp)):
if timestamp[i] > dst1 and timestamp[i] < dst2:
delta = timedelta(hours = 2)
else:
delta = timedelta(hours = 1)
sunrisetime.append(datetime.combine(date.today(), s.sunrise(timestamp[i])) + delta)
sunsettime.append(datetime.combine(date.today(), s.sunset(timestamp[i])) + delta)
if timestamp[i].time() > sunrisetime[i].time() and timestamp[i].time() < sunsettime[i].time():
sunperiod[i] = 1
return sunperiod
def main():
global sunriseclass
global scheduler
global pin1
global pin2
# setup
logger.info(scriptname+" starting")
wiringpi.wiringPiSetupGpio()
wiringpi.pinMode(pin1, 1)
wiringpi.pinMode(pin2, 1)
sunriseclass = sunrise.sun(lat=lat,long=long)
scheduler = sched.scheduler(time.time, time.sleep)
# calculate times for today
now = datetime.datetime.now()
testtime = pytz.timezone('Europe/Amsterdam').localize(datetime.datetime.combine(now.date(), datetime.time(hour=12, minute=0, second=0, microsecond=0)))
sunrisetoday = sunriseclass.sunrise(when = testtime)
sunsettoday = sunriseclass.sunset(when = testtime)
# determine current state
if sunrisetoday < now.time():
if now.time() < sunsettoday:
logger.info("sun is up")
lightsoff()
nextsunset = pytz.timezone('Europe/Amsterdam').localize(datetime.datetime.combine(now.date(), sunsettoday))
logger.info('Scheduling next sunset event at: '+str(nextsunset))
scheduler.enterabs(nextsunset.timestamp(), 1, sunsetevent)
scheduler.run()
else:
logger.info("sun is down, evening")
sunsetevent()
else:
logger.info("sun is down, night or morning")
lightson()
nextsunrise = pytz.timezone('Europe/Amsterdam').localize(datetime.datetime.combine(now.date(), sunrisetoday))
logger.info('Scheduling next sunrise event at: '+str(nextsunrise))
scheduler.enterabs(nextsunrise.timestamp(), 1, sunriseevent)
scheduler.run()
def main():
oldtime = "00:00"
#read timetable
rows = read_tt()
#endless loop
while True:
#loop timetable and compare with currenttime
#get current time
now = time.localtime(time.time())
current_time = time.strftime("%H:%M", now)
#get the sunrise time for Wageningen
s = sunrise.sun(lat=51.8, long=5.40)
#convert time to a datetime
sr = dt.datetime.combine(dt.date(1901, 1, 1), s.sunrise())
ss = dt.datetime.combine(dt.date(1901, 1, 1), s.sunset())
if current_time == '08:30':
rows = read_tt()
if current_time != oldtime:
#print( current_time )
for row in rows:
if row[1] is not None:
#there is a switchtime
#print ("%s %s %s %s %s" % row)
if row[1] == current_time:
switch_kaku(row[0], row[4], 'A')
else:
#print('we have a sunrise/set time')
#print(row[3])
if row[3] is None:
#print('sunset')
#calculate time
#print(row[2])
delta_s = dt.timedelta(minutes=row[2])
ss = ss + delta_s
#sstime=ss
sstime = ss.strftime("%H:%M")
#print('SS',sstime)
if sstime == current_time:
#print "%s %s %s %s %s" % row
switch_kaku(row[0], row[4], 'A')
else:
#print('sunrise')
#calculate time
delta_r = dt.timedelta(minutes=row[3])
sr = sr + delta_r
srtime = time.strftime("%H:%M")
#print('sr',srtime)
if srtime == current_time:
#print "%s %s %s %s %s" % row
switch_kaku(row[0], row[4], 'A')
#to ensure we switch oly one time per minute
oldtime = current_time
return
#!/usr/local/bin/python3.4
import config
import requests
import sys
import datetime, time
from time import sleep
from sunrise import sun
light = sys.argv[1]
s = sun(lat=52,long=-2)
time = s.sunset(when=datetime.datetime.now())
#print('Sunset at ', time)
today = datetime.date.today()
end = datetime.datetime.combine(today, time)
start = datetime.datetime.combine(today, datetime.datetime.now().time())
delta = end - start
sleep(delta.seconds +3600)
# Turn on
url='http://{}/api/{}/lights/{}/state'.format(
config.hue['host'],
config.hue['key'],
light
)
normal_data='{"on":true, "hue": 29000, "sat": 100, "bri": 80, "ct": 350}'
def get_sunset(date):
s = sun(lat=50.475, long=6.987)
sunset = datetime.datetime.combine(date, s.sunset(when=date))
return int(pytime.mktime(sunset.timetuple()) * 1e6)
def get_sunrise(date):
date += datetime.timedelta(days=1)
s = sun(lat=50.475, long=6.987)
sunrise = datetime.datetime.combine(date, s.sunrise(when=date))
return int(pytime.mktime(sunrise.timetuple()) * 1e6)
def get_sunrise(date):
date += datetime.timedelta(days=1)
s=sun(lat=50.475,long=6.987)
sunrise = datetime.datetime.combine(date, s.sunrise(when=date))
return int(pytime.mktime(sunrise.timetuple())*1e6)
self.humidity = 100
self.temp = 100
self.level = 100
self.brightness = 100
if __name__ == '__main__':
ib = IntelligenterBlumentopf()
tempHumiditySensor = TempHumiditySensor()
remotePowerSupplyController = RemotePowerSupplyController()
groundHumiditySensor = GroundHumiditySensor()
lightSensor = LightSensor()
levelSensor = LevelSensor()
sun = sun(lat=ib.coordsLat, long=ib.coordsLong)
csvData = CSVData()
ib.logger.debug('IntelligenterBlumentopf is up and running...')
ib.logger.debug('self.criticalHumidity:' + str(ib.criticalHumidity))
ib.logger.debug('self.criticalBrightness:' + str(ib.criticalBrightness))
ib.logger.debug('self.checkSensorsInterval:' +
str(ib.checkSensorsInterval))
ib.logger.debug('self.additionalLightingDuration:' +
str(ib.additionalLightingDuration))
while True:
#check sensors
ib.humidity = groundHumiditySensor.getGroundHumidity()
ib.temp = int(tempHumiditySensor.getTemparature())
import datetime
import sunrise
s = sunrise.sun(lat=51.441642, long=5.4697225)
sun_rise = s.sunrise(when=datetime.datetime.now())
sun_rise = datetime.time(0, 0) + datetime.timedelta(hours=2)
print('sunrise at ', sun_ris)
#!/usr/bin/python3
import urllib.request, urllib.parse, subprocess, os, string, json, re, sys
from datetime import date, datetime, time, timedelta
from sunrise import sun
from time import sleep
from PIL import Image, ImageFont, ImageDraw
ip = '192.168.0.193'
width = 112
height = 16
stationBoardFrom=time(hour=22,minute=0,second=0)
stationBoardTo=time(hour=8,minute=0,second=0)
s = sun(lat=52.37,long=9.72)
lightIs = False
black = (0,0,0)
yellow = (255,255,0)
debug = False
if len(sys.argv) >= 2:
debug = (sys.argv[1] == "debug")
bigfont = ImageFont.truetype("5x7.ttf", 16)
digfont = ImageFont.truetype("4x7.ttf", 7)
font = ImageFont.truetype("5x7.ttf", 8)
def isDarkOutside():
return s.sunrise() > datetime.now().time() or datetime.now().time() > s.sunset()
def URLRequest(url, params, method="GET"):
def Draw(self, ypos, owm):
xpos = 0
t = datetime.datetime.now()
dt = datetime.timedelta(hours=WeatherInfo.FORECAST_PERIOD_HOURS)
tf = t
s = sun()
for i in range(8):
f = owm.Get(tf)
if (f == None):
continue
#f.Print()
t_sunrise = s.sunrise(tf)
t_sunset = s.sunset(tf)
if (tf <= t_sunrise) and (tf + dt > t_sunrise):
dx = self.TimeDiffToPixels(t_sunrise - tf) - self.XSTEP / 2
self.PutImg("sun", 0, xpos + dx, ypos - self.YSTEP, False)
if (tf <= t_sunset) and (tf + dt > t_sunset):
dx = self.TimeDiffToPixels(t_sunset - tf) - self.XSTEP / 2
self.PutImg("moon", 0, xpos + dx, ypos - self.YSTEP)
if (i == 0):
self.PutImg("house", 0, xpos, ypos + self.YSTEP)
if (f.t.hour == 0):
self.PutImg("ground", 1, xpos, ypos + self.YSTEP)
if (f.t.hour == 12):
self.PutImg("ground", 2, xpos, ypos + self.YSTEP)
elif (f.t.hour == 0):
self.PutImg("ground", 1, xpos, ypos + self.YSTEP)
elif (f.t.hour == 12):
self.PutImg("ground", 2, xpos, ypos + self.YSTEP)
else:
self.PutImg("ground", 0, xpos, ypos + self.YSTEP)
wcond = int(f.id / 100)
if (wcond == WeatherInfo.Thunderstorm):
self.PutImg("thunderstorm", 0, xpos, ypos + self.YSTEP)
if (wcond == WeatherInfo.Atmosphere):
self.PutImg("fog", 0, xpos, ypos + self.YSTEP)
c = int((round(float(f.clouds) / 10)))
self.PutImg("cloud", c, xpos, ypos)
r = round(f.rain)
if (r == 0) and (f.rain > 0.01):
r = 1
if (r > 5):
r = 5
self.PutImg("rain", r, xpos, ypos + self.YSTEP)
xpos += self.XSTEP
tf += dt
def Draw(self, ypos, owm):
self.picheight = self.IMGHEIGHT
self.picwidth = self.IMGEWIDTH
self.ypos = ypos
nforecasrt = ((self.picwidth - self.XSTART) / self.XSTEP)
maxtime = datetime.datetime.now() + datetime.timedelta(
hours=WeatherInfo.FORECAST_PERIOD_HOURS * nforecasrt)
(self.tmin, self.tmax) = owm.GetTempRange(maxtime)
self.temprange = self.tmax - self.tmin
if (self.temprange < self.YSTEP):
self.degreeperpixel = self.DEFAULT_DEGREE_PER_PIXEL
else:
self.degreeperpixel = self.temprange / float(self.YSTEP)
print("tmin = %f , tmax = %f, range=%f" %
(self.tmin, self.tmax, self.temprange))
xpos = 0
tline = [0] * (self.picwidth + self.XSTEP + 1)
f = owm.GetCurr()
oldtemp = f.temp
oldy = self.DegToPix(oldtemp)
for i in range(self.XSTART):
tline[i] = oldy
yclouds = int(ypos - self.YSTEP / 2)
f.Print()
self.sprite.Draw("house", xpos, 0, oldy)
self.sprite.DrawInt(oldtemp, xpos + 8, oldy + 10)
self.sprite.DrawCloud(f.clouds, xpos, yclouds, self.XSTART,
self.YSTEP / 2)
self.sprite.DrawRain(f.rain, xpos, yclouds, self.XSTART, tline)
self.sprite.DrawSnow(f.snow, xpos, yclouds, self.XSTART, tline)
t = datetime.datetime.now()
dt = datetime.timedelta(hours=WeatherInfo.FORECAST_PERIOD_HOURS)
tf = t
xpos = int(self.XSTART)
nforecasrt = int(nforecasrt)
n = int((self.XSTEP - self.XFLAT) / 2)
for i in range(nforecasrt + 1):
f = owm.Get(tf)
if (f == None):
continue
f.Print()
newtemp = f.temp
newy = self.DegToPix(newtemp)
for i in range(n):
tline[xpos + i] = self.mybezier(xpos + i, xpos, oldy, xpos + n,
newy)
for i in range(self.XFLAT):
tline[int(xpos + i + n)] = newy
xpos += n + self.XFLAT
n = (self.XSTEP - self.XFLAT)
oldtemp = newtemp
oldy = newy
tf += dt
s = sun()
tf = t
xpos = self.XSTART
objcounter = 0
for i in range(nforecasrt + 1):
f = owm.Get(tf)
if (f == None):
continue
t_sunrise = s.sunrise(tf)
t_sunset = s.sunset(tf)
ymoon = ypos - self.YSTEP * 5 / 8
if (tf <= t_sunrise) and (tf + dt > t_sunrise):
dx = self.TimeDiffToPixels(t_sunrise - tf) - self.XSTEP / 2
self.sprite.Draw("sun", 0, xpos + dx, ymoon)
objcounter += 1
if (objcounter == 2):
break
if (tf <= t_sunset) and (tf + dt > t_sunset):
dx = self.TimeDiffToPixels(t_sunset - tf) - self.XSTEP / 2
self.sprite.Draw("moon", 0, xpos + dx, ymoon)
objcounter += 1
if (objcounter == 2):
break
xpos += self.XSTEP
tf += dt
istminprinted = False
istmaxprinted = False
tf = t
xpos = self.XSTART
n = int((self.XSTEP - self.XFLAT) / 2)
for i in range(nforecasrt + 1):
f = owm.Get(tf)
if (f == None):
continue
#f.Print()
yclouds = int(ypos - self.YSTEP / 2)
if (f.temp == self.tmin) and (not istminprinted):
self.sprite.DrawInt(f.temp, xpos + n, tline[xpos + n] + 10)
istminprinted = True
if (f.temp == self.tmax) and (not istmaxprinted):
self.sprite.DrawInt(f.temp, xpos + n, tline[xpos + n] + 10)
istmaxprinted = True
t0 = f.t - dt / 2
t1 = f.t + dt / 2
# FLOWERS: black - midnight , red - midday
dt_onehour = datetime.timedelta(hours=1)
dx_onehour = self.XSTEP / WeatherInfo.FORECAST_PERIOD_HOURS
tt = t0
xx = xpos
while (tt <= t1):
ix = int(xx)
if (tt.hour == 12):
self.sprite.Draw("flower", 1, ix, tline[ix])
if (tt.hour == 0):
self.sprite.Draw("flower", 0, ix, tline[ix])
if (tt.hour == 6) or (tt.hour == 18) or (tt.hour == 3) or (
tt.hour == 15) or (tt.hour == 9) or (tt.hour == 21):
self.sprite.DrawWind(f.windspeed, f.winddeg, ix, tline)
tt += dt_onehour
xx += dx_onehour
self.sprite.DrawCloud(f.clouds, xpos, yclouds, self.XSTEP,
self.YSTEP / 2)
self.sprite.DrawRain(f.rain, xpos, yclouds, self.XSTEP, tline)
self.sprite.DrawSnow(f.snow, xpos, yclouds, self.XSTEP, tline)
xpos += self.XSTEP
tf += dt
BLACK = 0
pixel = self.bimg.load()
for x in range(self.picwidth):
if (tline[x] < self.picheight):
pixel[x, tline[x]] = BLACK
else:
print("out of range: %i - %i(max %i)" %
(x, tline[x], self.picheight))
import datetime
import sunrise
s = sunrise.sun(lat=49,long=3)
print('sunrise at '+s.sunrise(when=datetime.datetime.now()))
def __init__(self,
filename,
inst='HARPS',
pfits=True,
orders=None,
wlog=def_wlog,
drs=False,
fib=None,
targ=None,
verb=False):
"""
pfits : fits reader
True: pyfits (safe, e.g. to get the full header of the start refence spectrum)
2: my own simple pure python fits reader, faster than pyfits
It was developed for HARPS e2ds, but the advent ADP.*.tar was difficult.
"""
self.filename = filename
self.drsname = 'DRS'
self.drs = drs
self.flag = 0
self.bflag = 0
self.tmmean = 0
self.f = None
self.w = None
self.e = None
self.bpmap = None
self.mod = None
self.fib = fib
self.fo = None
self.wo = None
self.eo = None
self.bo = None
self.drift = np.nan
self.e_drift = np.nan
self.utc = None
self.ra = None
self.de = None
# self.obs = type('specdata', (object,), {'lat': None, 'lon': None})
self.obs = type('specdata', (object, ), dict(lat=None, lon=None))
self.airmass = np.nan
self.inst = inst
self.scan = self.inst.scan
self.data = self.inst.data
if '.gz' in filename: pfits = True
self.ccf = type(
'ccf', (),
dict(rvc=np.nan,
err_rvc=np.nan,
bis=np.nan,
fwhm=np.nan,
contrast=np.nan,
mask=0,
header=0))
# scan fits header for times, modes, snr, etc.
#read_spec(self, filename, inst=inst, pfits=pfits, verb=verb)
self.scan(self, filename, pfits=pfits)
if verb:
print "scan %s:" % self.instname, self.timeid, self.header[
'OBJECT'], self.drsbjd, self.sn55, self.drsberv, self.drift, self.flag, self.calmode
if inst.name != self.instname:
pause('WARNING:', filename, 'from', self.inst, ', but mode is',
inst)
self.obj = self.header['OBJECT']
### Barycentric correction ###
# start and end computed only for WE and WEhtml
self.bjd_sart, self.berv_start = np.nan, np.nan
self.bjd_end, self.berv_end = np.nan, np.nan
if targ and targ.name == 'cal':
self.bjd, self.berv = self.drsbjd, 0.
elif targ and targ.ra: # unique coordinates
if self.brvref == 'MH':
# fastest version
#sys.path.append(os.environ['HOME']+'/programs/BarCor/')
sys.path.insert(1, sys.path[0] + os.sep +
'BarCor') # bary now in src/BarCor
import bary
self.bjd, self.berv = bary.bary(self.dateobs,
targ.ra,
targ.de,
inst.name,
epoch=2000,
exptime=self.exptime * 2 *
self.tmmean,
pma=targ.pmra,
pmd=targ.pmde)
if self.brvref in ('WEhtml', 'WEidl', 'WE'):
# Wright & Eastman (2014) via online or idl request
# cd /home/raid0/zechmeister/idl/exofast/bary
# export ASTRO_DATA=/home/raid0/zechmeister/
#idl -e 'print, bjd2utc(2457395.24563d, 4.58559072, 44.02195596), fo="(D)"'
jd_utc = [
self.mjd + 2400000.5 +
self.exptime * self.tmmean / 24. / 3600
]
jd_utcs = [
self.mjd + 2400000.5, jd_utc[0],
self.mjd + 2400000.5 + self.exptime / 24. / 3600
]
ra = (targ.ra[0] + targ.ra[1] / 60. +
targ.ra[2] / 3600.) * 15 # [deg]
de = (targ.de[0] + np.copysign(
targ.de[1] / 60. + targ.de[2] / 3600., targ.de[0])
) # [deg]
obsname = inst.obsname #{'CARM_VIS':'ca', 'CARM_NIR':'ca', 'FEROS':'eso', 'HARPS':'eso', 'HARPN':'lapalma', 'HPF':'hpf'}[inst]
obsloc = inst.obsloc if hasattr(inst, 'obsloc') else {}
if self.brvref == 'WE':
# pure python version
import brv_we14py
#self.bjd, self.berv = brv_we14py.bjdbrv(jd_utc=jd_utc[0], ra=ra, dec=de, obsname=obsname, pmra=targ.pmra, pmdec=targ.pmde, parallax=0., rv=0., zmeas=[0])
(_, self.bjd,
_), (self.berv_start, self.berv,
self.berv_end) = brv_we14py.bjdbrv(jd_utc=jd_utcs,
ra=ra,
dec=de,
obsname=obsname,
pmra=targ.pmra,
pmdec=targ.pmde,
parallax=0.,
rv=0.,
zmeas=[0],
**obsloc)
elif self.brvref == 'WEhtml':
self.bjd = brv_we14html.utc2bjd(jd_utc=jd_utc,
ra=ra,
dec=de)
#self.berv = brv_we14html.bvc(jd_utc=jd_utc, ra="%s+%s+%s"%targ.ra, dec="%s+%s+%s"%targ.de, obsname='ca', pmra=targ.pmra, pmdec=targ.pmde, parallax=0., rv=0., zmeas=[0], raunits='hours', deunits='degrees')[0]
self.berv_start, self.berv, self.berv_end = brv_we14html.bvc(
jd_utc=jd_utcs,
ra="%s+%s+%s" % targ.ra,
dec="%s+%s+%s" % targ.de,
obsname='ca',
pmra=targ.pmra,
pmdec=targ.pmde,
parallax=0.,
rv=0.,
zmeas=[0],
raunits='hours',
deunits='degrees')
else:
self.bjd, self.berv = brv_we14idl.bjdbrv(jd_utc=jd_utc[0],
ra=ra,
dec=de,
obsname=obsname,
pmra=targ.pmra,
pmdec=targ.pmde,
parallax=0.,
rv=0.,
zmeas=[0])
self.berv /= 1000. # m/s to km/s
if self.brvref == 'DRS':
self.bjd, self.berv = self.drsbjd, self.drsberv
self.brvref = self.drsname
else:
self.bjd, self.berv = self.drsbjd, self.drsberv
self.brvref = self.drsname
if self.fib == 'B':
self.berv = np.nan
self.drsberv = np.nan
self.header['HIERARCH SERVAL BREF'] = (self.brvref, 'Barycentric code')
self.header['HIERARCH SERVAL BJD'] = (self.bjd,
'Barycentric Julian Day')
self.header['HIERARCH SERVAL BERV'] = (self.berv,
'[km/s] Barycentric correction')
#self.header['HIERARCH SERVAL RA'] = (targ.ra[0], 'Barycentric code')
#self.header['HIERARCH SERVAL DE'] = (targ.ra[0], 'Barycentric code')
#self.header['HIERARCH SERVAL PMRA'] = (targ.ra[0], 'Barycentric code')
#self.header['HIERARCH SERVAL PMDE'] = (targ.ra[0], 'Barycentric code')
if self.utc:
date = self.utc.year, self.utc.month, self.utc.day
sunris = sunrise.sun(*date, lon=self.obs.lon, lat=self.obs.lat)
sunset = sunrise.sun(*date,
lon=self.obs.lon,
lat=self.obs.lat,
rise=False)
ut = self.utc.hour + self.utc.minute / 60. + self.utc.second / 3600.
utend = ut + self.exptime / 3600.
dark = ((sunset < ut <= utend < sunris) or # |****S__UT__R***|
(sunris < sunset < ut <= utend) or # |__R*******S__UT|
(utend < sunris < sunset < ut) or # |T__R********S_U|
(ut < utend < sunris < sunset)) # |UT__R********S_|
#if not dark:
#self.flag |= sflag.daytime
if orders is not None:
self.read_data(orders=orders, wlog=wlog)
def get_sunset(date):
s=sun(lat=50.475,long=6.987)
sunset = datetime.datetime.combine(date, s.sunset(when=date))
return int(pytime.mktime(sunset.timetuple())*1e6)
