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 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 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 get_fficutout(c_obj, cutoutdir=None, sector=None): # c_obj (SkyCoord): location of target star print('beginning download tesscut for {}'.format(repr(c_obj))) try: tab = Tesscut.download_cutouts(c_obj, size=20, sector=sector, path=cutoutdir) except (requests.exceptions.HTTPError, requests.exceptions.ConnectionError) as e: print('got {}, try again'.format(repr(e))) tab = Tesscut.download_cutouts(c_obj, size=20, sector=sector, path=cutoutdir)
def getTessCut(self): """ Perform tesscut. Not Done, come back. """ manifest = Tesscut.get_cutouts(self.coord, size)
def _find_sectors(self, ticid): """Helper function to read sectors from a search result.""" from astroquery.mast import Tesscut sectors = [] for s in Tesscut().get_sectors(objectname=ticid)['sector']: sectors.append(s) return sectors
def download_tess_cuts( ticid, lower_sector_limit=0, upper_sector_limit=1000, tesscut_path="/Users/rangus/projects/TESS-rotation/data/TESScut"): # Download light curves sectors, star = get_sectors(ticid, lower_sector_limit=lower_sector_limit, upper_sector_limit=upper_sector_limit) path_to_tesscut = "{0}/astrocut_{1:12}_{2:13}_{3}x{4}px".format( tesscut_path, star.coords[0], star.coords[1], 68, 68) for sector in sectors: print("sector = ", int(sector)) star = eleanor.Source(tic=ticid, sector=int(sector), tc=True) fits_only = "tess-s{0}-{1}-{2}_{3:.6f}_{4:.6f}_{5}x{6}_astrocut.fits" \ .format(str(int(sector)).zfill(4), star.camera, star.chip, star.coords[0], star.coords[1], 68, 68) full_path = os.path.join(path_to_tesscut, fits_only) if not os.path.exists(full_path): print("No cached file found. Downloading", full_path) if not os.path.exists(path_to_tesscut): os.mkdir(path_to_tesscut) print("Downloading sector", sector, "for TIC", ticid) hdulist = Tesscut.download_cutouts( objectname="TIC {}".format(ticid), sector=sector, size=68, path=path_to_tesscut) else: print("Found cached file ", full_path)
def __init__(self, ID: int, sectors: np.ndarray, search_radius: int = 10): """ Queries TIC for sources near the target and obtains a cutout of the pixels enclosing the target. Args: ID (int): TIC ID of the target. sectors (numpy array): Sectors in which the target has been observed. search_radius (int): Number of pixels from the target star to search. """ self.ID = ID self.sectors = sectors self.search_radius = search_radius self.N_pix = 2 * search_radius + 2 # query TIC for nearby stars pixel_size = 20.25 * u.arcsec df = Catalogs.query_object("TIC" + str(ID), radius=search_radius * pixel_size, catalog="TIC") new_df = df["ID", "Tmag", "ra", "dec", "mass", "rad", "Teff", "plx"] stars = new_df.to_pandas() self.stars = stars TESS_images = [] col0s, row0s = [], [] pix_coords = [] # for each sector, get FFI cutout and transform RA/Dec into # TESS pixel coordinates for j, sector in enumerate(sectors): Tmag = stars["Tmag"].values ra = stars["ra"].values dec = stars["dec"].values cutout_coord = SkyCoord(ra[0], dec[0], unit="deg") cutout_hdu = Tesscut.get_cutouts(cutout_coord, size=self.N_pix, sector=sector)[0] cutout_table = cutout_hdu[1].data hdu = cutout_hdu[2].header wcs = WCS(hdu) TESS_images.append(np.mean(cutout_table["FLUX"], axis=0)) col0 = cutout_hdu[1].header["1CRV4P"] row0 = cutout_hdu[1].header["2CRV4P"] col0s.append(col0) row0s.append(row0) pix_coord = np.zeros([len(ra), 2]) for i in range(len(ra)): RApix = np.asscalar(wcs.all_world2pix(ra[i], dec[i], 0)[0]) Decpix = np.asscalar(wcs.all_world2pix(ra[i], dec[i], 0)[1]) pix_coord[i, 0] = col0 + RApix pix_coord[i, 1] = row0 + Decpix pix_coords.append(pix_coord) self.TESS_images = TESS_images self.col0s = col0s self.row0s = row0s self.pix_coords = pix_coords return
def get_tess_cuts(coordinates, cube_side_size): """Gets the TESS cuts for a given set of coordinates, repeating on errors.""" cutouts = None while True: # This loop plus try is used to repeat if a connection error happens. try: cutouts = Tesscut.get_cutouts(coordinates, cube_side_size) break except HTTPError: print('HTTP error, trying again...') continue return cutouts
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 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 getTessCutout(coord, size_pixels, sector): """ Returns first returned for that sector. """ hdulist = Tesscut.get_cutouts(coord, size_pixels, sector=sector) if len(hdulist) < 1: raise IOError hdu = hdulist[0] return hdu[1].data, hdu[1].header, hdu[2].header
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 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 download_TESS_cutouts_coords(ra, dec, cutout_size=[11, 11]): """ This function downloads the TESS-cutouts for a target with specified ra and dec coordinates and prints the resulting filename(s) Inputs: Name unit type description ----------------------------------------------------------------------- ra deg float right ascension of target dec deg float declination of target cutout_size --- [2 x 1] list postcard cutout size """ cutout_coord = SkyCoord(ra, dec, unit="deg") manifest = Tesscut.download_cutouts(cutout_coord, cutout_size) print(manifest)
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 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 """ # Attributes only when using postcards self.all_postcards = None # Attribute for TessCut self.tc = True download_dir = self.tesscut_dir() coords = SkyCoord(self.coords[0], self.coords[1], unit=(u.deg, u.deg)) fn_exists = self.search_tesscut(download_dir, coords) if fn_exists is None: manifest = Tesscut.download_cutouts(coords, self.tesscut_size, sector=self.sector, 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 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 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 has_data(catalog, raname='ra', decname='dec', namename='Name', verbose=True, cutout=1): indices = [] for j, name in enumerate(catalog[namename]): ra, dec = catalog[j][raname, decname] coords = SkyCoord(ra, dec, unit=(u.hourangle, u.deg)) try: hdulist = Tesscut.get_cutouts( coords, cutout) # actually downloads the FITS files! eep! if len(hdulist) != 0: indices.append(j) if verbose: print('%s %.3f %.3f\n' % (name, coords.ra.deg, coords.dec.deg)) except: pass return indices
def get_multi_cutout_lst(coords, sz=(15, 15)): lst_hdu_elements = Tesscut.get_cutouts(coordinates=coords, size=sz) return (lst_hdu_elements)
def get_data(ra, dec, units="deg", size=64): c = SkyCoord(ra, dec, units=units) data_table = Tesscut.download_cutouts(c, size=size) return data_table
def data_dl(ra, dec, size): cutout_coord = SkyCoord(ra, dec, unit="deg") hdulist = Tesscut.get_cutouts(coordinates=cutout_coord, size=size) return hdulist
def raw_FFI_lc_download(target_ID, sector, plot_tpf = False, plot_lc = False, save_path = '', from_file = False): """ Downloads and returns 30min cadence lightcurves based on SAP analysis of the raw FFIs """ if from_file == True: with open('Sector_{}_target_filenames.pkl'.format(sector), 'rb') as f: target_filenames = pickle.load(f) f.close() else: target_filenames = {} ra, dec, tic = find_tic(target_ID, from_file = True) object_coord = SkyCoord(ra, dec, unit="deg") manifest = Tesscut.download_cutouts(object_coord, [11,11], 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)) if type(target_filenames[target_ID]) == str: filename = target_filenames[target_ID] else: filename = target_filenames[target_ID][0] # Load tpf tpf_30min = lightkurve.search.open(filename) # Attach target name to tpf tpf_30min.targetid = target_ID # Create a median image of the source over time median_image = np.nanmedian(tpf_30min.flux, axis=0) # Select pixels which are brighter than the 85th percentile of the median image aperture_mask = median_image > np.nanpercentile(median_image, 85) # Plot and save tpf if plot_tpf == True: tpf_30min.plot(aperture_mask = aperture_mask) #tpf_plot.savefig(save_path + '{} - Sector {} - tpf plot.png'.format(target_ID, tpf.sector)) #plt.close(tpf_plot) # Convert to lightcurve object lc_30min = tpf_30min.to_lightcurve(aperture_mask = aperture_mask) # lc_30min = lc_30min[(lc_30min.time < 1346) | (lc_30min.time > 1350)] if plot_lc == True: lc_30min.scatter() plt.title('{} - 30min FFI base lc'.format(target_ID)) plt.xlabel("Time - 2457000 (BTJD days)") plt.ylabel("Relative flux") plt.show() return lc_30min