oyster_floats.h

Go to the documentation of this file.

#undef GROWTH_ONLY
 
      MODULE biology_floats_mod
!
!git $Id$
!================================================== Hernan G. Arango ===
!  Copyright (c) 2002-2025 The ROMS Group           Diego A. Narvaez   !
!    Licensed under a MIT/X style license                              !
!    See License_ROMS.md                                               !
!=======================================================================
!                                                                      !
!  This routine sets behavior for Lagrangian particles that simulates  !
!  planktonic larvae.  The  planktonic behavior is based on the model  !
!  of Dekshenieks et al. (1993; 1996; 1997).  It  calculates the size  !
!  (length) and development of oyster larvae. Results about this model !
!  can be found in Narvaez et al. 2012 a,b (in review)                 !
!                                                                      !
!  The governing equation are:                                         !
!                                                                      !
!    d(Lsize)/d(t) = growth(food,Lsize) * Gfactor(T,S) * turb_ef       !
!                                                                      !
!    w_bio = TS * SW - (1 - TS) * SR                                   !
!                                                                      !
!  where                                                               !
!                                                                      !
!      turbef = m * turb + c,                for turbidity < 0.1 g/l   !
!  or                                                                  !
!      turbef = b * EXP(-beta*(turb-turb0)), for turbidity > 0.1 g/l   !
!                                                                      !
!      TS =  c * DS + d,    for increasing salinity gradient DS        !
!  or                                                                  !
!      TS = -e * DS + f,    for decreasing salinity gradient DS        !
!                                                                      !
!      SR = 2.665 * EXP(0.0058*(Lsize-220))                            !
!                                                                      !
!  TS: fraction of active larvae: fractional swimming time             !
!  SW: larval swimming rate (mm/s)                                     !
!  SR: larval sinking rate (mm/s)                                      !
!  DS: salinity change rate (1/s)                                      !
!                                                                      !
!  References:                                                         !
!                                                                      !
!    Dekshenieks, M.M., E.E. Hofmann, and E.N. Powell, 1993:           !
!      Environmental effect on the growth and development of           !
!      Eastern oyster, Crassostrea virginica (Gmelin, 1791),           !
!      larvae: A modeling study, J. Shelfish Res, 12, 241-254.         !
!                                                                      !
!    Dekshenieks, M.M., E.E. Hofmann, J.M. Klinck, and E.N.            !
!      Powell, 1996: Modeling the vertical distribution of             !
!      oyster larvae in response to environmental conditions,          !
!      Mar. Ecol. Prog. Ser., 136, 97-110.                             !
!                                                                      !
!    Dekshenicks, M.M., E.E. Hofmann, J.M. Klinck, and E.N.            !
!      Powell, 1997: A modeling study of the effect of size-           !
!      and depth_dependent predation on larval survival, J.            !
!      Plankton Res., 19, (11), 1583-1598.                             !
!                                                                      !
!    Narvaez, D.A, J.M. Klinck, E.N. Powell, E.E. Hofmann, J. Wilkin   !
!      and D. B. Haidvogel. Modeling the dispersal of Eastern          !
!      oyster (Crassostrea virginica) larvae in Delaware Bay, J. Mar.  !
!      Res., in review.                                                !
!                                                                      !
!    Narvaez, D.A, J.M. Klinck, E.N. Powell, E.E. Hofmann, J. Wilkin   !
!      and D. B. Haidvogel. Circulation and behavior controls on       !
!      dispersal of Eastern oyster (Crassostrea virginica) larvae in   !
!      Delaware Bay, J. Mar. Res., in review.                          !
!                                                                      !
!=======================================================================
!
      implicit none
!
      PRIVATE
      PUBLIC  :: biology_floats
!
      CONTAINS
!
!***********************************************************************
      SUBROUTINE biology_floats (ng, Lstr, Lend, Predictor, my_thread)
!***********************************************************************
!
      USE mod_param
      USE mod_floats
      USE mod_stepping
!
!  Imported variable declarations.
!
      integer, intent(in) :: ng, lstr, lend
 
      logical, intent(in) :: predictor
#ifdef ASSUMED_SHAPE
      logical, intent(in) :: my_thread(lstr:)
#else
      logical, intent(in) :: my_thread(lstr:lend)
#endif
!
!  Local variable declarations.
!
      character (len=*), parameter :: myfile =                          &
     &  __FILE__
!
#ifdef PROFILE
      CALL wclock_on (ng, inlm, 10, __line__, myfile)
#endif
      CALL oyster_floats_tile (ng, lstr, lend,                          &
     &                         nfm3(ng), nfm2(ng), nfm1(ng), nf(ng),    &
     &                         nfp1(ng),                                &
     &                         predictor, my_thread,                    &
     &                         drifter(ng) % bounded,                   &
     &                         drifter(ng) % Tinfo,                     &
     &                         drifter(ng) % track)
#ifdef PROFILE
      CALL wclock_off (ng, inlm, 10, __line__, myfile)
#endif
!
      RETURN
      END SUBROUTINE biology_floats
!
!***********************************************************************
      SUBROUTINE oyster_floats_tile (ng, Lstr, Lend,                    &
     &                               nfm3, nfm2, nfm1, nf, nfp1,        &
     &                               Predictor, my_thread, bounded,     &
     &                               Tinfo, track)
!***********************************************************************
!
      USE mod_param
      USE mod_parallel
      USE mod_behavior
#ifdef BIOLOGY
      USE mod_biology
#endif
      USE mod_floats
      USE mod_grid
      USE mod_iounits
      USE mod_scalars
!
!  Imported variable declarations.
!
      integer, intent(in) :: ng, Lstr, Lend
      integer, intent(in) :: nfm3, nfm2, nfm1, nf, nfp1
      logical, intent(in) :: Predictor
!
#ifdef ASSUMED_SHAPE
      logical, intent(in) :: bounded(:)
      logical, intent(in) :: my_thread(Lstr:)
 
      real(r8), intent(in) :: Tinfo(0:,:)
      real(r8), intent(inout) :: track(:,0:,:)
#else
      logical, intent(in) :: bounded(Nfloats(ng))
      logical, intent(in) :: my_thread(Lstr:Lend)
 
      real(r8), intent(in) :: Tinfo(0:izrhs,Nfloats(ng))
      real(r8), intent(inout) :: track(NFV(ng),0:NFT,Nfloats(ng))
#endif
!
!  Local variable declarations.
!
      integer :: i, i1, i2, j1, j2, l
 
      real(r8) :: dsalt, temp, salt
      real(r8) :: Lfood, Lturb, Lsize, LsizeNew
      real(r8) :: Grate, Gfactor, turb_ef
      real(r8) :: SwimRate, SwimTime, SwimTimeNew
      real(r8) :: bottom, brhs, sink, w_bio
      real(r8) :: cff1, cff2, cff3, cff4
      real(r8) :: p1, p2, q1, q2
      real(r8) :: my_food, my_salt, my_size, my_temp
      real(r8) :: oGfactor_DS, oGfactor_DT
      real(r8) :: oGrate_DF, oGrate_DL
      real(r8) :: oswim_DL, oswim_DT
      real(r8) :: HalfDT
!
!-----------------------------------------------------4-----------------
!  Estimate larval growth, as length (um), based on food, salinity,
!  temperature and turbidity.  Then, estimate swimming time (s),
!  larvae sinking velocity (m/s) and larvae vertical velocity (m/s).
!-----------------------------------------------------------------------
!
!  Compute look tables inverse axis increments to avoid repetitive
!  divisions.
!
      ograte_df=1.0_r8/grate_df
      ograte_dl=1.0_r8/grate_dl
 
      ogfactor_ds=1.0_r8/gfactor_ds
      ogfactor_dt=1.0_r8/gfactor_dt
 
      oswim_dt=1.0_r8/swim_dt
      oswim_dl=1.0_r8/swim_dl
