correlation.h

Go to the documentation of this file.

      MODULE roms_kernel_mod
!
!git $Id$
!================================================== Hernan G. Arango ===
!  Copyright (c) 2002-2025 The ROMS Group                              !
!    Licensed under a MIT/X style license                              !
!    See License_ROMS.md                                               !
!=======================================================================
!                                                                      !
!  ROMS 4DVAR Background-error Correlation Model                       !
!                                                                      !
!  This driver is used to build and test the 4DVAR background-error    !
!  correlation model using a generalized difussion operator:           !
!                                                                      !
!            B = S C S                                                 !
!                                                                      !
!            C = C^(1/2) C^(T/2)                                       !
!                                                                      !
!      C^(1/2) = G L^(1/2) W^(-1/2)                                    !
!                                                                      !
!      C^(T/2) = W^(T/2) L^(T/2) G                                     !
!                                                                      !
!  where                                                               !
!                                                                      !
!         B : background-error covariance                              !
!         C : background-error correlation                             !
!         G : normalization coefficient matrix                         !
!         L : self-adjoint diffusion filter                            !
!         S : background-error standard deviation                      !
!         W : Grid cell area or volume diagonal matrix                 !
!                                                                      !
!  The routines in this driver control the initialization,  time-      !
!  stepping, and finalization of  ROMS  model following ESMF           !
!  conventions:                                                        !
!                                                                      !
!     ROMS_initialize                                                  !
!     ROMS_run                                                         !
!     ROMS_finalize                                                    !
!                                                                      !
!  Reference                                                           !
!                                                                      !
!     Weaver, A. and P. Courtier, 2001: Correlation modelling on       !
!       the sphere using a generalized diffusion equation, Q. J.       !
!       R. Meteorol. Soc., 127, 1815-1845.                             !
!                                                                      !
!=======================================================================
!
      USE mod_param
      USE mod_parallel
      USE mod_arrays
      USE mod_fourdvar
      USE mod_iounits
      USE mod_ncparam
      USE mod_scalars
      USE mod_stepping
!
#ifdef BALANCE_OPERATOR
      USE ad_balance_mod,     ONLY : ad_balance
#endif
      USE ad_convolution_mod, ONLY : ad_convolution
      USE ad_def_his_mod,     ONLY : ad_def_his
      USE ad_variability_mod, ONLY : ad_variability
      USE ad_wrt_his_mod,     ONLY : ad_wrt_his
      USE analytical_mod,     ONLY : ana_perturb
      USE close_io_mod,       ONLY : close_inp, close_out
      USE def_norm_mod,       ONLY : def_norm
      USE get_state_mod,      ONLY : get_state
      USE ini_adjust_mod,     ONLY : load_adtotl
      USE ini_adjust_mod,     ONLY : load_tltoad
      USE inp_par_mod,        ONLY : inp_par
      USE normalization_mod,  ONLY : normalization
      USE stdout_mod,         ONLY : set_stdoutunit, stdout_unit
      USE strings_mod,        ONLY : founderror
#ifdef BALANCE_OPERATOR
      USE tl_balance_mod,     ONLY : tl_balance
#endif
      USE tl_convolution_mod, ONLY : tl_convolution
      USE tl_variability_mod, ONLY : tl_variability
      USE strings_mod,        ONLY : founderror
      USE wrt_rst_mod,        ONLY : wrt_rst
#if defined BALANCE_OPERATOR && defined ZETA_ELLIPTIC
      USE zeta_balance_mod,   ONLY : balance_ref, biconj
#endif
!
      implicit none
!
      PUBLIC :: roms_initialize
      PUBLIC :: roms_run
      PUBLIC :: roms_finalize
!
      CONTAINS
!
      SUBROUTINE roms_initialize (first, mpiCOMM)
!
!=======================================================================
!                                                                      !
!  This routine allocates and initializes ROMS state variables         !
!  and internal and external parameters.                               !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      logical, intent(inout) :: first
!
      integer, intent(in), optional :: mpiCOMM
!
!  Local variable declarations.
!
      logical :: allocate_vars = .true.
!
#ifdef DISTRIBUTE
      integer :: MyError, MySize
#endif
      integer :: STDrec, Tindex
      integer :: chunk_size, ng, thread, tile
#ifdef _OPENMP
      integer :: my_threadnum
#endif
!
      character (len=*), parameter :: MyFile =                          &
     &  __FILE__//", ROMS_initialize"
 
