mod_floats.F

Go to the documentation of this file.

#include "cppdefs.h"
      MODULE mod_floats
#ifdef FLOATS
!
!git $Id$
!================================================== Hernan G. Arango ===
!  Copyright (c) 2002-2025 The ROMS Group                              !
!    Licensed under a MIT/X style license                              !
!    See License_ROMS.md                                               !
!=======================================================================
!                                                                      !
!  Findex     Indices of spherical coordinates entries in initial      !
!               location arrays, if any.                               !
!  Flon       Initial longitude locations, if any.                     !
!  Flat       Initial latitude locations, if any.                      !
!  Ftype      Float trajectory type:                                   !
!               Ftype(:) = 1,  neutral density 3D Lagrangian           !
!               Ftype(:) = 2,  isobaric (constant depth) float.        !
!  Tinfo      Float trajectory initial information.                    !
!  bounded    Float bounded status switch.                             !
# if defined SOLVE3D && defined FLOAT_VWALK
!  rwalk      Normally distributed random deviates used in vertical    !
!               random walk.                                           !
# endif
# if defined SOLVE3D && defined FLOAT_STICKY
!  stuck      Reflection switch. Floats that hit the surface are       !
!               reflected and floats that hitthe bottom get stick      !
# endif
!  track      Multivariate float trajectory data at several time       !
!               time levels.                                           !
!                                                                      !
!=======================================================================
!
        USE mod_param
!
        implicit none
!
        PUBLIC :: allocate_floats
        PUBLIC :: deallocate_floats
!
!-----------------------------------------------------------------------
!  Define T_DRIFTER structure.
!-----------------------------------------------------------------------
!
        TYPE t_drifter
 
          logical, pointer  :: bounded(:)
 
# if defined SOLVE3D && defined FLOAT_STICKY
          logical, pointer  :: stuck(:)
# endif
 
          integer, pointer :: findex(:)
          integer, pointer :: ftype(:)
 
          real(r8), pointer :: flon(:)
          real(r8), pointer :: flat(:)
          real(r8), pointer :: fz0(:)
          real(r8), pointer :: tinfo(:,:)
# if defined SOLVE3D && defined FLOAT_VWALK
          real(r8), pointer :: rwalk(:)
# endif
          real(r8), pointer :: track(:,:,:)
 
        END TYPE t_drifter
!
        TYPE (t_drifter), allocatable :: drifter(:)
!
!-----------------------------------------------------------------------
!  Lagrangian drifters parameters.
!-----------------------------------------------------------------------
!
!  Switch to control the printing of floats positions to standard output
!  file.
!
        logical, allocatable :: fprint(:)
!
!  Identification indices.
!
        integer, parameter :: itstr = 0          ! release time
        integer, parameter :: ixgrd = 1          ! x-grid location
        integer, parameter :: iygrd = 2          ! y-grid location
        integer, parameter :: izgrd = 3          ! z-grid location
        integer, parameter :: iflon = 4          ! longitude location
        integer, parameter :: iflat = 5          ! latitude location
        integer, parameter :: idpth = 6          ! depth
        integer, parameter :: ixrhs = 7          ! x-slope
        integer, parameter :: iyrhs = 8          ! y-slope
        integer, parameter :: izrhs = 9          ! z-slope
        integer, parameter :: ifden = 10         ! density anomaly
# ifdef FLOAT_VWALK
        integer, parameter :: ifakt = 11         ! diffusivity, Akt
        integer, parameter :: ifdak = 12         ! d(Akt)/d(s)
# endif
# ifdef FLOAT_OYSTER
#  ifdef FLOAT_VWALK
        integer, parameter :: i1ohz = 13         ! 1/Hz
        integer, parameter :: isizf = 14         ! larvae size (length)
        integer, parameter :: ibrhs = 15         ! behavior RHS
        integer, parameter :: iswim = 16         ! swimming time
        integer, parameter :: iwbio = 17         ! biological w-velocity
        integer, parameter :: iwsin = 18         ! sinking velocity
#  else
        integer, parameter :: i1ohz = 11         ! 1/Hz
        integer, parameter :: isizf = 12         ! larvae size (length)
        integer, parameter :: ibrhs = 13         ! behavior RHS
        integer, parameter :: iswim = 14         ! swimming time
        integer, parameter :: iwbio = 15         ! biological w-velocity
        integer, parameter :: iwsin = 16         ! sinking velocity
#  endif
# endif
# ifdef SOLVE3D
!
!  Tracer variables indices in the track array.
!
        integer, allocatable :: iftvar(:)
# endif
!
!  Set float tracjectory types:
!
!    flt_Lagran:  3D Lagrangian floats
!    flt_Isobar:  Isobaric floats, p=g*(z+zeta)=constant
!    flt_Geopot:  Geopotential floats, constant depth
!
        integer, parameter :: flt_lagran = 1
        integer, parameter :: flt_isobar = 2
        integer, parameter :: flt_geopot = 3
 
# ifdef FLOAT_VWALK
!
!  Vertical random walk, initial seed state.
!
        integer :: flt_iseed
# endif
!
!  Floats restart switch.
!
        integer, allocatable :: frrec(:)
!
      CONTAINS
!
      SUBROUTINE allocate_floats (Ldrifter)
!
!=======================================================================
!                                                                      !
!  This routine eihter  allocates and initialize all variables in      !
!  the DRIFTER structure (Ldrifter=.TRUE.) or other parameters in      !
!  the module that are independent of Nfloats (Ldrifter=.FALSE.).      !
!                                                                      !
!=======================================================================
!
      USE mod_scalars
!
!  Imported variable declarations.
!
      logical, intent(in) :: ldrifter
!
!  Local variable declarations.
!
      integer :: ng, i, ic, iflt
 
      real(r8), parameter :: inival = 0.0_r8
!
!-----------------------------------------------------------------------
!  Allocate Langrangian drifters structure.
!-----------------------------------------------------------------------
!
      IF (ldrifter) THEN
 
        allocate ( drifter(ngrids) )
!
!  Allocate variables.
!
        DO ng=1,ngrids
          allocate ( drifter(ng) % bounded(nfloats(ng)) )
          dmem(ng)=dmem(ng)+real(nfloats(ng),r8)
 
# if defined SOLVE3D && defined FLOAT_STICKY
          allocate ( drifter(ng) % stuck(nfloats(ng)) )
          dmem(ng)=dmem(ng)+real(nfloats(ng),r8)
# endif
 
          allocate ( drifter(ng) % Findex(0:nfloats(ng)) )
          dmem(ng)=dmem(ng)+real(nfloats(ng)+1,r8)
 
          allocate ( drifter(ng) % Ftype(nfloats(ng)) )
          dmem(ng)=dmem(ng)+real(nfloats(ng),r8)
 
          allocate ( drifter(ng) % Flon(nfloats(ng)) )
          dmem(ng)=dmem(ng)+real(nfloats(ng),r8)
 
          allocate ( drifter(ng) % Flat(nfloats(ng)) )
          dmem(ng)=dmem(ng)+real(nfloats(ng),r8)
 
          allocate ( drifter(ng) % Fz0(nfloats(ng)) )
          dmem(ng)=dmem(ng)+real(nfloats(ng),r8)
 
          allocate ( drifter(ng) % Tinfo(0:izrhs,nfloats(ng)) )
          dmem(ng)=dmem(ng)+real((izrhs+1)*nfloats(ng),r8)
 
# if defined SOLVE3D && defined FLOAT_VWALK
          allocate ( drifter(ng) % rwalk(nfloats(ng)) )
          dmem(ng)=dmem(ng)+real(nfloats(ng),r8)
# endif
 
          allocate ( drifter(ng) % track(nfv(ng),0:nft,nfloats(ng)) )
          dmem(ng)=dmem(ng)+real(nfv(ng)*(nft+1)*nfloats(ng),r8)
        END DO
      END IF
!
!-----------------------------------------------------------------------
!  Lagrangian drifters parameters.
!-----------------------------------------------------------------------
!
      IF (.not.ldrifter) THEN
        allocate ( fprint(ngrids) )
        allocate ( frrec(ngrids) )
 
# ifdef SOLVE3D
        allocate ( iftvar(mt) )
# endif
      END IF
!
!-----------------------------------------------------------------------
!  Initialize Langrangian drifters structure.
!-----------------------------------------------------------------------
!
      IF (ldrifter) THEN
        DO ng=1,ngrids
          drifter(ng) % Findex(0) = 0
          DO iflt=1,nfloats(ng)
            drifter(ng) % bounded(iflt) = .false.
# if defined SOLVE3D && defined FLOAT_STICKY
            drifter(ng) % stuck(iflt) = .false.
# endif
            drifter(ng) % Findex(iflt) = 0
            drifter(ng) % Ftype(iflt) = 0
            drifter(ng) % Flon(iflt) = inival
            drifter(ng) % Flat(iflt) = inival
            drifter(ng) % Fz0(iflt) = 0
# if defined SOLVE3D && defined FLOAT_VWALK
            drifter(ng) % rwalk = inival
