def get_ffilc(name=None, tic=None, coords=None, sectors='all'): """ """ if name is None and tic is None and coords is None: raise ValueError('Please specify a name, TIC ID, or coordinates!') if name is None and tic is not None: name = 'TIC ' + str(tic) if coords is not None: if isinstance(coords, tuple) or isinstance(coords, list): coords = SkyCoord(coords[0], coords[1], unit='deg') if sectors == 'all' and coords is not None: sector_table = Tesscut.get_sectors(coordinates=coord) sectors = list( map(int, [row[6:10] for row in sector_table['sectorName']])) #tesscut add more here to parse sectors? elif sectors == 'all' and name is not None: sector_table = Tesscut.get_sectors(objectname=name) sectors = list( map(int, [row[6:10] for row in sector_table['sectorName']])) if name is None and tic is not None: name = "TIC " + str(tic) search_result = lk.search_tesscut(name, sector=sectors) else: print('hi')
def locate_with_tesscut(self): """Finds the best TESS postcard(s) and the position of the source on postcard. Sets attributes postcard, position_on_postcard, all_postcards. sector, camera, chip, position_on_chip. """ self.postcard = [] self.position_on_postcard = [] self.all_postcards = [] self.tc = True coord = SkyCoord(self.coords[0], self.coords[1], unit="deg") sector_table = Tesscut.get_sectors(coord) manifest = Tesscut.download_cutouts(coord, 31, sector = self.usr_sec) self.sector = self.usr_sec self.camera = sector_table[sector_table['sector'] == self.sector]['camera'].quantity[0] self.chip = sector_table[sector_table['sector'] == self.sector]['ccd'].quantity[0] whichtc = np.where(sector_table['sector'] == self.usr_sec)[0][0] cutout = fits.open(manifest['Local Path'][0]) self.cutout = cutout xcoord = cutout[1].header['1CRV4P'] ycoord = cutout[1].header['2CRV4P'] self.position_on_chip = np.array([xcoord, ycoord])
def get_ffi_image(target, cutout_deg=0.1): ra = target['ra'] dec = target['dec'] coord = SkyCoord(ra, dec, unit="deg") print(coord) npixels = 2 * np.ceil( cutout_deg * 3600 / 21) + 4 #This assumes 21arcsecond pixels) if npixels > 60: npixels = 60 print("Warning: cutout size set to 80 pixels.") if npixels < 10: npixels = 10 sector_tab = Tesscut.get_sectors(coordinates=coord) try: hdulist = Tesscut.get_cutouts(coord, size=npixels, sector=sector_tab[0]['sector']) except: print("Cutout not available") return [[0][0]], "no wcs" hdu = hdulist[0] aveImage = (hdu[1].data['FLUX'][0] + hdu[1].data['FLUX'][1] + hdu[1].data['FLUX'][2]) / 3 wcs = WCS(hdu[2].header) return aveImage, wcs
def set_quality_flags(sector=np.arange(1, 14, 1)): """ Uses the quality flags in a 2-minute target to create quality flags in the postcards. We create our own quality flag as well, using our pointing model. """ coord = SkyCoord('04:35:50.330 -64:01:37.33', unit=(u.hourangle, u.deg)) sector_table = Tesscut.get_sectors(coord) manifest = Tesscut.download_cutouts(coordinates=coord, size=31, sector=sector) cutout = fits.open(manifest['Local Path'][0]) ffi_time = cutout[1].data['TIME'] - cutout[1].data['TIMECORR'] shortCad_fn = 'eleanor/metadata/s{0:04d}/target_s{0:04d}.fits'.format( sector) # Binary string for values which apply to the FFIs ffi_apply = int('100010101111', 2) # Obtains information for 2-minute target twoMin = fits.open(shortCad_fn) twoMinTime = twoMin[1].data['TIME'] - twoMin[1].data['TIMECORR'] finite = np.isfinite(twoMinTime) twoMinQual = twoMin[1].data['QUALITY'] twoMinTime = twoMinTime[finite] twoMinQual = twoMinQual[finite] convolve_ffi = [] nodata = np.zeros_like(ffi_time) for i in range(len(ffi_time)): where = np.where( np.abs(ffi_time[i] - twoMinTime) == np.min(np.abs(ffi_time[i] - twoMinTime)))[0][0] sflux = np.sum(cutout[1].data['FLUX'][i]) if sflux == 0: nodata[i] = 4096 if (ffi_time[i] > 1420) and (ffi_time[i] < 1424): nodata[i] = 4096 v = np.bitwise_or.reduce(twoMinQual[where - 7:where + 8]) convolve_ffi.append(v) convolve_ffi = np.array(convolve_ffi) flags = np.bitwise_and(convolve_ffi, ffi_apply) np.savetxt('eleanor/metadata/s{0:04d}/quality_s{0:04d}.txt'.format(sector), flags + nodata, fmt='%i') return flags
def __init__(self, sector=None): if sector is None: print('Please pass a sector into eleanor.Update()!') return self.sector = sector try: os.mkdir(eleanorpath + '/metadata/s{:04d}'.format(sector)) success = 1 except FileExistsError: print('Sector {:d} metadata directory exists already!'.format( sector)) success = 0 if success == 1: tic_north_cvz = 198237770 tic_south_cvz = 38846515 if self.sector < 13.5: self.tic = tic_south_cvz elif self.sector < 26.5: self.tic = tic_north_cvz else: self.tic = tic_south_cvz if self.tic == 198237770: coord = SkyCoord('16:35:50.667 +63:54:39.87', unit=(u.hourangle, u.deg)) elif self.tic == 38846515: coord = SkyCoord('04:35:50.330 -64:01:37.33', unit=(u.hourangle, u.deg)) sector_table = Tesscut.get_sectors(coord) manifest = Tesscut.download_cutouts(coord, 31, sector=self.sector) self.cutout = fits.open(manifest['Local Path'][0]) print( 'This is the first light curve you have made for this sector. Getting eleanor metadata products for Sector {0:2d}...' .format(self.sector)) print( 'This will only take a minute, and only needs to be done once. Any other light curves you make in this sector will be faster.' ) self.get_target() print('Target Acquired') self.get_cadences() print('Cadences Calculated') self.get_quality() print('Quality Flags Assured') self.get_cbvs() print('CBVs Made') print('Success! Sector {:2d} now available.'.format(self.sector)) self.try_next_sector()
def locate_with_tesscut(self): """ Finds the best TESS postcard(s) and the position of the source on postcard. Attributes ---------- postcard : list postcard_path : str position_on_postcard : list all_postcards : list sector : int camera : int chip : int position_on_chip : np.array """ self.postcard = [] self.position_on_postcard = [] self.all_postcards = [] self.tc = True coord = SkyCoord(self.coords[0], self.coords[1], unit="deg") sector_table = Tesscut.get_sectors(coord) self.sector = self.usr_sec self.camera = sector_table[sector_table['sector'] == self.sector]['camera'].quantity[0].value self.chip = sector_table[sector_table['sector'] == self.sector]['ccd'].quantity[0].value download_dir = self.tesscut_dir() fn_exists = self.search_tesscut(download_dir, coord) if fn_exists is None: manifest = Tesscut.download_cutouts(coord, self.tesscut_size, sector=self.usr_sec, path=download_dir) cutout = fits.open(manifest['Local Path'][0]) self.postcard_path = manifest['Local Path'][0] else: self.postcard_path = fn_exists cutout = fits.open(fn_exists) self.cutout = cutout self.postcard = self.postcard_path.split('/')[-1] xcoord = cutout[1].header['1CRV4P'] ycoord = cutout[1].header['2CRV4P'] self.position_on_chip = np.array([xcoord, ycoord])
def diff_image_lc_download(target_ID, sector, plot_lc = False, from_file = True, save_path = '/home/u1866052/Lowess detrending/TESS S5/'): """ Downloads and returns 30min cadence lightcurves based on Oelkers & Stassun difference imaging analysis method of lightcurve extraction """ DIAdir = '/ngts/scratch/tess/FFI-LC/S{}/lc/clean/'.format(sector) ra, dec, tic = find_tic(target_ID, from_file = from_file) object_coord = SkyCoord(ra, dec, unit="deg") sector_info = Tesscut.get_sectors(object_coord) for i in range(len(sector_info)): if sector_info[i][1] == sector: index = i camera = sector_info[index][2] ccd = sector_info[index][3] # star = eleanor.Source(coords=(ra, dec), sector=1) ## camera = # ccd = star.chip filename = '{}_sector0{}_{}_{}.lc'.format(tic, sector, camera, ccd) # filename = '{}_sector0{}_{}_{}.lc'.format(tic, sector, camera, ccd) # filename = '410214986_sector01_3_2.lc' try: #lines = loadtxt(filename, delimiter = ' ') # For when in local directory lines = loadtxt(DIAdir+filename, delimiter = ' ') # For when on ngtshead DIA_lc = list(map(list, zip(*lines))) DIA_mag = np.array(DIA_lc[1]) # Convert TESS magnitudes to flux DIA_flux = 10**(-0.4*(DIA_mag - 20.60654144)) norm_flux = DIA_flux/np.median(DIA_flux) # Plot Difference imaged data if plot_lc == True: diffImage_fig = plt.figure() plt.scatter(DIA_lc[0], norm_flux, s=1, c= 'k') plt.ylabel('Normalized Flux') plt.xlabel('Time') plt.title('{} - Difference imaged light curve from FFIs'.format(target_ID)) # diffImage_fig.savefig(save_path + '{} - Sector {} - DiffImage flux.png'.format(target_ID, sector)) # plt.close(diffImage_fig) plt.show() lc = lightkurve.LightCurve(time = DIA_lc[0],flux = norm_flux, flux_err = DIA_lc[2], targetid = target_ID) return lc, filename except: print('The file {} does not exist - difference imaging data not available for {}'.format(filename,target_ID))
def checkCoordInSector(self, coord, sector): """ Determine if there is data on the Sector requested for the target. """ sectorTable = Tesscut.get_sectors(coord) if sector in sectorTable['sector']: sectorExists = True else: sectorExists = False return sectorExists
def tessobs_info(tic=None, ra=None, dec=None): #!!Update to include exp time, pixel location, other observation-specific # quantities!! """ Function to retrieve observation information for objects observed by TESS. Parameters ---------- tic : int or None TIC ID of target to be queried. Must not be None if ra and dec are None. ra : float or None RA of target to be queried. Must not be None if tic is None. dec : float or None Dec of target to be queried. Must not be None if tic is None. Returns ------- info : dict Dictionary continaing TESS observation info. """ if not tic and not ra and not dec: raise ValueError('Please provide either a TIC ID or both RA and Dec') if not ra or not dec: cat = Catalogs.query_criteria(catalog="TIC", ID=int(tic)) ra = cat[0]['ra'] dec = cat[0]['dec'] coords = coord.SkyCoord(ra, dec, unit='deg') sector_table = Tesscut.get_sectors(coordinates=coords) if len(sector_table) == 0: print('Object not observed by TESS') sec_name = [] sec = [] cam = [] ccd = [] for i in range(len(sector_table)): sec_name.append(sector_table[i]['sectorName']) sec.append(sector_table[i]['sector']) cam.append(sector_table[i]['camera']) ccd.append(sector_table[i]['ccd']) info = {'sectorName' : sec_name, 'sector' : sec, 'camera' : cam, 'ccd' : ccd} return info
def call_astropy(main, RA, DE): if (len(RA) == 0): call_file_name return else: coord = SkyCoord(RA[len(RA) - 1], DE[len(DE) - 1], unit="deg") sector_table = Tesscut.get_sectors(coordinates=coord) if (len(sector_table) == 0): # not in a sector (yet?) RA.pop() DE.pop() call_astropy(main, RA, DE) else: sectors = [0] * (len(sector_table)) for i in range(len(sector_table)): sectors[i] = int(sector_table['sector'][i]) view_next(main, RA, DE, coord, sectors)
def bert_tess_fullframe_main_1(): """Extract light curve data from TESS full frame images for a given TIC ID. This Lambda function loops through full frame images. For each full frame image, it invokes :func:`bert_tess_fullframe_worker`. """ from astropy.coordinates import SkyCoord from astroquery.mast import Catalogs, Tesscut work_queue, done_queue, ologger = utils.comm_binders( bert_tess_fullframe_main_1) # https://exo.mast.stsci.edu/exomast_planet.html?planet=WASP126b # Example event: # { # "tic_id": "25155310", # "radius": 2.5, # "cutout_width": 30, # "use_cache": "true" # } for event in work_queue: tic_id = event['tic_id'] info = Catalogs.query_criteria(catalog='Tic', ID=tic_id) ra = info['ra'][0] # deg dec = info['dec'][0] # deg coo = SkyCoord(ra, dec, unit='deg') # TODO: Allow auto determination of radius from mag if not given. # mag = info['Tmag'][0] sector_resp = Tesscut.get_sectors(coordinates=coo) ologger.info(f'Found {len(sector_resp)} sectors for {tic_id}') # Process all the matched sectors. for sec_id in sector_resp['sectorName']: done_queue.put({ 'tic_id': tic_id, 'sec_id': sec_id, 'ra': ra, 'dec': dec, 'radius': event['radius'], 'cutout_width': event['cutout_width'], 'use_cache': event['use_cache'] })
def test_pi_men(): """Tests `locate()` against `astroquery.mast.Tesscut.get_sectors()`""" # Query using Tesscut crd = SkyCoord(ra=84.291188, dec=-80.46911982, unit="deg") mast_result = Tesscut.get_sectors(crd) # Query using our tool our_result = locate(crd) # Do the sector, camera, and ccd numbers all match? our_result_df = our_result.to_pandas().reset_index()[["sector", "camera", "ccd"]] mast_result_df = mast_result.to_pandas().reset_index()[["sector", "camera", "ccd"]] # Hack: MAST incorrectly returns Pi Men as having been observed in Sector 35, while in # reality it is just off the science area of the CCD, so we ignore the row for Sector 35. mast_result_df = mast_result_df.query("sector != 35").reset_index(drop=True) # Note: MAST may have less results because it only reports archived data assert our_result_df.iloc[0 : len(mast_result_df)].equals(mast_result_df) # Can we search by passing a string instead of the coordinates? our_result2 = locate("Pi Men") assert our_result.to_pandas().round(2).equals(our_result2.to_pandas().round(2))
def get_object_coords(ticid, sector, nFFI=10, cloud=False, local_dir="."): """ Retrieve the camera, ccd, column row of the ticid of interest. Downloads a single FFI image in order to retrieve the FITS header. Input: ticid: tess ID sector : integer sector number nFFI: indicates which FFI cadence to use. cloud: False. Set to true if running on AWS local_dir: Is the location to store the FFI image before reading header. Returns: camera, ccd, column, row if they are all zero, then there is no data to be had """ coord = ticid_to_coord(ticid) results = Tesscut.get_sectors(coord, radius=0) camera = 0 ccd = 0 col = 0 row = 0 if len(results) > 0: want = results['sector'] == sector if len(results[want]) > 0: camera = results[want]['camera'][0] ccd = results[want]['ccd'][0] if camera > 0: secid = make_secid(sector, camera, ccd) ffi_file_path = get_wcsfile(secid) #filtered = id_wcs_file(secid) #ffi_file_path = download_wcs_file(filtered, local_dir, n=nFFI, cloud=cloud) #I need to create a file lookup in here, but for the moment. col, row = get_xy(ffi_file_path, coord) return camera, ccd, col, row
def download_TESS_cutouts_ID(target_ID_list, cutout_size=[11, 11]): """ This function downloads the TESS-cutouts for a specified list of target IDs and returns a dictionary of the associated filename(s) for each target Inputs: Name type description ----------------------------------------------------------------------- target_ID_ list [n x 1] list list of target IDs as strings cutout_size [2 x 1] list postcard cutout size Output: target_filenames n x 2 dictionary with target ids and target filenames """ filename = "BANYAN_XI-III_combined_members.csv" data = Table.read(filename, format='ascii.csv') target_filenames = {} for target_id in target_ID_list: i = list(data['main_id']).index(target_id) ra = data['ra'][i] dec = data['dec'][i] object_coord = SkyCoord(ra, dec, unit="deg") manifest = Tesscut.download_cutouts(object_coord, cutout_size, path='./TESS_Sector_1_cutouts') sector_info = Tesscut.get_sectors(object_coord) if len(manifest['Local Path']) == 1: target_filenames[target_id] = manifest['Local Path'][0][2:] elif len(manifest['Local Path']) > 1: target_filenames[target_id] = [] for filename in manifest['Local Path']: target_filenames[target_id].append(filename[2:]) else: print( 'Cutout for target {} can not be downloaded'.format(target_id)) return target_filenames, sector_info
def get_tess_visibility_given_ticid(tic_id): """ This checks if a given TIC ID is visible in a TESS sector. Parameters ---------- tic_id : str The TIC ID of the object as a string. Returns ------- sector_str,full_sector_str : tuple of strings The first element of the tuple contains a string list of the sector numbers where the object is visible. The second element of the tuple contains a string list of the full sector names where the object is visible. For example, "[16, 17]" and "[tess-s0016-1-4, tess-s0017-2-3]". If empty, will return "[]" and "[]". """ if not astroquery_dependency: LOGERROR( "The astroquery package is required for this function to work.") return None, None ticres = tic_objectsearch(tic_id) with open(ticres['cachefname'], 'r') as json_file: data = json.load(json_file) ra = data['data'][0]['ra'] dec = data['data'][0]['dec'] coord = SkyCoord(ra, dec, unit="deg") sector_table = Tesscut.get_sectors(coord) sector_str = list(sector_table['sector']) full_sector_str = list(sector_table['sectorName']) return sector_str, full_sector_str
def convolve_cbvs(sectors=np.arange(1, 14, 1)): """ Bins the co-trending basis vectors into FFI times; Calls download_cbvs to get filenames Input ----- type(sectors) == list """ # Gets the cutout for a target in the CVZ coord = SkyCoord('04:35:50.330 -64:01:37.33', unit=(u.hourangle, u.deg)) sector_table = Tesscut.get_sectors(coord) for sector in sectors: files = download_cbvs(int(sector)) manifest = Tesscut.download_cutouts(coordinates=coord, size=31, sector=sector) cutout = fits.open(manifest['Local Path'][0]) time = cutout[1].data['TIME'] - cutout[1].data['TIMECORR'] for c in trange(len(files)): cbv = fits.open(files[c]) camera = cbv[1].header['CAMERA'] ccd = cbv[1].header['CCD'] cbv_time = cbv[1].data['Time'] new_fn = './eleanor/metadata/s{0:04d}/cbv_components_s{0:04d}_{1:04d}_{2:04d}.txt'.format( sector, camera, ccd) convolved = np.zeros((len(time), 16)) for i in range(len(time)): g = np.argmin(np.abs(time[i] - cbv_time)) for j in range(16): index = 'VECTOR_{0}'.format(j + 1) cads = np.arange(g - 7, g + 8, 1) convolved[i, j] = np.mean(cbv[1].data[index][cads]) np.savetxt(new_fn, convolved)
def diff_image_lc_download(target_ID, sector, plot_lc=True, from_file=True, save_path=''): """ Downloads and returns 30min cadence lightcurves based on Oelkers & Stassun difference imaging analysis method of lightcurve extraction """ if sector < 3: DIAdir = '/tess/photometry/DIA_FFI/S{}/clean/'.format(sector) else: DIAdir = '/tess/photometry/DIA_FFI/S{}/lc/clean/'.format(sector) if from_file == True: # reads input table for targets table_data = Table.read("BANYAN_XI-III_members_with_TIC.csv", format='ascii.csv') # Obtains ra and dec for object from target_ID i = list(table_data['main_id']).index(target_ID) ra = table_data['ra'][i] dec = table_data['dec'][i] #camera = table_data['S{}'.format(sector)][i] tic = table_data['MatchID'][i] else: # Find ra, dec and tic # via the TIC (typically based on Gaia DR2) TIC_table = Catalogs.query_object(target_ID, catalog="TIC") ra = TIC_table['ra'][0] dec = TIC_table['dec'][0] tic = TIC_table['ID'][0] object_coord = SkyCoord(ra, dec, unit="deg") sector_info = Tesscut.get_sectors(object_coord) for i in range(len(sector_info)): if sector_info[i][1] == sector: index = i camera = sector_info[index][2] ccd = sector_info[index][3] # star = eleanor.Source(coords=(ra, dec), sector=1) ## camera = # ccd = star.chip filename = DIAdir + '{}_sector0{}_{}_{}.lc'.format(tic, sector, camera, ccd) # filename = '{}_sector0{}_{}_{}.lc'.format(tic, sector, camera, ccd) # filename = '410214986_sector01_3_2.lc' print('Trying file {}'.format(filename)) try: lines = loadtxt(filename, delimiter=' ') # For when in local directory # lines = loadtxt(DIAdir+filename, delimiter = ' ') # For when on ngtshead DIA_lc = list(map(list, zip(*lines))) DIA_mag = np.array(DIA_lc[1]) # Convert TESS magnitudes to flux DIA_flux = 10**(-0.4 * (DIA_mag - 20.60654144)) norm_flux = DIA_flux / np.median(DIA_flux) # Plot Difference imaged data if plot_lc == True: diffImage_fig = plt.figure() plt.scatter(DIA_lc[0], norm_flux, s=1, c='k') plt.ylabel('Normalized Flux') plt.xlabel('Time') plt.title('{} - Difference imaged light curve from FFIs'.format( target_ID)) #diffImage_fig.savefig(save_path + '{} - Sector {} - DiffImage flux.png'.format(target_ID, sector)) plt.close(diffImage_fig) diffImage_fig.show() lc = lightkurve.LightCurve(time=DIA_lc[0], flux=norm_flux, flux_err=DIA_lc[2], targetid=target_ID) print('Got the light-curve out') return lc, filename except: print( 'The file {} does not exist - difference imaging data not available for {}' .format(filename, target_ID))
ralist = pd.read_csv('agn_catalogue.csv', sep=',', usecols=['Right Ascension'], squeeze=True) declist = pd.read_csv('agn_catalogue.csv', sep=',', usecols=['Declination'], squeeze=True) sector_column = np.array([['Start']]) for row in range(46000, 46001): print(row) #Return a list of sectors the object was observed coord = SkyCoord(ralist[row], declist[row], unit='deg') sector_table = Tesscut.get_sectors(coordinates=coord) sector_col = sector_table['sector'] sector_list = [] for numbers in sector_col: sector_list.append(numbers) if sector_list == None: sector_list = 0 else: sector_string = np.array([[str(sector_list)]]) sector_column = np.concatenate((sector_column, sector_string), axis=0) np.savetxt('agn_sectors4.csv', sector_column, fmt='%s', delimiter=',') #18286-18287 #40600-40601
def gather_lc(coords=None, tic=None, name=None, cadence='shortest', ffi_only=False, method='2min', sectors='all', eleanor_flag=False, return_method=False, return_sectors=False, obsinfo=None, verbose=False, **kwargs): #!!Add ability to support common names as inputs in absence of TIC!! #!!Add ability for sector cuts in FFI light curves!! #!!Add obsinfo keyword to pass obsinfo if it exists!! #!!Add keyword to track 'author' and 'cadence' keywords for each sector?!! """ Function to gather the light curve of a given TIC using the specified method. Currently, 2 minute SPOC pipeline light curves, machine learning FFI light curves, and eleanor light curves are supported. Parameters ---------- coords : tuple or array Coords of input name : string common name ffi_only : bool whether to default to 2min or have everything be ffis tic : int TESS Input Catalog ID for desired target. At this time, common names are not accepted input, only TIC IDs. method : str The method with which the light curve will be acquired. Options are '2min', 'ffi_ml', and 'eleanor'. sectors : str or list or numpy array List of sectors to be included in the fetching of the light curve. If 'all' or None is passed, all available light curves will be fetched. Thresholds can be passed according to the valid syntax of the method specified. return_method : bool A flag to indicate whether the method used to gather the light curve will be returned. Useful if the chosen method is not known or expected to return a valid light curve. An additional output will be expected. return_sectors : bool A flag to indicate the sectors that the light curve was recovered from. An additional output will be expected. Currently in progress for most methods. obsinfo : dict A dictionary of observational information that can be passed to make some processes run faster if inlc is specified. Assumes output format of transit_tools.tessobs_info command. **kwargs Additional arguments to be passed to the selected method fetching function. Returns ------- lc : 'LightCurve' Light curve containing light curves from all sectors contained within the query of sectors. method : str, optional The method with which the output light curve was gathered. sectors : numpy array, optional The sectors that the light curve was gathered from. """ if coords is None and tic is None and name is None: raise ValueError("You must specify either (RA, Dec), a TIC ID, or " + "the name of the target!") #Fetching the TESS sectors that the target was observed in if coords is not None: coordinates = SkyCoord(coords[0], coords[1], unit="deg") sector_table = Tesscut.get_sectors(coordinates=coordinates) else: if tic is not None: name = "TIC " + str(tic) sector_table = Tesscut.get_sectors(objectname=str(name)) if len(sector_table) == 0: raise ValueError('No valid sectors found for specified target!') #Comprehension of sector inputs if sectors != 'all' and sectors != None: if not isinstance(sectors, list): sectors = list(sectors) secs = list(set(sector_table['sector'].value) & set(sectors)) else: secs = sector_table['sector'].value sec_clipboard = secs #Trying to fetch light curves from MAST if not eleanor_flag: #and not custom_only? try: lc, mast_sec = get_mastlc(tic=tic, name=name, coords=coords, sectors=sec_clipboard, out_sec=True, cadence=cadence, **kwargs) sec_clipboard = [x for x in sec_clipboard if x not in mast_sec] except: print( 'No light curves found on the MAST. Trying another method...') #Trying to generate light curves from eleanor #### #ELEANOR FUNCITON NEEDS TO BE DOUBLE-CHECKED! #### if eleanor_flag == True and len(sec_clipboard) > 0: try: lc, el_sec = get_eleanor(tic=tic, sectors=secs, out_sec=True, **kwargs) sec_clipboard = [x for x in sec_clipboard if x not in el_sec] except: print('eleanor could not find light curves for these sectors.' + ' Trying another method...') #Trying to generate light curves via FFI cutouts if len(sec_clipboard) > 0: try: lc, get_ffilc = ffi_cutout() sec_clipboard = [x for x in sec_clipboard if x not in cut_sec] except: print('Issue with fetching FFI cutouts!') #Printing the sectors (if any) that did not have light curves if len(sec_clipboard) > 0: print('Sectors ' + str(sec_clipboard) + ' did not have light curves!!') #Loop through sectors to fetch light curves #if ffi_only is not None: # try: # lc = get_mastlc() #if return_sectors: # lc, sectors = get_2minlc(tic, secs, out_sec=return_sectors, # **kwargs) #else: # lc = get_2minlc(tic, secs, out_sec=return_sectors, **kwargs) # except: # print('No TESS 2 minute light curves found! Trying FFIs...') # method = 'ffi_ml' #if method == 'ffi_ml': # try: # if return_sectors: # lc, sectors = get_mlffi(tic=tic, sectors=secs, # out_sec=return_sectors, **kwargs) # else: # lc = get_mlffi(tic=tic, sectors=secs, out_sec=return_sectors, # **kwargs) # except: # print('No ML light curves found locally. Trying with eleanor...') # method = 'eleanor' if method == 'eleanor': try: if return_sectors: lc, sectors = get_eleanor(tic=tic, sectors=secs, out_sec=return_sectors, **kwargs) else: lc = get_eleanor(tic=tic, sectors=secs, out_sec=return_sectors, **kwargs) except: raise ValueError( 'No light curves found for the specified sectors!') if return_method and not return_sectors: return lc, method elif not return_method and return_sectors: return lc, secs elif return_method and return_sectors: return lc, method, secs elif not return_method and not return_sectors: return lc
def my_animation(ticid, istart, istop, flare=None): Writer = animation.writers['imagemagick'] Writer = Writer(fps=20, metadata=dict(artist='Me'), bitrate=1800) starName = "TIC " + str(ticid) radSearch = 4 / 60 #radius in degrees #Querying RA and DEC from Catalogs given a TIC ID catalogData = Catalogs.query_object(starName, radius=radSearch, catalog="TIC") ra = catalogData[0]['ra'] dec = catalogData[0]['dec'] #Gets Skycoord given RA and DEC then calls to TESScut obj_coord = SkyCoord(ra, dec, unit="deg") print(obj_coord) Tesscut.get_sectors(obj_coord) cutout_hdu = Tesscut.get_cutouts(obj_coord, size=20)[0] cutout_hdu.info() cutout_table = cutout_hdu[1].data cutout_table.columns def find_index(btjd): return (np.abs(cutout_table['TIME'] - btjd)).argmin() start = find_index(istart) end = find_index(istop) print(f"Frames {istart}-{istop} ({istop-istart} frames)") def make_animation(data_array, start_frame=start, end_frame=end, vmin=None, vmax=None, delay=50): """ Function that takes an array where each frame is a 2D image array and make an animated plot that runs through the frames. Note: This can take a long time to run if you have a lot of frames. Parameters ---------- data_array : array Array of 2D images. start_frame : int The index of the initial frame to show. Default is the first frame. end_frame : int The index of the final frame to show. Default is the last frame. vmin : float Data range min for the colormap. Defaults to data minimum value. vmax : float Data range max for the colormap. Defaults to data maximum value. delay: Delay before the next frame is shown in milliseconds. Returns ------- response : `animation.FuncAnimation` """ if not vmin: vmin = np.min(data_array) if not vmax: vmax = np.max(data_array) if not end_frame: end_frame = len(data_array) - 1 # set to the end of the array num_frames = end_frame - start_frame + 1 # include the end frame def animate(i, fig, ax, binarytab, start=start): """Function used to update the animation""" ax.set_title("Epoch #" + str(i + start)) fig.suptitle(f'TIC {ticid}') im = ax.imshow(binarytab[i + start], cmap=plt.cm.YlGnBu_r, vmin=vmin, vmax=vmax) return im # Create initial plot. fig, ax = plt.subplots(figsize=(10, 10)) ax.imshow(data_array[start_frame], cmap=plt.cm.YlGnBu_r, vmin=vmin, vmax=vmax) ani = animation.FuncAnimation(fig, animate, fargs=(fig, ax, data_array, start_frame), frames=num_frames, interval=delay, repeat_delay=1000) ani.save('/Users/jshabazz/Work/TESScut_anims/' + str(ticid) + '_flareevent' + str(flare) + '.gif', writer=Writer) print('File created') plt.close() return ani make_animation(cutout_table['FLUX'], vmax=500)