Beispiel #1
0
    def __init__(self, start, end, near=None):
        self.start = anytim(start)
        self.end = anytim(end)
        self.near = None if near is None else anytim(near)

        _Range.__init__(self, start, end, self.__class__)
        Attr.__init__(self)
Beispiel #2
0
def test_anytim_ISO():
    assert util.anytim('1966-02-03') == LANDING
    assert (
        util.anytim('1966-02-03T20:17:40') == datetime(1966, 2, 3, 20, 17, 40)
    )
    assert (
        util.anytim('19660203T201740') == datetime(1966, 2, 3, 20, 17, 40)
    )
    
    lst = [
        ('2007-05-04T21:08:12.999999', datetime(2007, 5, 4, 21, 8, 12, 999999)),
        ('20070504T210812.999999', datetime(2007, 5, 4, 21, 8, 12, 999999)),
        ('2007/05/04 21:08:12.999999', datetime(2007, 5, 4, 21, 8, 12, 999999)),
        ('2007-05-04 21:08:12.999999', datetime(2007, 5, 4, 21, 8, 12, 999999)),
        ('2007/05/04 21:08:12', datetime(2007, 5, 4, 21, 8, 12)),
        ('2007-05-04 21:08:12', datetime(2007, 5, 4, 21, 8, 12)),
        ('2007-05-04 21:08', datetime(2007, 5, 4, 21, 8)),
        ('2007-05-04T21:08:12', datetime(2007, 5, 4, 21, 8, 12)),
        ('20070504T210812', datetime(2007, 5, 4, 21, 8, 12)),
        ('2007-May-04 21:08:12', datetime(2007, 5, 4, 21, 8, 12)),
        ('2007-May-04 21:08', datetime(2007, 5, 4, 21, 8)),
        ('2007-May-04', datetime(2007, 5, 4)),
        ('2007-05-04', datetime(2007, 5, 4)),
        ('2007/05/04', datetime(2007, 5, 4)),
        ('20070504_210812', datetime(2007, 5, 4, 21, 8, 12)),
    ]
    
    for k, v in lst:
        assert util.anytim(k) == v
Beispiel #3
0
 def get_properties(cls, header):
     """Returns the default and normalized values to use for the Map"""
     properties = BaseMap.get_properties()
     properties.update({
         'date': util.anytim(header.get('date_obs')),
         'det': header.get('telescop'),
         'inst': header.get('telescop'),
         'meas': [header.get('energy_l'), header.get('energy_h')],
         'obs': header.get('telescop'),
         'name': "RHESSI " + str(header.get('energy_l')) + '-' + 
                 str(header.get('energy_h')) + ' keV',
         'cmap': cm.get_cmap(name = 'rhessi'),
         'exptime': (util.anytim(header.get('date_end')) - 
                     util.anytim(header.get('date_obs'))).seconds
     })
     return properties
Beispiel #4
0
    def download(self):
        """ Function to download LYRA data, and/or set the filename where it can be found"""

        self.time = anytim(self.time)

        # date-based subdirectory
        dateLocation = self.time.strftime('%Y/%m/%d/')

        # date-based filename
        dateFilename = self.time.strftime('%Y%m%d-')

        # extension to the file name
        extension = '000000_lev'+ str(self.level) + '_' + self.dataType + '.fits'

        # calculated file name
        requestedLocation = self.location + dateLocation
        requestedFile  = self.prefix + dateFilename + extension

        f = os.path.expanduser(self.downloadto) + os.sep + requestedFile

        isAlreadyThere = os.path.isfile(f)

        if isAlreadyThere:
            if self.verbose:
                print('File '+ f + ' already exists.')
            self.filename = f
        else:
            self.filename = wgetDownload(requestedLocation,requestedFile, self.downloadto)
