API documentation

4. Vector Fields

MeshArrays.curl — Function

curl(u::AbstractMeshArray,v::AbstractMeshArray,Γ::NamedTuple)

Compute curl of a velocity field.

source

MeshArrays.convergence — Function

convergence(uFLD::AbstractMeshArray,vFLD::AbstractMeshArray)

Compute convergence of a vector field

source

MeshArrays.gradient — Function

gradient(inFLD::AbstractMeshArray,Γ::NamedTuple)

Compute spatial derivatives. Other methods:

gradient(inFLD::AbstractMeshArray,Γ::NamedTuple,doDIV::Bool)
gradient(inFLD::AbstractMeshArray,iDXC::AbstractMeshArray,iDYC::AbstractMeshArray)

source

MeshArrays.ScalarPotential — Function

ScalarPotential(TrspCon)

Scalar potential inversion.

TrspPot=ScalarPotential(TrspCon)

source

MeshArrays.VectorPotential — Function

VectorPotential(TrspX,TrspY,Γ,method::Int=1)

Vector potential inversion.

TrspPot=ScalarPotential(TrspCon)

source

MeshArrays.ThroughFlow — Function

ThroughFlow(VectorField,IntegralPath,Γ::NamedTuple)

Compute transport through an integration path

source

MeshArrays.UVtoTransport — Function

UVtoTransport(U,V,G::NamedTuple)

Convert e.g. velocity (m/s) to transport (m^3/s) by multiplying by DRF and DXG,DYG.

source

MeshArrays.UVtoUEVN — Function

UVtoUEVN(u,v,G::NamedTuple)

Interpolate to grid cell centers (uC,vC)
Convert to Eastward/Northward components (uE,vN)

Note: land masking u,v with NaNs preemptively can be adequate.

source

MeshArrays.EkmanTrsp — Function

EkmanTrsp(u::AbstractMeshArray,v::AbstractMeshArray,Γ::NamedTuple)

Compute Ekman Transport (in m2/s) from wind stress (in N/m2 , or kg/m/s2).

source

MeshArrays.calc_bolus — Function

compute bolus velocty field (bolusU,bolusV,bolusW) from gm streamfunction (GMPsiX,GMPsiY)

source

Integration Paths

MeshArrays.LatitudeCircles — Function

LatitudeCircles(LatValues,Γ::NamedTuple; format=:gridpath, range=(0.0,360.0))

Compute integration paths that follow latitude circles, within the specified longitude range.

source

MeshArrays.LatitudeCircle — Function

LatitudeCircle(lat,Γ::NamedTuple; format=:gridpath, range=(0.0,360.0))

Compute the integration path along a single latitude circle at lat degrees. Returns a gridpath by default, or a NamedTuple with fields lat, name, grid, C, W, S when format=:NamedTuple.

source

MeshArrays.Transect — Function

Transect(name,lons,lats,Γ; segment=:short, format=:gridpath)

Compute integration paths that follow a great circle between two geolocations give by lons, lats.

source

MeshArrays.edge_path — Function

edge_path(name,mskCint,Γ)

Compute integration path that follows the outer edge of mskCint>0.

Γ=GridLoad(ID=:LLC90)
mask=demo.extended_basin(demo.ocean_basins(),:Pac)
edge=edge_path("Pacific Ocean Edge",mask,Γ)

source

MeshArrays.edge_mask — Function

edge_mask(mskCint::AbstractMeshArray)

Compute edge mask (mskC,mskW,mskS) from domain interior mask (mskCint). This is used in LatitudeCircles and Transect.

source

5. Integration Loop

MeshArrays.Integration.loops — Function

loops(mask::gridmask; files=String[], var=:THETA, rd=read)

begin
  @everywhere using MeshArrays, MITgcm
  @everywhere rd(F,var,tim,tmp)=read(read_mdsio(F,var),tmp)
  @everywhere G,M,files=Integration.example()
    #,regions=(30,10),depths=Integration.DEPTHS)
end

