mom_ale Module Reference

Detailed Description

This module contains the main regridding routines.

Regridding comprises two steps:

1. Interpolation and creation of a new grid based on target interface densities (or any other criterion).
2. Remapping of quantities between old grid and new grid.

Original module written by Laurent White, 2008.06.09

Data Types
type	ale_cs
	ALE control structure. More...

Functions/Subroutines
subroutine, public	ale_init (param_file, GV, US, max_depth, CS)
	This routine is typically called (from initialize_MOM in file MOM.F90) before the main time integration loop to initialize the regridding stuff. We read the MOM_input file to register the values of different regridding/remapping parameters. More...
subroutine, public	ale_register_diags (Time, G, GV, US, diag, CS)
	Initialize diagnostics for the ALE module. More...
subroutine, public	adjustgridforintegrity (CS, G, GV, h)
	Crudely adjust (initial) grid for integrity. This routine is typically called (from initialize_MOM in file MOM.F90) before the main time integration loop to initialize the regridding stuff. We read the MOM_input file to register the values of different regridding/remapping parameters. More...
subroutine, public	ale_end (CS)
	End of regridding (memory deallocation). This routine is typically called (from MOM_end in file MOM.F90) after the main time integration loop to deallocate the regridding stuff. More...
subroutine, public	ale_main (G, GV, US, h, u, v, tv, Reg, CS, OBC, dt, frac_shelf_h)
	Takes care of (1) building a new grid and (2) remapping all variables between the old grid and the new grid. The creation of the new grid can be based on z coordinates, target interface densities, sigma coordinates or any arbitrary coordinate system. More...
subroutine, public	ale_main_offline (G, GV, h, tv, Reg, CS, OBC, dt)
	Takes care of (1) building a new grid and (2) remapping all variables between the old grid and the new grid. The creation of the new grid can be based on z coordinates, target interface densities, sigma coordinates or any arbitrary coordinate system. More...
subroutine, public	ale_offline_inputs (CS, G, GV, h, tv, Reg, uhtr, vhtr, Kd, debug, OBC)
	Regrid/remap stored fields used for offline tracer integrations. These input fields are assumed to have the same layer thicknesses at the end of the last offline interval (which should be a Zstar grid). This routine builds a grid on the runtime specified vertical coordinate. More...
subroutine, public	ale_offline_tracer_final (G, GV, h, tv, h_target, Reg, CS, OBC)
	Remaps all tracers from h onto h_target. This is intended to be called when tracers are done offline. In the case where transports don't quite conserve, we still want to make sure that layer thicknesses offline do not drift too far away from the online model. More...
subroutine	check_grid (G, GV, h, threshold)
	Check grid for negative thicknesses. More...
subroutine, public	ale_build_grid (G, GV, regridCS, remapCS, h, tv, debug, frac_shelf_h)
	Generates new grid. More...
subroutine, public	ale_regrid_accelerated (CS, G, GV, h, tv, n, u, v, OBC, Reg, dt, dzRegrid, initial)
	For a state-based coordinate, accelerate the process of regridding by repeatedly applying the grid calculation algorithm. More...
subroutine	remap_all_state_vars (CS_remapping, CS_ALE, G, GV, h_old, h_new, Reg, OBC, dxInterface, u, v, debug, dt)
	This routine takes care of remapping all variable between the old and the new grids. When velocity components need to be remapped, thicknesses at velocity points are taken to be arithmetic averages of tracer thicknesses. This routine is called during initialization of the model at time=0, to remap initiali conditions to the model grid. It is also called during a time step to update the state. More...
subroutine, public	ale_remap_scalar (CS, G, GV, nk_src, h_src, s_src, h_dst, s_dst, all_cells, old_remap, answers_2018)
	Remaps a single scalar between grids described by thicknesses h_src and h_dst. h_dst must be dimensioned as a model array with GVke layers while h_src can have an arbitrary number of layers specified by nk_src. More...
subroutine, public	ts_plm_edge_values (CS, S_t, S_b, T_t, T_b, G, GV, tv, h, bdry_extrap)
	Calculate edge values (top and bottom of layer) for T and S consistent with a PLM reconstruction in the vertical direction. Boundary reconstructions are PCM unless bdry_extrap is true. More...
subroutine, public	ale_plm_edge_values (CS, G, GV, h, Q, bdry_extrap, Q_t, Q_b)
	Calculate edge values (top and bottom of layer) 3d scalar array. Boundary reconstructions are PCM unless bdry_extrap is true. More...
subroutine, public	ts_ppm_edge_values (CS, S_t, S_b, T_t, T_b, G, GV, tv, h, bdry_extrap)
	Calculate edge values (top and bottom of layer) for T and S consistent with a PPM reconstruction in the vertical direction. Boundary reconstructions are PCM unless bdry_extrap is true. More...
subroutine, public	ale_initregridding (GV, US, max_depth, param_file, mdl, regridCS)
	Initializes regridding for the main ALE algorithm. More...
real function, dimension(cs%nk+1), public	ale_getcoordinate (CS)
	Query the target coordinate interfaces positions. More...
character(len=20) function, public	ale_getcoordinateunits (CS)
	Query the target coordinate units. More...
logical function, public	ale_remap_init_conds (CS)
	Returns true if initial conditions should be regridded and remapped. More...
subroutine, public	ale_update_regrid_weights (dt, CS)
	Updates the weights for time filtering the new grid generated in regridding. More...
subroutine, public	ale_updateverticalgridtype (CS, GV)
	Update the vertical grid type with ALE information. This subroutine sets information in the verticalGrid_type to be consistent with the use of ALE mode. More...
subroutine, public	ale_writecoordinatefile (CS, GV, directory)
	Write the vertical coordinate information into a file. This subroutine writes out a file containing any available data related to the vertical grid used by the MOM ocean model when in ALE mode. More...
subroutine, public	ale_initthicknesstocoord (CS, G, GV, h)
	Set h to coordinate values for fixed coordinate systems. More...

Function/Subroutine Documentation

adjustgridforintegrity()

subroutine, public mom_ale::adjustgridforintegrity	(	type(ale_cs), pointer	CS,
		type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		real, dimension(szi_(g),szj_(g),szk_(gv)), intent(inout)	h
	)

Crudely adjust (initial) grid for integrity. This routine is typically called (from initialize_MOM in file MOM.F90) before the main time integration loop to initialize the regridding stuff. We read the MOM_input file to register the values of different regridding/remapping parameters.

Parameters

	cs	Regridding parameters and options
[in]	g	Ocean grid informations
[in]	gv	Ocean vertical grid structure
[in,out]	h	Current 3D grid thickness that are to be adjusted [H ~> m or kg-2]

Definition at line 292 of file MOM_ALE.F90.

  type(ALE_CS),                              pointer       :: CS  !< Regridding parameters and options
  type(ocean_grid_type),                     intent(in)    :: G   !< Ocean grid informations
  type(verticalGrid_type),                   intent(in)    :: GV  !< Ocean vertical grid structure
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), intent(inout) :: h   !< Current 3D grid thickness that
                                                                  !! are to be adjusted [H ~> m or kg-2]
  call inflate_vanished_layers_old( cs%regridCS, g, gv, h(:,:,:) )
 

ale_build_grid()

subroutine, public mom_ale::ale_build_grid	(	type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		type(regridding_cs), intent(in)	regridCS,
		type(remapping_cs), intent(in)	remapCS,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, gv %ke), intent(inout)	h,
		type(thermo_var_ptrs), intent(inout)	tv,
		logical, intent(in), optional	debug,
		real, dimension(:,:), optional, pointer	frac_shelf_h
	)

Generates new grid.

Parameters

[in]	g	Ocean grid structure
[in]	gv	Ocean vertical grid structure
[in]	regridcs	Regridding parameters and options
[in]	remapcs	Remapping parameters and options
[in,out]	tv	Thermodynamical variable structure
[in,out]	h	Current 3D grid obtained after the last time step [H ~> m or kg-2]
[in]	debug	If true, show the call tree
	frac_shelf_h	Fractional ice shelf coverage

Definition at line 615 of file MOM_ALE.F90.

  type(ocean_grid_type),                   intent(in)    :: G        !< Ocean grid structure
  type(verticalGrid_type),                 intent(in)    :: GV       !< Ocean vertical grid structure
  type(regridding_CS),                     intent(in)    :: regridCS !< Regridding parameters and options
  type(remapping_CS),                      intent(in)    :: remapCS  !< Remapping parameters and options
  type(thermo_var_ptrs),                   intent(inout) :: tv       !< Thermodynamical variable structure
  real, dimension(SZI_(G),SZJ_(G), SZK_(GV)), intent(inout) :: h     !< Current 3D grid obtained after the
                                                                     !! last time step [H ~> m or kg-2]
  logical,                       optional, intent(in)    :: debug    !< If true, show the call tree
  real, dimension(:,:),          optional, pointer       :: frac_shelf_h !< Fractional ice shelf coverage
  ! Local variables
  integer :: nk, i, j, k
  real, dimension(SZI_(G), SZJ_(G), SZK_(GV)+1) :: dzRegrid ! The change in grid interface positions
  real, dimension(SZI_(G), SZJ_(G), SZK_(GV)) :: h_new ! The new grid thicknesses
  logical :: show_call_tree, use_ice_shelf
 
  show_call_tree = .false.
  if (present(debug)) show_call_tree = debug
  if (show_call_tree) call calltree_enter("ALE_build_grid(), MOM_ALE.F90")
  use_ice_shelf = .false.
  if (present(frac_shelf_h)) then
    if (associated(frac_shelf_h)) use_ice_shelf = .true.
  endif
 
  ! Build new grid. The new grid is stored in h_new. The old grid is h.
  ! Both are needed for the subsequent remapping of variables.
  if (use_ice_shelf) then
     call regridding_main( remapcs, regridcs, g, gv, h, tv, h_new, dzregrid, frac_shelf_h )
  else
     call regridding_main( remapcs, regridcs, g, gv, h, tv, h_new, dzregrid )
  endif
 
  ! Override old grid with new one. The new grid 'h_new' is built in
  ! one of the 'build_...' routines above.
!$OMP parallel do default(none) shared(G,h,h_new)
  do j = g%jsc,g%jec ; do i = g%isc,g%iec
    if (g%mask2dT(i,j)>0.) h(i,j,:) = h_new(i,j,:)
  enddo ; enddo
 
  if (show_call_tree) call calltree_leave("ALE_build_grid()")

ale_end()

subroutine, public mom_ale::ale_end

(

type(ale_cs), pointer

CS

)

End of regridding (memory deallocation). This routine is typically called (from MOM_end in file MOM.F90) after the main time integration loop to deallocate the regridding stuff.

Parameters

cs	module control structure