Beispiel #5
0
 def __init__(self, a, b = None):
     if b is None:
         if isinstance(a[0],str) or isinstance(a[0], float):
             self.t1 = anytim(a[0])
         if isinstance(a[1],str) or isinstance(a[1], float):
             self.t2 = anytim(a[1])
         if type(a[1]) == type(datetime.timedelta(1)):
             self.t2 = self.t1 + a[1]
         if isinstance(a[1], int):
             self.t2 = self.t1 + datetime.timedelta(0,a[1])                
     else:            
         if isinstance(a,str) or isinstance(a, float):
             self.t1 = anytim(a)
         if isinstance(b,str) or isinstance(b, float):
             self.t2 = anytim(b)
         if type(b) == type(datetime.timedelta(1)):
             self.t2 = self.t1 + b
         if isinstance(b, int):
             self.t2 = self.t1 + datetime.timedelta(0,b) 
     self.dt = self.t2 - self.t1
Beispiel #6
0
 def __init__(self,time):
     self.verbose = False
     self.filename = None
     self.data = None
     self.columns = None
     self.level = 2
     self.dataType = 'std'
     self.downloadto = os.path.expanduser('~')+os.sep
     self.location = 'http://proba2.oma.be/lyra/data/bsd/'
     self.prefix = 'lyra_'
     self.time = anytim(time)
     self.tstart = self.time
     self.tend = self.tstart + datetime.timedelta(days = 1)
     self.nt = None
Beispiel #7
0
 def get_properties(cls, header):
     """Returns the default and normalized values to use for the Map"""
     # Note: Trailing "Z" in date was dropped on 2010/12/07        
     properties = BaseMap.get_properties()
     properties.update({
         'date': util.anytim(header['date-obs'][0:22]),
         'det': "AIA",
         'inst': "AIA",
         'meas': header['wavelnth'],
         'obs': "SDO",
         'name': "AIA %s" % header['wavelnth'],
         'cmap': cm.get_cmap(name = 'sdoaia' + str(header['wavelnth']))
     })
     return properties
Beispiel #8
0
 def get_properties(cls, header):
     """Returns the default and normalized values to use for the Map"""
     properties = BaseMap.get_properties()
     properties.update({
         'date': util.anytim(header.get('date_obs')),
         'det': header.get('telescop'),
         'inst': header.get('telescop'),
         'meas': [header.get('energy_l'), header.get('energy_h')],
         'obs': header.get('telescop'),
         'name': "RHESSI " + str(header.get('energy_l')) + '-' + str(header.get('energy_h')) + ' keV',
         'cmap': cm.get_cmap(name = 'rhessi'),
         # 'norm': mpl.colors.Normalize(vmin=cls.min(), vmax=cls.max())
     })
     return properties
Beispiel #9
0
    def get_properties(cls, header):
        """Returns the default and normalized values to use for the Map"""
        datestr = "%sT%s" % (header['date_obs'], header['time_obs'])

        properties = BaseMap.get_properties()
        properties.update({
            "date": util.anytim(datestr),
            "det": header.get('detector'),
            "inst": "LASCO",
            "meas": header.get('wavelnth'),
            "obs": "SOHO",
            "name": "LASCO %s" % header.get('detector'),
            "exptime": header.get("exptime"),
        })
        return properties
Beispiel #10
0
 def get_properties(cls, header):
     """Returns the default and normalized values to use for the Map"""
     # Note: Trailing "Z" in date was dropped on 2010/12/07    
     meas = header['content'].split(" ")[0].lower()
     
     properties = BaseMap.get_properties()
     properties.update({
         "date": util.anytim(header.get('date-obs')),
         "det": "HMI",
         "inst": "HMI",
         "meas": meas,
         "obs": "SDO",
         "name": "HMI %s" % meas,
         "exptime": header.get('exptime')
     })
     return properties
