ntimestep.F

Go to the documentation of this file.

#include "cppdefs.h"
      SUBROUTINE ntimesteps (model, RunInterval, nl, Nsteps, Rsteps)
!
!git $Id$
!=======================================================================
!  Copyright (c) 2002-2025 The ROMS Group                              !
!    Licensed under a MIT/X style license                              !
!    See License_ROMS.md                                               !
!================================================== Hernan G. Arango ===
!                                                                      !
!  This routine set the number of time-steps to compute. In nesting    !
!  applications,  the number of time-steps depends on nesting layer    !
!  configuration.                                                      !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     model        Calling model identifier (integer)                  !
!     RunInterval  Time interval (seconds) to advance forward or       !
!                    backwards the primitive equations (scalar)        !
!     nl           Nesting layer number (integer)                      !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     nl           Updated nesting layer number (integer)              !
!     Nsteps       Number of time-steps to solve for all grids in      !
!                    current nesting layer "nl" (integer)              !
!     Rsteps       Number of time-steps to complete RunInterval        !
!                    time window (integer)                             !
!                                                                      !
!=======================================================================
!
      USE mod_param
      USE mod_parallel
      USE mod_iounits
#ifdef NESTING
      USE mod_nesting
#endif
      USE mod_scalars
!
!  Imported variable declarations.
!
      integer, intent(in)    :: model
      integer, intent(inout) :: nl
      integer, intent(out)   :: Nsteps, Rsteps
!
      real(dp), intent(in)   :: RunInterval
!
!  Local variable declarations.
!
      integer :: extra, gn, ig, il, ng, ngm1
      integer, dimension(Ngrids) :: WindowSteps, my_Nsteps
 
#if defined MODEL_COUPLING && !defined MCT_LIB
!
      real(dp) :: ENDtime, NEXTtime
#endif
!
!=======================================================================
!  Set number of time steps to execute for grid "ng".
!=======================================================================
!
!  Initialize.
!
      windowsteps=0
      my_nsteps=0
      nsteps=0
      rsteps=0
!
!  If appropriate, advance the nested layer counter.
!
      nl=nl+1
 
#ifdef NESTING
!
!  If refinement and telescoping refined grids, reset the nested layer
!  counter to advance all the grid to the current time of the coarser
!  of all grids (ng=1).
!
     IF (any(telescoping).and.(nl.gt.nestlayers)) THEN
       DO il=1,nestlayers
         DO ig=1,gridsinlayer(il)
           ng=gridnumber(ig,il)
           IF (telescoping(ng).and.                                     &
     &         (refinestepscounter(ng).lt.refinesteps(ng))) THEN
             nl=il
           END IF
         END DO
       END DO
     END IF
#endif
!
     IF ((0.lt.nl).and.(nl.le.nestlayers)) THEN
!
!  In composite and mosaic grids or all grids in the same nesting
!  layer, it is assumed that the donor and receiver grids have the
!  same time-step size. This is done to avoid the time interpolation
!  between donor and receiver grids. Only spatial interpolations
!  are possible in the current nesting design.
!
!  In grid refinement, it is assumed that the donor and receiver grids
!  are an interger factor of the grid size and time-step size.
!
        windowsteps=0
!
!  Loop over all grids in current layer nesting layer.
!
        DO ig=1,gridsinlayer(nl)
          ng=gridnumber(ig,nl)
 
#if defined MODEL_COUPLING && !defined MCT_LIB
!
!  Set extra step parameter needed to finish the simulation due to ROMS
!  delayed output until the next half step. If RunInterval (seconds) is
!  less than full simulation interval because of model coupling, extra=1
!  for last coupling interval and extra=0 otherwise.
!
          nexttime=time(ng)+runinterval
          endtime=initime(ng)+(ntimes(ng)-1)*dt(ng)
          IF (nexttime.eq.endtime) THEN
            extra=1
          ELSE
            extra=0
          END IF
 
#elif defined JEDI
!
! OOPS will advance ROMS kernels by smaller intervals, usually a single
! timestep. The strategy here is different from that used for coupling
! since OOPS controls every NLM, TLM, and ADM timestep. The exchange of
! ROMS-to-JEDI state fields is also done one at a time and, in a delay
! mode, to account for the modification to initial conditions and an
! extra half step to complete the solution.
!
          IF (model.eq.inlm) THEN
            nexttime=time(ng)+runinterval
            endtime=initime(ng)+ntimes(ng)*dt(ng)
            extra=0
          ELSE IF (model.eq.itlm) THEN
            nexttime=time(ng)+runinterval
            endtime=initime(ng)+ntimes(ng)*dt(ng)
            extra=0
          ELSE IF (model.eq.iadm) THEN
            nexttime=time(ng)-runinterval
            endtime=initime(ng)+ntimes(ng)*dt(ng)
            extra=0
          END IF
