예제 #1
0
def plot_dp(storm, datafile1, datafile2=None):

   #Single file netCDF reading
   ncf=datafile1
   nco=netCDF4.Dataset(ncf)

   #Get fields to plot
   lon=nco.variables['longitude'][:]
   lat=nco.variables['latitude'][:]
   timeindays=nco.variables['time'][:]
   dp=nco.variables['dp'][:]
   triangles=nco.variables['tri'][:,:]

   reflon=np.linspace(lon.min(),lon.max(),1000)
   reflat=np.linspace(lat.min(),lat.max(),1000)
   #reflon=np.linspace(-80.40, -74.75, 1000)
   #reflat=np.linspace(32.50, 36.60, 1000)
   #reflon=np.linspace(-75.70, -71.05, 1000)
   #reflat=np.linspace(38.50, 41.40, 1000)
   reflon,reflat=np.meshgrid(reflon,reflat)

   plt.figure(figsize = [6.4, 3.8])

   flatness=0.10  # flatness is from 0-.5 .5 is equilateral triangle
   triangles=triangles-1  # Correct indices for Python's zero-base
   tri=Triangulation(lon,lat,triangles=triangles)
   mask = TriAnalyzer(tri).get_flat_tri_mask(flatness)
   tri.set_mask(mask)

   # Loop through each time step and plot results
   for ind in range(0, len(timeindays)): 
      plt.clf()
      ax = plt.axes(projection=ccrs.Mercator())

      dt = datetime.datetime.combine(datetime.date(1990, 1, 1), datetime.time(0, 0)) + datetime.timedelta(days=timeindays[ind])
      dstr = datetime.date.strftime(dt,'%Y%m%d%H:%M:%S')
      dstr = dstr[0:8]+' '+dstr[8:17]
      print('Plotting '+dstr)

      par=np.double(dp[ind,:])
      tli=LinearTriInterpolator(tri,par)
      par_interp=tli(reflon,reflat)

      plt.pcolormesh(reflon,reflat,par_interp,vmin=0.0,vmax=360.0,shading='flat',cmap=plt.cm.jet, transform=ccrs.PlateCarree())
      cb = plt.colorbar()
      cb.ax.tick_params(labelsize=8)
      coast = cfeature.GSHHSFeature(scale='high',edgecolor='black',facecolor='none',linewidth=0.25)	
      ax.add_feature(coast)
      plt.xticks(fontsize=9)
      plt.yticks(fontsize=9)
      figtitle = storm.capitalize()+': Peak Dir (deg): '+dstr
      plt.title(figtitle)

      dtlabel = datetime.date.strftime(dt,'%Y%m%d%H%M%S')
      dtlabel = dtlabel[0:8]+'_'+dtlabel[8:14]
      filenm = 'nsem_'+storm+'_dp_'+dtlabel+'.png'
      plt.savefig(filenm,dpi=150,bbox_inches='tight',pad_inches=0.1)

      del(par)
      del(par_interp)
def plot_trisurf(data, out=None, ax=None, angles=None):
    if ax is None:
        fig = plt.figure()
        ax = fig.gca(projection='3d')

    Xs, Ys = np.meshgrid(data.coords[data.dims[0]].values,
                         data.coords[data.dims[1]].values)
    triang = Triangulation(Xs.ravel(), Ys.ravel())
    mask = np.any(np.isnan(data.transpose().values.ravel()[triang.triangles]),
                  axis=1)
    triang.set_mask(mask)

    values = data.copy(deep=True).transpose().values
    values[np.isnan(values)] = 0
    ax.plot_trisurf(triang,
                    values.ravel(),
                    antialiased=True,
                    cmap=cm.coolwarm,
                    linewidth=0)

    if angles is not None:
        ax.view_init(*angles)

    #plt.show()
    return ax
예제 #3
0
def mesh_tri(grid_file):

  ncmesh = Dataset(grid_file,'r')
  lon_mesh = np.rad2deg(ncmesh.variables['lonCell'][:])-360.0
  #lon_mesh = np.rad2deg(np.mod(ncmesh.variables['lonCell'][:] + np.pi, 2.0*np.pi) - np.pi)
  lat_mesh = np.rad2deg(ncmesh.variables['latCell'][:])
  nEdgesOnCell = ncmesh.variables['nEdgesOnCell'][:]
  cellsOnCell = ncmesh.variables['cellsOnCell'][:,:]
 
  # Triangulate cells 
  triangles = Triangulation(lon_mesh,lat_mesh)

  # Compute triangulation mask (needs to be vectorized)
  mask = np.array(np.zeros((triangles.triangles.shape[0],)),dtype=bool)
  ntri = triangles.neighbors.shape[0]
  for i in range(ntri):
    k = 0
    for j in range(3):
      n = triangles.triangles[i,j]
      if nEdgesOnCell[n] != np.where(cellsOnCell[n,:] != 0)[0].size:  # Mask triangles
        k = k +1                                                      # containing
    if k == 3:                                                        # 3 boundary
      mask[i] = True                                                  # cells
  triangles.set_mask(mask)


  return triangles
예제 #4
0
 def plot(self, variable, show=False, index=None):
     if index is None:
         self.animation(
             variable,
             # show=True,
             save='/home/jreniel/pyschism/examples/example_1/test.gif',
             vmin=0,
             vmax=3,
             # start_frame=200,
             # end_frame=300,
         )
     else:
         var = self.nc[variable]
         ugrid = UGrid.from_nc_dataset(self.nc)
         x = ugrid.nodes[:, 0]
         y = ugrid.nodes[:, 1]
         triangulation = Triangulation(x, y, ugrid.faces[:, :3])
         triangulation.set_mask(self.nc['wetdry_elem'][index])
         plt.tricontourf(triangulation,
                         var[index, :],
                         levels=256,
                         cmap='jet')
         plt.gca().axis('scaled')
         if show:
             plt.show()
예제 #5
0
 def buildTriangulation( self, x, y ):
     trig=None
     if qgis_qhull_fails:
         trig=self._buildtrig_workaround(x,y)
     else:
         trig=Triangulation(x,y)
     analyzer=TriAnalyzer(trig)
     mask=analyzer.get_flat_tri_mask()
     trig.set_mask(mask)
     return trig
 def buildTriangulation( self, x, y ):
     trig=None
     if qgis_qhull_fails:
         trig=self._buildtrig_workaround(x,y)
     else:
         trig=Triangulation(x,y)
     analyzer=TriAnalyzer(trig)
     mask=analyzer.get_flat_tri_mask()
     trig.set_mask(mask)
     return trig
예제 #7
0
def makeTri(projx, projy, max_l):
    tri = Triangulation(projx, projy)
    triangles = tri.triangles
    # Mask off unwanted triangles.
    xtri = projx[triangles] - np.roll(projx[triangles], 1, axis=1)
    ytri = projy[triangles] - np.roll(projy[triangles], 1, axis=1)
    ds = np.sqrt(xtri**2 + ytri**2)
    maxi = np.max(ds, axis=1)
    tdist = np.mean(ds)
    tri.set_mask(maxi > max_l)
    return tri, tdist
예제 #8
0
파일: plotting.py 프로젝트: C6xf/fish2eod
def generate_triangles(
    topology, geometry, mask: Optional[Sequence[bool]] = None
) -> Triangulation:
    """Convert topology and geometry to triangles - optionally set mask as well.

    :param topology: Topology of the triangles (connectivity)
    :param geometry: Geometry of the triangles (location of the nodes)
    :param mask: Valid matplotlib mask
    :return: Triangulation object for plotting
    """
    tri = Triangulation(geometry[:, 0], geometry[:, 1], topology)
    if mask:
        tri.set_mask(mask)

    return tri
예제 #9
0
    def plot_magnetic_field_contour(self, ax=None):
        if ax is None:
            fig, ax = plt.subplots()
        else:
            fig = plt.gcf()
        ax.set_aspect('equal')
        
        
        from matplotlib.tri import Triangulation, TriAnalyzer, UniformTriRefiner
        import matplotlib.cm as cm
            
        element_to_magnetic_field = self.magnetic_field_per_element()
        
        x = []
        y = []
        Z = []
        for group in self.mesh.elements_groups:
            for element in group.elements:
                x_center, y_center = element.center
                x.append(x_center)
                y.append(y_center)
                Z.append(element_to_magnetic_field[element].Norm())
        
        tri = Triangulation(x, y)
        
        
        #-----------------------------------------------------------------------------
        # Improving the triangulation before high-res plots: removing flat triangles
        #-----------------------------------------------------------------------------
        # masking badly shaped triangles at the border of the triangular mesh.
        min_circle_ratio = -1 
        mask = TriAnalyzer(tri).get_flat_tri_mask(min_circle_ratio)
        tri.set_mask(mask)
        
        # refining the data
        refiner = UniformTriRefiner(tri)
        subdiv = 3
        tri_refi, z_test_refi = refiner.refine_field(Z, subdiv=subdiv)
        
        levels = npy.arange(0., 1., 0.05)
        cmap = cm.get_cmap(name='Blues', lut=None)
        ax.tricontour(tri_refi, z_test_refi, levels=levels, #cmap=cmap,
                      linewidths=[2.0, 0.5, 1.0, 0.5])
#        ax.triplot(tri_refi, color='0.97')
#        ax.triplot(tri, color='0.7')
#        ax.tricontour(x, y, Z)
        return ax 
예제 #10
0
def plot_samples(num):
    samples_hundred = BM_sampling_method(num)
    tri = Triangulation(samples_hundred[0], samples_hundred[1])
    random_gen = np.random.mtrand.RandomState(seed=127260)
    init_mask_frac = 0.0
    min_circle_ratio = .01
    subdiv = 3

    ntri = tri.triangles.shape[0]

    print 'hi'
    mask_init = np.zeros(ntri, dtype=np.bool)
    masked_tri = random_gen.randint(0, ntri, int(ntri * init_mask_frac))
    mask_init[masked_tri] = True
    tri.set_mask(mask_init)
    print 'hey'

    z_exp = experiment_res(tri.x, tri.y)
    print z_exp

    mask = TriAnalyzer(tri).get_flat_tri_mask(min_circle_ratio)
    tri.set_mask(mask)

    # refining the data
    refiner = UniformTriRefiner(tri)
    tri_refi, z_test_refi = refiner.refine_field(z_exp, subdiv=subdiv)

    # analytical 'results' for comparison
    z_expected = experiment_res(tri_refi.x, tri_refi.y)

    plt.tricontour(tri_refi,
                   z_expected,
                   levels=levels,
                   cmap=cmap,
                   linestyles='--')

    plt.show()
    x, y = np.mgrid[-1:1:0.001, -1:1:0.001]
    pos = np.empty(x.shape + (2, ))
    pos[:, :, 0] = x
    pos[:, :, 1] = y
    rv = multivariate_normal([0, 0], [[1.0, 0.0], [0.0, 1.0]])
    plt.contour(x, y, rv.pdf(pos))
c2 = np.empty([num,3])
for i in range (num):
    c1[i, 0] = b1[i, 0] - b1[i, 1]  # X
    c1[i, 1] = b1[i, 1] - b1[i, 2]
    c1[i, 2] = b1[i, 0] - b1[i, 2]

    c2[i, 0] = b2[i, 0] - b2[i, 1]  # Y
    c2[i, 1] = b2[i, 1] - b2[i, 2]
    c2[i, 2] = b2[i, 0] - b2[i, 2]

c1 = c1 / 1.67e-04
c2 = c2 / 1.67e-04
n =np.hypot(c1,c2).sum(axis=1)

# tri.set_mask(n>0.004)
tri.set_mask(n > MA)


fig1, ax1 = plt.subplots()
ax1.set_aspect('equal')
ax1.triplot(tri, 'bo-', lw=1)
tcf = ax1.tricontourf(tri, z_test)
fig1.colorbar(tcf)
ax1.tricontour(tri, z_test, colors='k')

ax1.set_title('triplot of Delaunay triangulation')
plt.show()


newdata = gpd.GeoDataFrame()
newdata['geometry'] = None
예제 #12
0
def plot_wnd(storm, datafile1, datafile2=None):

    #Single file netCDF reading
    ncf = datafile1
    nco = netCDF4.Dataset(ncf)

    #Get fields to plot
    lon = nco.variables['x'][:]
    lat = nco.variables['y'][:]
    timeinsec = nco.variables['time'][:]
    uwnd = nco.variables['windx'][:]
    vwnd = nco.variables['windy'][:]
    triangles = nco.variables['element'][:, :]

    reflon = np.linspace(lon.min(), lon.max(), 1000)
    reflat = np.linspace(lat.min(), lat.max(), 1000)
    #reflon=np.linspace(-80.40, -74.75, 1000)
    #reflat=np.linspace(32.50, 36.60, 1000)
    #reflon=np.linspace(-75.70, -71.05, 1000)
    #reflat=np.linspace(38.50, 41.40, 1000)
    #reflon=np.linspace(-80.40, -73.35, 1000)
    #reflat=np.linspace(32.50, 39.50, 1000)
    #reflon=np.linspace(-85.30, -78.50, 1000)
    #reflat=np.linspace(23.00, 29.70, 1000)
    reflon, reflat = np.meshgrid(reflon, reflat)

    plt.figure(figsize=[6.4, 3.8])

    flatness = 0.10  # flatness is from 0-.5 .5 is equilateral triangle
    triangles = triangles - 1  # Correct indices for Python's zero-base
    tri = Triangulation(lon, lat, triangles=triangles)
    mask = TriAnalyzer(tri).get_flat_tri_mask(flatness)
    tri.set_mask(mask)

    # Loop through each time step and plot results
    for ind in range(0, len(timeinsec)):
        besttrack = pd.read_csv(PARMnsem + '/storms/' + STORM +
                                '/best_track.txt',
                                header=None,
                                skiprows=4,
                                delim_whitespace=True)
        plt.clf()
        ax = plt.axes(projection=ccrs.Mercator())
        ax.set_extent([-100.00, -50.00, 4.00, 48.00], crs=ccrs.PlateCarree())
        #ax.set_extent([-80.40, -74.75, 32.50, 36.60], crs=ccrs.PlateCarree())
        #ax.set_extent([-80.40, -73.35, 32.50, 39.50], crs=ccrs.PlateCarree())
        #ax.set_extent([-85.30, -78.50, 23.00, 29.70], crs=ccrs.PlateCarree())

        dt = base_info.tide_spin_start_date + datetime.timedelta(
            seconds=timeinsec[ind])
        dstr = datetime.date.strftime(dt, '%Y%m%d%H:%M:%S')
        dstr = dstr[0:8] + ' ' + dstr[8:17]
        print('Plotting ' + dstr)

        par = np.sqrt(
            np.square(np.double(uwnd[ind, :])) +
            np.square(np.double(vwnd[ind, :])))
        tli = LinearTriInterpolator(tri, par)
        par_interp = tli(reflon, reflat)

        plt.pcolormesh(reflon,
                       reflat,
                       par_interp,
                       vmax=60.0,
                       shading='flat',
                       cmap=plt.cm.jet,
                       transform=ccrs.PlateCarree())
        cb = plt.colorbar()
        cb.ax.tick_params(labelsize=8)
        coast = cfeature.GSHHSFeature(scale='high',
                                      edgecolor='black',
                                      facecolor='none',
                                      linewidth=0.25)
        ax.add_feature(coast)
        plt.plot(besttrack.iloc[:, 3].values,
                 besttrack.iloc[:, 2].values,
                 'k--',
                 linewidth=1.0,
                 transform=ccrs.PlateCarree())

        gl = ax.gridlines(crs=ccrs.PlateCarree(),
                          draw_labels=True,
                          linewidth=2,
                          color='gray',
                          alpha=0.5,
                          linestyle='--')
        gl.xlabels_top = False
        gl.ylabels_right = False
        gl.xlines = False
        gl.ylines = False
        gl.xformatter = LONGITUDE_FORMATTER
        gl.yformatter = LATITUDE_FORMATTER
        gl.xlabel_style = {'size': 6, 'color': 'black'}
        gl.ylabel_style = {'size': 6, 'color': 'black'}
        figtitle = storm.capitalize() + ': U10 (m/s): ' + dstr
        plt.title(figtitle)

        dtlabel = datetime.date.strftime(dt, '%Y%m%d%H%M%S')
        dtlabel = dtlabel[0:8] + '_' + dtlabel[8:14]
        filenm = 'nsem_' + storm + '_wnd_' + dtlabel + '.png'
        plt.savefig(filenm, dpi=150, bbox_inches='tight', pad_inches=0.1)

        del (par)
        del (par_interp)
예제 #13
0
    event.canvas.draw()


# Create a Triangulation.
n_angles = 16
n_radii = 5
min_radius = 0.25
radii = np.linspace(min_radius, 0.95, n_radii)
angles = np.linspace(0, 2 * math.pi, n_angles, endpoint=False)
angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1)
angles[:, 1::2] += math.pi / n_angles
x = (radii * np.cos(angles)).flatten()
y = (radii * np.sin(angles)).flatten()
triangulation = Triangulation(x, y)
xmid = x[triangulation.triangles].mean(axis=1)
ymid = y[triangulation.triangles].mean(axis=1)
mask = np.where(xmid * xmid + ymid * ymid < min_radius * min_radius, 1, 0)
triangulation.set_mask(mask)

