oyster_floats_inp.h File Reference

Go to the source code of this file.

Functions/Subroutines
subroutine	read_fltbiopar (model, inp, out, lwrite)

Function/Subroutine Documentation

read_fltbiopar()

subroutine read_fltbiopar	(	integer, intent(in)	model,
		integer, intent(in)	inp,
		integer, intent(in)	out,
		logical, intent(in)	lwrite )

Definition at line 1 of file oyster_floats_inp.h.

!
!git $Id$
!================================================== Hernan G. Arango ===
!  Copyright (c) 2002-2025 The ROMS Group                              !
!    Licensed under a MIT/X style license                              !
!    See License_ROMS.md                                               !
!=======================================================================
!                                                                      !
!  This routine reads in input biological floats parameters.           !
!                                                                      !
!=======================================================================
!
      USE mod_param
      USE mod_parallel
      USE mod_behavior
      USE mod_iounits
      USE mod_ncparam
      USE mod_scalars
!
      USE inp_decode_mod
!
      implicit none
!
!  Imported variable declarations
!
      logical, intent(in) :: Lwrite
      integer, intent(in) :: model, inp, out
!
!  Local variable declarations.
!
      integer :: Npts, Nval
      integer :: i, j, igrid, mc, nc, ng, status
      integer :: Ivalue(1)
 
      real(r8) :: Rvalue(1)
 
      real(dp), dimension(nRval) :: Rval
 
      character (len=35) :: frmt
      character (len=40) :: KeyWord
      character (len=256) :: line
      character (len=256), dimension(nCval) :: Cval
 
      character (len=1 ), parameter :: blank = ' '
!
!-----------------------------------------------------------------------
!  Read in initial float locations.
!-----------------------------------------------------------------------
!
!  Allocate oyster model parameter.
!
      CALL allocate_behavior