Definition at line 306 of file MOM_ALE.F90.

  type(ALE_CS), pointer :: CS  !< module control structure
 
  ! Deallocate memory used for the regridding
  call end_remapping( cs%remapCS )
  call end_regridding( cs%regridCS )
 
  deallocate(cs)
 

ale_getcoordinate()

real function, dimension(cs%nk+1), public mom_ale::ale_getcoordinate

(

type(ale_cs), pointer

CS

)

Query the target coordinate interfaces positions.

Parameters

cs	module control structure

Definition at line 1206 of file MOM_ALE.F90.

  type(ALE_CS), pointer    :: CS                  !< module control structure
 
  real, dimension(CS%nk+1) :: ALE_getCoordinate
  ale_getcoordinate(:) = getcoordinateinterfaces( cs%regridCS, undo_scaling=.true. )
 

ale_getcoordinateunits()

character(len=20) function, public mom_ale::ale_getcoordinateunits

(

type(ale_cs), pointer

CS

)

Query the target coordinate units.

Parameters

cs	module control structure

Definition at line 1216 of file MOM_ALE.F90.

  type(ALE_CS), pointer :: CS   !< module control structure
 
  character(len=20)     :: ALE_getCoordinateUnits
 
  ale_getcoordinateunits = getcoordinateunits( cs%regridCS )
 

ale_init()

subroutine, public mom_ale::ale_init	(	type(param_file_type), intent(in)	param_file,
		type(verticalgrid_type), intent(in)	GV,
		type(unit_scale_type), intent(in)	US,
		real, intent(in)	max_depth,
		type(ale_cs), pointer	CS
	)

This routine is typically called (from initialize_MOM in file MOM.F90) before the main time integration loop to initialize the regridding stuff. We read the MOM_input file to register the values of different regridding/remapping parameters.

Parameters

[in]	param_file	Parameter file
[in]	gv	Ocean vertical grid structure
[in]	us	A dimensional unit scaling type
[in]	max_depth	The maximum depth of the ocean [Z ~> m].
	cs	Module control structure

Definition at line 139 of file MOM_ALE.F90.

  type(param_file_type),   intent(in) :: param_file !< Parameter file
  type(verticalGrid_type), intent(in) :: GV         !< Ocean vertical grid structure
  type(unit_scale_type),   intent(in) :: US         !< A dimensional unit scaling type
  real,                    intent(in) :: max_depth  !< The maximum depth of the ocean [Z ~> m].
  type(ALE_CS),            pointer    :: CS         !< Module control structure
 
  ! Local variables
  real, dimension(:), allocatable :: dz
  character(len=40)               :: mdl = "MOM_ALE" ! This module's name.
  character(len=80)               :: string ! Temporary strings
  real                            :: filter_shallow_depth, filter_deep_depth
  logical       :: default_2018_answers
  logical                         :: check_reconstruction
  logical                         :: check_remapping
  logical                         :: force_bounds_in_subcell
  logical                         :: local_logical
  logical                         :: remap_boundary_extrap
 
  if (associated(cs)) then
    call mom_error(warning, "ALE_init called with an associated "// &
                            "control structure.")
    return
  endif
  allocate(cs)
 
  cs%show_call_tree = calltree_showquery()
  if (cs%show_call_tree) call calltree_enter("ALE_init(), MOM_ALE.F90")
 
  call get_param(param_file, mdl, "REMAP_UV_USING_OLD_ALG", cs%remap_uv_using_old_alg, &
                 "If true, uses the old remapping-via-a-delta-z method for "//&
                 "remapping u and v. If false, uses the new method that remaps "//&
                 "between grids described by an old and new thickness.", &
                 default=.false.)
 
  ! Initialize and configure regridding
  call ale_initregridding(gv, us, max_depth, param_file, mdl, cs%regridCS)
 
  ! Initialize and configure remapping
  call get_param(param_file, mdl, "REMAPPING_SCHEME", string, &
                 "This sets the reconstruction scheme used "//&
                 "for vertical remapping for all variables. "//&
                 "It can be one of the following schemes: "//&
                 trim(remappingschemesdoc), default=remappingdefaultscheme)
  call get_param(param_file, mdl, "FATAL_CHECK_RECONSTRUCTIONS", check_reconstruction, &
                 "If true, cell-by-cell reconstructions are checked for "//&
                 "consistency and if non-monotonicity or an inconsistency is "//&
                 "detected then a FATAL error is issued.", default=.false.)
  call get_param(param_file, mdl, "FATAL_CHECK_REMAPPING", check_remapping, &
                 "If true, the results of remapping are checked for "//&
                 "conservation and new extrema and if an inconsistency is "//&
                 "detected then a FATAL error is issued.", default=.false.)
  call get_param(param_file, mdl, "REMAP_BOUND_INTERMEDIATE_VALUES", force_bounds_in_subcell, &
                 "If true, the values on the intermediate grid used for remapping "//&
                 "are forced to be bounded, which might not be the case due to "//&
                 "round off.", default=.false.)
  call get_param(param_file, mdl, "REMAP_BOUNDARY_EXTRAP", remap_boundary_extrap, &
                 "If true, values at the interfaces of boundary cells are "//&
                 "extrapolated instead of piecewise constant", default=.false.)
  call get_param(param_file, mdl, "DEFAULT_2018_ANSWERS", default_2018_answers, &
                 "This sets the default value for the various _2018_ANSWERS parameters.", &
                 default=.false.)
  call get_param(param_file, mdl, "REMAPPING_2018_ANSWERS", cs%answers_2018, &
                 "If true, use the order of arithmetic and expressions that recover the "//&
                 "answers from the end of 2018.  Otherwise, use updated and more robust "//&
                 "forms of the same expressions.", default=default_2018_answers)
  call initialize_remapping( cs%remapCS, string, &
                             boundary_extrapolation=remap_boundary_extrap, &
                             check_reconstruction=check_reconstruction, &
                             check_remapping=check_remapping, &
                             force_bounds_in_subcell=force_bounds_in_subcell, &
                             answers_2018=cs%answers_2018)
 
  call get_param(param_file, mdl, "REMAP_AFTER_INITIALIZATION", cs%remap_after_initialization, &
                 "If true, applies regridding and remapping immediately after "//&
                 "initialization so that the state is ALE consistent. This is a "//&
                 "legacy step and should not be needed if the initialization is "//&
                 "consistent with the coordinate mode.", default=.true.)
 
  call get_param(param_file, mdl, "REGRID_TIME_SCALE", cs%regrid_time_scale, &
                 "The time-scale used in blending between the current (old) grid "//&
                 "and the target (new) grid. A short time-scale favors the target "//&
                 "grid (0. or anything less than DT_THERM) has no memory of the old "//&
                 "grid. A very long time-scale makes the model more Lagrangian.", &
                 units="s", default=0., scale=us%s_to_T)
  call get_param(param_file, mdl, "REGRID_FILTER_SHALLOW_DEPTH", filter_shallow_depth, &
                 "The depth above which no time-filtering is applied. Above this depth "//&
                 "final grid exactly matches the target (new) grid.", &
                 units="m", default=0., scale=gv%m_to_H)
  call get_param(param_file, mdl, "REGRID_FILTER_DEEP_DEPTH", filter_deep_depth, &
                 "The depth below which full time-filtering is applied with time-scale "//&
                 "REGRID_TIME_SCALE. Between depths REGRID_FILTER_SHALLOW_DEPTH and "//&
                 "REGRID_FILTER_SHALLOW_DEPTH the filter weights adopt a cubic profile.", &
                 units="m", default=0., scale=gv%m_to_H)
  call set_regrid_params(cs%regridCS, depth_of_time_filter_shallow=filter_shallow_depth, &
                         depth_of_time_filter_deep=filter_deep_depth)
  call get_param(param_file, mdl, "REGRID_USE_OLD_DIRECTION", local_logical, &
                 "If true, the regridding ntegrates upwards from the bottom for "//&
                 "interface positions, much as the main model does. If false "//&
                 "regridding integrates downward, consistant with the remapping "//&
                 "code.", default=.true., do_not_log=.true.)
  call set_regrid_params(cs%regridCS, integrate_downward_for_e=.not.local_logical)
 
  ! Keep a record of values for subsequent queries
  cs%nk = gv%ke
 
  if (cs%show_call_tree) call calltree_leave("ALE_init()")

ale_initregridding()

subroutine, public mom_ale::ale_initregridding	(	type(verticalgrid_type), intent(in)	GV,
		type(unit_scale_type), intent(in)	US,
		real, intent(in)	max_depth,
		type(param_file_type), intent(in)	param_file,
		character(len=*), intent(in)	mdl,
		type(regridding_cs), intent(out)	regridCS
	)

Initializes regridding for the main ALE algorithm.

Parameters

[in]	gv	Ocean vertical grid structure
[in]	us	A dimensional unit scaling type
[in]	max_depth	The maximum depth of the ocean [Z ~> m].
[in]	param_file	parameter file
[in]	mdl	Name of calling module
[out]	regridcs	Regridding parameters and work arrays

Definition at line 1185 of file MOM_ALE.F90.

  type(verticalGrid_type), intent(in)  :: GV         !< Ocean vertical grid structure
  type(unit_scale_type),   intent(in)  :: US         !< A dimensional unit scaling type
  real,                    intent(in)  :: max_depth  !< The maximum depth of the ocean [Z ~> m].
  type(param_file_type),   intent(in)  :: param_file !< parameter file
  character(len=*),        intent(in)  :: mdl        !< Name of calling module
  type(regridding_CS),     intent(out) :: regridCS   !< Regridding parameters and work arrays
  ! Local variables
  character(len=30) :: coord_mode
 
  call get_param(param_file, mdl, "REGRIDDING_COORDINATE_MODE", coord_mode, &
                 "Coordinate mode for vertical regridding. "//&
                 "Choose among the following possibilities: "//&
                 trim(regriddingcoordinatemodedoc), &
                 default=default_coordinate_mode, fail_if_missing=.true.)
 
  call initialize_regridding(regridcs, gv, us, max_depth, param_file, mdl, coord_mode, '', '')
 

ale_initthicknesstocoord()

subroutine, public mom_ale::ale_initthicknesstocoord	(	type(ale_cs), intent(inout)	CS,
		type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		real, dimension(szi_(g),szj_(g),szk_(gv)), intent(out)	h
	)

Set h to coordinate values for fixed coordinate systems.

Parameters

[in,out]	cs	module control structure
[in]	g	module grid structure
[in]	gv	Ocean vertical grid structure
[out]	h	layer thickness [H ~> m or kg m-2]

Definition at line 1305 of file MOM_ALE.F90.

  type(ALE_CS), intent(inout)                            :: CS  !< module control structure
  type(ocean_grid_type), intent(in)                      :: G   !< module grid structure
  type(verticalGrid_type), intent(in)                    :: GV  !< Ocean vertical grid structure
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), intent(out) :: h   !< layer thickness [H ~> m or kg m-2]
 
  ! Local variables
  integer :: i, j, k
 
  do j = g%jsd,g%jed ; do i = g%isd,g%ied
    h(i,j,:) = gv%Z_to_H * getstaticthickness( cs%regridCS, 0., g%bathyT(i,j) )
  enddo ; enddo
 

