async def get_targetpixelfile(self, mission, target, sector=None, campaign=None, quarter=None, aperture_mask="ALL"): result = None if mission == "TESS": result = search_targetpixelfile(mission=mission, target=target,sector=sector) elif mission == "Kepler": result = search_targetpixelfile(mission=mission, target=target, quarter=quarter) elif mission == "K2": result = search_targetpixelfile(mission=mission, target=target, campaign=campaign) else: raise ValueError("Unknown mission, must be TESS, Kepler, or K2") return result.download()
def FoldTarget(target, targetquarter, targetexp, targetperiod): pixelfile = search_targetpixelfile(target, quarter=targetquarter, exptime=targetexp).download(); #print("\nDownloaded") pixelfile.plot(frame=1); lc = pixelfile.to_lightcurve(aperture_mask=pixelfile.pipeline_mask); #plt.title("Scatter Plot"); lc.scatter(); lc.plot(); plt.title("Light Curve") #print("\nMask Done!") """lc = pixelfile.to_lightcurve(aperture_mask='all'); lc.plot(); print("\nAll Done!")""" flat_lc = lc.flatten(window_length=401); flat_lc.plot(); plt.title("Flat") #print("\nFlat Done!") folded_lc = flat_lc.fold(period=targetperiod); folded_lc.plot(); plt.title("Folded") #print("\nFold Done!") binned_lc = folded_lc.bin(time_bin_size=0.01); binned_lc.plot(); plt.title("Binned")
def _from_mast_K2(targetid, mode, c, flux_type="PDCSAP_FLUX", cadence="long", aperture_mask="default", download_dir=None): if mode == "TPF": tpffilelist = search_targetpixelfile(targetid, mission="K2", campaign=c, cadence=cadence) tpf = tpffilelist.download(download_dir=download_dir) if aperture_mask == "default": aperture_mask = tpf.pipeline_mask lc = tpf.to_lightcurve(aperture_mask=aperture_mask) flc = _convert_TPF_to_FLC(tpf, lc) return flc elif mode == "LC": flcfilelist = search_lightcurvefile(targetid, mission="K2", campaign=c, cadence=cadence) flcfile = flcfilelist.download(download_dir=download_dir) lc = flcfile.get_lightcurve(flux_type) flc = _convert_LC_to_FLC(lc, origin="KLC") return flc
def download_k2_tpf(star='WASP-47', **kw): ''' This function is a wrapper a "Target Pixel Files" (TPF) for Kepler/K2 data. Each TPF is basically a movie; it contains a time series of images in a tiny little area around a particular Kepler/K2 target. This has been tested only on data from the main Kepler mission and K2. Parameters ---------- star: str, int The name of the star whose light curve you want to download. This can be a name ("K2-18", "TRAPPIST-1") or an EPIC number (246199087). Returns ------- tpf: KeplerTargetPixelFile object This is a `lightkurve`-style TargetPixelFile object, which contains the attributes `tpf.time` (times in JD) and `tpf.flux` (the brightness of each pixel as a function of time), as well as lots of methods for analysis and plotting. ''' # download a KeplerLightCurveFile from the MAST archive tpf = search_targetpixelfile(star, **kw).download() return tpf
def data_K2(fitspath): targetname = fitspath[43:] targetname = targetname[:-18] print('TARGET ' + str(targetname)) campaign_no = 18 try: tpf = lk.search_targetpixelfile(str(targetname), campaign=18).download() except IOError: return 0, 0, 0, 0 lc = tpf.to_lightcurve().normalize().flatten() time = lc.time flux = lc.flux flux_count = len(flux) sumflux = sum(flux) flux_avg = sumflux/flux_count flux = [i/flux_avg for i in flux] #normalize to 0.0 flux = [i-1 for i in flux] flux = np.asarray(flux) time = np.asarray(time) #SIGMA CLIPPING flux = sigma_clip(flux, sigma=3, iters=1) flux = flux.filled(fill_value=0) return time, flux, targetname, campaign_no
def test_pld_corrector(): # download tpf data for a target k2_target = "EPIC247887989" k2_tpf = search_targetpixelfile(k2_target).download() # instantiate PLD corrector object pld = PLDCorrector(k2_tpf[:500], aperture_mask="threshold") # produce a PLD-corrected light curve with a default aperture mask corrected_lc = pld.correct() # ensure the CDPP was reduced by the corrector pld_cdpp = corrected_lc.estimate_cdpp() raw_cdpp = k2_tpf.to_lightcurve().estimate_cdpp() assert pld_cdpp < raw_cdpp # make sure the returned object is the correct type (`KeplerLightCurve`) assert isinstance(corrected_lc, KeplerLightCurve) # try detrending using a threshold mask corrected_lc = pld.correct() # reduce using fewer principle components corrected_lc = pld.correct(pca_components=20) # try PLD on a TESS observation from lightkurve import TessTargetPixelFile from ..test_targetpixelfile import TESS_SIM tess_tpf = TessTargetPixelFile(TESS_SIM) # instantiate PLD corrector object pld = PLDCorrector(tess_tpf[:500], aperture_mask="pipeline") # produce a PLD-corrected light curve with a pipeline aperture mask raw_lc = tess_tpf.to_lightcurve(aperture_mask="pipeline") corrected_lc = pld.correct(pca_components=20) # the corrected light curve should have higher precision assert corrected_lc.estimate_cdpp() < raw_lc.estimate_cdpp() # make sure the returned object is the correct type (`TessLightCurve`) assert isinstance(corrected_lc, TessLightCurve)
def _from_mast_K2(targetid, mode, c, flux_type="PDCSAP_FLUX", cadence="long", aperture_mask="default", download_dir=None): mission = "K2" if mode == "TPF": tpffilelist = search_targetpixelfile(targetid, mission=mission, campaign=c, cadence=cadence) tpf = tpffilelist.download(download_dir=download_dir) if aperture_mask == "default": aperture_mask = tpf.pipeline_mask lc = tpf.to_lightcurve(aperture_mask=aperture_mask) flc = _convert_TPF_to_FLC(tpf, lc) return flc elif mode == "LC": flcfilelist = search_lightcurve(targetid, mission=mission, campaign=c, cadence=cadence, author="K2") return _handle_missions(flcfilelist, mission, flux_type, cadence, download_dir, targetid, c)
def download_all_short_cadence_observations_for_targets_in_flare_catalog(): """Downloads and saves all the short cadence observations for the stars which appear in the flare catalog.""" flare_catalog = np.genfromtxt(catalog_path, delimiter=',', skip_header=1) kepler_input_catalog_numbers = list( map(int, [target[0] for target in flare_catalog])) observations_skipped = 0 targets_skipped = 0 for kepler_input_catalog_number in kepler_input_catalog_numbers: with warnings.catch_warnings(): warnings.filterwarnings("ignore", category=LightkurveWarning ) # Ignore warnings about empty downloads. current_target_skipped = False short_cadence_observations = search_targetpixelfile( kepler_input_catalog_number, cadence='short') for observation_index, observation in enumerate( short_cadence_observations): observation_file_name = f'{kepler_input_catalog_number}_{observation_index}.fits' try: observation.download().to_fits(os.path.join( data_directory, observation_file_name), overwrite=True) except OSError: observations_skipped += 1 if not current_target_skipped: current_target_skipped = True targets_skipped += 1 print(f'{targets_skipped} targets skipped.') print(f'{observations_skipped} observations skipped.')
def tpf_grabber(tic_id, sectors): '''Authors: Patrick Tamburo, Boston University, July 2020 Purpose: Given a target's position when it was observed with TESS, returns the column and row of the pixel that the target fell on. Inputs: tic_id (str): The target's TIC ID (e.g., 'TIC 326109505') sector (array of ints): Sectors during which the target was observed Outputs: tpfs (list): List of target pixel files. TODO: ''' tpfs = [] for i in range(len(sectors)): tpf = lk.search_targetpixelfile(tic_id, sector=sectors[i]).download() if tpf is not None: tpfs.append(tpf) else: #Sometimes, tpf files don't exist for certain sectors, even though the target may have been observed in them...don't know why. #But if that is the case, just skip that sector. print('ERROR: no data found for {} in sector {:2d}, skipping.'. format(tic_id, sectors[i])) continue return tpfs
def find_campaigns(s): '''Find campaigns and EPIC IDs for a given RA and Dec pair using lightkurve query function. Parameters: ------------ s : str "RA Dec" in deg Return: ------- list, int : list of campaigns, EPIC ID ''' res = search_targetpixelfile(s, radius=2) pdf = res.table.to_pandas() if pdf.shape[0] > 0: pdf['Campaign'] = pdf.obs_id.str[-5:-3].astype(int) pdf['EPIC'] = pdf.target_name.str[4:] try: assert (pdf.EPIC.values == pdf.EPIC.iloc[0]).all() except: print("Something went wrong here\n") print(pdf.EPIC.values) return [np.nan], np.nan return pdf.Campaign.tolist(), pdf.EPIC.iloc[0] else: return [np.nan], np.nan
def xmkpy3_plot_add_compass_rose_v5(): import matplotlib.pyplot as plt import lightkurve as lk # obj = 3 # USER CUSTOMIZE # tpf = None if (obj == 1): north_arm_arcsec = 8 tpf = lk.search_targetpixelfile( target='Kepler-138b', mission='Kepler', quarter=10)\ .download(quality_bitmask=0) # ^--- Exoplanet Kelper-138b is "KIC 7603200" elif (obj == 2): north_arm_arcsec = 42 search_results = lk.search_tesscut(target='CD Ind', sector=1) tpf = search_results[0].download(cutout_size=(11, 11), quality_bitmask=0) elif (obj == 3): north_arm_arcsec = 42 tpf = lk.search_targetpixelfile(target='CD Ind', mission='TESS', sector=1).download(quality_bitmask=0) else: print('***ERROR*** BAD OBJECT NUMBER:', obj) # pass:if assert (tpf is not None) # # Plot the 2nd frame of the TPF ax = tpf.plot(frame=1, cmap='gray_r') # # add a compass rose using the WCS from the TargetPixelFile mkpy3_plot_add_compass_rose_v5(ax=ax, wcs=tpf.wcs, north_arm_arcsec=north_arm_arcsec, verbose=True) # print(tpf.path, '\n^--- tpf.path\n') print(tpf.ra, '=tpf.ra') print(tpf.dec, '=tpf.dec') print(obj, '=obj') # plot_file = 'mkpy3_plot1.png' plt.savefig(plot_file, bbox_inches="tight") plt.close() print('\n', plot_file, ' <--- new PNG file written')
def makeLCQ(ID, q): """ Generates a Kepler lightcurve file for a given target ID and quarter. 1 <= q <= 17 """ tpf = lk.search_targetpixelfile(ID, quarter=q).download() lightcurve = tpf.to_lightcurve() lightcurve = remove_anomalies(lightcurve) return lightcurve
def FlatTarget(target, targetquarter, targetexp): pixelfile = search_targetpixelfile(target, quarter=targetquarter, exptime=targetexp).download(); lc = pixelfile.to_lightcurve(aperture_mask=pixelfile.pipeline_mask); lc.scatter(); flat_lc = lc.flatten(window_length=401); flat_lc.plot(); plt.title("Flat")
def test_FPs(): """Produce some figures that show centroid offsets""" names = [ "KIC 5391911", "KIC 5866724", "EPIC 220256496", "EPIC 210957318", "TIC 293435336", "TIC 13023738", ] kwargs = [ {"quarter": 3}, {"quarter": 3}, {"campaign": 8}, {"campaign": 4}, {}, {"sector": 2}, ] periods = [0.782068488, 2.154911236, 0.669558, 4.098503000, 1.809886, 8.0635] t0s = [ 131.8940201, 133.498613, 2457393.81364 - 2454833, 2457063.80710000 - 2454833, 2456107.85507 - 2457000, 2459104.87232 - 2457000, ] durs = np.asarray([1.239, 3.1341, 1, 2.3208, 3.694, 3.396]) / 24 depths = [ 0.01157 * 0.01, 0.00850 * 0.01, 0.015450 ** 2, 1.603 * 0.01, 1.189 * 0.01, 5180 * 1e-6, ] for name, period, t0, dur, kwarg, depth in zip( names, periods, t0s, durs, kwargs, depths ): tpf = lk.search_targetpixelfile(name, **kwarg).download() r = centroid_test( tpf, period, t0, dur, aperture_mask="pipeline", plot=True, transit_depths=depth, ) r["figs"][0].savefig( f"{testdir}/docs/{name.replace(' ','').lower()}.png", dpi=200, bbox_inches="tight", )
def get_tpf(self): """ FIXME: refactor to tpf.py? """ res = lk.search_targetpixelfile(f"EPIC {self.epicid}", campaign=self.campaign, mission="K2") tpf = res.download() self.tpf = tpf return tpf
def get_count_stars_in_flare_catalog_with_short_cadence_data(): """Returns the number of targets in the flare catalog with short cadence data.""" flare_catalog = np.genfromtxt(catalog_path, delimiter=',', skip_header=1) kepler_input_catalog_numbers = [target[0] for target in flare_catalog] count_with_short_cadence = 0 for kepler_input_catalog_number in kepler_input_catalog_numbers: short_cadence_observations = search_targetpixelfile( kepler_input_catalog_number, cadence='short') if len(short_cadence_observations) is not 0: count_with_short_cadence += 1 return count_with_short_cadence
def test_cyclic_conversion(self): tpfs = lightkurve.search_targetpixelfile(target="TIC 251848941", cadence=120, author="SPOC") \ .download_all(cutout_size=CUTOUT_SIZE) for tpf in tpfs: self.assertTrue((tpf.pipeline_mask == ApertureExtractor.from_pixels_to_boolean_mask( ApertureExtractor.from_boolean_mask( tpf.pipeline_mask, tpf.column, tpf.row), tpf.column, tpf.row, len(tpf.pipeline_mask[1]), len(tpf.pipeline_mask[0]))).all())
def test_pld_aperture_mask(): """Test for #523: does PLDCorrector.correct() accept separate apertures for PLD pixels?""" tpf = search_targetpixelfile("K2-205")[0].download() # use only the pixels in the pipeline mask lc_pipeline = tpf.to_corrector("pld").correct(pld_aperture_mask="pipeline", restore_trend=False) # use all pixels in the tpf lc_all = tpf.to_corrector("pld").correct(pld_aperture_mask="all", restore_trend=False) # does this improve the correction? assert lc_all.estimate_cdpp() < lc_pipeline.estimate_cdpp()
def get_tpf(self, campaign=None): """ FIXME: refactor to tpf.py? """ if campaign is None: campaign = self.campaign assert campaign in self.all_campaigns res = lk.search_targetpixelfile(f"EPIC {self.epicid}", campaign=campaign, mission="K2") tpf = res.download() self.tpf = tpf return tpf
def plot_EPIC_ID(epic, sigma_value = 5): search = lk.search_targetpixelfile(epic, mission='K2') print(search) pixelfile = search.download(quality_bitmask='hard' ) #gets the data about the EPIC ID print('*********Quarter :' ,pixelfile.quarter, 'Mission : ',pixelfile.mission ) #pixelfile.interact(notebook_url='localhost:8893') fname = str(epic)+'.fits' lc = pixelfile.to_lightcurve(aperture_mask='all') #gets the light curve information lc = outlier_removal(lc, sigma_value) #calls the function that removes outliers lc.to_fits(path=fname, overwrite=True) # files.download(fname) return lc #returns the light curve information
def xmkpy3_finder_chart_survey_fits_image_get_v1(): import lightkurve as lk lk.log.setLevel('INFO') import matplotlib.pyplot as plt import astropy.units as u from astropy.visualization import ImageNormalize, PercentileInterval, SqrtStretch import os import ntpath # Exoplanet Kelper-138b is "KIC 7603200": tpf = lk.search_targetpixelfile(target='kepler-138b', mission='kepler', cadence='long', quarter=10).download(quality_bitmask=0) print('TPF filename:', ntpath.basename(tpf.path)) print('TPF dirname: ', os.path.dirname(tpf.path)) target = 'Kepler-138b' ra_deg = tpf.ra dec_deg = tpf.dec # get survey image data width_height_arcmin = 3.00 survey = '2MASS-J' survey_hdu, survey_hdr, survey_data, survey_wcs, survey_cframe = \ mkpy3_finder_chart_survey_fits_image_get_v1(ra_deg, dec_deg, radius_arcmin=width_height_arcmin, survey=survey, verbose=True) # create a matplotlib figure object fig = plt.figure(figsize=(12, 12)) # create a matplotlib axis object with right ascension and declination axes ax = plt.subplot(projection=survey_wcs) norm = ImageNormalize(survey_data, interval=PercentileInterval(99.0), stretch=SqrtStretch()) ax.imshow(survey_data, origin='lower', norm=norm, cmap='gray_r') ax.set_xlabel('Right Ascension (J2000)') ax.set_ylabel('Declination (J2000)') ax.set_title('') plt.suptitle(target) # put a yellow circle at the target position ax.scatter(ra_deg * u.deg, dec_deg * u.deg, transform=ax.get_transform(survey_cframe), s=600, edgecolor='yellow', facecolor='None', lw=3, zorder=100) pname = 'mkpy3_plot.png' if (pname != ''): plt.savefig(pname, bbox_inches="tight") print(pname, ' <--- plot filename has been written! :-)\n')
def tpf_sap(tic): #search targetpixelfiles for given TIC ID search_res = lk.search_targetpixelfile('TIC ' + str(tic)) #initialize SPOC found,first found spoc_found = False spoc_first = False lc_holder = [] for i in range(len(search_res)): #select search result object search_i = search_res[i] #skip if not SPOC, 120 s exposure if (search_i.author.data[0] == 'SPOC') & (search_i.exptime.data[0] == 120): print("Found SPOC " + str(search_i.mission[0]) + " data for TIC " + str(tic) + "!") spoc_found = True if (spoc_first == False) & (spoc_first is not None): spoc_first = True else: continue tpf = search_res[i].download() if spoc_first == True: # get apertures, median image, and WCS data for contamination plot pipeline_mask = tpf.pipeline_mask threshold_mask = tpf.create_threshold_mask( threshold=10, reference_pixel='center') median_im = np.nanmedian(tpf.hdu[1].data['FLUX'], axis=0) im_header = tpf.hdu[2].header #used for later WCS projection #reset spoc_first to None spoc_first = None # get lightcurve with pipeline mask lc = tpf.to_lightcurve(aperture_mask=tpf.pipeline_mask) lc = lc.remove_outliers(sigma=5.0) lc['sector'] = np.repeat( a=lc.sector, repeats=len(lc)) #add sector label for my plotting functions lc_holder.append( lc.to_pandas().reset_index(drop=False)) #store in lc_holder if spoc_found == False: print("No SPOC data found for TIC " + str(tic) + ".") spoc_lc = pd.DataFrame() pipeline_mask = np.array([]) else: spoc_lc = pd.concat(lc_holder) #combine lc into 1 pandas dataframe return (spoc_lc, pipeline_mask, threshold_mask, median_im, im_header)
def make_lc(tic=None,epic=None,hostname=None,mission='tess',verbose=True): """Return a LightCurve object from TESS or K2 planet. Keyword arguments: Need one of: tic -- TIC ID # of the host star epic -- EPIC ID # of the host star hostname -- host star name mission -- which mission to get the data from (default 'tess') verbose -- whether to print status updates (default False) """ if tic == None: if epic: tic = get_tic_from_epic(epic) elif hostname: tic = get_tic_from_name(hostname) if verbose: print('Fetching TPF...') if mission.lower() == 'tess': tpf = lk.search_targetpixelfile(tic,mission='tess').download() elif mission.lower() == 'k2': epic = get_epic_from_tic(tic) tpf = lk.search_targetpixelfile(epic,mission='k2').download() else: raise ValueError('Mission must be \'tess\' or \'k2\'.') if verbose: print('Detrending...') if mission.lower() == 'tess': corrector = lk.PLDCorrector(tpf) lc = corrector.correct() elif mission.lower() == 'k2': lc = tpf.to_lightcurve(aperture_mask=tpf.pipeline_mask) lc.remove_outliers(sigma=6).flatten() if verbose: print('Success') return lc
def extract_sectors(object_info, cache_dir): mission, mission_prefix, id_int = LcBuilder().parse_object_info( object_info.mission_id()) object_sectors = None if mission == "Kepler": lcf_search_results = lightkurve.search_targetpixelfile( object_info.mission_id(), mission=object_info.mission_id(), cadence="long") object_sectors = lcf_search_results.download_all( download_dir=cache_dir).quarter elif mission == "K2": lcf_search_results = lightkurve.search_targetpixelfile( object_info.mission_id(), mission=object_info.mission_id(), cadence="long") object_sectors = lcf_search_results.download_all( download_dir=cache_dir).campaign elif mission == "TESS": lcf_search_results = lightkurve.search_tesscut( object_info.mission_id()) object_sectors = lcf_search_results.download_all( download_dir=cache_dir).sector return object_sectors
def test_tess_pld_corrector(): tpf = search_targetpixelfile("TOI 700")[0].download() pld = PLDCorrector(tpf) # Is the correct filetype returned? clc = pld.correct() assert isinstance(clc, TessLightCurve) # Do the diagnostic plots run? pld.diagnose() plt.close() pld.diagnose_masks() plt.close() # Does sparse correction work? pld.correct(sparse=True) # Did the correction with default values help? raw_lc = tpf.to_lightcurve(aperture_mask="threshold") assert clc.estimate_cdpp() < raw_lc.estimate_cdpp()
def ProcessTarget(target, targetquarter, targetexp): pixelfile = search_targetpixelfile(target, quarter=targetquarter, exptime=targetexp).download(); print("\nDownloaded") pixelfile.plot(frame=1); lc = pixelfile.to_lightcurve(aperture_mask=pixelfile.pipeline_mask); lc.plot(); print("\nMask Done!") """lc = pixelfile.to_lightcurve(aperture_mask='all'); lc.plot(); print("\nAll Done!")""" flat_lc = lc.flatten(window_length=401); flat_lc.plot(); print("\nFlat Done!")
def find_planet_iter_per(star, quarter): tpf = lk.search_targetpixelfile(star, quarter=quarter).download() #tpf.plot(frame=100, scale='log', show_colorbar=True) #plt.show() lc = tpf.to_lightcurve(aperture_mask=tpf.pipeline_mask) #lc.plot() #plt.show(); flat, trend = lc.flatten(window_length=301, return_trend=True) #ax = lc.errorbar(label=args.star) # plot() returns a matplotlib axes ... #trend.plot(ax=ax, color='red', lw=2, label='Trend'); # which we can pass to the next plot() to use the same axes #plt.show(); #flat.errorbar(label=args.star); #plt.show(); best_planet_score = None best_folded = None best_result = None best_interpolations = None for best_fit_period_start in np.arange(0.5, 30.1, 0.5): periodogram = flat.to_periodogram(method="bls", period=np.arange(best_fit_period_start, best_fit_period_start + 0.5, 0.0001)) best_fit_period = periodogram.period_at_max_power transit_time_at_max_power = periodogram.transit_time_at_max_power folded = flat.fold(period=best_fit_period, t0=transit_time_at_max_power) interpolations = process_folded_lc(folded) if is_there_a_planet(*interpolations): score = planet_score(*interpolations) # print(best_fit_period, transit_time_at_max_power, interpolations, score) if best_planet_score is None or score < best_planet_score: best_planet_score = score best_folded = folded best_result = (best_fit_period, transit_time_at_max_power) best_interpolations = interpolations # print(interpolations) #best_folded.bin().scatter() # .errorbar(); #plt.show(); #best_folded.plot_river() #plt.show(); if best_result is not None: print(star, best_result[0], best_result[1]) else: print(star, "No planet found")
def test_from_boolean_mask(self): tpfs = lightkurve.search_targetpixelfile(target="TIC 251848941", cadence=120, author="SPOC")\ .download_all() apertures = {} for tpf in tpfs: apertures[tpf.sector] = ApertureExtractor.from_boolean_mask( tpf.pipeline_mask, tpf.column, tpf.row) self.assertEquals(19, len(apertures[2])) self.assertTrue(any(([649, 171] == x).all() for x in apertures[2])) self.assertTrue(any(([649, 172] == x).all() for x in apertures[2])) self.assertTrue(any(([650, 170] == x).all() for x in apertures[2])) self.assertTrue(any(([650, 171] == x).all() for x in apertures[2])) self.assertTrue(any(([650, 172] == x).all() for x in apertures[2])) self.assertTrue(any(([650, 173] == x).all() for x in apertures[2])) self.assertTrue(any(([650, 174] == x).all() for x in apertures[2])) self.assertTrue(any(([651, 170] == x).all() for x in apertures[2])) self.assertTrue(any(([651, 171] == x).all() for x in apertures[2])) self.assertTrue(any(([651, 172] == x).all() for x in apertures[2])) self.assertTrue(any(([651, 173] == x).all() for x in apertures[2])) self.assertTrue(any(([651, 174] == x).all() for x in apertures[2])) self.assertTrue(any(([652, 170] == x).all() for x in apertures[2])) self.assertTrue(any(([652, 171] == x).all() for x in apertures[2])) self.assertTrue(any(([652, 172] == x).all() for x in apertures[2])) self.assertTrue(any(([652, 173] == x).all() for x in apertures[2])) self.assertTrue(any(([653, 171] == x).all() for x in apertures[2])) self.assertTrue(any(([653, 172] == x).all() for x in apertures[2])) self.assertTrue(any(([653, 173] == x).all() for x in apertures[2])) self.assertEquals(15, len(apertures[29])) self.assertTrue(any(([1133, 142] == x).all() for x in apertures[29])) self.assertTrue(any(([1133, 143] == x).all() for x in apertures[29])) self.assertTrue(any(([1133, 144] == x).all() for x in apertures[29])) self.assertTrue(any(([1133, 145] == x).all() for x in apertures[29])) self.assertTrue(any(([1134, 141] == x).all() for x in apertures[29])) self.assertTrue(any(([1134, 142] == x).all() for x in apertures[29])) self.assertTrue(any(([1134, 143] == x).all() for x in apertures[29])) self.assertTrue(any(([1134, 144] == x).all() for x in apertures[29])) self.assertTrue(any(([1134, 145] == x).all() for x in apertures[29])) self.assertTrue(any(([1135, 142] == x).all() for x in apertures[29])) self.assertTrue(any(([1135, 143] == x).all() for x in apertures[29])) self.assertTrue(any(([1135, 144] == x).all() for x in apertures[29])) self.assertTrue(any(([1135, 145] == x).all() for x in apertures[29])) self.assertTrue(any(([1136, 143] == x).all() for x in apertures[29])) self.assertTrue(any(([1136, 144] == x).all() for x in apertures[29]))
def test_tpf(): """ """ t = Tpf( ticid=TICID, sector=SECTOR, quality_bitmask="default", apply_data_quality_mask=False, ) tpf1 = t.get_tpf() assert tpf1.targetid == TICID assert tpf1.sector == SECTOR res = lk.search_targetpixelfile(f"TIC {t.ticid}", mission="TESS", cadence="short", sector=SECTOR) tpf2 = res.download() assert tpf1.targetid == tpf2.targetid assert tpf1.sector == tpf2.sector assert tpf1.quality_bitmask == tpf2.quality_bitmask
def plot_EPIC_ID(epic, sigma_value=5): #gets the pixelfile data pixelfile = lk.search_targetpixelfile(epic).download( quality_bitmask="hardest") #gets the pixel data lc = pixelfile.to_lightcurve(aperture_mask='all') #masks the noisy data lc = outlier_removal(lc, sigma_value) #removes remaining outliers lc = outlier_removal(lc, sigma_value) #removes remaining outliers #creates the file path and exports the fits file path = pathlib.Path( "EPIC ID Analysis" + str(epic) ) #creates the path for the EPIC ID; the name of the folder is the EPIC ID if path.exists() == False: os.mkdir("EPIC ID Analysis\\" + str(epic)) file = "EPIC ID Analysis\\" + str(epic) + "\\" + str( epic ) + "_Info.fits" #path for the fits file; e.g. EPIC ID Analysis/205008727/205008727_Info.fits print("Fits directory: ", file) lc.to_fits(path=file) #exports the fits file lc.plot() #plots the graph return lc #returns the lightcurve data