コード例 #1
0
ファイル: test_jsoc.py プロジェクト: dstansby/sunpy
def test_post_wave_series(client):
    with pytest.raises(
            TypeError,
            match="The series hmi.M_45s does not support wavelength attribute."
    ):
        client.search(
            a.Time('2020/1/1T00:00:00', '2020/1/1T00:00:45'),
            a.jsoc.Series('hmi.M_45s') | a.jsoc.Series('aia.lev1_euv_12s'),
            a.Wavelength(193 * u.AA) | a.Wavelength(335 * u.AA))
コード例 #2
0
ファイル: test_jsoc.py プロジェクト: tanvimoharir/sunpy
def test_post_wavelength(client):
    responses = client.search(
        a.Time('2020/07/30T13:30:00', '2020/07/30T14:00:00'),
        a.jsoc.Series('aia.lev1_euv_12s'), a.Wavelength(193 * u.AA) |
        a.Wavelength(335 * u.AA), a.jsoc.Notify('*****@*****.**'))
    aa = client.request_data(responses)
    [r.wait() for r in aa]
    tmpresp = aa[0]._d
    assert tmpresp['protocol'] == 'fits'
    assert tmpresp['method'] == 'url'
    assert tmpresp['count'] == '302'
    tmpresp = aa[1]._d
    assert tmpresp['protocol'] == 'fits'
    assert tmpresp['method'] == 'url'
    assert tmpresp['count'] == '302'
コード例 #3
0
def get_image(t, x, y):
    """
    This function gets an AIA EUV image from the SDO (AIA = Atmospheric Imaging Assembly, EUV = Extreme UltraViolent, SDO = SOlar Dynamics Observatory)
    at a given time t, and crops the image to given location x, y.
    
    Param:
          t datetime, the datetime of the flare
          x integer, the longitude position of the flare in arcsec
          y integer, the latitude position of the flare in arcsec
    
    Return:
           aia_sub sunpy Map, the cropped image
    """

    # request the data for the given time
    result = Fido.search(a.Time(t - dt.timedelta(seconds=10), t),
                         a.Instrument("aia"), a.Wavelength(94 * u.angstrom),
                         a.vso.Sample(12 * u.second))
    print('found result')
    #print(result)

    # download the data
    file_download = Fido.fetch(result[0, -1], site='ROB')
    print('downloaded data')
    #print(file_download)

    # load the data to a sun map
    aia1 = sunpy.map.Map(file_download)
    print('loaded to sun map')
    #print(aia1)

    # calibrate it
    aia = aiaprep(aia1)
    print('calibrated')

    # plot it
    aia.plot()
    plt.colorbar()
    #plt.show()

    # get the co-ordinates of the top right and bottom left of the crop box
    co_ords = get_box_coord(x, y, 100)
    tr = co_ords[1]
    bl = co_ords[2]

    # sub-map
    top_right = SkyCoord(tr[0] * u.arcsec,
                         tr[1] * u.arcsec,
                         frame=aia.coordinate_frame)
    bottom_left = SkyCoord(bl[0] * u.arcsec,
                           bl[1] * u.arcsec,
                           frame=aia.coordinate_frame)
    aia_sub = aia.submap(top_right, bottom_left)
    aia_sub.plot_settings['cmap'] = plt.get_cmap('Greys_r')
    ax = plt.subplot(projection=aia_sub)
    aia_sub.plot()
    #plt.show()
    print('made sub map')

    return aia_sub
コード例 #4
0
def qr_block_with_missing_physobs():
    return vso.VSOClient().search(
        net_attrs.Time('20130805T120000', '20130805T121000'),
        net_attrs.Instrument('SWAVES'), net_attrs.Source('STEREO_A'),
        net_attrs.Provider('SSC'), net_attrs.Wavelength(
            10 * u.kHz, 160 * u.kHz),
        response_format="legacy")[0]
