Exemple #1
0
 def aia_promote(self):
     if self.full_map.processing_level == 1.4:
         self.full_map = aia.aiaprep(self.full_map)
         self.full_map.meta['lvl_num'] = 1.6
     else:
         self.full_map = aia.aiaprep(self.full_map)
         self.full_map.meta['lvl_num'] = 1.5
Exemple #2
0
def process_med_int(fle):
    """
    Processes 1 image and extracts the median intensity on the disk
    normalized for exposure time.

    Args:
        fle (str): image file name

    Returns:
        median intensity of the solar disk normalized for exptime

    """
    amap = Map(fle)
    amap = aiaprep(amap)
    data = amap.data

    date = amap.date
    hdr = getFitsHdr(fle)
    exp_time = hdr['exptime']

    r_pix = hdr['rsun_obs'] / hdr['cdelt1']  # radius of the sun in pixels
    disk_mask = get_disk_mask(data.shape, r_pix)
    disk_data = np.ma.array(data, mask=disk_mask)
    med_int = np.ma.median(disk_data)  # np.median doesn't support masking

    return med_int / exp_time
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
def create_tempmap(date,
                   n_params=1,
                   data_dir=home + 'SDO_data/',
                   maps_dir=home + 'temperature_maps/'):
    wlens = ['94', '131', '171', '193', '211', '335']
    t0 = 5.6
    images = []
    #imdates = {}

    print 'Finding data for {}.'.format(date.date())
    # Loop through wavelengths
    for wl, wlen in enumerate(wlens):
        #print 'Finding {}A data...'.format(wlen),
        fits_dir = data_dir + '{}/{:%Y/%m/%d}/'.format(wlen, date)
        filename = fits_dir + 'aia*{0}*{1:%Y?%m?%d}?{1:%H?%M}*lev1?fits'.format(
            wlen, date)
        temp_im = Map(filename)
        # Download data if not enough found
        client = vso.VSOClient()
        if temp_im == []:
            print 'File not found. Downloading from VSO...'
            # Wavelength value for query needs to be an astropy Quantity
            wquant = u.Quantity(value=int(wlen), unit='Angstrom')
            qr = client.query(
                vso.attrs.Time(
                    date,  # - dt.timedelta(seconds=6),
                    date + dt.timedelta(seconds=12)),  #6)),
                vso.attrs.Wave(wquant, wquant),
                vso.attrs.Instrument('aia'),
                vso.attrs.Provider('JSOC'))
            res = client.get(qr, path=fits_dir + '{file}', site='NSO').wait()
            temp_im = Map(res)
        if temp_im == []:
            print 'Downloading failed.'
            print res, len(qr), qr
            return np.zeros((512, 512)), None, None
        if isinstance(temp_im, list):
            temp_im = temp_im[0]
        # TODO: save out level 1.5 data so it can be loaded quickly.
        temp_im = aiaprep(temp_im)
        temp_im.data = temp_im.data / temp_im.exposure_time  # Can probably increase speed a bit by making this * (1.0/exp_time)
        images.append(temp_im)
        #imdates[wlen] = temp_im.date

    normim = images[2].data.copy()
    # Normalise images to 171A
    print 'Normalising images'
    for i in range(len(wlens)):
        images[i].data = images[i].data / normim

    # Produce temperature map
    if n_params == 1:
        tempmap = find_temp(images, t0)  #, force_temp_scan=True)
    else:
        #tempmap = find_temp_3params(images, t0)
        pass

    return tempmap
