ice_mod.h

Go to the documentation of this file.

      MODULE mod_ice
!
!git $Id$
!================================================== Hernan G. Arango ===
!  Copyright (c) 2002-2025 The ROMS Group           Paul Budgell       !
!    Licensed under a MIT/X style license           Katherine Hedstrom !
!    See License_ROMS.md                            Scott M. Durski    !
!=======================================================================
!                                                                      !
!  The sea-ice model was originally written and tested by Paul Budgell !
!  (2005). It has been updated and improved by Kate Hedstrom and Scott !
!  Durski.                                                             !
!                                                                      !
!  It uses the elastic-viscous-plastic (EVP) rheology of Hunke and     !
!  Dukowicz (1997) and Hunke (2001). It has a simple one-layer ice and !
!  snow thermodynamics with a molecular sublayer under the ice (Mellor !
!  and Kantha, 1989).                                                  !
!                                                                      !
!  Variables:                                                          !
!                                                                      !
!  The ice model prognostic 'state' variable are declares in compact   !
!  form in the derived-type structure as:                              !
!                                                                      !
!    ICE(ng) % state(:,:,TimeLevel,StateIndex)                         !
!                                                                      !
!  where the 'StateIndex' are as follows:                              !
!                                                                      !
!    isAice    ice concentration (grid cell fraction)                  !
!    isEnth    enthalpy of the ice/brine system, ice heat content      !
!    isHage    thickness associated with age of ice (m)                !
!    isHice    average ice thickness (m), ice mass divided by area     !
!    isHmel    surface meltwater thickness on ice (m)                  !
!    isHsno    average thickness of snow coverage (m), mass snow       !
!    isIage    age of ice(s)                                           !
!    isISxx    internal ice stress, xx-component (N/m)                 !
!    isISxy    internal ice stress, xy-component (N/m)                 !
!    isISyy    internal ice stress, yy-component (N/m)                 !
!    isTice    ice interior temperature (Celsius)                      !
!    isUice    ice U-velocity (m/s)                                    !
!    isUevp    elastic-viscous-plastic ice U-velocity (m/s)            !
!    isVice    ice V-velocity (m/s)                                    !
!    isVevp    elastic-viscous-plastic ice V-velocity (m/s)            !
#if defined ICE_BIO
!    isIphy    ice biology, algae                                      !
!    isINO3    ice biology, nitrate                                    !
!    isINH4    ice biology, ammonia                                    !
!    isIlog    ice biology log                                         !
#endif
!                                                                      !
!  The ice model internal 'field' arrays are declares in compact form  !
!  in the derived-type structure as:                                   !
!                                                                      !
!    ICE(ng) % field(:,:,FieldIndex)                                   !
!                                                                      !
!  where the 'FieldIndex' are as follows:                              !
!                                                                      !
!    icAIus    surface Air-Ice U-stress (N/m2)                         !
!    icAIvs    surface Air-Ice V-stress (N/m2)                         !
!    icBvis    ice bulk viscosity                                      !
!    icHsse    sea surface elevation (m)                               !
!    icPgrd    gridded ice strength parameter (unitless)               !
!    icPice    ice pressure or strength (N/m2)                         !
!    icQcon    gradient heat conductivity over ice/snow (W/m2/K)       !
!    icQrhs    RHS surface net heat flux over ice/snow (W/m2)          !
!    icSvis    ice shear viscosity                                     !
!    icS0mk    salinity of molecular sublayer under ice (unitless)     !
!    icT0mk    temperature of molecular sublayer under ice (Celsius)   !
!    icIsst    temperature at the snow/atmosphere interface (Celsius)  !
!    icUavg    vertically averaged mixed-layer U-velocity (m/s)        !
!    icVavg    vertically averaged mixed-layer V-velocity (m/s)        !
!    icWdiv    rate of ice divergence (m3/s)                           !
!    icW_ai    rate of melt/freeze at Air/Ice edge (m3/s)              !
!    icW_ao    rate of melt/freeze at Air/Ocean edge (m3/s)            !
!    icW_fr    rate of ice accretion due to frazil growth (m3/s)       !
!    icW_io    rate of melt/freeze at Ice/Ocean edge (m3/s)            !
!    icW_ro    rate of melt/freeze runoff into ocean (m3/s)            !
!    icIOmf    Ice-Ocean mass flux (m/s)                               !
!    icIOvs    Ice-Ocean velocity shear magnitude (m/s)                !
!    icIOfv    Ice-Ocean friction velocity (m/s)                       !
!    icIOmt    Ice-Ocean momentum transfer coefficient (m/s)           !
!                                                                      !
!=======================================================================
!
      USE mod_kinds
!
      implicit none
!
      PUBLIC :: allocate_ice
      PUBLIC :: deallocate_ice
      PUBLIC :: initialize_ice
!
!-----------------------------------------------------------------------
!  Ice model identification indices.
!-----------------------------------------------------------------------
!
      integer :: idaice       ! ice concentration
      integer :: idaicl       ! ice concentration climatology
      integer :: idhage       ! thickness associated with age of ice
      integer :: idhice       ! ice thickness
      integer :: idhicl       ! ice thickness climatology
      integer :: idhmel       ! surface meltwater thickness
      integer :: idhsno       ! snow cover thickness
      integer :: idiage       ! ice age
      integer :: idiofv       ! ice-ocean friction velocity
      integer :: idiomf       ! ice-ocean mass flux
      integer :: idiomt       ! ice-ocean momentum transfer coefficient
      integer :: idisst       ! ice/snow surface temperature
      integer :: idisxx       ! internal ice stress xx-component
      integer :: idisxy       ! internal ice stress xy-component
      integer :: idisyy       ! internal ice stress yy-component
      integer :: ids0mk       ! under ice molecular sublayer salinity
      integer :: idt0mk       ! under ice molecular sublayer temperature
      integer :: idtice       ! ice interior temperature
      integer :: iduice       ! ice U-velocity
      integer :: iduicl       ! ice U-velocity climatology
      integer :: iduier       ! ice U-eastward  at RHO-points
      integer :: idvice       ! ice V-velocity
      integer :: idvicl       ! ice V-velocity climatology
      integer :: idvinr       ! ice V-northward at RHO-points
      integer :: idwdiv       ! rate of ice divergence
      integer :: idw_ai       ! rate of melt/freeze at air/ice edge
      integer :: idw_ao       ! rate of melt/freeze at air/ocean edge
      integer :: idw_fr       ! rate of ice accretion by frazil growth
      integer :: idw_io       ! rate of melt/freeze at ice/ocean edge
      integer :: idw_ro       ! rate of melt/freeze runoff into ocean
!
!  Ice model state prognostic variables indices.
!
#if defined ICE_BIO
      integer, parameter :: nices = 19  ! number of ice state variables
#else
      integer, parameter :: nices = 15  ! number of ice state variables
#endif
!
      integer :: isice(nices)           ! state I/O indices
!
      integer, parameter :: isaice =  1 ! ice concentration
      integer, parameter :: ishice =  2 ! ice thickness
      integer, parameter :: ishmel =  3 ! meltwater thickness on ice
      integer, parameter :: ishsno =  4 ! snow thickness
      integer, parameter :: isiage =  5 ! ice age
      integer, parameter :: isisxx =  6 ! internal ice xx-stress
      integer, parameter :: isisxy =  7 ! internal ice xy-stress
      integer, parameter :: isisyy =  8 ! internal ice yy-stress
      integer, parameter :: istice =  9 ! ice interior temperature
      integer, parameter :: isuice = 10 ! ice U-velocity
      integer, parameter :: isvice = 11 ! ice V-velocity
      integer, parameter :: isenth = 12 ! ice/brine enthalpy
      integer, parameter :: ishage = 13 ! thickness linked with ice age
      integer, parameter :: isuevp = 14 ! EVP ice U-velocity
      integer, parameter :: isvevp = 15 ! EVP ice V-velocity