コード例 #5
0
ファイル: wind.py プロジェクト: sunpy/radiospectra
    def _check_wavelengths(cls, wavelength):
        """
        Check for overlap between given wavelength and receiver frequency coverage defined in
        `RECEIVER_FREQUENCIES`.

        Parameters
        ----------
        wavelength : `sunpy.net.attrs.Wavelength`
            Input wavelength range to check

        Returns
        -------
        `list`
            List of receivers names or empty list if no overlap
        """
        # Input wavelength range is completely contained in one receiver range
        receivers = [
            k for k, v in RECEIVER_FREQUENCIES.items() if wavelength in v
        ]
        # If not defined need to continue
        if not receivers:
            # Overlaps but not contained in, either max in lfr or min hfr
            if wavelength.min in RECEIVER_FREQUENCIES['rad2'] or \
                    wavelength.max in RECEIVER_FREQUENCIES['rad2']:
                receivers.append('rad2')
            if wavelength.min in RECEIVER_FREQUENCIES['rad1'] or \
                    wavelength.max in RECEIVER_FREQUENCIES['rad1']:
                receivers.append('rad1')
            # min in lfr and max in hfr
            # min and max of combined lft and hfr contained in give wavelength range
            if a.Wavelength(RECEIVER_FREQUENCIES['rad1'].min,
                            RECEIVER_FREQUENCIES['rad2'].max) in wavelength:
                receivers = ['rad1', 'rad2']
            # If we get here the is no overlap so set to empty list
        return receivers
コード例 #6
0
def download_and_gen_carrmap(dt, resample_size=None):
    # Saves fits files to ~/sunpy/data
    stereoA = (a.vso.Source('STEREO_A') & a.Instrument('EUVI') & a.Time(
        time_string(dt), time_string(dt + timedelta(minutes=60))))
    stereoB = (a.vso.Source('STEREO_B') & a.Instrument('EUVI') & a.Time(
        time_string(dt), time_string(dt + timedelta(minutes=60))))
    aia = (a.Instrument('AIA')
           & a.Time(time_string(dt), time_string(dt + timedelta(minutes=60))))
    wave = a.Wavelength(19 * u.nm, 20 * u.nm)
    res = Fido.search(wave, aia | stereoA | stereoB)
    files = []
    for jj in range(len(res)):
        try:
            files.append(Fido.fetch(res[jj, 0]))
        except:
            ""

    maps = [m for m in sunpy.map.Map(files)]
    carrmaps = [
        get_carr_map(map_, resample_size=resample_size) for map_ in maps
    ]

    lons, lats = carrmaps[0][0:2]

    # Quick process maps to have same floor value (0) and same median
    quick_procs_list = []
    for arr in carrmaps[:]:
        arr = arr[2]
        quick_proc = arr - np.nanmin(arr)
        quick_procs_list.append(quick_proc / np.nanmedian(quick_proc))

    combined = np.nanmean(np.array(quick_procs_list), axis=0)

    return lons, lats, combined, maps
コード例 #7
0
def loadData(s_map: Map):
    query = Fido.search(attrs.Time(s_map.tstart.isoformat(), s_map.tstart.isoformat()),
                        attrs.Instrument(s_map.instrument), attrs.Wavelength(s_map.wavelength * u.AA))
    query = query[0, 0]
    if not s_map.id.startswith(list(query.responses)[0][0].fileid):
        raise Exception("ERROR: invalid search result encountered!")
    return Fido.fetch(query, progress=True)
コード例 #8
0
def test_rstn(parse_path_moc):
    start_time = Time('2020-01-01T06:17:38.000')
    end_time = Time('2020-01-01T15:27:43.000')
    meta = {
        'instrument': 'RSTN',
        'observatory': 'San Vito',
        'start_time': start_time,
        'end_time': end_time,
        'detector': 'RSTN',
        'wavelength': a.Wavelength(25000.0 * u.kHz, 180000.0 * u.kHz),
        'freqs': np.concatenate([np.linspace(25, 75, 401), np.linspace(75, 180, 401)])*u.MHz,
        'times': start_time + np.linspace(0, (end_time-start_time).to_value('s'), 11003)*u.s
    }
    array = np.zeros((802, 11003))
    parse_path_moc.return_value = [(array, meta)]
    file = Path('fakes.srs')
    spec = Spectrogram(file)
    assert isinstance(spec, RSTNSpectrogram)
    assert spec.observatory == 'SAN VITO'
    assert spec.instrument == 'RSTN'
    assert spec.detector == 'RSTN'
    assert spec.start_time.datetime == datetime(2020, 1, 1, 6, 17, 38)
    assert spec.end_time.datetime == datetime(2020, 1, 1, 15, 27, 43)
    assert spec.wavelength.min == 25000 * u.kHz
    assert spec.wavelength.max == 180000 * u.kHz