!
!  Assign predictor/corrector weights.
!
      IF (predictor) THEN
        cff1=8.0_r8/3.0_r8
        cff2=4.0_r8/3.0_r8
      ELSE
        cff1=9.0_r8/8.0_r8
        cff2=1.0_r8/8.0_r8
        cff3=3.0_r8/8.0_r8
        cff4=6.0_r8/8.0_r8
      END IF
!
!  Compute biological behavior fields.
!
      halfdt=0.5_r8*dt(ng)
 
      DO l=lstr,lend
        IF (my_thread(l).and.bounded(l)) THEN
!
!  If newly relased float, initialize biological behavior fields. Note
!  that since we need temperature and salinity, we need to initialize
!  their values to all time levels. Otherwise, we will have a parallel
!  bug.
!
          IF (time(ng)-halfdt.le.tinfo(itstr,l).and.                    &
     &        time(ng)+halfdt.gt.tinfo(itstr,l)) THEN
            temp=track(iftvar(itemp),nfp1,l)
            salt=track(iftvar(isalt),nfp1,l)
            DO i=0,nft
              track(isizf,i,l)=larvae_size0(ng)
              track(iswim,i,l)=0.5_r8*(swim_tmin(ng)+swim_tmax(ng))
              track(iftvar(itemp),i,l)=temp
              track(iftvar(isalt),i,l)=salt
            END DO
          END IF
!
!  Get temperature, salinity, larvae size (length), swimming time, and
!  food supply. For now, assume constant food and turbidity.  This
!  can be changed in the future with spatial and temporal variability
!  for food and/or turbidity.  If this is the case, we need to have
!  something like:
!
!         IF (Predictor) THEN
!           Lfood=track(ifood,nf,l)
!           Lturb=track(iturb,nf,l)
!           ...
!         ELSE
!           Lfood=track(ifood,nfp1,l)
!           Lturb=track(iturb,nfp1,l)
!           ...
!         END IF
!
!  The food variability may be from data, ecosystem model, or analytical
!  functions. Similarly, the turbidity may be from data, sediment model,
!  or analytical functions.
!
          temp=track(iftvar(itemp),nfp1,l)
          salt=track(iftvar(isalt),nfp1,l)
          dsalt=track(iftvar(isalt),nfp1,l)-                            &
     &          track(iftvar(isalt),nf  ,l)
          IF (predictor) THEN
            lsize=track(isizf,nf,l)
            swimtime=track(iswim,nf,l)
            lfood=food_supply(ng)
            lturb=turb_ambi(ng)
          ELSE
            lsize=track(isizf,nfp1,l)
            swimtime=track(iswim,nfp1,l)
            lfood=food_supply(ng)
            lturb=turb_ambi(ng)
          END IF
!
!  Determine larval growth rate (um/day) contribution as function of
!  food supply (mg_Carbon/l) and larval size (um). Linearly interpolate
!  growth rate from the look table of food concentration versus larval
!  size. Notice that extrapolation is suppresed by bounding "Lfood" and
!  "Lsize" to the range values in the look table.
!
          my_food=min(max(grate_f0,lfood),                              &
     &                grate_f0+grate_df*real(grate_im-1,r8))
          my_size=min(max(grate_l0,lsize),                              &
     &                grate_l0+grate_dl*real(grate_jm-1,r8))
 
          i1=int(1.0_r8+(my_food-grate_f0)*ograte_df)
          i2=min(i1+1,grate_im)
          j1=int(1.0_r8+(my_size-grate_l0)*ograte_dl)
          j2=min(j1+1,grate_jm)
 
          p2=(my_food-(grate_f0+real(i1-1,r8)*grate_df))*ograte_df
          q2=(my_size-(grate_l0+real(j1-1,r8)*grate_dl))*ograte_dl
          p1=1.0_r8-p2
          q1=1.0_r8-q2
 
          grate=p1*q1*grate_table(i1,j1)+                               &
     &          p2*q1*grate_table(i2,j1)+                               &
     &          p1*q2*grate_table(i1,j2)+                               &
     &          p2*q2*grate_table(i2,j2)