ale_main()

subroutine, public mom_ale::ale_main	(	type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		type(unit_scale_type), intent(in)	US,
		real, dimension(szi_(g),szj_(g),szk_(gv)), intent(inout)	h,
		real, dimension(szib_(g),szj_(g),szk_(gv)), intent(inout)	u,
		real, dimension(szi_(g),szjb_(g),szk_(gv)), intent(inout)	v,
		type(thermo_var_ptrs), intent(inout)	tv,
		type(tracer_registry_type), pointer	Reg,
		type(ale_cs), pointer	CS,
		type(ocean_obc_type), pointer	OBC,
		real, intent(in), optional	dt,
		real, dimension(:,:), optional, pointer	frac_shelf_h
	)

Takes care of (1) building a new grid and (2) remapping all variables between the old grid and the new grid. The creation of the new grid can be based on z coordinates, target interface densities, sigma coordinates or any arbitrary coordinate system.

Parameters

[in]	g	Ocean grid informations
[in]	gv	Ocean vertical grid structure
[in]	us	A dimensional unit scaling type
[in,out]	h	Current 3D grid obtained after the last time step [H ~> m or kg m-2]
[in,out]	u	Zonal velocity field [L T-1 ~> m s-1]
[in,out]	v	Meridional velocity field [L T-1 ~> m s-1]
[in,out]	tv	Thermodynamic variable structure
	reg	Tracer registry structure
	cs	Regridding parameters and options
	obc	Open boundary structure
[in]	dt	Time step between calls to ALE_main [T ~> s]
	frac_shelf_h	Fractional ice shelf coverage

Definition at line 321 of file MOM_ALE.F90.

  type(ocean_grid_type),                      intent(in)    :: G   !< Ocean grid informations
  type(verticalGrid_type),                    intent(in)    :: GV  !< Ocean vertical grid structure
  type(unit_scale_type),                      intent(in)    :: US  !< A dimensional unit scaling type
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)),  intent(inout) :: h   !< Current 3D grid obtained after the
                                                                   !! last time step [H ~> m or kg m-2]
  real, dimension(SZIB_(G),SZJ_(G),SZK_(GV)), intent(inout) :: u   !< Zonal velocity field [L T-1 ~> m s-1]
  real, dimension(SZI_(G),SZJB_(G),SZK_(GV)), intent(inout) :: v   !< Meridional velocity field [L T-1 ~> m s-1]
  type(thermo_var_ptrs),                      intent(inout) :: tv  !< Thermodynamic variable structure
  type(tracer_registry_type),                 pointer       :: Reg !< Tracer registry structure
  type(ALE_CS),                               pointer       :: CS  !< Regridding parameters and options
  type(ocean_OBC_type),                       pointer       :: OBC !< Open boundary structure
  real,                             optional, intent(in)    :: dt  !< Time step between calls to ALE_main [T ~> s]
  real, dimension(:,:),             optional, pointer       :: frac_shelf_h !< Fractional ice shelf coverage
  ! Local variables
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)+1) :: dzRegrid ! The change in grid interface positions
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)+1) :: eta_preale
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)) :: h_new ! New 3D grid obtained after last time step [H ~> m or kg-2]
  integer :: nk, i, j, k, isc, iec, jsc, jec
  logical :: ice_shelf
 
  nk = gv%ke; isc = g%isc; iec = g%iec; jsc = g%jsc; jec = g%jec
 
  ice_shelf = .false.
  if (present(frac_shelf_h)) then
    if (associated(frac_shelf_h)) ice_shelf = .true.
  endif
 
  if (cs%show_call_tree) call calltree_enter("ALE_main(), MOM_ALE.F90")
 
  ! These diagnostics of the state before ALE is applied are mostly used for debugging.
  if (cs%id_u_preale > 0) call post_data(cs%id_u_preale, u,    cs%diag)
  if (cs%id_v_preale > 0) call post_data(cs%id_v_preale, v,    cs%diag)
  if (cs%id_h_preale > 0) call post_data(cs%id_h_preale, h,    cs%diag)
  if (cs%id_T_preale > 0) call post_data(cs%id_T_preale, tv%T, cs%diag)
  if (cs%id_S_preale > 0) call post_data(cs%id_S_preale, tv%S, cs%diag)
  if (cs%id_e_preale > 0) then
    call find_eta(h, tv, g, gv, us, eta_preale)
    call post_data(cs%id_e_preale, eta_preale, cs%diag)
  endif
 
  if (present(dt)) then
    call ale_update_regrid_weights( dt, cs )
  endif
  dzregrid(:,:,:) = 0.0
 
  ! Build new grid. The new grid is stored in h_new. The old grid is h.
  ! Both are needed for the subsequent remapping of variables.
  if (ice_shelf) then
     call regridding_main( cs%remapCS, cs%regridCS, g, gv, h, tv, h_new, dzregrid, frac_shelf_h)
  else
     call regridding_main( cs%remapCS, cs%regridCS, g, gv, h, tv, h_new, dzregrid)
  endif
 
  call check_grid( g, gv, h, 0. )
 
  if (cs%show_call_tree) call calltree_waypoint("new grid generated (ALE_main)")
 
  ! The presence of dt is used for expediency to distinguish whether ALE_main is being called during init
  ! or in the main loop. Tendency diagnostics in remap_all_state_vars also rely on this logic.
  if (present(dt)) then
    call diag_update_remap_grids(cs%diag)
  endif
  ! Remap all variables from old grid h onto new grid h_new
  call remap_all_state_vars( cs%remapCS, cs, g, gv, h, h_new, reg, obc, -dzregrid, &
                             u, v, cs%show_call_tree, dt )
 
  if (cs%show_call_tree) call calltree_waypoint("state remapped (ALE_main)")
 
  ! Override old grid with new one. The new grid 'h_new' is built in
  ! one of the 'build_...' routines above.
  !$OMP parallel do default(shared)
  do k = 1,nk ; do j = jsc-1,jec+1 ; do i = isc-1,iec+1
    h(i,j,k) = h_new(i,j,k)
  enddo ; enddo ; enddo
 
  if (cs%show_call_tree) call calltree_leave("ALE_main()")
 
  if (cs%id_dzRegrid>0 .and. present(dt)) call post_data(cs%id_dzRegrid, dzregrid, cs%diag)
 
 

ale_main_offline()

subroutine, public mom_ale::ale_main_offline	(	type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		real, dimension(szi_(g),szj_(g),szk_(gv)), intent(inout)	h,
		type(thermo_var_ptrs), intent(inout)	tv,
		type(tracer_registry_type), pointer	Reg,
		type(ale_cs), pointer	CS,
		type(ocean_obc_type), pointer	OBC,
		real, intent(in), optional	dt
	)

Takes care of (1) building a new grid and (2) remapping all variables between the old grid and the new grid. The creation of the new grid can be based on z coordinates, target interface densities, sigma coordinates or any arbitrary coordinate system.

Parameters

[in]	g	Ocean grid informations
[in]	gv	Ocean vertical grid structure
[in,out]	h	Current 3D grid obtained after the last time step [H ~> m or kg-2]
[in,out]	tv	Thermodynamic variable structure
	reg	Tracer registry structure
	cs	Regridding parameters and options
	obc	Open boundary structure
[in]	dt	Time step between calls to ALE_main [T ~> s]

Definition at line 408 of file MOM_ALE.F90.

  type(ocean_grid_type),                      intent(in)    :: G   !< Ocean grid informations
  type(verticalGrid_type),                    intent(in)    :: GV  !< Ocean vertical grid structure
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)),  intent(inout) :: h   !< Current 3D grid obtained after the
                                                                   !! last time step [H ~> m or kg-2]
  type(thermo_var_ptrs),                      intent(inout) :: tv  !< Thermodynamic variable structure
  type(tracer_registry_type),                 pointer       :: Reg !< Tracer registry structure
  type(ALE_CS),                               pointer       :: CS  !< Regridding parameters and options
  type(ocean_OBC_type),                       pointer       :: OBC !< Open boundary structure
  real,                             optional, intent(in)    :: dt  !< Time step between calls to ALE_main [T ~> s]
  ! Local variables
  real, dimension(SZI_(G), SZJ_(G), SZK_(GV)+1) :: dzRegrid ! The change in grid interface positions
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)) :: h_new ! New 3D grid obtained after last time step [H ~> m or kg-2]
  integer :: nk, i, j, k, isc, iec, jsc, jec
 
  nk = gv%ke; isc = g%isc; iec = g%iec; jsc = g%jsc; jec = g%jec
 
  if (cs%show_call_tree) call calltree_enter("ALE_main_offline(), MOM_ALE.F90")
 
  if (present(dt)) then
    call ale_update_regrid_weights( dt, cs )
  endif
  dzregrid(:,:,:) = 0.0
 
  ! Build new grid. The new grid is stored in h_new. The old grid is h.
  ! Both are needed for the subsequent remapping of variables.
  call regridding_main( cs%remapCS, cs%regridCS, g, gv, h, tv, h_new, dzregrid )
 
  call check_grid( g, gv, h, 0. )
 
  if (cs%show_call_tree) call calltree_waypoint("new grid generated (ALE_main)")
 
  ! Remap all variables from old grid h onto new grid h_new
 
  call remap_all_state_vars(cs%remapCS, cs, g, gv, h, h_new, reg, obc, &
                            debug=cs%show_call_tree, dt=dt )
 
  if (cs%show_call_tree) call calltree_waypoint("state remapped (ALE_main)")
 
  ! Override old grid with new one. The new grid 'h_new' is built in
  ! one of the 'build_...' routines above.
  !$OMP parallel do default(shared)
  do k = 1,nk ; do j = jsc-1,jec+1 ; do i = isc-1,iec+1
    h(i,j,k) = h_new(i,j,k)
  enddo ; enddo ; enddo
 
  if (cs%show_call_tree) call calltree_leave("ALE_main()")
  if (cs%id_dzRegrid>0 .and. present(dt)) call post_data(cs%id_dzRegrid, dzregrid, cs%diag)
 

ale_offline_inputs()

subroutine, public mom_ale::ale_offline_inputs	(	type(ale_cs), pointer	CS,
		type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		real, dimension(szi_(g),szj_(g),szk_(gv)), intent(inout)	h,
		type(thermo_var_ptrs), intent(inout)	tv,
		type(tracer_registry_type), pointer	Reg,
		real, dimension(szib_(g),szj_(g),szk_(gv)), intent(inout)	uhtr,
		real, dimension(szi_(g),szjb_(g),szk_(gv)), intent(inout)	vhtr,
		real, dimension(szi_(g),szj_(g),szk_(gv)+1), intent(inout)	Kd,
		logical, intent(in)	debug,
		type(ocean_obc_type), pointer	OBC
	)