#if defined ICE_BIO
      integer, parameter :: isiphy = 16 ! ice biology, algae
      integer, parameter :: isino3 = 17 ! ice biology, nitrate
      integer, parameter :: isinh4 = 18 ! ice biology, ammonia
      integer, parameter :: isilog = 19 ! ice biology log
#endif
 
!
!  Ice model state lateral boundary conditions indices.
!
      integer :: ibice(nices)           ! indices to LBC switch
      integer :: iceobc(4,nices)        ! I/O metadata indices
!
!  Ice model internal variables indices.
!
      integer, parameter :: nicef = 24  ! number of ice field variables
!
      integer :: ifice(nicef)           ! internal fields I/O indices
!
      integer, parameter :: icaius =  1 ! surface Air-Ice U-stress
      integer, parameter :: icaivs =  2 ! surface Air-Ice V-stress
      integer, parameter :: icbvis =  3 ! ice bulk viscosity
      integer, parameter :: ichsse =  4 ! sea surface elevation
      integer, parameter :: iciofv =  5 ! Ice-Ocean friction velocity
      integer, parameter :: iciomf =  6 ! Ice-Ocean mass flux
      integer, parameter :: iciomt =  7 ! Ice-Ocean momentum transfer
      integer, parameter :: iciovs =  8 ! Ice-Ocean velocity shear
      integer, parameter :: icisst =  9 ! ice/snow surface temperature
      integer, parameter :: icpgrd = 10 ! gridded ice strength
      integer, parameter :: icpice = 11 ! ice pressure or strength
      integer, parameter :: icqcon = 12 ! ice/snow heat conductivity
      integer, parameter :: icqrhs = 13 ! RHS heat flux over ice/snow
      integer, parameter :: icsvis = 14 ! ice shear viscosity
      integer, parameter :: ics0mk = 15 ! molecular sublayer salinity
      integer, parameter :: ict0mk = 16 ! molecular sublayer temperature
      integer, parameter :: icuavg = 17 ! average mixed-layer U-velocity
      integer, parameter :: icvavg = 18 ! average mixed-layer V-velocity
      integer, parameter :: icwdiv = 19 ! ice divergence rate
      integer, parameter :: icw_ai = 20 ! melt/freeze rate at Air/Ice
      integer, parameter :: icw_ao = 21 ! melt/freeze rate at Air/Ocean
      integer, parameter :: icw_fr = 22 ! ice accretion rate by frazil
      integer, parameter :: icw_io = 23 ! melt/freeze rate at Ice/Ocean
      integer, parameter :: icw_ro = 24 ! melt/freeze rate runoff
!
!-----------------------------------------------------------------------
!  Ice model parameters.
!-----------------------------------------------------------------------
 
#ifdef AVERAGES
!
!  Switches to process time-averaged ice model state and internal
!  variables.
!
      logical, allocatable :: licefavg(:,:)     ! internal variables
      logical, allocatable :: licesavg(:,:)     ! state variables
#endif
!
!  Counter and number of Elastic-Viscous-Plastic (EVP) rheology
!  equations timesteps to resolve elastic dynamics.
!
      integer, allocatable :: ievp(:)           ! timestep counter
      integer, allocatable :: nevp(:)           ! number of timesteps
!
!  Ice equations time step (s).
!
      integer, allocatable :: dtice(:)          ! viscous
      integer, allocatable :: dtevp(:)          ! elastic
!
!  Density parameters (kg/m3).
!
      real(r8), allocatable :: airrho(:)        ! air density
      real(r8), allocatable :: icerho(:)        ! ice density
      real(r8), allocatable :: snowdryrho(:)    ! dry snow density
      real(r8), allocatable :: snowwetrho(:)    ! wet snow density
!
!  Boundary layer bulk drag coefficients (nondimensional).
!
      real(r8), allocatable :: cd_ai(:)         ! air-ice boundary
      real(r8), allocatable :: cd_io(:)         ! ice-ocean boundary
!
!  Ice strength exponential weighting coefficient on concentration
!  (nondimensional).
!
      real(r8), allocatable :: astrength(:)
      real(r8), allocatable :: pstar(:)