Beispiel #11
0
 def get_properties(cls, header):
     """Returns the default and normalized values to use for the Map"""
     #date_format = "%Y-%m-%dT%H:%M:%S.%fZ"
     
     properties = BaseMap.get_properties()
     properties.update({
         "date": util.anytim(header.get('date_obs')),
         "det": "EIT",
         "inst": "EIT",
         "meas": header.get('wavelnth'),
         "obs": "SOHO",
         "name": "EIT %s" % header.get('wavelnth'),
         "exptime": header.get('exptime'),
         'cmap': cm.get_cmap(name='sohoeit' + str(header.get('wavelnth'))),
     })
     return properties
Beispiel #12
0
def print_params(t=None):
    """Print out a summary of Solar ephemeris"""
    time = util.anytim(t)
    print('Solar Ephemeris for ' + time.ctime())
    print('')
    print('Distance (AU) = ' + str(sunearth_distance(t)))
    print('Semidiameter (arc sec) = ' + str(angular_size(t)))
    print('True (long,lat) in degrees = (' + str(true_longitude(t)) + ',' 
                                                 + str(true_latitude(t)) + ')')
    print('Apparent (long, lat) in degrees = (' + str(apparent_longitude(t)) + ',' 
                                                 + str(apparent_latitude(t)) + ')')
    print('True (RA, Dec) = (' + str(true_rightascenscion(t)) + ','
          + str(true_declination(t)))
    print('Apparent (RA, Dec) = (' + str(apparent_rightascenscion(t)) + ','
          + str(apparent_declination(t)))
    print('Heliographic long. and lat of disk center in deg = (' + str(heliographic_solar_center(t)) + ')')
    print('Position angle of north pole in deg = ' + str(solar_north(t)))
    print('Carrington Rotation Number = ' + str(carrington_rotation_number(t)))
Beispiel #13
0
def get_closest_image(date, observatory, instrument, detector, measurement):
    """Finds the closest image available for the specified source and date.
    
    For more information on what types of requests are available and the
    expected usage for the response, consult the Helioviewer API documenation:
        http://helioviewer.org/api
    
    Parameters
    ----------
    date : mixed
        A string or datetime object for the desired date of the image
    observatory : string
        The observatory to match
    instrument : string
        The instrument to match
    detector : string
        The detector to match
    measurement : string
        
    Returns
    -------
    out : dict A dictionary including the following information:
        filepath
        filename
        date
        scale
        width
        height
        sunCenterX
        sunCenterY
        
    Examples
    --------
    >>> 
    """
    # TODO 06/26/2011 Input validation
    params = {
        "date": util.anytim(date),
        "observatory": observatory,
        "instrument": instrument,
        "detector": detector,
        "measurement": measurement
    }
    return _request(params)
Beispiel #14
0
def get_jp2_image(date, directory=None, **kwargs):
    """
    Downloads the JPEG 2000 that most closely matches the specified time and 
    data source.
    
    Parameters
    ----------
    date : mixed
        A string or datetime object for the desired date of the image
        
    Returns
    -------
    string : The filepath to the JP2 image or a URL if the jpip parameter was
        set to True.
    """
    params = {
        "action": "getJP2Image",
        "date": util.anytim(date).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + "Z"
    }
    params.update(kwargs)
    
    # Submit request
    response = urllib2.urlopen(__BASE_API_URL__, urllib.urlencode(params))
    
    # JPIP URL response
    if 'jpip' in kwargs:
        return response.read()
    
    # JPEG 2000 image response
    if directory is None:
        import tempfile
        directory = tempfile.gettempdir()
    
    filename = response.info()['Content-Disposition'][22:-1]
    filepath = os.path.join(directory, filename)
    
    f = open(filepath, 'wb')
    f.write(response.read())
    
    return filepath