Regrid/remap stored fields used for offline tracer integrations. These input fields are assumed to have the same layer thicknesses at the end of the last offline interval (which should be a Zstar grid). This routine builds a grid on the runtime specified vertical coordinate.

Parameters

	cs	Regridding parameters and options
[in]	g	Ocean grid informations
[in]	gv	Ocean vertical grid structure
[in,out]	h	Layer thicknesses
[in,out]	tv	Thermodynamic variable structure
	reg	Tracer registry structure
[in,out]	uhtr	Zonal mass fluxes
[in,out]	vhtr	Meridional mass fluxes
[in,out]	kd	Input diffusivites
[in]	debug	If true, then turn checksums
	obc	Open boundary structure

Definition at line 462 of file MOM_ALE.F90.

  type(ALE_CS),                                 pointer       :: CS    !< Regridding parameters and options
  type(ocean_grid_type),                        intent(in   ) :: G     !< Ocean grid informations
  type(verticalGrid_type),                      intent(in   ) :: GV    !< Ocean vertical grid structure
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)),    intent(inout) :: h     !< Layer thicknesses
  type(thermo_var_ptrs),                        intent(inout) :: tv    !< Thermodynamic variable structure
  type(tracer_registry_type),                   pointer       :: Reg   !< Tracer registry structure
  real, dimension(SZIB_(G),SZJ_(G),SZK_(GV)),   intent(inout) :: uhtr  !< Zonal mass fluxes
  real, dimension(SZI_(G),SZJB_(G),SZK_(GV)),   intent(inout) :: vhtr  !< Meridional mass fluxes
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)+1),  intent(inout) :: Kd    !< Input diffusivites
  logical,                                      intent(in   ) :: debug !< If true, then turn checksums
  type(ocean_OBC_type),                         pointer       :: OBC   !< Open boundary structure
  ! Local variables
  integer :: nk, i, j, k, isc, iec, jsc, jec
  real, dimension(SZI_(G), SZJ_(G), SZK_(GV))   :: h_new    ! Layer thicknesses after regridding
  real, dimension(SZI_(G), SZJ_(G), SZK_(GV)+1) :: dzRegrid ! The change in grid interface positions
  real, dimension(SZK_(GV)) :: h_src
  real, dimension(SZK_(GV)) :: h_dest, uh_dest
  real, dimension(SZK_(GV)) :: temp_vec
 
  nk = gv%ke; isc = g%isc; iec = g%iec; jsc = g%jsc; jec = g%jec
  dzregrid(:,:,:) = 0.0
  h_new(:,:,:) = 0.0
 
  if (debug) call mom_tracer_chkinv("Before ALE_offline_inputs", g, h, reg%Tr, reg%ntr)
 
  ! Build new grid from the Zstar state onto the requested vertical coordinate. The new grid is stored
  ! in h_new. The old grid is h. Both are needed for the subsequent remapping of variables. Convective
  ! adjustment right now is not used because it is unclear what to do with vanished layers
  call regridding_main( cs%remapCS, cs%regridCS, g, gv, h, tv, h_new, dzregrid, conv_adjust = .false. )
  call check_grid( g, gv, h_new, 0. )
  if (cs%show_call_tree) call calltree_waypoint("new grid generated (ALE_offline_inputs)")
 
  ! Remap all variables from old grid h onto new grid h_new
  call remap_all_state_vars( cs%remapCS, cs, g, gv, h, h_new, reg, obc, debug=cs%show_call_tree )
  if (cs%show_call_tree) call calltree_waypoint("state remapped (ALE_inputs)")
 
  ! Reintegrate mass transports from Zstar to the offline vertical coordinate
  do j=jsc,jec ; do i=g%iscB,g%iecB
    if (g%mask2dCu(i,j)>0.) then
      h_src(:) = 0.5 * (h(i,j,:) + h(i+1,j,:))
      h_dest(:) = 0.5 * (h_new(i,j,:) + h_new(i+1,j,:))
      call reintegrate_column(nk, h_src, uhtr(i,j,:), nk, h_dest, 0., temp_vec)
      uhtr(i,j,:) = temp_vec
    endif
  enddo ; enddo
  do j=g%jscB,g%jecB ; do i=isc,iec
    if (g%mask2dCv(i,j)>0.) then
      h_src(:) = 0.5 * (h(i,j,:) + h(i,j+1,:))
      h_dest(:) = 0.5 * (h_new(i,j,:) + h_new(i,j+1,:))
      call reintegrate_column(nk, h_src, vhtr(i,j,:), nk, h_dest, 0., temp_vec)
      vhtr(i,j,:) = temp_vec
    endif
  enddo ; enddo
 
  do j = jsc,jec ; do i=isc,iec
    if (g%mask2dT(i,j)>0.) then
      if (check_column_integrals(nk, h_src, nk, h_dest)) then
        call mom_error(fatal, "ALE_offline_inputs: Kd interpolation columns do not match")
      endif
      call interpolate_column(nk, h(i,j,:), kd(i,j,:), nk, h_new(i,j,:), 0., kd(i,j,:))
    endif
  enddo ; enddo
 
  call ale_remap_scalar(cs%remapCS, g, gv, nk, h, tv%T, h_new, tv%T, answers_2018=cs%answers_2018)
  call ale_remap_scalar(cs%remapCS, g, gv, nk, h, tv%S, h_new, tv%S, answers_2018=cs%answers_2018)
 
  if (debug) call mom_tracer_chkinv("After ALE_offline_inputs", g, h_new, reg%Tr, reg%ntr)
 
  ! Copy over the new layer thicknesses
  do k = 1,nk  ; do j = jsc-1,jec+1 ; do i = isc-1,iec+1
      h(i,j,k) = h_new(i,j,k)
  enddo ; enddo ; enddo
 
  if (cs%show_call_tree) call calltree_leave("ALE_offline_inputs()")

ale_offline_tracer_final()

subroutine, public mom_ale::ale_offline_tracer_final	(	type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, gv %ke), intent(inout)	h,
		type(thermo_var_ptrs), intent(inout)	tv,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, gv %ke), intent(inout)	h_target,
		type(tracer_registry_type), pointer	Reg,
		type(ale_cs), pointer	CS,
		type(ocean_obc_type), pointer	OBC
	)

Remaps all tracers from h onto h_target. This is intended to be called when tracers are done offline. In the case where transports don't quite conserve, we still want to make sure that layer thicknesses offline do not drift too far away from the online model.

Parameters

[in]	g	Ocean grid informations
[in]	gv	Ocean vertical grid structure
[in,out]	h	Current 3D grid obtained after the last time step [H ~> m or kg-2]
[in,out]	tv	Thermodynamic variable structure
[in,out]	h_target	Current 3D grid obtained after last time step [H ~> m or kg-2]
	reg	Tracer registry structure
	cs	Regridding parameters and options
	obc	Open boundary structure

Definition at line 543 of file MOM_ALE.F90.

  type(ocean_grid_type),                      intent(in)    :: G   !< Ocean grid informations
  type(verticalGrid_type),                    intent(in)    :: GV  !< Ocean vertical grid structure
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)),  intent(inout) :: h   !< Current 3D grid obtained after the
                                                                   !! last time step [H ~> m or kg-2]
  type(thermo_var_ptrs),                      intent(inout) :: tv  !< Thermodynamic variable structure
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)),  intent(inout) :: h_target !< Current 3D grid obtained after
                                                                        !! last time step  [H ~> m or kg-2]
  type(tracer_registry_type),                 pointer       :: Reg !< Tracer registry structure
  type(ALE_CS),                               pointer       :: CS  !< Regridding parameters and options
  type(ocean_OBC_type),                       pointer       :: OBC !< Open boundary structure
  ! Local variables
 
  real, dimension(SZI_(G), SZJ_(G), SZK_(GV)+1) :: dzRegrid !< The change in grid interface positions
  real, dimension(SZI_(G), SZJ_(G), SZK_(GV))   :: h_new    !< Regridded target thicknesses
  integer :: nk, i, j, k, isc, iec, jsc, jec
 
  nk = gv%ke; isc = g%isc; iec = g%iec; jsc = g%jsc; jec = g%jec
 
  if (cs%show_call_tree) call calltree_enter("ALE_offline_tracer_final(), MOM_ALE.F90")
  ! Need to make sure that h_target is consistent with the current offline ALE confiuration
  call regridding_main( cs%remapCS, cs%regridCS, g, gv, h_target, tv, h_new, dzregrid )
  call check_grid( g, gv, h_target, 0. )
 
 
  if (cs%show_call_tree) call calltree_waypoint("Source and target grids checked (ALE_offline_tracer_final)")
 
  ! Remap all variables from old grid h onto new grid h_new
 
  call remap_all_state_vars( cs%remapCS, cs, g, gv, h, h_new, reg, obc, debug=cs%show_call_tree )
 
  if (cs%show_call_tree) call calltree_waypoint("state remapped (ALE_offline_tracer_final)")
 
  ! Override old grid with new one. The new grid 'h_new' is built in
  ! one of the 'build_...' routines above.
  !$OMP parallel do default(shared)
  do k = 1,nk
    do j = jsc-1,jec+1 ; do i = isc-1,iec+1
      h(i,j,k) = h_new(i,j,k)
    enddo ; enddo
  enddo
  if (cs%show_call_tree) call calltree_leave("ALE_offline_tracer_final()")

ale_plm_edge_values()

subroutine, public mom_ale::ale_plm_edge_values	(	type(ale_cs), intent(in)	CS,
		type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		real, dimension(szi_(g),szj_(g),szk_(gv)), intent(in)	h,
		real, dimension(szi_(g),szj_(g),szk_(gv)), intent(in)	Q,
		logical, intent(in)	bdry_extrap,
		real, dimension(szi_(g),szj_(g),szk_(gv)), intent(inout)	Q_t,
		real, dimension(szi_(g),szj_(g),szk_(gv)), intent(inout)	Q_b
	)

Calculate edge values (top and bottom of layer) 3d scalar array. Boundary reconstructions are PCM unless bdry_extrap is true.

Parameters

[in]	cs	module control structure
[in]	g	ocean grid structure
[in]	gv	Ocean vertical grid structure
[in]	h	layer thickness [H ~> m or kg m-2]
[in]	q	3d scalar array
[in]	bdry_extrap	If true, use high-order boundary extrapolation within boundary cells
[in,out]	q_t	Scalar at the top edge of each layer
[in,out]	q_b	Scalar at the bottom edge of each layer