# Use the triangulation's default TriFinder object.
trifinder = triangulation.get_trifinder()

# Setup plot and callbacks.
plt.subplot(111, aspect='equal')
plt.triplot(triangulation, 'bo-')
polygon = Polygon([[0, 0], [0, 0]], facecolor='y')  # dummy data for xs,ys
update_polygon(-1)
plt.gca().add_patch(polygon)
plt.gcf().canvas.mpl_connect('motion_notify_event', motion_notify)
plt.show()
    def visualization(self, savename='figure'):

        # --> Sets figure.
        fig = plt.figure()

        # Mesh arrays.
        x = self.x[:self.nde]
        y = self.y[:self.nde]

        # Vorticity array.
        vorticity = self.vorticity[:self.nde]

        # Delaunay triangulation.
        tri = Triangulation(x, y)

        # Mask unwanted triangles.
        radius = 0.5
        xmid = tri.x[tri.triangles].mean(axis=1)
        ymid = tri.y[tri.triangles].mean(axis=1)

        xc1, yc1 = 0, 0.75
        xc2, yc2 = 0, -0.75
        xc3, yc3 = -1.5 * np.sqrt(0.75), 0
        mask = np.where((xmid - xc1)**2 + (ymid - yc1)**2 < radius**2, 1, 0)
        mask += np.where((xmid - xc2)**2 + (ymid - yc2)**2 < radius**2, 1, 0)
        mask += np.where((xmid - xc3)**2 + (ymid - yc3)**2 < radius**2, 1, 0)
        tri.set_mask(mask)

        # Plot the vorticity field.
        ax = fig.gca()
        cmap = plt.cm.RdBu
        h = ax.tripcolor(tri, vorticity, shading='gouraud', cmap=cmap)
        h.set_clim(-4, 4)
        ax.set_aspect('equal')
        ax.set_xlim(-5, 20)
        ax.set_ylim(-4, 4)

        # Set up the colorbar.
        divider = make_axes_locatable(ax)
        cax = divider.append_axes('right', size='5%', pad=0.1)
        cb = plt.colorbar(h, cax=cax)
        tick_locator = ticker.MaxNLocator(nbins=5)
        cb.locator = tick_locator
        cb.update_ticks()

        # Highlight the cylinders.
        xc, yc, r = 0., 0.75, 0.5
        circle = Circle((xc, yc), r, facecolor='None', edgecolor='k')
        ax.add_patch(circle)

        xc, yc, r = 0., -0.75, 0.5
        circle = Circle((xc, yc), r, facecolor='None', edgecolor='k')
        ax.add_patch(circle)

        xc, yc, r = -1.5 * np.sqrt(0.75), 0., 0.5
        circle = Circle((xc, yc), r, facecolor='None', edgecolor='k')
        ax.add_patch(circle)

        # Titles, labels, ...
        ax.set_xlabel(r'$x$')
        ax.locator_params(axis='y', nbins=5)
        ax.set_ylabel(r'$y$', rotation=0)

        # Save the figure.
        fig.savefig(savename + '.png', bbox_inches='tight', dpi=300)

        return fig, ax
class BaseTrig:
    """" Base class to be inherited by CTrig (charges) and GTrig (FE calculation).  The class handles loading
         the triangulation, calculating relevant fields and plotting. Has two plotting functions: heatmap to 
         plot spatially varying fields and boundary_plot to plot just the boundary.
    """
    def __init__(self, lattice, p, method):
        self.method = method
        self.lattice = lattice
        self.p = p  # porosity
        self.holes = None  # list of hole positions
        self.boundary = None
        self.N_holes = None
        self.tri = None  # A matplotlib Tri object.
        self.real_nodes = None
        self.mask = None  # mask for Tri object, specifies which nodes to plot.
        self.length_factor = None

    def calc_tri(self):
        self.N_holes = self.holes.shape[1]
        self.tri = Triangulation(*self.lagrange_nodes(only_real=False))
        self._set_mask()

    def _set_mask(self, crop=np.inf):
        # mask tris which involve a hole
        c1 = self.tri.triangles.min(axis=1) <= self.N_holes

        # mask tris with points outside crop
        c2 = np.abs(self.tri.x[self.tri.triangles]).max(axis=1) > crop
        c3 = np.abs(self.tri.y[self.tri.triangles]).max(axis=1) > crop
        self.mask = c1 | c2 | c3
        self.tri.set_mask(self.mask)

    def lagrange_nodes(self, only_real=True):
        if only_real:
            return self.real_nodes
        else:
            return np.c_[self.holes, self.real_nodes]

    def euler_nodes(self, only_real=True):
        nodes = np.array([self.tri.x, self.tri.y])
        if only_real:
            nodes = nodes[:, self.N_holes:]
        return nodes

    def deform(self, strain, kind='lin'):
        """
        Deforms the mesh. Kind specifiec by which field to deform the mesh. It can be either 'lin'
        for linear response or 'mode' for most unstable mode. strain is the amplitude.
        """
        if 'linear'.startswith(kind):
            H = self.lagrange_nodes()[1].max() - self.lagrange_nodes()[1].min()
            scale = H * strain / 2
            sol = scale * self.d_lin
            self.stress *= scale
        elif 'mode'.startswith(kind):
            sol = strain * self.d_mode
        else:
            raise ValueError(f'didnt understand kind={kind}')

        all_nodes = self.lagrange_nodes(only_real=False)
        self.tri.x = all_nodes[0] + self.append_shit(sol[0])
        self.tri.y = all_nodes[1] + self.append_shit(sol[1])

    def heatmap(self,
                c,
                ax=None,
                cbar=True,
                cmap=None,
                clim=None,
                cax=None,
                crop=None):
        if ax is None:
            ax = plt.gca()
        single_color = c is None
        if single_color:
            c = np.full_like(self.lagrange_nodes()[0], 0)
            clim = [-1, 1]
            color = (0.2980392156862745, 0.4470588235294118,
                     0.6901960784313725)
            cmap = mpl.colors.ListedColormap((color, color))

        if clim is None:
            levels = np.linspace(c.min(), c.max(), 20)
        else:
            levels = np.linspace(*clim, 20)
        if crop:
            self._set_mask(crop)
        if cmap is None and not single_color:
            cmap = sns.color_palette("RdBu_r", 20)
            cmap = mpl.colors.ListedColormap(cmap)

        hf = ax.tricontourf(self.tri,
                            self.append_shit(c),
                            levels=levels,
                            cmap=cmap)
        if not single_color:
            hc = ax.tricontour(self.tri,
                               self.append_shit(c),
                               levels=levels,
                               colors=['0.25', '0.5', '0.5', '0.5', '0.5'],
                               linewidths=[1.0, 0.5, 0.5, 0.5, 0.5])
        ax.set_aspect(1)
        ax.axis('off')
        if cbar:
            if cax is None:
                cbar = plt.colorbar(hf, ax=ax)
            else:
                cbar = plt.colorbar(hf, cax=cax)
        return ax, cbar

    def boundary_plot(self,
                      deformation='mode',
                      fill=True,
                      scale=1,
                      ax=None,
                      facecolor='b',
                      edgecolor='None',
                      alpha=1,
                      skip=1):
        if deformation == 'mode':
            d = self.d_mode[:, self.boundary]
        elif deformation == 'lin':
            d = self.d_lin[:, self.boundary]
        if ax is None:
            ax = plt.gca()

        reference = self.lagrange_nodes()[:, self.boundary]
        if hasattr(self, 'cyc'):
            cyc = self.cyc
        else:
            print('no cyclifier, calculating')
            cyc = Cyclifier(reference)
            self.cyc = cyc
            print('done')

        pos = reference + scale * d
        patch = patchify(cyc(pos, as_patches=True, skip=skip))
        patch.set_facecolor(facecolor)
        patch.set_edgecolor(edgecolor)
        patch.set_alpha(alpha)
        patch = ax.add_patch(patch)
        ax.axis('off')
        ax.set_xticks([])
        ax.set_yticks([])
        ax.axis('equal')
        return patch

    def append_shit(self, x, fill_value=None):
        """Prepend zeros to x on hole nodes."""
        assert x.ndim == 1
        if hasattr(x, 'values'):
            x = x.values
        if fill_value is None:
            fill = x.mean().astype(x.dtype)
        else:
            fill = fill_value
        return np.r_[fill + np.zeros(self.N_holes, dtype=x.dtype), x]

    @property
    def sxy(self):
        return self.stress[2]

    @property
    def syy(self):
        return self.stress[1]

    @property
    def sxx(self):
        return self.stress[0]
예제 #16
0
    event.canvas.draw()


# Create a Triangulation.
n_angles = 16
n_radii = 5
min_radius = 0.25
radii = np.linspace(min_radius, 0.95, n_radii)
angles = np.linspace(0, 2*math.pi, n_angles, endpoint=False)
angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1)
angles[:, 1::2] += math.pi / n_angles
x = (radii*np.cos(angles)).flatten()
y = (radii*np.sin(angles)).flatten()
triangulation = Triangulation(x, y)
xmid = x[triangulation.triangles].mean(axis=1)
ymid = y[triangulation.triangles].mean(axis=1)
mask = np.where(xmid*xmid + ymid*ymid < min_radius*min_radius, 1, 0)
triangulation.set_mask(mask)

# Use the triangulation's default TriFinder object.
trifinder = triangulation.get_trifinder()

# Setup plot and callbacks.
plt.subplot(111, aspect='equal')
plt.triplot(triangulation, 'bo-')
polygon = Polygon([[0, 0], [0, 0]], facecolor='y')  # dummy data for xs,ys
update_polygon(-1)
plt.gca().add_patch(polygon)
plt.gcf().canvas.mpl_connect('motion_notify_event', motion_notify)
plt.show()
예제 #17
0
def extract_wnd(storm,
                datafile1,
                stations,
                df,
                lonmin=None,
                lonmax=None,
                latmin=None,
                latmax=None):

    #Single file netCDF reading
    #ncf='ww3.field.2018_wnd.nc'
    ncf = datafile1
    nco = netCDF4.Dataset(ncf)
    #ncf2='ww3.field.2018_dp.nc'
    #ncf2=datafile2
    #nco2=netCDF4.Dataset(ncf2)

    #Get fields to plot
    lon = nco.variables['longitude'][:]
    lat = nco.variables['latitude'][:]
    pnt_lon = stations.iloc[0, :].values
    pnt_lat = stations.iloc[1, :].values
    timeindays = nco.variables['time'][:]
    uwnd = nco.variables['uwnd'][:]
    vwnd = nco.variables['vwnd'][:]

    #timeindays2=nco2.variables['time'][:]
    #dir=nco2.variables['dp'][:]

    if lonmin != None:
        reflon = np.linspace(lonmin, lonmax, 1000)
        reflat = np.linspace(latmin, latmax, 1000)
    else:
        reflon = np.linspace(lon.min(), lon.max(), 1000)
        reflat = np.linspace(lat.min(), lat.max(), 1000)
    reflon, reflat = np.meshgrid(reflon, reflat)

    flatness = 0.10  # flatness is from 0-.5 .5 is equilateral triangle
    tri = Triangulation(lon, lat)
    mask = TriAnalyzer(tri).get_flat_tri_mask(flatness)
    tri.set_mask(mask)

    #Read obs point locations
    #data=np.loadtxt('erie_ndbc.loc', comments = '$')
    #buoylon=data[:,0]
    #buoylat=data[:,1]

    plt.figure(figsize=[6.4, 3.8])

    df_dates = pd.DataFrame(columns=['Date'])

    # Loop through each time step and plot results
    for ind in range(0, len(timeindays)):
        plt.clf()
        ax = plt.axes(projection=ccrs.Mercator())

        dt = datetime.datetime.combine(datetime.date(
            1990, 1, 1), datetime.time(
                0, 0)) + datetime.timedelta(days=timeindays[ind])
        dstr = datetime.date.strftime(dt, '%Y%m%d%H:%M:%S')
        dstr = dstr[0:8] + ' ' + dstr[8:17]
        print('Extracting ' + dstr)

        par = np.sqrt(
            np.square(np.double(uwnd[ind, :])) +
            np.square(np.double(vwnd[ind, :])))
        #par2=np.double(dir[ind,:])

        tli = LinearTriInterpolator(tri, par)
        par_interp = tli(pnt_lon, pnt_lat)

        #print(par_interp)
        df.loc[len(df)] = par_interp
        df_dates.loc[len(df_dates)] = pd.to_datetime(
            dt, format="%Y-%m-%d %H:%M:%S")
        #line = pd.to_datetime(dt, format="%Y-%m-%d %H:%M:%S")
        #new_row = pd.DataFrame(par_interp, columns=stations.columns, index=line)
        #df = pd.concat([df, pd.DataFrame(new_row)], ignore_index=False)

        del (par)
        del (par_interp)

    df['Date'] = df_dates
    df.set_index('Date', inplace=True)
    return df
# Random points
random_gen = np.random.mtrand.RandomState(seed=127260)
x_test = random_gen.uniform(-1., 1., size=n_test)
y_test = random_gen.uniform(-1., 1., size=n_test)
z_test = experiment_res(x_test, y_test)

# meshing with Delaunay triangulation
tri = Triangulation(x_test, y_test)
ntri = tri.triangles.shape[0]

# Some invalid data are masked out
mask_init = np.zeros(ntri, dtype=np.bool)
masked_tri = random_gen.randint(0, ntri, int(ntri*init_mask_frac))
mask_init[masked_tri] = True
tri.set_mask(mask_init)


#-----------------------------------------------------------------------------
# Improving the triangulation before high-res plots: removing flat triangles
#-----------------------------------------------------------------------------
# masking badly shaped triangles at the border of the triangular mesh.
mask = TriAnalyzer(tri).get_flat_tri_mask(min_circle_ratio)
tri.set_mask(mask)

# refining the data
refiner = UniformTriRefiner(tri)
tri_refi, z_test_refi = refiner.refine_field(z_test, subdiv=subdiv)

# analytical 'results' for comparison
z_expected = experiment_res(tri_refi.x, tri_refi.y)
예제 #19
0
angles = np.linspace(0, 2 * np.pi, n_angles, endpoint=False)
angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1)
angles[:, 1::2] += np.pi / n_angles

x = (radii*np.cos(angles)).flatten()
y = (radii*np.sin(angles)).flatten()
V = dipole_potential(x, y)

# Create the Triangulation; no triangles specified so Delaunay triangulation
# created.
triang = Triangulation(x, y)

# Mask off unwanted triangles.
triang.set_mask(np.hypot(x[triang.triangles].mean(axis=1),
                         y[triang.triangles].mean(axis=1))
                < min_radius)

#-----------------------------------------------------------------------------
# Refine data - interpolates the electrical potential V
#-----------------------------------------------------------------------------
refiner = UniformTriRefiner(triang)
tri_refi, z_test_refi = refiner.refine_field(V, subdiv=3)

