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)])

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,Γ)

Depth of isosurface θ=T

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