def test_diffrot_submap_pad(aia171_test_submap): aia_srot = diffrot_map(aia171_test_submap, -0.5 * u.day, pad=True) assert aia_srot.dimensions >= aia171_test_submap.dimensions assert (aia171_test_submap.date - timedelta(days=0.5)) - aia_srot.date < timedelta(seconds=1) assert aia_srot.meta['naxis1'] == 35 assert aia_srot.meta['naxis2'] == 18
def test_diffrot_submap_pad(aia171_test_submap): aia_srot = diffrot_map(aia171_test_submap, dt=-0.5 * u.day, pad=True) assert aia_srot.dimensions >= aia171_test_submap.dimensions assert (aia171_test_submap.date - TimeDelta(0.5 * u.day)) - aia_srot.date < TimeDelta(1 * u.second) assert aia_srot.meta['naxis1'] == 35 assert aia_srot.meta['naxis2'] == 18
def test_diffrot_allen_submap_pad(aia171_test_submap): aia_srot = diffrot_map(aia171_test_submap, dt=-0.5 * u.day, pad=True, rot_type='allen') assert aia_srot.dimensions >= aia171_test_submap.dimensions assert (aia171_test_submap.date - timedelta(days=0.5)) - aia_srot.date < timedelta(seconds=1) assert aia_srot.meta['naxis1'] == 35 assert aia_srot.meta['naxis2'] == 18
def test_diffrot_submap(aia171_test_submap): # Test a submap without padding aia_srot = diffrot_map(aia171_test_submap, '2011-02-14T12:00:00') assert aia_srot.dimensions == aia171_test_submap.dimensions assert (aia171_test_submap.date - timedelta(days=0.5)) - aia_srot.date < timedelta(seconds=1)
def test_diffrot_map(aia171_test_map): # Test a submap without padding aia_srot = diffrot_map(aia171_test_map, dt=-5 * u.day) assert aia_srot.dimensions == aia171_test_map.dimensions assert (aia171_test_map.date - timedelta(days=5)) - aia_srot.date < timedelta(seconds=1)
def datacube(flist_chunk): # rebin region to desired fraction def rebin(a, *args): shape = a.shape lenShape = len(shape) factor = np.asarray(shape) / np.asarray(args) evList = ['a.reshape('] + \ ['args[%d],factor[%d],'%(i,i) for i in range(lenShape)] + \ [')'] + ['.mean(%d)'%(i+1) for i in range(lenShape)] return eval(''.join(evList)) nf1 = len(flist_chunk) exposure = np.empty((nf1)) timestamp = np.empty((nf1)) visAvg = np.empty((mapShape[0], mapShape[1])) # image data is int16 dCube = np.empty((mapShape[0], mapShape[1], nf1), dtype=np.int16) start_sub = timer() T1 = 0 count = 0 dimCount = 0 # loop through datacube and extract timeseries, timestamps, exposures for filename in flist_chunk: smap = Map(filename).submap(c3, c4) exposure[count] = (smap.exposure_time).value timestamp[count] = Time(smap.date).jd dmap = diffrot_map(smap, time=dt0).data if dmap.shape != mapShape: dimenDiff = np.array(dmap.shape) - np.array(mapShape) dmap = dmap[:dmap.shape[0] - dimenDiff[0], :dmap.shape[1] - dimenDiff[1]] dimCount += 1 visAvg += (dmap / (smap.exposure_time).value) dCube[:, :, count] = dmap count += 1 # estimate time remaining and print to screen T = timer() T2 = T - T1 if count == 0: T_init = T - start_sub T_est = T_init * nf1 else: T_est = T2 * (nf1 - count) T_min, T_sec = divmod(T_est, 60) T_hr, T_min = divmod(T_min, 60) print("Thread %i on row %i/%i, ETR: %i:%.2i:%.2i" % (rank, count, nf1, T_hr, T_min, T_sec), flush=True) T1 = T # ---- trim dataCube and visual image dCube = dCube[diffLatPix:-diffLatPix, xminI:-xminF] visAvg = visAvg[diffLatPix:-diffLatPix, xminI:-xminF] np.save('%s/chunk_%i_of_%i' % (processed_dir, rank + 1, size), dCube) print('Processor: %i, Dimension Errors: %i' % (rank + 1, dimCount), flush=True) #return dCube return exposure, timestamp, visAvg
def test_diffrot_noinputs(aia171_test_map): with pytest.raises(ValueError) as exc_info: diffrot_map(aia171_test_map) assert 'Either a time or an interval (`dt=`) needs to be provided' in str(exc_info.value)
def test_diffrot_submap(aia171_test_submap): # Test a submap without padding aia_srot = diffrot_map(aia171_test_submap, '2011-02-14T12:00:00') assert aia_srot.dimensions == aia171_test_submap.dimensions assert (aia171_test_submap.date - timedelta(days=0.5)) - aia_srot.date < timedelta(seconds=1)
aiamapcube = sunpy.map.Map(AIA_193_CUTOUT01_IMAGE, AIA_193_CUTOUT02_IMAGE, AIA_193_CUTOUT03_IMAGE, cube=True) ############################################################################ # In case of running difference, we loop through all the maps in the # aiamapcube and differentially rotate each map in the mapcube # with respect to the previous map # while in case of base difference we differentially # rotate each map in the mapcube to the time of the base map. # We then store all the difference maps in a list. base_diffmap = [] running_diffmap = [] for i, map_i in enumerate(aiamapcube[1:]): aiamap_rot = diffrot.diffrot_map(map_i, time=aiamapcube[0].date) aiamapcube_rot = diffrot.diffrot_map(aiamapcube[i + 1], time=aiamapcube[i].date) diffdata = map_i.data - aiamap_rot.data smap_base = sunpy.map.Map(diffdata, map_i.meta) diffdata = aiamapcube_rot.data - map_i.data smap_run = sunpy.map.Map(diffdata, map_i.meta) smap_base.plot_settings['cmap'] = plt.get_cmap('Greys_r') smap_base.plot_settings['norm'] = colors.LogNorm(100, smap_base.max()) smap_run.plot_settings['cmap'] = plt.get_cmap('Greys_r') smap_run.plot_settings['norm'] = colors.LogNorm(100, smap_run.max()) base_diffmap.append(smap_base) running_diffmap.append(smap_run) ############################################################################ # This plots the original mapcube
def test_diffrot_submap(aia171_test_submap): # Test a submap without padding aia_srot = diffrot_map(aia171_test_submap, '2011-02-14T12:00:00') assert aia_srot.dimensions == aia171_test_submap.dimensions assert (aia171_test_submap.date - TimeDelta(0.5*u.day)) - aia_srot.date < TimeDelta(1*u.second)
def test_diffrot_map(aia171_test_map): # Test a submap without padding aia_srot = diffrot_map(aia171_test_map, dt=-5 * u.day) assert aia_srot.dimensions == aia171_test_map.dimensions assert (aia171_test_map.date - TimeDelta(5*u.day)) - aia_srot.date < TimeDelta(1*u.second)
# We create the MapCube using the AIA_193_CUTOUT sample data. # To create a MapCube, we can call Map directly and add in a keyword to output a MapCube instead. aiamapcube = sunpy.map.Map(AIA_193_CUTOUT01_IMAGE, AIA_193_CUTOUT02_IMAGE, AIA_193_CUTOUT03_IMAGE, cube=True) ############################################################################ # In case of running difference, we loop through all the maps in the # aiamapcube and differentially rotate each map in the mapcube # with respect to the previous map # while in case of base difference we differentially # rotate each map in the mapcube to the time of the base map. # We then store all the difference maps in a list. base_diffmap = [] running_diffmap = [] for i, map_i in enumerate(aiamapcube[1:]): aiamap_rot = diffrot.diffrot_map(map_i, time=aiamapcube[0].date) aiamapcube_rot = diffrot.diffrot_map(aiamapcube[i+1], time=aiamapcube[i].date) diffdata = map_i.data - aiamap_rot.data smap_base = sunpy.map.Map(diffdata, map_i.meta) diffdata = aiamapcube_rot.data - map_i.data smap_run = sunpy.map.Map(diffdata, map_i.meta) smap_base.plot_settings['cmap'] = plt.get_cmap('Greys_r') smap_base.plot_settings['norm'] = colors.LogNorm(100, smap_base.max()) smap_run.plot_settings['cmap'] = plt.get_cmap('Greys_r') smap_run.plot_settings['norm'] = colors.LogNorm(100, smap_run.max()) base_diffmap.append(smap_base) running_diffmap.append(smap_run) ############################################################################ # This plots the original mapcube aiamapcube.peek()
# We create the MapSequence using the AIA_193_CUTOUT sample data. # To create a MapSequence, we can call Map directly and add in a keyword to output a MapSequence instead. aiamapseq = sunpy.map.Map(AIA_193_CUTOUT01_IMAGE, AIA_193_CUTOUT02_IMAGE, AIA_193_CUTOUT03_IMAGE, sequence=True) ############################################################################ # In case of running difference, we loop through all the maps in the # aiamapseq and differentially rotate each map in the MapSequence # with respect to the previous map # while in case of base difference we differentially # rotate each map in the MapSequence to the time of the base map. # We then store all the difference maps in a list. base_diffmap = [] running_diffmap = [] for i, map_i in enumerate(aiamapseq[1:]): aiamap_rot = diffrot.diffrot_map(map_i, time=aiamapseq[0].date) aiamapseq_rot = diffrot.diffrot_map(map_i, time=aiamapseq[i].date) diffdata = map_i.data - aiamap_rot.data smap_base = sunpy.map.Map(diffdata, map_i.meta) diffdata = aiamapseq_rot.data - map_i.data smap_run = sunpy.map.Map(diffdata, map_i.meta) smap_base.plot_settings['cmap'] = plt.get_cmap('Greys_r') smap_base.plot_settings['norm'] = colors.LogNorm(100, smap_base.max()) smap_run.plot_settings['cmap'] = plt.get_cmap('Greys_r') smap_run.plot_settings['norm'] = colors.LogNorm(100, smap_run.max()) base_diffmap.append(smap_base) running_diffmap.append(smap_run) ############################################################################ # This plots the original MapSequence aiamapseq.peek()
aiamapseq = sunpy.map.Map(AIA_193_CUTOUT01_IMAGE, AIA_193_CUTOUT02_IMAGE, AIA_193_CUTOUT03_IMAGE, sequence=True) ############################################################################ # In case of running difference, we loop through all the maps in the # aiamapseq and differentially rotate each map in the MapSequence # with respect to the previous map # while in case of base difference we differentially # rotate each map in the MapSequence to the time of the base map. # We then store all the difference maps in a list. base_diffmap = [] running_diffmap = [] for i, map_i in enumerate(aiamapseq[1:]): aiamap_rot = diffrot.diffrot_map(map_i, time=aiamapseq[0].date) aiamapseq_rot = diffrot.diffrot_map(map_i, time=aiamapseq[i].date) diffdata = map_i.data - aiamap_rot.data smap_base = sunpy.map.Map(diffdata, map_i.meta) diffdata = aiamapseq_rot.data - map_i.data smap_run = sunpy.map.Map(diffdata, map_i.meta) smap_base.plot_settings['cmap'] = plt.get_cmap('Greys_r') smap_base.plot_settings['norm'] = colors.LogNorm(100, smap_base.max()) smap_run.plot_settings['cmap'] = plt.get_cmap('Greys_r') smap_run.plot_settings['norm'] = colors.LogNorm(100, smap_run.max()) base_diffmap.append(smap_base) running_diffmap.append(smap_run) ############################################################################ # This plots the original MapSequence aiamapseq.peek()
def test_diffrot_manyinputs(aia171_test_map): with pytest.raises(ValueError) as exc_info: diffrot_map(aia171_test_map, '2010-01-01', dt=3 * u.hour) assert 'Only a time or an interval is accepted' in str(exc_info.value)
def test_diffrot_noinputs(aia171_test_map): with pytest.raises(ValueError) as exc_info: diffrot_map(aia171_test_map) assert 'Either a time or an interval (`dt=`) needs to be provided' in str(exc_info.value)
def test_diffrot_allen_submap_pad(aia171_test_submap): aia_srot = diffrot_map(aia171_test_submap, dt=-0.5 * u.day, pad=True, rot_type='allen') assert aia_srot.dimensions >= aia171_test_submap.dimensions assert (aia171_test_submap.date - TimeDelta(0.5*u.day)) - aia_srot.date < TimeDelta(1*u.second) assert aia_srot.meta['naxis1'] == 35 assert aia_srot.meta['naxis2'] == 18
def test_diffrot_map(aia171_test_map): # Test a submap without padding aia_srot = diffrot_map(aia171_test_map, dt=-5 * u.day) assert aia_srot.dimensions == aia171_test_map.dimensions assert (aia171_test_map.date - timedelta(days=5)) - aia_srot.date < timedelta(seconds=1)
def test_diffrot_map(aia171_test_map): # Test a submap without padding aia_srot = diffrot_map(aia171_test_map, dt=-5 * u.day) assert aia_srot.dimensions == aia171_test_map.dimensions assert (aia171_test_map.date - TimeDelta(5 * u.day)) - aia_srot.date < TimeDelta(1 * u.second)
def test_diffrot_manyinputs(aia171_test_map): with pytest.raises(ValueError) as exc_info: diffrot_map(aia171_test_map, '2010-01-01', dt=3 * u.hour) assert 'Only a time or an interval is accepted' in str(exc_info.value)
def test_diffrot_submap(aia171_test_submap): # Test a submap without padding aia_srot = diffrot_map(aia171_test_submap, '2011-02-14T12:00:00') assert aia_srot.dimensions == aia171_test_submap.dimensions assert (aia171_test_submap.date - TimeDelta(0.5 * u.day)) - aia_srot.date < TimeDelta(1 * u.second)
def pltEovsaQlookImageSeries(timobjs, spws, vmaxs, vmins, aiawave, bd, fig=None, axs=None, imgoutdir=None, overwrite=False, verbose=False): from astropy.visualization.stretch import AsinhStretch from astropy.visualization import ImageNormalize plt.ioff() imgfiles = [] dpi = 512. / 4 aiaDataSource = { "0094": 8, "0193": 11, "0335": 14, # "4500": 17, "0171": 10, "0304": 13, "0131": 9, "1700": 16, "0211": 12, # "1600": 15, "_HMIcont": 18, "_HMImag": 19 } tmjd = timobjs.mjd tmjd_base = np.floor(tmjd) tmjd_hr = (tmjd - tmjd_base) * 24 for tidx, timobj in enumerate(tqdm(timobjs)): dateobj = timobj.to_datetime() timestr = dateobj.strftime("%Y-%m-%dT%H:%M:%SZ") tstrname = dateobj.strftime("%Y%m%dT%H%M%SZ") datestrdir = dateobj.strftime("%Y/%m/%d/") imgindir = imgfitsdir + datestrdir timobj_prevday = Time(tmjd[tidx] - 1, format='mjd') dateobj_prevday = timobj_prevday.to_datetime() datestrdir_prevday = dateobj_prevday.strftime("%Y/%m/%d/") imgindir_prevday = imgfitsdir + datestrdir_prevday # if not os.path.exists(imgindir): os.makedirs(imgindir) cmap = cm_smap.get_cmap('sdoaia304') if verbose: print('Processing EOVSA images for date {}'.format( dateobj.strftime('%Y-%m-%d'))) key, sourceid = aiawave, aiaDataSource[aiawave] s, sp = bd, spws[bd] figoutname = os.path.join( imgoutdir, 'eovsa_bd{:02d}_aia{}_{}.jpg'.format(s + 1, key, tstrname)) if overwrite or (not os.path.exists(figoutname)): ax = axs[0] ax.cla() spwstr = '-'.join( ['{:02d}'.format(int(sp_)) for sp_ in sp.split('~')]) t_hr = tmjd_hr[tidx] t_hr_st_blend = 2.0 t_hr_ed_blend = 14.0 if t_hr <= 8.0: eofile = imgindir_prevday + 'eovsa_{}.spw{}.tb.disk.fits'.format( dateobj_prevday.strftime('%Y%m%d'), spwstr) else: eofile = imgindir + 'eovsa_{}.spw{}.tb.disk.fits'.format( dateobj.strftime('%Y%m%d'), spwstr) if not os.path.exists(eofile): continue stretch = AsinhStretch(a=0.15) norm = ImageNormalize(vmin=vmins[s], vmax=vmaxs[s], stretch=stretch) eomap = er.readfits(eofile) eomap = eomap.resample(u.Quantity(eomap.dimensions) / 2) eomap.data[np.isnan(eomap.data)] = 0.0 eomap_rot = diffrot_map(eomap, time=timobj) offlimbidx = np.where(eomap_rot.data == eomap_rot.data[0, 0]) eomap_rot.data[offlimbidx] = eomap.data[offlimbidx] t_hr = tmjd_hr[tidx] if t_hr_st_blend <= t_hr <= t_hr_ed_blend: if t_hr <= 8.0: eofile_blend = imgindir + 'eovsa_{}.spw{}.tb.disk.fits'.format( dateobj.strftime('%Y%m%d'), spwstr) alpha = 1.0 - (t_hr - t_hr_st_blend) / (t_hr_ed_blend - t_hr_st_blend) else: eofile_blend = imgindir_prevday + 'eovsa_{}.spw{}.tb.disk.fits'.format( dateobj_prevday.strftime('%Y%m%d'), spwstr) alpha = (t_hr - t_hr_st_blend) / (t_hr_ed_blend - t_hr_st_blend) alpha_blend = 1.0 - alpha eomap_blend = er.readfits(eofile_blend) eomap_blend = eomap_blend.resample( u.Quantity(eomap_blend.dimensions) / 2) eomap_blend.data[np.isnan(eomap_blend.data)] = 0.0 eomap_rot_blend = diffrot_map(eomap_blend, time=timobj) offlimbidx = np.where( eomap_rot_blend.data == eomap_rot_blend.data[0, 0]) eomap_rot_blend.data[offlimbidx] = eomap_blend.data[offlimbidx] eomap_rot_plt = smap.Map((eomap_rot.data * alpha + eomap_rot_blend.data * alpha_blend), eomap_rot.meta) else: eomap_rot_plt = eomap_rot # eomap_plt.plot(axes=ax, cmap=cmap, norm=norm) eomap_rot_plt.plot(axes=ax, cmap=cmap, norm=norm) ax.set_xlabel('') ax.set_ylabel('') ax.set_xticklabels([]) ax.set_yticklabels([]) ax.text(0.02, 0.02, 'EOVSA {:.1f} GHz {}'.format( eomap.meta['CRVAL3'] / 1e9, dateobj.strftime('%d-%b-%Y %H:%M UT')), transform=ax.transAxes, color='w', ha='left', va='bottom', fontsize=9) ax.text(0.98, 0.02, 'Max Tb {:.0f} K'.format(np.nanmax(eomap.data)), transform=ax.transAxes, color='w', ha='right', va='bottom', fontsize=9) ax.set_xlim(-1227, 1227) ax.set_ylim(-1227, 1227) ax = axs[1] # for key, sourceid in aiaDataSource.items(): ax.cla() if not os.path.exists(imgoutdir): os.makedirs(imgoutdir) sdourl = 'https://api.helioviewer.org/v2/getJP2Image/?date={}&sourceId={}'.format( timestr, sourceid) # print(sdourl) sdofile = os.path.join(imgoutdir, 'AIA' + key + '.{}.jp2'.format(tstrname)) if not os.path.exists(sdofile): urllib.request.urlretrieve(sdourl, sdofile) if not os.path.exists(sdofile): continue sdomap = smap.Map(sdofile) norm = colors.Normalize() # sdomap_ = pmX.Sunmap(sdomap) if "HMI" in key: cmap = plt.get_cmap('gray') else: cmap = cm_smap.get_cmap('sdoaia' + key.lstrip('0')) sdomap.plot(axes=ax, cmap=cmap, norm=norm) # sdomap_.imshow(axes=ax, cmap=cmap, norm=norm) # sdomap_.draw_limb(axes=ax, lw=0.25, alpha=0.5) # sdomap_.draw_grid(axes=ax, grid_spacing=10. * u.deg, lw=0.25) ax.set_xlabel('') ax.set_ylabel('') ax.set_xticklabels([]) ax.set_yticklabels([]) ax.text(0.02, 0.02, '{}/{} {} {}'.format( sdomap.observatory, sdomap.instrument.split(' ')[0], sdomap.measurement, sdomap.date.strftime('%d-%b-%Y %H:%M UT')), transform=ax.transAxes, color='w', ha='left', va='bottom', fontsize=9) ax.set_xlim(-1227, 1227) ax.set_ylim(-1227, 1227) fig.savefig(figoutname, dpi=np.int(dpi), quality=85) imgfiles.append(figoutname) return imgfiles
c3 = SkyCoord((x1 - diffLon) * u.arcsec, y1 * u.arcsec, frame=frames.Helioprojective) c4 = SkyCoord((x2 + diffLon) * u.arcsec, y2 * u.arcsec, frame=frames.Helioprojective) # get middle frame subregion & time to anchor derotation midmap = Map(flist[mid_file]).submap(c3, c4) dt0 = midmap.date mapShape = midmap.data.shape # calculate pixels to trim based off of what actual derotation trims # *for some reason this result is different than method above diffMapI = diffrot_map(mapI.submap(c3, c4), time=dt0) diffMapF = diffrot_map(mapF.submap(c3, c4), time=dt0) xminindI = np.argmin(np.fliplr(diffMapI.data), axis=1)[diffLatPix:-diffLatPix] xminindF = np.argmin(diffMapF.data, axis=1)[diffLatPix:-diffLatPix] xminI = mapShape[1] - np.min(xminindI) xminF = mapShape[1] - np.min(xminindF) del new_mapcube1, mc_shifts, diffMapI, diffMapF # specify which chunks should be handled by each processor subcube = np.array_split(flist, size)[rank] start = timer()