#-----------------------------------------------------------------------------
# Computes the electrical field (Ex, Ey) as gradient of electrical potential
#-----------------------------------------------------------------------------
tci = CubicTriInterpolator(triang, -V)
# Gradient requested here at the mesh nodes but could be anywhere else:
(Ex, Ey) = tci.gradient(triang.x, triang.y)
E_norm = np.sqrt(Ex**2 + Ey**2)
예제 #20
0
def plot_cur(storm, datafile1, datafile2=None):

   #Single file netCDF reading
   ncf=datafile1
   nco=netCDF4.Dataset(ncf)
   #ncf2=datafile2
   #nco2=netCDF4.Dataset(ncf2)

   #Get fields to plot
   lon=nco.variables['longitude'][:]
   lat=nco.variables['latitude'][:]
   timeindays=nco.variables['time'][:]
   ucur=nco.variables['ucur'][:]
   vcur=nco.variables['vcur'][:]
   triangles=nco.variables['tri'][:,:]

   #timeindays2=nco2.variables['time'][:]
   #dir=nco2.variables['dp'][:]

   reflon=np.linspace(lon.min(),lon.max(),1000)
   reflat=np.linspace(lat.min(),lat.max(),1000)
   #reflon=np.linspace(-80.40, -74.75, 1000)
   #reflat=np.linspace(32.50, 36.60, 1000)
   #reflon=np.linspace(-75.70, -71.05, 1000)
   #reflat=np.linspace(38.50, 41.40, 1000)
   reflon,reflat=np.meshgrid(reflon,reflat)

   plt.figure(figsize = [6.4, 3.8])

   flatness=0.10  # flatness is from 0-.5 .5 is equilateral triangle
   triangles=triangles-1  # Correct indices for Python's zero-base
   tri=Triangulation(lon,lat,triangles=triangles)
   mask = TriAnalyzer(tri).get_flat_tri_mask(flatness)
   tri.set_mask(mask)

   # Loop through each time step and plot results
   for ind in range(0, len(timeindays)): 
      plt.clf()
      ax = plt.axes(projection=ccrs.Mercator())

      dt = datetime.datetime.combine(datetime.date(1990, 1, 1), datetime.time(0, 0)) + datetime.timedelta(days=timeindays[ind])
      dstr = datetime.date.strftime(dt,'%Y%m%d%H:%M:%S')
      dstr = dstr[0:8]+' '+dstr[8:17]
      print('Plotting '+dstr)

      par=np.sqrt( np.square(np.double(ucur[ind,:])) + np.square(np.double(vcur[ind,:])) )
      #par2=np.double(dir[ind,:])

      tli=LinearTriInterpolator(tri,par)
      par_interp=tli(reflon,reflat)

      #u=np.cos(np.pi/180*(270-par_interp))
      #v=np.sin(np.pi/180*(270-par_interp))

      plt.pcolormesh(reflon,reflat,par_interp,vmin=0.0,vmax=2.0,shading='flat',cmap=plt.cm.jet, transform=ccrs.PlateCarree())
      #plt.contourf(reflon, reflat, par_interp, vmax=60.0, cmap=plt.cm.jet, transform=ccrs.PlateCarree())
      cb = plt.colorbar()
      cb.ax.tick_params(labelsize=8)
      #rowskip=np.floor(par_interp.shape[0]/25)
      #colskip=np.floor(par_interp.shape[1]/25)
      rowskip = 50
      colskip = 50
      #plt.quiver(reflon[0::rowskip,0::colskip],reflat[0::rowskip,0::colskip],\
      #      u[0::rowskip,0::colskip],v[0::rowskip,0::colskip], \
      #      scale = 50, color='black',pivot='middle',units='xy',alpha=0.7)
      coast = cfeature.GSHHSFeature(scale='high',edgecolor='black',facecolor='none',linewidth=0.25)	
      ax.add_feature(coast)
      plt.xticks(fontsize=9)
      plt.yticks(fontsize=9)

      figtitle = storm.capitalize()+': Cur (m/s): '+dstr
      plt.title(figtitle)

      dtlabel = datetime.date.strftime(dt,'%Y%m%d%H%M%S')
      dtlabel = dtlabel[0:8]+'_'+dtlabel[8:14]
      filenm = 'nsem_'+storm+'_cur_'+dtlabel+'.png'
      plt.savefig(filenm,dpi=150,bbox_inches='tight',pad_inches=0.1)

      del(par)
      del(par_interp)
예제 #21
0
def plot_wlv(storm, datafile1, datafile2=None, lonmin=None, lonmax=None, latmin=None, latmax=None, domain=None):

   #Single file netCDF reading
   ncf=datafile1
   nco=netCDF4.Dataset(ncf)
   ncf2=datafile2
   nco2=netCDF4.Dataset(ncf2)

   #Get fields to plot
   lon=nco.variables['longitude'][:]
   lat=nco.variables['latitude'][:]
   timeindays=nco.variables['time'][:]
   wlv=nco.variables['wlv'][:]
   triangles=nco.variables['tri'][:,:]

   dpt=nco2.variables['dpt'][:]

   if lonmin != None:
      reflon=np.linspace(lonmin, lonmax, 1000)
      reflat=np.linspace(latmin, latmax, 1000)
   else:
      reflon=np.linspace(lon.min(),lon.max(),1000)
      reflat=np.linspace(lat.min(),lat.max(),1000)
   reflon,reflat=np.meshgrid(reflon,reflat)

   plt.figure(figsize = [6.4, 3.8])

   flatness=0.10  # flatness is from 0-.5 .5 is equilateral triangle
   triangles=triangles-1  # Correct indices for Python's zero-base
   tri=Triangulation(lon,lat,triangles=triangles)
   mask = TriAnalyzer(tri).get_flat_tri_mask(flatness)
   tri.set_mask(mask)

   # Loop through each time step and plot results
   for ind in range(0, len(timeindays)):
      besttrack = pd.read_csv(PARMnsem+'/storms/'+STORM+'/best_track.txt', header=None, skiprows=4, delim_whitespace=True) 
      plt.clf()
      ax = plt.axes(projection=ccrs.Mercator())
      if lonmin != None:
         ax.set_extent([lonmin, lonmax, latmin, latmax], crs=ccrs.PlateCarree())
 
      dt = datetime.datetime.combine(datetime.date(1990, 1, 1), datetime.time(0, 0)) + datetime.timedelta(days=timeindays[ind])
      dstr = datetime.date.strftime(dt,'%Y%m%d%H:%M:%S')
      dstr = dstr[0:8]+' '+dstr[8:17]
      print('Plotting '+dstr)

      par=np.double(wlv[ind,:])
      tli=LinearTriInterpolator(tri,par)
      par_interp=tli(reflon,reflat)

      plt.pcolormesh(reflon,reflat,par_interp,vmin=-2.0,vmax=2.0, shading='flat',cmap=plt.cm.bwr, transform=ccrs.PlateCarree())
      cb = plt.colorbar()
      cb.ax.tick_params(labelsize=8)
      coast = cfeature.GSHHSFeature(scale='high',edgecolor='black',facecolor='none',linewidth=0.25)	
      ax.add_feature(coast)
      plt.plot(besttrack.iloc[:,3].values, besttrack.iloc[:,2].values, 'k--', linewidth=1.0, transform=ccrs.PlateCarree())

      gl = ax.gridlines(crs=ccrs.PlateCarree(), draw_labels=True,
                  linewidth=2, color='gray', alpha=0.5, linestyle='--')
      gl.xlabels_top = False
      gl.ylabels_right = False
      gl.xlines = False
      gl.ylines = False
      gl.xformatter = LONGITUDE_FORMATTER
      gl.yformatter = LATITUDE_FORMATTER
      gl.xlabel_style = {'size': 6, 'color': 'black'}
      gl.ylabel_style = {'size': 6, 'color': 'black'}
      figtitle = storm.capitalize()+': WL (m MSL): '+dstr
      plt.title(figtitle)

      dtlabel = datetime.date.strftime(dt,'%Y%m%d%H%M%S')
      dtlabel = dtlabel[0:8]+'_'+dtlabel[8:14]
      filenm = 'nsem_'+storm+'_wlv_'+dtlabel+'_'+domain+'.png'
      plt.savefig(filenm,dpi=150,bbox_inches='tight',pad_inches=0.1)

      del(par)
      del(par_interp)
예제 #22
0
def extract_wlv(storm,
                datafile1,
                stations,
                df,
                lonmin=None,
                lonmax=None,
                latmin=None,
                latmax=None):

    print('Reading', datafile1)
    #Single file netCDF reading
    #ncf='ww3.field.2018_wnd.nc'
    ncf = datafile1
    nco = netCDF4.Dataset(ncf)
    #ncf2='ww3.field.2018_dp.nc'
    #ncf2=datafile2
    #nco2=netCDF4.Dataset(ncf2)

    #Get fields to plot
    lon = nco.variables['x'][:]
    lat = nco.variables['y'][:]
    pnt_lon = stations.iloc[0, :].values
    pnt_lat = stations.iloc[1, :].values
    timeinsec = nco.variables['time'][:]
    #base_date=nco.variables['time:base_date']
    #print(base_date)
    wlv = nco.variables['zeta'][:]
    triangles = nco.variables['element'][:, :]

    #timeindays2=nco2.variables['time'][:]
    #dir=nco2.variables['dp'][:]

    if lonmin != None:
        reflon = np.linspace(lonmin, lonmax, 1000)
        reflat = np.linspace(latmin, latmax, 1000)
    else:
        reflon = np.linspace(lon.min(), lon.max(), 1000)
        reflat = np.linspace(lat.min(), lat.max(), 1000)
    reflon, reflat = np.meshgrid(reflon, reflat)

    flatness = 0.10  # flatness is from 0-.5 .5 is equilateral triangle
    triangles = triangles - 1  # Correct indices for Python's zero-base
    tri = Triangulation(lon, lat, triangles=triangles)
    mask = TriAnalyzer(tri).get_flat_tri_mask(flatness)
    tri.set_mask(mask)

    #Read obs point locations
    #data=np.loadtxt('erie_ndbc.loc', comments = '$')
    #buoylon=data[:,0]
    #buoylat=data[:,1]

    df_dates = pd.DataFrame(columns=['Date'])

    # Loop through each time step and plot results
    for ind in range(0, len(timeinsec)):
        #plt.clf()
        #ax = plt.axes(projection=ccrs.Mercator())

        dt = base_info.tide_spin_start_date + datetime.timedelta(
            seconds=timeinsec[ind])
        dstr = datetime.date.strftime(dt, '%Y%m%d%H:%M:%S')
        dstr = dstr[0:8] + ' ' + dstr[8:17]
        print('Plotting ' + dstr)

        par = np.double(wlv[ind, :])

        tli = LinearTriInterpolator(tri, par)
        par_interp = tli(pnt_lon, pnt_lat)

        #print(par_interp)
        df.loc[len(df)] = par_interp
        df_dates.loc[len(df_dates)] = pd.to_datetime(
            dt, format="%Y-%m-%d %H:%M:%S")
        #line = pd.to_datetime(dt, format="%Y-%m-%d %H:%M:%S")
        #new_row = pd.DataFrame(par_interp, columns=stations.columns, index=line)
        #df = pd.concat([df, pd.DataFrame(new_row)], ignore_index=False)

        del (par)
        del (par_interp)

    df['Date'] = df_dates
    df.set_index('Date', inplace=True)
    return df
예제 #23
0
파일: mesh_2D.py 프로젝트: tupui/batman
def mesh_2D(fname,
            var=None,
            flabels=None,
            fformat='csv',
            xlabel='X axis',
            ylabel='Y axis',
            vmins=None,
            output_path=None):
    """Visualization of specific variable on a user provided 2D mesh.

    The provided mesh should contain two columns (x,y coordinates for each
    mesh point) and be one of :func:`batman.input_output.available_formats`.
    (x, y) must be respectively the first and second column. Any other column
    is treated as an extra variable and will be used to plot a figure.
    If :attr:`var` is not `None`, its content will be used as plotting
    variables.

    :param str fname: name of mesh file.
    :param array_like var: data to be plotted shape (n_coords, n_vars).
    :param list(str) flabels: names of the variables.
    :param str fformat: format of the mesh file.
    :param str xlabel: name of the x-axis.
    :param str ylabel: name of the y-axis.
    :param lst(double) vmins: value of the minimal output for data filtering.
    :param str output_path: name of the output path.
    :returns: figure.
    :rtype: Matplotlib figure instances.
    """
    # Read the mesh file
    io = formater(fformat)
    mesh = io.read(fname)

    if var is not None:
        var = np.asarray(var)
    else:
        var = mesh[:, 2:]

    if flabels is None:
        flabels = ['y' + str(i) for i in range(var.shape[1])]

    # Input variables
    var_len = var.shape[0]

    if var_len != len(mesh):
        raise ValueError(
            'Variable size not equal: Variable {} - Mesh {}'.format(
                var_len, len(mesh)))

    if vmins is None:
        vmins = [None] * var_len

    # Meshing with Delaunay triangulation
    tri = Triangulation(mesh[:, 0], mesh[:, 1])

    # Masking badly shaped triangles at the border of the triangular mesh
    mask = TriAnalyzer(tri).get_flat_tri_mask(0.01)
    tri.set_mask(mask)

    # Loop over input parameters
    figs, axs = [], []
    for i, _ in enumerate(var[0]):
        fig, ax = plt.subplots()
        figs.append(fig)
        axs.append(ax)

        cmap = cm.viridis
        cmap.set_bad(alpha=0.0)
        cmap.set_under('w', alpha=0.0)
        plt.tricontourf(tri,
                        var[:, i],
                        antialiased=True,
                        cmap=cmap,
                        vmin=vmins[i])
        plt.xlabel(xlabel)
        plt.ylabel(ylabel)
        plt.tick_params(axis='x')
        plt.tick_params(axis='y')
        cbar = plt.colorbar()
        cbar.set_label(flabels[i])
        cbar.ax.tick_params()

    bat.visualization.save_show(output_path, figs, extend='neither')

    return figs, axs
예제 #24
0
angles = np.linspace(0, 2 * np.pi, n_angles, endpoint=False)
angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1)
angles[:, 1::2] += np.pi / n_angles

x = (radii * np.cos(angles)).flatten()
y = (radii * np.sin(angles)).flatten()
V = dipole_potential(x, y)

# Create the Triangulation; no triangles specified so Delaunay triangulation
# created.
triang = Triangulation(x, y)

# Mask off unwanted triangles.
triang.set_mask(
    np.hypot(x[triang.triangles].mean(axis=1), y[triang.triangles].mean(
        axis=1)) < min_radius)

#-----------------------------------------------------------------------------
# Refine data - interpolates the electrical potential V
#-----------------------------------------------------------------------------
refiner = UniformTriRefiner(triang)
tri_refi, z_test_refi = refiner.refine_field(V, subdiv=3)

#-----------------------------------------------------------------------------
# Computes the electrical field (Ex, Ey) as gradient of electrical potential
#-----------------------------------------------------------------------------
tci = CubicTriInterpolator(triang, -V)
# Gradient requested here at the mesh nodes but could be anywhere else:
(Ex, Ey) = tci.gradient(triang.x, triang.y)
E_norm = np.sqrt(Ex**2 + Ey**2)
예제 #25
0
def plot_cur(storm, datafile1, datafile2=None):

    #Single file netCDF reading
    ncf = datafile1
    nco = netCDF4.Dataset(ncf)
    #ncf2=datafile2
    #nco2=netCDF4.Dataset(ncf2)

    #Get fields to plot
    lon = nco.variables['longitude'][:]
    lat = nco.variables['latitude'][:]
    timeindays = nco.variables['time'][:]
    ucur = nco.variables['ucur'][:]
    vcur = nco.variables['vcur'][:]
    triangles = nco.variables['tri'][:, :]

    #timeindays2=nco2.variables['time'][:]
    #dir=nco2.variables['dp'][:]

    reflon = np.linspace(lon.min(), lon.max(), 1000)
    reflat = np.linspace(lat.min(), lat.max(), 1000)
    #reflon=np.linspace(-80.40, -73.35, 1000)
    #reflat=np.linspace(32.50, 39.50, 1000)
    reflon, reflat = np.meshgrid(reflon, reflat)

    plt.figure(figsize=[6.4, 3.8])

    flatness = 0.10  # flatness is from 0-.5 .5 is equilateral triangle
    triangles = triangles - 1  # Correct indices for Python's zero-base
    tri = Triangulation(lon, lat, triangles=triangles)
    mask = TriAnalyzer(tri).get_flat_tri_mask(flatness)
    tri.set_mask(mask)

    # Loop through each time step and plot results
    for ind in range(0, len(timeindays)):
        besttrack = pd.read_csv(PARMnsem + '/storms/' + STORM +
                                '/best_track.txt',
                                header=None,
                                skiprows=4,
                                delim_whitespace=True)
        plt.clf()
        ax = plt.axes(projection=ccrs.Mercator())
        ax.set_extent([-100.00, -50.00, 4.00, 48.00], crs=ccrs.PlateCarree())
        #ax.set_extent([-80.40, -73.35, 32.50, 39.50], crs=ccrs.PlateCarree())

        dt = base_info.tide_spin_start_date + datetime.timedelta(
            days=timeindays[ind])
        dstr = datetime.date.strftime(dt, '%Y%m%d%H:%M:%S')
        dstr = dstr[0:8] + ' ' + dstr[8:17]
        print('Plotting ' + dstr)

        par = np.sqrt(
            np.square(np.double(ucur[ind, :])) +
            np.square(np.double(vcur[ind, :])))
        #par2=np.double(dir[ind,:])

        tli = LinearTriInterpolator(tri, par)
        par_interp = tli(reflon, reflat)

        #u=np.cos(np.pi/180*(270-par_interp))
        #v=np.sin(np.pi/180*(270-par_interp))

        plt.pcolormesh(reflon,
                       reflat,
                       par_interp,
                       vmin=0.0,
                       vmax=2.0,
                       shading='flat',
                       cmap=plt.cm.jet,
                       transform=ccrs.PlateCarree())
        #plt.contourf(reflon, reflat, par_interp, vmax=60.0, cmap=plt.cm.jet, transform=ccrs.PlateCarree())
        cb = plt.colorbar()
        cb.ax.tick_params(labelsize=8)
        #rowskip=np.floor(par_interp.shape[0]/25)
        #colskip=np.floor(par_interp.shape[1]/25)
        rowskip = 50
        colskip = 50
        #plt.quiver(reflon[0::rowskip,0::colskip],reflat[0::rowskip,0::colskip],\
        #      u[0::rowskip,0::colskip],v[0::rowskip,0::colskip], \
        #      scale = 50, color='black',pivot='middle',units='xy',alpha=0.7)
        coast = cfeature.GSHHSFeature(scale='high',
                                      edgecolor='black',
                                      facecolor='none',
                                      linewidth=0.25)
        ax.add_feature(coast)
        plt.plot(besttrack.iloc[:, 3].values,
                 besttrack.iloc[:, 2].values,
                 'k--',
                 linewidth=1.0,
                 transform=ccrs.PlateCarree())

        gl = ax.gridlines(crs=ccrs.PlateCarree(),
                          draw_labels=True,
                          linewidth=2,
                          color='gray',
                          alpha=0.5,
                          linestyle='--')
        gl.xlabels_top = False
        gl.ylabels_right = False
        gl.xlines = False
        gl.ylines = False
        gl.xformatter = LONGITUDE_FORMATTER
        gl.yformatter = LATITUDE_FORMATTER
        gl.xlabel_style = {'size': 6, 'color': 'black'}
        gl.ylabel_style = {'size': 6, 'color': 'black'}
        figtitle = storm.capitalize() + ': Cur (m/s): ' + dstr
        plt.title(figtitle)

        dtlabel = datetime.date.strftime(dt, '%Y%m%d%H%M%S')
        dtlabel = dtlabel[0:8] + '_' + dtlabel[8:14]
        filenm = 'nsem_' + storm + '_cur_' + dtlabel + '.png'
        plt.savefig(filenm, dpi=150, bbox_inches='tight', pad_inches=0.1)

        del (par)
        del (par_interp)
