def fov_shape(self): """Choosing the FoV shape: box (1) or circle (2).""" valid_fov_shape = False while not valid_fov_shape: try: print ('--> FoV shape: type (1) for a box and (2) for a circle') shape = input( ' : ' ) # loading footprint template from Git--> box or circle if shape==1: url_id = "https://raw.githubusercontent.com/ggreco77/GWsky/master/footprint_box" template_fov_footprint = download_file(url_id, cache=True, timeout=300) self._fov_box() self._make_fov_footprint(template_fov_footprint) elif shape==2: url_id = "https://raw.githubusercontent.com/ggreco77/GWsky/master/footprint_circle" template_fov_footprint = download_file(url_id, cache=True, timeout=300) self._fov_circle() self._make_fov_footprint(template_fov_footprint) else: continue except SyntaxError as io_error: print (io_error) except NameError as value_error: print (value_error) else: valid_fov_shape = True
def test_download_cache(): from astropy.utils.data import download_file, clear_download_cache download_dir = _get_download_cache_locs()[0] # Download the test URL and make sure it exists, then clear just that # URL and make sure it got deleted. fnout = download_file(TESTURL, cache=True) assert os.path.isdir(download_dir) assert os.path.isfile(fnout) clear_download_cache(TESTURL) assert not os.path.exists(fnout) # Test issues raised in #4427 with clear_download_cache() without a URL, # followed by subsequent download. fnout = download_file(TESTURL, cache=True) assert os.path.isfile(fnout) clear_download_cache() assert not os.path.exists(fnout) assert not os.path.exists(download_dir) fnout = download_file(TESTURL, cache=True) assert os.path.isfile(fnout) # Clearing download cache succeeds even if the URL does not exist. clear_download_cache('http://this_was_never_downloaded_before.com') # Make sure lockdir was released lockdir = os.path.join(download_dir, 'lock') assert not os.path.isdir(lockdir), 'Cache dir lock was not released!'
def test_is_url_in_cache(): from astropy.utils.data import download_file, is_url_in_cache assert not is_url_in_cache('http://astropy.org/nonexistentfile') download_file(TESTURL, cache=True, show_progress=False) assert is_url_in_cache(TESTURL)
def setup_module(module): try: db_path = download_file("http://github.com/BDNYC/BDNYCdb/raw/master/bdnyc_database.db") except: db_path = download_file("http://github.com/BDNYC/BDNYCdb/raw/master/BDNYCv1.0.db") module.bdnyc_db = astrodb.Database(db_path) astrodb.create_database(filename) module.empty_db = astrodb.Database(filename)
def test_invalid_location_download_noconnect(): """ checks that download_file gives an OSError if the socket is blocked """ from astropy.utils.data import download_file # This should invoke socket's monkeypatched failure with pytest.raises(OSError): download_file('http://astropy.org/nonexistentfile')
def test_invalid_location_download(): """ checks that download_file gives a URLError and not an AttributeError, as its code pathway involves some fiddling with the exception. """ from astropy.utils.data import download_file with pytest.raises(urllib.error.URLError): download_file('http://www.astropy.org/nonexistentfile')
def get_path(filename, location='local', cache=True, show_progress=False): """ Get path (location on your disk) for a given file. Parameters ---------- filename : str File name in the local or remote data folder. location : {'local', 'remote', 'photutils-datasets'} File location. ``'local'`` means bundled with ``photutils``. ``'remote'`` means the astropy data server (or the photutils-datasets repo as a backup) or the Astropy cache on your machine. ``'photutils-datasets'`` means the photutils-datasets repo or the Astropy cache on your machine. cache : bool, optional Whether to cache the contents of remote URLs. Default is `True`. show_progress : bool, optional Whether to display a progress bar during the download (default is `False`). Returns ------- path : str Path (location on your disk) of the file. Examples -------- >>> from astropy.io import fits >>> from photutils import datasets >>> hdulist = fits.open(datasets.get_path('fermi_counts.fits.gz')) """ datasets_url = ('https://github.com/astropy/photutils-datasets/raw/' 'master/data/{0}'.format(filename)) if location == 'local': path = get_pkg_data_filename('data/' + filename) elif location == 'remote': # pragma: no cover try: url = 'https://data.astropy.org/photometry/{0}'.format(filename) path = download_file(url, cache=cache, show_progress=show_progress) except (URLError, HTTPError): # timeout or not found path = download_file(datasets_url, cache=cache, show_progress=show_progress) elif location == 'photutils-datasets': # pragma: no cover path = download_file(datasets_url, cache=cache, show_progress=show_progress) else: raise ValueError('Invalid location: {0}'.format(location)) return path
def download_radex(redownload=True, url='http://www.sron.rug.nl/~vdtak/radex/radex_public.tar.gz'): filename = 'radex_public.tar.gz' if os.path.isfile(filename) and not redownload: return filename print("Downloading RADEX") try: filename = download_file(url, cache=True) except: import requests r = requests.get(url, #data={'filename':filename}, stream=True, verify=False) with open(filename,'wb') as f: for chunk in r.iter_content(1024): f.write(chunk) print("Download succeeded, or at least didn't obviously fail.") return filename
def get_path(filename, location='local'): """Get path (location on your disk) for a given file. Parameters ---------- filename : str File name in the local or remote data folder location : {'local', 'remote'} File location. ``'local'`` means bundled with ``photutils``. ``'remote'`` means a server or the Astropy cache on your machine. Returns ------- path : str Path (location on your disk) of the file. Examples -------- >>> from astropy.io import fits >>> from photutils import datasets >>> hdu_list = fits.open(datasets.get_path('fermi_counts.fits.gz')) """ if location == 'local': path = get_pkg_data_filename('data/' + filename) elif location == 'remote': # pragma: no cover url = 'https://github.com/astropy/photutils-datasets/blob/master/data/{0}?raw=true'.format(filename) path = download_file(url, cache=True) else: raise ValueError('Invalid location: {0}'.format(location)) return path
def get_path(filename, location='local'): """Get path (location on your disk) for a given file. Parameters ---------- filename : str File name in the local or remote data folder location : {'local', 'remote'} File location. ``'local'`` means bundled with ``gammapy``. ``'remote'`` means in the ``gammapy-extra`` repo in the ``datasets`` folder. Returns ------- path : str Path (location on your disk) of the file. Examples -------- >>> from gammapy import datasets >>> datasets.get_path('fermi/fermi_counts.fits.gz') '/Users/deil/code/gammapy/gammapy/datasets/data/fermi/fermi_counts.fits.gz' >>> datasets.get_path('vela_region/counts_vela.fits', location='remote') '/Users/deil/.astropy/cache/download/ce2456b0c9d1476bfd342eb4148144dd' """ if location == 'local': path = get_pkg_data_filename('data/' + filename) elif location == 'remote': url = ('https://github.com/gammapy/gammapy-extra/blob/master/datasets/' '{0}?raw=true'.format(filename)) path = download_file(url, cache=True) else: raise ValueError('Invalid location: {0}'.format(location)) return path
def _get_IERS_A_table(warn_update=14*u.day): """ Grab the locally cached copy of the IERS Bulletin A table. Check to see if it's up to date, and warn the user if it is not. This will fail and raise OSError if the file is not in the cache. """ if IERS_A_in_cache(): path = download_file(iers.IERS_A_URL, cache=True, show_progress=True) table = iers.IERS_A.open(path) # Use polar motion flag to identify last observation before predictions index_of_last_observation = ''.join(table['PolPMFlag_A']).index('IP') time_of_last_observation = Time(table['MJD'][index_of_last_observation], format='mjd') time_since_last_update = Time.now() - time_of_last_observation # If the IERS bulletin is more than `warn_update` days old, warn user if warn_update < time_since_last_update: warnmsg = ("Your version of the IERS Bulletin A is {:.1f} days " "old. ".format(time_since_last_update.to(u.day).value) + IERS_A_WARNING) warnings.warn(warnmsg, OldEarthOrientationDataWarning) return table else: raise OSError("No IERS A table has been downloaded.")
def test_subimage_integ_header(): # getting a dummy .fits file if not os.path.exists('foo.fits'): from astropy.utils.data import download_file tmp_path = download_file('https://db.tt/oleS9xD6') try: os.rename(tmp_path, 'foo.fits') except OSError: # os.rename doesn't like cross-device links import shutil shutil.move(tmp_path, 'foo.fits') cube = fits.getdata('foo.fits') header = fits.getheader('foo.fits') xcen, ycen = 4.5, 4.5 xwidth, ywidth = 2.5, 2.5 # saving results from subimage_integ: cutData, cutHead = cubes.subimage_integ(cube, xcen, xwidth, ycen, ywidth, vrange=(0,9), zunits='pixels', units='pixels', header=header) assert cutHead['CRPIX1'] == 7.0 assert cutHead['CRPIX2'] == -2.0 w1 = wcs.WCS(header) w2 = wcs.WCS(cutHead) # pixel 2,2 in the original image should be pixel 0,0 in the new one x1,y1,z1 = w1.wcs_pix2world(2,2,0,0) x2,y2 = w2.wcs_pix2world(0,0,0) np.testing.assert_almost_equal(x1,x2) np.testing.assert_almost_equal(y1,y2)
def strain(self, ifo, duration=32, sample_rate=4096): """ Return strain around the event Currently this will return the strain around the event in the smallest format available. Selection of other data is not yet available. Parameters ---------- ifo: str The name of the observatory you want strain for. Ex. H1, L1, V1 Returns ------- strain: pycbc.types.TimeSeries Strain around the event. """ from astropy.utils.data import download_file from pycbc.frame import read_frame # Information is currently wrong on GWOSC! # channels = self.data['files']['FrameChannels'] # for channel in channels: # if ifo in channel: # break length = "{}sec".format(duration) if sample_rate == 4096: sampling = "4KHz" elif sample_rate == 16384: sampling = "16KHz" channel = "{}:GWOSC-{}_R1_STRAIN".format(ifo, sampling.upper()) url = self.data['files'][ifo][length][sampling]['GWF'] filename = download_file(url, cache=True) return read_frame(str(filename), str(channel))
def _get_kernel(value): """ Try importing jplephem, download/retrieve from cache the Satellite Planet Kernel corresponding to the given ephemeris. """ if value is None or value.lower() == 'builtin': return None if value.lower() == 'jpl': value = DEFAULT_JPL_EPHEMERIS if value.lower() in ('de430', 'de432s'): value = ('http://naif.jpl.nasa.gov/pub/naif/generic_kernels' '/spk/planets/{:s}.bsp'.format(value.lower())) else: try: urlparse(value) except Exception: raise ValueError('{} was not one of the standard strings and ' 'could not be parsed as a URL'.format(value)) try: from jplephem.spk import SPK except ImportError: raise ImportError("Solar system JPL ephemeris calculations require " "the jplephem package " "(https://pypi.python.org/pypi/jplephem)") return SPK.open(download_file(value, cache=True))
def get_test_filename(filename, cache=True, timeout=30): '''Get a test filename from the package directory ''' # this stopped working when we went to testing files from the web #url = os.path.join(ROOT_URL, filename) url = "{}/{}".format(ROOT_URL, filename) return download_file(url, cache=cache, timeout=timeout)
def get_lsm(field_of_view): catalog_file = download_file( 'http://www.astrop.physics.usyd.edu.au/sumsscat/sumsscat.Mar-11-2008.gz', cache=True) full_cat = sumss_file_to_dataframe(catalog_file) lsm_cat = lsm_extract(field_of_view, full_cat) return lsm_cat
def download_sample_data(progress=True): """ Download the sample data. Parameters ---------- progress: bool Show a progress bar during download Returns ------- None """ number_of_files_fetched = 0 print("Downloading sample files to " + sampledata_dir) for base_url in _base_urls: for file_name in _files.itervalues(): full_file_name = file_name[0] + file_name[1] if url_exists(os.path.join(base_url, full_file_name)): f = download_file(os.path.join(base_url, full_file_name)) real_name, ext = os.path.splitext(full_file_name) if file_name[1] == '.zip': print("Unpacking: %s" % real_name) with ZipFile(f, 'r') as zip_file: zip_file.extract(real_name, sampledata_dir) remove(f) else: # move files to the data directory move(f, os.path.join(sampledata_dir, file_name[0])) # increment the number of files obtained to check later number_of_files_fetched += 1 if number_of_files_fetched < len(_files.keys()): raise URLError("Could not download all samples files. Problem with accessing sample data servers.")
def load_salt2model(remote_url, topdir, name=None, version=None): fn = download_file(remote_url, cache=True, timeout=REMOTE_TIMEOUT()) t = tarfile.open(fn, 'r:gz') errscalefn = join(topdir, 'salt2_spec_dispersion_scaling.dat') if errscalefn in t.getnames(): errscalefile = t.extractfile(errscalefn) else: errscalefile = None model = SALT2Source( m0file=t.extractfile(join(topdir,'salt2_template_0.dat')), m1file=t.extractfile(join(topdir,'salt2_template_1.dat')), clfile=t.extractfile(join(topdir,'salt2_color_correction.dat')), cdfile=t.extractfile(join(topdir,'salt2_color_dispersion.dat')), errscalefile=t.extractfile( join(topdir,'salt2_lc_dispersion_scaling.dat')), lcrv00file=t.extractfile( join(topdir,'salt2_lc_relative_variance_0.dat')), lcrv11file=t.extractfile( join(topdir,'salt2_lc_relative_variance_1.dat')), lcrv01file=t.extractfile( join(topdir,'salt2_lc_relative_covariance_01.dat')), name=name, version=version) t.close() #set_bandfluxerror_sn1a(model) return model
def setup_class(self): # make a fake header to test the helper functions which access the header w = WCS(naxis=2) w.wcs.crpix = [crpix_val, crpix_val] w.wcs.cdelt = np.array([-cdelt_val, cdelt_val]) w.wcs.crval = [cr1val_val, cr2val_val] w.wcs.ctype = [b"RA---TAN", b"DEC--TAN"] w.wcs.crota = [0, crota2_val] self.header = w.to_header() # make a temporary directory for the input and output self.tmpdir = tempfile.mkdtemp() # get the test data and copy it to the temp directory if os.path.exists('../data/testimgs'): # copy from ../data/testimgs if that exists shutil.copytree('../data/testimgs',self.tmpdir+'/imagecubetest') else: # download and symlink to temp directory: NOT WORKING os.makedirs(self.tmpdir+'/imagecubetest/') for fname in test_data_files: tmpname = download_file(test_data_loc+fname) linked_name = self.tmpdir+'/imagecubetest/'+fname shutil.copy2(tmpname, linked_name)
def example_dataset_rdi(): """ Download example FITS cube from github + prepare HCIDataset object. Returns ------- dataset : HCIDataset Notes ----- Astropy's ``download_file`` uses caching, so the file is downloaded at most once per test run. """ print("downloading data...") url_prefix = "https://github.com/carlgogo/VIP_extras/raw/master/datasets" f1 = download_file("{}/naco_betapic_cube.fits".format(url_prefix), cache=True) f2 = download_file("{}/naco_betapic_psf.fits".format(url_prefix), cache=True) f3 = download_file("{}/naco_betapic_pa.fits".format(url_prefix), cache=True) # load fits cube = vip.fits.open_fits(f1) angles = vip.fits.open_fits(f3).flatten() # shape (61,1) -> (61,) psf = vip.fits.open_fits(f2) # creating a flux screen scr = vip.var.create_synth_psf('moff', (101, 101), fwhm=50) scrcu = np.array([scr * i for i in np.linspace(1e3, 2e3, num=31)]) # upscaling (1.2) and taking half of the frames, reversing order cube_upsc = cube_px_resampling(cube[::-1], 1.2, verbose=False)[::2] # cropping and adding the flux screen cube_ref = cube_crop_frames(cube_upsc, 101, verbose=False) + scrcu # create dataset object dataset = vip.Dataset(cube, angles=angles, psf=psf, cuberef=cube_ref, px_scale=vip.conf.VLT_NACO['plsc']) dataset.normalize_psf(size=20, force_odd=False) # overwrite PSF for easy access dataset.psf = dataset.psfn return dataset
def _initialise_ephemeris(self, earth_ephem, sun_ephem, time_corr): """ Initialise the solar system ephemeris. """ if earth_ephem is not None: earthfile = earth_ephem else: earthfile = self.__earthstr.format(self.ephem) if sun_ephem is not None: sunfile = sun_ephem else: sunfile = self.__sunstr.format(self.ephem) if time_corr is not None: timefile = time_corr else: timefile = self.__timecorrstr.format(self.__units_map[self.units]) try: edat = lalpulsar.InitBarycenter(earthfile, sunfile) except RuntimeError: try: # try downloading the ephemeris files from astropy.utils.data import download_file efile = download_file(DOWNLOAD_URL.format(earthfile), cache=True) sfile = download_file(DOWNLOAD_URL.format(sunfile), cache=True) edat = lalpulsar.InitBarycenter(efile, sfile) except Exception as e: raise IOError("Could not read in ephemeris files: {}".format(e)) try: tdat = lalpulsar.InitTimeCorrections(timefile) except RuntimeError: try: # try downloading the ephemeris files from astropy.utils.data import download_file tfile = download_file(DOWNLOAD_URL.format(timefile), cache=True) tdat = lalpulsar.InitTimeCorrections(tfile) except Exception as e: raise IOError("Could not read in time correction file: {}".format(e)) return edat, tdat
def __init__(self): xmlrpc.XMLRPC.__init__(self) import DsaDataBase3 as Data from astropy.utils.data import download_file from astropy.utils import iers iers.IERS.iers_table = iers.IERS_A.open( download_file(iers.IERS_A_URL, cache=True)) self.data = Data.DsaDatabase3(refresh_apdm=True, allc2=False, loadp1=False)
def example_dataset_ifs(): """ Download example FITS cube from github + prepare HCIDataset object. Returns ------- dataset : HCIDataset Notes ----- Astropy's ``download_file`` uses caching, so the file is downloaded at most once per test run. """ print("downloading data...") url_prefix = "https://github.com/carlgogo/VIP_extras/raw/master/datasets" f1 = download_file("{}/sphere_v471tau_cube.fits".format(url_prefix), cache=True) f2 = download_file("{}/sphere_v471tau_psf.fits".format(url_prefix), cache=True) f3 = download_file("{}/sphere_v471tau_pa.fits".format(url_prefix), cache=True) f4 = download_file("{}/sphere_v471tau_wl.fits".format(url_prefix), cache=True) # load fits cube = vip.fits.open_fits(f1) angles = vip.fits.open_fits(f3).flatten() psf = vip.fits.open_fits(f2) wl = vip.fits.open_fits(f4) # create dataset object dataset = vip.Dataset(cube, angles=angles, psf=psf, px_scale=vip.conf.VLT_SPHERE_IFS['plsc'], wavelengths=wl) # crop dataset.crop_frames(size=100, force=True) dataset.normalize_psf(size=None, force_odd=False) # overwrite PSF for easy access dataset.psf = dataset.psfn return dataset
def download_dsn(): """ Download the DSN data from spaceprob.es """ dsn_url = 'http://murmuring-anchorage-8062.herokuapp.com/dsn/probes.json' f = download_file(dsn_url, cache=False) dsn = json.loads(open(f).read())['dsn_by_probe'] return dsn
def filenames(): """Dictionary of available file names.""" result = dict() BASE_URL = 'https://github.com/gammapy/gammapy-extra/raw/master/datasets/vela_region/' url_counts = BASE_URL + 'counts_vela.fits' url_exposure = BASE_URL + 'exposure_vela.fits' url_background = BASE_URL + 'background_vela.fits' url_diffuse = BASE_URL + 'gll_iem_v05_rev1_cutout.fit' url_psf = BASE_URL + 'psf_vela.fits' result['counts_cube'] = data.download_file(url_counts, cache=True) result['exposure_cube'] = data.download_file(url_exposure, cache=True) result['background_image'] = data.download_file(url_background, cache=True) result['diffuse_model'] = data.download_file(url_diffuse, cache=True) result['psf'] = data.download_file(url_psf, cache=True) return result
def cli(ra, dec, radius, outfile, vcat, catalog_file): """ Extracts sources from the catalog within a circular region \b Example usage: fastimg_extract_lsm -- 189.2 -45.6 1.5 lsm.csv or with separate variables catalog: fastimg_extract_lsm --vcat var.csv -- 189.2 -45.6 1.5 lsm.csv Note: arguments (RA, dec, radius, [outfile]) are separated from options by the separator `--`, this avoids mistakenly trying to parse a negative declination as an option flag. \b Args: - ra (float): RA of centre (decimal degrees, J2000) - dec (float): Dec of centre (decimal degrees, J2000) - radius (float): Cone-radius (decimal degrees) - outfile (filepath): Filename to write filtered catalog to. (Default is stdout) \b Options: - vcat (path): Path to output a separate catalog containing only variable sources. - catalog_file (path): Path to SUMS catalog file (sumsscat.Mar-11-2008.gz). If unsupplied, will attempt to download / use cached version via the Astropy download cache. Outputs: An list of matching sources in GSM-format. """ field_of_view = SkyRegion(SkyCoord(ra * u.deg, dec * u.deg), Angle(radius * u.deg)) if catalog_file is None: catalog_file = download_file( 'http://www.astrop.physics.usyd.edu.au/sumsscat/sumsscat.Mar-11-2008.gz', cache=True) full_cat = sumss_file_to_dataframe(catalog_file) lsm_cat = lsm_extract(field_of_view, full_cat) variable_cat = [s for s in lsm_cat if s.variable] write_catalog(lsm_cat, outfile) if vcat: write_catalog(variable_cat, vcat) click.echo("{} sources matched, of which {} variable".format( len(lsm_cat), len(variable_cat)), err=True)
def download_one_file(fn): dest = "{}/{}".format(data_folder, os.path.basename(fn)) if not os.path.exists(dest): url = "http://data.astrometry.net/{}".format(fn) df = data.download_file(url) try: shutil.move(df, dest) except OSError as e: print("Problem saving. (Maybe permissions?): {}".format(e))
def __init__(self): xmlrpc.XMLRPC.__init__(self) iers.IERS.iers_table = iers.IERS_A.open( download_file(iers.IERS_A_URL, cache=True)) self.data = Data.DsaDatabase3( path='/home/itoledo/sim/', refresh_apdm=True, loadp1=False) self.dsa = Dsa.DsaAlgorithm3(self.data)
def get_source(source): """Get the source data for a particular GW catalog """ if source == 'gwtc-1': fname = download_file(gwtc1_url, cache=True) data = json.load(open(fname, 'r')) else: raise ValueError('Unkown catalog source {}'.format(source)) return data['data']
def load_spectral_magsys_fits(remote_url, name=None): fn = download_file(remote_url, cache=True) hdulist = fits.open(fn) dispersion = hdulist[1].data['WAVELENGTH'] flux_density = hdulist[1].data['FLUX'] hdulist.close() refspectrum = Spectrum(dispersion, flux_density, unit=(u.erg / u.s / u.cm**2 / u.AA), wave_unit=u.AA) return SpectralMagSystem(refspectrum, name=name)
import pyspeckit import os if not os.path.exists('n2hp_cube.fit'): import astropy.utils.data as aud from astropy.io import fits f = aud.download_file('ftp://cdsarc.u-strasbg.fr/pub/cats/J/A%2BA/472/519/fits/opha_n2h.fit') with fits.open(f) as ff: ff[0].header['CUNIT3'] = 'm/s' for kw in ['CTYPE4','CRVAL4','CDELT4','CRPIX4']: del ff[0].header[kw] ff.writeto('n2hp_cube.fit') # Load the spectral cube spc = pyspeckit.Cube('n2hp_cube.fit') # Register the fitter # The N2H+ fitter is 'built-in' but is not registered by default; this example # shows how to register a fitting procedure # 'multi' indicates that it is possible to fit multiple components and a # background will not automatically be fit 4 is the number of parameters in the # model (excitation temperature, optical depth, line center, and line width) spc.Registry.add_fitter('n2hp_vtau',pyspeckit.models.n2hp.n2hp_vtau_fitter,4,multisingle='multi') # Run the fitter spc.fiteach(fittype='n2hp_vtau', multifit=True, guesses=[5,0.5,3,1], # Tex=5K, tau=0.5, v_center=12, width=1 km/s signal_cut=6, # minimize the # of pixels fit for the example ) # There are a huge number of parameters for the fiteach procedure. See: # http://pyspeckit.readthedocs.org/en/latest/example_nh3_cube.html
import numpy as np import matplotlib import matplotlib.pyplot as plt from astropy.utils.data import download_file from astropy.io import fits image_list = [ download_file('http://www.mistisoftware.com/astronomy/fits/'+n+'m_L.FIT', cache=True ) \ for n in ['m27_050711_6i30', 'ngc7293_050906_8i40']] image_concat = [] for image in image_list: plt.figure() hdu_list = fits.open(image) hdu_list.info() image_data = hdu_list[0].data hdu_list.close() plt.imshow(image_data, cmap='jet') plt.draw() image_concat.append(fits.getdata(image)) plt.figure() final_image = np.sum(image_concat, axis=0) plt.imshow(final_image, cmap='jet') plt.colorbar() plt.draw() plt.show() outfile = 'concat.fits'
def get_sample_file(filename, url_list, show_progress=True, overwrite=False, timeout=None): """ Downloads a sample file. Will download a sample data file and move it to the sample data directory. Also, uncompresses zip files if necessary. Returns the local file if exists. Parameters ---------- filename: `str` Name of the file url_list: `str` or `list` urls where to look for the file show_progress: `bool` Show a progress bar during download overwrite: `bool` If True download and overwrite an existing file. timeout: `float` The timeout in seconds. If `None` the default timeout is used from `astropy.utils.data.Conf.remote_timeout`. Returns ------- result: `str` The local path of the file. None if it failed. """ if filename[-3:] == 'zip': uncompressed_filename = filename[:-4] else: uncompressed_filename = filename # check if the (uncompressed) file exists if not overwrite and os.path.isfile( os.path.join(sampledata_dir, uncompressed_filename)): return os.path.join(sampledata_dir, uncompressed_filename) else: # check each provided url to find the file for base_url in url_list: online_filename = filename if base_url.count('github'): online_filename += '?raw=true' try: exists = url_exists(os.path.join(base_url, online_filename)) if exists: f = download_file(os.path.join(base_url, online_filename), show_progress=show_progress, timeout=timeout) real_name, ext = os.path.splitext(f) if ext == '.zip': print("Unpacking: {}".format(real_name)) with ZipFile(f, 'r') as zip_file: unzipped_f = zip_file.extract( real_name, sampledata_dir) os.remove(f) move( unzipped_f, os.path.join(sampledata_dir, uncompressed_filename)) return os.path.join(sampledata_dir, uncompressed_filename) else: # move files to the data directory move( f, os.path.join(sampledata_dir, uncompressed_filename)) return os.path.join(sampledata_dir, uncompressed_filename) except (socket.error, socket.timeout) as e: warnings.warn("Download failed with error {}. \n" "Retrying with different mirror.".format(e)) # if reach here then file has not been downloaded. warnings.warn("File {} not found.".format(filename)) return None
def get_icrs_coordinates(name, parse=False, cache=False): """ Retrieve an ICRS object by using an online name resolving service to retrieve coordinates for the specified name. By default, this will search all available databases until a match is found. If you would like to specify the database, use the science state ``astropy.coordinates.name_resolve.sesame_database``. You can also specify a list of servers to use for querying Sesame using the science state ``astropy.coordinates.name_resolve.sesame_url``. This will try each one in order until a valid response is returned. By default, this list includes the main Sesame host and a mirror at vizier. The configuration item `astropy.utils.data.Conf.remote_timeout` controls the number of seconds to wait for a response from the server before giving up. Parameters ---------- name : str The name of the object to get coordinates for, e.g. ``'M42'``. parse: bool Whether to attempt extracting the coordinates from the name by parsing with a regex. For objects catalog names that have J-coordinates embedded in their names eg: 'CRTS SSS100805 J194428-420209', this may be much faster than a sesame query for the same object name. The coordinates extracted in this way may differ from the database coordinates by a few deci-arcseconds, so only use this option if you do not need sub-arcsecond accuracy for coordinates. cache : bool, str, optional Determines whether to cache the results or not. Passed through to `~astropy.utils.data.download_file`, so pass "update" to update the cached value. Returns ------- coord : `astropy.coordinates.ICRS` object The object's coordinates in the ICRS frame. """ # if requested, first try extract coordinates embedded in the object name. # Do this first since it may be much faster than doing the sesame query if parse: from . import jparser if jparser.search(name): return jparser.to_skycoord(name) else: # if the parser failed, fall back to sesame query. pass # maybe emit a warning instead of silently falling back to sesame? database = sesame_database.get() # The web API just takes the first letter of the database name db = database.upper()[0] # Make sure we don't have duplicates in the url list urls = [] domains = [] for url in sesame_url.get(): domain = urllib.parse.urlparse(url).netloc # Check for duplicates if domain not in domains: domains.append(domain) # Add the query to the end of the url, add to url list fmt_url = os.path.join(url, "{db}?{name}") fmt_url = fmt_url.format(name=urllib.parse.quote(name), db=db) urls.append(fmt_url) exceptions = [] for url in urls: try: resp_data = get_file_contents( download_file(url, cache=cache, show_progress=False)) break except urllib.error.URLError as e: exceptions.append(e) continue except socket.timeout as e: # There are some cases where urllib2 does not catch socket.timeout # especially while receiving response data on an already previously # working request e.reason = "Request took longer than the allowed {:.1f} " \ "seconds".format(data.conf.remote_timeout) exceptions.append(e) continue # All Sesame URL's failed... else: messages = [f"{url}: {e.reason}" for url, e in zip(urls, exceptions)] raise NameResolveError("All Sesame queries failed. Unable to " "retrieve coordinates. See errors per URL " "below: \n {}".format("\n".join(messages))) ra, dec = _parse_response(resp_data) if ra is None and dec is None: if db == "A": err = f"Unable to find coordinates for name '{name}'" else: err = "Unable to find coordinates for name '{}' in database {}"\ .format(name, database) raise NameResolveError(err) # Return SkyCoord object sc = SkyCoord(ra=ra, dec=dec, unit=(u.degree, u.degree), frame='icrs') return sc
def get_toi_list(use_cache=True): url = TOI_URL + "?sort=toi&output=csv&version={0}".format(__version__) if use_cache: return pd.read_csv(download_file(url, cache=True)) return pd.read_csv(url)
def test_aspcapStar_loader(tmpdir): aspcap_url = ("https://data.sdss.org/sas/dr16/apogee/spectro/aspcap/r12/" "l33/apo25m/N7789/aspcapStar-r12-2M00005414+5522241.fits") with set_temp_cache(path=str(tmpdir)): filename = download_file(aspcap_url, cache=True) spectrum = aspcapStar_loader(filename)
raise KeyError( "Please work in a conda environment with lalsuite and cwinpy installed" ) execpath = os.path.join(execpath, "bin") lppen = os.path.join(execpath, "lalapps_pulsar_parameter_estimation_nested") n2p = os.path.join(execpath, "lalinference_nest2pos") Nlive = 1024 # number of nested sampling live points Nmcmcinitial = 0 # set to 0 so that prior samples are not resampled outfile = os.path.join(outdir, "{}_nest.hdf".format(label)) # set ephemeris files efile = download_file(DOWNLOAD_URL.format("earth00-40-DE405.dat.gz"), cache=True) sfile = download_file(DOWNLOAD_URL.format("sun00-40-DE405.dat.gz"), cache=True) tfile = download_file(DOWNLOAD_URL.format("te405_2000-2040.dat.gz"), cache=True) # set the command line arguments runcmd = " ".join([ lppen, "--verbose", "--input-files", ",".join(hetfiles), "--detectors", detector, "--par-file", parfile, "--prior-file",
def setup(self, request, reference, data_path): """ This method does initial setup of creating configuration and performing a single run of integration test. """ # The last component in dirpath can be extracted as name of setup. self.name = data_path['setup_name'] self.config_file = os.path.join(data_path['config_dirpath'], "config.yml") # A quick hack to use atom data per setup. Atom data is ingested from # local HDF or downloaded and cached from a url, depending on data_path # keys. atom_data_name = yaml.load(open(self.config_file))['atom_data'] # Get the path to HDF file: if 'atom_data_url' in data_path: # If the atom data is to be ingested from url: atom_data_filepath = download_file(urlparse.urljoin( base=data_path['atom_data_url'], url=atom_data_name), cache=True ) else: # If the atom data is to be ingested from local file: atom_data_filepath = os.path.join( data_path['atom_data_dirpath'], atom_data_name ) # Load atom data file separately, pass it for forming tardis config. self.atom_data = AtomData.from_hdf5(atom_data_filepath) # Check whether the atom data file in current run and the atom data # file used in obtaining the reference data are same. # TODO: hard coded UUID for kurucz atom data file, generalize it later. # kurucz_data_file_uuid1 = "5ca3035ca8b311e3bb684437e69d75d7" # assert self.atom_data.uuid1 == kurucz_data_file_uuid1 # Create a Configuration through yaml file and atom data. tardis_config = Configuration.from_yaml( self.config_file, atom_data=self.atom_data) # Check whether current run is with less packets. if request.config.getoption("--less-packets"): less_packets = request.config.integration_tests_config['less_packets'] tardis_config['montecarlo']['no_of_packets'] = ( less_packets['no_of_packets'] ) tardis_config['montecarlo']['last_no_of_packets'] = ( less_packets['last_no_of_packets'] ) # We now do a run with prepared config and get radial1d model. self.result = Radial1DModel(tardis_config) # If current test run is just for collecting reference data, store the # output model to HDF file, save it at specified path. Skip all tests. # Else simply perform the run and move further for performing # assertions. if request.config.getoption("--generate-reference"): run_radial1d(self.result, hdf_path_or_buf=os.path.join( data_path['gen_ref_dirpath'], "{0}.h5".format(self.name) )) pytest.skip("Reference data saved at {0}".format( data_path['gen_ref_dirpath'] )) else: run_radial1d(self.result) # Get the reference data through the fixture. self.reference = reference
parser.add_argument('-w', '--noweb', dest='noweb', default=False, action='store_true', help='Does not build the web.') # We use parse_known_args because we want to leave the remaining args for distutils args = parser.parse_known_args()[0] if args.noweb: packages = find_packages(where='python', exclude=['marvin.web*']) else: packages = find_packages(where='python') data_files = get_data_files(with_web=not args.noweb) maskbits_path = download_file( 'https://svn.sdss.org/public/repo/sdss/idlutils/' 'trunk/data/sdss/sdssMaskbits.par') shutil.copy( maskbits_path, os.path.join(os.path.dirname(__file__), 'python/marvin/data/', 'sdssMaskbits.par')) # Now we remove all our custom arguments to make sure they don't interfere with distutils remove_args(parser) # Runs distutils run(data_files, packages)
def compute_TDBs(self): """Compute and add TDB and TDB long double columns to the TOA table. This routine creates new columns 'tdb' and 'tdbld' in a TOA table for TDB times, using the Observatory locations and IERS A Earth rotation corrections for UT1. """ from astropy.utils.iers import IERS_A, IERS_A_URL from astropy.utils.data import download_file, clear_download_cache global iers_a_file, iers_a # If previous columns exist, delete them if 'tdb' in self.table.colnames: log.info('tdb column already exists. Deleting...') self.table.remove_column('tdb') if 'tdbld' in self.table.colnames: log.info('tdbld column already exists. Deleting...') self.table.remove_column('tdbld') # First make sure that we have already applied clock corrections ccs = False for tfs in self.table['flags']: if 'clkcorr' in tfs: ccs = True if ccs is False: log.warn( "No TOAs have clock corrections. Use .apply_clock_corrections() first." ) # These will be the new table columns col_tdb = numpy.zeros_like(self.table['mjd']) col_tdbld = numpy.zeros(self.ntoas, dtype=numpy.longdouble) # Read the IERS for ut1_utc corrections, if needed iers_a_file = download_file(IERS_A_URL, cache=True) # Check to see if the cached file is older than any of the TOAs iers_file_time = time.Time(os.path.getctime(iers_a_file), format="unix") if (iers_file_time.mjd < self.last_MJD.mjd): clear_download_cache(iers_a_file) try: log.warn("Cached IERS A file is out-of-date. Re-downloading.") iers_a_file = download_file(IERS_A_URL, cache=True) except: pass iers_a = IERS_A.open(iers_a_file) # Now step through in observatory groups to compute TDBs for ii, key in enumerate(self.table.groups.keys): grp = self.table.groups[ii] obs = self.table.groups.keys[ii]['obs'] loind, hiind = self.table.groups.indices[ii:ii + 2] # Make sure the string precisions are all set to 9 for all TOAs for t in grp['mjd']: t.precision = 9 if key['obs'] in ["Barycenter", "Geocenter", "Spacecraft"]: # For these special cases, convert the times to TDB. # For Barycenter this will be # a null conversion, but for Geocenter the scale will Likely # be TT (if they came from a spacecraft like Fermi, RXTE or NICER) tdbs = [t.tdb for t in grp['mjd']] elif key['obs'] in observatories: # For a normal observatory, convert to Time in UTC # with location specified as observatory, # and then convert to TDB utcs = time.Time([t.isot for t in grp['mjd']], format='isot', scale='utc', precision=9, location=observatories[obs].loc) utcs.delta_ut1_utc = utcs.get_delta_ut1_utc(iers_a) # Also save delta_ut1_utc for these TOAs for later use for toa, dut1 in zip(grp['mjd'], utcs.delta_ut1_utc): toa.delta_ut1_utc = dut1 # The actual conversion from UTC to TDB is done by astropy.Time # as described here <http://docs.astropy.org/en/stable/time/>, # with the real work done by the IAU SOFA library tdbs = utcs.tdb else: log.error("Unknown observatory ({0})".format(key['obs'])) col_tdb[loind:hiind] = numpy.asarray([t for t in tdbs]) col_tdbld[loind:hiind] = numpy.asarray( [utils.time_to_longdouble(t) for t in tdbs]) # Now add the new columns to the table col_tdb = table.Column(name='tdb', data=col_tdb) col_tdbld = table.Column(name='tdbld', data=col_tdbld) self.table.add_columns([col_tdb, col_tdbld])
of the Sun as observed by SDO/AIA. """ import matplotlib.pyplot as plt from astropy import units as u from astropy.coordinates import SkyCoord from astropy.coordinates import solar_system_ephemeris from astropy.utils.data import download_file import sunpy.map from sunpy.coordinates import get_body_heliographic_stonyhurst ############################################################################### # Let's download an image of the Venus transit. f = download_file( 'http://jsoc.stanford.edu/data/events/Venus_AIA24s_1600/Out/fits/20120606_040731_UTC.0041.fits' ) aiamap = sunpy.map.Map(f) ############################################################################### # For this example, we require high precision ephemeris information. The built-in # ephemeris provided by astropy are not accurate enough. This requires jplephem # to be installed. solar_system_ephemeris.set('jpl') ############################################################################### # Now we get the position of venus and convert it into the SDO/AIA coordinates. venus = get_body_heliographic_stonyhurst('venus', aiamap.date, observer=aiamap.observer_coordinate) venus_hpc = venus.transform_to(aiamap.coordinate_frame)
file_best_fit_1c = './fits/NGC1333_NH3_MC_best_npeaks1.fits' file_best_fit_2c = './fits/NGC1333_NH3_MC_best_npeaks2.fits' download_data = False do_1comp = False do_2comp = False do_inspect = True if download_data: from astropy.utils.data import download_file import os, shutil if os.path.exists('data') == False: os.mkdir('data') # get rms file if os.path.isfile(file_rms) == False: tmp_rms = download_file( 'https://dataverse.harvard.edu/api/access/datafile/3008213') shutil.move(tmp_rms, file_rms) # get cube if os.path.isfile(file_cube) == False: tmp_cube = download_file( 'https://dataverse.harvard.edu/api/access/datafile/2902348') shutil.move(tmp_cube, file_cube) # create Peak temperature file if os.path.isfile(file_tp) == False: hd = fits.getheader(file_rms) hd['BUNIT'] = 'K' cube = fits.getdata(file_cube) tp_data = cube.max(axis=0) fits.writeto(file_tp, tp_data, hd) hd = fits.getheader(file_rms)
""" Quick-look to demonstrate that the off positions are relatively emission-free """ import aplpy from astropy.utils.data import download_file import paths dame2001 = download_file('http://www.cfa.harvard.edu/mmw/Wco_DHT2001.fits.gz', cache=True) F = aplpy.FITSFigure(dame2001, convention='calabretta') F.show_grayscale() F.recenter(0, 0, width=5, height=3) # center on the inner 5x3 degrees F.show_regions(paths.rpath('target_fields_8x8.reg')) F.show_regions(paths.rpath('off_positions_selectedfromDame2001.reg')) F.save(paths.fpath('Dame2001_APEXCMZ_offpositions.png')) F.save(paths.fpath('Dame2001_APEXCMZ_offpositions.pdf')) F.hide_layer('region_set_1') F.hide_layer('region_set_1_txt') F.show_regions(paths.rpath('target_fields_8x8_coloredbyoffposition.reg')) F.save(paths.fpath('Dame2001_APEXCMZ_offpositions_coloredbyoff.png'))
def sdss_astrombad(run, camcol, field, photolog_version='dr10'): """For a list of RUN, CAMCOL, FIELD, return whether each field has bad astrometry. Parameters ---------- run, camcol, field : :class:`int` or array of :class:`int` Run, camcol and field. If arrays are passed, all must have the same length. photolog_version : :class:`str`, optional Use this version of photolog to obtain the obBadfields.par file, if :envvar:`PHOTOLOG_DIR` is not set. Returns ------- :class:`numpy.ndarray` of :class:`bool` Array of bool. ``True`` indicates the field is bad. Raises ------ ValueError If the sizes of the arrays don't match or if the array values are out of bounds. Notes ----- Reads data from ``$PHOTOLOG_DIR/opfiles/opBadFields.par``. If there is a problem with one camcol, we assume a problem with all camcols. """ from astropy.utils.data import download_file from .yanny import yanny global opbadfields # # Check inputs # if isinstance(run, int): # # Assume all inputs are integers & promote to arrays. # run = np.array([run], dtype=np.int64) camcol = np.array([camcol], dtype=np.int64) field = np.array([field], dtype=np.int64) else: # # Check that all inputs have the same shape. # if run.shape != camcol.shape: raise ValueError("camcol.shape does not match run.shape!") if run.shape != field.shape: raise ValueError("field.shape does not match run.shape!") # # Check ranges of parameters # if ((run < 0) | (run >= 2**16)).any(): raise ValueError("run values are out-of-bounds!") if ((camcol < 1) | (camcol > 6)).any(): raise ValueError("camcol values are out-of-bounds!") if ((field < 0) | (field >= 2**12)).any(): raise ValueError("camcol values are out-of-bounds!") # # Read the file # if opbadfields is None: # pragma: no cover if os.getenv('PHOTOLOG_DIR') is None: if (photolog_version == 'trunk' or photolog_version.startswith('branches/')): iversion = photolog_version else: iversion = 'tags/'+photolog_version baseurl = ('https://svn.sdss.org/public/data/sdss/photolog/' + '{0}/opfiles/opBadfields.par').format(iversion) filename = download_file(baseurl, cache=True) else: filename = os.path.join(os.getenv('PHOTOLOG_DIR'), 'opfiles', 'opBadfields.par') astrombadfile = yanny(filename) w = ((astrombadfile['BADFIELDS']['problem'] == 'astrom'.encode()) | (astrombadfile['BADFIELDS']['problem'] == 'rotator'.encode())) opbadfields = astrombadfile['BADFIELDS'][w] # # opbadfields already has astrom problems selected at this point # bad = np.zeros(run.shape, dtype=bool) for row in opbadfields: w = ((run == row['run']) & (field >= row['firstfield']) & (field < row['lastfield'])) if w.any(): bad[w] = True return bad
def _download(ilon, ilat): # download the tile to path srtm_dir = SrtmConf.srtm_dir server = SrtmConf.server tile_name = _hgt_filename(ilon, ilat) tile_path = os.path.join(srtm_dir, tile_name) # Unfortunately, each server has a different structure. # NASA stores them in sub-directories (by continents) # Panoramic-Viewfinders has a flat structure but has several hgt tiles # zipped in a file # Furthermore, we need to check against the available tiles # (ocean tiles and polar caps are not present); we also do this # in the _get_hgt_file function (because it's not only important # for downloading). However, we have to figure out, in which # subdirectory/zip-file a tile is located. if server.startswith('nasa_v'): if server == 'nasa_v1.0': base_url = 'https://dds.cr.usgs.gov/srtm/version1/' elif server == 'nasa_v2.1': base_url = 'https://dds.cr.usgs.gov/srtm/version2_1/SRTM3/' continent = _check_availability(ilon, ilat) # downloading full_url = base_url + continent + '/' + tile_name + '.zip' tmp_path = download_file(full_url) # move to srtm_dir shutil.move(tmp_path, tile_path + '.zip') # unpacking with ZipFile(tile_path + '.zip', 'r') as zf: zf.extractall(srtm_dir) os.remove(tile_path + '.zip') elif server == 'viewpano': base_url = 'http://viewfinderpanoramas.org/dem3/' zipfile_name = _check_availability(ilon, ilat) super_tile_path = os.path.join(srtm_dir, zipfile_name) # downloading full_url = base_url + zipfile_name tmp_path = download_file(full_url) # move to srtm_dir shutil.move(tmp_path, super_tile_path) # unpacking with ZipFile(super_tile_path, 'r') as zf: zf.extractall(srtm_dir) os.remove(super_tile_path)
def grabImage(ra,dec): imagelist = IrsaDust.get_image_list(SkyCoord(ra,dec).fk5, image_type="100um", radius=2*u.degree) image_file = download_file(imagelist[0],cache=True) image_data.append(fits.getdata(image_file, ext=0)) #gets image from IRSA database
def test_make_kurucz_tlusty_spectral_grid(): # download the needed files url_loc = 'http://www.stsci.edu/~kgordon/beast/' kurucz_fname_dld = download_file('%s%s' % (url_loc, 'kurucz2004.grid.fits')) tlusty_fname_dld = download_file('%s%s' % (url_loc, 'tlusty.lowres.grid.fits')) filter_fname_dld = download_file('%s%s' % (url_loc, 'filters.hd5')) iso_fname_dld = download_file('%s%s' % (url_loc, 'beast_example_phat_iso.csv')) # rename files to have the correct extensions kurucz_fname = '%s.fits' % (kurucz_fname_dld) os.rename(kurucz_fname_dld, kurucz_fname) tlusty_fname = '%s.fits' % (tlusty_fname_dld) os.rename(tlusty_fname_dld, tlusty_fname) filter_fname = '%s.hd5' % (filter_fname_dld) os.rename(filter_fname_dld, filter_fname) iso_fname = '%s.csv' % (iso_fname_dld) os.rename(iso_fname_dld, iso_fname) # download cached version of spectral grid filename = download_file('%s%s' % (url_loc, 'beast_example_phat_spec_grid.hd5')) hdf_cache = h5py.File(filename, 'r') ################ # generate the same spectral grid from the code # read in the cached isochrones oiso = ezIsoch(iso_fname) # define the distance distances = [24.47] distance_unit = units.mag velocity = -300 * units.km / units.s redshift = (velocity / const.c).decompose().value # define the spectral libraries to use osl = stellib.Tlusty(filename=tlusty_fname) \ + stellib.Kurucz(filename=kurucz_fname) filters = [ 'HST_WFC3_F275W', 'HST_WFC3_F336W', 'HST_ACS_WFC_F475W', 'HST_ACS_WFC_F814W', 'HST_WFC3_F110W', 'HST_WFC3_F160W' ] add_spectral_properties_kwargs = dict(filternames=filters) spec_fname = '/tmp/beast_example_phat_spec_grid.hd5' spec_fname, g = make_spectral_grid( 'test', oiso, osl=osl, redshift=redshift, distance=distances, distance_unit=distance_unit, spec_fname=spec_fname, filterLib=filter_fname, add_spectral_properties_kwargs=add_spectral_properties_kwargs) # open the hdf file with the specral grid hdf_new = h5py.File(spec_fname, 'r') # go through the file and check if it is exactly the same for sname in hdf_cache.keys(): if isinstance(hdf_cache[sname], h5py.Dataset): cvalue = hdf_cache[sname] cvalue_new = hdf_new[sname] if cvalue.dtype.fields is None: np.testing.assert_equal(cvalue.value, cvalue_new.value, 'testing %s' % (sname)) else: for ckey in cvalue.dtype.fields.keys(): np.testing.assert_equal(cvalue.value[ckey], cvalue_new.value[ckey], 'testing %s/%s' % (sname, ckey))
try: from urllib.error import URLError except ImportError: from urllib2 import URLError # Science modules from random import gauss import numpy as np from astropy import units as u from astropy.time import Time from astropy.table import Table, Column, vstack from astropy.utils.iers import IERS_A, IERS_A_URL, IERS from astropy.utils.data import download_file from astropy.coordinates import EarthLocation try: iers_a_file = download_file(IERS_A_URL, cache=True) iers_a = IERS_A.open(iers_a_file) IERS.iers_table = iers_a except: print('IERS_A_URL is temporarily unavailable') pass # Custom modules import dfn_utils from orbital_utilities import OrbitObject, \ random_compute_orbit_integration_EOE, \ random_compute_orbit_ceplecha, random_compute_orbit_integration_posvel, \ compute_cartesian_velocities_from_radiant#, compute_infinity_radiant # Define some constants mu_e = 3.986005000e14 #4418e14 # Earth's standard gravitational parameter (m3/s2)
def setup_class(cls): # create dummy frame cache files cls.dummydir = "testing_frame_cache" os.makedirs(cls.dummydir, exist_ok=True) cls.dummy_cache_files = [] for i in range(0, 5): dummyfile = os.path.join(cls.dummydir, "frame_cache_{0:01d}.cache".format(i)) cls.dummy_cache_files.append(dummyfile) with open(dummyfile, "w") as fp: fp.write("blah\n") # create some fake data frames using lalapps_Makefakedata_v5 mfd = shutil.which("lalapps_Makefakedata_v5") cls.fakedatadir = "testing_fake_frame_cache" cls.fakedatadetectors = ["H1", "L1"] cls.fakedatachannels = [ "{}:FAKE_DATA".format(det) for det in cls.fakedatadetectors ] cls.fakedatastarts = [1000000000, 1000000000 + 86400 * 2] cls.fakedataduration = 86400 os.makedirs(cls.fakedatadir, exist_ok=True) cls.fakedatabandwidth = 8 # Hz sqrtSn = 1e-29 # noise amplitude spectral density cls.fakedataname = "FAKEDATA" # Create two pulsars to inject: one isolated and one binary cls.fakepulsarpar = [] # requirements for Makefakedata pulsar input files isolatedstr = """\ Alpha = {alpha} Delta = {delta} Freq = {f0} f1dot = {f1} f2dot = {f2} refTime = {pepoch} h0 = {h0} cosi = {cosi} psi = {psi} phi0 = {phi0} """ binarystr = """\ orbitasini = {asini} orbitPeriod = {period} orbitTp = {Tp} orbitArgp = {argp} orbitEcc = {ecc} """ transientstr = """\ transientWindowType = {wintype} transientStartTime = {tstart} transientTau = {tau} """ # FIRST PULSAR (ISOLATED) f0 = 6.9456 / 2.0 # source rotation frequency (Hz) f1 = -9.87654e-11 / 2.0 # source rotational frequency derivative (Hz/s) f2 = 2.34134e-18 / 2.0 # second frequency derivative (Hz/s^2) alpha = 0.0 # source right ascension (rads) delta = 0.5 # source declination (rads) pepoch = 1000000000 # frequency epoch (GPS) # GW parameters h0 = 3.0e-24 # GW amplitude phi0 = 1.0 # GW initial phase (rads) cosiota = 0.1 # cosine of inclination angle psi = 0.5 # GW polarisation angle (rads) mfddic = { "alpha": alpha, "delta": delta, "f0": 2 * f0, "f1": 2 * f1, "f2": 2 * f2, "pepoch": pepoch, "h0": h0, "cosi": cosiota, "psi": psi, "phi0": phi0, } cls.fakepulsarpar.append(PulsarParametersPy()) cls.fakepulsarpar[0]["PSRJ"] = "J0000+0000" cls.fakepulsarpar[0]["H0"] = h0 cls.fakepulsarpar[0]["PHI0"] = phi0 / 2.0 cls.fakepulsarpar[0]["PSI"] = psi cls.fakepulsarpar[0]["COSIOTA"] = cosiota cls.fakepulsarpar[0]["F"] = [f0, f1, f2] cls.fakepulsarpar[0]["RAJ"] = alpha cls.fakepulsarpar[0]["DECJ"] = delta cls.fakepulsarpar[0]["PEPOCH"] = pepoch cls.fakepulsarpar[0]["EPHEM"] = "DE405" cls.fakepulsarpar[0]["UNITS"] = "TDB" cls.fakepardir = "testing_fake_par_dir" os.makedirs(cls.fakepardir, exist_ok=True) cls.fakeparfile = [] cls.fakeparfile.append(os.path.join(cls.fakepardir, "J0000+0000.par")) cls.fakepulsarpar[0].pp_to_par(cls.fakeparfile[-1]) injfile = os.path.join(cls.fakepardir, "inj.dat") with open(injfile, "w") as fp: fp.write("[Pulsar 1]\n") fp.write(isolatedstr.format(**mfddic)) fp.write("\n") # SECOND PULSAR (BINARY SYSTEM) f0 = 3.8654321 / 2.0 # source rotation frequency (Hz) f1 = 9.87654e-13 / 2.0 # source rotational frequency derivative (Hz/s) f2 = -1.34134e-20 / 2.0 # second frequency derivative (Hz/s^2) alpha = 1.3 # source right ascension (rads) delta = -0.4 # source declination (rads) pepoch = 1000086400 # frequency epoch (GPS) # GW parameters h0 = 7.5e-25 # GW amplitude phi0 = 0.7 # GW initial phase (rads) cosiota = 0.6 # cosine of inclination angle psi = 1.1 # GW polarisation angle (rads) # binary parameters asini = 1.4 # projected semi-major axis (ls) period = 0.1 * 86400 # orbital period (s) Tp = 999992083 # time of periastron (GPS) argp = 0.0 # argument of perisatron (rad) ecc = 0.09 # the orbital eccentricity mfddic = { "alpha": alpha, "delta": delta, "f0": 2 * f0, "f1": 2 * f1, "f2": 2 * f2, "pepoch": pepoch, "h0": h0, "cosi": cosiota, "psi": psi, "phi0": phi0, } mfdbindic = { "asini": asini, "Tp": Tp, "period": period, "argp": argp, "ecc": ecc, } cls.fakepulsarpar.append(PulsarParametersPy()) cls.fakepulsarpar[1]["PSRJ"] = "J1111+1111" cls.fakepulsarpar[1]["H0"] = h0 cls.fakepulsarpar[1]["PHI0"] = phi0 / 2.0 cls.fakepulsarpar[1]["PSI"] = psi cls.fakepulsarpar[1]["COSIOTA"] = cosiota cls.fakepulsarpar[1]["F"] = [f0, f1, f2] cls.fakepulsarpar[1]["RAJ"] = alpha cls.fakepulsarpar[1]["DECJ"] = delta cls.fakepulsarpar[1]["PEPOCH"] = pepoch cls.fakepulsarpar[1]["BINARY"] = "BT" cls.fakepulsarpar[1]["E"] = ecc cls.fakepulsarpar[1]["A1"] = asini cls.fakepulsarpar[1]["T0"] = Tp cls.fakepulsarpar[1]["OM"] = argp cls.fakepulsarpar[1]["PB"] = period cls.fakepulsarpar[1]["EPHEM"] = "DE405" cls.fakepulsarpar[1]["UNITS"] = "TDB" cls.fakeparfile.append(os.path.join(cls.fakepardir, "J1111+1111.par")) cls.fakepulsarpar[1].pp_to_par(cls.fakeparfile[-1]) with open(injfile, "a") as fp: fp.write("[Pulsar 2]\n") fp.write(isolatedstr.format(**mfddic)) fp.write(binarystr.format(**mfdbindic)) fp.write("\n") # THIRD PULSAR (GLITCHING PULSAR) f0 = 5.3654321 / 2.0 # source rotation frequency (Hz) f1 = -4.57654e-10 / 2.0 # source rotational frequency derivative (Hz/s) f2 = 1.34134e-18 / 2.0 # second frequency derivative (Hz/s^2) alpha = 4.6 # source right ascension (rads) delta = -0.9 # source declination (rads) pepoch = 1000000000 + 1.5 * 86400 # frequency epoch (GPS) # glitch parameters df0 = 0.0001 # EM glitch frequency jump df1 = 1.2e-11 # EM glitch frequency derivative jump df2 = -4.5e-19 # EM glitch frequency second derivative jump dphi = 1.1 # EM glitch phase offset glepoch = pepoch # glitch epoch # GW parameters h0 = 8.7e-25 # GW amplitude phi0 = 0.142 # GW initial phase (rads) cosiota = -0.3 # cosine of inclination angle psi = 0.52 # GW polarisation angle (rads) # binary parameters asini = 2.9 # projected semi-major axis (ls) period = 0.3 * 86400 # orbital period (s) Tp = 999995083 # time of periastron (GPS) argp = 0.5 # argument of perisatron (rad) ecc = 0.09 # the orbital eccentricity # for MFD I need to create this as two transient pulsars using a # rectangular window cutting before and after the glitch mfddic = { "alpha": alpha, "delta": delta, "f0": 2 * f0, "f1": 2 * f1, "f2": 2 * f2, "pepoch": pepoch, "h0": h0, "cosi": cosiota, "psi": psi, "phi0": phi0, } mfdbindic = { "asini": asini, "Tp": Tp, "period": period, "argp": argp, "ecc": ecc, } mfdtransientdic = { "wintype": "rect", "tstart": cls.fakedatastarts[0], "tau": 86400, } # signal before the glitch with open(injfile, "a") as fp: fp.write("[Pulsar 3]\n") fp.write(isolatedstr.format(**mfddic)) fp.write(binarystr.format(**mfdbindic)) fp.write(transientstr.format(**mfdtransientdic)) fp.write("\n") mfddic["f0"] = 2 * (f0 + df0) mfddic["f1"] = 2 * (f1 + df1) mfddic["f2"] = 2 * (f2 + df2) mfddic["phi0"] = phi0 + 2 * dphi mfdtransientdic["tstart"] = cls.fakedatastarts[1] # signal after the glitch with open(injfile, "a") as fp: fp.write("[Pulsar 4]\n") fp.write(isolatedstr.format(**mfddic)) fp.write(binarystr.format(**mfdbindic)) fp.write(transientstr.format(**mfdtransientdic)) cls.fakepulsarpar.append(PulsarParametersPy()) cls.fakepulsarpar[2]["PSRJ"] = "J2222+2222" cls.fakepulsarpar[2]["H0"] = h0 cls.fakepulsarpar[2]["PHI0"] = phi0 / 2.0 cls.fakepulsarpar[2]["PSI"] = psi cls.fakepulsarpar[2]["COSIOTA"] = cosiota cls.fakepulsarpar[2]["F"] = [f0, f1, f2] cls.fakepulsarpar[2]["RAJ"] = alpha cls.fakepulsarpar[2]["DECJ"] = delta cls.fakepulsarpar[2]["PEPOCH"] = pepoch cls.fakepulsarpar[2]["BINARY"] = "BT" cls.fakepulsarpar[2]["E"] = ecc cls.fakepulsarpar[2]["A1"] = asini cls.fakepulsarpar[2]["T0"] = Tp cls.fakepulsarpar[2]["OM"] = argp cls.fakepulsarpar[2]["PB"] = period cls.fakepulsarpar[2]["EPHEM"] = "DE405" cls.fakepulsarpar[2]["UNITS"] = "TDB" cls.fakepulsarpar[2]["GLEP"] = [glepoch] cls.fakepulsarpar[2]["GLF0"] = [df0] cls.fakepulsarpar[2]["GLF1"] = [df1] cls.fakepulsarpar[2]["GLF2"] = [df2] cls.fakepulsarpar[2]["GLPH"] = [dphi / (2 * np.pi)] cls.fakeparfile.append(os.path.join(cls.fakepardir, "J2222+2222.par")) cls.fakepulsarpar[2].pp_to_par(cls.fakeparfile[-1]) # set ephemeris files efile = download_file(DOWNLOAD_URL.format("earth00-40-DE405.dat.gz"), cache=True) sfile = download_file(DOWNLOAD_URL.format("sun00-40-DE405.dat.gz"), cache=True) for datastart in cls.fakedatastarts: for i in range(len(cls.fakedatachannels)): cmds = [ "-F", cls.fakedatadir, "--outFrChannels={}".format(cls.fakedatachannels[i]), "-I", cls.fakedatadetectors[i], "--sqrtSX={0:.1e}".format(sqrtSn), "-G", str(datastart), "--duration={}".format(cls.fakedataduration), "--Band={}".format(cls.fakedatabandwidth), "--fmin", "0", '--injectionSources="{}"'.format(injfile), "--outLabel={}".format(cls.fakedataname), '--ephemEarth="{}"'.format(efile), '--ephemSun="{}"'.format(sfile), ] # run makefakedata sp.run([mfd] + cmds) # create dummy segment file cls.dummysegments = [(1000000000, 1000000600), (1000000800, 1000000900)] cls.dummysegmentfile = os.path.join(cls.fakedatadir, "fakesegments.txt") with open(cls.dummysegmentfile, "w") as fp: for segs in cls.dummysegments: fp.write("{} {}\n".format(segs[0], segs[1]))
In this example we load the Daily Synoptic Maps produced by the HMI team. This data is an interesting demonstration of SunPy's Map class as it is not in the more common Helioprojective coordinate system, it is in Heliographic Carrington coordinates and in a non-trivial Cylindrical Equal Area projection. """ import matplotlib.pyplot as plt from astropy.utils.data import download_file import sunpy.map ############################################################################### # Let's download the file and read it into a Map filename = download_file( 'http://jsoc.stanford.edu/data/hmi/synoptic/hmi.Synoptic_Mr.2191.fits', cache=True) syn_map = sunpy.map.Map(filename) ############################################################################### # Let's fix the plot settings syn_map.plot_settings['cmap'] = 'hmimag' syn_map.plot_settings['norm'] = plt.Normalize(-1500, 1500) ############################################################################### # Let's plot the results fig = plt.figure(figsize=(12, 5)) axes = plt.subplot(projection=syn_map) im = syn_map.plot() # Set up the Sine Latitude Grid
def query_flag(ifo, name, start_time, end_time, source='any', server="segments.ligo.org", veto_definer=None, cache=False): """Return the times where the flag is active Parameters ---------- ifo: string The interferometer to query (H1, L1). name: string The status flag to query from LOSC. start_time: int The starting gps time to begin querying from LOSC end_time: int The end gps time of the query source: str, Optional Choice between "GWOSC" or "dqsegdb". If dqsegdb, the server option may also be given. The default is to try GWOSC first then try dqsegdb. server: str, Optional The server path. Only used with dqsegdb atm. veto_definer: str, Optional The path to a veto definer to define groups of flags which themselves define a set of segments. cache: bool If true cache the query. Default is not to cache Returns --------- segments: glue.segments.segmentlist List of segments """ info = name.split(':') if len(info) == 2: segment_name, version = info elif len(info) == 1: segment_name = info[0] version = 1 flag_segments = segmentlist([]) if source in ['GWOSC', 'any']: # Special cases as the LOSC convention is backwards from normal # LIGO / Virgo operation!!!! if (('_HW_INJ' in segment_name and 'NO' not in segment_name) or 'VETO' in segment_name): data = query_flag(ifo, 'DATA', start_time, end_time) if '_HW_INJ' in segment_name: name = 'NO_' + segment_name else: name = segment_name.replace('_VETO', '') negate = query_flag(ifo, name, start_time, end_time, cache=cache) return (data - negate).coalesce() duration = end_time - start_time url = GWOSC_URL.format(get_run(start_time + duration / 2), ifo, segment_name, int(start_time), int(duration)) try: fname = download_file(url, cache=cache) data = json.load(open(fname, 'r')) if 'segments' in data: flag_segments = data['segments'] except Exception as e: msg = "Unable to find segments in GWOSC, check flag name or times" print(e) if source != 'any': raise ValueError(msg) else: print("Tried and failed GWOSC {}, trying dqsegdb", name) return query_flag(ifo, segment_name, start_time, end_time, source='dqsegdb', server=server, veto_definer=veto_definer) elif source == 'dqsegdb': # Let's not hard require dqsegdb to be installed if we never get here. try: from dqsegdb.apicalls import dqsegdbQueryTimes as query except ImportError: raise ValueError("Could not query flag. Install dqsegdb" ":'pip install dqsegdb'") # The veto definer will allow the use of MACRO names # These directly correspond the name defined in the veto definer file. if veto_definer is not None: veto_def = parse_veto_definer(veto_definer) # We treat the veto definer name as if it were its own flag and # a process the flags in the veto definer if veto_definer is not None and segment_name in veto_def[ifo]: for flag in veto_def[ifo][segment_name]: segs = query("https", server, ifo, flag['name'], flag['version'], 'active', int(start_time), int(end_time))[0]['active'] # Apply padding to each segment for rseg in segs: seg_start = rseg[0] + flag['start_pad'] seg_end = rseg[1] + flag['end_pad'] flag_segments.append(segment(seg_start, seg_end)) # Apply start / end of the veto definer segment send = segmentlist([segment([veto_def['start'], veto_def['end']])]) flag_segments = (flag_segments.coalesce() & send) else: # Standard case just query directly. try: segs = query("https", server, ifo, name, version, 'active', int(start_time), int(end_time))[0]['active'] for rseg in segs: flag_segments.append(segment(rseg[0], rseg[1])) except Exception as e: print("Could not query flag, check name " " (%s) or times" % segment_name) raise e else: raise ValueError("Source must be dqsegdb or GWOSC." " Got {}".format(source)) return segmentlist(flag_segments).coalesce()
# plots differntial refraction relative to 4000A and 5400A (adr_plot.pdf) import numpy as np import matplotlib as mpl mpl.use('Agg') mpl.rcParams.update({'font.size': 18}) mpl.rcParams.update({'savefig.dpi': 200}) mpl.rcParams.update({'savefig.bbox': 'tight'}) import matplotlib.pyplot as plt from astropy.utils.data import download_file from astropy.utils import iers iers.IERS.iers_table = iers.IERS_A.open( download_file(iers.IERS_A_URL, cache=True)) import astropy.units as u import astropy.coordinates import astropy.time def main(): # observatory apo = astropy.coordinates.EarthLocation.of_site('apo') pressure = 72.80555 * u.kPa temperature = 15 * u.deg_C when = astropy.time.Time.now() # pointings num_alt_steps = 5
*By: Adrian Price-Whelan* *License: BSD* ------------------- """ from astropy.io import fits ############################################################################## # Download a FITS file: from astropy.utils.data import download_file fits_file = download_file( 'http://data.astropy.org/tutorials/FITS-Header/input_file.fits', cache=True) ############################################################################## # Look at contents of the FITS file fits.info(fits_file) ############################################################################## # Look at the headers of the two extensions: print("Before modifications:") print() print("Extension 0:") print(repr(fits.getheader(fits_file, 0))) print()
def _pvobs(self): '''calculates position and velocity of the observatory returns position/velocity in AU and AU/d in GCRS reference frame ''' # convert obs position from WGS84 (lat long) to ITRF geocentric coords in AU xyz = self.location.to(u.AU).value # now we need to convert this position to Celestial Coords # specifically, the GCRS coords. # conversion from celestial to terrestrial coords given by # [TRS] = RPOM * R_3(ERA) * RC2I * [CRS] # where: # [CRS] is vector in GCRS (geocentric celestial system) # [TRS] is vector in ITRS (International Terrestrial Ref System) # ERA is earth rotation angle # RPOM = polar motion matrix tt = self.tt mjd = self.utc.mjd # we need the IERS values to correct for the precession/nutation of the Earth iers_tab = IERS.open() # Find UT1, which is needed to calculate ERA # uses IERS_B by default , for more recent times use IERS_A download try: ut1 = self.ut1 except: try: iers_a_file = download_file(IERS_A_URL, cache=True) iers_a = IERS_A.open(iers_a_file) self.delta_ut1_utc = self.get_delta_ut1_utc(iers_a) ut1 = self.ut1 except: # fall back to UTC with degraded accuracy warnings.warn( 'Cannot calculate UT1: using UTC with degraded accuracy') ut1 = self.utc # Gets x,y coords of Celestial Intermediate Pole (CIP) and CIO locator s # CIO = Celestial Intermediate Origin # Both in GCRS X, Y, S = erfa.xys00a(tt.jd1, tt.jd2) # Get dX and dY from IERS B dX = np.interp(mjd, iers_tab['MJD'], iers_tab['dX_2000A']) * u.arcsec dY = np.interp(mjd, iers_tab['MJD'], iers_tab['dY_2000A']) * u.arcsec # Get GCRS to CIRS matrix # can be used to convert to Celestial Intermediate Ref Sys # from GCRS. rc2i = erfa.c2ixys(X + dX.to(u.rad).value, Y + dY.to(u.rad).value, S) # Gets the Terrestrial Intermediate Origin (TIO) locator s' # Terrestrial Intermediate Ref Sys (TIRS) defined by TIO and CIP. # TIRS related to to CIRS by Earth Rotation Angle sp = erfa.sp00(tt.jd1, tt.jd2) # Get X and Y from IERS B # X and Y are xp = np.interp(mjd, iers_tab['MJD'], iers_tab['PM_x']) * u.arcsec yp = np.interp(mjd, iers_tab['MJD'], iers_tab['PM_y']) * u.arcsec # Get the polar motion matrix. Relates ITRF to TIRS. rpm = erfa.pom00(xp.to(u.rad).value, yp.to(u.rad).value, sp) # multiply ITRF position of obs by transpose of polar motion matrix # Gives Intermediate Ref Frame position of obs x, y, z = np.array([rpmMat.T.dot(xyz) for rpmMat in rpm]).T # Functions of Earth Rotation Angle, theta # Theta is angle bewtween TIO and CIO (along CIP) # USE UT1 here. theta = erfa.era00(ut1.jd1, ut1.jd2) S, C = np.sin(theta), np.cos(theta) # Position #GOT HERE pos = np.asarray([C * x - S * y, S * x + C * y, z]).T # multiply by inverse of GCRS to CIRS matrix # different methods for scalar times vs arrays if pos.ndim > 1: pos = np.array( [np.dot(rc2i[j].T, pos[j]) for j in range(len(pos))]) else: pos = np.dot(rc2i.T, pos) # Velocity vel = np.asarray( [SR * (-S * x - C * y), SR * (C * x - S * y), np.zeros_like(x)]).T # multiply by inverse of GCRS to CIRS matrix if vel.ndim > 1: vel = np.array( [np.dot(rc2i[j].T, vel[j]) for j in range(len(pos))]) else: vel = np.dot(rc2i.T, vel) #return position and velocity return pos, vel
def _fetch_catalog_snrcat_snr_table(cache): url = "http://www.physics.umanitoba.ca/snr/SNRcat/SNRdownload.php?table=SNR" filename = download_file(url, cache=cache) # Note: currently the first line contains this comment, which we skip via `header_start=1` table = Table.read(filename, format="ascii.csv", header_start=1, delimiter=";") table.meta["url"] = url table.meta["version"] = _snrcat_parse_download_date(filename) # TODO: doesn't work properly ... don't call for now. # _snrcat_fix_na(table) table.rename_column("G", "Source_Name") table.rename_column("J2000_ra (hh:mm:ss)", "RAJ2000_str") table.rename_column("J2000_dec (dd:mm:ss)", "DEJ2000_str") data = Angle(table["RAJ2000_str"], unit="hour").deg index = table.index_column("RAJ2000_str") + 1 table.add_column(Column(data=data, name="RAJ2000", unit="deg"), index=index) data = Angle(table["DEJ2000_str"], unit="deg").deg index = table.index_column("DEJ2000_str") + 1 table.add_column(Column(data=data, name="DEJ2000", unit="deg"), index=index) radec = SkyCoord(table["RAJ2000"], table["DEJ2000"], unit="deg") galactic = radec.galactic table.add_column(Column(data=galactic.l.deg, name="GLON", unit="deg")) table.add_column(Column(data=galactic.b.deg, name="GLAT", unit="deg")) table.rename_column("age_min (yr)", "age_min") table["age_min"].unit = "year" table.rename_column("age_max (yr)", "age_max") table["age_max"].unit = "year" distance = np.mean([table["age_min"], table["age_max"]], axis=0) index = table.index_column("age_max") + 1 table.add_column(Column(distance, name="age", unit="year"), index=index) table.rename_column("distance_min (kpc)", "distance_min") table["distance_min"].unit = "kpc" table.rename_column("distance_max (kpc)", "distance_max") table["distance_max"].unit = "kpc" distance = np.mean([table["distance_min"], table["distance_max"]], axis=0) index = table.index_column("distance_max") + 1 table.add_column(Column(distance, name="distance", unit="kpc"), index=index) table.rename_column("size_radio", "diameter_radio_str") diameter_radio_mean = _snrcat_parse_diameter(table["diameter_radio_str"]) index = table.index_column("diameter_radio_str") + 1 table.add_column( Column(diameter_radio_mean, name="diameter_radio_mean", unit="arcmin"), index=index, ) table.rename_column("size_X", "diameter_xray_str") diameter_xray_mean = _snrcat_parse_diameter(table["diameter_xray_str"]) index = table.index_column("diameter_xray_str") + 1 table.add_column( Column(diameter_xray_mean, name="diameter_xray_mean", unit="arcmin"), index=index, ) table.rename_column("size_coarse (arcmin)", "diameter_mean") table["diameter_mean"].unit = "arcmin" table.rename_column("size_imprecise", "diameter_mean_is_imprecise") return table
def query_flag(ifo, segment_name, start_time, end_time, source='any', server="https://segments.ligo.org", veto_definer=None, cache=False): """Return the times where the flag is active Parameters ---------- ifo: string The interferometer to query (H1, L1). segment_name: string The status flag to query from LOSC. start_time: int The starting gps time to begin querying from LOSC end_time: int The end gps time of the query source: str, Optional Choice between "GWOSC" or "dqsegdb". If dqsegdb, the server option may also be given. The default is to try GWOSC first then try dqsegdb. server: str, Optional The server path. Only used with dqsegdb atm. veto_definer: str, Optional The path to a veto definer to define groups of flags which themselves define a set of segments. cache: bool If true cache the query. Default is not to cache Returns --------- segments: glue.segments.segmentlist List of segments """ flag_segments = segmentlist([]) if source in ['GWOSC', 'any']: # Special cases as the LOSC convention is backwards from normal # LIGO / Virgo operation!!!! if (('_HW_INJ' in segment_name and 'NO' not in segment_name) or 'VETO' in segment_name): data = query_flag(ifo, 'DATA', start_time, end_time) if '_HW_INJ' in segment_name: name = 'NO_' + segment_name else: name = segment_name.replace('_VETO', '') negate = query_flag(ifo, name, start_time, end_time, cache=cache) return (data - negate).coalesce() duration = end_time - start_time try: url = GWOSC_URL.format(get_run(start_time + duration / 2), ifo, segment_name, int(start_time), int(duration)) fname = download_file(url, cache=cache) data = json.load(open(fname, 'r')) if 'segments' in data: flag_segments = data['segments'] except Exception as e: if source != 'any': print(e) raise ValueError("Unable to find {} segments in GWOSC, check " "flag name or times".format(segment_name)) else: print("Tried and failed to find {} in GWOSC, trying dqsegdb". format(segment_name)) return query_flag(ifo, segment_name, start_time, end_time, source='dqsegdb', server=server, veto_definer=veto_definer) elif source == 'dqsegdb': # Let's not hard require dqsegdb to be installed if we never get here. try: from dqsegdb2.query import query_segments as query except ImportError: raise ValueError("Could not query flag. Install dqsegdb2" ":'pip install dqsegdb2'") # The veto definer will allow the use of MACRO names # These directly correspond to the name in the veto definer file if veto_definer is not None: veto_def = parse_veto_definer(veto_definer, [ifo]) # We treat the veto definer name as if it were its own flag and # process the flags in the veto definer if veto_definer is not None and segment_name in veto_def[ifo]: for flag in veto_def[ifo][segment_name]: partial = segmentlist([]) segs = query(ifo + ':' + flag['full_name'], int(start_time), int(end_time), host=server)['active'] # Apply padding to each segment for rseg in segs: seg_start = rseg[0] + flag['start_pad'] seg_end = rseg[1] + flag['end_pad'] partial.append(segment(seg_start, seg_end)) # Limit to the veto definer stated valid region of this flag flag_start = flag['start'] flag_end = flag['end'] # Corner case: if the flag end time is 0 it means 'no limit' # so use the query end time if flag_end == 0: flag_end = int(end_time) send = segmentlist([segment(flag_start, flag_end)]) flag_segments += (partial.coalesce() & send) else: # Standard case just query directly try: segs = query(':'.join([ifo, segment_name]), int(start_time), int(end_time), host=server)['active'] for rseg in segs: flag_segments.append(segment(rseg[0], rseg[1])) except Exception as e: print("Could not query flag, check name " "(%s) or times" % segment_name) raise e # dqsegdb output is not guaranteed to lie entirely within start # and end times, hence restrict to this range flag_segments = flag_segments.coalesce() & \ segmentlist([segment(int(start_time), int(end_time))]) else: raise ValueError("Source must be dqsegdb or GWOSC." " Got {}".format(source)) return segmentlist(flag_segments).coalesce()
""" ############################################################################## # Use `astropy.utils.data` subpackage to download the FITS file used in this # example. Also import `~astropy.table.Table` from the `astropy.table` subpackage # and `astropy.io.fits` from astropy.utils.data import download_file from astropy.table import Table from astropy.io import fits ############################################################################## # Download a FITS file event_filename = download_file('http://data.astropy.org/tutorials/FITS-tables/chandra_events.fits', cache=True) ############################################################################## # Display information about the contents of the FITS file. fits.info(event_filename) ############################################################################## # Extension 1, EVENTS, is a Table that contains information about each X-ray # photon that hit Chandra's HETG-S detector. # # Use `~astropy.table.Table` to read the table events = Table.read(event_filename, hdu=1) ##############################################################################
def fetch_fermi_catalog(catalog, extension=None): """Fetch Fermi catalog data. Reference: http://fermi.gsfc.nasa.gov/ssc/data/access/lat/. The Fermi catalogs contain the following relevant catalog HDUs: * 3FGL Catalog : LAT 4-year Point Source Catalog * ``LAT_Point_Source_Catalog`` Point Source Catalog Table. * ``ExtendedSources`` Extended Source Catalog Table. * 2FGL Catalog : LAT 2-year Point Source Catalog * ``LAT_Point_Source_Catalog`` Point Source Catalog Table. * ``ExtendedSources`` Extended Source Catalog Table. * 1FGL Catalog : LAT 1-year Point Source Catalog * ``LAT_Point_Source_Catalog`` Point Source Catalog Table. * 2FHL Catalog : Second Fermi-LAT Catalog of High-Energy Sources * ``Count Map`` AIT projection 2D count image * ``2FHL Source Catalog`` Main catalog * ``Extended Sources`` Extended Source Catalog Table * ``ROIs`` Regions of interest * 1FHL Catalog : First Fermi-LAT Catalog of Sources above 10 GeV * ``LAT_Point_Source_Catalog`` Point Source Catalog Table. * ``ExtendedSources`` Extended Source Catalog Table. * 2PC Catalog : LAT Second Catalog of Gamma-ray Pulsars * ``PULSAR_CATALOG`` Pulsar Catalog Table. * ``SPECTRAL`` Table of Pulsar Spectra Parameters. * ``OFF_PEAK`` Table for further Spectral and Flux data for the Catalog. Parameters ---------- catalog : {'3FGL', '2FGL', '1FGL', '1FHL', '2FHL', '2PC'} Specifies which catalog to display. extension : str Specifies which catalog HDU to provide as a table (optional). See list of catalog HDUs above. Returns ------- hdu_list (Default) : `~astropy.io.fits.HDUList` Catalog FITS HDU list (for access to full catalog dataset). catalog_table : `~astropy.table.Table` Catalog table for a selected hdu extension. Examples -------- >>> from gammapy.catalog import fetch_fermi_catalog >>> fetch_fermi_catalog('2FGL') [<astropy.io.fits.hdu.image.PrimaryHDU at 0x3330790>, <astropy.io.fits.hdu.table.BinTableHDU at 0x338b990>, <astropy.io.fits.hdu.table.BinTableHDU at 0x3396450>, <astropy.io.fits.hdu.table.BinTableHDU at 0x339af10>, <astropy.io.fits.hdu.table.BinTableHDU at 0x339ff10>] >>> from gammapy.catalog import fetch_fermi_catalog >>> fetch_fermi_catalog('2FGL', 'LAT_Point_Source_Catalog') <Table rows=1873 names= ... > """ BASE_URL = 'http://fermi.gsfc.nasa.gov/ssc/data/access/lat/' if catalog == '3FGL': url = BASE_URL + '4yr_catalog/gll_psc_v16.fit' elif catalog == '2FGL': url = BASE_URL + '2yr_catalog/gll_psc_v08.fit' elif catalog == '1FGL': url = BASE_URL + '1yr_catalog/gll_psc_v03.fit' elif catalog == '1FHL': url = BASE_URL + '1FHL/gll_psch_v07.fit' elif catalog == '2FHL': url = 'https://github.com/gammapy/gammapy-extra/raw/master/datasets/catalogs/fermi/gll_psch_v08.fit.gz' elif catalog == '2PC': url = BASE_URL + '2nd_PSR_catalog/2PC_catalog_v03.fits' else: ss = 'Invalid catalog: {0}\n'.format(catalog) raise ValueError(ss) filename = download_file(url, cache=True) hdu_list = fits.open(filename) if extension is None: return hdu_list # TODO: 2FHL doesn't have a 'CLASS1' column, just 'CLASS' # It's probably better if we make a `SourceCatalog` class # and then sub-class `FermiSourceCatalog` and `Fermi2FHLSourceCatalog` # and handle catalog-specific stuff in these classes, # trying to provide an as-uniform as possible API to the common catalogs. table = Table(hdu_list[extension].data) table['IS_GALACTIC'] = [_is_galactic(_) for _ in table['CLASS1']] return table
# Set up matplotlib and astropy import matplotlib.pyplot as plt from astropy.io import fits # Download the fits file from astropy.utils.data import download_file file = 'http://data.astropy.org/tutorials/FITS-images/HorseHead.fits' image = download_file(file, cache=True) # simple image grabber hdu_list = fits.open(image) hdu_list.info() new = hdu_list[0].data # show the image plt.imshow(new) plt.colorbar() plt.show()
from pathlib import Path import tarfile from astropy.utils.data import download_file # Get single images url = 'https://zenodo.org/record/3320113/files/combined_bias_100_images.fit.bz2?download=1' download = download_file(url, show_progress=True) p = Path(download) p.rename('combined_bias_100_images.fit.bz2') url = 'https://zenodo.org/record/3312535/files/dark-test-0002d1000.fit.bz2?download=1' download = download_file(url, show_progress=True) p = Path(download) p.rename('dark-test-0002d1000.fit.bz2') url = 'https://zenodo.org/record/3332818/files/combined_dark_300.000.fits.bz2?download=1' download = download_file(url, show_progress=True) p = Path(download) p.rename('combined_dark_300.000.fits.bz2') url = 'https://zenodo.org/record/4302262/files/combined_dark_exposure_1000.0.fit.bz2?download=1' download = download_file(url, show_progress=True) p = Path(download) p.rename('combined_dark_exposure_1000.0.fit.bz2') # Get the tarball for the smaller example and extract it url = 'https://zenodo.org/record/3254683/files/example-cryo-LFC.tar.bz2?download=1' download = download_file(url, show_progress=True, cache=True) tarball = tarfile.open(download) tarball.extractall('.')