コード例 #9
0
def test_get_url_for_time_range(LCClient, timerange, url_start, url_end):
    with mock.patch('sunpy.net.dataretriever.sources.norh.NoRHClient.search',
                    return_value=mock_query_object(timerange)):
        qresponse = LCClient.search(timerange, a.Wavelength(17 * u.GHz))
        assert isinstance(qresponse, QueryResponse)
        urls = [i['url'] for i in qresponse]
        assert urls[0] == url_start
コード例 #10
0
def download(dtime, dt, dir_path, *args):
    """
    Description:
              download fits files for specified time window and wavelength channels
              from the VSO


    dtime:    should be a datetime object. EX: datetime(2010, 6, 13, 5, 25, 0)
    dt:       should be a time delta object in correct units. EX: timedelta(seconds=6)
    dir_path: path to directory for storing fits files
    *argv:    wavelength channels you want fits files for. EX: 193, 211, etc... 
    """


    sform = '%Y/%m/%d %H:%M:%S'  # format datetime objects correctly

    start = datetime.strftime(dtime-dt, sform)
    end = datetime.strftime(dtime+dt, sform)

    time = attrs.Time(start, end)
    ins = attrs.Instrument('aia') 


    for thing in args:
        print("Downloading {} angstrom data\n".format(thing)) 
        wave = attrs.Wavelength(int(thing)*u.AA)
        searchResults = Fido.search(time, ins, wave)

        for file_ in searchResults:
            print("{}".format(file_))

        dl_fil = Fido.fetch(searchResults, path=dir_path, wait=True) 
コード例 #11
0
ファイル: hek2vso.py プロジェクト: tanvimoharir/sunpy
def vso_attribute_parse(phrase):
    """
    Parses VSO attributes from a HEK result.

    This is a simple function to parse HEK query result and generate a list
    containing VSO relevant attributes.

    Parameters
    ----------
    phrase : `sunpy.net.hek.hek.HEKRow`.
        The single HEK result to be parsed for VSO attribute data.

    Examples
    --------
    >>> from sunpy.net import attrs as a
    >>> from sunpy.net.hek import hek, HEKClient
    >>> from sunpy.net.hek2vso import hek2vso, H2VClient
    >>> h = HEKClient()  # doctest: +REMOTE_DATA
    >>> h2v = H2VClient()  # doctest: +REMOTE_DATA
    >>> q = h.search(a.Time('2011/08/09 07:23:56', '2011/08/09 12:40:29'), a.hek.EventType('FL'))  # doctest: +REMOTE_DATA
    >>> len(q)  # doctest: +REMOTE_DATA
    19
    >>> hek2vso.vso_attribute_parse(q[9])  # doctest: +REMOTE_DATA
    [<sunpy.net.attrs.Time(2011-08-09 07:22:38.000, 2011-08-09 08:32:02.000)>, <sunpy.net.attrs.Source(SDO: The Solar Dynamics Observatory.) object at ...>, <sunpy.net.attrs.Instrument(AIA: Atmospheric Imaging Assembly) object at ...>, <sunpy.net.attrs.Wavelength(210.99999999999997, 210.99999999999997, 'Angstrom')>]
    """
    try:
        query = [a.Time(phrase['event_starttime'],
                        phrase['event_endtime']),
                 a.Source(phrase['obs_observatory']),
                 a.Instrument(phrase['obs_instrument'])]
        avg_wave_len = phrase['obs_meanwavel'] * units.Unit(phrase['obs_wavelunit'])
        query.append(a.Wavelength(avg_wave_len, avg_wave_len))
    except (KeyError, TypeError):
        raise TypeError("'{dtype!s}' is an improper data type".format(dtype=type(phrase)))
    return query
コード例 #12
0
ファイル: dlSunImage.py プロジェクト: aldebaran1/pyEclipse
def dlSun(tlim: Union[list, ndarray] = [],
          instrument: str = 'aia',
          wl: int = 193,
          odir: str = '',
          first: bool = False):

    assert isinstance(tlim[0], str), 'time limits must be stings'
    tlim = array(tlim) if isinstance(tlim, list) else tlim
    assert tlim.shape[
        0] == 2, 'tlim must have length of 2 (start, stop) (yyyy/mm/dd hh:mm)'

    if odir == "":
        odir = os.path.join(
            'C:\\Users\\smrak\\Google Drive\\BU\\Projects\\Eclipse-Nsf\\data\\',
            instrument, "")
    if not os.path.exists(odir):
        call('mkdir "{}"'.format(odir), shell=True)

    attrs_time = a.Time(tlim[0], tlim[1])

    result = Fido.search(attrs_time, a.Instrument(instrument),
                         a.Wavelength(wl * u.angstrom))

    if first:
        print('Downloading to {}:'.format(odir))
        print(result[0, 0])
        Fido.fetch(result[0, 0], path=odir)
    else:
        print('Downloading {} elements.... to {}:'.format(
            result.file_num, odir))
        print(result)
        Fido.fetch(result, path=odir)
    print('Downloading complete.')
コード例 #13
0
def test_tables_all_types():
    # Data retriver response objects
    drclient = Fido.search(
        a.Time('2012/3/4', '2012/3/6'),
        a.Instrument('lyra') |
        (a.Instrument('rhessi') & a.Physobs("summary_lightcurve")))
    drtables = drclient.tables
    assert isinstance(drtables, list)
    assert isinstance(drtables[0], Table)

    # VSO response objects
    vsoclient = Fido.search(a.Time('2011-06-07 06:33', '2011-06-07 06:33:08'),
                            a.Instrument('aia'), a.Wavelength(171 * u.AA))
    vsotables = vsoclient.tables
    assert isinstance(vsotables, list)
    assert isinstance(vsotables[0], Table)

    # JSOC response objects
    jsocclient = Fido.search(
        a.Time('2014-01-01T00:00:00', '2014-01-01T01:00:00'),
        a.jsoc.Series('hmi.v_45s'), a.jsoc.Notify('*****@*****.**'))
    jsoctables = jsocclient.tables

    assert isinstance(jsoctables, list)
    assert isinstance(jsoctables[0], Table)
コード例 #14
0
ファイル: test_goes_suvi.py プロジェクト: thilak007/sunpy
def test_fetch_working(suvi_client):
    """
    Tests if the online server for fermi_gbm is working.
    This also checks if the mock is working well.
    """
    start = '2019/05/25 00:50'
    end = '2019/05/25 00:52'
    wave = 94 * u.Angstrom
    qr1 = suvi_client.search(a.Time(start, end), a.Instrument.suvi,
                             a.Wavelength(wave))

    # Mock QueryResponse object
    mock_qr = mock_querry_object(suvi_client, start, end, wave)

    # Compare if two objects have the same attribute

    mock_qr = mock_qr.blocks[0]
    qr = qr1.blocks[0]

    assert mock_qr.source == qr.source
    assert mock_qr.provider == qr.provider
    assert mock_qr.physobs == qr.physobs
    assert mock_qr.instrument == qr.instrument
    assert mock_qr.url == qr.url

    assert qr1.time_range() == TimeRange("2019-05-25T00:52:00.000",
                                         "2019-05-25T00:56:00.000")

    with tempfile.TemporaryDirectory() as tmpdirname:
        download_list = suvi_client.fetch(qr1, path=tmpdirname)
    assert len(download_list) == len(qr1)
コード例 #15
0
ファイル: test_goes_suvi.py プロジェクト: yukienomiya/sunpy
def test_fetch_working(suvi_client):
    """
    Tests if the online server for goes_suvi is working.
    This also checks if the mock is working well.
    """
    start = '2019/05/25 00:50'
    end = '2019/05/25 00:52'
    wave = 94 * u.Angstrom
    goes_sat = a.goes.SatelliteNumber.sixteen
    tr = a.Time(start, end)
    qr1 = suvi_client.search(tr, a.Instrument.suvi, a.Wavelength(wave),
                             goes_sat, a.Level(2))

    # Mock QueryResponse object
    mock_qr = mock_query_object(suvi_client)

    # Compare if two objects have the same attribute

    mock_qr = mock_qr[0]
    qr = qr1[0]

    assert mock_qr['Source'] == qr['Source']
    assert mock_qr['Provider'] == qr['Provider']
    assert mock_qr['Physobs'] == qr['Physobs']
    assert mock_qr['Instrument'] == qr['Instrument']
    assert mock_qr['url'] == qr['url']

    assert qr1['Start Time'] == Time("2019-05-25T00:52:00.000")
    assert qr1['End Time'] == Time("2019-05-25T00:56:00.000")

    with tempfile.TemporaryDirectory() as tmpdirname:
        download_list = suvi_client.fetch(qr1, path=tmpdirname)
    assert len(download_list) == len(qr1)
コード例 #16
0
ファイル: test_goes_suvi.py プロジェクト: yukienomiya/sunpy
def test_fido_waverange_level1b(start, end, wave1, wave2, expected_num_files):
    """check that we get all wavelengths if no wavelength is given"""
    goes_sat = a.goes.SatelliteNumber.sixteen
    result = Fido.search(a.Time(start, end), a.Instrument.suvi, goes_sat,
                         a.Wavelength(wave1 * u.Angstrom, wave2 * u.Angstrom),
                         a.Level('1b'))
    assert result.file_num == expected_num_files
コード例 #17
0
def test_jsoc_cutout_attrs(client):
    m_ref = sunpy.map.Map(
        sunpy.data.test.get_test_filepath('aia_171_level1.fits'))
    cutout = a.jsoc.Cutout(SkyCoord(-500 * u.arcsec,
                                    -275 * u.arcsec,
                                    frame=m_ref.coordinate_frame),
                           top_right=SkyCoord(150 * u.arcsec,
                                              375 * u.arcsec,
                                              frame=m_ref.coordinate_frame),
                           tracking=True)
    q = client.search(
        a.Time(m_ref.date, m_ref.date + 1 * u.min),
        a.Wavelength(171 * u.angstrom),
        a.jsoc.Series.aia_lev1_euv_12s,
        a.jsoc.Notify('*****@*****.**'),  # Put your email here
        a.jsoc.Segment.image,
        cutout,
    )
    req = client.request_data(q, method='url', protocol='fits')
    req.wait()
    assert req.status == 0
    files = client.get_request(req, max_conn=2)
    assert len(files) == 6
    m = sunpy.map.Map(files, sequence=True)
    assert m.all_maps_same_shape()
    assert m.as_array().shape == (1085, 1085, 6)