#ifdef DISTRIBUTE
!
!-----------------------------------------------------------------------
!  Set distribute-memory (mpi) world communicator.
!-----------------------------------------------------------------------
!
      IF (PRESENT(mpicomm)) THEN
        ocn_comm_world=mpicomm
      ELSE
        ocn_comm_world=mpi_comm_world
      END IF
      CALL mpi_comm_rank (ocn_comm_world, myrank, myerror)
      CALL mpi_comm_size (ocn_comm_world, mysize, myerror)
#endif
!
!-----------------------------------------------------------------------
!  On first pass, initialize model parameters a variables for all
!  nested/composed grids.  Notice that the logical switch "first"
!  is used to allow multiple calls to this routine during ensemble
!  configurations.
!-----------------------------------------------------------------------
!
      IF (first) THEN
        first=.false.
!
!  Initialize parallel control switches. These scalars switches are
!  independent from standard input parameters.
!
        CALL initialize_parallel
!
!  Set the ROMS standard output unit to write verbose execution info.
!  Notice that the default standard out unit in Fortran is 6.
!
!  In some applications like coupling or disjointed mpi-communications,
!  it is advantageous to write standard output to a specific filename
!  instead of the default Fortran standard output unit 6. If that is
!  the case, it opens such formatted file for writing.
!
        IF (set_stdoutunit) THEN
          stdout=stdout_unit(master)
          set_stdoutunit=.false.
        END IF
!
!  Read in model tunable parameters from standard input. Allocate and
!  initialize variables in several modules after the number of nested
!  grids and dimension parameters are known.
!
        CALL inp_par (inlm)
        IF (founderror(exit_flag, noerror, __line__, myfile)) RETURN
!
!  Set domain decomposition tile partition range.  This range is
!  computed only once since the "first_tile" and "last_tile" values
!  are private for each parallel thread/node.
!
#if defined _OPENMP
      mythread=my_threadnum()
#elif defined DISTRIBUTE
      mythread=myrank
#else
      mythread=0
#endif
      DO ng=1,ngrids
        chunk_size=(ntilex(ng)*ntilee(ng)+numthreads-1)/numthreads
        first_tile(ng)=mythread*chunk_size
        last_tile(ng)=first_tile(ng)+chunk_size-1
      END DO
!
!  Initialize internal wall clocks. Notice that the timings does not
!  includes processing standard input because several parameters are
!  needed to allocate clock variables.
!
        IF (master) THEN
          WRITE (stdout,10)
 10       FORMAT (/,' Process Information:',/)
        END IF
!
        DO ng=1,ngrids
          DO thread=thread_range
            CALL wclock_on (ng, inlm, 0, __line__, myfile)
          END DO
        END DO
!
!  Allocate and initialize modules variables.
!
        CALL roms_allocate_arrays (allocate_vars)
        CALL roms_initialize_arrays
        IF (founderror(exit_flag, noerror, __line__, myfile)) RETURN
 
      END IF
!
!-----------------------------------------------------------------------
!  Initialize metrics over all nested grids, if applicable.
!-----------------------------------------------------------------------
!
      CALL initial
      IF (founderror(exit_flag, noerror, __line__, myfile)) RETURN
!
!  Adjust "time" variable since we are not time-stepping.
!
      DO ng=1,ngrids
        time(ng)=time(ng)+dt(ng)
      END DO
!
!  Initialize run or ensemble counter.
!
      nrun=1
!
!-----------------------------------------------------------------------
!  Read in standard deviation factors for error covariance.
!-----------------------------------------------------------------------
!
!  Initial conditions standard deviation. They are loaded in Tindex=1
!  of the e_var(...,Tindex) state variables.
!
      stdrec=1
      tindex=1
      DO ng=1,ngrids
        IF (ldefnrm(1,ng).or.lwrtnrm(1,ng)) THEN
          CALL get_state (ng, 10, 10, std(1,ng), stdrec, tindex)
          IF (founderror(exit_flag, noerror, __line__, myfile)) RETURN
        END IF
      END DO
!
!  Model error standard deviation. They are loaded in Tindex=2
!  of the e_var(...,Tindex) state variables.
!
      stdrec=1
      tindex=2
      DO ng=1,ngrids
        IF ((ldefnrm(2,ng).or.lwrtnrm(2,ng)).and.(nsa.eq.2)) THEN
          CALL get_state (ng, 11, 11, std(2,ng), stdrec, tindex)
          IF (founderror(exit_flag, noerror, __line__, myfile)) RETURN
        END IF
      END DO
 