Definition at line 1038 of file MOM_ALE.F90.

  type(ALE_CS),            intent(in)    :: CS   !< module control structure
  type(ocean_grid_type),   intent(in)    :: G    !< ocean grid structure
  type(verticalGrid_type), intent(in)    :: GV   !< Ocean vertical grid structure
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), &
                           intent(in)    :: h    !< layer thickness [H ~> m or kg m-2]
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), &
                           intent(in)    :: Q    !< 3d scalar array
  logical,                 intent(in)    :: bdry_extrap !< If true, use high-order boundary
                                                 !! extrapolation within boundary cells
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), &
                           intent(inout) :: Q_t  !< Scalar at the top edge of each layer
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), &
                           intent(inout) :: Q_b  !< Scalar at the bottom edge of each layer
  ! Local variables
  integer :: i, j, k
  real :: slp(GV%ke)
  real :: mslp
  real :: h_neglect
 
  if (.not.cs%answers_2018) then
    h_neglect = gv%H_subroundoff
  elseif (gv%Boussinesq) then
    h_neglect = gv%m_to_H*1.0e-30
  else
    h_neglect = gv%kg_m2_to_H*1.0e-30
  endif
 
  !$OMP parallel do default(shared) private(slp,mslp)
  do j = g%jsc-1,g%jec+1 ; do i = g%isc-1,g%iec+1
    slp(1) = 0.
    do k = 2, gv%ke-1
      slp(k) = plm_slope_wa(h(i,j,k-1), h(i,j,k), h(i,j,k+1), h_neglect, q(i,j,k-1), q(i,j,k), q(i,j,k+1))
    enddo
    slp(gv%ke) = 0.
 
    do k = 2, gv%ke-1
      mslp = plm_monotonized_slope(q(i,j,k-1), q(i,j,k), q(i,j,k+1), slp(k-1), slp(k), slp(k+1))
      q_t(i,j,k) = q(i,j,k) - 0.5 * mslp
      q_b(i,j,k) = q(i,j,k) + 0.5 * mslp
    enddo
    if (bdry_extrap) then
      mslp = - plm_extrapolate_slope(h(i,j,2), h(i,j,1), h_neglect, q(i,j,2), q(i,j,1))
      q_t(i,j,1) = q(i,j,1) - 0.5 * mslp
      q_b(i,j,1) = q(i,j,1) + 0.5 * mslp
      mslp = plm_extrapolate_slope(h(i,j,gv%ke-1), h(i,j,gv%ke), h_neglect, q(i,j,gv%ke-1), q(i,j,gv%ke))
      q_t(i,j,gv%ke) = q(i,j,gv%ke) - 0.5 * mslp
      q_b(i,j,gv%ke) = q(i,j,gv%ke) + 0.5 * mslp
    else
      q_t(i,j,1) = q(i,j,1)
      q_b(i,j,1) = q(i,j,1)
      q_t(i,j,gv%ke) = q(i,j,gv%ke)
      q_b(i,j,gv%ke) = q(i,j,gv%ke)
    endif
 
  enddo ; enddo
 

ale_register_diags()

subroutine, public mom_ale::ale_register_diags	(	type(time_type), intent(in), target	Time,
		type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		type(unit_scale_type), intent(in)	US,
		type(diag_ctrl), intent(in), target	diag,
		type(ale_cs), pointer	CS
	)

Initialize diagnostics for the ALE module.

Parameters

[in]	time	Time structure
[in]	g	Grid structure
[in]	us	A dimensional unit scaling type
[in]	gv	Ocean vertical grid structure
[in]	diag	Diagnostics control structure
	cs	Module control structure

Definition at line 249 of file MOM_ALE.F90.

  type(time_type),target,     intent(in)  :: Time  !< Time structure
  type(ocean_grid_type),      intent(in)  :: G     !< Grid structure
  type(unit_scale_type),      intent(in)  :: US    !< A dimensional unit scaling type
  type(verticalGrid_type),    intent(in)  :: GV    !< Ocean vertical grid structure
  type(diag_ctrl), target,    intent(in)  :: diag  !< Diagnostics control structure
  type(ALE_CS), pointer                   :: CS    !< Module control structure
 
  cs%diag => diag
 
  ! These diagnostics of the state variables before ALE are useful for
  ! debugging the ALE code.
  cs%id_u_preale = register_diag_field('ocean_model', 'u_preale', diag%axesCuL, time, &
      'Zonal velocity before remapping', 'm s-1', conversion=us%L_T_to_m_s)
  cs%id_v_preale = register_diag_field('ocean_model', 'v_preale', diag%axesCvL, time, &
      'Meridional velocity before remapping', 'm s-1', conversion=us%L_T_to_m_s)
  cs%id_h_preale = register_diag_field('ocean_model', 'h_preale', diag%axesTL, time, &
      'Layer Thickness before remapping', get_thickness_units(gv), &
      conversion=gv%H_to_MKS, v_extensive=.true.)
  cs%id_T_preale = register_diag_field('ocean_model', 'T_preale', diag%axesTL, time, &
      'Temperature before remapping', 'degC')
  cs%id_S_preale = register_diag_field('ocean_model', 'S_preale', diag%axesTL, time, &
      'Salinity before remapping', 'PSU')
  cs%id_e_preale = register_diag_field('ocean_model', 'e_preale', diag%axesTi, time, &
      'Interface Heights before remapping', 'm', conversion=us%Z_to_m)
 
  cs%id_dzRegrid = register_diag_field('ocean_model','dzRegrid',diag%axesTi,time, &
      'Change in interface height due to ALE regridding', 'm', &
      conversion=gv%H_to_m)
  cs%id_vert_remap_h = register_diag_field('ocean_model', 'vert_remap_h', &
      diag%axestl, time, 'layer thicknesses after ALE regridding and remapping', 'm', &
      conversion=gv%H_to_m, v_extensive=.true.)
  cs%id_vert_remap_h_tendency = register_diag_field('ocean_model','vert_remap_h_tendency',diag%axestl,time, &
      'Layer thicknesses tendency due to ALE regridding and remapping', 'm', &
      conversion=gv%H_to_m*us%s_to_T, v_extensive = .true.)
 

ale_regrid_accelerated()

subroutine, public mom_ale::ale_regrid_accelerated	(	type(ale_cs), pointer	CS,
		type(ocean_grid_type), intent(inout)	G,
		type(verticalgrid_type), intent(in)	GV,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, gv %ke), intent(inout)	h,
		type(thermo_var_ptrs), intent(inout)	tv,
		integer, intent(in)	n,
		real, dimension( g %isdb: g %iedb, g %jsd: g %jed, gv %ke), intent(inout)	u,
		real, dimension( g %isd: g %ied, g %jsdb: g %jedb, gv %ke), intent(inout)	v,
		type(ocean_obc_type), pointer	OBC,
		type(tracer_registry_type), optional, pointer	Reg,
		real, intent(in), optional	dt,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, gv %ke+1), intent(inout), optional	dzRegrid,
		logical, intent(in), optional	initial
	)

For a state-based coordinate, accelerate the process of regridding by repeatedly applying the grid calculation algorithm.

Parameters

	cs	ALE control structure
[in,out]	g	Ocean grid
[in]	gv	Vertical grid
[in,out]	h	Original thicknesses [H ~> m or kg-2]
[in,out]	tv	Thermo vars (T/S/EOS)
[in]	n	Number of times to regrid
[in,out]	u	Zonal velocity [L T-1 ~> m s-1]
[in,out]	v	Meridional velocity [L T-1 ~> m s-1]
	obc	Open boundary structure
	reg	Tracer registry to remap onto new grid
[in]	dt	Model timestep to provide a timescale for regridding [T ~> s]
[in,out]	dzregrid	Final change in interface positions
[in]	initial	Whether we're being called from an initialization routine (and expect diagnostics to work)