!
!  Notice I added one when allocating local scratch arrays to avoid
!  out of bounds in some compilers when reading the last blank line
!  which signal termination of input data.
!
      DO WHILE (.true.)
        READ (inp,'(a)',err=10,END=30) line
        status=decode_line(line, keyword, nval, cval, rval)
        IF (status.gt.0) THEN
          SELECT CASE (trim(keyword))
            CASE ('Larvae_size0')
              npts=load_r(nval, rval, ngrids, larvae_size0)
            CASE ('Larvae_GR0')
              npts=load_r(nval, rval, ngrids, larvae_gr0)
            CASE ('settle_size')
              npts=load_r(nval, rval, ngrids, settle_size)
            CASE ('food_supply')
              npts=load_r(nval, rval, ngrids, food_supply)
            CASE ('turb_ambi')
              npts=load_r(nval, rval, ngrids, turb_ambi)
            CASE ('turb_crit')
              npts=load_r(nval, rval, ngrids, turb_crit)
            CASE ('turb_slop')
              npts=load_r(nval, rval, ngrids, turb_slop)
            CASE ('turb_axis')
              npts=load_r(nval, rval, ngrids, turb_axis)
            CASE ('turb_base')
              npts=load_r(nval, rval, ngrids, turb_base)
            CASE ('turb_rate')
              npts=load_r(nval, rval, ngrids, turb_rate)
            CASE ('turb_mean')
              npts=load_r(nval, rval, ngrids, turb_mean)
            CASE ('turb_size')
              npts=load_r(nval, rval, ngrids, turb_size)
            CASE ('swim_Tmin')
              npts=load_r(nval, rval, ngrids, swim_tmin)
            CASE ('swim_Tmax')
              npts=load_r(nval, rval, ngrids, swim_tmax)
            CASE ('swim_Sinc')
              npts=load_r(nval, rval, ngrids, swim_sinc)
            CASE ('swim_Sdec')
              npts=load_r(nval, rval, ngrids, swim_sdec)
            CASE ('slope_Sinc')
              npts=load_r(nval, rval, ngrids, slope_sinc)
            CASE ('slope_Sdec')
              npts=load_r(nval, rval, ngrids, slope_sdec)
            CASE ('sink_base')
              npts=load_r(nval, rval, ngrids, sink_base)
            CASE ('sink_rate')
              npts=load_r(nval, rval, ngrids, sink_rate)
            CASE ('sink_size')
              npts=load_r(nval, rval, ngrids, sink_size)
            CASE ('swim_Im')
              npts=load_i(nval, rval, 1, ivalue)
              swim_im=ivalue(1)
            CASE ('swim_Jm')
              npts=load_i(nval, rval, 1, ivalue)
              swim_jm=ivalue(1)
            CASE ('swim_L0')
              npts=load_r(nval, rval, 1, rvalue)
              swim_l0=rvalue(1)
            CASE ('swim_T0')
              npts=load_r(nval, rval, 1, rvalue)
              swim_t0=rvalue(1)
            CASE ('swim_DL')
              npts=load_r(nval, rval, 1, rvalue)
              swim_dl=rvalue(1)
            CASE ('swim_DT')
              npts=load_r(nval, rval, 1, rvalue)
              swim_dt=rvalue(1)
            CASE ('swim_table')
              IF (.not.allocated(swim_table)) THEN
                allocate ( swim_table(swim_im,swim_jm) )
                swim_table=0.0_r8
                dmem(1)=dmem(1)+real(swim_im*swim_jm,r8)
              END IF
              READ (inp,*,err=20,END=30)                                &
                   ((swim_table(i,j),i=1,swim_im),j=1,swim_jm)
            CASE ('Gfactor_Im')
              npts=load_i(nval, rval, 1, ivalue)
              gfactor_im=ivalue(1)
            CASE ('Gfactor_Jm')
              npts=load_i(nval, rval, 1, ivalue)
              gfactor_jm=ivalue(1)
            CASE ('Gfactor_S0')
              npts=load_r(nval, rval, 1, rvalue)
              gfactor_s0=rvalue(1)
            CASE ('Gfactor_T0')
              npts=load_r(nval, rval, 1, rvalue)
              gfactor_t0=rvalue(1)
            CASE ('Gfactor_DS')
              npts=load_r(nval, rval, 1, rvalue)
              gfactor_ds=rvalue(1)
            CASE ('Gfactor_DT')
              npts=load_r(nval, rval, 1, rvalue)
              gfactor_dt=rvalue(1)
            CASE ('Gfactor_table')
              IF (.not.allocated(gfactor_table)) THEN
                allocate ( gfactor_table(gfactor_im,gfactor_jm) )
                gfactor_table=0.0_r8
                dmem(1)=dmem(1)+real(gfactor_im*gfactor_jm)
              END IF
              READ (inp,*,err=20,END=30)                                &
                   ((gfactor_table(i,j),i=1,gfactor_im),j=1,gfactor_jm)
            CASE ('Grate_Im')
              npts=load_i(nval, rval, 1, ivalue)
              grate_im=ivalue(1)
            CASE ('Grate_Jm')
              npts=load_i(nval, rval, 1, ivalue)
              grate_jm=ivalue(1)
            CASE ('Grate_F0')
              npts=load_r(nval, rval, 1, rvalue)
              grate_f0=rvalue(1)
            CASE ('Grate_L0')
              npts=load_r(nval, rval, 1, rvalue)
              grate_l0=rvalue(1)
            CASE ('Grate_DF')
              npts=load_r(nval, rval, 1, rvalue)
              grate_df=rvalue(1)
            CASE ('Grate_DL')
              npts=load_r(nval, rval, 1, rvalue)
              grate_dl=rvalue(1)
            CASE ('Grate_table')
              IF (.not.allocated(grate_table)) THEN
                allocate ( grate_table(grate_im,grate_jm) )
                grate_table=0.0_r8
                dmem(1)=dmem(1)+real(grate_im*grate_jm,r8)
              END IF
              READ (inp,*,err=20,END=30)                                &
                   ((grate_table(i,j),i=1,grate_im),j=1,grate_jm)
          END SELECT
        END IF
      END DO
  10  IF (master) WRITE (out,40) line
      exit_flag=4
      RETURN
  20  IF (master) WRITE (out,50) trim(keyword)
      exit_flag=4
      RETURN
  30  CLOSE (inp)