!
!  Minimum and maximum average fractional ice concetration coverage
!  (nomdimensional) limiters.
!
      real(r8), allocatable :: min_ai(:)        ! minimum limiter
      real(r8), allocatable :: max_ai(:)        ! maximun limiter
!
!  Minimum average ice thickness (m) limiter.
!
      real(r8), allocatable :: min_hi(:)        ! minimum limiter
!
!  Maximum surface melt water thickness (m) limiter.
!
      real(r8), allocatable :: max_hmelt(:)
!
!  Minimum and maximum ice shear strength (N/m2) limiters.
!
      real(r8), allocatable :: zetamin(:)       ! minimum limiter
      real(r8), allocatable :: zetamax(:)       ! maximum limiter
!
!  Turning angle for ice-water drag (radians).
!
      real(r8), allocatable :: stressang(:)
!
!  Squared ellipticity/eccentricity of the yield curve (nondimensional).
!
      real(r8), allocatable :: ellip_sq(:)
!
!  Model formulation constants.
!
      real(r8) :: ice_emiss       ! ice emissivity (unitless)
      real(r8) :: spec_heat_air   ! specific heat of air (J/kg/K)
      real(r8) :: trans_coeff     ! heat transfer coefficient (unitless)
      real(r8) :: sublimation     ! latent heat of sublimation (J/kg)
!
!-----------------------------------------------------------------------
!  Define derived-type structure ice model state and internal arrays.
!-----------------------------------------------------------------------
!
      TYPE t_ice
 
        real(r8), pointer :: fi(:,:,:)               ! [i,j,1:nIceF]
        real(r8), pointer :: si(:,:,:,:)             ! [i,j,1:2,1:nIceS]
 
      END TYPE t_ice
!
      TYPE (t_ice), allocatable :: ice(:)            ! [Ngrids]
!
!-----------------------------------------------------------------------
!  Define derived-type structure ice model lateral boundary variables.
!-----------------------------------------------------------------------
!
      TYPE t_ice_lobc
 
        real(r8), pointer :: ice_west (:)
        real(r8), pointer :: ice_east (:)
        real(r8), pointer :: ice_south(:)
        real(r8), pointer :: ice_north(:)
!
        real(r8), pointer :: iceg_west (:,:)
        real(r8), pointer :: iceg_east (:,:)
        real(r8), pointer :: iceg_south(:,:)
        real(r8), pointer :: iceg_north(:,:)
 
      END TYPE t_ice_lobc
!
      TYPE (t_ice_lobc), allocatable :: ice_lobc(:,:)   ! [nIceS,Ngrids]
 
#ifdef AVERAGES
!
!-----------------------------------------------------------------------
!  Define derived-type structure ice model state and internal arrays
!  time-averaged variables. Notice that only the requested arrays are
!  allocated and processed.
!-----------------------------------------------------------------------
!
      TYPE t_ice_avg
 
        real(r8), pointer :: var(:,:)                ! [i,j]
 
      END TYPE t_ice_avg
!
      TYPE (t_ice_avg), allocatable :: ice_favg(:,:) ! [nIceF,Ngrids]
      TYPE (t_ice_avg), allocatable :: ice_savg(:,:) ! [nIceS,Ngrids]
#endif
!
      CONTAINS
!
      SUBROUTINE allocate_ice (ng, LBi, UBi, LBj, UBj, ice_kernel)
!
!=======================================================================
!                                                                      !
!  This routine allocates either the derived-type ice model variables  !
!  (ice_kernel=TRUE) or module parameters (ice_kernel=FALSE).          !
!                                                                      !
!=======================================================================
!
      USE mod_param,   ONLY : dmem, lbc, ngrids
      USE mod_scalars, ONLY : iwest, ieast, isouth, inorth
!
!  Imported variable declarations.
!
      logical, intent(in) :: ice_kernel
!
      integer, intent(in) :: ng, lbi, ubi, lbj, ubj
!
!  Local variable declarations.
!
      integer :: i
!
      real(r8) :: size2d, xsize, ysize
