biology_floats_mod Module Reference

Functions/Subroutines
subroutine, public	biology_floats (ng, lstr, lend, predictor, my_thread)
subroutine	oyster_floats_tile (ng, lstr, lend, nfm3, nfm2, nfm1, nf, nfp1, predictor, my_thread, bounded, tinfo, track)

Function/Subroutine Documentation

biology_floats()

subroutine, public biology_floats_mod::biology_floats	(	integer, intent(in)	ng,
		integer, intent(in)	lstr,
		integer, intent(in)	lend,
		logical, intent(in)	predictor,
		logical, dimension(lstr:lend), intent(in)	my_thread )

Definition at line 78 of file oyster_floats.h.

!***********************************************************************
!
      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

References mod_floats::drifter, mod_param::inlm, mod_stepping::nf, mod_stepping::nfm1, mod_stepping::nfm2, mod_stepping::nfm3, mod_stepping::nfp1, oyster_floats_tile(), wclock_off(), and wclock_on().

Referenced by step_floats_mod::step_floats_tile().

Here is the call graph for this function:

Here is the caller graph for this function:

oyster_floats_tile()

subroutine biology_floats_mod::oyster_floats_tile ( integer, intent(in) ng, integer, intent(in) lstr, integer, intent(in) lend, integer, intent(in) nfm3, integer, intent(in) nfm2, integer, intent(in) nfm1, integer, intent(in) nf, integer, intent(in) nfp1, logical, intent(in) predictor, logical, dimension(lstr:lend), intent(in) my_thread, logical, dimension(nfloats(ng)), intent(in) bounded, real(r8), dimension(0:izrhs,nfloats(ng)), intent(in) tinfo, real(r8), dimension(nfv(ng),0:nft,nfloats(ng)), intent(inout) track )

private

Definition at line 119 of file oyster_floats.h.

!***********************************************************************
!
      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

References mod_scalars::dt, mod_behavior::food_supply, mod_behavior::gfactor_ds, mod_behavior::gfactor_dt, mod_behavior::gfactor_im, mod_behavior::gfactor_jm, mod_behavior::gfactor_s0, mod_behavior::gfactor_t0, mod_behavior::gfactor_table, mod_behavior::grate_df, mod_behavior::grate_dl, mod_behavior::grate_f0, mod_behavior::grate_im, mod_behavior::grate_jm, mod_behavior::grate_l0, mod_behavior::grate_table, mod_grid::grid, mod_floats::ibrhs, mod_floats::idpth, mod_floats::iftvar, mod_scalars::isalt, mod_floats::isizf, mod_floats::iswim, mod_scalars::itemp, mod_floats::itstr, mod_floats::iwbio, mod_floats::iwsin, mod_floats::ixgrd, mod_floats::iygrd, mod_behavior::larvae_gr0, mod_behavior::larvae_size0, mod_param::lm, mod_param::mm, mod_scalars::sec2day, mod_behavior::settle_size, mod_behavior::sink_base, mod_behavior::sink_rate, mod_behavior::sink_size, mod_behavior::slope_sdec, mod_behavior::slope_sinc, mod_behavior::swim_dl, mod_behavior::swim_dt, mod_behavior::swim_im, mod_behavior::swim_jm, mod_behavior::swim_l0, mod_behavior::swim_t0, mod_behavior::swim_table, mod_behavior::swim_tmax, mod_behavior::swim_tmin, mod_scalars::time, mod_behavior::turb_ambi, mod_behavior::turb_axis, mod_behavior::turb_base, mod_behavior::turb_crit, mod_behavior::turb_mean, mod_behavior::turb_rate, mod_behavior::turb_size, and mod_behavior::turb_slop.

Referenced by biology_floats().

Here is the caller graph for this function: