PUBLIC INTERFACE ~ PUBLIC ROUTINES ~ NAMELIST

Module ocean_blob_mod

Contact:  Michael L. Bates ,  Stephen M. Griffies
Reviewers: 
Change History: WebCVS Log

OVERVIEW

This is the main "driver" module for the Lagrangian blob scheme. This module calls other modules that contain the individual parameterisations. Please note that the preprocessor option MOM_STATIC_ARRAYS is NOT supported. This is because to run a model where the memeory statically allocated without the blob framework will incur a large, unnecessary increase in memory requirements.

This module is the top-level module of the Lagrangian blob framework. It calls routines to form blobs, to integrate their properties, to transfer them from one dynamic regime to another, and also calculates the L system contribution towards grid cell thickness. This module also handles some framework wide variables, mostly associated with system wide diagnostics and the system wide accounting required to ensure the Eulerian model and the Lagrangian model can coexist. It should be noted that many of the parameterisations are not mutually exclusive. As such, care should be excercised when creating namelists for experiments.

OTHER MODULES USED

                constants_mod
             diag_manager_mod
                      fms_mod
                   fms_io_mod
              mpp_domains_mod
                      mpp_mod
          ocean_blob_diag_mod
ocean_blob_dynamic_bottom_mod
  ocean_blob_dynamic_free_mod
   ocean_blob_static_free_mod
 ocean_blob_static_bottom_mod
          ocean_blob_util_mod
            ocean_density_mod
            ocean_domains_mod
         ocean_parameters_mod
              ocean_types_mod
               ocean_util_mod
          ocean_workspace_mod

PUBLIC INTERFACE

ocean_blob_init:
init_blob_thickness:
ocean_blob_update:
ocean_blob_cell_update:
update_L_thickness:
calculate_rhoT:
ocean_blob_implicit:
adjust_L_thickness:
ocean_blob_diagnose_depth:
ocean_blob_end:
write_all_blobs:
entrainment_checksum:

PUBLIC ROUTINES

  1. ocean_blob_init

    DESCRIPTION
    Initialises the Lagrangian blob module by setting up module wide variables and calling initialisation scripts for the related modules, as well as the Lagrangian system itself. Infrastructure for communicating between PE's, interpolation of E system variables to a blob, communicating model wide namelist values and variables to other modules and picking up restarts is all done.


  2. init_blob_thickness

    DESCRIPTION
    Initialises the L_system thickness, based on the existing blobs


  3. ocean_blob_update

    DESCRIPTION
    Updates the Lagrangian blobs by calling routines that run during the explicit in time part of the time step.


  4. ocean_blob_cell_update

    DESCRIPTION
    For bottom blobs, it diagnoses the blobs vertical position in the models native vertical coordinate. For free blobs, it searches for the vertical grid cell that a free blob resides in. We require the information regarding the vertical grid cell that a blob resides in prior to the calculation of total grid cell thickness and prior to the calculation of the vertical advection velocity. In order to figure out which grid cell the blob is in, we need to employ different strategies for different coordinate system (see notes for details). For any blobs that penetrate the free surface (which is unlikely, but not impossible) we immediately kill them, returning their properties to the surface grid cell of the (i,j) column that they belong to. We recalculate a blobs density and volume for taup1, based on the pressure at the centre of the grid cell that it resides in.


  5. update_L_thickness

    DESCRIPTION
    Calculates the contribution to thickness of all the blobs for the L system arrays in the Thickness strcture. The mass per unit area from the blobs is also calculated for the upper and lower part of each grid cell and stored in the L_system structure. The calculate of mass per unit area is required for pressure calculations. We note that in DEPTH_BASED models, the value for density used is rho0, while it is the actual density in PRESSURE_BASED models. For the L_system mass per unit area, the actual density is used for all supported coordinates.


  6. calculate_rhoT

    DESCRIPTION
    Calculates the density of the combined E and L systems. It needs to be done here so that the blobs are taken into account.


  7. ocean_blob_implicit

    DESCRIPTION
    Updates the Lagrangian blobs by calling routines that run during the implicit in time part of the time step.


  8. adjust_L_thickness

    DESCRIPTION
    blob_thickness is called after new blobs are formed implicitly in time. blob_thickness provides the same function as update_L_thickness, with a couple of subtle differences. At the point that this routine is called, we: 1/ Know the vertical position of an "old" blob relative to the geoid and in the Eulerian model's native vertical coordinate. We do not know a blobs depth relative to the sea surface. 2/ Know the vertical position relative to the sea surface for "new" blobs, but we do not know its position relative to the geoid or in the Euerlian model's native vertical coordinate. So, blob_thickness uses the logical new, which is part of the blob derived type, to distinguish between new blobs and old blobs. New blobs have their position (upper or lower part of a grid cell) calculated using the depth relative to the sea surface height, while blobs that are not new have their position calculated using the Eulerian models native coordinate. The accumulation of thickness and mass per unit area are done in the same was as is done in update_L_thickness.


  9. ocean_blob_diagnose_depth

    DESCRIPTION
    When blobs are created implicitly in time, the sea surface height has not been calcualted in pressure based models (but depth has). However, the prognostic variable for blobs is the geodepth and not the depth. So, for a new blob, we set the depth when it is formed and then calculate the geodepth here. For existing blobs, we diagnose the depth using eta_t and geodepth. We note that in GEOPOTENTIAL coordinates, depth and geodepth are equivalent, and so we set them to be equivalent for the blobs too.


  10. ocean_blob_end

    DESCRIPTION
    Writes restarts and do checksums for the blobs at the end of a run.


  11. write_all_blobs

    DESCRIPTION
    A convenient subroutine for debugging that dumps blob details from every list


  12. entrainment_checksum

    DESCRIPTION
    Do the entrainment checksums