Exemple #5
0
    def calculate_em(self, wlen='171', dz=100, model=False):
        """
        Calculate an approximation of the coronal EmissionMeasure using a given
        TemperatureMap object and a particular AIA channel.
    
        Parameters
        ----------
        tmap : CoronaTemps.temperature.TemperatureMap
            A TemperatureMap instance containing coronal temperature data
        wlen : {'94' | '131' | '171' | '193' | '211' | '335'}
            AIA wavelength used to approximate the emission measure. '171', '193'
            and '211' are most likely to provide reliable results. Use of other
            channels is not recommended.
        """
        # Load the appropriate temperature response function
        tresp = read('/imaps/holly/home/ajl7/CoronaTemps/aia_tresp')
        resp = tresp['resp{}'.format(wlen)]
    
        # Get some information from the TemperatureMap and set up filenames, etc
        tempdata = self.data.copy()
        tempdata[np.isnan(tempdata)] = 0.0
        date = sunpy.time.parse_time(self.date)
        if not model:
            data_dir = self.data_dir
            fits_dir = path.join(data_dir, '{:%Y/%m/%d}/{}'.format(date, wlen))
            filename = path.join(fits_dir,
                                 '*{0:%Y?%m?%d}?{0:%H?%M}*fits'.format(date))
            if wlen == '94': filename = filename.replace('94', '094')
    
            # Load and appropriately process AIA data
            filelist = glob.glob(filename)
            if filelist == []:
                print 'AIA data not found :('
                return
            aiamap = Map(filename)
            aiamap.data /= aiamap.exposure_time
            aiamap = aiaprep(aiamap)
            aiamap = aiamap.submap(self.xrange, self.yrange)
        else:
            fname = '/imaps/holly/home/ajl7/CoronaTemps/data/synthetic/{}/model.fits'.format(wlen)
            if wlen == '94': fname = fname.replace('94', '094')
            aiamap = Map(fname)

        # Create new Map and put EM values in it
        emmap = Map(self.data.copy(), self.meta.copy())
        indices = np.round((tempdata - 4.0) / 0.05).astype(int)
        indices[indices < 0] = 0
        indices[indices > 100] = 100
        #print emmap.shape, indices.shape, tempdata.shape, aiamap.shape, resp.shape
        emmap.data = np.log10(aiamap.data / resp[indices])
        #emmap.data = aiamap.data / resp[indices]

        emmapcubehelix = _cm.cubehelix(s=2.8, r=-0.7, h=1.4, gamma=1.0)
        cm.register_cmap(name='emhelix', data=emmapcubehelix)
        emmap.cmap = cm.get_cmap('emhelix')
    
        return emmap
def create_tempmap(date, n_params=1, data_dir=home+'SDO_data/',
                   maps_dir=home+'temperature_maps/'):
    wlens = ['94', '131', '171', '193', '211', '335']
    t0 = 5.6
    images = []
    #imdates = {}
    
    print 'Finding data for {}.'.format(date.date())
    # Loop through wavelengths
    for wl, wlen in enumerate(wlens):
        #print 'Finding {}A data...'.format(wlen),
        fits_dir = data_dir + '{}/{:%Y/%m/%d}/'.format(wlen, date)
        filename = fits_dir + 'aia*{0}*{1:%Y?%m?%d}?{1:%H?%M}*lev1?fits'.format(wlen, date)
        temp_im = Map(filename)
        # Download data if not enough found
        client = vso.VSOClient()
        if temp_im == []:
            print 'File not found. Downloading from VSO...'
            # Wavelength value for query needs to be an astropy Quantity
            wquant = u.Quantity(value=int(wlen), unit='Angstrom')
            qr = client.query(vso.attrs.Time(date,# - dt.timedelta(seconds=6),
                                             date + dt.timedelta(seconds=12)),#6)),
                              vso.attrs.Wave(wquant, wquant),
                              vso.attrs.Instrument('aia'),
                              vso.attrs.Provider('JSOC'))
            res = client.get(qr, path=fits_dir+'{file}', site='NSO').wait()
            temp_im = Map(res)
        if temp_im == []:
            print 'Downloading failed.'
            print res, len(qr), qr
            return np.zeros((512, 512)), None, None
        if isinstance(temp_im, list):
            temp_im = temp_im[0]
        # TODO: save out level 1.5 data so it can be loaded quickly.
        temp_im = aiaprep(temp_im)
        temp_im.data = temp_im.data / temp_im.exposure_time # Can probably increase speed a bit by making this * (1.0/exp_time)
        images.append(temp_im)
        #imdates[wlen] = temp_im.date
    
    normim = images[2].data.copy()
    # Normalise images to 171A
    print 'Normalising images'
    for i in range(len(wlens)):
        images[i].data = images[i].data / normim
    
    # Produce temperature map
    if n_params == 1:
        tempmap = find_temp(images, t0)#, force_temp_scan=True)
    else:
        #tempmap = find_temp_3params(images, t0)
        pass

    return tempmap
