def test_potential_extrapolator_subclass(): # Parameters for the extrapolator xrange = u.Quantity([50, 300] * u.arcsec) yrange = u.Quantity([-350, -100] * u.arcsec) zrange = u.Quantity([0, 250] * u.arcsec) shape = u.Quantity([5, 5, 5] * u.pixel) # Load HMI map (from fits file) then submap and resample. hmi_filename = pkg_resources.resource_filename('solarbextrapolation', 'data/sdo-hmi_2011-02-14_20-34-12.fits') map_boundary = sunpy.map.Map(hmi_filename) map_boundary = map_boundary.submap(xrange, yrange).resample(shape[0:2], method='linear') # Extrapolate using python native code aPotExt = PotentialExtrapolator(map_boundary, zshape=shape[2].value, zrange=zrange) aMap3D = aPotExt.extrapolate(enable_numba=False) # Extrapolate using numba aMap3D = aPotExt.extrapolate()
# Generate the data and make into a map arr_data = generate_example_data(arr_grid_shape[0:2], xrange, yrange, arrA0, arrA1) map_boundary = dummyDataToMap(arr_data, xrange, yrange) ############################################################################## # You can check the resulting generated data by using peek(). map_boundary.peek() ############################################################################## # You now simply want to extrapolate using this boundary data, this is achieved # by first creating a potential extrapolator object and then by running the # extrapolate on this to return a Map3D object with the resulting vector field. # Use potential extrapolator to generate field aPotExt = PotentialExtrapolator(map_boundary, zshape=arr_grid_shape[2], zrange=zrange) aMap3D = aPotExt.extrapolate(enable_numba=True) # The Extrapolations run time is stored in the meta floSeconds = np.round(aMap3D.meta['extrapolator_duration'],3) print('\nextrapolation duration: ' + str(floSeconds) + ' s\n') ############################################################################## # Note that you used enable_numba=True to speed up the computation on systems # with Anaconda numba installed. ############################################################################## # You can now get a quick and easy visualisation using the # solarbextrapolation.example_data_generator.visualise tools: # Visualise the 3D vector field
arr_data = generate_example_data(arr_grid_shape[0:2], xrange, yrange, arrA0, arrA1) map_boundary = dummyDataToMap(arr_data, xrange, yrange) ############################################################################## # You can check the resulting generated data by using peek(). map_boundary.peek() ############################################################################## # You now simply want to extrapolate using this boundary data, this is achieved # by first creating a potential extrapolator object and then by running the # extrapolate on this to return a Map3D object with the resulting vector field. # Use potential extrapolator to generate field aPotExt = PotentialExtrapolator(map_boundary, zshape=arr_grid_shape[2], zrange=zrange) aMap3D = aPotExt.extrapolate(enable_numba=True) # The Extrapolations run time is stored in the meta floSeconds = np.round(aMap3D.meta['extrapolator_duration'], 3) print('\nextrapolation duration: ' + str(floSeconds) + ' s\n') ############################################################################## # Note that you used enable_numba=True to speed up the computation on systems # with Anaconda numba installed. ############################################################################## # You can now get a quick and easy visualisation using the # solarbextrapolation.example_data_generator.visualise tools:
dimensions = u.Quantity([100, 100] * u.pixel) map_hmi_cropped_resampled = map_hmi_cropped.resample(dimensions, method='linear') # Open the map and create a cropped version for the visualisation. #map_boundary = mp.Map('C:\\git\\solarbextrapolation\\examples\\2011-02-14__20-35-25__02_aia.fits') # For AIA map_boundary = mp.Map( 'C:\\git\\solarbextrapolation\\examples\\2011-02-14__20-35-25__01_hmi.fits' ) # For HMI map_boundary_cropped = map_boundary.submap(xrangeextended, yrangeextended) # Only extrapolate if we don't have a saved version if not os.path.isfile(str_vol_filepath): aPotExt = PotentialExtrapolator(map_hmi_cropped_resampled, filepath=str_vol_filepath, zshape=dimensions[0].value, zrange=zrange) aMap3D = aPotExt.extrapolate() aMap3D = Map3D.load(str_vol_filepath) print('\nextrapolation duration: ' + str(np.round(aMap3D.meta['extrapolator_duration'], 3)) + ' s\n') # Visualise this visualise(aMap3D, boundary=map_boundary_cropped, scale=1.0 * u.Mm, boundary_unit=1.0 * u.arcsec, show_boundary_axes=False, show_volume_axes=True, debug=False) mlab.show()
################################################################################ # You can check the resulting generated data by using peek(). map_hmi_cropped_resampled.peek() ################################################################################ # To speed up repeat usage of this script it will save the extrapolation output, # you can use os.path.isfile() to check if the file already exists, assuming it # doesn't you will extrapolate and create it, otherwise you load it. # Only extrapolate if we don't have a saved version str_vol_filepath = data_hmi[0][0:-5] + '_Bxyz.npy' if not os.path.isfile(str_vol_filepath): # Create the potential extrapolator and run the extrapolate method. aPotExt = PotentialExtrapolator(map_hmi_cropped_resampled, filepath=str_vol_filepath, zshape=20, zrange=zrange) aMap3D = aPotExt.extrapolate() # Load the results. aMap3D = Map3D.load(str_vol_filepath) #print '\nextrapolation duration: ' + str(np.round(aMap3D.meta['extrapolator_duration'],3)) + ' s\n' ################################################################################ # For the perposes of visualisation we will want an extended boundary data, not # just that of the extrapolated region, and at the instruments full resolution, # not resampled. xrangeextended = u.Quantity([xrange.value[0] - 50, xrange.value[1] + 50] * xrange.unit) yrangeextended = u.Quantity([yrange.value[0] - 50, yrange.value[1] + 50] * yrange.unit)
generate_example_data(shape[0:2], xrange, yrange, arrA0, arrA1, arrA2, arrA3), xrange, yrange) ]) ############################################################################## # You may wish to run each test more than once, so you can use a parameter to # autimate this. int_trials = 1 # The times to repeat each extrapolation. ############################################################################## # You iterate through the extrapolations on each dataset, adding teh runtime to # the table. for extrapolation in lis_datasets: # Setup the extrapolator and table aPotExt = PotentialExtrapolator(extrapolation[3], zshape=extrapolation[1], zrange=extrapolation[2]) # List to store the trial lis_times = [] # Run the extrapolation without numba for each dataset (map and ranges). for i in range(0, int_trials): aMap3D = aPotExt.extrapolate(enable_numba=False) lis_times.append(aMap3D.meta['extrapolator_duration']) t.add_row([ extrapolation[0], np.round(np.min(lis_times), 2), np.round(np.average(lis_times), 2), np.round(np.std(lis_times), 2) ])