#ifdef ADJUST_BOUNDARY
!
!  Open boundary conditions standard deviation.
!
      stdrec=1
      tindex=1
      DO ng=1,ngrids
        IF (ldefnrm(3,ng).or.lwrtnrm(3,ng)) THEN
          CALL get_state (ng, 12, 12, std(3,ng), stdrec, tindex)
          IF (founderror(exit_flag, noerror, __line__, myfile)) RETURN
        END IF
      END DO
#endif
#if defined ADJUST_WSTRESS || defined ADJUST_STFLUX
!
!  Surface forcing standard deviation.
!
      stdrec=1
      tindex=1
      DO ng=1,ngrids
        IF (ldefnrm(4,ng).or.lwrtnrm(4,ng)) THEN
          CALL get_state (ng, 13, 13, std(4,ng), stdrec, tindex)
          IF (founderror(exit_flag, noerror, __line__, myfile)) RETURN
        END IF
      END DO
#endif
!
!-----------------------------------------------------------------------
!  Compute or read in error covariance normalization factors.
!-----------------------------------------------------------------------
!
!  If computing, write out factors to NetCDF. This is an expensive
!  computation and needs to be computed once for a particular
!  application grid.
!
      DO ng=1,ngrids
        IF (any(lwrtnrm(:,ng))) THEN
          IF (ldefnrm(1,ng).or.lwrtnrm(1,ng)) THEN
            CALL def_norm (ng, inlm, 1)
            IF (founderror(exit_flag, noerror, __line__, myfile)) RETURN
          END IF
 
          IF ((ldefnrm(2,ng).or.lwrtnrm(2,ng)).and.(nsa.eq.2)) THEN
            CALL def_norm (ng, inlm, 2)
          IF (founderror(exit_flag, noerror, __line__, myfile)) RETURN
          END IF
#ifdef ADJUST_BOUNDARY
          IF (ldefnrm(3,ng).or.lwrtnrm(3,ng)) THEN
            CALL def_norm (ng, inlm, 3)
            IF (founderror(exit_flag, noerror, __line__, myfile)) RETURN
          END IF
#endif
#if defined ADJUST_WSTRESS || defined ADJUST_STFLUX
          IF (ldefnrm(4,ng).or.lwrtnrm(4,ng)) THEN
            CALL def_norm (ng, inlm, 4)
            IF (founderror(exit_flag, noerror, __line__, myfile)) RETURN
          END IF
#endif
          IF (founderror(exit_flag, noerror, __line__, myfile)) RETURN
          DO tile=first_tile(ng),last_tile(ng),+1
            CALL normalization (ng, tile, 2)
          END DO
          ldefnrm(1:4,ng)=.false.
          lwrtnrm(1:4,ng)=.false.
        END IF
      END DO
!
      RETURN
      END SUBROUTINE roms_initialize
!
      SUBROUTINE roms_run (RunInterval)
!
!=======================================================================
!                                                                      !
!  This routine computes background-error correlations.                !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      real(dp), intent(in) :: RunInterval            ! seconds
!
!  Local variable declarations.
!
      logical :: Lweak, add
      integer :: i, ng, tile
#ifdef BALANCE_OPERATOR
      integer :: Lbck = 1
#endif
!
      character (len=*), parameter :: MyFile =                          &
     &  __FILE__//", ROMS_run"
!
!-----------------------------------------------------------------------
!  Test correlation model.
!-----------------------------------------------------------------------
 
#ifdef BALANCE_OPERATOR
!
!  Read background state, use initial conditions.
!
      DO ng=1,ngrids
        CALL get_state (ng, inlm, 9, ini(ng), lbck, lbck)
        IF (founderror(exit_flag, noerror, __line__, myfile)) RETURN
      END DO
 
# ifdef ZETA_ELLIPTIC
!
!  Compute the reference zeta and biconjugate gradient arrays
!  required for the balance of free surface.
!
      IF (balance(isfsur)) THEN
        DO ng=1,ngrids
          DO tile=first_tile(ng),last_tile(ng),+1
            CALL balance_ref (ng, tile, lbck)
            CALL biconj (ng, tile, inlm, lbck)
          END DO
          wrtzetaref(ng)=.true.
        END DO
      END IF
# endif
#endif
!
!  Initialize adjoint model state with a delta function at specified
!  point. Use USER parameters from standard input to perturb solution
!  in routine "ana_perturb". Then, convolve solution with the adjoint
!  diffusion operator.
!
      admodel=.true.
      lweak=.false.
 
      DO ng=1,ngrids
        lnew(ng)=1
        DO tile=first_tile(ng),last_tile(ng),+1
          CALL ana_perturb (ng, tile, iadm)