Exemple #7
0
 def run_subpix(self, fits_hmi, index):
     map_hmi = aiaprep(Map(fits_hmi))
     data = map_hmi.data[2048 - 140:2048 + 140, 2048 - 140:2048 + 140]
     if index == self.nb_stack // 2:
         data_shift = data
     else:
         meta = map_hmi.meta
         shift_index = index - float(self.nb_stack // 2)
         rsun = meta['r_sun']
         angle = (shift_index * 360. * np.pi) / (self.solar_rot_period *
                                                 24. * 80. * 180.)
         shift = rsun * np.sin(angle) * -1.
         data_shift = interpolation.shift(data, (0.0, shift), order=1)
     return data_shift
    def compare(self, display_wlen='171', context_wlen=None, extra_maps=[]):
        #        temp_args=None, temp_kwargs=None,
        #        wlen_args=None, wlen_kwargs=None,
        #        ctxt_args=None, ctxt_kwargs=None,
        #        extr_args=None, extr_kwargs=None):
        valid_wlens = ['94', '131', '171', '195', '211', '335', '304', 'hmi']
        if display_wlen.lower() not in valid_wlens:
            print "Display wavelength provided invalid or None."
            output = self.plot()  #*temp_args, **temp_kwargs)
            return output
        save_output = True
        data_dir = self.data_dir
        maps_dir = self.maps_dir

        date = self.date
        nmaps = 2 + len(extra_maps)
        if context_wlen:
            nrows = 2
        else:
            nrows = 1

        fig = plt.figure(figsize=(24, 14))

        fig.add_subplot(nrows, nmaps, nmaps, axisbg='k')
        self.plot()  #*temp_args, **temp_kwargs)
        plt.colorbar(orientation='horizontal')

        displaymap = Map(data_dir+'{0}/{1:%Y/%m/%d}/aia*{0}*t{1:%H?%M}*lev1?fits'\
            .format(display_wlen, date))
        if isinstance(displaymap, list):
            displaymap = displaymap[0]
        displaymap = aiaprep(displaymap)
        displaymap /= displaymap.exposure_time

        fig.add_subplot(nrows, nmaps, 1, axisbg='k')
        displaymap.plot()  #*wlen_args, **wlen_kwargs)
        plt.colorbar(orientation='horizontal')

        if context_wlen and self.region != None:
            context_plot = fig.add_subplot(nrows, 1, nrows)
            contextmap = Map(data_dir +
                             '{0}/{1:%Y/%m/%d}/aia*{0}*t{1:%H?%M}*lev1?fits'.
                             format(context_wlen, date))
            if isinstance(contextmap, list):
                contextmap = contextmap[0]
            x, y = self.region_coordinate['x'], self.region_coordinate['y']
            contextmap = contextmap.submap([-1000, 1000], [y - 300, y + 300])
            # Need to figure out how to get 'subimsize' from self. Use the default 150'' for now
            #rect = patches.Rectangle([x-subdx, y-subdx], subimsize[0], subimsize[1], color='white', fill=False)
            rect = patches.Rectangle([x - 150, y - 150],
                                     300,
                                     300,
                                     color='white',
                                     fill=False)
            contextmap.plot()  #*ctxt_args, **ctxt_kwargs)
            context_plot.add_artist(rect)

        for m, thismap in extra_maps:
            fig.add_subplot(nrows, nmaps, 3 + m)
            thismap.plot()  #*extr_args, **extr_kwargs)

        if save_output:
            error = sys('touch ' + maps_dir +
                        'maps/{:%Y/%m/%d/} > shelloutput.txt'.format(date))
            if error != 0:
                sys('{0}{1:%Y}; {0}{1:%Y/%m}; {0}{1:%Y/%m/%d} > shelloutput.txt'\
                        .format('mkdir '+maps_dir+'maps/', date))
            filename = maps_dir+'maps/{:%Y/%m/%d/%Y-%m-%dT%H:%M:%S}_with{}'.\
                    format(date, display_wlen)
            plt.savefig(filename)
            if self.region != None:
                reg_dir = maps_dir + 'maps/region_maps'
                reg_dir = reg_dir + '/{}/'.format(self.region)
                error = sys('touch ' + reg_dir + ' > shelloutput.txt')
                if error != 0:
                    sys('mkdir ' + reg_dir + ' > shelloutput.txt')
                plt.savefig(reg_dir + '{:%Y-%m-%dT%H:%M:%S}'.format(date))
            plt.close()
        else:
            plt.show()

        return
Exemple #9
0
from __future__ import absolute_import

import tempfile

import numpy as np

import sunpy
import sunpy.data.test as test
from sunpy.instr.aia import aiaprep

# Define the original and prepped images first so they're available to all functions
original = sunpy.map.Map(test.aia_171_level1)
prep_map = aiaprep(original)


def test_aiaprep():
    # Test that header info for the map has been correctly updated
    # Check all of these for Map attributes and .meta values?
    # Check crpix values
    assert prep_map.meta["crpix1"] == prep_map.data.shape[1] / 2.0 + 0.5
    assert prep_map.meta["crpix2"] == prep_map.data.shape[0] / 2.0 + 0.5
    # Check cdelt values
    assert prep_map.meta["cdelt1"] / 0.6 == int(prep_map.meta["cdelt1"] / 0.6)
    assert prep_map.meta["cdelt2"] / 0.6 == int(prep_map.meta["cdelt2"] / 0.6)
    # Check rotation value, I am assuming that the inaccuracy in
    # the CROTA -> PCi_j matrix is causing the inaccuracy here
    np.testing.assert_allclose(prep_map.rotation_matrix, np.identity(2), rtol=1e-5, atol=1e-8)
    # Check level number
    assert prep_map.meta["lvl_num"] == 1.5

Exemple #10
0
from sunpy.instr.aia import aiaprep
from sunpy.net import Fido, attrs as a
from astropy.coordinates import SkyCoord
from astropy import units as u
from matplotlib import animation
from IPython.display import HTML
import warnings
warnings.filterwarnings("ignore")


download = 'C:\\Users\\Carleano Libretto\\downloads\\LIP2020M5(171(allimgs))'
mapped_files = sunpy.map.Map(download)
aia_seq = []
k=0
for img in mapped_files:
    aiaprep(mapped_files[k])
    k+=1
    top_right = SkyCoord(1400*u.arcsec, 500*u.arcsec, frame=img.coordinate_frame)
    bottom_left = SkyCoord(600 * u.arcsec, -250. * u.arcsec, frame=img.coordinate_frame)
    aia_seq.append(img.submap(top_right, bottom_left))
aia = sunpy.map.Map(aia_seq)
fig, ax = plt.subplots()
# image half down sequence to get better scaling
plot_obj = aia[len(aia) // 2].plot()

def animate(i):
    ax.set_title("AIA %s %s" % (aia[i].meta['wave_str'][:-5],
                                aia[i].meta['t_obs']))
    
    plot_obj.set_data(aia[i].data)
    return (plot_obj,)
Exemple #11
0
from __future__ import absolute_import

import tempfile

import numpy as np

import sunpy
import sunpy.data.test as test
from sunpy.instr.aia import aiaprep

# Define the original and prepped images first so they're available to all functions
original = sunpy.map.Map(test.aia_171_level1)
prep_map = aiaprep(original)


def test_aiaprep():
    # Test that header info for the map has been correctly updated
    # Check all of these for Map attributes and .meta values?
    # Check crpix values
    assert prep_map.meta['crpix1'] == prep_map.data.shape[1] / 2.0 + 0.5
    assert prep_map.meta['crpix2'] == prep_map.data.shape[0] / 2.0 + 0.5
    # Check cdelt values
    assert prep_map.meta['cdelt1'] / 0.6 == int(prep_map.meta['cdelt1'] / 0.6)
    assert prep_map.meta['cdelt2'] / 0.6 == int(prep_map.meta['cdelt2'] / 0.6)
    # Check rotation value, I am assuming that the inaccuracy in
    # the CROTA -> PCi_j matrix is causing the inaccuracy here
    np.testing.assert_allclose(prep_map.rotation_matrix,
                               np.identity(2),
                               rtol=1e-5,
                               atol=1e-8)
    # Check level number
Exemple #12
0
def prep_map(original):
    with pytest.warns(SunpyDeprecationWarning):
        return aiaprep(original)
Exemple #13
0
wlens = ["094", "131", "171", "193", "211", "335"]
t0 = 5.6
thiswlen = None

if rank == 0:
    if datfile:
        images = {}
        f = open(datfile)
        # Loop through wavelengths
        for line in f:
            if line[:3] in wlens:
                allwlenmaps = []
                thiswlen = line[:3]
                print "Loading {} files".format(thiswlen)
            elif "fits" in line:
                thismap = aiaprep(Map(line[:-1]))
                thismap.data /= thismap.exposure_time
                allwlenmaps.append(thismap)
            elif line.strip() in ["", "\n"]:
                if thiswlen:
                    wlenmap = allwlenmaps[-1]
                    for thismap in allwlenmaps[:-1]:
                        wlenmap.data += thismap.data
                    wlenmap.data /= len(allwlenmaps)
                    images[thiswlen] = wlenmap

        images = [images[w] for w in wlens]
    else:
        images = []
        # imagefiles = []
        for wl, wlen in enumerate(wlens):
Exemple #14
0
def process_img(fits_file,
                fname=None,
                downscale=None,
                rescale_brightness=True,
                side_by_side=False,
                timestamp=True,
                single_channel=False,
                suppress_aia_prep=False,
                custom_f=lambda x: x):
    """Produces an AIA image of the Sun from a fits file

    Parameters
    ----------
    fits_file: str (Eg 'dir/image482005.fits')
        name of fits file to process
    fname : str (Eg 'dir/out_img.jpg')
        file name to save image as
        If None:
            returns a PIL image instance instead of saving directly
    downscale: tuple of two ints (Eg: (8, 8))
        downscales the data by (x, y) factor if filled
    rescale_brightness: bool
        determines if brightness correction is done
    side_by_side: bool
        make a side-by-side comparison of the scaled and not
        brightness scaled images
    timestamp: bool
        show timestamp or not
    single_channel: bool
        return image data in np array before applying the colormap
    suppress_aia_prep: bool
        not do aia prep if image below lvl 1
    custom_f: function
        custom function applied to data array
        applied early on, just after aiaprep
    """
    hdr = sun_intensity.getFitsHdr(fits_file)
    wavelength = str(hdr['wavelnth'])
    exptime = hdr['EXPTIME']
    cmap = get_cmap('sdoaia' + wavelength)
    cmap.set_bad()
    imin, imax = MINMAX[wavelength]

    themap = Map(fits_file)
    if (hdr['lvl_num'] != 1.5) and (not suppress_aia_prep):
        # perform aiaprep if data not at level 1.5
        themap = aiaprep(themap)
    data = themap.data
    data = np.flipud(data)
    data = custom_f(data)  # apply custom function data
    data = data / exptime  #  normalize for exposure
    norm_scale = STANDARD_INT[wavelength]
    dim_factor = sun_intensity.get_dim_factor(themap.date, wavelength)
    data = data * norm_scale
    if downscale:
        data = downscale_local_mean(data, downscale)

    if rescale_brightness or side_by_side:
        imin = imin / dim_factor  # brightness correction
        imax = imax / dim_factor
    data[0, 0] = imin  # first pixel set to min
    data[0, 1] = imax  # second pixel sit to max

    if SQRT_NORM[wavelength]:
        norm = colors.PowerNorm(1)
        data = np.sqrt(np.clip(data, imin, imax))
    else:
        norm = colors.LogNorm(vmin=imin, vmax=imax, clip=True)
    if single_channel:
        return norm(data)
    pil_img = misc.toimage(cmap(norm(data)))

    width, height = pil_img.size
    if side_by_side:
        new_img = Image.new('RGB', (width * 2, height))
        new_img.paste(pil_img, (0, 0))
        second_image = process_img(fits_file,
                                   downscale=downscale,
                                   rescale_brightness=False,
                                   timestamp=False)
        new_img.paste(second_image, (width, 0))
        pil_img = new_img

    if timestamp:
        draw = ImageDraw.Draw(pil_img)
        font_height = int(height / 64)
        font = ImageFont.truetype('/Library/Fonts/Arial.ttf', font_height)
        draw.text((font_height, height - (2 * font_height)),
                  'SDO/AIA- ' + wavelength + ' ' +
                  themap.date.strftime('%Y-%m-%d %H:%M:%S'),
                  font=font)

    if fname:
        pil_img.save(fname)
    else:
        return pil_img
Exemple #15
0
def prep_map(original):
    return aiaprep(original)
# In[23]:

file_download = Fido.fetch(result[0, 3], site='ROB')

# Read downloaed file in Map form.

# In[5]:

aia1 = sunpy.map.Map(file_download[0])

# Prepare the Map (Correct for rotation and revolution if needed)

# In[6]:

aia = aiaprep(aia1)

# Finaly Plot the data

# In[19]:

plt.rc('font', family='serif')
plt.figure(figsize=[8, 10])
aia.plot()
aia.draw_limb()
plt.grid(False)
#plt.colorbar()
plt.show()

# In[ ]:
    def compare(self, display_wlen='171', context_wlen=None, extra_maps=[]):
        #        temp_args=None, temp_kwargs=None,
        #        wlen_args=None, wlen_kwargs=None,
        #        ctxt_args=None, ctxt_kwargs=None,
        #        extr_args=None, extr_kwargs=None):
        valid_wlens = ['94', '131', '171', '195', '211', '335', '304', 'hmi']
        if display_wlen.lower() not in valid_wlens:
            print "Display wavelength provided invalid or None."
            output = self.plot()#*temp_args, **temp_kwargs)
            return output
        save_output = True
        data_dir = self.data_dir
        maps_dir = self.maps_dir
        
        date = self.date
        nmaps = 2 + len(extra_maps)
        if context_wlen:
            nrows = 2
        else:
            nrows = 1
        
        fig = plt.figure(figsize=(24, 14))
        
        fig.add_subplot(nrows, nmaps, nmaps, axisbg='k')
        self.plot()#*temp_args, **temp_kwargs)
        plt.colorbar(orientation='horizontal')
        
        displaymap = Map(data_dir+'{0}/{1:%Y/%m/%d}/aia*{0}*t{1:%H?%M}*lev1?fits'\
            .format(display_wlen, date))
        if isinstance(displaymap, list):
            displaymap = displaymap[0]
        displaymap = aiaprep(displaymap)
        displaymap /= displaymap.exposure_time
        
        fig.add_subplot(nrows, nmaps, 1, axisbg='k')
        displaymap.plot()#*wlen_args, **wlen_kwargs)
        plt.colorbar(orientation='horizontal')
        
        if context_wlen and self.region != None:
            context_plot = fig.add_subplot(nrows, 1, nrows)
            contextmap = Map(data_dir+'{0}/{1:%Y/%m/%d}/aia*{0}*t{1:%H?%M}*lev1?fits'.format(context_wlen, date))
            if isinstance(contextmap, list):
                contextmap = contextmap[0]
            x, y = self.region_coordinate['x'], self.region_coordinate['y']
            contextmap = contextmap.submap([-1000, 1000], [y-300, y+300])
            # Need to figure out how to get 'subimsize' from self. Use the default 150'' for now
            #rect = patches.Rectangle([x-subdx, y-subdx], subimsize[0], subimsize[1], color='white', fill=False)
            rect = patches.Rectangle([x-150, y-150], 300, 300, color='white',
                                     fill=False)
            contextmap.plot()#*ctxt_args, **ctxt_kwargs)
            context_plot.add_artist(rect)
        
        for m, thismap in extra_maps:
            fig.add_subplot(nrows, nmaps, 3+m)
            thismap.plot()#*extr_args, **extr_kwargs)
        
        if save_output:
            error = sys('touch '+maps_dir+'maps/{:%Y/%m/%d/} > shelloutput.txt'.format(date))
            if error != 0:
                sys('{0}{1:%Y}; {0}{1:%Y/%m}; {0}{1:%Y/%m/%d} > shelloutput.txt'\
                        .format('mkdir '+maps_dir+'maps/', date))
            filename = maps_dir+'maps/{:%Y/%m/%d/%Y-%m-%dT%H:%M:%S}_with{}'.\
                    format(date, display_wlen)
            plt.savefig(filename)
            if self.region != None:
                reg_dir = maps_dir + 'maps/region_maps'
                reg_dir = reg_dir + '/{}/'. format(self.region)
                error = sys('touch ' + reg_dir + ' > shelloutput.txt')
                if error != 0:
                    sys('mkdir ' + reg_dir + ' > shelloutput.txt')
                plt.savefig(reg_dir+'{:%Y-%m-%dT%H:%M:%S}'.format(date))
            plt.close()
        else:
            plt.show()

        return
Exemple #18
0
## rebinning AIA data

opdir = '/Users/mskirk/data/AIA/TempQuicklook/304/'

import os
import fnmatch
import sunpy.map as map
import sunpy.instr.aia as aia

fls = fnmatch.filter(os.listdir(opdir), '*.fits')
itr = 0

for file in fls:
    aia_map = aia.aiaprep(map.Map(opdir + file))
    prep_map = aia_map.resample([1024, 1024])
    prep_map.save(opdir + file, filetype='fits', clobber=True)
    itr = itr + 1
    print itr
def download_AIA_data(rec_time,
                      doCut=True,
                      jsoc_serie='aia.lev1_euv_12s',
                      wavelength=[94, 131, 171, 193, 211, 304, 335]):
    '''
    Download the AIA data from a given time which is same to the HMI data in
    this project.
    
    Parameters:
    ----------------------------
    rec_time: String (in JSOC time format) 
        The HMI record time, locate the corresponding AIA data, notice 
        that the record time maybe not exactly the same
    
    doCut: Bool (Default is True)
        Control if the AIA data is cropped
    
    jsoc_serie: String    
        The jsoc series to get the AIA data, 
        default is 'aia.lev1_euv_12s'
    
    wavelength: List
        The wavelengths for the AIA data, 
        all avaiable are [94,131,171,193,211,304,335]
       
    Returns:
    ----------------------------  
    For now, the return is a dictionary, data part are image datas,
    keys are channels (wavelength). [Output HDF5 files in the future.]
    '''

    c = drms.Client()

    # Query the HMI data, because can't directly get the record time from the
    # HMI fits files
    ds_HMI = '{}[{}]'.format('hmi.sharp_cea_720s[1-7256]', rec_time)
    keys_HMI, segments_HMI = c.query(ds_HMI,
                                     key=drms.const.all,
                                     seg='magnetogram')
    url_hmi_cea = 'http://jsoc.stanford.edu' + segments_HMI.magnetogram[0]
    hmi_image = fits.open(url_hmi_cea)

    ds = '{}[{}]'.format(jsoc_serie, rec_time)
    avaiable_wavelengths = [94, 131, 171, 193, 211, 304, 335]
    for wlength in wavelength:
        if wlength not in avaiable_wavelengths:
            raise RuntimeError('Wavelength not avaiable!')
    ds = ds + str(wavelength)
    keys_AIA, segments_AIA = c.query(ds, key=drms.const.all, seg='image')
    # The all aia urls
    urls_aia = 'http://jsoc.stanford.edu' + segments_AIA['image']

    aia_data_dict = dict()
    for chnl in range(len(wavelength)):
        url = urls_aia[chnl]
        image_file = download_file(url, cache=False)
        aiamap = aiaprep(Map(image_file))
        fullsize_aia_image_data = np.array(aiamap.data, dtype=np.int16)
        if doCut:
            aia_image_data = cut_AIA(keys_AIA.loc[chnl], keys_HMI,
                                     fullsize_aia_image_data, hmi_image)
        else:
            aia_image_data = fullsize_aia_image_data
        wavelnth = str(int(aiamap.wavelength.value))
        aia_data_dict[wavelnth] = aia_image_data

    return aia_data_dict, keys_AIA, keys_HMI
Exemple #20
0
def prep_map(original):
    return aiaprep(original)
Exemple #21
0
    a = 1.
    b = -2 * (r_1.to(u.cm) * np.cos(phi.to(u.radian)))
    c = r_1.to(u.cm)**2 - r_2.to(u.cm)**2
    r = (-b + np.sqrt(b**2 - 4 * a * c)) / 2 / a
    # Choose only points above the surface
    i_r = np.where(r > r_1)
    r = r[i_r]
    phi = phi[i_r]
    hcc_frame = Heliocentric(
        observer=SkyCoord(lon=75 * u.deg,
                          lat=25 * u.deg,
                          radius=r_1,
                          frame='heliographic_stonyhurst'))
    return (SkyCoord(y=r.to(u.cm) * np.sin(phi.to(u.radian)),
                     x=u.Quantity(r.shape[0] * [0 * u.cm]),
                     z=r.to(u.cm) * np.cos(phi.to(u.radian)),
                     frame=hcc_frame).transform_to('heliographic_stonyhurst'))


loop = semi_circular_loop(140 * u.Mm, theta0=5 * u.deg)
aia = glob.glob('C:\\Users\\Carleano Libretto\\downloads\\LIP2020M5(171)')
aia = sorted(aia)
dummy_map = (sunpy.map.Map(aia))
dummy_map = aiaprep(dummy_map[0])
fig = plt.figure(figsize=(30, 35))
ax = fig.gca(projection=dummy_map)
dummy_map.plot(title=False)
ax.plot_coord(loop.transform_to(dummy_map.coordinate_frame), color='C3', lw=3)
#ax.plot_coord(SkyCoord(1400*u.arcsec, 500*u.arcsec, frame=dummy_map.coordinate_frame))
#ax.plot_coord(SkyCoord(600*u.arcsec, -250*u.arcsec, frame=dummy_map.coordinate_frame))