Detailed Description

This module contains the main regridding routines.

Regridding comprises two steps:

Interpolation and creation of a new grid based on target interface densities (or any other criterion).
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, 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, 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)
	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)
	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, 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, 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)
	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	pressure_gradient_plm (CS, S_t, S_b, T_t, T_b, G, GV, tv, h, bdry_extrap)
	Use plm reconstruction for pressure gradient (determine edge values) By using a PLM (limited piecewise linear method) reconstruction, this routine determines the edge values for the salinity and temperature within each layer. These edge values are returned and are used to compute the pressure gradient (by computing the densities). More...

subroutine, public	pressure_gradient_ppm (CS, S_t, S_b, T_t, T_b, G, GV, tv, h, bdry_extrap)
	Use ppm reconstruction for pressure gradient (determine edge values) By using a PPM (limited piecewise linear method) reconstruction, this routine determines the edge values for the salinity and temperature within each layer. These edge values are returned and are used to compute the pressure gradient (by computing the densities). 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 276 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 594 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 290 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 1135 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 1145 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 135 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                         :: 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=.true.)
  
   ! 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 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)
  
   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.)
   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 1114 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 1234 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,
		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 [m s-1]
[in,out]	v	Meridional velocity field [m s-1]
[in,out]	tv	Thermodynamic variable structure
	reg	Tracer registry structure
	cs	Regridding parameters and options
[in]	dt	Time step between calls to ALE_main()
	frac_shelf_h	Fractional ice shelf coverage

Definition at line 305 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 [m s-1]
   real, dimension(SZI_(G),SZJB_(G),SZK_(GV)), intent(inout) :: v   !< Meridional velocity field [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
   real,                             optional, intent(in)    :: dt  !< Time step between calls to ALE_main()
   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, -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,
		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
[in]	dt	Time step between calls to ALE_main()

Definition at line 391 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
   real,                             optional, intent(in)    :: dt  !< Time step between calls to ALE_main()
   ! 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, 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
	)

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

Definition at line 443 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
   ! 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, 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)
   call ale_remap_scalar(cs%remapCS, g, gv, nk, h, tv%S, h_new, tv%S)
  
   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
	)

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

Definition at line 523 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
   ! 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, 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_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 237 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')
   cs%id_v_preale = register_diag_field('ocean_model', 'v_preale', diag%axesCvL, time, &
       'Meridional velocity before remapping', 'm s-1')
   cs%id_h_preale = register_diag_field('ocean_model', 'h_preale', diag%axesTL, time, &
       'Layer Thickness before remapping', get_thickness_units(gv), 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')
   cs%id_vert_remap_h = register_diag_field('ocean_model','vert_remap_h',diag%axestl,time, &
       'layer thicknesses after ALE regridding and remapping', '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', 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(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
[in,out]	tv	Thermo vars (T/S/EOS)
[in]	n	Number of times to regrid
[in,out]	u	Zonal velocity
[in,out]	v	Meridional velocity
	reg	Tracer registry to remap onto new grid
[in]	dt	Model timestep to provide a timescale for regridding
[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 638 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
   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
   real, dimension(SZI_(G),SZJB_(G),SZK_(GV)), &
                            intent(inout) :: v      !< Meridional velocity
   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
   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, dzinttotal, u, v, dt=dt)
  
   ! 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 1156 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
	)

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".

Definition at line 896 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".
   ! 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
  
   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
  
   !### Try replacing both of these with GV%H_subroundoff
   if (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
	cs	ALE control structure

Definition at line 1164 of file MOM_ALE.F90.

   real,         intent(in) :: dt !< Time-step used between ALE calls
   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 1183 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 1203 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 567 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
  
  

◆ pressure_gradient_plm()

subroutine, public mom_ale::pressure_gradient_plm	(	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
	)

Use plm reconstruction for pressure gradient (determine edge values) By using a PLM (limited piecewise linear method) reconstruction, this routine determines the edge values for the salinity and temperature within each layer. These edge values are returned and are used to compute the pressure gradient (by computing the densities).

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 962 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
  
   ! Local variables
   integer :: i, j, k
   real    :: hTmp(GV%ke)
   real    :: tmp(GV%ke)
   real, dimension(CS%nk,2) :: ppol_E     !Edge value of polynomial
   real, dimension(CS%nk,2) :: ppol_coefs !Coefficients of polynomial
   real :: h_neglect
  
   !### Replace this with GV%H_subroundoff
   if (gv%Boussinesq) then
     h_neglect = gv%m_to_H*1.0e-30
   else
     h_neglect = gv%kg_m2_to_H*1.0e-30
   endif
  
   ! Determine reconstruction within each column
   !$OMP parallel do default(shared) private(hTmp,ppol_E,ppol_coefs,tmp)
   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 plm_reconstruction( gv%ke, htmp, tmp, ppol_e, ppol_coefs, h_neglect )
     if (bdry_extrap) &
       call plm_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,:)
     call plm_reconstruction( gv%ke, htmp, tmp, ppol_e, ppol_coefs, h_neglect )
     if (bdry_extrap) &
       call plm_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
  

◆ pressure_gradient_ppm()

subroutine, public mom_ale::pressure_gradient_ppm	(	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
	)

Use ppm reconstruction for pressure gradient (determine edge values) By using a PPM (limited piecewise linear method) reconstruction, this routine determines the edge values for the salinity and temperature within each layer. These edge values are returned and are used to compute the pressure gradient (by computing the densities).

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 1036 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)
   real    :: tmp(GV%ke)
   real, dimension(CS%nk,2) :: &
       ppol_E            !Edge value of polynomial
   real, dimension(CS%nk,3) :: &
       ppol_coefs !Coefficients of polynomial
   real :: h_neglect, h_neglect_edge
  
   !### Try replacing both of these with GV%H_subroundoff
   if (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
     !### Try to replace the following value of h_neglect with GV%H_subroundoff.
     call edge_values_implicit_h4( gv%ke, htmp, tmp, ppol_e, h_neglect=h_neglect_edge )
     call ppm_reconstruction( gv%ke, htmp, tmp, ppol_e, ppol_coefs, h_neglect )
     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,:)
     !### Try to replace the following value of h_neglect with GV%H_subroundoff.
     call edge_values_implicit_h4( gv%ke, htmp, tmp, ppol_e, h_neglect=1.0e-10*gv%m_to_H )
     call ppm_reconstruction( gv%ke, htmp, tmp, ppol_e, ppol_coefs, h_neglect )
     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
  

◆ 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,
		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
[in]	dxinterface	Change in interface position
[in,out]	u	Zonal velocity component [m s-1]
[in,out]	v	Meridional velocity component [m s-1]
[in]	debug	If true, show the call tree
[in]	dt	time step for diagnostics

Definition at line 722 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
   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 component [m s-1]
   real, dimension(SZI_(G),SZJB_(G),SZK_(GV)), &
                                    optional, intent(inout) :: v          !< Meridional velocity component [m s-1]
   logical,                         optional, intent(in)    :: debug      !< If true, show the call tree
   real,                            optional, intent(in)    :: dt         !< time step for diagnostics
   ! 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, 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
  
   !### Try replacing both of these with GV%H_subroundoff
   if (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
       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
       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()")
  

Detailed Description

Data Types

Functions/Subroutines

Function/Subroutine Documentation

◆ adjustgridforintegrity()

◆ ale_build_grid()

◆ ale_end()

◆ ale_getcoordinate()

◆ ale_getcoordinateunits()

◆ ale_init()

◆ ale_initregridding()

◆ ale_initthicknesstocoord()

◆ ale_main()

◆ ale_main_offline()

◆ ale_offline_inputs()

◆ ale_offline_tracer_final()

◆ ale_register_diags()

◆ ale_regrid_accelerated()

◆ ale_remap_init_conds()

◆ ale_remap_scalar()

◆ ale_update_regrid_weights()

◆ ale_updateverticalgridtype()

◆ ale_writecoordinatefile()

◆ check_grid()

◆ pressure_gradient_plm()

◆ pressure_gradient_ppm()

◆ remap_all_state_vars()