#else
!
!  Here, extra=1, indicates that the RunInterval is the same as
!  simulation interval.
!
          extra=1
#endif
!
!  Determine number of steps in time-interval window.
!
          windowsteps(ig)=int((runinterval+0.5_r8*dt(ng))/dt(ng))
!
!  Advancing model forward: Nonlinear, tangent linear, and representer
!  models.
!
          IF ((model.eq.inlm).or.                                       &
     &        (model.eq.itlm).or.                                       &
     &        (model.eq.irpm)) THEN
 
#ifdef NESTING
            IF (any(compositegrid(:,ng))) THEN
              IF (step_counter(ng).le.(windowsteps(ig)+extra)) THEN
                my_nsteps(ig)=1
                step_counter(ng)=step_counter(ng)+1
              ELSE
                my_nsteps(ig)=0
              END IF
            ELSE IF (refinedgrid(ng).and.(refinescale(ng).eq.0)) THEN
              refinestepscounter=0    ! The coarser grid, reset counters
              IF (step_counter(ng).le.(windowsteps(ig)+extra)) THEN
                my_nsteps(ig)=1
                step_counter(ng)=step_counter(ng)+1
                refinestepscounter(ng)=refinestepscounter(ng)+1
              ELSE
                my_nsteps(ig)=0
              END IF
            ELSE IF (refinedgrid(ng).and.(refinescale(ng).gt.0)) THEN
              IF (step_counter(ng).le.(windowsteps(ig)+extra)) THEN
                IF (telescoping(ng)) THEN
                  my_nsteps(ig)=1
                  step_counter(ng)=step_counter(ng)+1
                  refinestepscounter(ng)=refinestepscounter(ng)+1
                  DO il=nl+1,nestlayers         ! When a parent steps,
                    gn=gridnumber(ig,il)        ! set all its telescoped
                    IF (telescoping(gn)) THEN   ! children counters to
                      refinestepscounter(gn)=0  ! zero
                    END IF
                  END DO
                ELSE
                  my_nsteps(ig)=refinesteps(ng)
                  step_counter(ng)=step_counter(ng)+refinesteps(ng)
                  refinestepscounter(ng)=refinestepscounter(ng)+        &
     &                                   refinesteps(ng)
                END IF
              ELSE
                my_nsteps(ig)=0
              END IF
            END IF
#else
            my_nsteps(ig)=max(my_nsteps(ig), windowsteps(ig)+extra)
            step_counter(ng)=step_counter(ng)+windowsteps(ig)+extra
#endif
 
#if defined ADJOINT && !defined NESTING
!
!  Advancing model backwards: Adjoint model.
!
          ELSE IF (model.eq.iadm) THEN
            my_nsteps(ig)=max(my_nsteps(ig), windowsteps(ig)+extra)
            step_counter(ng)=step_counter(ng)+windowsteps(ig)+extra
#endif
          END IF
        END DO
!
!  Insure that the steps per time-window are the same.
!
        IF (gridsinlayer(nl).gt.1) THEN
          DO ig=2,gridsinlayer(nl)
            IF (windowsteps(ig).ne.windowsteps(ig-1)) THEN
              ngm1=gridnumber(ig-1,nl)
              ng  =gridnumber(ig  ,nl)
              IF (master) THEN
                WRITE (stdout,10) nl, ngm1, dt(ngm1), ng, dt(ng)
  10            FORMAT (/,' NTIMESTEPS - timestep size are not the ',   &
     &                    ' same in nesting layer: ',i2,                &
     &                  2(/,14x,'Grid ',i2.2,3x,'dt = ',f11.3))
              END IF
              exit_flag=5
            END IF
          END DO
        END IF
!
!  Set number of time-steps to execute. Choose minimum values.
!
        nsteps=my_nsteps(1)
        rsteps=windowsteps(1)+extra
        DO ig=2,gridsinlayer(nl)
          nsteps=min(nsteps, my_nsteps(ig))
          rsteps=min(rsteps, windowsteps(ig)+extra)
        END DO
      END IF
 
      RETURN
      END SUBROUTINE ntimesteps
 