예제 #26
0
angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1)
angles[:, 1::2] += math.pi/n_angles

x = (radii*np.cos(angles)).flatten()
y = (radii*np.sin(angles)).flatten()
V = dipole_potential(x, y)

# Create the Triangulation; no triangles specified so Delaunay triangulation
# created.
triang = Triangulation(x, y)

# Mask off unwanted triangles.
xmid = x[triang.triangles].mean(axis=1)
ymid = y[triang.triangles].mean(axis=1)
mask = np.where(xmid*xmid + ymid*ymid < min_radius*min_radius, 1, 0)
triang.set_mask(mask)

#-----------------------------------------------------------------------------
# Refine data - interpolates the electrical potential V
#-----------------------------------------------------------------------------
refiner = UniformTriRefiner(triang)
tri_refi, z_test_refi = refiner.refine_field(V, subdiv=3)

#-----------------------------------------------------------------------------
# Computes the electrical field (Ex, Ey) as gradient of electrical potential
#-----------------------------------------------------------------------------
tci = CubicTriInterpolator(triang, -V)
# Gradient requested here at the mesh nodes but could be anywhere else:
(Ex, Ey) = tci.gradient(triang.x, triang.y)
E_norm = np.sqrt(Ex**2 + Ey**2)
예제 #27
0
def density(model, refinement=0):
    """
    Create a Voronoi mesh and calculate the local particle density on its vertices.

    The local density is calculated as follows:
    for each vertex, compute the density of each neighbour region as
    one over the area and assign the average of
    the neighbouring density to the vertex.

    Parameters
    ----------
    model : simulation.builder.Model
        the Model object containing
    refinement : int (defaults : 0)
        number of subdivision for refining the mesh (0 == None)
    Returns
    -------
    tri : matplotlib.tri.Triangulation
        the triangulation mesh (refined if set as)
    vert_density : numpy.array
        the array containing the local denstity associated with the tri mesh


    Example
    -------
    To plot the result using matplotlib use :

    .. code-block:: python

        import matplotlib.pyplot as plt
        tri, density = data_proc.density(model)
        plt.tricontour(tri, density) # to draw contours
        plt.tricontourf(tri, density) # ot draw filled contours
        plt.show()

    Note
    ----
    As of now, the numerical results may not be quantitatively accurate
    but should qualitatively represent the density.
    """
    vor = Voronoi(model.pos)
    vert_density = np.zeros(max(vor.vertices.shape))  # density vector
    reg_num = np.zeros(max(
        vor.vertices.shape))  # nbr of regions per vertex --> averaging
    for point_index, reg in enumerate(vor.point_region):
        vertices = vor.regions[reg]
        if vertices:
            if -1 not in vertices:
                area = ConvexHull(vor.vertices[vertices]).area  # gets the area
                vert_density[
                    vertices] += 1 / area  # makes it a density (sort-of)
                reg_num[vertices] += 1
    vert_density /= reg_num  # averaging

    # getting rid of really ugly border points
    new_vert, vert_density = (
        vor.vertices[vor.vertices[:, 0] >= np.min(model.pos[:, 0])],
        vert_density[vor.vertices[:, 0] >= np.min(model.pos[:, 0])])

    new_vert, vert_density = (
        new_vert[new_vert[:, 0] <= np.max(model.pos[:, 0])],
        vert_density[new_vert[:, 0] <= np.max(model.pos[:, 0])])

    new_vert, vert_density = (
        new_vert[new_vert[:, 1] >= np.min(model.pos[:, 1])],
        vert_density[new_vert[:, 1] >= np.min(model.pos[:, 1])])

    new_vert, vert_density = (
        new_vert[new_vert[:, 1] <= np.max(model.pos[:, 1])],
        vert_density[new_vert[:, 1] <= np.max(model.pos[:, 1])])

    # for triangulation refinement
    tri2 = Triangulation(*new_vert.T)
    if refinement:
        tri2.set_mask(TriAnalyzer(tri2).get_flat_tri_mask(0.1))
        refiner = UniformTriRefiner(tri2)
        print(len(tri2.neighbors), vert_density.shape)
        tri, vert_density = refiner.refine_field(vert_density,
                                                 subdiv=refinement)
    else:
        tri, vert_density = tri2, vert_density

    return tri, vert_density
예제 #28
0
                       z,
                       breaks,
                       linewidths=[0.5, 0.25],
                       colors='saddlebrown')
    plt.clabel(CS, inline=5, fontsize=8)
    ax.set_ylabel('X[m]')
    ax.set_xlabel('Y[m]')
    plt.grid()
    plt.savefig('plot.png', dpi=300)
    plt.show()

    # Tworzenie mapy hipsometrycznej
    matplotlib.rcParams['contour.negative_linestyle'] = 'solid'
    tri = Triangulation(y, x)
    mask = TriAnalyzer(tri).get_flat_tri_mask(0.02)
    tri.set_mask(mask)
    fig, ax = plt.subplots()
    fig.set_size_inches(10, 15)
    ax.tick_params(labelsize=15)
    ax.yaxis.set_major_formatter(FormatStrFormatter('%d'))
    ax.xaxis.set_major_formatter(FormatStrFormatter('%d'))
    ax.set_aspect('equal')
    ax.set_title("Mapa warstwicowa")
    CS = ax.tricontourf(tri, z, cmap='RdBu')
    ax.tricontour(tri, z, breaks, linewidths=[0.5, 0.25], colors='saddlebrown')
    plt.clabel(CS, inline=1, fontsize=10)
    ax.set_ylabel('X[m]')
    ax.set_xlabel('Y[m]')
    plt.grid()
    plt.savefig('plotHipso.png', dpi=300)
    plt.show()
예제 #29
0
    # Read data from mesh file
    ncmesh = Dataset(cfg['mesh_file'], 'r')
    lon_mesh = np.rad2deg(
        np.mod(ncmesh.variables['lonCell'][:] + np.pi, 2.0 * np.pi) - np.pi)
    lat_mesh = np.rad2deg(ncmesh.variables['latCell'][:])
    nEdgesOnCell = ncmesh.variables['nEdgesOnCell'][:]
    cellsOnCell = ncmesh.variables['cellsOnCell'][:, :]

    # Triangulate cells
    triangles = Triangulation(lon_mesh, lat_mesh)

    # Compute triangulation mask (needs to be vectorized)
    mask = np.array(np.zeros((triangles.triangles.shape[0], )), dtype=bool)
    ntri = triangles.neighbors.shape[0]
    for i in range(ntri):
        k = 0
        for j in range(3):
            n = triangles.triangles[i, j]
            if nEdgesOnCell[n] != np.where(
                    cellsOnCell[n, :] != 0)[0].size:  # Mask triangles
                k = k + 1  # containing
        if k == 3:  # 3 boundary
            mask[i] = True  # cells
    triangles.set_mask(mask)

    # Write out geotiff image
    output_name = cfg['output_variable'] + '.tif'
    write_to_geotiff(var, triangles, cfg['nx'], cfg['ny'], cfg['bbox'],
                     output_name)
예제 #30
0
angles[:, 1::2] += math.pi/n_angles

x = (radii*np.cos(angles)).flatten()
y = (radii*np.sin(angles)).flatten()
z = function_z(x, y)

# Now create the Triangulation.
# (Creating a Triangulation without specifying the triangles results in the
# Delaunay triangulation of the points.)
triang = Triangulation(x, y)

# Mask off unwanted triangles.
xmid = x[triang.triangles].mean(axis=1)
ymid = y[triang.triangles].mean(axis=1)
mask = np.where(xmid*xmid + ymid*ymid < min_radius*min_radius, 1, 0)
triang.set_mask(mask)