NAMELIST

&ocean_blob_nml

use_this_module
Must be true to use this module. Default is use_this_module=.false.
[logical]
debug_this_module
Writes additional diagnostic data to fms.out. This also controls debug output for the other related blob modules. Default is debug_this_module=.false.
[logical]
really_debug
Be careful what you wish for, this outputs A LOT of diagnostics to standard out! Default is debug_this_module=.false.
[logical]
do_bitwise_exact_sum
When global sum outputs are done there is additional computational expense to ensure that they are bitwise the same across an arbitrary number of processors. However, for debugging purposes, it can be useful for global sums to be the same. Note, that this differs from bitwise_reproduction in that it do_bitwise_exact_sum only applies to the mpp_global_sum diagnostic. Note that this flag controls the output for all associated blob modules. Default is do_bitwise_exact_sum=.false.
[logical]
bitwise_reproduction
There is additional cost involved in ensuring that results are reproducable across an arbitrary number of processors and across restarts. Bitwise reproduction is a very memory intensive operation and should only be used for debugging. For bitwise_reproduction=.true. We need to process blobs and their histories in the same relative order regardless of domain decomposition and restarts. To do so, we save the "history" of each blob subcycle is saved to a number of arrays (which can be a very memory intensive process) and process them in order. Note that this flag controls reproducability for all associated blob modules. Bitwise reproducibility is only possible with the appropriate compiler flags AND when the simulation is run on hardware that is capable of producing bitwise reproduction. Default is bitwise_reproduction=.false.
[logical]
blob_small_mass
Will delete blobs of mass less than blob_small_mass. Note that this variable is for all associated blob modules. The deletion of blobs is a conservative action, any mass/tracer fields that are nonzero have the remaining properties transferred back to the Eulerian system. So, in principle, blob_small_mass can actually be a relatively large number, and the model will remain conservative. It has been found in certain test cases (with very low tracer values) that setting blob_small_mass to be very small (i.e. <1e2) that roundoff error can cause non-trivial errors. So, it is recommended that blob_small_mass be no smaller than than 1e3 kg (which is approximately 1.0m**3 -- a very small blob!) Default is blob_small_mass=1.e3
[real, units: kg]
mass_prop_thickness
Sets the maximum proportion of a grid cell that the Lagrangian system may occupy. This is actually calculated separately (and therefore must be satisfied separately) for the uppper and lower portions of a grid cell. Default is blob_small_mass=0.7
[real, units: dimensionless]

REFERENCES

  1. S.M. Griffies, Elements of MOM4p1 (2009) NOAA/Geophysical Fluid Dynamics Laboratory

top