#if defined NESTING && defined ADJOINT
!
      SUBROUTINE nlm_step_sequence (RunInterval, icount)
!
!git $Id$
!================================================== Hernan G. Arango ===
!  Copyright (c) 2002-2025 The ROMS Group            Andrew M. Moore   !
!    Licensed under a MIT/X style license                              !
!    See License_ROMS.md                                               !
!=======================================================================
!                                                                      !
!  Given a time interval window (seconds), this routine stores all the !
!  parameters needed to timestep the adjoint model backwards in nested !
!  applications.  It is an elegant way to have the correct parameters  !
!  in complex setups.                                                  !
!                                                                      !
!  StepInfo(:,1)     NL, current nested layer number                   !
!  StepInfo(:,2)     Nsteps, number of timesteps for grids in NL       !
!  StepInfo(:,3)     Rsteps, number of timesteps for simulation window !
!  StepInfo(:,ng+3)  step_counter(ng), timestep counter for each grid  !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     RunInterval    Time interval window (seconds) to advance forward !
!                      or backwards the primitive equations (scalar)   !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     icount         Number of stored values in "StepInfo" (integer)   !
!                      StepInfo(icount,Ngrid+3)                        !
!                                                                      !
!  It calls repetitively routine "ntimestep".                          !
!                                                                      !
!=======================================================================
!
      USE mod_param
      USE mod_parallel
      USE mod_iounits
      USE mod_nesting
      USE mod_scalars
!
!  Imported variable declarations.
!
      integer, intent(out) :: icount
!
      real(dp), intent(in) :: RunInterval
!
!  Local variable declarations.
!
      logical :: DoNestLayer, Time_Step
      integer :: NL, Nsteps, Rsteps
      integer :: dg, ig, istep, ng
!
!=======================================================================
!  Compute the NLM sequence of nested timesteps parameters.
!=======================================================================
!
!  If applicable, allocate and intialize parameter sequence array.  It
!  can only be allocated in "ROMS_run" phase when the RunInterval value
!  is known, and niot before. That value is specified by the Master or
!  Coupler subroutine. Notice that we use the (rs-1) factor to discount
!  the coarser grid step that other grids need to execute to arrive to
!  the same simulation time.
!
      IF (.not.allocated(stepinfo)) THEN
        dg=1
        rs=1
        DO ng=1,ngrids
          IF (refinescale(ng).gt.0) THEN
            rs=rs*refinescale(ng)
          END IF
        END DO
        nstepinfo=int((runinterval+0.5_r8*dt(dg))/dt(dg))*(rs-1)+       &
     &            ngrids
        allocate ( stepinfo(nstepinfo,ngrids+3) )
        stepinfo=0
      END IF
!
!  Initialize.
!
      time_step=.true.
      donestlayer=.true.
      icount=0
!
!  Compute and store nonlinear model sequence of NL, Nstep, Rstep, and
!  step_counter parameters. The sequence of values will be reversed
!  when timestepping the adjoint model backwards.
!
      DO WHILE (time_step)
        nl=0
        DO WHILE (donestlayer)
          CALL ntimesteps (inlm, runinterval, nl, nsteps, rsteps)
          icount=icount+1
          IF (icount.le.nstepinfo) THEN
            stepinfo(icount,1)=nl
            stepinfo(icount,2)=nsteps
            stepinfo(icount,3)=rsteps
            DO ng=1,ngrids
              stepinfo(icount,ng+3)=step_counter(ng)
            END DO
!
            IF ((nl.le.0).or.(nl.gt.nestlayers)) EXIT
!
            DO istep=1,nsteps
              DO ig=1,gridsinlayer(nl)
                ng=gridnumber(ig,nl)
                IF (step_counter(ng).eq.rsteps) time_step=.false.
              END DO
            END DO
            IF (.not.time_step.and.nl.eq.nestlayers) EXIT
          ELSE
            IF (master) WRITE(stdout,10) ', nStepInfo = ', nstepinfo,   &
     &                                   icount
            exit_flag=5
            RETURN
          END IF
        END DO
      END DO
!
  10  FORMAT (/,' NLM_STEP_SEQUENCE - too small dimension parameter ',  &
     &        a,i0,3x,i0,/,21x,'Recompute dimensions for ''StepInfo''')
!
      RETURN
      END SUBROUTINE nlm_step_sequence
#endif