H=Integration.loops(M,files=files,rd=rd)
# Hbis=Integration.streamlined_loop(M,files=files,rd=rd)

and to save results:

using JLD2; output_path="test.jld2"
jldsave(output_path; depths=M.depths, integral=H, volume=vol, name=M.names)

where vol is calculated as follows:

#option=:loops
allones=1.0 .+0*G.hFacC
M.tmp2d.=M.v_int[1](allones)
vol=[b(M.tmp2d) for b in M.h_sum]

#option=:streamlined_loop
allones=1.0 .+0*G.hFacC
vol=[b(allones) for b in M.h_sum]

source

MeshArrays.Integration.streamlined_loop — Function

streamlined_loop(mask::gridmask; files=String[], var=:THETA, rd=read)

Alternate approach to loops, where loops are streamlined in a single dimension.

source

MeshArrays.Integration.define_regions — Function

define_regions(;option=:global,grid::NamedTuple)

Define regional integration mask (one value period region).

source

MeshArrays.Integration.define_sums — Function

define_sums(;option=:loops, grid::NamedTuple, regions=:global, 
              depths=[(0,7000)], re_define_regions=true)

Define regional integration function for each basin and depth range.

source

6. Grid Data Sets

MeshArrays.Dataset — Function

Dataset(d::String; do_read=true, verbose=false)

get folder name for dataset d.
download dataset if needed.
read content if do_read

source

Internals

MeshArrays.mydatadep — Function

mydatadep(nam="countries_shp1")

Download data dependency with predefined name; currently :

"countries_shp1"
"countries_geojson1"
"basemap_jpg1"
"interp_halfdeg"
"interp_quarterdeg"
"oceans_geojson1"

source

7. Polygons

MeshArrays.within_pol — Function

within_pol(pol; ID=1)

Generate a name,rule pair to test if location lon,lat is within polygon pol[ID].geometry.

using MeshArrays, DataDeps, GeoJSON, GeometryOps
fil=MeshArrays.Dataset("oceans_geojson1",do_read=false)
pol=MeshArrays.read_json(fil,format=:GeoJSON)

name,rule=MeshArrays.within_pol(pol; ID=11)
rule(-30,40)

source

MeshArrays.read_json — Function

read_json(fil; format=:polyarray)

Call GeoJSON.read and return polyarray (default)

format :polyarray(default): returnpolyarray`
format :coord : convert to GI.coordinates.
format :GeoJSON : return FeatureCollection (vector of name,geom pairs)

import MeshArrays, DataDeps, GeoJSON
pol=MeshArrays.Dataset("oceans_geojson1")

source

MeshArrays.read_shp — Function

read_shp(fil; format=:polyarray)

Call Shapefile.Table and Shapefile.shapes and return polyarray (default).

format :polyarray (default) : return polyarray
format :Shapefile : return vector of name,geometry` named tuples.
format :coord : convert to GI.coordinates.

using MeshArrays, DataDeps, Shapefile
fil=MeshArrays.Dataset("countries_shp1")

using CairoMakie
lines(pol)

source

MeshArrays.NamedPolygon — Type

struct NamedPolygon geometry::Vector{Tuple{Float32, Float32}} name::String points::Vector{} end

source

MeshArrays.polyarray — Type

struct polyarray name::String f::Array{NamedPolygon} end

using MeshArrays, GeoJSON, DataDeps
pol=MeshArrays.Dataset("oceans_geojson1")

write(pol,tempname()*".json")

using CairoMakie
lines(pol)

source

MeshArrays.to_Polygon — Function

to_Polygon(pa::polyarray)

Convert polyarray into a GI.Polygon array.

pol_P,nams=MeshArrays.to_Polygon(pol)

source

MeshArrays.to_polyarray — Function

 to_polyarray(pol)

Convert polygon data into a polyarray.

fil="countries.geojson"
MeshArrays.to_polyarray(GeoJSON.read(fil))

source

8. Other

MeshArrays.isosurface — Function

isosurface(θ, T, Γ)