#ifdef BALANCE_OPERATOR
          CALL ad_balance (ng, tile, lbck, lnew(ng))
          CALL ad_variability (ng, tile, lnew(ng), lweak)
#endif
          CALL ad_convolution (ng, tile, lnew(ng), lweak, 2)
        END DO
 
        admodel=.false.
!
!  Initialize tangent linear model with convolved adjoint solution.
!  Then, apply tangent linear convolution.
!
        add=.false.
        DO tile=first_tile(ng),last_tile(ng),+1
          CALL load_adtotl (ng, tile, lnew(ng), lnew(ng), add)
          CALL tl_convolution (ng, tile, lnew(ng), lweak, 2)
#ifdef BALANCE_OPERATOR
          CALL tl_variability (ng, tile, lnew(ng), lweak)
          CALL tl_balance (ng, tile, lbck, lnew(ng))
#endif
          CALL load_tltoad (ng, tile, lnew(ng), lnew(ng), add)
        END DO
      END DO
!
!  Write out background error correlation in adjoint history NetCDF
!  file.
!
      DO ng=1,ngrids
        kstp(ng)=lnew(ng)
#ifdef SOLVE3D
        nstp(ng)=lnew(ng)
#endif
        ldefadj(ng)=.true.
        lwrtadj(ng)=.true.
        lwrtstate2d(ng)=.true.
        CALL ad_def_his (ng, ldefadj(ng))
        IF (founderror(exit_flag, noerror, __line__, myfile)) RETURN
#if defined ADJUST_STFLUX || defined ADJUST_WSTRESS
        ladjusted(ng)=.true.
#endif
#ifdef DISTRIBUTE
        CALL ad_wrt_his (ng, myrank)
#else
        CALL ad_wrt_his (ng, -1)
#endif
        IF (founderror(exit_flag, noerror, __line__, myfile)) RETURN
#if defined ADJUST_STFLUX || defined ADJUST_WSTRESS
        ladjusted(ng)=.false.
#endif
      END DO
!
      RETURN
      END SUBROUTINE roms_run
!
      SUBROUTINE roms_finalize
!
!=======================================================================
!                                                                      !
!  This routine terminates ROMS driver execution.                      !
!                                                                      !
!=======================================================================
!
!  Local variable declarations.
!
      integer :: Fcount, ng, thread
!
      character (len=*), parameter :: MyFile =                          &
     &  __FILE__//", ROMS_finalize"
!
!-----------------------------------------------------------------------
!  If blowing-up, save latest model state into RESTART NetCDF file.
!-----------------------------------------------------------------------
!
!  If cycling restart records, write solution into record 3.
!
      IF (exit_flag.eq.1) THEN
        DO ng=1,ngrids
          IF (lwrtrst(ng)) THEN
            IF (master) WRITE (stdout,10)
 10         FORMAT (/,' Blowing-up: Saving latest model state into ',   &
     &                ' RESTART file',/)
            fcount=rst(ng)%load
            IF (lcyclerst(ng).and.(rst(ng)%Nrec(fcount).ge.2)) THEN
              rst(ng)%Rindex=2
              lcyclerst(ng)=.false.
            END IF
            blowup=exit_flag
            exit_flag=noerror
#ifdef DISTRIBUTE
            CALL wrt_rst (ng, myrank)
#else
            CALL wrt_rst (ng, -1)
#endif
          END IF
        END DO
      END IF
!
!-----------------------------------------------------------------------
!  Stop model and time profiling clocks, report memory requirements, and
!  close output NetCDF files.
!-----------------------------------------------------------------------
!
!  Stop time clocks.
!
      IF (master) THEN
        WRITE (stdout,20)
 20     FORMAT (/,'Elapsed wall CPU time for each process (seconds):',/)
      END IF
!
      DO ng=1,ngrids
        DO thread=thread_range
          CALL wclock_off (ng, inlm, 0, __line__, myfile)
        END DO
      END DO
!
!  Report dynamic memory and automatic memory requirements.
!
      CALL memory
!
!  Close IO files.
!
      DO ng=1,ngrids
        CALL close_inp (ng, inlm)
      END DO
      CALL close_out
!
      RETURN
      END SUBROUTINE roms_finalize
 
      END MODULE roms_kernel_mod