def deleteOldObservations(data_dir,
captured_dir,
archived_dir,
config,
duration=None):
""" Deletes old observation directories to free up space for new ones.
Arguments:
data_dir: [str] Path to the RMS data directory which contains the Captured and Archived diretories
captured_dir: [str] Captured directory name.
archived_dir: [str] Archived directory name.
config: [Configuration object]
Keyword arguments:
duration: [float] Duration of next video capturing in seconds. If None (by default), duration will
be calculated for the next night.
Return:
[bool]: True if there's enough space for the next night's data, False if not.
"""
captured_dir = os.path.join(data_dir, captured_dir)
archived_dir = os.path.join(data_dir, archived_dir)
### Calculate the approximate needed disk space for the next night
# If the duration of capture is not given
if duration is None:
# Time of next local noon
#ct = datetime.datetime.utcnow()
#noon_time = datetime.datetime(ct.year, ct.month, ct.date, 12)
# Initialize the observer and find the time of next noon
o = ephem.Observer()
o.lat = config.latitude
o.long = config.longitude
o.elevation = config.elevation
sun = ephem.Sun()
sunrise = o.previous_rising(sun, start=ephem.now())
noon_time = o.next_transit(sun, start=sunrise).datetime()
# if ct.hour > 12:
# noon_time += datetime.timedelta(days=1)
# Get the duration of the next night
_, duration = captureDuration(config.latitude,
config.longitude,
config.elevation,
current_time=noon_time)
# Calculate the approx. size for the night night
next_night_bytes = (duration *
config.fps) / 256 * config.width * config.height * 4
# Always leave at least 2 GB free for archive
next_night_bytes += config.extra_space_gb * (1024**3)
######
# If there's enough free space, don't do anything
if availableSpace(data_dir) > next_night_bytes:
return True
# Intermittently delete captured and archived directories until there's enough free space
prev_available_space = availableSpace(data_dir)
nothing_deleted_count = 0
while True:
# Delete one captured directory
captured_dirs_remaining = deleteNightFolders(captured_dir, config)
# Break the there's enough space
if availableSpace(data_dir) > next_night_bytes:
break
# Delete one archived directory
archived_dirs_remaining = deleteNightFolders(archived_dir, config)
# Break the there's enough space
if availableSpace(data_dir) > next_night_bytes:
break
# If no folders left to delete, try to delete archived files
if (len(captured_dirs_remaining)
== 0) and (len(archived_dirs_remaining) == 0):
archived_files_remaining = deleteFiles(archived_dir, config)
# If there's nothing left to delete, return False
if len(archived_files_remaining) == 0:
return False
# Break the there's enough space
if availableSpace(data_dir) > next_night_bytes:
break
# If nothing was deleted in this loop,
if availableSpace(data_dir) == prev_available_space:
nothing_deleted_count += 1
else:
nothing_deleted_count = 0
# If nothing was deleted for 100 loops, indicate that no more space can be freed
if nothing_deleted_count >= 100:
return False
prev_available_space = availableSpace(data_dir)
return True
o_log.insert(0, str(' ' + event + ' | ' + details))
o_log.insert(0, now + ' - ' + action)
with open(today + '_ObservingLog.txt', 'a') as f:
f.write(now + ' - ' + action + ' | ' + event + ' | ' + details + '\n')
return
# Window Options
root = tk.Tk()
root.title("RhoPi Telescope Pointing v0.0.5 (alpha)")
default_font = tkFont.nametofont("TkDefaultFont")
default_font.configure(size=11, family='system')
# print tkFont.families()
# Observer Setup
rho = ephem.Observer()
rho.lon, rho.lat = '-82.586203', '29.400249'
# --- Section Frames Column Configuration --- #
c = tk.Frame(root) # c is for catalog section widgets
c.grid(column=0, row=0, sticky='N')
o = tk.Frame(root) # a is for align section widgets
o.grid(column=1, row=0, sticky='N')
s = tk.Frame(root) # s is for information section widgets
s.grid(column=2, row=0, sticky='N')
# --- All widget initializations and names --- #
# Target Section Widgets
c_fill = [
tk.StringVar(c, '--None--'),
def mjd2ut(mjd):
obs = ephem.Observer()
doff = ephem.Date(0) - ephem.Date('1858/11/17')
djd = mjd - doff
obs.date = djd
return obs.date
def params_struct(dateobs,
tobs=None,
filt=['r'],
exposuretimes=[60.0],
mindiff=30.0 * 60.0,
probability=0.9,
tele='ZTF',
airmass=2.5,
schedule_type='greedy',
doReferences=True,
doUsePrimary=False,
filterScheduleType='block',
schedule_strategy='tiling'):
growthpath = os.path.dirname(growth.__file__)
config_directory = os.path.join(growthpath, 'too', 'config')
tiling_directory = os.path.join(growthpath, 'too', 'tiling')
catalogpath = os.path.join('too', 'catalog')
try:
app.open_instance_resource('%s/CLU.hdf5' % catalogpath)
catalog_directory = app.instance_path
except IOError:
catalog_directory = os.path.join(growthpath, catalogpath)
params = {}
params["config"] = {}
config_files = glob.glob("%s/*.config" % config_directory)
for config_file in config_files:
telescope = config_file.split("/")[-1].replace(".config", "")
params["config"][telescope] =\
gwemopt.utils.readParamsFromFile(config_file)
params["config"][telescope]["telescope"] = telescope
if "tesselationFile" in params["config"][telescope]:
params["config"][telescope]["tesselationFile"] =\
os.path.join(config_directory,
params["config"][telescope]["tesselationFile"])
tesselation_file = params["config"][telescope]["tesselationFile"]
if not os.path.isfile(tesselation_file):
if params["config"][telescope]["FOV_type"] == "circle":
gwemopt.tiles.tesselation_spiral(
params["config"][telescope])
elif params["config"][telescope]["FOV_type"] == "square":
gwemopt.tiles.tesselation_packing(
params["config"][telescope])
params["config"][telescope]["tesselation"] =\
np.loadtxt(params["config"][telescope]["tesselationFile"],
usecols=(0, 1, 2), comments='%')
if "referenceFile" in params["config"][telescope]:
params["config"][telescope]["referenceFile"] =\
os.path.join(config_directory,
params["config"][telescope]["referenceFile"])
refs = table.unique(
table.Table.read(params["config"][telescope]["referenceFile"],
format='ascii',
data_start=2,
data_end=-1)['field', 'fid'])
reference_images =\
{group[0]['field']: group['fid'].astype(int).tolist()
for group in refs.group_by('field').groups}
reference_images_map = {1: 'g', 2: 'r', 3: 'i', 4: 'z', 5: 'J'}
for key in reference_images:
reference_images[key] = [
reference_images_map.get(n, n)
for n in reference_images[key]
]
params["config"][telescope]["reference_images"] = reference_images
observer = ephem.Observer()
observer.lat = str(params["config"][telescope]["latitude"])
observer.lon = str(params["config"][telescope]["longitude"])
observer.horizon = str(-12.0)
observer.elevation = params["config"][telescope]["elevation"]
params["config"][telescope]["observer"] = observer
params["skymap"] = ""
params["gpstime"] = -1
params["outputDir"] = "output/%s" % dateobs.strftime("%Y%m%dT%H%M%S")
params["tilingDir"] = tiling_directory
params["event"] = ""
params["telescopes"] = [tele]
if schedule_strategy == "catalog":
params["tilesType"] = "galaxy"
params["catalogDir"] = catalog_directory
params["galaxy_catalog"] = "CLU"
params["galaxy_grade"] = "S"
params["writeCatalog"] = False
params["catalog_n"] = 1.0
params["powerlaw_dist_exp"] = 1.0
params["doChipGaps"] = False
elif schedule_strategy == "tiling":
params["tilesType"] = "moc"
if tele == "ZTF":
params["doChipGaps"] = True
else:
params["doChipGaps"] = False
params["scheduleType"] = schedule_type
params["timeallocationType"] = "powerlaw"
params["nside"] = 512
params["powerlaw_cl"] = probability
params["powerlaw_n"] = 1.0
params["powerlaw_dist_exp"] = 0.0
params["doPlots"] = False
params["doMovie"] = False
params["doObservability"] = True
params["do3D"] = False
params["doFootprint"] = False
params["footprint_ra"] = 30.0
params["footprint_dec"] = 60.0
params["footprint_radius"] = 10.0
params["airmass"] = airmass
params["doCommitDatabase"] = True
params["doRequestScheduler"] = False
params["dateobs"] = dateobs
params["doEvent"] = False
params["doSkymap"] = False
params["doFootprint"] = False
params["doDatabase"] = True
params["doReferences"] = doReferences
params["doUsePrimary"] = doUsePrimary
params["doSplit"] = False
params["doParallel"] = False
params["doUseCatalog"] = False
if tele in ["KPED", "GROWTH-India"]:
params["doMinimalTiling"] = True
else:
params["doMinimalTiling"] = False
params["doIterativeTiling"] = False
params["galaxies_FoV_sep"] = 1.0
if params["doEvent"]:
params["skymap"], eventinfo = gwemopt.gracedb.get_event(params)
params["gpstime"] = eventinfo["gpstime"]
event_time = time.Time(params["gpstime"], format='gps', scale='utc')
params["dateobs"] = event_time.iso
elif params["doSkymap"]:
event_time = time.Time(params["gpstime"], format='gps', scale='utc')
params["dateobs"] = event_time.iso
elif params["doFootprint"]:
params["skymap"] = gwemopt.footprint.get_skymap(params)
event_time = time.Time(params["gpstime"], format='gps', scale='utc')
params["dateobs"] = event_time.iso
elif params["doDatabase"]:
event_time = time.Time(params["dateobs"],
format='datetime',
scale='utc')
params["gpstime"] = event_time.gps
else:
raise ValueError('Need to enable --doEvent, --doFootprint, '
'--doSkymap, or --doDatabase')
if tobs is None:
now_time = time.Time.now()
timediff = now_time.gps - event_time.gps
timediff_days = timediff / 86400.0
params["Tobs"] = np.array([timediff_days, timediff_days + 1])
else:
params["Tobs"] = tobs
params["doSingleExposure"] = True
if filterScheduleType == "block":
params["doAlternatingFilters"] = True
else:
params["doAlternatingFilters"] = False
params["filters"] = filt
params["exposuretimes"] = exposuretimes
params["mindiff"] = mindiff
params = gwemopt.segments.get_telescope_segments(params)
params = gwemopt.utils.params_checker(params)
if params["doPlots"]:
if not os.path.isdir(params["outputDir"]):
os.makedirs(params["outputDir"])
return params
bodies = []
for i in range(len(kbos)):
kbo = eph.EllipticalBody()
(a, e, inc, a0, a1, a2, djdM, djd, H, m) = kbos[i]
kbo._a = a
kbo._e = e
kbo._inc = inc
kbo._M = a0
kbo._Om = a1
kbo._om = a2
kbo._epoch_M = djdM
kbo._epoch = djd
bodies.append(kbo)
del kbo
observer = eph.Observer()
observer.lon = '204:31:40.1'
observer.lat = '19:49:34.0'
observer.elevation = 4212
mask_files = glob.glob(masksDir + '/mask*fits')
mask_files.sort()
dirInd = '02530'
if dirInd == '02531':
dirStr = 'rocketdata/DEC2018'
elif dirInd in ['02532', '02533', '02534']:
dirStr = 'Hammer/DEC2018'
else:
dirStr = 'Thumber/DEC2018_also'
if len(n) >= 1 and n[0].nodeType == n[0].TEXT_NODE:
return n[0].data
return None
if __name__ == '__main__':
filename = sys.argv[1]
waypoints = read_track_file_GPX(filename)
if not waypoints:
print("No waypoints in", filename)
sys.exit(1)
print("First waypoint:", waypoints[0])
observerPoint = waypoints[0]
observer = ephem.Observer()
# Observer will take degrees as a string, but if you pass it floats
# it expects radians, though that's undocumented.
observer.lat = observerPoint[1] * ephem.degree
observer.lon = observerPoint[2] * ephem.degree
if len(observerPoint) > 3:
observer.elevation = observerPoint[3]
else:
observer.elevation = 500.0 # meters
observer.name = "%s %f, %f, %f" % (observerPoint[0], observer.lon,
observer.lat, observer.elevation)
print(observer)
print()
find_alignments(observer, waypoints)
passwd=DBpasswd,
db=DBname)
print "MySQL Database:", DBname, " at Host:", DBhost
else:
import sqlite3 # the SQL data base routines^M
conn = sqlite3.connect(DBase) # connect with the database
print "SQLITE3 Database: ", DBase
# --------------------------------------#
curs = conn.cursor() # set the cursor
#
#-----------------------------------------------------------------
# Initialise API for computing sunrise and sunset
#-----------------------------------------------------------------
#
location = ephem.Observer()
location.pressure = 0
location.horizon = '-0:34' # Adjustments for angle to horizon
location.lat, location.lon = location_latitude, location_longitude
date = datetime.now()
next_sunrise = location.next_rising(ephem.Sun(), date)
next_sunset = location.next_setting(ephem.Sun(), date)
print "Sunrise today is at: ", next_sunrise, " UTC "
print "Sunset today is at: ", next_sunset, " UTC "
print "Time now is: ", date, " Local time"
prtreq = sys.argv[1:]
if prtreq and prtreq[0] == 'prt':
prt = True
else:
###This is a code meant to check weather and sun position to see if the dome
###should be open or not. Uses observing condition cutoffs from main minerva code
import ephem, time
from win32com.client import Dispatch
import should_be_open
##Here, we define the location of he MINERVA telescope, used for calculating
##locations, etc.
hopkins = ephem.Observer()
hopkins.lon='-110:52:44.6'
hopkins.lat='31:40:49.4'
hopkins.elevation= 2345.
dome=Dispatch("ascom.astrohavenpw.dome")
dome.Connected=True
i=0.
##This will run like a loop. Check a bunch of things, see if the telescope
##should be open open or closed, take action.
while i == 0:
hopkins.date=ephem.now()
Sun=ephem.Sun(hopkins)
sunalt=(float(repr(Sun.alt)))*57.3
#Dome shojuld be closed if Sun is more than -5, let's say.
#This loop checks to make sure that the dome is closed, and if it isn't
#closes. Check and seems to work.
if sunalt >= -5.0:
def calculateEphemerides(parFile):
'''
:INPUTS:
parFile -- path to the parameter file
'''
#parFile = 'umo.par'
'''Parse the observatory .par file'''
parFileText = open(os.path.join(os.path.dirname(oscaar.__file__),'extras','eph','observatories',parFile),'r').read().splitlines()
def returnBool(value):
'''Return booleans from strings'''
if value == 'True': return True
elif value == 'False': return False
for line in parFileText:
parameter = line.split(':')[0]
if len(line.split(':')) > 1:
value = line.split(':')[1].strip()
if parameter == 'name': observatory_name = value
elif parameter == 'latitude': observatory_latitude = value
elif parameter == 'longitude': observatory_longitude = value
elif parameter == 'elevation': observatory_elevation = float(value)
elif parameter == 'temperature': observatory_temperature = float(value)
elif parameter == 'min_horizon': observatory_minHorizon = value
elif parameter == 'start_date': startSem = gd2jd(eval(value))
elif parameter == 'end_date': endSem = gd2jd(eval(value))
elif parameter == 'v_limit': v_limit = float(value)
elif parameter == 'depth_limit': depth_limit = float(value)
elif parameter == 'calc_transits': calcTransits = returnBool(value)
elif parameter == 'calc_eclipses': calcEclipses = returnBool(value)
elif parameter == 'html_out': htmlOut = returnBool(value)
elif parameter == 'text_out': textOut = returnBool(value)
elif parameter == 'twilight': twilightType = value
from oscaar.extras.knownSystemParameters import getLatestParams
exoplanetDB = getLatestParams.downloadAndPickle()
''' Set up observatory parameters '''
observatory = ephem.Observer()
observatory.lat = observatory_latitude#'38:58:50.16' ## Input format- deg:min:sec (type=str)
observatory.long = observatory_longitude#'-76:56:13.92' ## Input format- deg:min:sec (type=str)
observatory.elevation = observatory_elevation # m
observatory.temp = observatory_temperature ## Celsius
observatory.horizon = observatory_minHorizon ## Input format- deg:min:sec (type=str)
def trunc(f, n):
'''Truncates a float f to n decimal places without rounding'''
slen = len('%.*f' % (n, f))
return str(f)[:slen]
def RA(planet):
'''Type: str, Units: hours:min:sec'''
return exoplanetDB[planet]['RA_STRING']
def dec(planet):
'''Type: str, Units: deg:min:sec'''
return exoplanetDB[planet]['DEC_STRING']
def period(planet):
'''Units: days'''
return np.float64(exoplanetDB[planet]['PER'])
def epoch(planet):
'''Tc at mid-transit. Units: days'''
if exoplanetDB[planet]['TT'] == '': return 0.0
else: return np.float64(exoplanetDB[planet]['TT'])
def duration(planet):
'''Transit/eclipse duration. Units: days'''
if exoplanetDB[planet]['T14'] == '': return 0.0
else: return float(exoplanetDB[planet]['T14'])
def V(planet):
'''V mag'''
if exoplanetDB[planet]['V'] == '': return 0.0
else: return float(exoplanetDB[planet]['V'])
def KS(planet):
'''KS mag'''
if exoplanetDB[planet]['KS'] == '': return 0.0
else: return float(exoplanetDB[planet]['KS'])
def depth(planet):
'''Transit depth'''
if exoplanetDB[planet]['DEPTH'] == '': return 0.0
else: return float(exoplanetDB[planet]['DEPTH'])
def transitBool(planet):
'''True if exoplanet is transiting, False if detected by other means'''
if exoplanetDB[planet]['TRANSIT'] == '0': return 0
elif exoplanetDB[planet]['TRANSIT'] == '1': return 1
########################################################################################
########################################################################################
def datestr2list(datestr):
''' Take strings of the form: "2013/1/18 20:08:18" and return them as a
tuple of the same parameters'''
year,month,others = datestr.split('/')
day, time = others.split(' ')
hour,minute,sec = time.split(':')
return (int(year),int(month),int(day),int(hour),int(minute),int(sec))
def list2datestr(inList):
'''Converse function to datestr2list'''
inList = map(str,inList)
return inList[0]+'/'+inList[1]+'/'+inList[2]+' '+inList[3].zfill(2)+':'+inList[4].zfill(2)+':'+inList[5].zfill(2)
def list2datestrCSV(inList):
'''Converse function to datestr2list'''
inList = map(str,inList)
return inList[0]+'/'+inList[1]+'/'+inList[2]+','+inList[3].zfill(2)+':'+inList[4].zfill(2)+':'+inList[5].zfill(2)
def list2datestrHTML(inList,alt,direction):
'''Converse function to datestr2list'''
inList = map(str,inList)
#return inList[1].zfill(2)+'/'+inList[2].zfill(2)+'<br />'+inList[3].zfill(2)+':'+inList[4].zfill(2)
return inList[1].zfill(2)+'/<strong>'+inList[2].zfill(2)+'</strong>, '+inList[3].zfill(2)+':'+inList[4].split('.')[0].zfill(2)+'<br /> '+alt+'° '+direction
def simbadURL(planet):
if exoplanetDB[planet]['SIMBADURL'] == '': return 'http://simbad.harvard.edu/simbad/'
else: return exoplanetDB[planet]['SIMBADURL']
def RADecHTML(planet):
return '<a href="'+simbadURL(planet)+'">'+RA(planet).split('.')[0]+'<br />'+dec(planet).split('.')[0]+'</a>'
def constellation(planet):
return exoplanetDB[planet]['Constellation']
def orbitReference(planet):
return exoplanetDB[planet]['TRANSITURL']
def nameWithLink(planet):
return '<a href="'+orbitReference(planet)+'">'+planet+'</a>'
def mass(planet):
if exoplanetDB[planet]['MASS'] == '': return '---'
else: return trunc(float(exoplanetDB[planet]['MASS']),2)
def semimajorAxis(planet):
#return trunc(0.004649*float(exoplanetDB[planet]['AR'])*float(exoplanetDB[planet]['RSTAR']),3) ## Convert from solar radii to AU
return trunc(float(exoplanetDB[planet]['SEP']),3)
def radius(planet):
return trunc(float(exoplanetDB[planet]['R']),2) ## Convert from solar radii to Jupiter radii
def midTransit(Tc, P, start, end):
'''Calculate mid-transits between Julian Dates start and end, using a 2500
orbital phase kernel since T_c (for 2 day period, 2500 phases is 14 years)
'''
Nepochs = np.arange(0,2500,dtype=np.float64)
transitTimes = Tc + P*Nepochs
transitTimesInSem = transitTimes[(transitTimes < end)*(transitTimes > start)]
return transitTimesInSem
def midEclipse(Tc, P, start, end):
'''Calculate mid-eclipses between Julian Dates start and end, using a 2500
orbital phase kernel since T_c (for 2 day period, 2500 phases is 14 years)
'''
Nepochs = np.arange(0,2500,dtype=np.float64)
transitTimes = Tc + P*(0.5 + Nepochs)
transitTimesInSem = transitTimes[(transitTimes < end)*(transitTimes > start)]
return transitTimesInSem
'''Choose which planets from the database to include in the search,
assemble a list of them.'''
planets = []
for planet in exoplanetDB:
if V(planet) != 0.0 and depth(planet) != 0.0 and float(V(planet)) <= v_limit and float(depth(planet)) >= depth_limit and transitBool(planet):
planets.append(planet)
if calcTransits: transits = {}
if calcEclipses: eclipses = {}
for day in np.arange(startSem,endSem+1):
if calcTransits: transits[str(day)] = []
if calcEclipses: eclipses[str(day)] = []
planetsNeverUp = []
def azToDirection(az):
az = float(az)
if (az >= 0 and az < 22.5) or (az >= 337.5 and az < 360): return 'N'
elif az >= 22.5 and az < 67.5: return 'NE'
elif az >= 67.5 and az < 112.5: return 'E'
elif az >= 112.5 and az < 157.5: return 'SE'
elif az >= 157.5 and az < 202.5: return 'S'
elif az >= 202.5 and az < 247.5: return 'SW'
elif az >= 247.5 and az < 292.5: return 'W'
elif az >= 292.5 and az < 337.5: return 'NW'
def ingressEgressAltAz(planet,observatory,ingress,egress):
altitudes = []
directions = []
for time in [ingress,egress]:
observatory.date = list2datestr(jd2gd(time))
star = ephem.FixedBody()
star._ra = ephem.hours(RA(planet))
star._dec = ephem.degrees(dec(planet))
star.compute(observatory)
altitudes.append(str(ephem.degrees(star.alt)).split(":")[0])
directions.append(azToDirection(str(ephem.degrees(star.az)).split(":")[0]))
ingressAlt,egressAlt = altitudes
ingressDir,egressDir = directions
return ingressAlt,ingressDir,egressAlt,egressDir
def aboveHorizonForEvent(planet,observatory,ingress,egress):
altitudes = []
for time in [ingress,egress]:
observatory.date = list2datestr(jd2gd(time))
star = ephem.FixedBody()
star._ra = ephem.hours(RA(planet))
star._dec = ephem.degrees(dec(planet))
star.compute(observatory)
#altitudes.append(str(ephem.degrees(star.alt)).split(":")[0])
altitudes.append(float(repr(star.alt))/(2*np.pi) * 360) ## Convert altitudes to degrees
if altitudes[0] > 0 and altitudes[1] > 0: return True
else: return False
def eventAfterTwilight(planet,observatory,ingress,egress,twilightType):
altitudes = []
for time in [ingress,egress]:
observatory.date = list2datestr(jd2gd(time))
sun = ephem.Sun()
sun.compute(observatory)
altitudes.append(float(repr(sun.alt))/(2*np.pi) * 360) ## Convert altitudes to degrees
if altitudes[0] < float(twilightType) and altitudes[1] < float(twilightType): return True
else: return False
for planet in planets:
'''Compute all of the coming transits and eclipses for a long time out'''
allTransitEpochs = midTransit(epoch(planet),period(planet),startSem,endSem)
allEclipseEpochs = midEclipse(epoch(planet),period(planet),startSem,endSem)
for day in np.arange(startSem,endSem+1,1.0):
try:
'''For each day, gather the transits and eclipses that happen'''
transitEpochs = allTransitEpochs[(allTransitEpochs <= day+0.5)*(allTransitEpochs > day-0.5)]
eclipseEpochs = allEclipseEpochs[(allEclipseEpochs <= day+0.5)*(allEclipseEpochs > day-0.5)]
if calcTransits and len(transitEpochs) != 0:
transitEpoch = transitEpochs[0]
ingress = transitEpoch-duration(planet)/2
egress = transitEpoch+duration(planet)/2
''' Calculate positions of host stars'''
star = ephem.FixedBody()
star._ra = ephem.hours(RA(planet))
star._dec = ephem.degrees(dec(planet))
star.compute(observatory)
exoplanetDB[planet]['Constellation'] = ephem.constellation(star)[0]
'''If star is above horizon and sun is below horizon during transit/eclipse:'''
if aboveHorizonForEvent(planet,observatory,ingress,egress) and eventAfterTwilight(planet,observatory,ingress,egress,twilightType):
ingressAlt,ingressDir,egressAlt,egressDir = ingressEgressAltAz(planet,observatory,ingress,egress)
transitInfo = [planet,transitEpoch,duration(planet)/2,'transit',ingressAlt,ingressDir,egressAlt,egressDir]
transits[str(day)].append(transitInfo)
if calcEclipses and len(eclipseEpochs) != 0:
eclipseEpoch = eclipseEpochs[0]
ingress = eclipseEpoch-duration(planet)/2
egress = eclipseEpoch+duration(planet)/2
''' Calculate positions of host stars'''
star = ephem.FixedBody()
star._ra = ephem.hours(RA(planet))
star._dec = ephem.degrees(dec(planet))
star.compute(observatory)
exoplanetDB[planet]['Constellation'] = ephem.constellation(star)[0]
if aboveHorizonForEvent(planet,observatory,ingress,egress) and eventAfterTwilight(planet,observatory,ingress,egress,twilightType):
ingressAlt,ingressDir,egressAlt,egressDir = ingressEgressAltAz(planet,observatory,ingress,egress)
eclipseInfo = [planet,eclipseEpoch,duration(planet)/2,'eclipse',ingressAlt,ingressDir,egressAlt,egressDir]
eclipses[str(day)].append(eclipseInfo)
except ephem.NeverUpError:
if str(planet) not in planetsNeverUp:
print 'Note: planet %s is never above the horizon at this observing location.' % (planet)
planetsNeverUp.append(str(planet))
def removeEmptySets(dictionary):
'''Remove days where there were no transits/eclipses from the transit/eclipse list dictionary.
Can't iterate through the transits dictionary with a for loop because it would change length
as keys get deleted, so loop through with while loop until all entries are not empty sets'''
dayCounter = startSem
while any(dictionary[day] == [] for day in dictionary):
if dictionary[str(dayCounter)] == []:
del dictionary[str(dayCounter)]
dayCounter += 1
if calcTransits: removeEmptySets(transits)
if calcEclipses: removeEmptySets(eclipses)
events = {}
def mergeDictionaries(dict):
for key in dict:
if any(key == eventKey for eventKey in events) == False: ## If key does not exist in events,
if np.shape(dict[key])[0] == 1: ## If new event is the only one on that night, add only it
events[key] = [dict[key][0]]
else: ## If there were multiple events that night, add them each
events[key] = []
for event in dict[key]:
events[key].append(event)
else:
if np.shape(dict[key])[0] > 1: ## If there are multiple entries to append,
for event in dict[key]:
events[key].append(event)
else: ## If there is only one to add,
events[key].append(dict[key][0])
if calcTransits: mergeDictionaries(transits)
if calcEclipses: mergeDictionaries(eclipses)
if textOut:
allKeys = events.keys()
allKeys = np.array(allKeys)[np.argsort(allKeys)]
report = open(os.path.join(os.path.dirname(oscaar.__file__),'extras','eph','ephOutputs','eventReport.csv'),'w')
firstLine = 'Planet,Event,Ingress Date, Ingress Time (UT) ,Altitude at Ingress,Azimuth at Ingress,Egress Date, Egress Time (UT) ,Altitude at Egress,Azimuth at Egress,V mag,Depth,Duration,RA,Dec,Const.,Mass,Semimajor Axis (AU),Radius (R_J)\n'
report.write(firstLine)
for key in allKeys:
def writeCSVtransit():
middle = ','.join([planet[0],str(planet[3]),list2datestrCSV(jd2gd(float(planet[1]-planet[2]))),planet[4],planet[5],\
list2datestrCSV(jd2gd(float(planet[1]+planet[2]))),planet[6],planet[7],trunc(V(str(planet[0])),2),\
trunc(depth(planet[0]),4),trunc(24.0*duration(planet[0]),2),RA(planet[0]),dec(planet[0]),constellation(planet[0]),\
mass(planet[0]),semimajorAxis(planet[0]),radius(planet[0])])
line = middle+'\n'
report.write(line)
def writeCSVeclipse():
middle = ','.join([planet[0],str(planet[3]),list2datestrCSV(jd2gd(float(planet[1]-planet[2]))),planet[4],planet[5],\
list2datestrCSV(jd2gd(float(planet[1]+planet[2]))),planet[6],planet[7],trunc(V(str(planet[0])),2),\
trunc(depth(planet[0]),4),trunc(24.0*duration(planet[0]),2),RA(planet[0]),dec(planet[0]),constellation(planet[0]),\
mass(planet[0]),semimajorAxis(planet[0]),radius(planet[0])])
line = middle+'\n'
report.write(line)
if np.shape(events[key])[0] > 1:
elapsedTime = []
for i in range(1,len(events[key])):
nextPlanet = events[key][1]
planet = events[key][0]
double = False
'''If the other planet's ingress is before this one's egress, then'''
if ephem.Date(list2datestr(jd2gd(float(nextPlanet[1]-nextPlanet[2])))) -\
ephem.Date(list2datestr(jd2gd(float(planet[1]+planet[2])))) > 0.0:
double = True
elapsedTime.append(ephem.Date(list2datestr(jd2gd(float(nextPlanet[1]-nextPlanet[2])))) - \
ephem.Date(list2datestr(jd2gd(float(planet[1]+planet[2])))))
if ephem.Date(list2datestr(jd2gd(float(planet[1]-planet[2])))) - \
ephem.Date(list2datestr(jd2gd(float(nextPlanet[1]+nextPlanet[2])))) > 0.0:
'''If the other planet's egress is before this one's ingress, then'''
double = True
elapsedTime.append(ephem.Date(list2datestr(jd2gd(float(planet[1]-planet[2])))) - \
ephem.Date(list2datestr(jd2gd(float(nextPlanet[1]+nextPlanet[2])))))
for planet in events[key]:
if calcTransits and planet[3] == 'transit':
writeCSVtransit()
if calcEclipses and planet[3] == 'eclipse':
writeCSVeclipse()
elif np.shape(events[key])[0] == 1:
planet = events[key][0]
if calcTransits and planet[3] == 'transit':
writeCSVtransit()
if calcEclipses and planet[3] == 'eclipse':
writeCSVeclipse()
# report.write('\n')
report.close()
#print exoplanetDB['HD 209458 b']
print 'calculateEphemerides.py: Done'
if htmlOut:
'''Write out a text report with the transits/eclipses. Write out the time of
ingress, egress, whether event is transit/eclipse, elapsed in time between
ingress/egress of the temporally isolated events'''
report = open(os.path.join(os.path.dirname(oscaar.__file__),'extras','eph','ephOutputs','eventReport.html'),'w')
allKeys = events.keys()
## http://www.kryogenix.org/code/browser/sorttable/
htmlheader = '\n'.join([
'<!doctype html>',\
'<html>',\
' <head>',\
' <meta http-equiv="content-type" content="text/html; charset=UTF-8" />',\
' <title>Ephemeris</title>',\
' <link rel="stylesheet" href="stylesheetEphem.css" type="text/css" />',\
' <script type="text/javascript">',\
' function changeCSS(cssFile, cssLinkIndex) {',\
' var oldlink = document.getElementsByTagName("link").item(cssLinkIndex);',\
' var newlink = document.createElement("link")',\
' newlink.setAttribute("rel", "stylesheet");',\
' newlink.setAttribute("type", "text/css");',\
' newlink.setAttribute("href", cssFile);',\
' document.getElementsByTagName("head").item(0).replaceChild(newlink, oldlink);',\
' }',\
' </script>',\
' <script src="./sorttable.js"></script>',\
' </head>',\
' <body>',\
' <div id="textDiv">',\
' <h1>Ephemerides for: '+observatory_name+'</h1>',\
' <h2>Observing dates (UT): '+list2datestr(jd2gd(startSem)).split(' ')[0]+' - '+list2datestr(jd2gd(endSem)).split(' ')[0]+'</h2>'
' Click the column headers to sort. ',\
' <table class="daynight" id="eph">',\
' <tr><th colspan=2>Toggle Color Scheme</th></tr>',\
' <tr><td><a href="#" onclick="changeCSS(\'stylesheetEphem.css\', 0);">Day</a></td><td><a href="#" onclick="changeCSS(\'stylesheetEphemDark.css\', 0);">Night</a></td></tr>',\
' </table>'])
tableheader = '\n'.join([
'\n <table class="sortable" id="eph">',\
' <tr> <th>Planet<br /><span class="small">[Link: Orbit ref.]</span></th> <th>Event</th> <th>Ingress <br /><span class="small">(MM/DD<br />HH:MM, UT)</span></th> <th>Egress <br /><span class="small">(MM/DD<br />HH:MM, UT)</span></th>'+\
'<th>V mag</th> <th>Depth<br />(mag)</th> <th>Duration<br />(hrs)</th> <th>RA/Dec<br /><span class="small">[Link: Simbad ref.]</span></th> <th>Const.</th> <th>Mass<br />(M<sub>J</sub>)</th>'+\
'<th>Semimajor <br />Axis (AU)</th> <th>Radius<br />(R<sub>J</sub>)</th></tr>'])
tablefooter = '\n'.join([
'\n </table>',\
' <br /><br />',])
htmlfooter = '\n'.join([
'\n <p class="headinfo">',\
' Developed by Brett Morris with great gratitude for the help of <a href="http://rhodesmill.org/pyephem/">PyEphem</a>,<br/>',\
' and for up-to-date exoplanet parameters from <a href="http://www.exoplanets.org/">exoplanets.org</a> (<a href="http://adsabs.harvard.edu/abs/2011PASP..123..412W">Wright et al. 2011</a>).<br />',\
' </p>',\
' </div>',\
' </body>',\
'</html>'])
report.write(htmlheader)
report.write(tableheader)
allKeys = np.array(allKeys)[np.argsort(allKeys)]
for key in allKeys:
def writeHTMLtransit():
indentation = ' '
middle = '</td><td>'.join([nameWithLink(planet[0]),str(planet[3]),list2datestrHTML(jd2gd(float(planet[1]-planet[2])),planet[4],planet[5]),\
list2datestrHTML(jd2gd(float(planet[1]+planet[2])),planet[6],planet[7]),trunc(V(str(planet[0])),2),\
trunc(depth(planet[0]),4),trunc(24.0*duration(planet[0]),2),RADecHTML(planet[0]),constellation(planet[0]),\
mass(planet[0]),semimajorAxis(planet[0]),radius(planet[0])])
line = indentation+'<tr><td>'+middle+'</td></tr>\n'
report.write(line)
def writeHTMLeclipse():
indentation = ' '
middle = '</td><td>'.join([nameWithLink(planet[0]),str(planet[3]),list2datestrHTML(jd2gd(float(planet[1]-planet[2])),planet[4],planet[5]),\
list2datestrHTML(jd2gd(float(planet[1]+planet[2])),planet[6],planet[7]),trunc(V(str(planet[0])),2),\
'---',trunc(24.0*duration(planet[0]),2),RADecHTML(planet[0]),constellation(planet[0]),\
mass(planet[0]),semimajorAxis(planet[0]),radius(planet[0])])
line = indentation+'<tr><td>'+middle+'</td></tr>\n'
report.write(line)
if np.shape(events[key])[0] > 1:
elapsedTime = []
for i in range(1,len(events[key])):
nextPlanet = events[key][1]
planet = events[key][0]
double = False
'''If the other planet's ingress is before this one's egress, then'''
if ephem.Date(list2datestr(jd2gd(float(nextPlanet[1]-nextPlanet[2])))) -\
ephem.Date(list2datestr(jd2gd(float(planet[1]+planet[2])))) > 0.0:
double = True
elapsedTime.append(ephem.Date(list2datestr(jd2gd(float(nextPlanet[1]-nextPlanet[2])))) - \
ephem.Date(list2datestr(jd2gd(float(planet[1]+planet[2])))))
if ephem.Date(list2datestr(jd2gd(float(planet[1]-planet[2])))) - \
ephem.Date(list2datestr(jd2gd(float(nextPlanet[1]+nextPlanet[2])))) > 0.0:
'''If the other planet's egress is before this one's ingress, then'''
double = True
elapsedTime.append(ephem.Date(list2datestr(jd2gd(float(planet[1]-planet[2])))) - \
ephem.Date(list2datestr(jd2gd(float(nextPlanet[1]+nextPlanet[2])))))
for planet in events[key]:
if calcTransits and planet[3] == 'transit':
writeHTMLtransit()
if calcEclipses and planet[3] == 'eclipse':
writeHTMLeclipse()
elif np.shape(events[key])[0] == 1:
planet = events[key][0]
if calcTransits and planet[3] == 'transit':
writeHTMLtransit()
if calcEclipses and planet[3] == 'eclipse':
writeHTMLeclipse()
report.write(tablefooter)
report.write(htmlfooter)
report.close()
def setup_observatory(self):
"""Method to generate an ephem.Observer object, with hardcoded options.
"""
#If an ephem.Observer object has been passed, use that.
if isinstance(self.obs, ephem.Observer):
observer = obs
#If it is an observatory name, set up the appropriate Observer object.
else:
observer = ephem.Observer()
if obs == 'keck':
observer.long, observer.lat = '-155:28.7', '19:49.7'
observer.elevation = 4160
elif obs == 'lick':
observer.long, observer.lat = '-121:38.2', '37:20.6'
observer.elevation = 1290
elif obs == 'palomar':
observer.long, observer.lat = '-116:51:50', '33:21:21'
observer.elevation = 1712
elif obs == 'flwo':
observer.long, observer.lat = '-110:52.7', '31:40.8'
observer.elevation = 2606
elif obs == 'lapalma':
observer.long, observer.lat = '-17:53.6', '28:45.5'
observer.elevation = 2396
elif obs == 'ctio':
observer.long, observer.lat = '-70:48:54', '-30:9.92'
observer.elevation = 2215
elif obs == 'dct' or obs == 'happyjack':
observer.long, observer.lat = '-111:25:20', '34:44:40'
observer.elevation = 2360
elif obs == 'andersonmesa':
observer.long, observer.lat = '-111:32:09', '30:05:49'
observer.elevation = 2163
elif obs == 'mtbigelow' or obs == 'catalina':
observer.long, observer.lat = '-110:44:04.3', '32:24:59.3'
observer.elevation = 2518
elif obs == 'mtgraham':
observer.long, observer.lat = '-109:53:23', '32:42:05'
observer.elevation = 3221
elif obs == 'kpno':
observer.long, observer.lat = '-111:25:48', '31:57:30'
observer.elevation = 2096
elif obs == 'cerropachon':
observer.long, observer.lat = '-70:44:11.7', '-30:14:26.6'
observer.elevation = 2722
elif obs == 'lasilla':
observer.long, observer.lat = '-70:43:53', '-29:15:40'
observer.elevation = 2400
elif obs == 'cerroparanal':
observer.long, observer.lat = '-70:24:15', '-24:37:38'
observer.elevation = 2635
elif obs == 'calaralto':
observer.long, observer.lat = '-02:32:46', '+37:13:25'
observer.elevation = 2168
elif obs == 'lascampanas':
observer.long, observer.lat = '-70:41:33', '-29:00:53'
observer.elevation = 2380
elif obs == 'saao':
observer.long, observer.lat = '-32:22:42', '+20:48:38'
observer.elevation = 1798
elif obs == 'sidingspring':
observer.long, observer.lat = '-31:16:24', '+149:04:16'
observer.elevation = 1116
#self.observer = observer
return observer
# pyephem needs yyyy/mm/dd format
# correct time format is e.g. starttime = '2015/10/15 04:00:00'
starttime = line.split("=")[-1].replace('-', '/')
if line.find("Observation.Beam[%s].subbandList" % (sap)) >= 0:
subbandlist = line.split("=")[-1]
file.close()
# convert to HHMMSS
src = ephem.FixedBody()
src._ra = float(rarad)
src._dec = float(decrad)
# Estimate the beam shape, only for HBA data
# set up the observatory
src._epoch = ephem.J2000
telescope = ephem.Observer()
telescope.lat = ephem.degrees('52.91511')
telescope.long = ephem.degrees('6.869883')
telescope.elevation = 0
telescope.date = ephem.Date(starttime)
src.compute(telescope)
# calculate the approximate beam size
LOW_FREQ = ????? # SET YOUR BOTTOM OBS FREQUENCY HERE!
BW = ????? # SET YOUR BANDWIDTH HERE!
# CHAN_BW = ????? # SET YOUR CHANNEL BANDWIDTH HERE!
#BOTTOMSUBBAND = float(re.findall(r"\d+", subbandlist)[0])
#l = 300.0 / (LOW_FREQ + chan_bw * BOTTOMSUBBAND) # bottom wavelength in m
l = 300.0 / (LOW_FREQ + BW / 2) # high wavelength in m
#!/usr/bin/env python
import os
import sys
import ephem
import numpy as np
import tables as tb
from leda_cal.leda_cal import *
from leda_cal.params import params
ovro_location = ('37.2397808', '-118.2816819', 1183.4839)
ovro = ephem.Observer(); (ovro.lat, ovro.lon, ovro.elev) = ovro_location
sun = ephem.Sun()
gal_center = ephem.FixedBody()
gal_center._ra = '17 45 40.04'
gal_center._dec = '-29 00 28.1'
gal_center.name = "Galactic Center"
def main(args, all_lsts):
filenames = args
results = {}
for filename in filenames:
print "Working on '%s'" % os.path.basename(filename)
h5 = tb.open_file(filename)
T_ant = apply_calibration(h5)
lst_stamps = T_ant['lst']
if len(lst_stamps) == 0:
print "No LSTS in file"
continue
import math
import ephem
import datetime
#Penentuan Lintasan Arah Kiblat Harian
latitudkaabah = 21+25/60+21/3600
longitudkaabah = 39+49/60+34.32/3600
print("Masukkan Nama Tempat")
namatempat = str(input())
print("Masukkan Koordinate Tempat yang ingin Dikira Kiblatnya")
lokasi = ephem.Observer()
print("Masukkan Latitud (Utara = Positif, Selatan=Negatif)")
lokasi.lat = input()
print("Masukkan Longitud(Timur = Positif, Barat=Negatif)")
lokasi.long = input()
print("Masukkan Hari")
day = int(input())
print("Masukkan Bulan")
month = int(input())
print("Masukkan Tahun")
year = int(input ())
time = 0
print("Masukkan Time Zone")
tz = int(input())
tz1 = time - tz
def scheduler_map(request, size=600):
targets = SchedulerTargets.objects.order_by('-time_created').exclude(
ra__isnull=True)
# SAO location
obs = ephem.Observer()
obs.lat = deg2rad(settings.LATITUDE)
obs.lon = deg2rad(settings.LONGITUDE)
obs.elevation = settings.ELEVATION
obs.pressure = 0.0
# Current zenith position
z = obs.radec_of(0, 90)
st = rad2deg(z[0]) # stellar time in degrees
fig = Figure(facecolor='white',
dpi=72,
figsize=(size / 72, size / 72),
tight_layout=True)
ax = fig.add_subplot(111)
# set up orthographic map projection
map = Basemap(projection='ortho',
lat_0=rad2deg(obs.lat),
lon_0=-st,
resolution=None,
celestial=True,
ax=ax)
# draw the edge of the map projection region (the projection limb)
map.drawmapboundary()
# draw and label ra/dec grid lines every 30 degrees.
degtoralabel = lambda deg: "$%d^h$" % int(deg / 15)
degtodeclabel = lambda deg: "%+d$^\circ$" % deg
map.drawparallels(np.arange(-90, 90, 30),
color='lightgray') #, fmt=degtodeclabel)
map.drawmeridians(np.arange(0, 360, 45), color='lightgray')
for h in [0, 3, 6, 9, 12, 15, 18, 21]:
try:
x, y = map(h * 15, 0)
if abs(x) < 1e10 and abs(y) < 1e10:
ax.text(x, y, degtoralabel(h * 15), color='black')
except:
pass
# Place stars
star_size = [10 * (10**(-0.4 * v)) for v in tycho2['v']]
px, py = map(tycho2['ra'], tycho2['dec'])
map.scatter(px, py, s=star_size, c='gray')
# Sun
s = ephem.Sun()
s.compute(obs)
px, py = map(rad2deg(s.ra), rad2deg(s.dec))
if abs(px) < 1e10 and abs(py) < 1e10:
map.scatter(px, py, s=2000, c='lightgray', marker='o')
ax.text(px, py, "Sun", color='black', va='center', ha='center')
# Moon
m = ephem.Moon()
m.compute(obs)
px, py = map(rad2deg(m.ra), rad2deg(m.dec))
if abs(px) < 1e10 and abs(py) < 1e10:
map.scatter(px, py, s=1200, c='lightgray', marker='o')
ax.text(px, py, "Moon", color='black', va='center', ha='center')
mp, ip, cp = None, None, None
for target in targets:
if target.status.name == 'completed' or target.status.name == 'archived' or target.status.name == 'inactive' or target.status.name == 'failed':
continue
px, py = map(target.ra, target.dec)
if abs(px) < 1e10 and abs(py) < 1e10:
if target.type == 'monitoring':
mp = map.scatter(px,
py,
marker='o',
s=300,
alpha=0.3,
color='blue')
elif target.type == 'imaging':
ip = map.scatter(px,
py,
marker='o',
s=300,
alpha=0.3,
color='green')
else:
cp = map.scatter(px,
py,
marker='o',
s=300,
alpha=0.3,
color='yellow')
ax.text(px, py, target.name, color='black', va='bottom', ha='left')
# Title etc
ax.set_title("%s UT, Sidereal %s" % (obs.date, (ephem.hours(deg2rad(st)))))
if cp or mp or ip:
fig.legend([mp, ip, cp], ["Monitoring", "Imaging", "Custom"],
loc=4).draw_frame(False)
# Return the image
canvas = FigureCanvas(fig)
response = HttpResponse(content_type='image/png')
canvas.print_png(response, bbox_inches='tight')
return response
print('Pan axis (x-axis) PID gains kpx=', params.kpx, 'kix=', params.kix,
'kdx=', params.kdx)
print('Tilt axis (t-axis) PID gains kpy=', params.kpy, 'kiy=', params.kiy,
'kdy=', params.kdy)
#Define tracking/data collection parameters
track_time = params.track_time #20 #number of seconds to capture data/track
hz = params.hz #15 #data sample rate
cnt = 0
delay = 1.0 / hz
#Define directory to save data in
save_dir = params.save_dir #'C:/git_repos/GLO/Tutorials/tracking/'
#Obtain ephemeris data
ep = ephem.Observer()
#Establish communication with sun sensor/s - store in a list
ss = [
SS(inst_id=params.ss1_inst_id,
com_port=params.ss1_com_port,
baudrate=params.ss1_baud_rate),
SS(inst_id=params.ss2_inst_id,
com_port=params.ss2_com_port,
baudrate=params.ss2_baud_rate),
SS(inst_id=params.ss3_inst_id,
com_port=params.ss3_com_port,
baudrate=params.ss3_baud_rate)
]
#List of sun sensors to read data from (reduce number of sensors to increase sampling rate)
def ephem_doponly(maindir, tleoff=10.0):
"""
This function will output a dictionary that can be used to remove the
frequency offset.
Args:
maindir (:obj:'str'): Directory that holds the digital rf and metadata.
tleoff (:obj:'float'): Offset of the tle from the actual data.
Returns:
outdict (dict[str, obj]): Output data dictionary::
{
't': Time in posix,
'dop1': Doppler frequency of 150 MHz channel from TLE ,
'dop2': Doppler frequency of 400 MHz channel from TLE ,
}
"""
#%% Get Ephem info
# Assuming this will stay the same
ut0 = 25567.5
e2p = 3600.0 * 24 # ephem day to utc seconds
sitepath = os.path.expanduser(os.path.join(maindir,
"metadata/config/site"))
sitemeta = drf.DigitalMetadataReader(sitepath)
sdict = sitemeta.read_latest()
sdict1 = list(sdict.values())[0]
infopath = os.path.expanduser(os.path.join(maindir, "metadata/info"))
infometa = drf.DigitalMetadataReader(infopath)
idict = infometa.read_latest()
idict1 = list(idict.values())[0]
passpath = os.path.expanduser(os.path.join(maindir, "metadata/pass/"))
passmeta = drf.DigitalMetadataReader(passpath)
pdict = passmeta.read_latest()
pdict1 = list(pdict.values())[0]
rtime = (pdict1["rise_time"] - ut0) * e2p
tsave = list(pdict.keys())[0]
Dop_bw = pdict1["doppler_bandwidth"]
t = sp.arange(0, (Dop_bw.shape[0] + 1) * 10, 10.0) + rtime
t = t.astype(float)
obsLoc = ephem.Observer()
obsLoc.lat = sdict1["latitude"]
obsLoc.long = sdict1["longitude"]
satObj = ephem.readtle(idict1["name"], idict1["tle1"][1:-1],
idict1["tle2"][1:-1])
tephem = (t - rtime) * ephem.second + pdict1["rise_time"]
sublat = sp.zeros_like(tephem)
sublon = sp.zeros_like(tephem)
for i, itime in enumerate(tephem):
obsLoc.date = itime
satObj.compute(obsLoc)
sublat[i] = sp.rad2deg(satObj.sublat)
sublon[i] = sp.rad2deg(satObj.sublong)
# XXX Extend t vector because for the most part the velocities at the edge
# are not changing much so to avoid having the interpolation extrapolate.
# If extrapolation used then error messages that the time was off
t[-1] = t[-1] + 600
t[-2] = t[-2] + 500
t[0] = t[0] - 240
tdop = (t[0:(len(t) - 1)] + t[1:len(t)]) / 2.0
tdop[0] = tdop[0] - 35.0
# XXX Used this to line up inital TLE times
tdop = tdop - tleoff
tephem = (tdop - rtime) * ephem.second + pdict1["rise_time"]
sublat = sp.zeros_like(tephem)
sublon = sp.zeros_like(tephem)
for i, itime in enumerate(tephem):
obsLoc.date = itime
satObj.compute(obsLoc)
sublat[i] = sp.rad2deg(satObj.sublat)
sublon[i] = sp.rad2deg(satObj.sublong)
return {
"t": t,
"tsave": tsave,
"dop1": sp.interpolate.interp1d(tdop, Dop_bw[:, 0], kind="cubic"),
"dop2": sp.interpolate.interp1d(tdop, Dop_bw[:, 1], kind="cubic"),
"sublat": sp.interpolate.interp1d(tdop, sublat, kind="cubic"),
"sublon": sp.interpolate.interp1d(tdop, sublon, kind="cubic"),
"site_latitude": float(sdict1["latitude"]),
"site_longitude": float(sdict1["longitude"]),
}
def alerts_map(request, night='', state='all', size=800):
alerts = Alerts.objects.order_by('time')
time = None
if night and night != 'all':
alerts = alerts.filter(night=night)
time = get_time_from_night(night)
ra, dec = [], []
N = 0
N0 = 0
Nf = 0
for alert in alerts:
ra.append(alert.ra)
dec.append(alert.dec)
N0 += 1
if RealtimeObjects.objects.filter(channel_id=alert.channel_id).filter(
time_start=alert.time).exists():
N += 1
if Images.objects.filter(type='alert').extra(
where=["keywords->'TARGET'='alert_%s'" % alert.id]).exists():
Nf += 1
# Map
fig = Figure(facecolor='white',
dpi=72,
figsize=(size / 72, 0.6 * size / 72),
tight_layout=True)
ax = fig.add_subplot(111)
# set up gnomonic map projection
map = Basemap(projection='hammer',
lat_0=0,
lon_0=0,
resolution=None,
celestial=True,
ax=ax)
# draw the edge of the map projection region (the projection limb)
map.drawmapboundary()
# draw and label ra/dec grid lines every 30 degrees.
degtoralabel = lambda deg: "$%d^h$" % int(deg / 15)
degtodeclabel = lambda deg: "%+d$^\circ$" % deg
map.drawparallels(np.arange(-90, 90, 30),
color='lightgray') #, fmt=degtodeclabel)
map.drawmeridians(np.arange(0, 360, 45), color='lightgray')
for h in [0, 3, 6, 9, 12, 15, 18, 21]:
try:
x, y = map(h * 15, 0)
if abs(x) < 1e10 and abs(y) < 1e10:
ax.text(x, y, degtoralabel(h * 15), color='black')
except:
pass
# Place stars
star_size = [10 * (10**(-0.4 * v)) for v in tycho2['v']]
px, py = map(tycho2['ra'], tycho2['dec'])
map.scatter(px, py, s=star_size, c='gray', edgecolors='None')
# Sun and Moon
if time is not None:
# SAO location
obs = ephem.Observer()
obs.lat = np.deg2rad(settings.LATITUDE)
obs.lon = np.deg2rad(settings.LONGITUDE)
obs.elevation = settings.ELEVATION
obs.pressure = 0.0
obs.date = time
s = ephem.Sun()
s.compute(obs)
px, py = map(np.rad2deg(s.ra), np.rad2deg(s.dec))
if abs(px) < 1e10 and abs(py) < 1e10:
map.scatter(px, py, s=2000, c='lightgray', marker='o')
ax.text(px, py, "Sun", color='black', va='center', ha='center')
# anti-Sun
as_ra = (np.rad2deg(s.ra) + 180) % 360
as_dec = -np.rad2deg(s.dec)
px, py = map(as_ra, as_dec)
if abs(px) < 1e10 and abs(py) < 1e10:
map.scatter(px,
py,
s=2000,
c='lightgray',
marker='o',
linestyle='--',
alpha=0.5)
ax.text(px,
py,
"Anti\nSun",
color='black',
va='center',
ha='center',
alpha=0.5)
m = ephem.Moon()
m.compute(obs)
px, py = map(np.rad2deg(m.ra), np.rad2deg(m.dec))
if abs(px) < 1e10 and abs(py) < 1e10:
map.scatter(px, py, s=1200, c='lightgray', marker='o')
ax.text(px, py, "Moon", color='black', va='center', ha='center')
# Alerts
if alerts:
px, py = map(ra, dec)
map.scatter(px,
py,
s=100,
c='red',
marker='*',
edgecolors='blue',
linewidths=0.3)
# Title
if night and night != 'all':
fig.suptitle("Realtime Alerts for night %s" % night)
else:
fig.suptitle("Realtime Alerts")
ax.set_title("%d alerts, %d with objects, %d followed up" % (N0, N, Nf))
# Return the image
canvas = FigureCanvas(fig)
response = HttpResponse(content_type='image/png')
canvas.print_png(response, bbox_inches='tight')
return response
def __init__(self):
"""Create the TCC Frame"""
wx.Frame.__init__(self, None, -1, self.title,
size=(900, 675)) #Wxpython frame object
#############################################################
#Dictionaries of relevant telescope information
#Most of Bifrost's functions rely on and alter the contents of these dictionaries.
#Bifrost has been designed such that these dictionaries provide a quick summary of the overall observing
#session.
#Telescope Status: Contains information on dynamic processes in GUI operation
self.telescope_status = {
'connectState': False,
'RA': 'Unknown',
'Dec': 'Unknown',
'slewing': False,
'tracking': False,
'guiding': False,
'pointState': False,
'precession': True,
'initState': False,
'guider_rot': False
}
#Initilization Status: Contains information on (typically) static processes in GUI operation or information
#from past observing sessions.
self.dict = {
'lat': None,
'lon': None,
'elevation': None,
'lastRA': None,
'lastDEC': None,
'lastGuiderRot': None,
'lastFocusPos': None,
'maxdRA': None,
'maxdDEC': None,
'RAtrackingRate': None
}
#Target Coordinates: For pointing, align telescope coordinates with these values once pointing is carried out.
self.target_coords = {"Name": None, "RA": None, "Dec": None}
#############################################################
#Additional variables
self.protocol = None # twisted python connection protocol to server, overwrite during connection
self.server = DataForwardingProtocol(
) # Twisted Python server identification
self.calculate = True # Flag for dynamic airmass calculation
self.night = True # Send GUI to night mode
self.export_active = False # Track the status of the export target list window
self.d_color = wx.SystemSettings.GetColour(
wx.SYS_COLOUR_BACKGROUND) #Default background color for OS
self.list_count = 0 #Tracks the number of targets currently in the targetlist.
self.active_threads = {} #Keep track of threads open in GUI
self.thread_to_close = -1
self.current_timezone = "PST" #Current timezone is Pacific Standard Time at MRO
self.mro = ephem.Observer(
) #Ephem object for mro location (To do: Roll this into Astroplan's Observer object)
self.mrolat = 46.9528 * u.deg #Latitude of Manastash Ridge Observatory
self.MRO = Observer(
longitude=-120.7278 * u.deg, #Astroplan Observer Object for MRO
latitude=46.9528 * u.deg,
elevation=1198 * u.m,
name="Manastash Ridge Observatory")
#self.at_MRO = True #Dev variable for ease of development offsite
self.process_list = []
debug = True #Debug mode, currently no functionality
ico = wx.Icon("bifrost_small.ico", wx.BITMAP_TYPE_ICO) #GUI Icon
self.SetIcon(ico)
self.dir = os.getcwd() #Current path for file IO
#if self.at_MRO == True:
self.stordir = "/home/mro/storage/tcc_data"
#else:
#self.stordir = self.dir
self.plot_open = False
self.code_timer_W = wx.Timer(self)
self.code_timer_E = wx.Timer(self)
self.code_timer_N = wx.Timer(self)
self.code_timer_S = wx.Timer(self)
self.code_timer_Slew = wx.Timer(self)
self.stop_time = 250 #Waiting time for tracking to finish 500 works
#self.targetlists=glob.glob('/home/mro/Desktop/targetlists/*')
#self.targetlists=glob.glob('/home/doug/TCC/targetlists/*')
#############################################################
#Setup Notebook
p = wx.Panel(self)
nb = wx.Notebook(p)
controlPage = Control(nb, debug, self.night) #Telescope Control Tab
targetPage = Target(nb, debug, self.night) #Target List Tab
guiderControlPage = GuiderControl(nb, debug,
self.night) #Guider Control Tab
initPage = Initialization(nb, debug, self.night) #Initialization Tab
logPage = NightLog(nb, debug, self.night) #Night Log Tab
nb.AddPage(controlPage, "Telescope Control")
self.control = nb.GetPage(0)
nb.AddPage(targetPage, "Target List")
self.target = nb.GetPage(1)
nb.AddPage(guiderControlPage, "Guider Control")
self.guiderControl = nb.GetPage(2)
nb.AddPage(initPage, "Initialization")
self.init = nb.GetPage(3)
#nb.AddPage(logPage,"Night Log")
#self.nl=nb.GetPage(3)
#Control Tab Bindings
self.Bind(wx.EVT_BUTTON, self.startSlew, self.control.slewButton)
self.Bind(wx.EVT_BUTTON, self.toggletracksend,
self.control.trackButton)
self.Bind(wx.EVT_BUTTON, self.pointing, self.control.pointButton)
self.Bind(wx.EVT_BUTTON, self.haltmotion, self.control.stopButton)
self.Bind(wx.EVT_BUTTON, self.Noffset, self.control.jogNButton)
self.Bind(wx.EVT_BUTTON, self.Soffset, self.control.jogSButton)
self.Bind(wx.EVT_BUTTON, self.Eoffset, self.control.jogEButton)
self.Bind(wx.EVT_BUTTON, self.Woffset, self.control.jogWButton)
self.Bind(wx.EVT_BUTTON, self.focusIncPlus,
self.control.focusIncPlusButton)
self.Bind(wx.EVT_BUTTON, self.focusIncNeg,
self.control.focusIncNegButton)
self.Bind(wx.EVT_BUTTON, self.setfocus, self.control.focusAbsMove)
#Target Tab Bindings
self.Bind(wx.EVT_BUTTON, self.set_target, self.target.selectButton)
self.Bind(wx.EVT_BUTTON, self.addToList, self.target.enterButton)
self.Bind(wx.EVT_BUTTON, self.populateCurrPos, self.target.popButton)
self.Bind(wx.EVT_BUTTON, self.readToList, self.target.listButton)
self.Bind(wx.EVT_BUTTON, self.removeFromList, self.target.removeButton)
self.Bind(wx.EVT_BUTTON, self.ExportOpen, self.target.exportButton)
self.Bind(wx.EVT_BUTTON, self.target_plot, self.target.plot_button)
self.Bind(wx.EVT_BUTTON, self.airmass_plot, self.target.airmass_button)
self.Bind(wx.EVT_BUTTON, self.FinderOpen, self.target.finder_button)
#self.Bind(wx.EVT_BUTTON,self.refreshList,self.target.refresh_button)
#Guider Control Tab Bindings
#self.Bind(wx.EVT_BUTTON,self.on_Rot,self.guiderControl.guiderRotButton)
# Init Tab Bindings
self.Bind(wx.EVT_BUTTON, self.setTelescopeZenith,
self.init.atZenithButton)
self.Bind(wx.EVT_BUTTON, self.setTelescopePosition,
self.init.syncButton)
self.Bind(wx.EVT_BUTTON, self.onInit, self.init.initButton)
self.Bind(wx.EVT_BUTTON, self.setRATrackingRate,
self.init.rateRAButton)
self.Bind(wx.EVT_BUTTON, self.resetRATrackingRate,
self.init.resetTRButton)
self.Bind(wx.EVT_BUTTON, self.setmaxdRA, self.init.dRAButton)
self.Bind(wx.EVT_BUTTON, self.setmaxdDEC, self.init.dDECButton)
self.Bind(wx.EVT_BUTTON, self.coverpos, self.init.coverposButton)
self.Bind(wx.EVT_BUTTON, self.parkscope, self.init.parkButton)
#self.Bind(wx.EVT_BUTTON, self.pointing, self.init.onTargetButton)
self.Bind(wx.EVT_TIMER, self.timeW, self.code_timer_W)
self.Bind(wx.EVT_TIMER, self.timeE, self.code_timer_E)
self.Bind(wx.EVT_TIMER, self.timeN, self.code_timer_N)
self.Bind(wx.EVT_TIMER, self.timeS, self.code_timer_S)
self.Bind(wx.EVT_TIMER, self.timeSlew, self.code_timer_Slew)
self.createMenu()
self.sb = self.CreateStatusBar(5)
self.sb.SetStatusWidths([150, 150, 150, -2, -1])
sizer = wx.BoxSizer()
sizer.Add(nb, 1, wx.EXPAND | wx.ALL)
p.SetSizer(sizer)
p.Layout()
#############################################################
self.readConfig()
"""Target testing parameters """
#self.target.nameText.SetValue('M31')
#self.target.raText.SetValue('00h42m44.330s')
#self.target.decText.SetValue('+41d16m07.50s')
#self.target.epochText.SetValue('J2000')
#self.target.magText.SetValue('3.43')
img_default = os.path.join(self.dir, 'gimg', 'gcam_56901_859.jpg')
img = mpimg.imread(img_default)
def astro_parameter_calculate(utc_datetime):
homedir = os.getcwd()
conf_obs_parameters_sys = './conf_obs_parameters_sys.dat'
conf_obs_parameters_sys_dev = open(conf_obs_parameters_sys, 'rU')
lines2 = conf_obs_parameters_sys_dev.read().splitlines()
conf_obs_parameters_sys_dev.close()
for line2 in lines2:
word = line2.split()
if word[0] == 'observatory_lat':
observatory_lat = word[2]
elif word[0] == 'observatory_lon':
observatory_lon = word[2]
elif word[0] == 'observatory_elevation':
observatory_elevation = float(word[2])
elif word[0] == 'zenith_sun_min':
zenith_sun_min = float(word[2])
elif word[0] == 'zenith_min':
zenith_min = float(word[2])
elif word[0] == 'gal_min':
gal_min = float(word[2])
elif word[0] == 'moon_dis_min_para':
moon_dis_min_str = word[2]
moon_dis_para_str = moon_dis_min_str.split('|')
moon_dis_phase_data = [[]]
for moon_dis_para in moon_dis_para_str:
moon_dis_para_phase_min = float(
moon_dis_para.split(':')[0].split('-')[0])
moon_dis_para_phase_max = float(
moon_dis_para.split(':')[0].split('-')[1])
moon_dis_para_dis = float(moon_dis_para.split(':')[1])
moon_dis_phase_data.append([
moon_dis_para_phase_min, moon_dis_para_phase_max,
moon_dis_para_dis
])
moon_dis_phase_data = filter(None, moon_dis_phase_data)
# set observatory parameters ----------------------------------------
observatory = ephem.Observer()
observatory.lat = observatory_lat
observatory.lon = observatory_lon
observatory.elevation = observatory_elevation
lat_dd = float(str(observatory.lat).split(":")[0])+\
float(str(observatory.lat).split(":")[1])/60.0+\
float(str(observatory.lat).split(":")[2])/3600.0
# print "utc_datetime", utc_datetime
utc_datetime_str = time.strftime('%Y/%m/%d %H:%M:%S', utc_datetime)
# print "utc_datetime_str",utc_datetime_str
observatory.date = utc_datetime_str
# calculate local time ----------------------------------------
local_time = ephem.localtime(observatory.date)
local_time_str = str(local_time).replace(' ', 'T')
# calculate local sidereal time ----------------------------------------
lst_dd = float(str(observatory.sidereal_time()).split(":")[0])* 15.0+\
float(str(observatory.sidereal_time()).split(":")[1])/60.0* 15.0+\
float(str(observatory.sidereal_time()).split(":")[2])/3600.0* 15.0
# calculate time difference between ut and lst ----------------------------------
ut_time_dd = float(str(observatory.date).split(" ")[1].split(":")[0])* 15.0+\
float(str(observatory.date).split(" ")[1].split(":")[1])/60.0* 15.0+\
float(str(observatory.date).split(" ")[1].split(":")[2])/3600.0* 15.0
lst_ut_dd = lst_dd - ut_time_dd
# print 'lst_ut', observatory.date, local_time,observatory.sidereal_time(), lst_dd,ut_time_dd,lst_ut_dd
# calculate altitude angle or zenith angular distance of the sun ---------------------------------
solar = ephem.Sun(observatory)
solar_alt_dd = 90 - float(str(solar.alt).split(":")[0]) + float(
str(solar.alt).split(":")[1]) / 60.0 + float(
str(solar.alt).split(":")[2]) / 3600.0
#print('solar %s' % (solar_alt_dd))
lunar = ephem.Moon(observatory)
lunar_ra_dd = float(str(lunar.ra).split(":")[0]) * 15.0 + float(
str(lunar.ra).split(":")[1]) / 60.0 * 15.0 + float(
str(lunar.ra).split(":")[2]) / 3600.0 * 15.0
lunar_dec_dd = float(str(lunar.dec).split(":")[0]) + float(
str(lunar.dec).split(":")[1]) / 60.0 + float(
str(lunar.dec).split(":")[2]) / 3600.0
moon_phase = float(lunar.moon_phase)
#print('lunar %s %s %s' % (lunar_ra_dd, lunar_dec_dd, lunar.moon_phase))
return [
lat_dd, local_time_str, lst_dd, solar_alt_dd, lunar_ra_dd,
lunar_dec_dd, lst_ut_dd, moon_dis_phase_data, moon_phase,
zenith_sun_min, zenith_min, gal_min
]
def automate(): #main function for automation
#initialize ephemeris
#pos = ephem.city("Toronto")#need to enter exact coordinates
pos = ephem.Observer()
pos.lon, pos.lat = '-79.39', '43.66'
sun = ephem.Sun()
try:
#dome initialization
sun.compute(pos) #get data on sun
if dome.shutter == 'Unknown': #send dome to starting position if shutter is unknown
dome.write_command('GHOM')
sleep(30)
dome.write_command('GCLS')
sleep(30)
if goodWeather(
) == True and dome.shutter == 'Closed' and sun.alt > 0.15: #send Dome to sun position if weather permits and daytime
dome.write_command('GHOM')
print '\n Sun is out! Going to home position ....\n'
sleep(30)
dome.write_command("GOPN")
print '\n Openning the dome shutter ....\n'
sleep(30)
print '\n Moving the dome to the right position ....\n'
move(57.2958 * float(sun.az) + 10)
sleep(30)
while True: #looping program
pos.date = ephem.now()
sun.compute(pos)
dome.write_command('GINF')
result, message = dome.readfrom()
if result == 1: #check dome info
parseinfo(message)
else:
print '\t Contact Failed. Dome status unknown.'
if dome.shutter == 'Opened':
if sun.alt < 0.15: #closing for night time
dome.write_command('GHOM')
sleep(30)
dome.write_command('GCLS')
for i in range(60):
sleep(1)
print "\nNight time -- Dome closed"
elif goodWeather() == False: #closing for bad weather
dome.write_command('GHOM')
sleep(30)
dome.write_command('GCLS')
sleep(60)
print "\nPoor weather conditions detected -- Dome closed"
elif positionAccurate(
sun.az) == False and goodWeather() == True:
print "\n Sun position and dome position don't match. Checking... \n"
checkMovement(float(sun.az)) #move to track sun
for i in range(10): #wait 10 seconds
sleep(
1
) #enables keyboardinterrupt to be processed right away
else:
if goodWeather(
) == True and sun.alt > 0.15: #opens dome again if conditions allow it
dome.write_command('GHOM')
sleep(30)
dome.write_command("GOPN")
for i in range(30):
sleep(1)
move(57.2958 * float(sun.az) + 10)
sleep(30)
else: #waiting in bad conditions
for i in range(60):
sleep(1)
except KeyboardInterrupt: #allows user to exit infinite loop by pressing ctrl-c
print "\nKeyboardInterrupt -- exiting automation"
return
obpos = GLOBALutils.obspos( longitude, obsradius, R0 )
jplephem.set_ephemeris_dir( baryc_dir , ephemeris )
jplephem.set_observer_coordinates( obpos[0], obpos[1], obpos[2] )
res = jplephem.doppler_fraction(ra/15.0, dec, int(mjd), mjd%1, 1, 0.0)
lbary_ltopo = 1.0 + res['frac'][0]
bcvel_baryc = ( lbary_ltopo - 1.0 ) * 2.99792458E5
print("\t\tBarycentric velocity:", bcvel_baryc)
res = jplephem.pulse_delay(ra/15.0, dec, int(mjd), mjd%1, 1, 0.0)
mbjd = mjd + res['delay'][0] / (3600.0 * 24.0)
# Moon Phase Calculations
gobs = ephem.Observer()
gobs.name='Clay_Mag_2'
gobs.lat=rad(latitude) # lat/long in decimal degrees
gobs.long=rad(longitude)
DDATE = h[0].header['UT-DATE']
HHOUR = h[0].header['UT-TIME']
Mho = HHOUR[:2]
Mmi = HHOUR[3:5]
Mse = HHOUR[6:]
gobs.date = str(DDATE[:4]) + '-' + str(DDATE[5:6]) + '-' + str(DDATE[7:]) + ' ' + Mho + ':' + Mmi +':' +Mse
mephem = ephem.Moon()
mephem.compute(gobs)
Mcoo = jplephem.object_track("Moon", int(mjd), float(mjd%1), 1, 0.0)
Mp = jplephem.barycentric_object_track("Moon", int(mjd), float(mjd%1), 1, 0.0)
Sp = jplephem.barycentric_object_track("Sun", int(mjd), float(mjd%1), 1, 0.0)
res = jplephem.object_doppler("Moon", int(mjd), mjd%1, 1, 0.0)
def only_daytime_overpasses(self, sun):
"""
Return only those which are visible -- this will take awhile i imagine
"""
observer_on_the_ground = ephem.Observer()
observer_on_the_ground.lat = np.radians(self.lat)
observer_on_the_ground.long = np.radians(self.long)
observer_on_the_ground.date = self.datetime
"""
Improvment from
http://stackoverflow.com/questions/15044521/
javascript-or-python-how-do-i-figure-out-if-its-night-or-day
think should work without timezones
-- essentially next sunset should be before the next sunset
For it to be the day time the sunset must be nearer than
the next sunrise
NOTE: towards the poles the sun never rises or sets
depending on time of year. When this happens
pyephem raises an error...
These are some annoying edge cases to deal
with
"""
#import pdb; pdb.set_trace()
try:
next_sunrise= observer_on_the_ground.next_rising(sun).datetime()
next_sunset = observer_on_the_ground.next_setting(sun).datetime()
except (ephem.AlwaysUpError):
# polar summer and sun never sets
# so it must be daytime...
self.daytime = True
sun.compute(observer_on_the_ground)
# can check with solarzenith angle
solZenith = np.degrees(sun.alt)
return None
except (ephem.NeverUpError):
# polar winter and sun never sets
# so it must be nighttime
self.daytime = False
sun.compute(observer_on_the_ground)
# can check with solarzenith angle
solZenith = np.degrees(sun.alt)
return None
# if no exceptions it's not polar and sun does rise and set...
if next_sunset < next_sunrise:
self.daytime = True
elif next_sunset > next_sunrise:
self.daytime = False
else:
import pdb; pdb.set_trace() # something wrong
self.daytime = -1 #error
sun.compute(observer_on_the_ground)
# can check with solarzenith angle
solZenith = np.degrees(sun.alt)
self.solarZenith = solZenith
return None
converge_percent = 0.0001
max_iter = 50
step_size = .3
######################################################################
######################################################################
######################################################################
########Massage user parameters###################################
oppath += '/'
####get some info from the first uvfile ################
print "Getting some basic info from %s" % uvfiles[0],
sys.stdout.flush()
sa = ephem.Observer()
sa.pressure = 0
if input_type == 'odf':
with open(uvfiles[0] + '/header.txt') as f:
for l in f.readlines():
if l.split()[0] == 'nChannels':
nfreq = int(l.split()[1])
elif l.split()[0] == 'nAntennas':
nant = int(l.split()[1])
elif l.split(
)[0] == 'longitude': #odf header has bug that switched lat and lon
sa.lat = float(l.split()[1]) * PI / 180.
elif l.split()[0] == 'latitude':
sa.lon = float(l.split()[1]) * PI / 180.
elif l.split()[0] == 'startFreq':
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""
Created on Wed Jan 4 13:55:58 2017
@author: ahmed
"""
# IMPORTATION
from pylab import *
import ephem as ep
# OBSERVATEUR
obs = ep.Observer()
obs.lon, obs.lat, obs.elev = '10.08', '36.4', 100.0
obs.name = "SAT-TUNIS"
# OBJETS
soleil = ep.Sun()
lune = ep.Moon()
# pas de temps - heure
dt = ep.hour
# temps initial
#ts = ep.now()
ts = ep.Date("2019-01-01 00:00:00")
# heure actuelle
tm = ts
for i in range(365 * 24 * 10):
# nous fixons l'heure actuelle
obs.date = tm
# nous calculons les coordonnées
soleil.compute(obs)
print(
"This program returns the rise and set LSTs for the provided RA and DEC at the requested site"
)
print("e.g. riseset mk 12:34:56 -43:21:00")
print("Site = MeerKAT")
print("Long,Lat = 21:24:40.0 -30:43:16.0")
print("Target Coordinates = 12:34:56.00 -43:21:00.0")
print("Rise Time (LST) = 6:01:30.97")
print("Set Time (LST) = 19:10:28.11")
sys.exit(0)
place = sys.argv[1]
ra = sys.argv[2]
dec = sys.argv[3]
site = ephem.Observer()
# NB. I got all coordinates from wikipedia. Sorry if they are incorrect!
if (place == "jbo" or place == "jodrell"):
site.long = '-2.30715'
site.lat = '53.23700'
site.elevation = 0
place = "Jodrell Bank"
elif (place == "birr" or place == "Birr" or place == "I-LOFAR"
or place == "ilofar"):
site.long = '-7.9133'
site.lat = '53.0914'
site.elevation = 0
place = "Birr"
elif (place == "eff" or place == "effelsberg"):
site.long = '6:52:58'
import ephem from datetime import * from time import strftime #Make an observer fred = ephem.Observer() #PyEphem takes and returns only UTC times. 15:00 is noon in Fredericton fred.date = datetime.today() #Location of Fredericton, Canada #fred.lon = str(-66.666667) #Note that lon should be in string format #fred.lat = str(45.95) #Note that lat should be in string format# #Elevation of Fredericton, Canada, in metres #fred.elev = 20 #To get U.S. Naval Astronomical Almanac values, use these settings #fred.pressure= 0 #fred.horizon = '-0:34' #Location of New York, NY fred.lon = str(-73.9400) fred.lat = str(40.6700) #Elevation of New York, NY in meters fred.elev = 56.6928 fred.pressure = 0 fred.horizon = '-0:34' sunrise = fred.previous_rising(ephem.Sun()) #Sunrise
def ut2Mjd(dateString):
obs = ephem.Observer()
obs.date = dateString
doff = ephem.Date(0) - ephem.Date('1858/11/17')
mjd = obs.date + doff
return mjd
def main():
""" Main entry point """
os.system('reset')
startup_ts = dt.datetime.utcnow().strftime("%Y%m%d_%H%M%S")
cwd = os.getcwd()
#--------START Command Line argument parser------------------------------------------------------
parser = argparse.ArgumentParser(
description="Generates Doppler Curves from TLE list, \
uses measurement metadata to derive required parameters",
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
tle = parser.add_argument_group('TLE related configurations')
tle_fp_default = '/'.join([cwd, 'tle'])
tle.add_argument('--tle_file',
dest='tle_file',
type=str,
default='pslv40_st.tle',
help="TLE File of candidate satellites",
action="store")
tle.add_argument('--tle_folder',
dest='tle_folder',
type=str,
default=tle_fp_default,
help="Folder containing TLE file",
action="store")
meas = parser.add_argument_group('Measurement Related Configurations')
meas_fp_default = '/'.join([cwd, 'measurements'])
meas.add_argument(
'--meas_json',
dest='meas_json',
type=str,
default='DOPPLER_FOX-1D_20180113_161201.862011_UTC_10sps.json',
help="Converted Doppler offset measurement file, JSON format",
action="store")
meas.add_argument(
'--meas_csv',
dest='meas_csv',
type=str,
default='DOPPLER_FOX-1D_20180113_161201.862011_UTC_10sps.csv',
help="Converted Doppler offset measurement file, CSV format",
action="store")
meas.add_argument(
'--meas_md',
dest='meas_md',
type=str,
default='DOPPLER_FOX-1D_20180113_161201.862011_UTC_10sps.md',
help="Measurement metadata file, JSON format",
action="store")
meas.add_argument(
'--meas_folder',
dest='meas_folder',
type=str,
default=meas_fp_default,
help="Converted Doppler offset measurement file location",
action="store")
gen = parser.add_argument_group('Generated Doppler Related Configurations')
gen_fp_default = '/'.join([cwd, 'generated'])
gen.add_argument('--gen_folder',
dest='gen_folder',
type=str,
default=gen_fp_default,
help="Generated Doppler measurement file location",
action="store")
gen.add_argument(
'--gen_json',
dest='gen_json',
type=str,
default=None,
help="Generated Doppler offset measurement file, JSON format",
action="store")
gen.add_argument(
'--gen_csv',
dest='gen_csv',
type=str,
default=None,
help="Generated Doppler offset measurement file, CSV format",
action="store")
plot = parser.add_argument_group('Plotting Related Configurations')
fig_fp_default = '/'.join([cwd, 'figures'])
plot.add_argument('--fig_path',
dest='fig_path',
type=str,
default=fig_fp_default,
help="Folder location for saved figures",
action="store")
plot.add_argument('--fig_save',
dest='fig_save',
type=int,
default=0,
help="Save Figure Flag, 0=N, 1=Y",
action="store")
args = parser.parse_args()
#--------END Command Line argument parser------------------------------------------------------
import warnings
warnings.filterwarnings('ignore')
#--Read in Measurement metadata
fp_md = '/'.join([args.meas_folder, args.meas_md])
if not os.path.isfile(fp_md) == True:
print 'ERROR: invalid Measurement Metadata file: {:s}'.format(fp_md)
sys.exit()
print 'Importing measurement metadata from: {:s}'.format(fp_md)
with open(fp_md, 'r') as f:
md = json.load(f)
for k in md.keys():
print k, md[k]
#with open
#--Read in TLE Files--
tle = utilities.pyephem.tle_file_input(args.tle_folder, args.tle_file)
#print tle
#--create list of satellite objects with pyephem--
sats = [] #list of satellite objects
for sat in tle.keys():
ephem_sat = ephem.readtle(sat, tle[sat]['line1'], tle[sat]['line2'])
norad_id = tle[sat]['line1'][2:7]
sats.append(utilities.satellite.satellite(ephem_sat, sat, norad_id))
#--create ground station object with pyephem--
gs = ephem.Observer()
gs.lat, gs.lon, gs.elevation = md['gs_lat']*deg2rad, \
md['gs_lon']*deg2rad, \
md['gs_alt']
#Read in Doppler Measurement File
#This data is needed to get the relevant time stamps
fp_meas = '/'.join([args.meas_folder, args.meas_json])
print 'Importing measurement metadata from: {:s}'.format(fp_meas)
df = pd.read_json(fp_meas, orient='records')
df.name = md['sat_name']
dopplers = [] #list containing doppler data, might not be needed
for sat in sats:
print "Generating Doppler data for {:s}_{:s}".format(
sat.sat_name, sat.norad_id)
print "Downlink Center Freq [MHz]: {:3.6f}".format(
md['rx_center_freq'] / 1e6)
dop_df = sat.gen_doppler( gs, \
df['timestamp'].values.tolist(), \
md['rx_center_freq'])
dopplers.append(dop_df)
for dop in dopplers:
ts = dop['timestamp'][0].strftime("%Y%m%d_%H%M%S.%f_UTC")
fn = '_'.join(['DOPPLER', dop.name, ts, md['samp_rate_str']])
fp_json = '/'.join([args.gen_folder, fn]) + '.json'
fp_csv = '/'.join([args.gen_folder, fn]) + '.csv'
#--Export JSON Doppler File
print "Exporting JSON Doppler Measurement File: {:s}".format(fp_json)
dop.to_json(fp_json, \
orient='records', \
date_format='iso', \
date_unit = 'us')
#--Export CSV Doppler File
print " Exporting CSV Doppler Measurement File: {:s}".format(fp_csv)
dop.to_csv( fp_csv, \
index_label ="index", \
float_format="%.10f", \
date_format='%Y-%m-%dT%H:%M:%S.%fZ')
def load(fnames,
tag=None,
sat_id=None,
obs_long=0.,
obs_lat=0.,
obs_alt=0.,
TLE1=None,
TLE2=None):
"""
Returns data and metadata in the format required by pysat. Finds position
of satellite in both ECI and ECEF co-ordinates.
Routine is directly called by pysat and not the user.
Parameters
----------
fnames : list-like collection
File name that contains date in its name.
tag : string
Identifies a particular subset of satellite data
sat_id : string
Satellite ID
obs_long: float
Longitude of the observer on the Earth's surface
obs_lat: float
Latitude of the observer on the Earth's surface
obs_alt: float
Altitude of the observer on the Earth's surface
TLE1 : string
First string for Two Line Element. Must be in TLE format
TLE2 : string
Second string for Two Line Element. Must be in TLE format
Example
-------
inst = pysat.Instrument('pysat', 'sgp4',
TLE1='1 25544U 98067A 18135.61844383 .00002728 00000-0 48567-4 0 9998',
TLE2='2 25544 51.6402 181.0633 0004018 88.8954 22.2246 15.54059185113452')
inst.load(2018, 1)
"""
# wgs72 is the most commonly used gravity model in satellite tracking
# community
from sgp4.earth_gravity import wgs72
from sgp4.io import twoline2rv
import ephem
import pysatMagVect
# TLEs (Two Line Elements for ISS)
# format of TLEs is fixed and available from wikipedia...
# lines encode list of orbital elements of an Earth-orbiting object
# for a given point in time
line1 = (
'1 25544U 98067A 18135.61844383 .00002728 00000-0 48567-4 0 9998'
)
line2 = (
'2 25544 51.6402 181.0633 0004018 88.8954 22.2246 15.54059185113452'
)
# use ISS defaults if not provided by user
if TLE1 is not None:
line1 = TLE1
if TLE2 is not None:
line2 = TLE2
# create satellite from TLEs and assuming a gravity model
# according to module webpage, wgs72 is common
satellite = twoline2rv(line1, line2, wgs72)
# grab date from filename
parts = os.path.split(fnames[0])[-1].split('-')
yr = int(parts[0])
month = int(parts[1])
day = int(parts[2][0:2])
date = pysat.datetime(yr, month, day)
# create timing at 1 Hz (for 1 day)
times = pds.date_range(start=date,
end=date + pds.DateOffset(seconds=86399),
freq='1S')
# reduce requirements if on testing server
# TODO Remove this when testing resources are higher
on_travis = os.environ.get('ONTRAVIS') == 'True'
if on_travis:
times = times[0:100]
# create list to hold satellite position, velocity
position = []
velocity = []
for time in times:
# orbit propagator - computes x,y,z position and velocity
pos, vel = satellite.propagate(time.year, time.month, time.day,
time.hour, time.minute, time.second)
position.extend(pos)
velocity.extend(vel)
# put data into DataFrame
data = pysat.DataFrame(
{
'position_eci_x': position[::3],
'position_eci_y': position[1::3],
'position_eci_z': position[2::3],
'velocity_eci_x': velocity[::3],
'velocity_eci_y': velocity[1::3],
'velocity_eci_z': velocity[2::3]
},
index=times)
data.index.name = 'Epoch'
# add position and velocity in ECEF
# add call for GEI/ECEF translation here
# instead, since available, I'll use an orbit predictor from another
# package that outputs in ECEF
# it also supports ground station calculations
# the observer's (ground station) position on the Earth surface
site = ephem.Observer()
site.lon = str(obs_long)
site.lat = str(obs_lat)
site.elevation = obs_alt
# The first parameter in readtle() is the satellite name
sat = ephem.readtle('pysat', line1, line2)
output_params = []
for time in times:
lp = {}
site.date = time
sat.compute(site)
# parameters relative to the ground station
lp['obs_sat_az_angle'] = ephem.degrees(sat.az)
lp['obs_sat_el_angle'] = ephem.degrees(sat.alt)
# total distance away
lp['obs_sat_slant_range'] = sat.range
# satellite location
# sub latitude point
lp['glat'] = np.degrees(sat.sublat)
# sublongitude point
lp['glong'] = np.degrees(sat.sublong)
# elevation of sat in m, stored as km
lp['alt'] = sat.elevation / 1000.
# get ECEF position of satellite
lp['x'], lp['y'], lp['z'] = pysatMagVect.geodetic_to_ecef(
lp['glat'], lp['glong'], lp['alt'])
output_params.append(lp)
output = pds.DataFrame(output_params, index=times)
# modify input object to include calculated parameters
data[['glong', 'glat', 'alt']] = output[['glong', 'glat', 'alt']]
data[['position_ecef_x', 'position_ecef_y', 'position_ecef_z']] = \
output[['x', 'y', 'z']]
data['obs_sat_az_angle'] = output['obs_sat_az_angle']
data['obs_sat_el_angle'] = output['obs_sat_el_angle']
data['obs_sat_slant_range'] = output['obs_sat_slant_range']
return data, meta.copy()
def find_parallax(self, date):
'''Find the maximum parallax of self.planet on the given date
from self.observer's location -- in other words, the difference
in Mars' position between the observer's position and an
observer at the same latitude but opposite longitude:
this tells you you how much difference you would see from
your position if Mars didn't move between your sunrise and sunset.
'''
save_date = self.observer.date
# https://www.quora.com/Is-it-possible-to-measure-the-distance-to-Mars-using-a-telescope-and-the-parallax-method
# says it should vary between 361.9 arc sec > a > 51.6 arc sec,
# but I think he's smoking something.
# So let's calculate it.
observer = ephem.Observer()
observer.name = "Observer"
# To calculate from a point on the equator, set observer.lat to 0.
observer.lat = self.observer.lat
observer.lon = self.observer.lon
observer.elevation = 0
antipode = ephem.Observer()
antipode.name = "Anti-point"
antipode.lat = observer.lat
antipode.lon = 360 - self.observer.lon
antipode.elevation = 0
observer.date = observer.next_rising(self.planet, start=date)
self.planet.compute(observer)
our_ra = self.planet.ra
our_dec = self.planet.dec
antipode.date = observer.date
self.planet.compute(antipode)
antipode_ra = self.planet.ra
antipode_dec = self.planet.dec
# Calculate it the straightforward way using trig:
print()
mars_dist_miles = self.planet.earth_distance * 9.2956e7
print("Miles to Mars:", mars_dist_miles)
earth_mean_radius = 3958.8 # in miles
half_dist = earth_mean_radius * math.cos(observer.lat)
print("Distance between observers:", 2. * half_dist)
par = 2. * math.atan(
half_dist / mars_dist_miles) * 180 / math.pi * 3600
print("Calculated parallax (arcsec):", par)
# See what pyephem calculates as the difference between observations:
print()
print(" Us:", our_ra, our_dec)
print("Anti-pt:", antipode_ra, antipode_dec)
print("parallax on %s: RA %f, dec %f" %
(antipode.date, our_ra - antipode_ra, our_dec - antipode_dec))
total_par = (math.sqrt((our_ra - antipode_ra)**2 +
(our_dec - antipode_dec)**2) * 180. / math.pi *
3600.)
print("Total parallax (sum of squares): %f arcseconds" % total_par)
print()
# Set planet back to its previous position,
# since we're in the middle of ongoing computations:
self.planet.compute(self.observer.date)