!
!-----------------------------------------------------------------------
!  Report input parameters.
!-----------------------------------------------------------------------
!
      IF (master.and.lwrite) THEN
        DO ng=1,ngrids
          WRITE (out,60) ng
          WRITE (out,70) larvae_size0(ng), 'Larvae_size0',              &
     &          'Initial larvae size (um).'
          WRITE (out,70) larvae_gr0(ng), 'Larvae_GR0',                  &
     &          'Initial larvae growth rate (um/day).'
          WRITE (out,70) settle_size(ng), 'settle_size',                &
     &          'Larvae settlement size (um).'
          WRITE (out,70) food_supply(ng), 'food_supply',                &
     &          'Food supply (mg Carbon/l).'
          WRITE (out,70) turb_ambi(ng), 'turb_ambi',                    &
     &          'Ambient turbidity level (g/l).'
          WRITE (out,70) turb_crit(ng), 'turb_crit',                    &
     &          'Critical turbidity value (g/l).'
          WRITE (out,70) turb_slop(ng), 'turb_slop',                    &
     &          'Turbidity linear slope (l/g).'
          WRITE (out,70) turb_axis(ng), 'turb_axis',                    &
     &          'Turbidity linear axis crossing (g/l).'
          WRITE (out,70) turb_base(ng), 'turb_base',                    &
     &          'Turbidity exponential base factor (g/l).'
          WRITE (out,70) turb_rate(ng), 'turb_rate',                    &
     &          'Turbidity exponential rate (l/g).'
          WRITE (out,70) turb_mean(ng), 'turb_mean',                    &
     &          'Turbidity exponential mean (g/l).'
          WRITE (out,70) turb_size(ng), 'turb_size',                    &
     &          'Minimum larvae size (um) affected by turbidity.'
          WRITE (out,70) swim_tmin(ng), 'swim_Tmin',                    &
     &          'Minimum swimming time fraction.'
          WRITE (out,70) swim_tmax(ng), 'swim_Tmax',                    &
     &          'Maximum swimming time fraction.'
          WRITE (out,70) swim_sinc(ng), 'swim_Sinc',                    &
     &          'Swimming, active fraction due to increasing salinity.'
          WRITE (out,70) swim_sdec(ng), 'swim_Sdec',                    &
     &          'Swimming, active fraction due to decreasing salinity.'
          WRITE (out,70) slope_sinc(ng), 'slope_Sinc',                  &
     &          'Swimming, coefficient due to increasing salinity.'
          WRITE (out,70) slope_sdec(ng), 'slope_Sdec',                  &
     &          'Swimming, coefficient due to increasing salinity.'
          WRITE (out,70) sink_base(ng), 'sink_base',                    &
     &          'Sinking, exponential base factor (mm/s).'
          WRITE (out,70) sink_rate(ng), 'sink_rate',                    &
     &          'Sinking, exponential rate factor (1/um).'
          WRITE (out,70) sink_size(ng), 'sink_mean',                    &
     &          'Sinking, exponential mean size (um).'
          WRITE (out,80) swim_im, 'swim_Im',                            &
     &          'Swim table, number of values in larval size I-axis.'
          WRITE (out,80) swim_jm, 'swim_Jm',                            &
     &          'Swim table, number of values in temperature J-axis.'
          WRITE (out,70) swim_l0, 'swim_L0',                            &
     &          'Swim table, starting value for larval size I-axis.'
          WRITE (out,70) swim_t0, 'swim_T0',                            &
     &          'Swim table, starting value for temperature J-axis.'
          WRITE (out,70) swim_dl, 'swim_DL',                            &
     &          'Swim table, larval size I-axis increment.'
          WRITE (out,70) swim_dt, 'swim_DT',                            &
     &          'Swim table, temperature J-axis increment.'
          WRITE (out,80) gfactor_im, 'Gfactor_Im',                      &
     &          'Gfactor table, number of values in salinity I-axis.'
          WRITE (out,80) gfactor_jm, 'Gfactor_Jm',                      &
     &          'Gfactor table, number of values in temperature J-axis.'
          WRITE (out,70) gfactor_s0, 'Gfactor_S0',                      &
     &          'Gfactor table, starting value for salinity I-axis.'
          WRITE (out,70) gfactor_t0, 'Gfactor_T0',                      &
     &          'Gfactor table, starting value for temperature J-axis.'
          WRITE (out,70) gfactor_ds, 'Gfactor_DS',                      &
     &          'Gfactor table, starting value for salinity I-axis.'
          WRITE (out,70) gfactor_dt, 'Gfactor_DT',                      &
     &          'Gfactor table, starting value for temperature J-axis.'
          WRITE (out,80) grate_im, 'Grate_Im',                          &
     &          'Grate table, number of values in food supply I-axis.'
          WRITE (out,80) grate_jm, 'Grate_Jm',                          &
     &          'Grate table, number of values in larval size J-axis.'
          WRITE (out,70) grate_f0, 'Grate_F0',                          &
     &          'Grate table, starting value for food supply I-axis.'
          WRITE (out,70) grate_l0, 'Grate_L0',                          &
     &          'Grate table, starting value for larval size J-axis.'
          WRITE (out,70) grate_df, 'Grate_DF',                          &
     &          'Grate table, food supply I-axis increment.'
          WRITE (out,70) grate_dl, 'Grate_DL',                          &
     &          'Grate table, larval size J-axis increment.'
        END DO
      END IF
 
  40  FORMAT (/,' READ_FloatsBioPar - Error while processing line: ',/, &
     &        a)
  50  FORMAT (/,' READ_FloatsBioPar - Error reading look table: ',a)
  60  FORMAT (/,/,' Biological Floats Behavior Parameters, Grid: ',i2.2,&
     &        /,  ' ===============================================',/)
  70  FORMAT (1p,e11.4,2x,a,t32,a)
  80  FORMAT (1x,i10,2x,a,t32,a)
 
      RETURN

References mod_behavior::allocate_behavior(), and mod_iounits::err.

Referenced by inp_par_mod::inp_par().

Here is the call graph for this function:

Here is the caller graph for this function: