How to set up an infinite ocean?

[josuemtzmo]

Hello,

I'm new using oceananigans. I'm interested of creating a configuration with an open boundary to avoid the reflection of waves back into the domain (see issue in fig below of vorticity).

In other words, I would like to create an infinite ocean. My understanding reading the documentation is that I need to prescribe the open boundary condition (OpenBoundaryCondition ) as shown below to make the velocities zero in the normal direction of the model edge.

u_nsopen = OpenBoundaryCondition(0.0)
v_ewopen = OpenBoundaryCondition(0.0)

u_ewopen = OpenBoundaryCondition(0.0)
v_nsopen = OpenBoundaryCondition(0.0)

u_bcs = FieldBoundaryConditions(top = drag_bc_u, 
                                east = u_ewopen, 
                                west = u_ewopen,
                                north = u_nsopen,
                                south = u_nsopen,
                                )

v_bcs = FieldBoundaryConditions(top = drag_bc_v, 
                                east = v_ewopen, 
                                west = v_ewopen,
                                north = v_nsopen, 
                                south = v_nsopen 
                                )

I've used the conditions above, and I still have reflection of waves, so I'm certainly doing something wrong.

Is there something that I'm missing?

[glwagner]

Probably you want to add sponge layer forcing on the velocity fields (possibly also the tracer fields) to damp perturbations that come close to the boundary. You can use Relaxation for that:

https://clima.github.io/OceananigansDocumentation/stable/model_setup/forcing_functions/#Relaxation

There's also some information on Relaxation in its docstring.

Note that OpenBoundaryCondition is supposed to set the state of the given field on the boundary directly. So OpenBoundaryCondition(0) is used only for wall-normal velocities, and a synonymous with impenetrable boundary. There's no need to use this boundary condition explicitly; it will be default for Bounded topologies.

There is some work now to add features so that OpenBoundaryCondition can be used for open boundary conditions but we its still a WIP.

[josuemtzmo]

Just for reference, I've created this function to mask the damping at the edge of the domain using a smoothed square wave:

"""
    EdgeMask{D}(A,f,delta)

Callable object that returns a edge mask function centered on
center of the domain, with `A`, the amplitude of the square wave,
`f` the frequency of the wave, and `delta` the with smoothing of the square wave.

Examples
========

* Create a edge mask using a smoothe squared wave, centered in the center of the domain.

julia
julia> mask = EdgeMask{:z}(A, f, delta)

"""
struct EdgeMask{D, T}
     A :: T
     f :: T
     delta :: T

    function EdgeMask{D}(; A, f, delta) where D
        T = promote_type(typeof(A), typeof(f), typeof(delta))
        return new{D, T}(A, f, delta)
    end
end    

@inline (g::EdgeMask{:xy})(x, y, z) = -1 * ((2*A/pi)* atan(sin(-pi/2 + 2*pi*(x/(Lx/2))*f)/delta) * (2*A/pi)* atan(sin(-pi/2 + 2*pi*(y/(Ly/2))*f)/delta)) + 1

with A = 1, f = 0.25, delta=0.04

[glwagner]

Nice! Your function might be expensive because it nests a sin inside atan. But depending on your case it may not have a noticeable impact on performance.

Mainly I suggest writing the mask function in more than one line. It's hard to read all on one line. I also suggest patterns like 2π rather than 2 * pi for readability.

The example uses a direction :z, but the source code seems to have a direction :xy, is that right?

[glwagner]

Also I think there are some bugs, you need g.A rather than just A. But in the source code the letter "g" stood for Gaussian, so maybe something like m is better.

[glwagner]

As an example:

@inline function (edge_mask::EdgeMask{:xy})(x, y, z)
    A = edge_mask.A
    δ = edge_mask.delta
    f = edge_mask.f
    Lx = edge_mask.Lx
    Ly = edge_mask.Ly

    sin_x = sin(4π * f * x / Lx - π/2) / δ
    sin_y = sin(4π * f * y / Ly - π/2) / δ

    return 2A/π * (atan(sin_x) + atan(sin_y))
end