def tab1_update_addStrID(): global dftmp if tab1_selected_dspec_square: time0, time1 = dftmp['time'].min() + timestart, dftmp['time'].max() + timestart freq0, freq1 = dftmp['freq'].min(), dftmp['freq'].max() date_char = Time(timestart / 3600. / 24., format='jd', scale='utc', precision=3, out_subfmt='date').iso t0_char = Time(time0 / 3600. / 24., format='jd', scale='utc', precision=3, out_subfmt='date_hms').iso t0_char = t0_char.split(' ')[1] t1_char = Time(time1 / 3600. / 24., format='jd', scale='utc', precision=3, out_subfmt='date_hms').iso t1_char = t1_char.split(' ')[1] time0, time1 = (time0 / 86400. - 2400000.5) * 24. * 3600., (time1 / 86400. - 2400000.5) * 24. * 3600. StrID = pd.DataFrame(dict(time=[[time0, time1, time1, time0]], freq=[[freq0, freq0, freq1, freq1]], str_id=[[tab1_input_StrID.value]], date=[[date_char]], timeran=[[t0_char + '~' + t1_char]], freqran=[["{:.3f}~{:.3f} GHz".format(freq0, freq1)]])) StrIDList = pd.read_json(event_dir + 'StrID_list_tmp.json') StrIDList = pd.concat([StrIDList, StrID]) StrIDList = StrIDList.sort_values(by='timeran', ascending=1) StrIDList.index = range(StrIDList.index.size) StrIDList.to_json(event_dir + 'StrID_list_tmp.json') StrIDList['time'] = [ll - tab1_tim[0] for ll in StrIDList['time']] tab1_render_patch.data_source.data = ColumnDataSource(StrIDList).data tab1_Div_Tb.text = """<p>added <b>""" + tab1_input_StrID.value + """</b> to the list</p>""" else: tab1_Div_Tb.text = """<p><b>Warning: No time & freq range selected.
def tab2_BUT_tCLN_param_default(): global tab2_tCLN_Param_dict, dspecDF0 tab2_tCLN_Param_dict = OrderedDict() time0, time1 = dspecDF0['time'].min() + timestart, dspecDF0['time'].max( ) + timestart t0_char = Time(time0 / 3600. / 24., format='jd', scale='utc', precision=3, out_subfmt='date_hms').iso date0_char = t0_char.split(' ')[0].replace('-', '/') time0_char = t0_char.split(' ')[1] t1_char = Time(time1 / 3600. / 24., format='jd', scale='utc', precision=3, out_subfmt='date_hms').iso date1_char = t1_char.split(' ')[0].replace('-', '/') time1_char = t1_char.split(' ')[1] freq0, freq1 = dspecDF0['freq'].min(), dspecDF0['freq'].max() freqrange = "'{:.3f}~{:.3f} GHz'".format(freq0, freq1) tab2_tCLN_Param_dict['freqrange'] = freqrange tab2_tCLN_Param_dict['workdir'] = "'./'" tab2_tCLN_Param_dict['vis'] = "''" tab2_tCLN_Param_dict['imageprefix'] = "'slfcal/{}{}'".format( struct_id, CleanID) tab2_tCLN_Param_dict['ncpu'] = "10" tab2_tCLN_Param_dict['twidth'] = "1" tab2_tCLN_Param_dict['doreg'] = "False" tab2_tCLN_Param_dict['timerange'] = "''" tab2_tCLN_Param_dict['uvrange'] = "''" tab2_tCLN_Param_dict['antenna'] = "''" tab2_tCLN_Param_dict['ephemfile'] = "'horizons_sun_20141101.radecp'" tab2_tCLN_Param_dict[ 'msinfofile'] = "'SUN01_20141101.T163940-164700.50ms.cal.msinfo.npz'" tab2_tCLN_Param_dict['event_id'] = "'{}'".format(event_id.replace("/", "")) tab2_tCLN_Param_dict['struct_id'] = "'{}'".format( struct_id.replace("/", "")) tab2_tCLN_Param_dict['clean_id'] = "'{}'".format(CleanID.replace("/", "")) tab2_tCLN_Param_dict['mode'] = "'channel'" tab2_tCLN_Param_dict['imagermode'] = "'csclean'" tab2_tCLN_Param_dict['weighting'] = "'natural'" tab2_tCLN_Param_dict['gain'] = '0.1' tab2_tCLN_Param_dict['psfmode'] = "'clark'" tab2_tCLN_Param_dict['imsize'] = "" '[256, 256]' "" tab2_tCLN_Param_dict['cell'] = "['3.0arcsec', '3.0arcsec']" tab2_tCLN_Param_dict['phasecenter'] = "'J2000 14h26m22.7351 -14d29m29.801'" tab2_tCLN_Param_dict['mask'] = "''" tab2_tCLN_Param_dict['stokes'] = "'RRLL'" tab2_tCLN_Param_dict['uvrange'] = "''" tab2_tCLN_Param_dict['niter'] = "500" tab2_tCLN_Param_dict['usescratch'] = "False" tab2_tCLN_Param_dict['interactive'] = "False" tab2_Div_tCLN_text = '<p><b># ptclean :: Parallelized clean in consecutive time steps</b></p>' + ' '.join( "<p><b>{}</b> = {}</p>".format(key, val) for (key, val) in tab2_tCLN_Param_dict.items()) tab2_Div_tCLN.text = tab2_Div_tCLN_text tab2_Div_tCLN2.text = '<p><b>Default parameter Restored.</b></p>'
def onTimer(self): timeStr = Time(datetime.utcnow(), scale='utc').iso.split('.')[0] self.curTime.setText(timeStr.split(" ")[1]) #print('write ' + timeStr.split(" ")[1]) dateStr = Time(datetime.utcnow(), scale='utc').iso.split(' ')[0] self.curDate.setText(dateStr) if (self.cmd < 200): self.cmd = 200 else: self.cmd = 100 self.SendTimePacket() self.SrhAntSocket.writeDatagram( QtCore.QByteArray( struct.pack('!16sHHHLL', b'_Srh_Net_Packet_', 0, self.cmd, 0, 0, 0)), QtNetwork.QHostAddress('192.168.0.168'), 9998) testSocket = QtNetwork.QTcpSocket() testSocket.connectToHost('192.168.0.1', 80) if testSocket.waitForConnected() == True: self.Network.setPixmap(self.greenBox) else: self.Network.setPixmap(self.redBox) testSocket.close()
def epoch_time_array( epoch_range, index_epoch=None, cadence=None, ): """Create a Skyfield :class:`~skyfield.timelib.Timescale` object at which to evaluate satellite positions. Begins by downloading up-to-date time files, using the skyfield :class:`~skyfield.iokit.Loader` class, needed to accurate converted between various time formats. See `Dates and Time <https://rhodesmill.org/skyfield/time.html>`_ for more info. The files are saved to :samp:`./embers_out/sat_utils/skyfield-data`. For a particular time inverval in :samp:`epoch_range`, chosen by :samp:`index_epoch`, a Skyfield :class:`~skyfield.timelib.Timescale` array object is generated, at a given time :samp:`cadence`. This time array will be used by :func:`~embers.sat_utils.sat_ephemeris.sat_pass` to compute the position of satellites at each time. .. code-block:: python from embers.sat_utils.sat_ephemeris import load_tle, epoch_ranges, epoch_time_array sats, epochs = load_tle('~/embers-data/TLE/21576.txt') epoch_range = epoch_ranges(epochs) index_epoch = 0 # select first time interval from epoch_range cadence = 10 # evaluate satellite position every 10 seconds t_arr, index_epoch = epoch_time_array(epoch_range, index_epoch, cadence) :param index_epoch: Index of :samp:`epoch_range` to be converted to time array :class:`~int` :param epoch_range: List of time intervals where an epoch is most accurate, from :func:`embers.sat_utils.sat_ephemeris.epoch_ranges` :param cadence: Time cadence at which to evaluate sat position, in seconds :class:`~int` :returns: A :class:`~tuple` of (t_arr, index_epoch) - t_arr: Skyfield :class:`~skyfield.timelib.Timescale` object with array of times at given :samp:`cadence` - index_epoch: Index of :samp:`epoch_range` to be converted to time array :class:`~int` """ # Skyfield Timescale ts = load.timescale(builtin=True) # find time between epochs/ midpoints in seconds, using Astropy Time t1 = Time(epoch_range[index_epoch], scale="tt", format="jd").gps t2 = Time(epoch_range[index_epoch + 1], scale="tt", format="jd").gps dt = round(t2 - t1) t3 = Time(epoch_range[index_epoch], scale="tt", format="jd").iso date, time = t3.split() year, month, day = date.split("-") hour, minute, _ = time.split(":") # Create a time array, every 2[cadence] seconds, starting at the first epoch, approximately seconds = np.arange(0, dt, cadence) t_arr = ts.tt(int(year), int(month), int(day), int(hour), int(minute), seconds) return (t_arr, index_epoch)
def SolarSystem(t_jd): t_iso = Time(t_jd, format='jd', scale='utc').iso date = ':'.join(t_iso.split(':')[:-1]) sim = rebound.Simulation() sim.units = ('yr', 'AU', 'Msun') sim.add("Sun", date=date) sim.add("Mercury", date=date) sim.add("Venus", date=date) sim.add("399", date=date) # Earth sim.add("301", date=date) # Moon sim.add("Mars", date=date) sim.add("Jupiter", date=date) sim.add("Saturn", date=date) sim.add("Uranus", date=date) sim.add("Neptune", date=date) sim.particles[0].hash = 'sun' sim.particles[3].hash = 'earth' # sim.convert_particle_units('AU', 'yr', 'Msun') sim.move_to_com() return sim
def launch_ds9(dir, tree, overwrite): #LOAD CONFIG try: with open(root_path + "/obsconfig.txt", "r") as obsf: for line in obsf: if "Observatory Code" in line: obscode = line.split(":")[-1].strip() if "Name" in line: obsname = line.split(":")[-1].strip() if "Observer" in line: observer = line.split(":")[-1].strip() if "Measurer" in line: measurer = line.split(":")[-1].strip() if "Telescope" in line: telescope = line.split(":")[-1].strip() if "Email" in line: email = line.split(":")[-1].strip() if "Initials" in line: initials = line.split(":")[-1].strip() if "DS9 Text Color" in line: ds9Color = line.split(":")[-1].strip() if "DS9 Font Size" in line: ds9FontSize = line.split(":")[-1].strip() if "Invert images?" in line: invertImages = False if line.split(":")[-1].strip() == "yes": invertImages = True if "Blink Inverval" in line: ds9BlinkInterval = line.split(":")[-1].strip() except: print("\nConfiguration file obsconfig.txt not found, exiting..\n") return try: with open(dir + '/asteroids', 'rb') as fp: asteroids = pickle.load(fp) with open(dir + '/midpoints', 'rb') as fp: midpoints = pickle.load(fp) with open(dir + '/totaltime', 'rb') as fp: totalTime = pickle.load(fp) except: print("\nAsteroids file or Midpoints file missing\n") return findDesig = True reportClosed = False ##### ADD REPORT DATE ##### ut = Time(datetime.utcnow(), scale='utc') ut = str(ut) yymmdd = ut.split(" ")[0] hhmmss = ut.split(" ")[-1] yy = yymmdd.split("-")[0] mo = yymmdd.split("-")[1] dd = yymmdd.split("-")[2] hh = hhmmss.split(":")[0] mm = hhmmss.split(":")[1] ss = hhmmss.split(":")[2] ss = ss.split(".")[0] reportDate = yy + "." + mo + "." + dd + " " + hh + ":" + mm + ":" + ss #### CHECK FOR REPORT FILE AND ASK TO REPLACE? ### replacereport = overwrite if (replacereport): reportfile = open(dir + "/report.txt", "w") reportfile.write("COD " + obscode + "\n") reportfile.write("CON " + obsname + " [" + email + "]\n") reportfile.write("OBS " + observer + "\n") reportfile.write("MEA " + measurer + "\n") reportfile.write("TEL " + telescope + "\n") reportfile.write("ACK MPCReport file updated " + reportDate + "\n") #ADD UTC DATE TIME reportfile.write("AC2 " + email + "\n") reportfile.write("NET Gaia DR1\n") #Output to user print("\nLaunching DS9 to confirm asteroids..\nAnswer y or n\n") #Initiate DS9 d = pyds9.DS9(target='DS9:*', start=True, wait=15, verify=False) #Clear out any previous runs in DS9 d.set("blink no") d.set("frame delete all") fitsfiles = glob.glob(dir + "/*.fits") #Check for only "Stack" fits for file in fitsfiles: if "Stack" in file: continue else: fitsfiles.remove(file) #Sort by name fitsfiles.sort() #Load frames into DS9 for i in range(len(fitsfiles)): #print(fitsfiles[i]) d.set("frame " + str(i + 1)) d.set("fits " + fitsfiles[i]) if (invertImages): d.set("cmap invert yes") #set locks and scale d.set("scale squared") d.set("scale zscale") d.set("scale match yes") d.set("frame lock wcs") d.set("lock colorbar yes") d.set("lock scalelimits yes") d.set("blink interval " + ds9BlinkInterval) d.set("zoom 4") astnum = 0 astLength = len(asteroids) def close_out(): print("\nFinished processing asteroids for this sequence.\n") if (replacereport): reportfile.write("----- end -----") reportfile.close() d.set("blink no") #tree.destroy() # CLEAR OUT TREE tree.delete(*tree.get_children()) #for asteroid in asteroids: def show_asteroid(event): curItem = tree.focus() if tree.item(curItem)["text"] == "END": print("Enter to close sequence") d.set("blink no") return astindex = int(tree.item(curItem)["text"]) asteroid = asteroids[astindex] print("Asteroid ", astindex + 1, "/", astLength) def displayAst(ast): d.set("blink no") if ast[0][0] == 'dummy': d.set("frame 1") d.set("regions delete all") #pass else: d.set("frame 1") d.set("regions delete all") d.set( 'regions', 'image; circle(' + ast[0][4] + ' ' + ast[0][5] + ' 9")# color=' + ds9Color + ' font="times' + ds9FontSize + '" text={' + ast[0][2] + 'V ' + ast[0][3] + ' FWHM }') d.set("frame 2") d.set("regions delete all") d.set( 'regions', 'image; circle(' + ast[1][4] + ' ' + ast[1][5] + ' 9")# color=' + ds9Color + ' font="times' + ds9FontSize + '" text={' + ast[1][2] + 'V ' + ast[1][3] + ' FWHM }') d.set("frame 3") d.set("regions delete all") d.set( 'regions', 'image; circle(' + ast[2][4] + ' ' + ast[2][5] + ' 9")# color=' + ds9Color + ' font="times' + ds9FontSize + '" text={' + ast[2][2] + 'V ' + ast[2][3] + ' FWHM }') if ast[3][0] == 'dummy': d.set("frame 4") d.set("regions delete all") #pass else: d.set("frame 4") d.set("regions delete all") d.set( 'regions', 'image; circle(' + ast[3][4] + ' ' + ast[3][5] + ' 9")# color=' + ds9Color + ' font="times' + ds9FontSize + '" text={' + ast[3][2] + 'V ' + ast[3][3] + ' FWHM }') d.set("pan to " + str(ast[1][0]) + ' ' + str(ast[1][1]) + " wcs") #d.set("regions save foo.reg") #print(d.get('regions')) d.set("blink yes") ### INITIAL DISPLAY ### displayAst(asteroid) ### DISPLAY 1-3 or 2-4 ### if asteroid[0][0] == 'dummy': print("Images 2-4") elif asteroid[3][0] == "dummy": print("Images 1-3") else: print("Images 1-4") ### SHOW LOCATION #### dispRA = asteroid[1][0] dispDEC = asteroid[1][1] dispT = SkyCoord(ra=dispRA * u.degree, dec=dispDEC * u.degree) dispcoordsT = dispT.to_string('hmsdms') dispCOORDS = clean_coords(dispcoordsT) print("Location: ", dispCOORDS, " Copied to Clipboard") pyperclip.copy(dispCOORDS) print("\n") #print("Resid: ",asteroid[4][0] ) #ENTER Q/A RESP ## CONFIM WITH ENTER def just_desig(event): curItem = tree.focus() if tree.item(curItem)["text"] == "END": close_out() return astindex = int(tree.item(curItem)["text"]) asteroid = asteroids[astindex] print("Asteroid ", astindex + 1, "/", astLength) print("\n") if astindex == astLength + 1: print("\n close out") return #print("Resid: ",asteroid[4][0] ) #ENTER Q/A RESP #DESIG IS SET HERE FIRST desig = "TMP001" # AST #PLOT #CONFIRM resids = solve_residuals(asteroid, False, True) resids = "{:.2f}".format(resids) print("\n", resids, " Asteroid mean residual") #Temp file for scoring asteroids tempfile = open(dir + "/digest2temp.txt", "w") raT = asteroid[1][0] decT = asteroid[1][1] magT = round(float(asteroid[1][2]), 1) magT = str(magT) + " V" cT = SkyCoord(ra=raT * u.degree, dec=decT * u.degree) coordsT = cT.to_string('hmsdms') coordsCleanT = clean_coords(coordsT) # Get designation of first measurement, parse MPC if (findDesig): # Only need 1 pos to search for desig obsT = " " + desig + " KC" + midpoints[ 1] + coordsCleanT + " " + magT + " " + obscode # find designation solveddesig = find_desig(obsT) print("Information for " + desig) print("##########################################") print("##### MPC SEARCH RESULTS BELOW #####") print("##########################################") print("\n", solveddesig) if (solveddesig is not None): desig = solveddesig.split()[1] print("MPC desig: ", desig + "\n") else: print("No MPC designation found.\n") for i in range(len(asteroid)): #convert radec if asteroid[i][0] == 'dummy': continue ra = asteroid[i][0] dec = asteroid[i][1] mag = round(float(asteroid[i][2]), 1) #Catch bad mags if (mag > 21.2): mag = " " else: mag = str(mag) + " V" c = SkyCoord(ra=ra * u.degree, dec=dec * u.degree) coords = c.to_string('hmsdms') coordsClean = clean_coords(coords) desig = desig.rjust(11) blankSP = " " tempfile.write(desig + blankSP + "KC" + midpoints[i] + coordsClean + " " + mag + " " + obscode + "\n") tempfile.close() #Score the rock and print out score_rock(dir) print("\n Finished searching and scoring object. \n") def confirm_asteroid(event): curItem = tree.focus() if tree.item(curItem)["text"] == "END": close_out() return astindex = int(tree.item(curItem)["text"]) asteroid = asteroids[astindex] print("Asteroid ", astindex + 1, "/", astLength) print("\n") if astindex == astLength + 1: print("\n close out") return #print("Resid: ",asteroid[4][0] ) #ENTER Q/A RESP #DESIG IS SET HERE FIRST desig = "TMP001" desigFromMPC = False # AST #PLOT #CONFIRM resids = solve_residuals(asteroid, False, True) resids = "{:.2f}".format(resids) print("\n", resids, " Asteroid mean residual") #Temp file for scoring asteroids tempfile = open(dir + "/digest2temp.txt", "w") raT = asteroid[1][0] decT = asteroid[1][1] magT = round(float(asteroid[1][2]), 1) magT = str(magT) + " V" cT = SkyCoord(ra=raT * u.degree, dec=decT * u.degree) coordsT = cT.to_string('hmsdms') coordsCleanT = clean_coords(coordsT) # Get designation of first measurement, parse MPC if (findDesig): # Only need 1 pos to search for desig obsT = " " + desig + " KC" + midpoints[ 1] + coordsCleanT + " " + magT + " " + obscode # find designation solveddesig = find_desig(obsT) print("Information for " + desig) print("##########################################") print("##### MPC SEARCH RESULTS BELOW #####") print("##########################################") print("\n", solveddesig) if (solveddesig is not None): useMPCdesig = True if (useMPCdesig): desig = solveddesig.split()[1] print("Assigned MPC desig: ", desig + "\n") desigFromMPC = True else: print("No MPC designation found.") #OVERWRITE REPORT? if (replacereport and not desigFromMPC): desig = id_generator() print("Assigned temp designation: " + desig + "\n") for i in range(len(asteroid)): #convert radec if asteroid[i][0] == 'dummy': continue ra = asteroid[i][0] dec = asteroid[i][1] mag = round(float(asteroid[i][2]), 1) #Catch bad mags if (mag > 21.2): mag = " " else: mag = str(mag) + " V" c = SkyCoord(ra=ra * u.degree, dec=dec * u.degree) coords = c.to_string('hmsdms') coordsClean = clean_coords(coords) if (desigFromMPC): #Capture provisional designation if len(desig) == 7: desig = desig.rjust(12) blankSP = " " if len(desig) < 7: blankSP = " " desig = desig.ljust(11) else: desig = desig.rjust(11) blankSP = " " # IF WE REPLACE REPORT if (replacereport): reportfile.write(desig + blankSP + "KC" + midpoints[i] + coordsClean + " " + mag + " " + obscode + "\n") tempfile.write(desig + blankSP + "KC" + midpoints[i] + coordsClean + " " + mag + " " + obscode + "\n") tempfile.close() #Score the rock and print out score_rock(dir) print("\n Finished processing object. \n") #CLEAR OUT TREE tree.delete(*tree.get_children()) # TREE COLUMNS CREATE # tree.config(columns=('fwhm','astloc','astresid', 'astmag')) tree['columns'] = ('fwhm', 'astloc', 'astresid', 'astmag', 'velocity') tree.column('#0', width=70) tree.column('fwhm', width=70, anchor='center') tree.column('astloc', width=180, anchor='center') tree.column('astresid', width=70, anchor='center') tree.column('astmag', width=70, anchor='center') tree.column('velocity', width=150, anchor='center') tree.heading('#0', text='Ast Num') tree.heading('fwhm', text='Ast FWHM') tree.heading('astloc', text='Ast Location') tree.heading('astresid', text='Ast Resid') tree.heading('astmag', text='Ast Mag') tree.heading('velocity', text='Ast Vel Arcsec/min') tree.config(selectmode='browse') tree.bind('<<TreeviewSelect>>', show_asteroid) tree.bind("<Return>", confirm_asteroid) tree.bind("<c>", just_desig) astnum2 = 0 #Convert total time to float totalTime = float(totalTime) for ast in asteroids: astT = [] #REMOVE DUMMY for k in range(len(ast)): if ast[k][0] == "dummy": continue else: astT.append(ast[k]) #SOLVE AVE FWHM fwhm = sum(float(astT[i][3]) for i in range(len(astT))) / len(astT) fwhm = round(fwhm, 2) #SOLVE AVE MAG mag = sum(float(astT[i][2]) for i in range(len(astT))) / len(astT) mag = round(mag, 2) #SOLVE RESID resid = solve_residuals(astT, False, False) ### SHOW LOCATION #### ra = astT[2][0] dec = astT[2][1] dispT = SkyCoord(ra=ra * u.degree, dec=dec * u.degree) dispcoordsT = dispT.to_string('hmsdms') dispCOORDS = clean_coords(dispcoordsT) #### SOLVE SPEED #### x1 = astT[0][0] y1 = astT[0][1] x2 = astT[-1][0] y2 = astT[-1][1] astDist = math.sqrt((x2 - x1)**2 + (y2 - y1)**2) astDist = astDist * 3600 # CONVERT TO ARCSEC vel = round(astDist / totalTime, 2) # parent id name text #fwhm #loc #resid #mag tree.insert('', str(astnum2), text=str(astnum2), values=(fwhm, dispCOORDS, resid, mag, vel)) astnum2 += 1 #INSERT END LINE if astnum2 == len(asteroids): tree.insert('', str(len(asteroids) + 1), text="END") tree.update() #MODULE TESTING PURPOSES, UNCOMMENT # myTree = Toplevel() # tree1 = ttk.Treeview(myTree) # tree1.pack(fill="both") #launch_ds9("/home/david/Desktop/C4", tree1, False)
def shownightobs(observable, meteo, obs_night=None, savefig=False, dirpath=None, verbose=False): """ Plot the observability of one observable along the night #todo: add the option to be returned in an Axes object instead of plotting """ logger.debug("Creating night observability plot for {}".format(observable.name)) if not obs_night: meteo.time.format = 'iso' hour = int(meteo.time.value.split()[1][:2]) if hour < 12: obs_night = Time(meteo.time.mjd - 1, format='mjd', scale='utc') else: obs_night = Time(meteo.time.mjd, format='mjd', scale='utc') obs_night.format = 'iso' obs_night = obs_night.value.split()[0] # list of times between nautical twilights times = meteo.get_nighthours(obs_night) #mymeteo = pythoncopy.deepcopy(meteo) # as we don't want to affect the current meteo, we make a copy that we update with the time mymeteo = meteo obss = [] moonseps = [] airmasses = [] for time in times: mymeteo.update(obs_time=time, minimal=True) observable.compute_observability(meteo=mymeteo, displayall=True, cloudscheck=False, verbose=verbose) observable.compute_airmass(mymeteo) obss.append(observable.observability) moonseps.append(observable.angletomoon.degree) airmasses.append(observable.airmass) # create the x ticks labels every hour Time('%s 05:00:00' % obs_night, format='iso', scale='utc') hstart=22 hend=12 nhbm = 24-hstart # number of hours before midnight... myhours = [] for hour in np.arange(nhbm)[::-1]: myhours.append(24-(hour+1)) for hour in np.arange(hend+1): myhours.append(hour) myhours = ["%02i:00:00" % h for h in myhours] mytimes = [Time('%s %s' % (obs_night, h), format='iso', scale='utc') for h in myhours[:nhbm]] for h in myhours[nhbm:]: t = Time('%s %s' % (obs_night, h), format='iso', scale='utc') t = Time(t.mjd + 1, format='mjd', scale='utc') mytimes.append(t) tmin, tmax = times[0].mjd, times[-1].mjd xmax=len(obss) xs = [(t.mjd-tmin)*xmax/(tmax-tmin) for t in mytimes] labels = [str(h[:5]) for h in myhours] starttimes = [] stoptimes = [] # todo: this needs to be improved. if 1 in obss: starttimes.append(times[obss.index(1)]) stoptimes.append(times[::-1][obss[::-1].index(1)]) if 0.8 in obss: starttimes.append(times[obss.index(0.8)]) stoptimes.append(times[::-1][obss[::-1].index(0.8)]) if 0.7 in obss: starttimes.append(times[obss.index(0.7)]) stoptimes.append(times[::-1][obss[::-1].index(0.7)]) if 0.56 in obss: starttimes.append(times[obss.index(0.56)]) stoptimes.append(times[::-1][obss[::-1].index(0.56)]) if not 1 in obss and not 0.8 in obss and not 0.7 in obss and not 0.56 in obss: print(("%s is not observable tonight !" % observable.name)) return starttime = min(starttimes) stoptime = max(stoptimes) # shift the start and stoptime if needed if starttime.mjd > stoptime.mjd - (observable.exptime/60./1440.): starttime = Time(stoptime.mjd - (observable.exptime/60./1440.), format='mjd', scale='utc') if stoptime.mjd < starttime.mjd + (observable.exptime/60./1440.): stoptime = Time(starttime.mjd + (observable.exptime/60./1440.), format='mjd', scale='utc') starttime = starttime.iso stoptime = stoptime.iso plt.figure(figsize=(8,1.3)) plt.subplots_adjust(left=0.02, right=0.98, bottom=0.45, top=0.7) ax = plt.subplot(1, 1, 1) xticks = np.arange(len(obss)) plt.xticks(xs, labels, fontsize=16) # green, everything is fine if 1 in obss: plt.axvspan(obss.index(1), len(obss)-obss[::-1].index(1), color='chartreuse') # blue, problem with moon sep, airmass or both. #todo: code that better if 0.8 in obss: color = "royalblue" plt.axvspan(obss.index(0.8), len(obss)-obss[::-1].index(0.8), color=color) msg = "Moonsep = %i" % int(min(moonseps)) plt.annotate(msg, xy=(0, -1.5), xycoords='axes fraction', fontsize=14, color=color) if 0.7 in obss: color = "royalblue" plt.axvspan(obss.index(0.7), len(obss)-obss[::-1].index(0.7), color=color) msg = "Airmass > 1.5" plt.annotate(msg, xy=(0, -1.5), xycoords='axes fraction', fontsize=14, color=color) if 0.56 in obss: color = "indianred" plt.axvspan(obss.index(0.5), len(obss)-obss[::-1].index(0.5), color='indianred') msg = "Moonsep = %i, Airmass > 1.5" % int(min(moonseps)) plt.annotate(msg, xy=(1.0, -1.5), ha="right", xycoords='axes fraction', fontsize=14, color=color) plt.axis([min(xticks), max(xticks), 0.0, 1.0]) ax.get_yaxis().set_visible(False) plt.xlabel('UT', fontsize=18) plt.suptitle(observable.name+" ("+starttime.split(" ")[1][:5]+" --> "+stoptime.split(" ")[1][:5]+")", fontsize=25, y=0.93) if savefig: assert dirpath != None if not os.path.isdir(os.path.join(dirpath, obs_night)): os.mkdir(os.path.join(dirpath, obs_night)) path = os.path.join(dirpath, obs_night, observable.name+'.png') plt.savefig(path) print(("Plot saved on %s" % path)) else: plt.show() logger.info("Night observability plot for {} done".format(observable.name))
def readsdofile(datadir=None, wavelength=None, jdtime=None, isexists=False, timtol=1): ''' read sdo file from local database :param datadir: :param wavelength: :param jdtime: the timestamp or timerange in Julian days. if is timerange, return a list of files in the timerange :param isexists: check if file exist. if files exist, return file name :param timtol: time difference tolerance in days for considering data as the same timestamp :return: ''' from astropy.time import Time import sunpy.map from datetime import date from datetime import timedelta as td wavelength = str(wavelength) wavelength = wavelength.lower() if timtol < 12. / 3600 / 24: timtol = 12. / 3600 / 24 if isinstance(jdtime, list) or isinstance(jdtime, tuple) or type(jdtime) == np.ndarray: if len(jdtime) != 2: raise ValueError('jdtime must be a number or a two elements array/list/tuple') else: if jdtime[1] < jdtime[0]: raise ValueError('start time must be occur earlier than end time!') else: sdofitspath = [] jdtimestr = [Time(ll, format='jd').iso for ll in jdtime] ymd = [ll.split(' ')[0].split('-') for ll in jdtimestr] d1 = date(int(ymd[0][0]), int(ymd[0][1]), int(ymd[0][2])) d2 = date(int(ymd[1][0]), int(ymd[1][1]), int(ymd[1][2])) delta = d2 - d1 for i in xrange(delta.days + 1): ymd = d1 + td(days=i) sdofitspathtmp = glob.glob( datadir + '/{:04d}/{:02d}/{:02d}/aia.lev1_*Z.{}.image_lev1.fits'.format(ymd.year, ymd.month, ymd.day, wavelength)) if len(sdofitspathtmp) > 0: sdofitspath = sdofitspath + sdofitspathtmp if len(sdofitspath) == 0: if isexists: return sdofitspath else: raise ValueError( 'No SDO file found under {} at the time range of {} to {}. Download the data with EvtBrowser first.'.format( datadir, jdtimestr[0], jdtimestr[1])) sdofits = [os.path.basename(ll) for ll in sdofitspath] sdotimeline = Time( [insertchar(insertchar(ll.split('.')[2].replace('T', ' ').replace('Z', ''), ':', -4), ':', -2) for ll in sdofits], format='iso', scale='utc') sdofitspathnew = [x for (y, x) in sorted(zip(sdotimeline.jd, sdofitspath))] sdofitsnew = [os.path.basename(ll) for ll in sdofitspathnew] sdotimelinenew = Time( [insertchar(insertchar(ll.split('.')[2].replace('T', ' ').replace('Z', ''), ':', -4), ':', -2) for ll in sdofitsnew], format='iso', scale='utc') sdofile = list(np.array(sdofitspathnew)[np.where( np.logical_and(jdtime[0] < sdotimelinenew.jd, sdotimelinenew.jd < jdtime[1]))[0]]) return sdofile else: jdtimstr = Time(jdtime, format='jd').iso ymd = jdtimstr.split(' ')[0].split('-') sdofitspath = glob.glob( datadir + '/{}/{}/{}/aia.lev1_*Z.{}.image_lev1.fits'.format(ymd[0], ymd[1], ymd[2], wavelength)) if len(sdofitspath) == 0: raise ValueError('No SDO file found under {}.'.format(datadir)) sdofits = [os.path.basename(ll) for ll in sdofitspath] sdotimeline = Time( [insertchar(insertchar(ll.split('.')[2].replace('T', ' ').replace('Z', ''), ':', -4), ':', -2) for ll in sdofits], format='iso', scale='utc') if timtol < np.min(np.abs(sdotimeline.jd - jdtime)): raise ValueError('No SDO file found at the select timestamp. Download the data with EvtBrowser first.') idxaia = np.argmin(np.abs(sdotimeline.jd - jdtime)) sdofile = sdofitspath[idxaia] if isexists: return sdofile else: try: sdomap = sunpy.map.Map(sdofile) return sdomap except: raise ValueError('File not found or invalid input')
def generate_polycos( self, model, mjdStart, mjdEnd, obs, segLength, ncoeff, obsFreq, maxha=12.0, method="TEMPO", numNodes=20, ): """ Generate the polyco data. Parameters ---------- model : TimingModel TimingModel to generate the Polycos with parameters setup. mjdStart : float / numpy longdouble Start time of polycos in mjd mjdEnd : float / numpy longdouble Ending time of polycos in mjd obs : str Observatory code segLength : int Length of polyco segement [minutes] ncoeff : int Number of coefficents obsFreq : float Observing frequency [MHz] maxha : float optional. Default 12.0 Maximum hour angle. Only 12.0 is supported for now. method : string optional ["TEMPO", "TEMPO2", ...] Default TEMPO Method to generate polycos. Only the TEMPO method is supported for now. numNodes : int optional. Default 20 Number of nodes for fitting. It cannot be less then the number of coefficents. Return --------- A polyco table. """ mjdStart = data2longdouble(mjdStart) mjdEnd = data2longdouble(mjdEnd) segLength = int(segLength) obsFreq = float(obsFreq) # Use the planetary ephemeris specified in the model, if available. if model.EPHEM.value is not None: ephem = model.EPHEM.value else: log.info( "No ephemeris specified in model, using DE421 to generate polycos" ) ephem = "DE421" if maxha != 12.0: raise ValueError("Maximum hour angle != 12.0 is not supported.") # Make sure the number of nodes is bigger than number of coeffs. if numNodes < ncoeff: numNodes = ncoeff + 1 mjdSpan = data2longdouble(segLength / MIN_PER_DAY) # Generate "nice" MJDs for consistency with what tempo2 does tmids = np.arange( int(mjdStart * 24) * 60, int(mjdEnd * 24) * 60 + segLength, segLength) tmids = data2longdouble(tmids) / MIN_PER_DAY # generate the ploynomial coefficents if method == "TEMPO": entryList = [] # Using tempo1 method to create polycos # If you want to disable the progress bar, add disable=True to the tqdm() call. for tmid in tqdm(tmids): tStart = tmid - mjdSpan / 2 tStop = tmid + mjdSpan / 2 nodes = np.linspace(tStart, tStop, numNodes) toaMid = toa.get_TOAs_list( [ toa.TOA((np.modf(tmid)[1], np.modf(tmid)[0]), obs=obs, freq=obsFreq) ], ephem=ephem, ) refPhase = model.phase(toaMid, abs_phase=True) # Create node toas(Time sample using TOA class) toaList = [ toa.TOA( (np.modf(toaNode)[1], np.modf(toaNode)[0]), obs=obs, freq=obsFreq, ) for toaNode in nodes ] toas = toa.get_TOAs_list(toaList, ephem=ephem) ph = model.phase(toas, abs_phase=True) dt = (nodes - tmid) * MIN_PER_DAY rdcPhase = ph - refPhase rdcPhase = rdcPhase.int - (dt * model.F0.value * 60.0) + rdcPhase.frac dtd = dt.astype(float) # Truncate to double rdcPhased = rdcPhase.astype(float) coeffs = np.polyfit(dtd, rdcPhased, ncoeff - 1)[::-1] date, hms = Time(tmid, format="mjd", scale="utc").iso.split() yy, mm, dd = date.split("-") date = dd + "-" + MONTHS[int(mm) - 1] + "-" + yy[-2:] hms = float(hms.replace(":", "")) entry = PolycoEntry( tmid, segLength, refPhase.int, refPhase.frac, model.F0.value, ncoeff, coeffs, ) entry_dict = OrderedDict() entry_dict["psr"] = model.PSR.value entry_dict["date"] = date entry_dict["utc"] = hms entry_dict["tmid"] = tmid entry_dict["dm"] = model.DM.value entry_dict["doppler"] = 0.0 entry_dict["logrms"] = 0.0 entry_dict["mjd_span"] = segLength entry_dict["t_start"] = entry.tstart entry_dict["t_stop"] = entry.tstop entry_dict["obs"] = obs entry_dict["obsfreq"] = obsFreq if model.is_binary: binphase = model.orbital_phase(toaMid, radians=False)[0] entry_dict["binary_phase"] = binphase b = model.get_components_by_category()["pulsar_system"][0] entry_dict["f_orbit"] = 1 / b.PB.value entry_dict["entry"] = entry entryList.append(entry_dict) pTable = table.Table(entryList, meta={"name": "Polyco Data Table"}) self.polycoTable = pTable if len(self.polycoTable) == 0: raise ValueError("Zero polycos found for table") else: raise NotImplementedError( "Only TEMPO method has been implemented.")
def patchAndDenoise(x_values, orders, waves, x_errors=None, times=None, file_list=None, K=2, num_iters=50, running_window=9, line_cutoff=0.5, file_cutoff=0.5, outlier_cut=0, verbose=False): """ - Vet for bad lines/exposures - Initial patch of bad data with running mean - Iterative patch with PCA for specified number of iterations - Optional second round of interative PCA patching to catch outliers Parameters ---------- x_values, x_errors : 2D ndarray Array of line positions for all lines for each exposure and errors orders : 1D ndarray Array of orders for each line waves : 1D ndarray Array of wavelengths for each line times : 1D ndarray, optional Time stamps for each exposure Just written into the returned patch dictionary (not explicitely used for this code, but helps with evalWaveSol) K : int, optional (default: 2) Number of principal components used for denoising num_iters : int, optional (default: 50) Number of iterations to run iterative PCA patching running_window ; int, optional (default: 9) Window size of running mean used to initialize pixel values for lines missing measured pixel values line_cutoff, file_cutoff : float [0,1], optional (default: 0.5) Cutoff for bad lines or files, respectively. i.e. defaults cut lines that show up in less than 50% of exposure and files that contain less than 50% of all lines outlier_cut : float, optional (default: 0) Sigma cut used to identify outliers following first round of iterative PCA. Note: 0 means this process isn't done. Returns ------- patch : dict Dictionary containing all the useful information from this process (among, very many uselss information!) Needed for evalWaveSol function """ # Arrays that aren't needed, but are helpful to have in returned dictionary if times is None: times = np.zeros_like(file_list) if x_errors is None: x_errors = np.zeros_like(x_errors) if file_list is None: file_list = np.zeros_like(times) ### Vetting # Find where there is no line information x_values[np.nan_to_num(x_values) < 1] = np.nan # Mask out of order lines out_of_order = np.zeros_like(x_values, dtype=bool) for m in np.unique(orders): I = orders == m wave_sort = np.argsort(waves[I]) for i, exp in enumerate(x_values): exp_sort = exp[I][wave_sort] exp_diff = np.diff(exp_sort) left_diff = np.insert(exp_diff < 0, 0, False) right_diff = np.append(exp_diff < 0, False) exp_mask = np.logical_or(left_diff, right_diff) out_of_order[i, I] = exp_mask.copy() x_values[out_of_order] = np.nan if verbose: num_bad = np.sum(out_of_order) num_total = out_of_order.size print('{:.3}% of lines masked'.format((num_bad) / num_total * 100)) # Get rid of bad lines good_lines = np.mean(np.isnan(x_values), axis=0) < line_cutoff # Trim everything orders = orders[good_lines] waves = waves[good_lines] x_values = x_values[:, good_lines] x_errors = x_errors[:, good_lines] if verbose: num_good = np.sum(good_lines) num_total = good_lines.size print('{} of {} lines cut ({:.3}%)'.format( (num_total - num_good), num_total, (num_total - num_good) / num_total * 100)) # Get rid of bad files good_files = np.mean(np.isnan(x_values), axis=1) < file_cutoff # Trim everything x_values = x_values[good_files] x_errors = x_errors[good_files] file_names = file_list[good_files] file_times = times[good_files] if verbose: num_good = np.sum(good_files) num_total = good_files.size print('{} of {} files cut ({:.3}%)'.format( (num_total - num_good), num_total, (num_total - num_good) / num_total * 100)) print('Files that were cut:') print(file_list[~good_files]) ### Patching # Initial patch of bad data with mean bad_mask = np.isnan(x_values) # mask to identify patched x_values if running_window > 0: half_size = int(running_window // 2) counter = 6 while np.sum(np.isnan(x_values)) > 0: for i in range(x_values.shape[0]): # Identify files in window file_range = [ max((i - half_size, 0)), min((i + half_size + 1, x_values.shape[1])) ] # Find mean of non-NaN values run_med = np.nanmean(x_values[file_range[0]:file_range[1], :], axis=0) # Patch NaN values with mean for center file x_values[i][bad_mask[i, :]] = run_med[bad_mask[i, :]] counter -= 1 if counter < 0: print("Persistant NaNs with running mean.") print("Replacing remaining NaNs with global mean.") tot_mean = np.nanmean( x_values, axis=0)[None, ...] * np.ones_like(x_values) x_values[np.isnan(x_values)] = tot_mean[np.isnan(x_values)] break else: # don't bother with running mean mean_values = np.nanmean(x_values, axis=0) mean_patch = np.array([mean_values for _ in range(x_values.shape[0])]) x_values[bad_mask] = mean_patch[bad_mask] # Iterative PCA pca_results = pcaPatch(x_values, bad_mask, K=K, num_iters=num_iters) x_values, mean_x_values, denoised_xs, uu, ss, vv = pca_results # Mask line center outliers if outlier_cut > 0: x_resids = x_values - denoised_xs out_mask = abs(x_resids - np.mean(x_resids)) > (outlier_cut * np.nanstd(x_resids)) if verbose: num_out = np.sum(out_mask) num_total = out_mask.size num_bad = np.sum(np.logical_and(out_mask, bad_mask)) print('{:.3}% of lines marked as Outliers'.format( (num_out) / num_total * 100)) print('{:.3}% of lines marked as Outliers that were PCA Patched'. format((num_bad) / num_total * 100)) pca_results = pcaPatch(x_values, np.logical_or(bad_mask, out_mask), K=K, num_iters=num_iters) x_values, mean_x_values, denoised_xs, uu, ss, vv = pca_results # Load in all relevant information into dictionary patch_dict = {} patch_dict['K'] = K # Exposure Information patch_dict['files'] = file_names.copy() patch_dict['times'] = file_times.copy() min_date = Time(file_times.min(), format='mjd').isot.split('T')[0] yr, mn, dy = min_date.split('-') patch_dict['min_date'] = yr[2:] + mn + dy min_date = Time(file_times.max(), format='mjd').isot.split('T')[0] yr, mn, dy = min_date.split('-') patch_dict['max_date'] = yr[2:] + mn + dy # Line Information patch_dict['orders'] = orders.copy() patch_dict['waves'] = waves.copy() # Line Measurement Information patch_dict['x_values'] = x_values.copy() patch_dict['x_errors'] = x_errors.copy() patch_dict['denoised_xs'] = denoised_xs.copy() patch_dict['mean_xs'] = mean_x_values.copy() patch_dict['bad_mask'] = bad_mask.copy() # PCA Information patch_dict['u'] = uu.copy() patch_dict['s'] = ss.copy() patch_dict['v'] = vv.copy() patch_dict['ec'] = (uu * ss)[:, :K] # Outlier Information if outlier_cut > 0: patch_dict['out_mask'] = out_mask.copy() return patch_dict
Photo_Log = Photo_Log.round({ 'HWPANG': 2, 'JD': 6, 'FWHM_o': 2, 'FWHM_e': 2, 'Aper [pix]': 2, 'EXP [s]': 2, 'Ann': 2, 'Ann_out': 2, 'Flux_o': 4, 'eFLux_o': 4, 'Flux_e': 4, 'eFLux_e': 4, 'SNR_o': 2, 'SNR_e': 2, 'Sky_o': 4, 'eSky_o': 4, 'Sky_e': 4, 'eSky_e': 4 }) Pol_Log.to_csv( os.path.join(path, 'result_Pol_{}.csv'.format(time_.split(' ')[0]))) Photo_Log.to_csv( os.path.join(path, 'result_Photo_{}.csv'.format(time_.split(' ')[0]))) print( os.path.join(path, 'result_Pol_{}.csv'.format(time_.split(' ')[0])) + ' is created.') print( os.path.join(path, 'result_Photo_{}.csv'.format(time_.split(' ')[0])) + ' is created.')
import yaml from astropy.time import Time import os with open('recycler.yaml', 'r') as f: recy = yaml.load(f) propid = recy["propid"] MJDnite = recy["start_of_season"] nite = Time(MJDnite, format="mjd").iso nite = nite.split(' ')[0].split('-')[0] + nite.split(' ')[0].split( '-')[1] + nite.split(' ')[0].split('-')[2] os.system('. ./getExpWPropIDandNite.sh -n ' + nite + ' -p ' + propid)
def tab2_BUT_tCLN_param_save(): with open(CleanID_dir + 'CASA_CLN_args.json', 'w') as fp: json.dump(tab2_tCLN_Param_dict, fp) tab2_Div_tCLN2.text = '<p>CASA script and arguments config file saved to <b>{}</b>.</p>'.format( CleanID_dir) timestrs = [] fits_local = [] fits_global = [] if 'twidth' in tab2_tCLN_Param_dict.keys(): val = tab2_tCLN_Param_dict['twidth'] exec('twidth = int({})'.format(val)) else: twidth = 1 if 'workdir' in tab2_tCLN_Param_dict.keys(): val = tab2_tCLN_Param_dict['workdir'] exec('workdir = {}'.format(val)) else: workdir = './' # os.system('cp {} {}'.format(CleanID_dir + 'CASA_CLN_args.json', workdir)) os.system('cp {}/DataBrowser/ToClean/script_clean.py {}'.format( suncasa_dir, CleanID_dir)) for ii in range(tab2_ntim): iit = int(ii) / twidth * twidth t0 = xx[iit] - tab2_dt / 2 datestr = Time(t0 / 3600. / 24., format='jd', scale='utc', precision=3, out_subfmt='date').iso timestr0 = Time(t0 / 3600. / 24., format='jd', scale='utc', precision=3, out_subfmt='date_hms').iso timestr0 = timestr0.split(' ')[1] timestr = datestr.replace("-", "") + 'T' + timestr0.replace(":", "") timestrs.append(timestr0) fits_local.append(timestr + '.fits') fits_global.append(timestr + '.fits') timestrs = timestrs * int(tab2_nfreq) fits_local = fits_local * int(tab2_nfreq) fits_global = fits_global * int(tab2_nfreq) freqstrs = ['{:.3f}'.format(ll) for ll in yy] dspecDFout = pd.DataFrame({ 'time': xx - xx[0], 'freq': yy, 'timestr': timestrs, 'freqstr': freqstrs, 'dspec': tab2_spec_plt.flatten(), 'fits_local': fits_local, 'fits_global': fits_global }) with open(FS_dspecDF, 'wb') as fp: pickle.dump(dspecDFout, fp) tab2_Div_tCLN2.text = '<p>CASA script, arguments config file and dspecDF-base saved to <b>{}</b>. '.format( CleanID_dir ) + 'Click the <b>clean</b> button to clean. When finished, \ go back to <b>QLook</b> window, select StrID <b>{}</b> and \ click <b>FSview</b> button again.</p>'.format(CleanID_dir, struct_id[0:-1])
def tab2_dspec_selection_change(attrname, old, new): global tapPointDF_dspec, dspecDF_select global SRC_dspec_quadselround if clickmode == 'singleclick': tab2_r_dspec_patch.data_source.data = {'xx': [], 'yy': []} tab2_SRC_dspec_quadx_selected = tab2_SRC_dspec_quadx.selected['1d'][ 'indices'] tab2_SRC_dspec_quady_selected = tab2_SRC_dspec_quady.selected['1d'][ 'indices'] if len(tab2_SRC_dspec_quadx_selected) > 0 and len( tab2_SRC_dspec_quady_selected) > 0: quadx_selected = tab2_SRC_dspec_quadx_selected[0] quady_selected = tab2_SRC_dspec_quady_selected[0] idx = quady_selected * tab2_ntim + quadx_selected tmp = tab2_r_dspec.data_source.data['image'][0] timstr = dspecDF0['timestr'].iloc[idx] freqstr = '{:.3f} [GHz]'.format(dspecDF0['freq'].iloc[idx]) tooltips = ['{} {}'.format(timstr, freqstr)] tab2_dspec_xPro_data = { 'x': tab2_dtim, 'y': tmp[quady_selected, :] } r_dspec_xPro.data_source.data = tab2_dspec_xPro_data tab2_dspec_xPro_hover_data = { 'x': [tab2_dtim[quadx_selected]], 'y': [tmp[quady_selected, quadx_selected]], 'tooltips': tooltips } r_dspec_xPro_hover.data_source.data = tab2_dspec_xPro_hover_data tab2_dspec_yPro_data = { 'x': tmp[:, quadx_selected], 'y': tab2_freq } r_dspec_yPro.data_source.data = tab2_dspec_yPro_data tab2_dspec_yPro_hover_data = { 'x': [tmp[quady_selected, quadx_selected]], 'y': [tab2_freq[quady_selected]], 'tooltips': tooltips } r_dspec_yPro_hover.data_source.data = tab2_dspec_yPro_hover_data tab2_r_dspec_line_x.data_source.data = { 'time': [tab2_dtim[0], tab2_dtim[-1]], 'freq': [tab2_freq[quady_selected]] * 2 } tab2_r_dspec_line_y.data_source.data = { 'time': [tab2_dtim[quadx_selected]] * 2, 'freq': [tab2_freq[0], tab2_freq[-1]] } elif len(tab2_SRC_dspec_quadx_selected) == 0 and len( tab2_SRC_dspec_quady_selected) == 0: r_dspec_xPro.data_source.data = {'x': [], 'y': []} r_dspec_xPro_hover.data_source.data = { 'x': [], 'y': [], 'tooltips': [] } r_dspec_yPro.data_source.data = {'x': [], 'y': []} r_dspec_yPro_hover.data_source.data = { 'x': [], 'y': [], 'tooltips': [] } tab2_r_dspec_line_x.data_source.data = {'time': [], 'freq': []} tab2_r_dspec_line_y.data_source.data = {'time': [], 'freq': []} elif clickmode == 'doubleclick': SRC_dspec_quadselround += 1 if SRC_dspec_quadselround == 2: SRC_dspec_quadselround = 0 tab2_SRC_dspec_quadx_selected = tab2_SRC_dspec_quadx.selected[ '1d']['indices'] tab2_SRC_dspec_quady_selected = tab2_SRC_dspec_quady.selected[ '1d']['indices'] tab2_SRC_dspec_quadx.selected = { '0d': { 'glyph': None, 'indices': [] }, '1d': { 'indices': [] }, '2d': {} } tab2_SRC_dspec_quady.selected = { '0d': { 'glyph': None, 'indices': [] }, '1d': { 'indices': [] }, '2d': {} } if len(tab2_SRC_dspec_quadx_selected) > 0 and len( tab2_SRC_dspec_quady_selected) > 0: quadx_selected = tab2_SRC_dspec_quadx_selected[0] quady_selected = tab2_SRC_dspec_quady_selected[0] tapPointDF_dspec = tapPointDF_dspec.append(pd.Series({ 'xx': tab2_dtim[quadx_selected], 'yy': tab2_freq[quady_selected] }), ignore_index=True) if len(tapPointDF_dspec.index) == 1: tab2_r_dspec_lines.data_source.data = { 'xs': [[tab2_dtim[quadx_selected]] * 2, [tab2_dtim[0], tab2_dtim[-1]]], 'ys': [[tab2_freq[0], tab2_freq[-1]], [tab2_freq[quady_selected]] * 2] } tab2_r_dspec_patch.data_source.data = {'xx': [], 'yy': []} elif len(tapPointDF_dspec.index) == 2: x0, x1 = tapPointDF_dspec['xx'].min( ), tapPointDF_dspec['xx'].max() y0, y1 = tapPointDF_dspec['yy'].min( ), tapPointDF_dspec['yy'].max() tab2_r_dspec_patch.data_source.data = { 'xx': [x0, x1, x1, x0], 'yy': [y0, y0, y1, y1] } tab2_r_dspec_lines.data_source.data = {'xs': [], 'ys': []} dspecDF_select = \ dspecDF0_rs[dspecDF0_rs['time'] >= x0][dspecDF0_rs['time'] <= x1][ dspecDF0_rs['freq'] >= y0][ dspecDF0_rs['freq'] <= y1] tapPointDF_dspec = pd.DataFrame({'xx': [], 'yy': []}) time0, time1 = dspecDF_select['time'].min( ) + timestart, dspecDF_select['time'].max() + timestart t0_char = Time(time0 / 3600. / 24., format='jd', scale='utc', precision=3, out_subfmt='date_hms').iso date0_char = t0_char.split(' ')[0].replace('-', '/') time0_char = t0_char.split(' ')[1] t1_char = Time(time1 / 3600. / 24., format='jd', scale='utc', precision=3, out_subfmt='date_hms').iso date1_char = t1_char.split(' ')[0].replace('-', '/') time1_char = t1_char.split(' ')[1] tab2_tCLN_Param_dict['timerange'] = "'{}/{}~{}/{}'".format( date0_char, time0_char, date1_char, time1_char) freq0, freq1 = dspecDF_select['freq'].min( ), dspecDF_select['freq'].max() freqrange = "'{:.3f}~{:.3f} GHz'".format(freq0, freq1) tab2_tCLN_Param_dict['freqrange'] = freqrange tab2_Div_tCLN_text = ' '.join( "<p><b>{}</b> = {}</p>".format(key, val) for (key, val) in tab2_tCLN_Param_dict.items()) tab2_Div_tCLN.text = tab2_Div_tCLN_text
xx = tim_map.flatten() yy = freq_map.flatten() timestart = xx[0] tab2_panel_Div_exit = Div( text="""<p><b>Warning</b>: Click the <b>Exit ToClean</b> first before closing the tab</p></b>""", width=config_main['plot_config']['tab_ToClean']['widgetbox_wdth1']) timestrs = [] for ll in tab2_tim: timestr = Time(ll / 3600. / 24., format='mjd', scale='utc', precision=3, out_subfmt='date_hms').iso timestrs.append(timestr.split(' ')[1]) timestrs = timestrs * tab2_nfreq dspecDF0 = pd.DataFrame({ 'time': xx - xx[0], 'freq': yy, 'dspec': tab2_spec_plt.flatten(), 'timestr': timestrs }) rmax, rmin = tab2_spec_plt.max(), tab2_spec_plt.min() # timestart = xx[0] TOOLS = "crosshair,pan,wheel_zoom,box_zoom,reset,save" # downsample_dspecDF(spec_square_rs_tmax=spec_square_rs_tmax, spec_square_rs_fmax=spec_square_rs_fmax) # tab2_SRC_dspec_square = ColumnDataSource(dspecDF0_rs) dspecDF0_rs = dspecDF0.copy() '''create the dynamic spectrum plot'''
ignore_index=True) Pol_name = ['filename', 'JD', 'alpha [deg]', 'PsANG [deg]', 'q', 'u', 'ran_q', 'ran_u', 'sys_q', 'sys_u', 'P', 'eP', 'Pr', 'theta', 'theta_r', 'eTheta', 'Aper_radius [pix]'] Phot_name = ['Object', 'Filename', 'set', 'TIME', 'JD', 'HWPANG', 'FWHM_o', 'FWHM_e', 'EXP [s]', 'Aper [pix]', 'Ann', 'Ann_out', 'Flux_o', 'eFLux_o', 'Flux_e', 'eFLux_e', 'Sky_o', 'eSky_o', 'Sky_e', 'eSky_e', 'SNR_o', 'SNR_e'] Pol_Log = Pol_Log.reindex(columns=Pol_name) Photo_Log = Photo_Log.reindex(columns=Phot_name) Pol_Log = Pol_Log.round({'JD': 6, 'alpha [deg]': 2, 'PsANG [deg]': 2, 'q': 4, 'u': 4, 'ran_q': 4, 'ran_u': 4, 'sys_q': 4, 'sys_u': 4, 'theta': 2, 'theta_r': 2, 'P': 4, 'eP': 4, 'Aper_radius [pix]': 2, 'Pr': 4, 'eTheta': 2}) Photo_Log = Photo_Log.round({'HWPANG': 2, 'JD': 6, 'FWHM_o': 2, 'FWHM_e': 2, 'Aper [pix]': 2, 'EXP [s]': 2, 'Ann': 2, 'Ann_out': 2, 'Flux_o': 4, 'eFLux_o': 4, 'Flux_e': 4, 'eFLux_e': 4, 'SNR_o': 2, 'SNR_e': 2, 'Sky_o': 4, 'eSky_o': 4, 'Sky_e': 4, 'eSky_e': 4}) Pol_Log.to_csv(os.path.join(path, 'result_Pol_{}.csv'.format(time_.split(' ')[0]))) Photo_Log.to_csv(os.path.join(path, 'result_Photo_{}.csv'.format(time_.split(' ')[0]))) print(os.path.join(path, 'result_Pol_{}.csv'.format(time_.split(' ')[0])) + ' is created.') print(os.path.join(path, 'result_Photo_{}.csv'.format(time_.split(' ')[0])) + ' is created.')