Return the uppermost in-water depth at which θ crosses the threshold T.

Crossing depths are linearly interpolated between adjacent wet vertical cell centers, using Γ.RC. A crossing is considered only where both adjacent cells have Γ.hFacC > 0; a wet/dry transition is interpreted as the sea floor and does not constitute an isosurface.

The returned field is NaN where no in-water crossing is found, including land points, below-bottom points, columns entirely above or below T, and columns with only one wet vertical level.

The function scans downward and retains only the first valid crossing, i.e. the uppermost crossing. It supports non-monotonic vertical profiles, which may contain multiple crossings.

Dry-cell values in θ are ignored. Values of θ must be finite in wet cells.

source

MeshArrays.layerfraction — Function

layerfraction(θ, Tlo, Thi, Γ)

Return the fraction of each wet tracer cell satisfying

Tlo ≤ θ < Thi.

The result is computed as

hotlayer(θ, Tlo, Γ) - hotlayer(θ, Thi, Γ),

and thus inherits the vertical interpolation, wet/dry, surface, and sea-floor conventions of hotlayer.

Tlo must not exceed Thi. The returned fraction refers to the nominal tracer cell; multiply by Γ.hFacC and cell volume for volume-weighted integrals.

Special cases include:

coldlayer(θ, T, Γ) == layerfraction(θ, -Inf, T, Γ)
hotlayer(θ, T, Γ)  == layerfraction(θ, T, Inf, Γ)

up to floating-point roundoff.

See also: hotlayer, coldlayer, isosurface.

source

MeshArrays.hotlayer — Function

hotlayer(θ, T, Γ)

Return the fraction of each wet tracer cell for which θ ≥ T.

The returned MeshArray has values between zero and one. It accounts for linear variation of θ between adjacent wet cell centers, and therefore allows fractional contributions from cells crossed by the threshold. Non-monotonic profiles and multiple crossings are supported.

At the upper ocean boundary and at a wet/dry transition at the sea floor, the relevant half-cell is classified using the adjacent wet cell-center value. Dry cells, identified by Γ.hFacC == 0, are returned as zero.

The result is a fraction of the nominal tracer cell; Γ.hFacC is used only to distinguish wet from dry cells. For a physical-volume integral, multiply the result by Γ.hFacC and the cell volume.

source

MeshArrays.coldlayer — Function

coldlayer(θ, T, Γ)

Return the fraction of each wet tracer cell for which θ < T.

This is the wet-cell complement of hotlayer, which uses the convention θ ≥ T. It therefore has identical vertical interpolation, surface, sea-floor, and wet/dry conventions.

Dry cells, identified by Γ.hFacC == 0, are returned as zero. The result is a fraction of the nominal tracer cell; include Γ.hFacC separately when computing physical-volume integrals.

source

MeshArrays.land_mask — Function

land_mask(m::AbstractMeshArray)

Define land mask from m (1 if m>0; NaN if otherwise).

source

MeshArrays.demo.ocean_basins — Function

ocean_basins()

Mask of ocean basins on ECCO grid (LLC90).

basins=demo.ocean_basins()
AtlExt=extended_basin(basins,:Atl)

source

MeshArrays.demo.extended_basin — Function

extended_basin(basins,ID=:Atl)

Consolidate basins mask to include marginal seas.

note : has only be tested on the ECCO grid (LLC90).

basins=demo.ocean_basins()
AtlExt=extended_basin(basins,:Atl)

source

Masked Array Utilities

MeshArrays.nansum — Function

Sum of non-NaN elements; nansum(x,dim) reduces along dimension dim.

source

MeshArrays.nanmean — Function

Mean of non-NaN elements; nanmean(x,dim) reduces along dimension dim. Two-argument scalar form returns the mean of the two values, treating NaN as missing.

source

MeshArrays.nanmax — Function

Maximum of non-NaN elements; nanmax(x,dim) reduces along dimension dim.

source

MeshArrays.nanmin — Function

Minimum of non-NaN elements; nanmin(x,dim) reduces along dimension dim.

source