Пример #1
0
    def normal_current(self, U, V):
        """Sample normal component of velocity field"""

        # Interpolerer foreløpig langs s-flater

        # Offset for interpolation from U and V grid
        deltaU = -0.5 + self.grid.i0 - self.grid.i0_u
        deltaV = -0.5 + self.grid.j0 - self.grid.j0_v
        Usec = np.zeros((self.N, self.nseg))
        Vsec = np.zeros((self.N, self.nseg))
        for k in range(self.N):
            Usec[k,:] = sample2D(U[k,:,:], self.Xm+deltaU, self.Ym)
            Vsec[k,:] = sample2D(V[k,:,:], self.Xm, self.Ym+deltaV)
        return self.nx*Usec + self.ny*Vsec
Пример #2
0
    def __init__(self, grid, X, Y):

        self.grid = grid
        # Vertices, in subgrid coordinates
        self.X = X - grid.i0
        self.Y = Y - grid.j0

        # Nodes
        self.Xm = 0.5*(self.X[:-1] + self.X[1:])
        self.Ym = 0.5*(self.Y[:-1] + self.Y[1:])

        # Section size
        self.nseg = len(self.Xm)  # Number of segments = Number of nodes
        self.N = len(self.grid.Cs_r)

        # Compatible with both SGrid and grdClass
        try:
            self.h = sample2D(self.grid.h, self.Xm, self.Ym,
                          mask=self.grid.mask_rho, undef_value=0.0)
        except AttributeError:
            self.h = sample2D(self.grid.depth, self.Xm, self.Ym)

        pm = sample2D(self.grid.pm, self.Xm, self.Ym)
        pn = sample2D(self.grid.pn, self.Xm, self.Ym)

        # Unit normal vector (nx, ny)
        # Sjekk om dette er korrekt hvis pm og pn er ulike
        dX = (X[1:]-X[:-1]) / pm
        dY = (Y[1:]-Y[:-1]) / pn

        # Length of segments
        #   Kan kanskje forbedres med sfærisk avstand
        self.dS = np.sqrt(dX*dX+dY*dY)
        # Cumulative distance (at vertices)s
        self.S = np.concatenate(([0], np.add.accumulate(self.dS)))

        nx, ny  = dY, -dX
        norm = np.sqrt(nx*nx + ny*ny)
        self.nx, self.ny = nx/norm, ny/norm    

        # Vertical structure
        self.z_r = sdepth(self.h, self.grid.hc, self.grid.Cs_r,
                          stagger='rho', Vtransform=self.grid.Vtransform)
        self.z_w = sdepth(self.h, self.grid.hc, self.grid.Cs_w,
                          stagger='w', Vtransform=self.grid.Vtransform)
        self.dZ = self.z_w[1:,:]-self.z_w[:-1,:]
        
        self.Area = self.dZ * self.dS
Пример #3
0
    def sample3D(self, F):
        """Sample a 3D field in rho-points with shape (N,Mp,Lp)"""

        # Not masked ??

        Fsec = np.zeros((self.N, self.L))
        for k in range(self.N):
            Fsec[k, :] = sample2D(F[k, :, :], self.X, self.Y,
                                  mask=self.grid.mask_rho)
        return Fsec
Пример #4
0
    def sample3D(self, F):
        """Sample a 3D field in rho-points with shape (N,Mp,Lp)"""

        # Interpolerer foreløpig langs s-flater
        # Sikkert OK for plotting, Godt nok for flux-beregning?

        Fsec = np.zeros((self.grid.N, self.nseg))
        for k in range(self.grid.N):
            Fsec[k,:] = sample2D(F[k,:,:], self.Xm, self.Ym,
                                 mask=self.grid.mask_rho)
        Fsec = np.ma.masked_where(self.extend_vertically(self.h) == 0, Fsec)
        return Fsec
Пример #5
0
    def __init__(self, grid, X, Y):

        self.grid = grid
        # Vertices, in subgrid coordinates
        self.X = X 
        self.Y = Y 

        # Section size
        self.L = len(self.X)         # Number of nodes
        self.N = len(self.grid.Cs_r)

        # Topography
        self.h = sample2D(self.grid.h, self.X, self.Y,
                          mask=self.grid.mask_rho, undef_value=1.0)

        # Metric
        pm = sample2D(self.grid.pm, self.X, self.Y)
        pn = sample2D(self.grid.pn, self.X, self.Y)
        dX = 2 * (X[1:]-X[:-1]) / (pm[:-1] + pm[1:])      # unit = meter
        dY = 2 * (Y[1:]-Y[:-1]) / (pn[:-1] + pn[1:])
        # Assume spacing is close enough to approximate distance
        self.dS = np.sqrt(dX*dX+dY*dY)
        # Cumulative distance
        self.S = np.concatenate(([0], np.add.accumulate(self.dS)))
        # Weights for trapez integration (linear interpolation)
        self.W = 0.5*np.concatenate(([self.dS[0]],
                                     self.dS[:-1] + self.dS[1:], [self.dS[-1]]))

        #nx, ny  = dY, -dX
        #norm = np.sqrt(nx*nx + ny*ny)
        #self.nx, self.ny = nx/norm, ny/norm

        # Vertical structure
        self.z_r = sdepth(self.h, self.grid.hc, self.grid.Cs_r,
                          stagger='rho', Vtransform=self.grid.Vtransform)
        self.z_w = sdepth(self.h, self.grid.hc, self.grid.Cs_w,
                          stagger='w', Vtransform=self.grid.Vtransform)
        self.dZ = self.z_w[1:, :]-self.z_w[:-1, :]

        self.Area = self.dZ * self.W
Пример #6
0
 def sample2D(self, F):
     return sample2D(F, self.Xm, self.Ym)
Пример #7
0
 def xy2ll(self, x, y):
     return (sample2D(self.lon_rho, x-self.i0, y-self.j0),
             sample2D(self.lat_rho, x-self.i0, y-self.j0))
Пример #8
0
 def sample2D(self, F):
     """Sample a horizontal field at rho poins with shape (Mp, Lp)"""
     return sample2D(F, self.X, self.Y, mask=self.grid.mask_rho)
Пример #9
0
 def xy2ll(self, x, y):
     return sample2D(self.lon_rho, x, y),    \
            sample2D(self.lat_rho, x, y)
Пример #10
0
 def sample2D(self, F, X, Y, mask=True, undef=np.nan):
     if mask:
         return sample2D(F, X, Y, mask=self.mask_rho, 
                         undef_value=undef)
     else:
         return sample2D(F, X, Y)