Definition at line 659 of file MOM_ALE.F90.

  type(ALE_CS),            pointer       :: CS     !< ALE control structure
  type(ocean_grid_type),   intent(inout) :: G      !< Ocean grid
  type(verticalGrid_type), intent(in)    :: GV     !< Vertical grid
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), &
                           intent(inout) :: h      !< Original thicknesses [H ~> m or kg-2]
  type(thermo_var_ptrs),   intent(inout) :: tv     !< Thermo vars (T/S/EOS)
  integer,                 intent(in)    :: n      !< Number of times to regrid
  real, dimension(SZIB_(G),SZJ_(G),SZK_(GV)), &
                           intent(inout) :: u      !< Zonal velocity [L T-1 ~> m s-1]
  real, dimension(SZI_(G),SZJB_(G),SZK_(GV)), &
                           intent(inout) :: v      !< Meridional velocity [L T-1 ~> m s-1]
  type(ocean_OBC_type),    pointer       :: OBC    !< Open boundary structure
  type(tracer_registry_type), &
                 optional, pointer       :: Reg    !< Tracer registry to remap onto new grid
  real,          optional, intent(in)    :: dt     !< Model timestep to provide a timescale for regridding [T ~> s]
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)+1), &
                 optional, intent(inout) :: dzRegrid !< Final change in interface positions
  logical,       optional, intent(in)    :: initial !< Whether we're being called from an initialization
                                                    !! routine (and expect diagnostics to work)
 
  ! Local variables
  integer :: i, j, k, nz
  type(thermo_var_ptrs) :: tv_local ! local/intermediate temp/salt
  type(group_pass_type) :: pass_T_S_h ! group pass if the coordinate has a stencil
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV))         :: h_loc, h_orig ! A working copy of layer thicknesses
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), target :: T, S ! local temporary state
  ! we have to keep track of the total dzInterface if for some reason
  ! we're using the old remapping algorithm for u/v
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)+1) :: dzInterface, dzIntTotal
 
  nz = gv%ke
 
  ! initial total interface displacement due to successive regridding
  dzinttotal(:,:,:) = 0.
 
  call create_group_pass(pass_t_s_h, t, g%domain)
  call create_group_pass(pass_t_s_h, s, g%domain)
  call create_group_pass(pass_t_s_h, h_loc, g%domain)
 
  ! copy original temp/salt and set our local tv_pointers to them
  tv_local = tv
  t(:,:,:) = tv%T(:,:,:)
  s(:,:,:) = tv%S(:,:,:)
  tv_local%T => t
  tv_local%S => s
 
  ! get local copy of thickness and save original state for remapping
  h_loc(:,:,:) = h(:,:,:)
  h_orig(:,:,:) = h(:,:,:)
 
  ! Apply timescale to regridding (for e.g. filtered_grid_motion)
  if (present(dt)) &
    call ale_update_regrid_weights(dt, cs)
 
  do k = 1, n
    call do_group_pass(pass_t_s_h, g%domain)
 
    ! generate new grid
    call regridding_main(cs%remapCS, cs%regridCS, g, gv, h_loc, tv_local, h, dzinterface)
    dzinttotal(:,:,:) = dzinttotal(:,:,:) + dzinterface(:,:,:)
 
    ! remap from original grid onto new grid
    do j = g%jsc-1,g%jec+1 ; do i = g%isc-1,g%iec+1
      call remapping_core_h(cs%remapCS, nz, h_orig(i,j,:), tv%S(i,j,:), nz, h(i,j,:), tv_local%S(i,j,:))
      call remapping_core_h(cs%remapCS, nz, h_orig(i,j,:), tv%T(i,j,:), nz, h(i,j,:), tv_local%T(i,j,:))
    enddo ; enddo
 
    ! starting grid for next iteration
    h_loc(:,:,:) = h(:,:,:)
  enddo
 
  ! remap all state variables (including those that weren't needed for regridding)
  call remap_all_state_vars(cs%remapCS, cs, g, gv, h_orig, h, reg, obc, dzinttotal, u, v)
 
  ! save total dzregrid for diags if needed?
  if (present(dzregrid)) dzregrid(:,:,:) = dzinttotal(:,:,:)

ale_remap_init_conds()

logical function, public mom_ale::ale_remap_init_conds

(

type(ale_cs), pointer

CS

)

Returns true if initial conditions should be regridded and remapped.

Parameters

cs	module control structure

Definition at line 1227 of file MOM_ALE.F90.

  type(ALE_CS), pointer :: CS   !< module control structure
 
  ale_remap_init_conds = .false.
  if (associated(cs)) ale_remap_init_conds = cs%remap_after_initialization

ale_remap_scalar()

subroutine, public mom_ale::ale_remap_scalar	(	type(remapping_cs), intent(in)	CS,
		type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		integer, intent(in)	nk_src,
		real, dimension(szi_(g),szj_(g),nk_src), intent(in)	h_src,
		real, dimension(szi_(g),szj_(g),nk_src), intent(in)	s_src,
		real, dimension(szi_(g),szj_(g),szk_(gv)), intent(in)	h_dst,
		real, dimension(szi_(g),szj_(g),szk_(gv)), intent(inout)	s_dst,
		logical, intent(in), optional	all_cells,
		logical, intent(in), optional	old_remap,
		logical, intent(in), optional	answers_2018
	)

Remaps a single scalar between grids described by thicknesses h_src and h_dst. h_dst must be dimensioned as a model array with GVke layers while h_src can have an arbitrary number of layers specified by nk_src.

Parameters

[in]	cs	Remapping control structure
[in]	g	Ocean grid structure
[in]	gv	Ocean vertical grid structure
[in]	nk_src	Number of levels on source grid
[in]	h_src	Level thickness of source grid [H ~> m or kg-2]
[in]	s_src	Scalar on source grid
[in]	h_dst	Level thickness of destination grid [H ~> m or kg-2]
[in,out]	s_dst	Scalar on destination grid
[in]	all_cells	If false, only reconstruct for non-vanished cells. Use all vanished layers otherwise (default).
[in]	old_remap	If true, use the old "remapping_core_w" method, otherwise use "remapping_core_h".
[in]	answers_2018	If true, use the order of arithmetic and expressions that recover the answers for remapping from the end of 2018. Otherwise, use more robust forms of the same expressions.

Definition at line 944 of file MOM_ALE.F90.

  type(remapping_CS),                      intent(in)    :: CS        !< Remapping control structure
  type(ocean_grid_type),                   intent(in)    :: G         !< Ocean grid structure
  type(verticalGrid_type),                 intent(in)    :: GV        !< Ocean vertical grid structure
  integer,                                 intent(in)    :: nk_src    !< Number of levels on source grid
  real, dimension(SZI_(G),SZJ_(G),nk_src), intent(in)    :: h_src     !< Level thickness of source grid
                                                                      !! [H ~> m or kg-2]
  real, dimension(SZI_(G),SZJ_(G),nk_src), intent(in)    :: s_src     !< Scalar on source grid
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)),intent(in)   :: h_dst     !< Level thickness of destination grid
                                                                      !! [H ~> m or kg-2]
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)),intent(inout) :: s_dst    !< Scalar on destination grid
  logical, optional,                       intent(in)    :: all_cells !< If false, only reconstruct for
                                                                      !! non-vanished cells. Use all vanished
                                                                      !! layers otherwise (default).
  logical, optional,                       intent(in)    :: old_remap !< If true, use the old "remapping_core_w"
                                                                      !! method, otherwise use "remapping_core_h".
  logical,                       optional, intent(in)    :: answers_2018 !< If true, use the order of arithmetic
                                                                      !! and expressions that recover the answers for
                                                                      !! remapping from the end of 2018. Otherwise,
                                                                      !! use more robust forms of the same expressions.
  ! Local variables
  integer :: i, j, k, n_points
  real :: dx(GV%ke+1)
  real :: h_neglect, h_neglect_edge
  logical :: ignore_vanished_layers, use_remapping_core_w, use_2018_remap
 
  ignore_vanished_layers = .false.
  if (present(all_cells)) ignore_vanished_layers = .not. all_cells
  use_remapping_core_w = .false.
  if (present(old_remap)) use_remapping_core_w = old_remap
  n_points = nk_src
  use_2018_remap = .true. ; if (present(answers_2018)) use_2018_remap = answers_2018
 
  if (.not.use_2018_remap) then
    h_neglect = gv%H_subroundoff ; h_neglect_edge = gv%H_subroundoff
  elseif (gv%Boussinesq) then
    h_neglect = gv%m_to_H*1.0e-30 ; h_neglect_edge = gv%m_to_H*1.0e-10
  else
    h_neglect = gv%kg_m2_to_H*1.0e-30 ; h_neglect_edge = gv%kg_m2_to_H*1.0e-10
  endif
 
  !$OMP parallel do default(shared) firstprivate(n_points,dx)
  do j = g%jsc,g%jec ; do i = g%isc,g%iec
    if (g%mask2dT(i,j) > 0.) then
      if (ignore_vanished_layers) then
        n_points = 0
        do k = 1, nk_src
          if (h_src(i,j,k)>0.) n_points = n_points + 1
        enddo
        s_dst(i,j,:) = 0.
      endif
      if (use_remapping_core_w) then
        call dzfromh1h2( n_points, h_src(i,j,1:n_points), gv%ke, h_dst(i,j,:), dx )
        call remapping_core_w(cs, n_points, h_src(i,j,1:n_points), s_src(i,j,1:n_points), &
                              gv%ke, dx, s_dst(i,j,:), h_neglect, h_neglect_edge)
      else
        call remapping_core_h(cs, n_points, h_src(i,j,1:n_points), s_src(i,j,1:n_points), &
                              gv%ke, h_dst(i,j,:), s_dst(i,j,:), h_neglect, h_neglect_edge)
      endif
    else
      s_dst(i,j,:) = 0.
    endif
  enddo ; enddo
 

ale_update_regrid_weights()

subroutine, public mom_ale::ale_update_regrid_weights	(	real, intent(in)	dt,
		type(ale_cs), pointer	CS
	)

Updates the weights for time filtering the new grid generated in regridding.

Parameters

[in]	dt	Time-step used between ALE calls [T ~> s]
	cs	ALE control structure

Definition at line 1235 of file MOM_ALE.F90.

  real,         intent(in) :: dt !< Time-step used between ALE calls [T ~> s]
  type(ALE_CS), pointer    :: CS !< ALE control structure
  ! Local variables
  real :: w  ! An implicit weighting estimate.
 
  if (associated(cs)) then
    w = 0.0
    if (cs%regrid_time_scale > 0.0) then
      w = cs%regrid_time_scale / (cs%regrid_time_scale + dt)
    endif
    call set_regrid_params(cs%regridCS, old_grid_weight=w)
  endif
 

ale_updateverticalgridtype()

subroutine, public mom_ale::ale_updateverticalgridtype	(	type(ale_cs), pointer	CS,
		type(verticalgrid_type), pointer	GV
	)

Update the vertical grid type with ALE information. This subroutine sets information in the verticalGrid_type to be consistent with the use of ALE mode.

Parameters

cs	ALE control structure
gv	vertical grid information

Definition at line 1254 of file MOM_ALE.F90.

  type(ALE_CS),            pointer :: CS  !< ALE control structure
  type(verticalGrid_type), pointer :: GV  !< vertical grid information
 
  integer :: nk
 
  nk = gv%ke
  gv%sInterface(1:nk+1) = getcoordinateinterfaces( cs%regridCS, undo_scaling=.true. )
  gv%sLayer(1:nk) = 0.5*( gv%sInterface(1:nk) + gv%sInterface(2:nk+1) )
  gv%zAxisUnits = getcoordinateunits( cs%regridCS )
  gv%zAxisLongName = getcoordinateshortname( cs%regridCS )
  gv%direction = -1 ! Because of ferret in z* mode. Need method to set
                    ! as function of coordinae mode.
 

ale_writecoordinatefile()

subroutine, public mom_ale::ale_writecoordinatefile	(	type(ale_cs), pointer	CS,
		type(verticalgrid_type), intent(in)	GV,
		character(len=*), intent(in)	directory
	)

Write the vertical coordinate information into a file. This subroutine writes out a file containing any available data related to the vertical grid used by the MOM ocean model when in ALE mode.

Parameters

	cs	module control structure
[in]	gv	ocean vertical grid structure
[in]	directory	directory for writing grid info

Definition at line 1274 of file MOM_ALE.F90.

  type(ALE_CS),            pointer     :: CS         !< module control structure
  type(verticalGrid_type), intent(in)  :: GV         !< ocean vertical grid structure
  character(len=*),        intent(in)  :: directory  !< directory for writing grid info
 
  character(len=240) :: filepath
  type(vardesc)      :: vars(2)
  type(fieldtype)    :: fields(2)
  integer            :: unit
  real               :: ds(GV%ke), dsi(GV%ke+1)
 
  filepath    = trim(directory) // trim("Vertical_coordinate")
  ds(:)       = getcoordinateresolution( cs%regridCS, undo_scaling=.true. )
  dsi(1)      = 0.5*ds(1)
  dsi(2:gv%ke) = 0.5*( ds(1:gv%ke-1) + ds(2:gv%ke) )
  dsi(gv%ke+1) = 0.5*ds(gv%ke)
 
  vars(1) = var_desc('ds', getcoordinateunits( cs%regridCS ), &
                    'Layer Coordinate Thickness','1','L','1')
  vars(2) = var_desc('ds_interface', getcoordinateunits( cs%regridCS ), &
                    'Layer Center Coordinate Separation','1','i','1')
 
  call create_file(unit, trim(filepath), vars, 2, fields, single_file, gv=gv)
  call write_field(unit, fields(1), ds)
  call write_field(unit, fields(2), dsi)
  call close_file(unit)
 

check_grid()

subroutine mom_ale::check_grid ( type(ocean_grid_type), intent(in)  G, type(verticalgrid_type), intent(in)  GV, real, dimension( g %isd: g %ied, g %jsd: g %jed, gv %ke), intent(in)  h, real, intent(in)  threshold  )

