def dlonlat_at_grid_center(ctr_lat, ctr_lon, dx=4.0e3, dy=4.0e3, x_bnd = (-100e3, 100e3), y_bnd = (-100e3, 100e3), proj_datum = 'WGS84', proj_ellipse = 'WGS84'): """ Utility function useful for producing a regular grid of lat/lon data, where an approximate spacing (dx, dy) and total span of the grid (x_bnd, y_bnd) is desired. Units are in meters. There is guaranteed to be distortion away from the grid center, i.e., only the grid cells adjacent to the center location will have area dx * dy. Likewise, the lat, lon range is calculated naively using dlat, dlon multiplied by the number of grid cells implied by x_bnd/dx, y_bnd/dy. This is the naive approach, but probably what's expected when specifying distances in kilometers for an inherently distorted lat/lon grid. Returns: (dlon, dlat, lon_bnd, lat_bnd) corresponding to (dx, dy, x_range, y_range) """ # Use the Azimuthal equidistant projection as the method for converting to kilometers. proj_name = 'aeqd' mapProj = MapProjection(projection=proj_name, ctrLat=ctr_lat, ctrLon=ctr_lon, lat_ts=ctr_lat, lon_0=ctr_lon, lat_0=ctr_lat, lat_1=ctr_lat, ellipse=proj_ellipse, datum=proj_datum) geoProj = GeographicSystem() # Get dlat lon_n, lat_n, z_n = geoProj.fromECEF(*mapProj.toECEF(0,dy,0)) dlat = lat_n - ctr_lat # Get dlon lon_e, lat_e, z_e = geoProj.fromECEF(*mapProj.toECEF(dx,0,0)) dlon = lon_e - ctr_lon lon_min = ctr_lon + dlon * (x_bnd[0]/dx) lon_max = ctr_lon + dlon * (x_bnd[1]/dx) lat_min = ctr_lat + dlat * (y_bnd[0]/dy) lat_max = ctr_lat + dlat * (y_bnd[1]/dy) # Alternate method: lat lon for the actual distance to the NSEW in the projection #lon_range_n, lat_range_n, z_range_n = geoProj.fromECEF(*mapProj.toECEF(0,y_bnd,0)) #lon_range_e, lat_range_e, z_range_e = geoProj.fromECEF(*mapProj.toECEF(x_bnd,0,0)) return dlon, dlat, (lon_min, lon_max), (lat_min, lat_max)
def test_fixed_grid_GOESR(): """ Tests from the GOES-R PUG Volume 3, L1b data """ sat_lon_nadir = -75.0 goes_sweep = 'x' # Meteosat is 'y' ellipse = 'GRS80' datum = 'WGS84' sat_ecef_height = 35786023.0 geofixcs = GeostationaryFixedGridSystem(subsat_lon=sat_lon_nadir, ellipse=ellipse, datum=datum, sweep_axis=goes_sweep, sat_ecef_height=sat_ecef_height) latloncs = GeographicSystem(ellipse=ellipse, datum=datum) test_lat = 33.846162 test_lon = -84.690932 test_alt = 0.0 test_fixx = -0.024052 test_fixy = 0.095340 test_fixz = 0.0 atol = 1e-6 # Test forward from geodetic X, Y, Z = latloncs.toECEF(test_lon, test_lat, test_alt) x, y, z = geofixcs.fromECEF(X, Y, Z) assert_allclose(test_fixx, x, rtol=atol) assert_allclose(test_fixy, y, rtol=atol) assert_allclose(test_fixz, z, rtol=atol) # print(test_fixx, test_fixy, test_fixz) # print(x,y,z) # Test inverse from fixed grid angle X, Y, Z = geofixcs.toECEF(test_fixx, test_fixy, test_fixz) x, y, z = latloncs.fromECEF(X, Y, Z) assert_allclose(test_lon, x, atol=atol) assert_allclose(test_lat, y, atol=atol) assert_allclose(test_alt, z, atol=atol)
def test_fixed_grid_GOESR(): """ Tests from the GOES-R PUG Volume 3, L1b data """ sat_lon_nadir = -75.0 goes_sweep = 'x' # Meteosat is 'y' ellipse = 'GRS80' datum = 'WGS84' sat_ecef_height=35786023.0 geofixcs = GeostationaryFixedGridSystem(subsat_lon=sat_lon_nadir, ellipse=ellipse, datum=datum, sweep_axis=goes_sweep, sat_ecef_height=sat_ecef_height) latloncs = GeographicSystem(ellipse=ellipse, datum=datum) test_lat = 33.846162 test_lon = -84.690932 test_alt = 0.0 test_fixx = -0.024052 test_fixy = 0.095340 test_fixz = 0.0 atol = 1e-6 # Test forward from geodetic X,Y,Z = latloncs.toECEF(test_lon, test_lat, test_alt) x, y, z = geofixcs.fromECEF(X, Y, Z) assert_allclose(test_fixx, x, rtol=atol) assert_allclose(test_fixy, y, rtol=atol) assert_allclose(test_fixz, z, rtol=atol) # print(test_fixx, test_fixy, test_fixz) # print(x,y,z) # Test inverse from fixed grid angle X,Y,Z = geofixcs.toECEF(test_fixx, test_fixy, test_fixz) x, y, z = latloncs.fromECEF(X, Y, Z) assert_allclose(test_lon, x, atol=atol) assert_allclose(test_lat, y, atol=atol) assert_allclose(test_alt, z, atol=atol)
def dlonlat_at_grid_center(ctr_lat, ctr_lon, dx=4.0e3, dy=4.0e3, x_bnd=(-100e3, 100e3), y_bnd=(-100e3, 100e3), proj_datum='WGS84', proj_ellipse='WGS84'): """ Utility function useful for producing a regular grid of lat/lon data, where an approximate spacing (dx, dy) and total span of the grid (x_bnd, y_bnd) is desired. Units are in meters. There is guaranteed to be distortion away from the grid center, i.e., only the grid cells adjacent to the center location will have area dx * dy. Likewise, the lat, lon range is calculated naively using dlat, dlon multiplied by the number of grid cells implied by x_bnd/dx, y_bnd/dy. This is the naive approach, but probably what's expected when specifying distances in kilometers for an inherently distorted lat/lon grid. Returns: (dlon, dlat, lon_bnd, lat_bnd) corresponding to (dx, dy, x_range, y_range) """ # Use the Azimuthal equidistant projection as the method for converting to kilometers. proj_name = 'aeqd' mapProj = MapProjection(projection=proj_name, ctrLat=ctr_lat, ctrLon=ctr_lon, lat_ts=ctr_lat, lon_0=ctr_lon, lat_0=ctr_lat, lat_1=ctr_lat, ellipse=proj_ellipse, datum=proj_datum) geoProj = GeographicSystem() # Get dlat lon_n, lat_n, z_n = geoProj.fromECEF(*mapProj.toECEF(0, dy, 0)) dlat = lat_n - ctr_lat # Get dlon lon_e, lat_e, z_e = geoProj.fromECEF(*mapProj.toECEF(dx, 0, 0)) dlon = lon_e - ctr_lon lon_min = ctr_lon + dlon * (x_bnd[0] / dx) lon_max = ctr_lon + dlon * (x_bnd[1] / dx) lat_min = ctr_lat + dlat * (y_bnd[0] / dy) lat_max = ctr_lat + dlat * (y_bnd[1] / dy) # Alternate method: lat lon for the actual distance to the NSEW in the projection #lon_range_n, lat_range_n, z_range_n = geoProj.fromECEF(*mapProj.toECEF(0,y_bnd,0)) #lon_range_e, lat_range_e, z_range_e = geoProj.fromECEF(*mapProj.toECEF(x_bnd,0,0)) return dlon, dlat, (lon_min, lon_max), (lat_min, lat_max)
def grid_h5flashfiles(h5_filenames, start_time, end_time, frame_interval=120.0, dx=4.0e3, dy=4.0e3, dz=1.0e3, x_bnd = (-100e3, 100e3), y_bnd = (-100e3, 100e3), z_bnd = (0e3, 20e3), ctr_lat = 35.23833, ctr_lon = -97.46028, ctr_alt=0.0, min_points_per_flash=10, outpath = '', flash_count_logfile = None, proj_name = 'aeqd', proj_datum = 'WGS84', proj_ellipse = 'WGS84', output_writer = write_cf_netcdf, output_writer_3d = write_cf_netcdf_3d, output_filename_prefix="LMA", output_kwargs = {}, spatial_scale_factor = 1.0/1000.0, ): from math import ceil """ Create 2D plan-view density grids for events, flash origins, flash extents, and mean flash footprint frame_interval: Frame time-step in seconds dx, dy: horizontal grid size in m (or deg) {x,y,z}_bnd: horizontal grid edges in m ctr_lat, ctr_lon: coordinate center Uses an azimuthal equidistant map projection on the WGS84 ellipsoid. read_flashes filter_flash extract_events flash_to_frame frame0_broadcast, frame1_broadcast, ... each broadcaster above sends events and flashes to: projection( event_location), projection(flash_init_location), projection(event_location) which map respectively to: point_density->accum_on_grid(event density), point_density->accum_on_grid(flash init density), extent_density->accum_on_grid(flash_extent_density) grids are in an HDF5 file. how to handle flushing? """ if flash_count_logfile is None: flash_count_logfile = sys.stdout # reference time is the date part of the start_time t_edges, duration = time_edges(start_time, end_time, frame_interval) t_ref, t_edges_seconds = seconds_since_start_of_day(start_time, t_edges) n_frames = len(t_edges)-1 xedge=np.arange(x_bnd[0], x_bnd[1]+dx, dx) yedge=np.arange(y_bnd[0], y_bnd[1]+dy, dy) zedge=np.arange(z_bnd[0], z_bnd[1]+dz, dz) x0 = xedge[0] y0 = yedge[0] z0 = zedge[0] if proj_name == 'latlong': dx_units = '{0:6.4f}deg'.format(dx) mapProj = GeographicSystem() else: dx_units = '{0:5.1f}m'.format(dx) mapProj = MapProjection(projection=proj_name, ctrLat=ctr_lat, ctrLon=ctr_lon, lat_ts=ctr_lat, lon_0=ctr_lon, lat_0=ctr_lat, lat_1=ctr_lat, ellipse=proj_ellipse, datum=proj_datum) geoProj = GeographicSystem() event_density_grid = np.zeros((xedge.shape[0]-1, yedge.shape[0]-1, n_frames), dtype='int32') init_density_grid = np.zeros((xedge.shape[0]-1, yedge.shape[0]-1, n_frames), dtype='int32') extent_density_grid = np.zeros((xedge.shape[0]-1, yedge.shape[0]-1, n_frames), dtype='int32') footprint_grid = np.zeros((xedge.shape[0]-1, yedge.shape[0]-1, n_frames), dtype='float32') event_density_grid_3d = np.zeros((xedge.shape[0]-1, yedge.shape[0]-1, zedge.shape[0]-1, n_frames), dtype='int32') init_density_grid_3d = np.zeros((xedge.shape[0]-1, yedge.shape[0]-1, zedge.shape[0]-1, n_frames), dtype='int32') extent_density_grid_3d = np.zeros((xedge.shape[0]-1, yedge.shape[0]-1, zedge.shape[0]-1, n_frames), dtype='int32') footprint_grid_3d = np.zeros((xedge.shape[0]-1, yedge.shape[0]-1, zedge.shape[0]-1, n_frames), dtype='float32') all_frames = [] # extent_frames = [] # init_frames = [] # event_frames = [] # extent_frames_3d = [] # init_frames_3d = [] # event_frames_3d = [] for i in range(n_frames): extent_out = {'name':'extent'} init_out = {'name':'init'} event_out = {'name':'event'} extent_out_3d = {'name':'extent_3d'} init_out_3d = {'name':'init_3d'} event_out_3d = {'name':'event_3d'} accum_event_density = density_to_files.accumulate_points_on_grid(event_density_grid[:,:,i], xedge, yedge, out=event_out, label='event') accum_init_density = density_to_files.accumulate_points_on_grid(init_density_grid[:,:,i], xedge, yedge, out=init_out, label='init') accum_extent_density = density_to_files.accumulate_points_on_grid(extent_density_grid[:,:,i], xedge, yedge, out=extent_out,label='extent') accum_footprint = density_to_files.accumulate_points_on_grid(footprint_grid[:,:,i], xedge, yedge, label='footprint') accum_event_density_3d = density_to_files.accumulate_points_on_grid_3d(event_density_grid_3d[:,:,:,i], xedge, yedge, zedge, out=event_out_3d, label='event_3d') accum_init_density_3d = density_to_files.accumulate_points_on_grid_3d(init_density_grid_3d[:,:,:,i], xedge, yedge, zedge, out=init_out_3d, label='init_3d') accum_extent_density_3d = density_to_files.accumulate_points_on_grid_3d(extent_density_grid_3d[:,:,:,i], xedge, yedge, zedge, out=extent_out_3d,label='extent_3d') accum_footprint_3d = density_to_files.accumulate_points_on_grid_3d(footprint_grid_3d[:,:,:,i], xedge, yedge, zedge, label='footprint_3d') extent_out['func'] = accum_extent_density init_out['func'] = accum_init_density event_out['func'] = accum_event_density # extent_frames.append(extent_out) # init_frames.append(init_out) # event_frames.append(event_out) extent_out_3d['func'] = accum_extent_density_3d init_out_3d['func'] = accum_init_density_3d event_out_3d['func'] = accum_event_density_3d # extent_frames_3d.append(extent_out_3d) # init_frames_3d.append(init_out_3d) # event_frames_3d.append(event_out_3d) event_density_target = density_to_files.point_density(accum_event_density) init_density_target = density_to_files.point_density(accum_init_density) extent_density_target = density_to_files.extent_density(x0, y0, dx, dy, accum_extent_density) mean_footprint_target = density_to_files.extent_density(x0, y0, dx, dy, accum_footprint, weight_key='area') event_density_target_3d = density_to_files.point_density_3d(accum_event_density_3d) init_density_target_3d = density_to_files.point_density_3d(accum_init_density_3d) extent_density_target_3d = density_to_files.extent_density_3d(x0, y0, z0, dx, dy, dz, accum_extent_density_3d) mean_footprint_target_3d = density_to_files.extent_density_3d(x0, y0, z0, dx, dy, dz, accum_footprint_3d, weight_key='area') spew_to_density_types = broadcast( ( density_to_files.project('lon', 'lat', 'alt', mapProj, geoProj, event_density_target, use_flashes=False), density_to_files.project('init_lon', 'init_lat', 'init_alt', mapProj, geoProj, init_density_target, use_flashes=True), density_to_files.project('lon', 'lat', 'alt', mapProj, geoProj, extent_density_target, use_flashes=False), density_to_files.project('lon', 'lat', 'alt', mapProj, geoProj, mean_footprint_target, use_flashes=False), density_to_files.project('lon', 'lat', 'alt', mapProj, geoProj, event_density_target_3d, use_flashes=False), density_to_files.project('init_lon', 'init_lat', 'init_alt', mapProj, geoProj, init_density_target_3d, use_flashes=True), density_to_files.project('lon', 'lat', 'alt', mapProj, geoProj, extent_density_target_3d, use_flashes=False), density_to_files.project('lon', 'lat', 'alt', mapProj, geoProj, mean_footprint_target_3d, use_flashes=False), ) ) all_frames.append( density_to_files.extract_events_for_flashes( spew_to_density_types ) ) frame_count_log = density_to_files.flash_count_log(flash_count_logfile) framer = density_to_files.flashes_to_frames(t_edges_seconds, all_frames, time_key='start', time_edges_datetime=t_edges, flash_counter=frame_count_log) read_flashes( h5_filenames, framer, base_date=t_ref, min_points=min_points_per_flash) # print 'event_density_grid ', id(event_density_grid[:,:,-1]) # print 'extent_density_grid', id(extent_density_grid[:,:,-1]) # print 'init_density_grid ', id(init_density_grid[:,:,-1]) x_coord = (xedge[:-1] + xedge[1:])/2.0 y_coord = (yedge[:-1] + yedge[1:])/2.0 z_coord = (zedge[:-1] + zedge[1:])/2.0 nx = x_coord.shape[0] ny = y_coord.shape[0] nz = z_coord.shape[0] x_all, y_all = (a.T for a in np.meshgrid(x_coord, y_coord)) assert x_all.shape == y_all.shape assert x_all.shape[0] == nx assert x_all.shape[1] == ny z_all = np.zeros_like(x_all) grid_shape_3d = (nx,ny,nz) x_ones_3d = np.ones(grid_shape_3d, dtype='f4') y_ones_3d = np.ones(grid_shape_3d, dtype='f4') z_ones_3d = np.ones(grid_shape_3d, dtype='f4') x_all_3d = x_coord[:, None, None]*x_ones_3d y_all_3d = y_coord[None,:,None]*y_ones_3d z_all_3d = z_coord[None, None, :]*z_ones_3d lons, lats, alts = x,y,z = geoProj.fromECEF( *mapProj.toECEF(x_all, y_all, z_all) ) lons.shape=x_all.shape lats.shape=y_all.shape lons_3d, lats_3d, alts_3d = x_3d,y_3d,z_3d = geoProj.fromECEF( *mapProj.toECEF(x_all_3d, y_all_3d, z_all_3d) ) lons_3d.shape=x_all_3d.shape lats_3d.shape=y_all_3d.shape alts_3d.shape=z_all_3d.shape outflile_basename = os.path.join(outpath,'%s_%s_%d_%dsrc_%s-dx_' % (output_filename_prefix, start_time.strftime('%Y%m%d_%H%M%S'), to_seconds(duration), min_points_per_flash, dx_units)) outfiles = (outflile_basename+'flash_extent.nc', outflile_basename+'flash_init.nc', outflile_basename+'source.nc', outflile_basename+'footprint.nc', ) outfiles_3d = (outflile_basename+'flash_extent_3d.nc', outflile_basename+'flash_init_3d.nc', outflile_basename+'source_3d.nc', outflile_basename+'footprint_3d.nc', ) outgrids = (extent_density_grid, init_density_grid, event_density_grid, footprint_grid, ) outgrids_3d = (extent_density_grid_3d, init_density_grid_3d, event_density_grid_3d, footprint_grid_3d,) field_names = ('flash_extent', 'flash_initiation', 'lma_source', 'flash_footprint') field_descriptions = ('LMA flash extent density', 'LMA flash initiation density', 'LMA source density', 'LMA local mean flash area') if proj_name=='latlong': density_units = "grid" density_units_3d = "grid" else: density_units = "{0:5.1f} km^2".format(dx/1000.0 * dy/1000.0).lstrip() density_units_3d = "{0:5.1f} km^3".format(dx/1000.0 * dy/1000.0 * dz/1000.0).lstrip() time_units = "{0:5.1f} min".format(frame_interval/60.0).lstrip() density_label = 'Count per ' + density_units + " pixel per "+ time_units density_label_3d = 'Count per ' + density_units_3d + " pixel per "+ time_units field_units = ( density_label, density_label, density_label, "km^2 per flash", ) field_units_3d = ( density_label_3d, density_label_3d, density_label_3d, "km^2 per flash", ) output_writer(outfiles[0], t_ref, np.asarray(t_edges_seconds[:-1]), x_coord*spatial_scale_factor, y_coord*spatial_scale_factor, lons, lats, ctr_lat, ctr_lon, outgrids[0], field_names[0], field_descriptions[0], grid_units=field_units[0], **output_kwargs) output_writer(outfiles[1], t_ref, np.asarray(t_edges_seconds[:-1]), x_coord*spatial_scale_factor, y_coord*spatial_scale_factor, lons, lats, ctr_lat, ctr_lon, outgrids[1], field_names[1], field_descriptions[1], grid_units=field_units[1], **output_kwargs) output_writer(outfiles[2], t_ref, np.asarray(t_edges_seconds[:-1]), x_coord*spatial_scale_factor, y_coord*spatial_scale_factor, lons, lats, ctr_lat, ctr_lon, outgrids[2], field_names[2], field_descriptions[2], grid_units=field_units[2], **output_kwargs) output_writer(outfiles[3], t_ref, np.asarray(t_edges_seconds[:-1]), x_coord*spatial_scale_factor, y_coord*spatial_scale_factor, lons, lats, ctr_lat, ctr_lon, outgrids[3], field_names[3], field_descriptions[3], format='f', grid_units=field_units[3], **output_kwargs) output_writer_3d(outfiles_3d[0], t_ref, np.asarray(t_edges_seconds[:-1]), x_coord*spatial_scale_factor, y_coord*spatial_scale_factor, z_coord*spatial_scale_factor, lons_3d, lats_3d, alts_3d, ctr_lat, ctr_lon, ctr_alt, outgrids_3d[0], field_names[0], field_descriptions[0], grid_units=field_units_3d[0], **output_kwargs) output_writer_3d(outfiles_3d[1], t_ref, np.asarray(t_edges_seconds[:-1]), x_coord*spatial_scale_factor, y_coord*spatial_scale_factor, z_coord*spatial_scale_factor, lons_3d, lats_3d, alts_3d, ctr_lat, ctr_lon, ctr_alt, outgrids_3d[1], field_names[1], field_descriptions[1], grid_units=field_units_3d[1], **output_kwargs) output_writer_3d(outfiles_3d[2], t_ref, np.asarray(t_edges_seconds[:-1]), x_coord*spatial_scale_factor, y_coord*spatial_scale_factor, z_coord*spatial_scale_factor, lons_3d, lats_3d, alts_3d, ctr_lat, ctr_lon, ctr_alt, outgrids_3d[2], field_names[2], field_descriptions[2], grid_units=field_units_3d[2], **output_kwargs) output_writer_3d(outfiles_3d[3], t_ref, np.asarray(t_edges_seconds[:-1]), x_coord*spatial_scale_factor, y_coord*spatial_scale_factor, z_coord*spatial_scale_factor, lons_3d, lats_3d, alts_3d, ctr_lat, ctr_lon, ctr_alt, outgrids_3d[3], field_names[3], field_descriptions[3], format='f', grid_units=field_units_3d[3], **output_kwargs) print('max extent is', extent_density_grid.max()) return x_coord, y_coord, z_coord, lons, lats, alts, extent_density_grid, outfiles, field_names