#-----------------------------------------------------------------------------
# Refine data
#-----------------------------------------------------------------------------
refiner = UniformTriRefiner(triang)
tri_refi, z_test_refi = refiner.refine_field(z, subdiv=3)

#-----------------------------------------------------------------------------
# Plot the triangulation and the high-res iso-contours
#-----------------------------------------------------------------------------
plt.figure()
plt.gca().set_aspect('equal')
plt.triplot(triang, lw=0.5, color='white')

levels = np.arange(0., 1., 0.025)
예제 #31
0
    def __init__(self, **kwargs):
        super(ContourMap, self).__init__(**kwargs)

        n_test = 200  # Number of test data points, tested from 3 to 5000 for subdiv=3

        subdiv = 3  # Number of recursive subdivisions of the initial mesh for smooth
        # plots. Values >3 might result in a very high number of triangles
        # for the refine mesh: new triangles numbering = (4**subdiv)*ntri

        init_mask_frac = 0.0  # Float > 0. adjusting the proportion of
        # (invalid) initial triangles which will be masked
        # out. Enter 0 for no mask.

        min_circle_ratio = .01  # Minimum circle ratio - border triangles with circle
        # ratio below this will be masked if they touch a
        # border. Suggested value 0.01 ; Use -1 to keep
        # all triangles.

        # Random points
        random_gen = np.random.mtrand.RandomState(seed=127260)
        x_test = random_gen.uniform(-1., 1., size=n_test)
        y_test = random_gen.uniform(-1., 1., size=n_test)
        z_test = experiment_res(x_test, y_test)

        # meshing with Delaunay triangulation
        tri = Triangulation(x_test, y_test)
        ntri = tri.triangles.shape[0]

        # Some invalid data are masked out
        mask_init = np.zeros(ntri, dtype=np.bool)
        masked_tri = random_gen.randint(0, ntri, int(ntri * init_mask_frac))
        mask_init[masked_tri] = True
        tri.set_mask(mask_init)

        #-----------------------------------------------------------------------------
        # Improving the triangulation before high-res plots: removing flat triangles
        #-----------------------------------------------------------------------------
        # masking badly shaped triangles at the border of the triangular mesh.
        mask = TriAnalyzer(tri).get_flat_tri_mask(min_circle_ratio)
        tri.set_mask(mask)

        # refining the data
        refiner = UniformTriRefiner(tri)
        tri_refi, z_test_refi = refiner.refine_field(z_test, subdiv=subdiv)

        # analytical 'results' for comparison
        z_expected = experiment_res(tri_refi.x, tri_refi.y)

        # for the demo: loading the 'flat' triangles for plot
        flat_tri = Triangulation(x_test, y_test)
        flat_tri.set_mask(~mask)

        #-----------------------------------------------------------------------------
        # Now the plots
        #-----------------------------------------------------------------------------
        # User options for plots
        plot_tri = True  # plot of base triangulation
        plot_masked_tri = True  # plot of excessively flat excluded triangles
        plot_refi_tri = False  # plot of refined triangulation
        plot_expected = False  # plot of analytical function values for comparison

        # Graphical options for tricontouring
        levels = np.arange(0., 1., 0.025)
        cmap = cm.get_cmap(name='Blues', lut=None)

        plt.figure()
        plt.gca().set_aspect('equal')
        plt.title("Filtering a Delaunay mesh\n" +
                  "(application to high-resolution tricontouring)")

        # 1) plot of the refined (computed) data countours:
        plt.tricontour(tri_refi,
                       z_test_refi,
                       levels=levels,
                       cmap=cmap,
                       linewidths=[2.0, 0.5, 1.0, 0.5])
        # 2) plot of the expected (analytical) data countours (dashed):
        if plot_expected:
            plt.tricontour(tri_refi,
                           z_expected,
                           levels=levels,
                           cmap=cmap,
                           linestyles='--')
        # 3) plot of the fine mesh on which interpolation was done:
        if plot_refi_tri:
            plt.triplot(tri_refi, color='0.97')
        # 4) plot of the initial 'coarse' mesh:
        if plot_tri:
            plt.triplot(tri, color='0.7')
        # 4) plot of the unvalidated triangles from naive Delaunay Triangulation:
        if plot_masked_tri:
            plt.triplot(flat_tri, color='red')

        plt.show()
예제 #32
0
# Random points
random_gen = np.random.RandomState(seed=19680801)
x_test = random_gen.uniform(-1., 1., size=n_test)
y_test = random_gen.uniform(-1., 1., size=n_test)
z_test = experiment_res(x_test, y_test)

# meshing with Delaunay triangulation
tri = Triangulation(x_test, y_test)
ntri = tri.triangles.shape[0]

# Some invalid data are masked out
mask_init = np.zeros(ntri, dtype=bool)
masked_tri = random_gen.randint(0, ntri, int(ntri * init_mask_frac))
mask_init[masked_tri] = True
tri.set_mask(mask_init)


#-----------------------------------------------------------------------------
# Improving the triangulation before high-res plots: removing flat triangles
#-----------------------------------------------------------------------------
# masking badly shaped triangles at the border of the triangular mesh.
mask = TriAnalyzer(tri).get_flat_tri_mask(min_circle_ratio)
tri.set_mask(mask)

# refining the data
refiner = UniformTriRefiner(tri)
tri_refi, z_test_refi = refiner.refine_field(z_test, subdiv=subdiv)

# analytical 'results' for comparison
z_expected = experiment_res(tri_refi.x, tri_refi.y)
예제 #33
0
    def visualization(mesh,
                      vorticity,
                      psi=None,
                      savename='figure',
                      var_range=[-4, 4]):

        # --> Import various utilities from matplotlib.
        from matplotlib.tri import Triangulation
        from matplotlib import ticker
        from matplotlib.patches import Circle
        from mpl_toolkits.axes_grid1 import make_axes_locatable

        # --> Get mesh information and build-up the Delaunay triangulation.
        x, y = mesh.coordinates()[:, 0], mesh.coordinates()[:, 1]
        tri = Triangulation(x, y)

        # --> Mask the unwanted triangles.
        radius = 0.5
        xmid = tri.x[tri.triangles].mean(axis=1)
        ymid = tri.y[tri.triangles].mean(axis=1)

        xc1, yc1 = 0, 0.75
        xc2, yc2 = 0, -0.75
        xc3, yc3 = -1.5 * np.sqrt(0.75), 0
        mask = np.where((xmid - xc1)**2 + (ymid - yc1)**2 < radius**2, 1, 0)
        mask += np.where((xmid - xc2)**2 + (ymid - yc2)**2 < radius**2, 1, 0)
        mask += np.where((xmid - xc3)**2 + (ymid - yc3)**2 < radius**2, 1, 0)
        tri.set_mask(mask)

        # --> Get the vorticity field at the mesh nodes.
        vorticity = vorticity.compute_vertex_values(mesh)

        #-----------------------------------
        #-----     PLOT THE FIGURE     -----
        #-----------------------------------

        # --> Create matplotlib figure.
        fig = plt.figure()
        ax = fig.gca()

        # --> Plot the vorticity field.
        h = ax.tripcolor(tri, vorticity, shading='gouraud', cmap=plt.cm.RdBu)
        h.set_clim(var_range[0], var_range[1])

        # --> Set the axis.
        ax.set_aspect('equal')
        ax.set_xlim(-5, 20)
        ax.set_ylim(-4, 4)

        # --> Setup the colorbar.
        divider = make_axes_locatable(ax)
        cax = divider.append_axes('right', size='5%', pad=0.1)
        cb = plt.colorbar(h, cax=cax)
        tick_locator = ticker.MaxNLocator(nbins=5)
        cb.locator = tick_locator
        cb.update_ticks()

        # --> Highlight the cylinders.
        xc, yc, r = 0., 0.75, 0.5
        circle = Circle((xc, yc), r, facecolor='None', edgecolor='k')
        ax.add_patch(circle)

        xc, yc, r = 0., -0.75, 0.5
        circle = Circle((xc, yc), r, facecolor='None', edgecolor='k')
        ax.add_patch(circle)

        xc, yc, r = -1.5 * np.sqrt(0.75), 0., 0.5
        circle = Circle((xc, yc), r, facecolor='None', edgecolor='k')
        ax.add_patch(circle)

        # --> Titles, labels, ...
        ax.set_xlabel(r'$x$')
        ax.locator_params(axis='y', nbins=5)
        ax.set_ylabel(r'$y$', rotation=0)

        # --> Save the figure.
        fig.savefig(savename + '.png', bbox_inches='tight', dpi=300)

        return