!
!  Determine larval growth rate factor (nondimensional) as function of
!  salinity and temperature (Celsius). Linearly interpolate growth rate
!  factor from the look table of salinity versus temperature. Notice
!  that extrapolation is suppresed by bounding "salt" and "temp" to the
!  range values in the look table.
!
          IF (temp.lt.gfactor_t0) THEN
            gfactor=0.0_r8
          ELSE
            my_salt=min(max(gfactor_s0,salt),                           &
     &                  gfactor_s0+gfactor_ds*real(gfactor_im-1,r8))
            my_temp=min(max(gfactor_t0,temp),                           &
     &                  gfactor_t0+gfactor_dt*real(gfactor_jm-1,r8))
 
            i1=int(1.0_r8+(my_salt-gfactor_s0)*ogfactor_ds)
            i2=min(i1+1,gfactor_im)
            j1=int(1.0_r8+(my_temp-gfactor_t0)*ogfactor_dt)
            j2=min(j1+1,gfactor_jm)
 
            p2=(my_salt-(gfactor_s0+real(i1-1,r8)*gfactor_ds))*         &
     &         ogfactor_ds
            q2=(my_temp-(gfactor_t0+real(j1-1,r8)*gfactor_dt))*         &
     &         ogfactor_dt
            p1=1.0_r8-p2
            q1=1.0_r8-q2
 
            gfactor=p1*q1*gfactor_table(i1,j1)+                         &
     &              p2*q1*gfactor_table(i2,j1)+                         &
     &              p1*q2*gfactor_table(i1,j2)+                         &
     &              p2*q2*gfactor_table(i2,j2)
          END IF
!
!  Determine turbidity effect (linear or exponential) on larval growth.
!  Then, compute new larvae size (um) as function of growth rate (um/s)
!  which is loaded in track(ibrhs,:,:).
!
          IF (lsize.gt.turb_size(ng)) THEN
            IF (lturb.gt.turb_crit(ng)) THEN
              turb_ef=turb_base(ng)*                                    &
     &                exp(-turb_rate(ng)*(lturb-turb_mean(ng)))
            ELSE
              turb_ef=turb_slop(ng)*lturb+turb_axis(ng)
            END IF
            track(ibrhs,nfp1,l)=grate*gfactor*turb_ef*sec2day
          ELSE
            track(ibrhs,nfp1,l)=larvae_gr0(ng)*gfactor*sec2day
          END IF
          IF (predictor) THEN
            track(isizf,nfp1,l)=track(isizf,nfm3,l)+                    &
     &                          dt(ng)*(cff1*track(ibrhs,nf  ,l)-       &
     &                                  cff2*track(ibrhs,nfm1,l)+       &
     &                                  cff1*track(ibrhs,nfm2,l))
          ELSE
            track(isizf,nfp1,l)=cff1*track(isizf,nf  ,l)-               &
     &                          cff2*track(isizf,nfm2,l)+               &
     &                          dt(ng)*(cff3*track(ibrhs,nfp1,l)+       &
     &                                  cff4*track(ibrhs,nf  ,l)-       &
     &                                  cff3*track(ibrhs,nfm1,l))
          END IF
          lsize=track(isizf,nfp1,l)
!
!  Estimate the fraction of time that the larvae spend swimming.
!
          IF (abs(dsalt).lt.0.00001_r8) THEN
            dsalt=0.0_r8
          END IF
          IF (dsalt.gt.0.0_r8) THEN
            swimtimenew=min(swimtime+dsalt*slope_sinc(ng),swim_tmax(ng))
          ELSE
            swimtimenew=max(swimtime+dsalt*slope_sdec(ng),swim_tmin(ng))
          END IF