private

Check grid for negative thicknesses.

Parameters

[in]	g	Ocean grid structure
[in]	gv	Ocean vertical grid structure
[in]	h	Current 3D grid obtained after the last time step [H ~> m or kg m-2]
[in]	threshold	Value below which to flag issues, [H ~> m or kg m-2]

Definition at line 588 of file MOM_ALE.F90.

  type(ocean_grid_type),                     intent(in) :: G  !< Ocean grid structure
  type(verticalGrid_type),                   intent(in) :: GV !< Ocean vertical grid structure
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), intent(in) :: h  !< Current 3D grid obtained after the
                                                              !! last time step [H ~> m or kg m-2]
  real,                                      intent(in) :: threshold !< Value below which to flag issues,
                                                              !! [H ~> m or kg m-2]
  ! Local variables
  integer :: i, j
 
  do j = g%jsc,g%jec ; do i = g%isc,g%iec
    if (g%mask2dT(i,j)>0.) then
      if (minval(h(i,j,:)) < threshold) then
        write(0,*) 'check_grid: i,j=',i,j,'h(i,j,:)=',h(i,j,:)
        if (threshold <= 0.) then
          call mom_error(fatal,"MOM_ALE, check_grid: negative thickness encountered.")
        else
          call mom_error(fatal,"MOM_ALE, check_grid: too tiny thickness encountered.")
        endif
      endif
    endif
  enddo ; enddo
 
 

remap_all_state_vars()

subroutine mom_ale::remap_all_state_vars ( type(remapping_cs), intent(in)  CS_remapping, type(ale_cs), intent(in)  CS_ALE, type(ocean_grid_type), intent(in)  G, type(verticalgrid_type), intent(in)  GV, real, dimension(szi_(g),szj_(g),szk_(gv)), intent(in)  h_old, real, dimension(szi_(g),szj_(g),szk_(gv)), intent(in)  h_new, type(tracer_registry_type), pointer  Reg, type(ocean_obc_type), pointer  OBC, real, dimension(szi_(g),szj_(g),szk_(gv)+1), intent(in), optional  dxInterface, real, dimension(szib_(g),szj_(g),szk_(gv)), intent(inout), optional  u, real, dimension(szi_(g),szjb_(g),szk_(gv)), intent(inout), optional  v, logical, intent(in), optional  debug, real, intent(in), optional  dt  )

private

This routine takes care of remapping all variable between the old and the new grids. When velocity components need to be remapped, thicknesses at velocity points are taken to be arithmetic averages of tracer thicknesses. This routine is called during initialization of the model at time=0, to remap initiali conditions to the model grid. It is also called during a time step to update the state.

Parameters

[in]	cs_remapping	Remapping control structure
[in]	cs_ale	ALE control structure
[in]	g	Ocean grid structure
[in]	gv	Ocean vertical grid structure
[in]	h_old	Thickness of source grid [H ~> m or kg-2]
[in]	h_new	Thickness of destination grid [H ~> m or kg-2]
	reg	Tracer registry structure
	obc	Open boundary structure
[in]	dxinterface	Change in interface position
[in,out]	u	Zonal velocity [L T-1 ~> m s-1]
[in,out]	v	Meridional velocity [L T-1 ~> m s-1]
[in]	debug	If true, show the call tree
[in]	dt	time step for diagnostics [T ~> s]

Definition at line 744 of file MOM_ALE.F90.

  type(remapping_CS),                        intent(in)    :: CS_remapping !< Remapping control structure
  type(ALE_CS),                              intent(in)    :: CS_ALE       !< ALE control structure
  type(ocean_grid_type),                     intent(in)    :: G            !< Ocean grid structure
  type(verticalGrid_type),                   intent(in)    :: GV           !< Ocean vertical grid structure
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), intent(in)    :: h_old        !< Thickness of source grid
                                                                           !! [H ~> m or kg-2]
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), intent(in)    :: h_new        !< Thickness of destination grid
                                                                           !! [H ~> m or kg-2]
  type(tracer_registry_type),                pointer       :: Reg          !< Tracer registry structure
  type(ocean_OBC_type),                      pointer       :: OBC          !< Open boundary structure
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)+1), &
                                   optional, intent(in)    :: dxInterface  !< Change in interface position
                                                                           !! [H ~> m or kg-2]
  real, dimension(SZIB_(G),SZJ_(G),SZK_(GV)), &
                                   optional, intent(inout) :: u      !< Zonal velocity [L T-1 ~> m s-1]
  real, dimension(SZI_(G),SZJB_(G),SZK_(GV)), &
                                   optional, intent(inout) :: v      !< Meridional velocity [L T-1 ~> m s-1]
  logical,                         optional, intent(in)    :: debug  !< If true, show the call tree
  real,                            optional, intent(in)    :: dt     !< time step for diagnostics [T ~> s]
  ! Local variables
  integer                                     :: i, j, k, m
  integer                                     :: nz, ntr
  real, dimension(GV%ke+1)                    :: dx
  real, dimension(GV%ke)                      :: h1, u_column
  real, dimension(SZI_(G), SZJ_(G), SZK_(GV)) :: work_conc
  real, dimension(SZI_(G), SZJ_(G), SZK_(GV)) :: work_cont
  real, dimension(SZI_(G), SZJ_(G))           :: work_2d
  real                                        :: Idt ! The inverse of the timestep [T-1 ~> s-1]
  real                                        :: ppt2mks
  real, dimension(GV%ke)                      :: h2
  real :: h_neglect, h_neglect_edge
  logical                                     :: show_call_tree
  type(tracer_type), pointer                  :: Tr => null()
 
  show_call_tree = .false.
  if (present(debug)) show_call_tree = debug
  if (show_call_tree) call calltree_enter("remap_all_state_vars(), MOM_ALE.F90")
 
  ! If remap_uv_using_old_alg is .true. and u or v is requested, then we must have dxInterface. Otherwise,
  ! u and v can be remapped without dxInterface
  if ( .not. present(dxinterface) .and. (cs_ale%remap_uv_using_old_alg .and. (present(u) .or. present(v))) ) then
    call mom_error(fatal, "remap_all_state_vars: dxInterface must be present if using old algorithm "// &
                          "and u/v are to be remapped")
  endif
 
  if (.not.cs_ale%answers_2018) then
    h_neglect = gv%H_subroundoff ; h_neglect_edge = gv%H_subroundoff
  elseif (gv%Boussinesq) then
    h_neglect = gv%m_to_H*1.0e-30 ; h_neglect_edge = gv%m_to_H*1.0e-10
  else
    h_neglect = gv%kg_m2_to_H*1.0e-30 ; h_neglect_edge = gv%kg_m2_to_H*1.0e-10
  endif
 
  nz      = gv%ke
  ppt2mks = 0.001
 
  ntr = 0 ; if (associated(reg)) ntr = reg%ntr
 
  if (present(dt)) then
    idt = 1.0/dt
    work_conc(:,:,:) = 0.0
    work_cont(:,:,:) = 0.0
  endif
 
  ! Remap tracer
  if (ntr>0) then
    if (show_call_tree) call calltree_waypoint("remapping tracers (remap_all_state_vars)")
    !$OMP parallel do default(shared) private(h1,h2,u_column,Tr)
    do m=1,ntr ! For each tracer
      tr => reg%Tr(m)
      do j = g%jsc,g%jec ; do i = g%isc,g%iec ; if (g%mask2dT(i,j)>0.) then
        ! Build the start and final grids
        h1(:) = h_old(i,j,:)
        h2(:) = h_new(i,j,:)
        call remapping_core_h(cs_remapping, nz, h1, tr%t(i,j,:), nz, h2, &
                              u_column, h_neglect, h_neglect_edge)
 
        ! Intermediate steps for tendency of tracer concentration and tracer content.
        if (present(dt)) then
          if (tr%id_remap_conc > 0) then
            do k=1,gv%ke
              work_conc(i,j,k) = (u_column(k) - tr%t(i,j,k)) * idt
            enddo
          endif
          if (tr%id_remap_cont > 0 .or. tr%id_remap_cont_2d > 0) then
            do k=1,gv%ke
              work_cont(i,j,k) = (u_column(k)*h2(k) - tr%t(i,j,k)*h1(k)) * idt
            enddo
          endif
        endif
        ! update tracer concentration
        tr%t(i,j,:) = u_column(:)
      endif ; enddo ; enddo
 
      ! tendency diagnostics.
      if (present(dt)) then
        if (tr%id_remap_conc > 0) then
          call post_data(tr%id_remap_conc, work_conc, cs_ale%diag)
        endif
        if (tr%id_remap_cont > 0) then
          call post_data(tr%id_remap_cont, work_cont, cs_ale%diag)
        endif
        if (tr%id_remap_cont_2d > 0) then
          do j = g%jsc,g%jec ; do i = g%isc,g%iec
            work_2d(i,j) = 0.0
            do k = 1,gv%ke
              work_2d(i,j) = work_2d(i,j) + work_cont(i,j,k)
            enddo
          enddo ; enddo
          call post_data(tr%id_remap_cont_2d, work_2d, cs_ale%diag)
        endif
      endif
    enddo ! m=1,ntr
 
  endif   ! endif for ntr > 0
 
  if (show_call_tree) call calltree_waypoint("tracers remapped (remap_all_state_vars)")
 
  ! Remap u velocity component
  if ( present(u) ) then
    !$OMP parallel do default(shared) private(h1,h2,dx,u_column)
    do j = g%jsc,g%jec ; do i = g%iscB,g%iecB ; if (g%mask2dCu(i,j)>0.) then
      ! Build the start and final grids
      h1(:) = 0.5 * ( h_old(i,j,:) + h_old(i+1,j,:) )
      if (cs_ale%remap_uv_using_old_alg) then
        dx(:) = 0.5 * ( dxinterface(i,j,:) + dxinterface(i+1,j,:) )
        do k = 1, nz
          h2(k) = max( 0., h1(k) + ( dx(k+1) - dx(k) ) )
        enddo
      else
        h2(:) = 0.5 * ( h_new(i,j,:) + h_new(i+1,j,:) )
      endif
      if (associated(obc)) then
        if (obc%segnum_u(i,j) .ne. 0) then
          if (obc%segment(obc%segnum_u(i,j))%direction == obc_direction_e) then
            h1(:) = h_old(i,j,:)
            h2(:) = h_new(i,j,:)
          else ! (OBC%segment(n)%direction == OBC_DIRECTION_W)
            h1(:) = h_old(i+1,j,:)
            h2(:) = h_new(i+1,j,:)
          endif
        endif
      endif
      call remapping_core_h(cs_remapping, nz, h1, u(i,j,:), nz, h2, &
                            u_column, h_neglect, h_neglect_edge)
      u(i,j,:) = u_column(:)
    endif ; enddo ; enddo
  endif
 
  if (show_call_tree) call calltree_waypoint("u remapped (remap_all_state_vars)")
 
  ! Remap v velocity component
  if ( present(v) ) then
    !$OMP parallel do default(shared) private(h1,h2,dx,u_column)
    do j = g%jscB,g%jecB ; do i = g%isc,g%iec ; if (g%mask2dCv(i,j)>0.) then
      ! Build the start and final grids
      h1(:) = 0.5 * ( h_old(i,j,:) + h_old(i,j+1,:) )
      if (cs_ale%remap_uv_using_old_alg) then
        dx(:) = 0.5 * ( dxinterface(i,j,:) + dxinterface(i,j+1,:) )
        do k = 1, nz
          h2(k) = max( 0., h1(k) + ( dx(k+1) - dx(k) ) )
        enddo
      else
        h2(:) = 0.5 * ( h_new(i,j,:) + h_new(i,j+1,:) )
      endif
      if (associated(obc)) then
        if (obc%segnum_v(i,j) .ne. 0) then
          if (obc%segment(obc%segnum_v(i,j))%direction == obc_direction_n) then
            h1(:) = h_old(i,j,:)
            h2(:) = h_new(i,j,:)
          else ! (OBC%segment(n)%direction == OBC_DIRECTION_S)
            h1(:) = h_old(i,j+1,:)
            h2(:) = h_new(i,j+1,:)
          endif
        endif
      endif
      call remapping_core_h(cs_remapping, nz, h1, v(i,j,:), nz, h2, &
                            u_column, h_neglect, h_neglect_edge)
      v(i,j,:) = u_column(:)
    endif ; enddo ; enddo
  endif
 
  if (cs_ale%id_vert_remap_h > 0) call post_data(cs_ale%id_vert_remap_h, h_old, cs_ale%diag)
  if ((cs_ale%id_vert_remap_h_tendency > 0) .and. present(dt)) then
    do k = 1, nz ; do j = g%jsc,g%jec ; do i = g%isc,g%iec
      work_cont(i,j,k) = (h_new(i,j,k) - h_old(i,j,k))*idt
    enddo ; enddo ; enddo
    call post_data(cs_ale%id_vert_remap_h_tendency, work_cont, cs_ale%diag)
  endif
  if (show_call_tree) call calltree_waypoint("v remapped (remap_all_state_vars)")
  if (show_call_tree) call calltree_leave("remap_all_state_vars()")
 