# endif
            DO i=0,izrhs
              drifter(ng) % Tinfo(i,iflt) = inival
            END DO
            DO i=1,nfv(ng)
              drifter(ng) % track(i,0,iflt) = inival
              drifter(ng) % track(i,1,iflt) = inival
              drifter(ng) % track(i,2,iflt) = inival
              drifter(ng) % track(i,3,iflt) = inival
              drifter(ng) % track(i,4,iflt) = inival
            END DO
          END DO
        END DO
      END IF
!
!-----------------------------------------------------------------------
!  Initialize Langrangian drifters parameters.
!-----------------------------------------------------------------------
!
      IF (.not.ldrifter) THEN
# ifdef FLOAT_VWALK
        flt_iseed=149876
# endif
        DO ng=1,ngrids
          fprint(ng)=.true.
        END DO
 
# ifdef SOLVE3D
!
!  Indices for tracer variables in the floats array track.
!
#  ifdef FLOAT_OYSTER
#   ifdef FLOAT_VWALK
        ic=18
#   else
        ic=16
#   endif
#  else
#   ifdef FLOAT_VWALK
        ic=12
#   else
        ic=10
#   endif
#  endif
        DO i=1,mt
          ic=ic+1
          iftvar(i)=ic
        END DO
# endif
      END IF
!
      RETURN
      END SUBROUTINE allocate_floats
!
      SUBROUTINE deallocate_floats (ng)
!
!=======================================================================
!                                                                      !
!  This routine dealocates all variables in module for all nested      !
!  grids.                                                              !
!                                                                      !
!=======================================================================
!
      USE mod_param,   ONLY : ngrids
# ifdef SUBOBJECT_DEALLOCATION
      USE destroy_mod, ONLY : destroy
# endif
!
!  Imported variable declarations.
!
      integer, intent(in) :: ng
!
!  Local variable declarations.
!
      character (len=*), parameter :: myfile =                          &
     &  __FILE__//", deallocate_floats"
 
# ifdef SUBOBJECT_DEALLOCATION
!
!-----------------------------------------------------------------------
!  Deallocate each variable in the derived-type T_DRIFTER structure
!  separately.
!-----------------------------------------------------------------------
!
      IF (.not.destroy(ng, drifter(ng)%bounded, myfile,                 &
     &                 __line__, 'DRIFTER(ng)%bounded')) RETURN
 
#  if defined SOLVE3D && defined FLOAT_STICKY
      IF (.not.destroy(ng, drifter(ng)%stuck, myfile,                   &
     &                 __line__, 'DRIFTER(ng)%stuck')) RETURN
#  endif
 
      IF (.not.destroy(ng, drifter(ng)%Findex, myfile,                  &
     &                 __line__, 'DRIFTER(ng)%Findex')) RETURN
 
      IF (.not.destroy(ng, drifter(ng)%Ftype, myfile,                   &
     &                 __line__, 'DRIFTER(ng)%Ftype')) RETURN
 
      IF (.not.destroy(ng, drifter(ng)%Flon, myfile,                    &
     &                 __line__, 'DRIFTER(ng)%Flon')) RETURN
 
      IF (.not.destroy(ng, drifter(ng)%Flat, myfile,                    &
     &                 __line__, 'DRIFTER(ng)%Flat')) RETURN
 
      IF (.not.destroy(ng, drifter(ng)%Fz0, myfile,                     &
     &                 __line__, 'DRIFTER(ng)%Fz0')) RETURN
 
      IF (.not.destroy(ng, drifter(ng)%Tinfo, myfile,                   &
     &                 __line__, 'DRIFTER(ng)%Tinfo')) RETURN
 
#  if defined SOLVE3D && defined FLOAT_VWALK
      IF (.not.destroy(ng, drifter(ng)%rwalk, myfile,                   &
     &                 __line__, 'DRIFTER(ng)%rwalk')) RETURN
#  endif
 
      IF (.not.destroy(ng, drifter(ng)%track, myfile,                   &
     &                 __line__, 'DRIFTER(ng)%track')) RETURN
# endif
!
!-----------------------------------------------------------------------
!  Deallocate T_DRIFTER structure.
!-----------------------------------------------------------------------
!
      IF (ng.eq.ngrids) THEN
        IF (allocated(drifter)) deallocate ( drifter )
      END IF
!
!-----------------------------------------------------------------------
!  Deallocate other variables in module.
!-----------------------------------------------------------------------
!
      IF (allocated(fprint))  deallocate ( fprint )
 
      IF (allocated(frrec))   deallocate ( frrec )
 
# ifdef SOLVE3D
      IF (allocated(iftvar))  deallocate ( iftvar )
# endif
!
      RETURN
      END SUBROUTINE deallocate_floats
#endif
      END MODULE mod_floats