Beispiel #15
0
    def get_properties(cls, header):
        """Returns the default and normalized values to use for the Map"""
        # MDI sometimes has an "60" in seconds field
        datestr = header['date_obs']

        if datestr[17:19] == "60":
            datestr = datestr[:17] + "30" + datestr[19:]
        
        # Determine measurement
        dpcobsr = header.get('dpc_obsr')
        meas = "magnetogram" if dpcobsr.find('Mag') != -1 else "continuum"
        
        properties = BaseMap.get_properties()        
        properties.update({
            "date": util.anytim(datestr),
            "det": "MDI",
            "inst": "MDI",
            "meas": meas,
            "obs": "SOHO",
            "name": "MDI %s" % meas,
            "exptime": header.get('exptime'),
            "r_sun": header.get('radius')
        })
        return properties
Beispiel #16
0
def test_anytim_tuple():
    assert util.anytim((1966, 2, 3)) == LANDING
Beispiel #17
0
def simulate_raw(params, verbose = False):
    """
    Simulate data in HG' coordinates
    
    HG' = HG, except center at wave epicenter
    """
    from sunpy.util import util
    import datetime
    from scipy.special import ndtr

    cadence = params["cadence"]
    direction = 180.+params["direction"]
    
    width_coeff = prep_coeff(params["width"])
    wave_thickness_coeff = prep_coeff(params["wave_thickness"])
    wave_normalization_coeff = prep_coeff(params["wave_normalization"])
    speed_coeff = prep_coeff(params["speed"])
    
    steps = params["max_steps"]
    
    lat_min = params["lat_min"]
    lat_max = params["lat_max"]
    lat_bin = params["lat_bin"]
    lon_min = params["lon_min"]
    lon_max = params["lon_max"]
    lon_bin = params["lon_bin"]

    #This roundabout approach recalculates lat_bin and lon_bin to produce
    #equally sized bins to exactly span the min/max ranges
    lat_num = int(round((lat_max-lat_min)/lat_bin))
    lat_edges, lat_bin = np.linspace(lat_min, lat_max, lat_num+1,
                                     retstep=True)
    lon_num = int(round((lon_max-lon_min)/lon_bin))
    lon_edges, lon_bin = np.linspace(lon_min, lon_max, lon_num+1,
                                     retstep=True)
    
    #Propagates from 90. down to lat_min, irrespective of lat_max
    p = np.poly1d([speed_coeff[2]/3., speed_coeff[1]/2., speed_coeff[0],
                   -(90.-lat_min)])
    
    #Will fail if wave does not propogate all the way to lat_min
    #duration = p.r[np.logical_and(p.r.real > 0, p.r.imag == 0)][0]
    
    #steps = int(duration/cadence)+1
    #if steps > params["max_steps"]:
    #    steps = params["max_steps"]
    
    #Maybe used np.poly1d() instead to do the polynomial calculation?
    time = np.arange(steps)*cadence
    time_powers = np.vstack((time**0, time**1, time**2))
    
    width = np.dot(width_coeff, time_powers).ravel()
    wave_thickness = np.dot(wave_thickness_coeff, time_powers).ravel()
    wave_normalization = np.dot(wave_normalization_coeff, time_powers).ravel()
    
    #Propagates from 90., irrespective of lat_max
    wave_peak = 90.-(p(time)+(90.-lat_min))
    
    out_of_bounds = np.logical_or(wave_peak < lat_min, wave_peak > lat_max)
    if out_of_bounds.any():
        steps = np.where(out_of_bounds)[0][0]
        
    wave_maps = []
    
    dict_header = {
        "CDELT1": lon_bin,
        "NAXIS1": lon_num,
        "CRVAL1": lon_min,
        "CRPIX1": 0.5, #this makes lon_min the left edge of the first bin
        "CUNIT1": "deg",
        "CTYPE1": "HG",
        "CDELT2": lat_bin,
        "NAXIS2": lat_num,
        "CRVAL2": lat_min,
        "CRPIX2": 0.5, #this makes lat_min the left edge of the first bin
        "CUNIT2": "deg",
        "CTYPE2": "HG",
        "HGLT_OBS": 0,
        "HGLN_OBS": 0,
        "RSUN_OBS": 963.879683,
        "RSUN_REF": 696000000.0,
        "DSUN_OBS": 148940609626.98
    }
    
    header = sunpy.map.MapHeader(dict_header)
    
    if verbose:
        print("Simulating "+str(steps)+" raw maps")
    
    for istep in xrange(steps):
        #Gaussian profile in longitudinal direction
        #Does not take into account spherical geometry
        #(i.e., change in area element)
        if (wave_thickness[istep] <= 0):
            print("ERROR: wave thickness is non-physical!")
        z = (lat_edges-wave_peak[istep])/wave_thickness[istep]
        wave_1d = wave_normalization[istep]*(ndtr(np.roll(z, -1))-ndtr(z))[0:lat_num]
        wave_1d /= lat_bin
        
        wave_lon_min = direction-width[istep]/2
        wave_lon_max = direction+width[istep]/2

        if (width[istep]< 360.):
            #Do these need to be np.remainder() instead?
            wave_lon_min_mod = ((wave_lon_min+180.) % 360.)-180.
            wave_lon_max_mod = ((wave_lon_max+180.) % 360.)-180.
            
            index1 = np.arange(lon_num+1)[np.roll(lon_edges, -1) > min(wave_lon_min_mod, wave_lon_max_mod)][0]
            index2 = np.roll(np.arange(lon_num+1)[lon_edges < max(wave_lon_min_mod, wave_lon_max_mod)], 1)[0]
    
            wave_lon = np.zeros(lon_num)
            wave_lon[index1+1:index2] = 1.
            #Possible weirdness if index1 == index2
            wave_lon[index1] += (lon_edges[index1+1]-min(wave_lon_min_mod, wave_lon_max_mod))/lon_bin
            wave_lon[index2] += (max(wave_lon_min_mod, wave_lon_max_mod)-lon_edges[index2])/lon_bin
            
            if (wave_lon_min_mod > wave_lon_max_mod):
                wave_lon = 1.-wave_lon
        else:
            wave_lon = np.ones(lon_num)
        
        #Could be accomplished with np.dot() without casting as matrices?
        wave = np.mat(wave_1d).T*np.mat(wave_lon)
        
        wave_maps += [sunpy.map.BaseMap(wave, header)]
        wave_maps[istep].name = "Simulation"
        wave_maps[istep].date = util.anytim("2011-11-11")+datetime.timedelta(0, istep*cadence)
    
    return wave_maps