ts_plm_edge_values()

subroutine, public mom_ale::ts_plm_edge_values	(	type(ale_cs), intent(inout)	CS,
		real, dimension(szi_(g),szj_(g),szk_(gv)), intent(inout)	S_t,
		real, dimension(szi_(g),szj_(g),szk_(gv)), intent(inout)	S_b,
		real, dimension(szi_(g),szj_(g),szk_(gv)), intent(inout)	T_t,
		real, dimension(szi_(g),szj_(g),szk_(gv)), intent(inout)	T_b,
		type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		type(thermo_var_ptrs), intent(in)	tv,
		real, dimension(szi_(g),szj_(g),szk_(gv)), intent(in)	h,
		logical, intent(in)	bdry_extrap
	)

Calculate edge values (top and bottom of layer) for T and S consistent with a PLM reconstruction in the vertical direction. Boundary reconstructions are PCM unless bdry_extrap is true.

Parameters

[in]	g	ocean grid structure
[in]	gv	Ocean vertical grid structure
[in,out]	cs	module control structure
[in,out]	s_t	Salinity at the top edge of each layer
[in,out]	s_b	Salinity at the bottom edge of each layer
[in,out]	t_t	Temperature at the top edge of each layer
[in,out]	t_b	Temperature at the bottom edge of each layer
[in]	tv	thermodynamics structure
[in]	h	layer thickness [H ~> m or kg m-2]
[in]	bdry_extrap	If true, use high-order boundary extrapolation within boundary cells

Definition at line 1013 of file MOM_ALE.F90.

  type(ocean_grid_type),   intent(in)    :: G    !< ocean grid structure
  type(verticalGrid_type), intent(in)    :: GV   !< Ocean vertical grid structure
  type(ALE_CS),            intent(inout) :: CS   !< module control structure
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), &
                           intent(inout) :: S_t  !< Salinity at the top edge of each layer
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), &
                           intent(inout) :: S_b  !< Salinity at the bottom edge of each layer
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), &
                           intent(inout) :: T_t  !< Temperature at the top edge of each layer
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), &
                           intent(inout) :: T_b  !< Temperature at the bottom edge of each layer
  type(thermo_var_ptrs),   intent(in)    :: tv   !< thermodynamics structure
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), &
                           intent(in)    :: h    !< layer thickness [H ~> m or kg m-2]
  logical,                 intent(in)    :: bdry_extrap !< If true, use high-order boundary
                                                 !! extrapolation within boundary cells
 
  call ale_plm_edge_values( cs, g, gv, h, tv%S, bdry_extrap, s_t, s_b )
  call ale_plm_edge_values( cs, g, gv, h, tv%T, bdry_extrap, t_t, t_b )
 

ts_ppm_edge_values()

subroutine, public mom_ale::ts_ppm_edge_values	(	type(ale_cs), intent(inout)	CS,
		real, dimension(szi_(g),szj_(g),szk_(gv)), intent(inout)	S_t,
		real, dimension(szi_(g),szj_(g),szk_(gv)), intent(inout)	S_b,
		real, dimension(szi_(g),szj_(g),szk_(gv)), intent(inout)	T_t,
		real, dimension(szi_(g),szj_(g),szk_(gv)), intent(inout)	T_b,
		type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		type(thermo_var_ptrs), intent(in)	tv,
		real, dimension(szi_(g),szj_(g),szk_(gv)), intent(in)	h,
		logical, intent(in)	bdry_extrap
	)

Calculate edge values (top and bottom of layer) for T and S consistent with a PPM reconstruction in the vertical direction. Boundary reconstructions are PCM unless bdry_extrap is true.

Parameters

[in]	g	ocean grid structure
[in]	gv	Ocean vertical grid structure
[in,out]	cs	module control structure
[in,out]	s_t	Salinity at the top edge of each layer
[in,out]	s_b	Salinity at the bottom edge of each layer
[in,out]	t_t	Temperature at the top edge of each layer
[in,out]	t_b	Temperature at the bottom edge of each layer
[in]	tv	thermodynamics structure
[in]	h	layer thicknesses [H ~> m or kg m-2]
[in]	bdry_extrap	If true, use high-order boundary extrapolation within boundary cells

Definition at line 1099 of file MOM_ALE.F90.

  type(ocean_grid_type),   intent(in)    :: G    !< ocean grid structure
  type(verticalGrid_type), intent(in)    :: GV   !< Ocean vertical grid structure
  type(ALE_CS),            intent(inout) :: CS   !< module control structure
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), &
                           intent(inout) :: S_t  !< Salinity at the top edge of each layer
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), &
                           intent(inout) :: S_b  !< Salinity at the bottom edge of each layer
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), &
                           intent(inout) :: T_t  !< Temperature at the top edge of each layer
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), &
                           intent(inout) :: T_b  !< Temperature at the bottom edge of each layer
  type(thermo_var_ptrs),   intent(in)    :: tv   !< thermodynamics structure
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), &
                           intent(in)    :: h    !< layer thicknesses [H ~> m or kg m-2]
  logical,                 intent(in)    :: bdry_extrap !< If true, use high-order boundary
                                                 !! extrapolation within boundary cells
 
  ! Local variables
  integer :: i, j, k
  real    :: hTmp(GV%ke) ! A 1-d copy of h [H ~> m or kg m-2]
  real    :: tmp(GV%ke)  ! A 1-d copy of a column of temperature [degC] or salinity [ppt]
  real, dimension(CS%nk,2) :: &
      ppol_E            ! Edge value of polynomial in [degC] or [ppt]
  real, dimension(CS%nk,3) :: &
      ppol_coefs        ! Coefficients of polynomial, all in [degC] or [ppt]
  real :: h_neglect, h_neglect_edge ! Tiny thicknesses [H ~> m or kg m-2]
 
  if (.not.cs%answers_2018) then
    h_neglect = gv%H_subroundoff ; h_neglect_edge = gv%H_subroundoff
  elseif (gv%Boussinesq) then
    h_neglect = gv%m_to_H*1.0e-30 ; h_neglect_edge = gv%m_to_H*1.0e-10
  else
    h_neglect = gv%kg_m2_to_H*1.0e-30 ; h_neglect_edge = gv%kg_m2_to_H*1.0e-10
  endif
 
  ! Determine reconstruction within each column
  !$OMP parallel do default(shared) private(hTmp,tmp,ppol_E,ppol_coefs)
  do j = g%jsc-1,g%jec+1 ; do i = g%isc-1,g%iec+1
 
    ! Build current grid
    htmp(:) = h(i,j,:)
    tmp(:) = tv%S(i,j,:)
 
    ! Reconstruct salinity profile
    ppol_e(:,:) = 0.0
    ppol_coefs(:,:) = 0.0
    call edge_values_implicit_h4( gv%ke, htmp, tmp, ppol_e, h_neglect=h_neglect_edge, &
                                  answers_2018=cs%answers_2018 )
    call ppm_reconstruction( gv%ke, htmp, tmp, ppol_e, ppol_coefs, h_neglect, &
                                  answers_2018=cs%answers_2018 )
    if (bdry_extrap) &
      call ppm_boundary_extrapolation( gv%ke, htmp, tmp, ppol_e, ppol_coefs, h_neglect )
 
    do k = 1,gv%ke
      s_t(i,j,k) = ppol_e(k,1)
      s_b(i,j,k) = ppol_e(k,2)
    enddo
 
    ! Reconstruct temperature profile
    ppol_e(:,:) = 0.0
    ppol_coefs(:,:) = 0.0
    tmp(:) = tv%T(i,j,:)
    if (cs%answers_2018) then
      call edge_values_implicit_h4( gv%ke, htmp, tmp, ppol_e, h_neglect=1.0e-10*gv%m_to_H, &
                                  answers_2018=cs%answers_2018 )
    else
      call edge_values_implicit_h4( gv%ke, htmp, tmp, ppol_e, h_neglect=gv%H_subroundoff, &
                                  answers_2018=cs%answers_2018 )
    endif
    call ppm_reconstruction( gv%ke, htmp, tmp, ppol_e, ppol_coefs, h_neglect, &
                                  answers_2018=cs%answers_2018 )
    if (bdry_extrap) &
      call ppm_boundary_extrapolation(gv%ke, htmp, tmp, ppol_e, ppol_coefs, h_neglect )
 
    do k = 1,gv%ke
      t_t(i,j,k) = ppol_e(k,1)
      t_b(i,j,k) = ppol_e(k,2)
    enddo
 
  enddo ; enddo