!
!  Compute swim behavior as function of larval size and temperature.
!  Linearly interpolate swimming rate (mm/s) from the look table of
!  larval size (um) versus temperature (Celsius).  Notice that
!  extrapolation is suppresed by bounding "Lsize" and "temp" to
!  the range values in the look table.
!
          IF ((temp.lt.swim_t0).or.(lsize.lt.swim_l0)) THEN
            swimrate=0.0_r8
          ELSE
            my_size=min(max(swim_l0,lsize),                             &
     &                  swim_l0+swim_dl*real(swim_im-1,r8))
            my_temp=min(max(swim_t0,temp),                              &
     &                  swim_t0+swim_dt*real(swim_jm-1,r8))
 
            i1=int(1.0_r8+(my_size-swim_l0)*oswim_dl)
            i2=min(i1+1,swim_im)
            j1=int(1.0_r8+(my_temp-swim_t0)*oswim_dt)
            j2=min(j1+1,swim_jm)
 
            p2=(my_size-(swim_l0+real(i1-1,r8)*swim_dl))*oswim_dl
            q2=(my_temp-(swim_t0+real(j1-1,r8)*swim_dt))*oswim_dt
            p1=1.0_r8-p2
            q1=1.0_r8-q2
 
            swimrate=p1*q1*swim_table(i1,j1)+                           &
     &               p2*q1*swim_table(i2,j1)+                           &
     &               p1*q2*swim_table(i1,j2)+                           &
     &               p2*q2*swim_table(i2,j2)
 
            swimrate=swimrate*0.001_r8        ! convert from mm/s to m/s
          END IF
!
!  Compute larvae sinking velocity (m/s).
!
          sink=sink_base(ng)*(exp(sink_rate(ng)*(lsize-sink_size(ng))))
 
          sink=sink*0.001_r8                  ! convert from mm/s to m/s
!
!  Compute larvae vertical velocity (m/s).
!
#ifdef GROWTH_ONLY
          w_bio=0.0_r8
#else
          w_bio=swimtime*swimrate-(1.0_r8-swimtime)*sink
#endif
!
!  Load behavior into track array. Apply settlement condition: larvae
!  greater or equal than SETTLE_SIZE, settle on the bottom.
!
          IF (track(isizf,nfp1,l).lt.settle_size(ng)) THEN
            track(iwbio,nfp1,l)=w_bio
            track(iwsin,nfp1,l)=sink
            track(iswim,nfp1,l)=swimtimenew
          ELSE
            i1=min(max(0,int(track(ixgrd,nfp1,l))),lm(ng)+1)
            i2=min(i1+1,lm(ng)+1)
            j1=min(max(0,int(track(iygrd,nfp1,l))),mm(ng)+1)
            j2=min(j1+1,mm(ng)+1)
 
            p2=real(i2-i1,r8)*(track(ixgrd,nfp1,l)-real(i1,r8))
            q2=real(j2-j1,r8)*(track(iygrd,nfp1,l)-real(j1,r8))
            p1=1.0_r8-p2
            q1=1.0_r8-q2
 
            bottom=p1*q1*grid(ng)%h(i1,j1)+                             &
     &             p2*q1*grid(ng)%h(i2,j1)+                             &
     &             p1*q2*grid(ng)%h(i1,j2)+                             &
     &             p2*q2*grid(ng)%h(i2,j2)
 
            track(idpth,nfp1,l)=-bottom
            track(isizf,nfp1,l)=track(isizf,nf,l)
            track(iwbio,nfp1,l)=0.0_r8
            track(iwsin,nfp1,l)=0.0_r8
            track(iswim,nfp1,l)=0.0_r8
          END IF
!
!  If newly relased float, set vertical migration fields for all time
!  levels.
!
          IF (time(ng)-halfdt.le.tinfo(itstr,l).and.                    &
     &        time(ng)+halfdt.gt.tinfo(itstr,l)) THEN
            brhs=track(ibrhs,nfp1,l)
            sink=track(iwsin,nfp1,l)
            w_bio=track(iwbio,nfp1,l)
            DO i=0,nft
              track(ibrhs,i,l)=brhs
              track(iwsin,i,l)=sink
              track(iwbio,i,l)=w_bio
            END DO
          END IF
 
        END IF
      END DO
!
      RETURN
      END SUBROUTINE oyster_floats_tile
 
      END MODULE biology_floats_mod