コード例 #18
0
ファイル: test_psp_rfs.py プロジェクト: sunpy/radiospectra
def test_psp_rfs_lfr(parse_path_moc):
    start_time = Time('2019-04-09 00:01:16.197889')
    end_time = Time('2019-04-10 00:01:04.997573')
    meta = {
        'cdf_meta': {
            'TITLE': 'PSP FIELDS RFS LFR data',
            'Project': 'PSP',
            'Source_name': 'PSP_FLD>Parker Solar Probe FIELDS',
            'Descriptor': 'RFS_LFR>Radio Frequency Spectrometer LFR',
            'Data_type': 'L2>Level 2 Data',
            'Data_version': '01',
            'MODS': 'Revision 1',
            'Logical_file_id': 'psp_fld_l2_rfs_lfr_20190409_v01',
            'Mission_group': 'PSP'
        },
        'detector':
        'lfr',
        'instrument':
        'FIELDS/RFS',
        'observatory':
        'PSP',
        'start_time':
        start_time,
        'end_time':
        end_time,
        'wavelength':
        a.Wavelength(10.546879882812501 * u.kHz, 1687.5 * u.kHz),
        'times':
        start_time +
        np.linspace(0, (end_time - start_time).to_value('s'), 12359) * u.s,
        'freqs': [
            10546.88, 18750., 28125., 37500., 46875., 56250., 65625., 75000.,
            84375., 89062.5, 94921.88, 100781.25, 106640.62, 112500.,
            118359.38, 125390.62, 132421.88, 140625., 146484.38, 157031.25,
            166406.25, 175781.25, 186328.12, 196875., 208593.75, 220312.5,
            233203.12, 247265.62, 261328.12, 276562.5, 292968.75, 309375.,
            328125., 346875., 366796.88, 387890.62, 411328.12, 434765.62,
            459375., 486328.12, 514453.12, 544921.9, 576562.5, 609375.,
            645703.1, 682031.25, 721875., 764062.5, 808593.75, 855468.75,
            904687.5, 957421.9, 1013671.9, 1072265.6, 1134375., 1196484.4,
            1265625., 1312500., 1368750., 1425000., 1481250., 1565625.,
            1621875., 1687500.
        ] * u.Hz
    }
    array = np.zeros((64, 12359))
    parse_path_moc.return_value = [(array, meta)]
    file = Path('fake.cdf')
    spec = Spectrogram(file)
    assert isinstance(spec, RFSSpectrogram)
    assert spec.observatory == 'PSP'
    assert spec.instrument == 'FIELDS/RFS'
    assert spec.detector == 'LFR'
    # TODO check why not exact prob base on spacecrast ET so won't match utc exacly
    assert spec.start_time.datetime == datetime(2019, 4, 9, 0, 1, 16, 197889)
    assert spec.end_time.datetime == datetime(2019, 4, 10, 0, 1, 4, 997573)
    assert spec.wavelength.min.round(1) == 10.5 * u.kHz
    assert spec.wavelength.max == 1687.5 * u.kHz
    assert spec.level == 'L2'
    assert spec.version == 1
コード例 #19
0
ファイル: test_psp_rfs.py プロジェクト: sunpy/radiospectra
def test_psp_rfs_hfr(parse_path_moc):
    start_time = Time('2019-04-09 00:01:13.904188')
    end_time = Time('2019-04-10 00:01:02.758315')
    meta = {
        'cdf_meta': {
            'TITLE': 'PSP FIELDS RFS HFR data',
            'Project': 'PSP',
            'Source_name': 'PSP_FLD>Parker Solar Probe FIELDS',
            'Descriptor': 'RFS_HFR>Radio Frequency Spectrometer HFR',
            'Data_type': 'L2>Level 2 Data',
            'Data_version': '01',
            'MODS': 'Revision 1',
            'Logical_file_id': 'psp_fld_l2_rfs_lfr_20190409_v01',
            'Mission_group': 'PSP'
        },
        'detector':
        'hfr',
        'instrument':
        'FIELDS/RFS',
        'observatory':
        'PSP',
        'start_time':
        start_time,
        'end_time':
        end_time,
        'wavelength':
        a.Wavelength(1275.0 * u.kHz, 19171.876 * u.kHz),
        'times':
        start_time +
        np.linspace(0, (end_time - start_time).to_value('s'), 12359) * u.s,
        'freqs': [
            1275000., 1321875., 1378125., 1425000., 1471875., 1575000.,
            1621875., 1678125., 1771875., 1828125., 1921875., 2025000.,
            2128125., 2221875., 2278125., 2371875., 2521875., 2625000.,
            2728125., 2878125., 2971875., 3121875., 3271875., 3375000.,
            3525000., 3721875., 3871875., 4021875., 4228125., 4425000.,
            4575000., 4771875., 5025000., 5221875., 5475000., 5728125.,
            5971875., 6225000., 6478125., 6778125., 7078125., 7425000.,
            7725000., 8071875., 8428125., 8821875., 9178125., 9571875.,
            10021875., 10471875., 10921875., 11428125., 11925000., 12421875.,
            13021875., 13575000., 14175000., 14821875., 15478125., 16125000.,
            16875000., 17625000., 18375000., 19171876.
        ] * u.Hz
    }
    array = np.zeros((64, 12359))
    parse_path_moc.return_value = [(array, meta)]
    file = Path('fake.cdf')
    spec = Spectrogram(file)
    assert isinstance(spec, RFSSpectrogram)
    assert spec.observatory == 'PSP'
    assert spec.instrument == 'FIELDS/RFS'
    assert spec.detector == 'HFR'
    # TODO check why not exact prob base on spacecrast ET so won't match utc exacly
    assert spec.start_time.datetime == datetime(2019, 4, 9, 0, 1, 13, 904188)
    assert spec.end_time.datetime == datetime(2019, 4, 10, 0, 1, 2, 758315)
    assert spec.wavelength.min == 1275.0 * u.kHz
    assert spec.wavelength.max == 19171.876 * u.kHz
    assert spec.level == 'L2'
    assert spec.version == 1
コード例 #20
0
ファイル: norh.py プロジェクト: wtbarnes/sunpy
 def pre_search_hook(cls, *args, **kwargs):
     """
     Converts the wavelength specified in the query to its
     representation in the url which can be used by the scraper.
     """
     d = cls._get_match_dict(*args, **kwargs)
     waverange = a.Wavelength(34 * u.GHz, 17 * u.GHz)
     req_wave = d.get('Wavelength', waverange)
     wmin = req_wave.min.to(u.GHz, equivalencies=u.spectral())
     wmax = req_wave.max.to(u.GHz, equivalencies=u.spectral())
     req_wave = a.Wavelength(wmin, wmax)
     d['Wavelength'] = []
     if 17 * u.GHz in req_wave:
         d['Wavelength'].append('tca')
     if 34 * u.GHz in req_wave:
         d['Wavelength'].append('tcz')
     return cls.baseurl, cls.pattern, d
コード例 #21
0
def test_can_handle_query(LCClient, time):
    ans1 = LCClient._can_handle_query(time, a.Instrument.norh)
    assert ans1 is True
    ans1 = LCClient._can_handle_query(time, a.Instrument.norh,
                                      a.Wavelength(10 * u.GHz))
    assert ans1 is True
    ans2 = LCClient._can_handle_query(time)
    assert ans2 is False
コード例 #22
0
ファイル: test_jsoc.py プロジェクト: tanvimoharir/sunpy
def test_search_metadata(client):
    with pytest.raises(SunpyDeprecationWarning):
        metadata = client.search_metadata(a.Time('2020-01-01T00:00:00', '2020-01-01T00:02:00'),
                                          a.jsoc.Series('aia.lev1_euv_12s'), a.Wavelength(304*u.AA))
        assert isinstance(metadata, pd.DataFrame)
        assert metadata.shape == (11, 176)
        for i in metadata.index.values:
            assert (i.startswith('aia.lev1_euv_12s') and i.endswith('[304]'))
コード例 #23
0
ファイル: test_goes_suvi.py プロジェクト: thilak007/sunpy
def test_can_handle_query(suvi_client, time):
    ans1 = suvi_client._can_handle_query(time, a.Instrument.suvi)
    assert ans1 is True
    ans2 = suvi_client._can_handle_query(time, a.Instrument.suvi,
                                         a.Wavelength(131 * u.Angstrom))
    assert ans2 is True
    ans3 = suvi_client._can_handle_query(time, a.Instrument.suvi,
                                         a.Wavelength(131 * u.Angstrom),
                                         a.Level.two)
    assert ans3 is True
    ans4 = suvi_client._can_handle_query(time)
    assert ans4 is False
    ans5 = suvi_client._can_handle_query(time, a.Instrument.aia)
    assert ans5 is False
    ans6 = suvi_client._can_handle_query(time, a.Instrument.suvi,
                                         a.goes.SatelliteNumber(16))
    assert ans6 is True
コード例 #24
0
def test_response_block_properties(client):
    res = client.search(a.Time('2020/3/4', '2020/3/6'),
                        a.Instrument('aia'),
                        a.Wavelength(171 * u.angstrom),
                        a.Sample(10 * u.minute),
                        response_format="legacy")
    properties = res.response_block_properties()
    assert len(properties) == 0