!
      size2d=real((ubi-lbi+1)*(ubj-lbj+1),r8)
      xsize =real(ubi-lbi,r8)
      ysize =real(ubj-lbj,r8)
 
!
!-----------------------------------------------------------------------
!  Allocate ice model parameters.
!-----------------------------------------------------------------------
!
      IF (.not.ice_kernel) THEN
 
#ifdef AVERAGES
        IF (.not.allocated(licefavg))                                   &
          allocate ( licefavg(nicef,ngrids) )
 
        IF (.not.allocated(licesavg))                                   &
          allocate ( licesavg(nices,ngrids) )
#endif
        IF (.not.allocated(ievp))                                       &
     &    allocate ( ievp(ngrids) )
 
        IF (.not.allocated(nevp))                                       &
     &    allocate ( nevp(ngrids) )
 
        IF (.not.allocated(dtice))                                      &
     &    allocate ( dtice(ngrids) )
 
        IF (.not.allocated(dtevp))                                      &
     &    allocate ( dtevp(ngrids) )
 
        IF (.not.allocated(airrho))                                     &
     &    allocate ( airrho(ngrids) )
 
        IF (.not.allocated(icerho))                                     &
     &    allocate ( icerho(ngrids) )
 
        IF (.not.allocated(snowdryrho))                                &
     &    allocate ( snowdryrho(ngrids) )
 
        IF (.not.allocated(snowwetrho))                                &
     &    allocate ( snowwetrho(ngrids) )
 
        IF (.not.allocated(cd_ai))                                      &
     &    allocate ( cd_ai(ngrids) )
 
        IF (.not.allocated(cd_io))                                      &
     &    allocate ( cd_io(ngrids) )
 
        IF (.not.allocated(astrength))                                  &
     &    allocate ( astrength(ngrids) )
 
        IF (.not.allocated(pstar))                                      &
     &    allocate ( pstar(ngrids) )
 
        IF (.not.allocated(min_ai))                                     &
     &    allocate ( min_ai(ngrids) )
 
        IF (.not.allocated(max_ai))                                     &
     &    allocate ( max_ai(ngrids) )
 
        IF (.not.allocated(min_hi))                                     &
     &    allocate ( min_hi(ngrids) )
 
        IF (.not.allocated(max_hmelt))                                  &
     &    allocate ( max_hmelt(ngrids) )
 
        IF (.not.allocated(zetamin))                                    &
     &    allocate ( zetamin(ngrids) )
 
        IF (.not.allocated(zetamax))                                    &
     &    allocate ( zetamax(ngrids) )
 
        IF (.not.allocated(stressang))                                  &
     &    allocate ( stressang(ngrids) )
 
        IF (.not.allocated(ellip_sq))                                   &
     &    allocate ( ellip_sq(ngrids) )
 
      END IF
!
!-----------------------------------------------------------------------
!  Allocate derived-type structure ice model kernel variables.
!-----------------------------------------------------------------------
!
      IF (ice_kernel) THEN
        IF (ng.eq.1) allocate ( ice(ngrids) )
!
!  Nonlinear ice model state variables (Si) and internal kernel field
!  (Fi) arrays.
!
        allocate ( ice(ng) % Si(lbi:ubi,lbj:ubj,2,nices) )
        dmem(ng)=dmem(ng)+2.0_r8*real(nices,r8)*size2d
!
        allocate ( ice(ng) % Fi(lbi:ubi,lbj:ubj,nicef) )
        dmem(ng)=dmem(ng)+real(nicef,r8)*size2d
      END IF
!
!-----------------------------------------------------------------------
!  Allocate derived-type structure ice model lateral boundary variables.
!-----------------------------------------------------------------------
!
      IF (ice_kernel) THEN
        IF (ng.eq.1) allocate ( ice_lobc(nices,ngrids) )
!
!  Nonlinear ice model 'state' lateral boundary arrays.
!
        DO i=1,nices
          IF (lbc(iwest,ibice(i),ng)%acquire) THEN
            allocate ( ice_lobc(i,ng) % ice_west(lbj:ubj) )
            dmem(ng)=dmem(ng)+ysize
 
            allocate ( ice_lobc(i,ng) % iceG_west(lbj:ubj,2) )
            dmem(ng)=dmem(ng)+2.0_r8*ysize
          END IF
!
          IF (lbc(ieast,ibice(i),ng)%acquire) THEN
            allocate ( ice_lobc(i,ng) % ice_east(lbj:ubj) )
            dmem(ng)=dmem(ng)+ysize
 
            allocate ( ice_lobc(i,ng) % iceG_east(lbj:ubj,2) )
            dmem(ng)=dmem(ng)+2.0_r8*ysize
          END IF
!
          IF (lbc(isouth,ibice(i),ng)%acquire) THEN
            allocate ( ice_lobc(i,ng) % ice_south(lbi:ubi) )
            dmem(ng)=dmem(ng)+xsize
 
            allocate ( ice_lobc(i,ng) % iceG_south(lbi:ubi,2) )
            dmem(ng)=dmem(ng)+2.0_r8*xsize
          END IF
!
          IF (lbc(inorth,ibice(i),ng)%acquire) THEN
            allocate ( ice_lobc(i,ng) % ice_north(lbi:ubi) )
            dmem(ng)=dmem(ng)+xsize
 
            allocate ( ice_lobc(i,ng) % iceG_north(lbi:ubi,2) )
            dmem(ng)=dmem(ng)+2.0_r8*xsize
          END IF
        END DO
      END IF
 
#ifdef AVERAGES
!
!-----------------------------------------------------------------------
!  Allocate derived-type structure ice model state and internal arrays
!  time-averaged variables.
!-----------------------------------------------------------------------
!
      IF (ice_kernel) THEN
        IF (ng.eq.1) THEN
          allocate ( ice_favg(nicef,ngrids) )
          allocate ( ice_savg(nices,ngrids) )
        END IF
!
!  Time-averaged internal fields. Only fields with metadata (iFice > 0)
!  are allocated and processed.
!
        DO i=1,nicef
          IF (ifice(i).gt.0) THEN
            IF (licefavg(i,ng)) THEN
              allocate ( ice_favg(i,ng) % var(lbi:ubi,lbj:ubj) )
              dmem(ng)=dmem(ng)+size2d
            END IF
          END IF
        END DO
!
!  Time-averaged state fields. Only fields with metadata (iSice > 0)
!  are allocated and processed.
!
        DO i=1,nices
          IF (isice(i).gt.0) THEN
            IF (licesavg(i,ng)) THEN
              allocate ( ice_savg(i,ng) % var(lbi:ubi,lbj:ubj) )
              dmem(ng)=dmem(ng)+size2d
            END IF
          END IF
        END DO
      END IF
#endif
!
      RETURN
      END SUBROUTINE allocate_ice
!
      SUBROUTINE deallocate_ice (ng)
!
!=======================================================================
!                                                                      !
!  This routine deallocates all variables in the module for all nested !
!  grids.                                                              !
!                                                                      !
!=======================================================================
!
      USE mod_param,   ONLY : ngrids
#ifdef SUBOBJECT_DEALLOCATION
      USE mod_param,   ONLY : lbc
      USE mod_scalars, ONLY : iwest, ieast, isouth, inorth
!
      USE destroy_mod, ONLY : destroy
#endif
!
!  Imported variable declarations.
!
      integer, intent(in) :: ng
!
!  Local variable declarations.
!
#ifdef SUBOBJECT_DEALLOCATION
      integer :: i
!
#endif
      character (len=*), parameter :: myfile =                          &
     &  __FILE__//", deallocate_ice"
 
#ifdef SUBOBJECT_DEALLOCATION
!
!-----------------------------------------------------------------------
!  Deallocate each variable in the derived-type T_FORCES structure
!  separately.
!-----------------------------------------------------------------------
!
!  Nonlinear ice model state variables 'Si' and internal kernel arrays
!  'Fi'.
!
      IF (.not.destroy(ng, ice(ng)%Si, myfile,                          &
     &                 __line__, 'ICE(ng)%Si')) RETURN