Beispiel #18
0
def test_anytim_int():
    assert util.anytim(765548612.0) == datetime(2003, 4, 5, 12, 23, 32)
    assert util.anytim(1009685652.0) == datetime(2010, 12, 30, 4, 14, 12)
Beispiel #19
0
def _a(wlk, root, state, dct):
    dct["event_starttime"] = anytim(root.start).strftime("%Y-%m-%dT%H:%M:%S")
    dct["event_endtime"] = anytim(root.end).strftime("%Y-%m-%dT%H:%M:%S")
    return dct
Beispiel #20
0
def solar_cycle_number(t=None):
    time = util.anytim(t)
    result = (time.year + 8) % 28 + 1
    return result
Beispiel #21
0
def _a(wlk, root, state, dct):
    dct['event_starttime'] = anytim(root.start).strftime('%Y-%m-%dT%H:%M:%S')
    dct['event_endtime'] = anytim(root.end).strftime('%Y-%m-%dT%H:%M:%S')
    return dct
Beispiel #22
0
    def query_legacy(self, tstart=None, tend=None, **kwargs):
        """
        Query data from the VSO mocking the IDL API as close as possible.
        Either tstart and tend or date_start and date_end or date have
        to be supplied.
        
        Parameters
        ----------
        tstart : datetime.datetime
            Start of the time-range in which records are searched.
        tend : datetime.datetime
            Start of the time-range in which records are searched.
        date : str
            (start date) - (end date)
        start_date : datetime
            the start date
        end_date : datetime
            the end date
        wave : str
            (min) - (max) (unit)
        min_wave : str
            minimum spectral range
        max_wave : str
            maximum spectral range
        unit_wave : str
            spectral range units (Angstrom, GHz, keV)
        extent : str
            VSO 'extent type' ... (FULLDISK, CORONA, LIMB, etc)
        physobj : str
            VSO 'physical observable'
        provider : str
            VSO ID for the data provider (SDAC, NSO, SHA, MSU, etc)
        source : str
            spacecraft or observatory (SOHO, YOHKOH, BBSO, etc)
            synonyms : spacecraft, observatory
        instrument : str
            instrument ID (EIT, SXI-0, SXT, etc)
            synonyms : telescope, inst
        detector : str
            detector ID (C3, EUVI, COR2, etc.)
        layout : str
            layout of the data (image, spectrum, time_series, etc.)

        level : str 
            level of the data product (numeric range, see below)
        pixels : str
            number of pixels (numeric range, see below)
        resolution : str
            effective resolution (1 = full, 0.5 = 2x2 binned, etc)
            numeric range, see below.
        pscale : str
            pixel scale, in arcseconds (numeric range, see below)
        near_time : datetime
            return record closest to the time.  See below.
        sample : int
            attempt to return only one record per SAMPLE seconds.  See below.
        
        Numeric Ranges:
        
            - May be entered as a string or any numeric type for equality matching
            - May be a string of the format '(min) - (max)' for range matching
            - May be a string of the form '(operator) (number)' where operator is one of: lt gt le ge < > <= >=
        
        
        Examples
        --------
        Query all data from eit between 2010-01-01T00:00 and
        2010-01-01T01:00.
        
        >>> qr = client.query_legacy(
        ...     datetime(2010, 1, 1), datetime(2010, 1, 1, 1), instrument='eit')
        
        Returns
        -------
        out : :py:class:`QueryResult` (enhanced list) of matched items. Return value of same type as the one of :py:class:`VSOClient.query`.
        """
        sdk = lambda key: lambda value: {key: value}
        ALIASES = {
            'wave_min': sdk('wave_wavemin'),
            'wave_max': sdk('wave_wavemax'),
            'wave_type': sdk('wave_wavetype'),
            'wave_unit': sdk('wave_waveunit'),
            'min_wave': sdk('wave_wavemin'),
            'max_wave': sdk('wave_wavemax'),
            'type_wave': sdk('wave_wavetype'),
            'unit_wave': sdk('wave_waveunit'),
            'wave': _parse_waverange,
            'inst': sdk('instrument'),
            'telescope': sdk('instrument'),
            'spacecraft': sdk('source'),
            'observatory': sdk('source'),
            'start_date': sdk('time_start'),
            'end_date': sdk('time_end'),
            'start': sdk('time_start'),
            'end': sdk('time_end'),
            'near_time': sdk('time_near'),
            'date': _parse_date,
            'layout': sdk('datatype'),
        }
        kwargs.update({'time_start': tstart, 'time_end': tend})
        
        queryreq = self.api.factory.create('QueryRequest')
        for key, value in kwargs.iteritems():
            if key.startswith('time'):
                value = anytim(value).strftime(TIMEFORMAT)
            for k, v in ALIASES.get(key, sdk(key))(value).iteritems():
                attr = k.split('_')
                lst = attr[-1]
                rest = attr[:-1]
                
                # pylint: disable=E1103
                item = queryreq.block
                for elem in rest:
                    try:
                        item = item[elem]
                    except KeyError:
                        raise ValueError("Unexpected argument %s." % key)
                if lst not in item:
                    raise ValueError("Unexpected argument %s." % key)
                if item[lst]:
                    raise ValueError("Got multiple values for %s." % k)
                item[lst] = v
        return QueryResponse.create(self.api.service.Query(queryreq))