コード例 #25
0
def test_can_handle_query(time):
    ans1 = norh.NoRHClient._can_handle_query(time, a.Instrument('norh'))
    assert ans1 is True
    ans1 = norh.NoRHClient._can_handle_query(time, a.Instrument('norh'),
                                             a.Wavelength(10 * u.GHz))
    assert ans1 is True
    ans2 = norh.NoRHClient._can_handle_query(time)
    assert ans2 is False
コード例 #26
0
ファイル: test_fido.py プロジェクト: yashrsharma44/sunpy
def online_query(draw, instrument=online_instruments()):
    query = draw(instrument)

    if isinstance(query, a.Instrument) and query.value == 'eve':
        query &= a.Level(0)
    if isinstance(query, a.Instrument) and query.value == 'norh':
        query &= a.Wavelength(17 * u.GHz)

    return query
コード例 #27
0
ファイル: test_goes_suvi.py プロジェクト: yukienomiya/sunpy
def test_get_url_for_time_range_level2(suvi_client, start, end, wave,
                                       expected_num_files):
    goes_sat = a.goes.SatelliteNumber.sixteen
    qresponse = suvi_client.search(a.Time(start, end),
                                   a.Wavelength(wave * u.Angstrom), goes_sat,
                                   a.Level(2))
    urls = [i['url'] for i in qresponse]
    assert isinstance(urls, list)
    assert len(urls) == expected_num_files
コード例 #28
0
ファイル: test_vso.py プロジェクト: gvvynplaine/sunpy
def test_vso_post_search(client):
    timerange = a.Time(('2020-01-01 00:01:05'), ('2020-01-01 00:01:10'))
    results = client.search(timerange, a.Instrument('aia') | a.Instrument('hmi'))
    trange_filter = a.Time(('2020-01-01 00:01:05'), ('2020-01-01 00:01:07'))
    wave_filter = a.Wavelength(131 * u.Angstrom)
    res_filtered = results.search(trange_filter & a.Instrument('aia') & wave_filter)
    for rec in res_filtered:
        assert parse_time(rec.time.start) <= parse_time(trange_filter.end)
        assert rec.instrument.lower() == 'aia'
        assert (float(rec.wave.wavemax) == 131.0 or float(rec.wave.wavemin) == 131.0)
コード例 #29
0
def test_can_handle_query(time):
    # Don't use the fixture, as hypothesis complains
    suvi_client = goes.SUVIClient()
    ans1 = suvi_client._can_handle_query(time, a.Instrument.suvi)
    assert ans1 is True
    ans2 = suvi_client._can_handle_query(time, a.Instrument.suvi,
                                         a.Wavelength(131 * u.Angstrom))
    assert ans2 is True
    ans3 = suvi_client._can_handle_query(time, a.Instrument.suvi,
                                         a.Wavelength(131 * u.Angstrom),
                                         a.Level.two)
    assert ans3 is True
    ans4 = suvi_client._can_handle_query(time)
    assert ans4 is False
    ans5 = suvi_client._can_handle_query(time, a.Instrument.aia)
    assert ans5 is False
    ans6 = suvi_client._can_handle_query(time, a.Instrument.suvi,
                                         a.goes.SatelliteNumber(16))
    assert ans6 is True
コード例 #30
0
ファイル: test_tables.py プロジェクト: vn-ki/sunpy
def fido_search_result():
    # A search query with responses from all instruments
    # No JSOC query
    return Fido.search(
        net_attrs.Time("2012/1/1", "2012/1/2"),
        net_attrs.Instrument('lyra') | net_attrs.Instrument('eve')
        | net_attrs.Instrument('XRS') | net_attrs.Instrument('noaa-indices')
        | net_attrs.Instrument('noaa-predict') |
        (net_attrs.Instrument('norh') & net_attrs.Wavelength(17 * u.GHz))
        | net_attrs.Instrument('rhessi') |
        (net_attrs.Instrument('EVE') & net_attrs.Level(0)))