!
      IF (.not.destroy(ng, ice(ng)%Fi, myfile,                          &
     &                 __line__, 'ICE(ng)%Fi')) RETURN
!
!  Nonlinear ice model state lateral boundary arrays.
!
      DO i=1,nices
        IF (lbc(iwest,ibice(i),ng)%acquire) THEN
          IF (.not.destroy(ng, ice_lobc(i,ng)%ice_west, myfile,         &
     &                     __line__, 'ICE_LOBC(i,ng)%ice_west')) RETURN
          IF (.not.destroy(ng, ice_lobc(i,ng)%iceG_west, myfile,        &
     &                     __line__, 'ICE_LOBC(i,ng)%iceG_west')) RETURN
        END IF
!
        IF (lbc(ieast,ibice(i),ng)%acquire) THEN
          IF (.not.destroy(ng, ice_lobc(i,ng)%ice_east, myfile,         &
     &                     __line__, 'ICE_LOBC(i,ng)%ice_west')) RETURN
          IF (.not.destroy(ng, ice_lobc(i,ng)%iceG_east, myfile,        &
     &                     __line__, 'ICE_LOBC(i,ng)%iceG_west')) RETURN
        END IF
!
        IF (lbc(isouth,ibice(i),ng)%acquire) THEN
          IF (.not.destroy(ng, ice_lobc(i,ng)%ice_south, myfile,        &
     &                     __line__, 'ICE_LOBC(i,ng)%ice_south')) RETURN
          IF (.not.destroy(ng, ice_lobc(i,ng)%iceG_south, myfile,       &
     &                     __line__,'ICE_LOBC(i,ng)%iceG_south')) RETURN
        END IF
!
        IF (lbc(inorth,ibice(i),ng)%acquire) THEN
          IF (.not.destroy(ng, ice_lobc(i,ng)%ice_north, myfile,        &
     &                     __line__, 'ICE_LOBC(i,ng)%ice_north')) RETURN
          IF (.not.destroy(ng, ice_lobc(i,ng)%iceG_south, myfile,       &
     &                     __line__,'ICE_LOBC(i,ng)%iceG_north')) RETURN
        END IF
      END DO
 
# ifdef AVERAGES
!
!-----------------------------------------------------------------------
!  Time-averaged ice model state and internal variables.
!-----------------------------------------------------------------------
!
      DO i=1,nicef
        IF (licefavg(i,ng)) THEN
          IF (.not.destroy(ng, ice_favg(i,ng)%var, myfile,              &
     &                     __line__, 'ICE_FAVG(i,ng)%var')) RETURN
        END IF
      END DO
!
      DO i=1,nices
        IF (licesavg(i,ng)) THEN
          IF (.not.destroy(ng, ice_savg(i,ng)%var, myfile,              &
     &                     __line__, 'ICE_SAVG(i,ng)%var')) RETURN
        END IF
      END DO
# endif
#endif
!
!-----------------------------------------------------------------------
!  Deallocate derived-type ICE and ICE_LOBC structures.
!-----------------------------------------------------------------------
!
      IF (allocated(ice))      deallocate ( ice )
      IF (allocated(ice_lobc)) deallocate ( ice_lobc )
#ifdef AVERAGES
      IF (allocated(ice_favg)) deallocate ( ice_favg )
      IF (allocated(ice_savg)) deallocate ( ice_savg )
#endif
!
      RETURN
      END SUBROUTINE deallocate_ice
!
      SUBROUTINE initialize_ice (ng, tile, model)
!
!=======================================================================
!                                                                      !
!  This routine initialize all variables in the module using first     !
!  touch distribution policy. In shared-memory configuration, this     !
!  operation actually performs propagation of the  "shared arrays"     !
!  across the cluster, unless another policy is specified to           !
!  override the default.                                               !
!                                                                      !
!=======================================================================
!
      USE mod_param,   ONLY : bounds, domain, lbc, inlm
      USE mod_scalars, ONLY : iwest, ieast, isouth, inorth
!
!  Imported variable declarations.
!
      integer, intent(in) :: ng, tile, model
!
!  Local variable declarations.
!
      integer :: i, j, nf, ns
      integer :: imin, imax, jmin, jmax
 
      real(r8), parameter :: inival = 0.0_r8
!
#include "tile.h"
!
!  Set array initialization range.
!
#ifdef _OPENMP
      IF (domain(ng)%Western_Edge(tile)) THEN
        imin=bounds(ng)%LBi(tile)
      ELSE
        imin=istr
      END IF
      IF (domain(ng)%Eastern_Edge(tile)) THEN
        imax=bounds(ng)%UBi(tile)
      ELSE
        imax=iend
      END IF
      IF (domain(ng)%Southern_Edge(tile)) THEN
        jmin=bounds(ng)%LBj(tile)
      ELSE
        jmin=jstr
      END IF
      IF (domain(ng)%Northern_Edge(tile)) THEN
        jmax=bounds(ng)%UBj(tile)
      ELSE
        jmax=jend
      END IF
#else
      imin=lbi
      imax=ubi
      jmin=lbj
      jmax=ubj
#endif
!
!-----------------------------------------------------------------------
!  Initialize ice model state (Si) and internal field (Fi) arrays.
!-----------------------------------------------------------------------
!
      DO j=jmin,jmax
        DO i=imin,imax
          DO ns=1,nices
            ice(ng) % Si(i,j,1,ns) = inival
            ice(ng) % Si(i,j,2,ns) = inival
          END DO
!
          DO nf=1,nicef
            ice(ng) % Fi(i,j,nf) = inival
          END DO
        END DO
      END DO
!
!-----------------------------------------------------------------------
!  Initialize ice model lateral boundary arrays.
!-----------------------------------------------------------------------
!
      IF ((model.eq.0).or.(model.eq.inlm)) THEN
 
        DO i=1,nices
          IF (domain(ng)%NorthWest_Test(tile)) THEN
            IF (lbc(iwest,ibice(i),ng)%acquire) THEN
              ice_lobc(i,ng) % ice_west  = inival
              ice_lobc(i,ng) % iceG_west = inival
            END IF
          END IF
!
          IF (domain(ng)%SouthEast_Test(tile)) THEN
            IF (lbc(ieast,ibice(i),ng)%acquire) THEN
              ice_lobc(i,ng) % ice_east  = inival
              ice_lobc(i,ng) % iceG_east = inival
            END IF
          END IF
!
          IF (domain(ng)%SouthWest_Test(tile)) THEN
            IF (lbc(isouth,ibice(i),ng)%acquire) THEN
              ice_lobc(i,ng) % ice_south  = inival
              ice_lobc(i,ng) % iceG_south = inival
            END IF
          END IF
!
          IF (domain(ng)%NorthEast_Test(tile)) THEN
            IF (lbc(inorth,ibice(i),ng)%acquire) THEN
              ice_lobc(i,ng) % ice_north  = inival
              ice_lobc(i,ng) % iceG_north = inival
            END IF
          END IF
        END DO
 
      END IF
 
#ifdef AVERAGES
!
!-----------------------------------------------------------------------
!  Initialize time-averaged variables.
!-----------------------------------------------------------------------
!
!  Ice model internal fields.
!
      DO nf=1,nicef
        IF (ifice(nf).gt.0) THEN
          IF (licefavg(nf,ng)) THEN
            DO j=jmin,jmax
              DO i=imin,imax
                ice_favg(nf,ng) % var(i,j) = inival
              END DO
            END DO
          END IF
        END IF
      END DO
!
!  Time-averaged state fields.
!
      DO ns=1,nices
        IF (isice(ns).gt.0) THEN
          IF (licesavg(ns,ng)) THEN
            DO j=jmin,jmax
              DO i=imin,imax
                ice_savg(ns,ng) % var(i,j) = inival
              END DO
            END DO
          END IF
        END IF
      END DO
#endif
!
      RETURN
      END SUBROUTINE initialize_ice
!
      END MODULE mod_ice