New URL for NEMO forge!   http://forge.nemo-ocean.eu

Since March 2022 along with NEMO 4.2 release, the code development moved to a self-hosted GitLab.
This present forge is now archived and remained online for history.
Changeset 13286 for NEMO/trunk/src/OCE/LBC – NEMO

Ignore:
Timestamp:
2020-07-09T17:48:29+02:00 (4 years ago)
Author:
smasson
Message:

trunk: merge extra halos branch in trunk, see #2366

Location:
NEMO/trunk
Files:
13 edited
1 copied

Legend:

Unmodified
Added
Removed
  • NEMO/trunk

    • Property svn:externals
      •  

        old new  
        22^/utils/build/makenemo@HEAD   makenemo 
        33^/utils/build/mk@HEAD         mk 
        4 ^/utils/tools/@HEAD           tools 
         4^/utils/tools@HEAD            tools 
        55^/vendors/AGRIF/dev_r12970_AGRIF_CMEMS      ext/AGRIF 
        66^/vendors/FCM@HEAD            ext/FCM 
         
        88 
        99# SETTE 
        10 ^/utils/CI/sette@12931        sette 
         10^/utils/CI/r12931_sette_ticket2366@HEAD  sette 
  • NEMO/trunk/src/OCE/LBC/lbc_lnk_multi_generic.h90

    r13226 r13286  
    3939      &                    , pt5, cdna5, psgn5, pt6 , cdna6 , psgn6 , pt7 , cdna7 , psgn7 , pt8, cdna8, psgn8   & 
    4040      &                    , pt9, cdna9, psgn9, pt10, cdna10, psgn10, pt11, cdna11, psgn11                      & 
    41       &                    , kfillmode, pfillval, lsend, lrecv, ihlcom ) 
     41      &                    , kfillmode, pfillval, lsend, lrecv ) 
    4242      !!--------------------------------------------------------------------- 
    4343      CHARACTER(len=*)   ,                   INTENT(in   ) :: cdname  ! name of the calling subroutine 
     
    5151      REAL(wp)           , OPTIONAL        , INTENT(in   ) :: pfillval    ! background value (used at closed boundaries) 
    5252      LOGICAL, DIMENSION(4), OPTIONAL      , INTENT(in   ) :: lsend, lrecv   ! indicate how communications are to be carried out 
    53       INTEGER            , OPTIONAL        , INTENT(in   ) :: ihlcom         ! number of ranks and rows to be communicated 
    5453      !! 
    5554      INTEGER                          ::   kfld        ! number of elements that will be attributed 
     
    7675      IF( PRESENT(psgn11) )   CALL ROUTINE_LOAD( pt11, cdna11, psgn11, ptab_ptr, cdna_ptr, psgn_ptr, kfld ) 
    7776      ! 
    78       CALL lbc_lnk_ptr    ( cdname,               ptab_ptr, cdna_ptr, psgn_ptr, kfld, kfillmode, pfillval, lsend, lrecv, ihlcom ) 
     77      CALL lbc_lnk_ptr    ( cdname,               ptab_ptr, cdna_ptr, psgn_ptr, kfld, kfillmode, pfillval, lsend, lrecv ) 
    7978      ! 
    8079   END SUBROUTINE ROUTINE_MULTI 
  • NEMO/trunk/src/OCE/LBC/lbc_nfd_ext_generic.h90

    r13226 r13286  
    3434      ! 
    3535      SELECT CASE ( jpni ) 
    36       CASE ( 1 )     ;   ipj = nlcj       ! 1 proc only  along the i-direction 
     36      CASE ( 1 )     ;   ipj = jpj        ! 1 proc only  along the i-direction 
    3737      CASE DEFAULT   ;   ipj = 4          ! several proc along the i-direction 
    3838      END SELECT 
  • NEMO/trunk/src/OCE/LBC/lbc_nfd_generic.h90

    r13226 r13286  
    1010#      endif 
    1111#      define ARRAY_IN(i,j,k,l,f)      ptab(f)%pt2d(i,j) 
     12#      define J_SIZE(ptab)             SIZE(ptab(1)%pt2d,2) 
    1213#      define K_SIZE(ptab)             1 
    1314#      define L_SIZE(ptab)             1 
     
    2021#      endif 
    2122#      define ARRAY_IN(i,j,k,l,f)      ptab(f)%pt3d(i,j,k) 
     23#      define J_SIZE(ptab)             SIZE(ptab(1)%pt3d,2) 
    2224#      define K_SIZE(ptab)             SIZE(ptab(1)%pt3d,3) 
    2325#      define L_SIZE(ptab)             1 
     
    3032#      endif 
    3133#      define ARRAY_IN(i,j,k,l,f)      ptab(f)%pt4d(i,j,k,l) 
     34#      define J_SIZE(ptab)             SIZE(ptab(1)%pt4d,2) 
    3235#      define K_SIZE(ptab)             SIZE(ptab(1)%pt4d,3) 
    3336#      define L_SIZE(ptab)             SIZE(ptab(1)%pt4d,4) 
     
    4043#   if defined DIM_2d 
    4144#      define ARRAY_IN(i,j,k,l,f)   ptab(i,j) 
     45#      define J_SIZE(ptab)          SIZE(ptab,2) 
    4246#      define K_SIZE(ptab)          1 
    4347#      define L_SIZE(ptab)          1 
     
    4549#   if defined DIM_3d 
    4650#      define ARRAY_IN(i,j,k,l,f)   ptab(i,j,k) 
     51#      define J_SIZE(ptab)          SIZE(ptab,2) 
    4752#      define K_SIZE(ptab)          SIZE(ptab,3) 
    4853#      define L_SIZE(ptab)          1 
     
    5055#   if defined DIM_4d 
    5156#      define ARRAY_IN(i,j,k,l,f)   ptab(i,j,k,l) 
     57#      define J_SIZE(ptab)          SIZE(ptab,2) 
    5258#      define K_SIZE(ptab)          SIZE(ptab,3) 
    5359#      define L_SIZE(ptab)          SIZE(ptab,4) 
     
    7682      REAL(wp)         , INTENT(in   ) ::   SGN_IN(:)   ! sign used across the north fold boundary 
    7783      ! 
    78       INTEGER  ::    ji,  jj,  jk,  jl, jh, jf   ! dummy loop indices 
    79       INTEGER  ::   ipi, ipj, ipk, ipl,    ipf   ! dimension of the input array 
    80       INTEGER  ::   ijt, iju, ipjm1 
     84      INTEGER  ::    ji,  jj,  jk,  jl, jf   ! dummy loop indices 
     85      INTEGER  ::        ipj, ipk, ipl, ipf   ! dimension of the input array 
     86      INTEGER  ::   ii1, ii2, ij1, ij2 
    8187      !!---------------------------------------------------------------------- 
    8288      ! 
    83       ipk = K_SIZE(ptab)   ! 3rd dimension 
     89      ipj = J_SIZE(ptab)   ! 2nd dimension 
     90      ipk = K_SIZE(ptab)   ! 3rd    - 
    8491      ipl = L_SIZE(ptab)   ! 4th    - 
    8592      ipf = F_SIZE(ptab)   ! 5th    -      use in "multi" case (array of pointers) 
    86       ! 
    87       ! 
    88       SELECT CASE ( jpni ) 
    89       CASE ( 1 )     ;   ipj = nlcj       ! 1 proc only  along the i-direction 
    90       CASE DEFAULT   ;   ipj = 4          ! several proc along the i-direction 
    91       END SELECT 
    92       ipjm1 = ipj-1 
    93  
    9493      ! 
    9594      DO jf = 1, ipf                      ! Loop on the number of arrays to be treated 
     
    101100            SELECT CASE ( NAT_IN(jf)  ) 
    102101            CASE ( 'T' , 'W' )                         ! T-, W-point 
    103                DO ji = 2, jpiglo 
    104                   ijt = jpiglo-ji+2 
    105                   ARRAY_IN(ji,ipj,:,:,jf) = SGN_IN(jf)  * ARRAY_IN(ijt,ipj-2,:,:,jf) 
    106                END DO 
    107                ARRAY_IN(1,ipj,:,:,jf) = SGN_IN(jf)  * ARRAY_IN(3,ipj-2,:,:,jf) 
    108                DO ji = jpiglo/2+1, jpiglo 
    109                   ijt = jpiglo-ji+2 
    110                   ARRAY_IN(ji,ipjm1,:,:,jf) = SGN_IN(jf)  * ARRAY_IN(ijt,ipjm1,:,:,jf) 
    111                END DO 
     102               DO jl = 1, ipl; DO jk = 1, ipk 
     103                  ! 
     104                  ! last nn_hls lines (from ipj to ipj-nn_hls+1) : full 
     105                    DO jj = 1, nn_hls 
     106                       ij1 = ipj            - jj + 1       ! ends at: ipj - nn_hls + 1 
     107                     ij2 = ipj - 2*nn_hls + jj - 1       ! ends at: ipj - 2*nn_hls + nn_hls - 1 = ipj - nn_hls - 1 
     108                     ! 
     109                     DO ji = 1, nn_hls            ! first nn_hls points 
     110                        ii1 =                ji          ! ends at: nn_hls 
     111                        ii2 = 2*nn_hls + 2 - ji          ! ends at: 2*nn_hls + 2 - nn_hls = nn_hls + 2 
     112                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     113                     END DO 
     114                     DO ji = 1, 1                 ! point nn_hls+1 
     115                        ii1 = nn_hls + ji 
     116                        ii2 = ii1 
     117                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     118                     END DO 
     119                     DO ji = 1, Ni0glo - 1        ! points from nn_hls+2 to jpiglo - nn_hls   (note: Ni0glo = jpiglo - 2*nn_hls) 
     120                        ii1 = 2 + nn_hls      + ji - 1   ! ends at: 2 + nn_hls + jpiglo - 2*nn_hls - 1 - 1 = jpiglo - nn_hls 
     121                        ii2 = jpiglo - nn_hls - ji + 1   ! ends at: jpiglo - nn_hls - ( jpiglo - 2*nn_hls - 1 ) + 1 = nn_hls + 2 
     122                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     123                     END DO 
     124                     DO ji = 1, 1                 ! point jpiglo - nn_hls + 1 
     125                        ii1 = jpiglo - nn_hls + ji 
     126                        ii2 =          nn_hls + ji 
     127                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     128                     END DO 
     129                     DO ji = 1, nn_hls-1          ! last nn_hls-1 points 
     130                        ii1 = jpiglo - nn_hls + 1 + ji   ! ends at: jpiglo - nn_hls + 1 + nn_hls - 1 = jpiglo 
     131                        ii2 = jpiglo - nn_hls + 1 - ji   ! ends at: jpiglo - nn_hls + 1 - nn_hls + 1 = jpiglo - 2*nn_hls + 2 
     132                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     133                     END DO 
     134                  END DO 
     135                  ! 
     136                  ! line number ipj-nn_hls : right half 
     137                    DO jj = 1, 1 
     138                     ij1 = ipj - nn_hls 
     139                     ij2 = ij1   ! same line 
     140                     ! 
     141                     DO ji = 1, Ni0glo/2-1        ! points from jpiglo/2+2 to jpiglo - nn_hls   (note: Ni0glo = jpiglo - 2*nn_hls) 
     142                        ii1 = jpiglo/2 + ji + 1          ! ends at: jpiglo/2 + (jpiglo/2 - nn_hls - 1) + 1 = jpiglo - nn_hls 
     143                        ii2 = jpiglo/2 - ji + 1          ! ends at: jpiglo/2 - (jpiglo/2 - nn_hls - 1) + 1 = nn_hls + 2 
     144                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     145                     END DO 
     146                     DO ji = 1, nn_hls            ! first nn_hls points: redo them just in case (if e-w periodocity already done) 
     147                        !                         ! as we just changed points jpiglo-2nn_hls+1 to jpiglo-nn_hls   
     148                        ii1 =                ji          ! ends at: nn_hls 
     149                        ii2 = 2*nn_hls + 2 - ji          ! ends at: 2*nn_hls + 2 - nn_hls = nn_hls + 2 
     150                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     151                     END DO 
     152                     !                            ! last nn_hls-1 points: have been / will done by e-w periodicity  
     153                  END DO 
     154                  ! 
     155               END DO; END DO 
    112156            CASE ( 'U' )                               ! U-point 
    113                DO ji = 1, jpiglo-1 
    114                   iju = jpiglo-ji+1 
    115                   ARRAY_IN(ji,ipj,:,:,jf) = SGN_IN(jf)  * ARRAY_IN(iju,ipj-2,:,:,jf) 
    116                END DO 
    117                ARRAY_IN(   1  ,ipj,:,:,jf) = SGN_IN(jf)  * ARRAY_IN(    2   ,ipj-2,:,:,jf) 
    118                ARRAY_IN(jpiglo,ipj,:,:,jf) = SGN_IN(jf)  * ARRAY_IN(jpiglo-1,ipj-2,:,:,jf)  
    119                DO ji = jpiglo/2, jpiglo-1 
    120                   iju = jpiglo-ji+1 
    121                   ARRAY_IN(ji,ipjm1,:,:,jf) = SGN_IN(jf)  * ARRAY_IN(iju,ipjm1,:,:,jf) 
    122                END DO 
     157               DO jl = 1, ipl; DO jk = 1, ipk 
     158                  ! 
     159                  ! last nn_hls lines (from ipj to ipj-nn_hls+1) : full 
     160                    DO jj = 1, nn_hls 
     161                       ij1 = ipj            - jj + 1       ! ends at: ipj - nn_hls + 1 
     162                     ij2 = ipj - 2*nn_hls + jj - 1       ! ends at: ipj - 2*nn_hls + nn_hls - 1 = ipj - nn_hls - 1 
     163                     ! 
     164                     DO ji = 1, nn_hls            ! first nn_hls points 
     165                        ii1 =                ji          ! ends at: nn_hls 
     166                        ii2 = 2*nn_hls + 1 - ji          ! ends at: 2*nn_hls + 1 - nn_hls = nn_hls + 1 
     167                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     168                     END DO 
     169                     DO ji = 1, Ni0glo            ! points from nn_hls to jpiglo - nn_hls   (note: Ni0glo = jpiglo - 2*nn_hls) 
     170                        ii1 = nn_hls          + ji       ! ends at: nn_hls + jpiglo - 2*nn_hls = jpiglo - nn_hls 
     171                        ii2 = jpiglo - nn_hls - ji + 1   ! ends at: jpiglo - nn_hls - ( jpiglo - 2*nn_hls ) + 1 = nn_hls + 1 
     172                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     173                     END DO 
     174                     DO ji = 1, nn_hls            ! last nn_hls points 
     175                        ii1 = jpiglo - nn_hls + ji       ! ends at: jpiglo - nn_hls + nn_hls = jpiglo 
     176                        ii2 = jpiglo - nn_hls + 1 - ji   ! ends at: jpiglo - nn_hls + 1 - nn_hls = jpiglo - 2*nn_hls + 1 
     177                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     178                     END DO 
     179                  END DO 
     180                  ! 
     181                  ! line number ipj-nn_hls : right half 
     182                    DO jj = 1, 1 
     183                     ij1 = ipj - nn_hls 
     184                     ij2 = ij1   ! same line 
     185                     ! 
     186                     DO ji = 1, Ni0glo/2          ! points from jpiglo/2+1 to jpiglo - nn_hls   (note: Ni0glo = jpiglo - 2*nn_hls) 
     187                        ii1 = jpiglo/2 + ji              ! ends at: jpiglo/2 + (jpiglo/2 - nn_hls) = jpiglo - nn_hls 
     188                        ii2 = jpiglo/2 - ji + 1          ! ends at: jpiglo/2 - (jpiglo/2 - nn_hls) + 1 = nn_hls + 1 
     189                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     190                     END DO 
     191                     DO ji = 1, nn_hls            ! first nn_hls points: redo them just in case (if e-w periodocity already done) 
     192                        !                         ! as we just changed points jpiglo-2nn_hls+1 to jpiglo-nn_hls   
     193                        ii1 =                ji          ! ends at: nn_hls 
     194                        ii2 = 2*nn_hls + 1 - ji          ! ends at: 2*nn_hls + 1 - nn_hls = nn_hls + 1 
     195                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     196                     END DO 
     197                     !                            ! last nn_hls-1 points: have been / will done by e-w periodicity  
     198                  END DO 
     199                  ! 
     200               END DO; END DO 
    123201            CASE ( 'V' )                               ! V-point 
    124                DO ji = 2, jpiglo 
    125                   ijt = jpiglo-ji+2 
    126                   ARRAY_IN(ji,ipj-1,:,:,jf) = SGN_IN(jf)  * ARRAY_IN(ijt,ipj-2,:,:,jf) 
    127                   ARRAY_IN(ji,ipj  ,:,:,jf) = SGN_IN(jf)  * ARRAY_IN(ijt,ipj-3,:,:,jf) 
    128                END DO 
    129                ARRAY_IN(1,ipj,:,:,jf) = SGN_IN(jf)  * ARRAY_IN(3,ipj-3,:,:,jf)  
     202               DO jl = 1, ipl; DO jk = 1, ipk 
     203                  ! 
     204                  ! last nn_hls+1 lines (from ipj to ipj-nn_hls) : full 
     205                    DO jj = 1, nn_hls+1 
     206                       ij1 = ipj            - jj + 1       ! ends at: ipj - ( nn_hls + 1 ) + 1 = ipj - nn_hls 
     207                     ij2 = ipj - 2*nn_hls + jj - 2       ! ends at: ipj - 2*nn_hls + nn_hls + 1 - 2 = ipj - nn_hls - 1 
     208                     ! 
     209                     DO ji = 1, nn_hls            ! first nn_hls points 
     210                        ii1 =                ji          ! ends at: nn_hls 
     211                        ii2 = 2*nn_hls + 2 - ji          ! ends at: 2*nn_hls + 2 - nn_hls = nn_hls + 2 
     212                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     213                     END DO 
     214                     DO ji = 1, 1                 ! point nn_hls+1 
     215                        ii1 = nn_hls + ji 
     216                        ii2 = ii1 
     217                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     218                     END DO 
     219                     DO ji = 1, Ni0glo - 1        ! points from nn_hls+2 to jpiglo - nn_hls   (note: Ni0glo = jpiglo - 2*nn_hls) 
     220                        ii1 = 2 + nn_hls      + ji - 1   ! ends at: 2 + nn_hls + jpiglo - 2*nn_hls - 1 - 1 = jpiglo - nn_hls 
     221                        ii2 = jpiglo - nn_hls - ji + 1   ! ends at: jpiglo - nn_hls - ( jpiglo - 2*nn_hls - 1 ) + 1 = nn_hls + 2 
     222                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     223                     END DO 
     224                     DO ji = 1, 1                 ! point jpiglo - nn_hls + 1 
     225                        ii1 = jpiglo - nn_hls + ji 
     226                        ii2 =          nn_hls + ji 
     227                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     228                     END DO 
     229                     DO ji = 1, nn_hls-1          ! last nn_hls-1 points 
     230                        ii1 = jpiglo - nn_hls + 1 + ji   ! ends at: jpiglo - nn_hls + 1 + nn_hls - 1 = jpiglo 
     231                        ii2 = jpiglo - nn_hls + 1 - ji   ! ends at: jpiglo - nn_hls + 1 - nn_hls + 1 = jpiglo - 2*nn_hls + 2 
     232                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     233                     END DO 
     234                  END DO 
     235                  ! 
     236               END DO; END DO 
    130237            CASE ( 'F' )                               ! F-point 
    131                DO ji = 1, jpiglo-1 
    132                   iju = jpiglo-ji+1 
    133                   ARRAY_IN(ji,ipj-1,:,:,jf) = SGN_IN(jf)  * ARRAY_IN(iju,ipj-2,:,:,jf) 
    134                   ARRAY_IN(ji,ipj  ,:,:,jf) = SGN_IN(jf)  * ARRAY_IN(iju,ipj-3,:,:,jf) 
    135                END DO 
    136                ARRAY_IN(   1  ,ipj,:,:,jf) = SGN_IN(jf)  * ARRAY_IN(    2   ,ipj-3,:,:,jf) 
    137                ARRAY_IN(jpiglo,ipj,:,:,jf) = SGN_IN(jf)  * ARRAY_IN(jpiglo-1,ipj-3,:,:,jf)  
    138             END SELECT 
     238               DO jl = 1, ipl; DO jk = 1, ipk 
     239                  ! 
     240                  ! last nn_hls+1 lines (from ipj to ipj-nn_hls) : full 
     241                    DO jj = 1, nn_hls+1 
     242                       ij1 = ipj            - jj + 1       ! ends at: ipj - ( nn_hls + 1 ) + 1 = ipj - nn_hls 
     243                     ij2 = ipj - 2*nn_hls + jj - 2       ! ends at: ipj - 2*nn_hls + nn_hls + 1 - 2 = ipj - nn_hls - 1 
     244                     ! 
     245                     DO ji = 1, nn_hls            ! first nn_hls points 
     246                        ii1 =                ji          ! ends at: nn_hls 
     247                        ii2 = 2*nn_hls + 1 - ji          ! ends at: 2*nn_hls + 1 - nn_hls = nn_hls + 1 
     248                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     249                     END DO 
     250                     DO ji = 1, Ni0glo            ! points from nn_hls to jpiglo - nn_hls   (note: Ni0glo = jpiglo - 2*nn_hls) 
     251                        ii1 = nn_hls          + ji       ! ends at: nn_hls + jpiglo - 2*nn_hls = jpiglo - nn_hls 
     252                        ii2 = jpiglo - nn_hls - ji + 1   ! ends at: jpiglo - nn_hls - ( jpiglo - 2*nn_hls ) + 1 = nn_hls + 1 
     253                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     254                     END DO 
     255                     DO ji = 1, nn_hls            ! last nn_hls points 
     256                        ii1 = jpiglo - nn_hls + ji       ! ends at: jpiglo - nn_hls + nn_hls = jpiglo 
     257                        ii2 = jpiglo - nn_hls + 1 - ji   ! ends at: jpiglo - nn_hls + 1 - nn_hls = jpiglo - 2*nn_hls + 1 
     258                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     259                     END DO 
     260                  END DO 
     261                  ! 
     262               END DO; END DO 
     263            END SELECT   ! NAT_IN(jf) 
    139264            ! 
    140265         CASE ( 5 , 6 )                        ! *  North fold  F-point pivot 
     
    142267            SELECT CASE ( NAT_IN(jf)  ) 
    143268            CASE ( 'T' , 'W' )                         ! T-, W-point 
    144                DO ji = 1, jpiglo 
    145                   ijt = jpiglo-ji+1 
    146                   ARRAY_IN(ji,ipj,:,:,jf) = SGN_IN(jf)  * ARRAY_IN(ijt,ipj-1,:,:,jf) 
    147                END DO 
     269               DO jl = 1, ipl; DO jk = 1, ipk 
     270                  ! 
     271                  ! first: line number ipj-nn_hls : 3 points 
     272                    DO jj = 1, 1 
     273                     ij1 = ipj - nn_hls 
     274                     ij2 = ij1   ! same line 
     275                     ! 
     276                     DO ji = 1, 1            ! points from jpiglo/2+1 
     277                        ii1 = jpiglo/2 + ji 
     278                        ii2 = jpiglo/2 - ji + 1 
     279                        ARRAY_IN(ii1,ij1,jk,jl,jf) =              ARRAY_IN(ii2,ij2,jk,jl,jf)   ! Warning: pb with sign... 
     280                     END DO 
     281                     DO ji = 1, 1            ! points jpiglo - nn_hls 
     282                        ii1 = jpiglo - nn_hls + ji - 1 
     283                        ii2 =          nn_hls + ji 
     284                        ARRAY_IN(ii1,ij1,jk,jl,jf) =              ARRAY_IN(ii2,ij2,jk,jl,jf)   ! Warning: pb with sign... 
     285                     END DO 
     286                     DO ji = 1, 1            ! point nn_hls: redo it just in case (if e-w periodocity already done) 
     287                        !                    ! as we just changed point jpiglo - nn_hls 
     288                        ii1 = nn_hls + ji - 1 
     289                        ii2 = nn_hls + ji 
     290                        ARRAY_IN(ii1,ij1,jk,jl,jf) =              ARRAY_IN(ii2,ij2,jk,jl,jf)   ! Warning: pb with sign... 
     291                     END DO 
     292                  END DO 
     293                  ! 
     294                  ! Second: last nn_hls lines (from ipj to ipj-nn_hls+1) : full 
     295                    DO jj = 1, nn_hls 
     296                       ij1 = ipj + 1        - jj           ! ends at: ipj + 1 - nn_hls 
     297                     ij2 = ipj - 2*nn_hls + jj           ! ends at: ipj - 2*nn_hls + nn_hls = ipj - nn_hls 
     298                     ! 
     299                     DO ji = 1, nn_hls            ! first nn_hls points 
     300                        ii1 =                ji          ! ends at: nn_hls 
     301                        ii2 = 2*nn_hls + 1 - ji          ! ends at: 2*nn_hls + 1 - nn_hls = nn_hls + 1 
     302                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     303                     END DO 
     304                     DO ji = 1, Ni0glo            ! points from nn_hls to jpiglo - nn_hls   (note: Ni0glo = jpiglo - 2*nn_hls) 
     305                        ii1 = nn_hls          + ji       ! ends at: nn_hls + jpiglo - 2*nn_hls = jpiglo - nn_hls 
     306                        ii2 = jpiglo - nn_hls - ji + 1   ! ends at: jpiglo - nn_hls - ( jpiglo - 2*nn_hls ) + 1 = nn_hls + 1 
     307                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     308                     END DO 
     309                     DO ji = 1, nn_hls            ! last nn_hls points 
     310                        ii1 = jpiglo - nn_hls + ji       ! ends at: jpiglo - nn_hls + nn_hls = jpiglo 
     311                        ii2 = jpiglo - nn_hls + 1 - ji   ! ends at: jpiglo - nn_hls + 1 - nn_hls = jpiglo - 2*nn_hls + 1 
     312                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     313                     END DO 
     314                  END DO 
     315                  ! 
     316               END DO; END DO 
    148317            CASE ( 'U' )                               ! U-point 
    149                DO ji = 1, jpiglo-1 
    150                   iju = jpiglo-ji 
    151                   ARRAY_IN(ji,ipj,:,:,jf) = SGN_IN(jf)  * ARRAY_IN(iju,ipj-1,:,:,jf) 
    152                END DO 
    153                ARRAY_IN(jpiglo,ipj,:,:,jf) = SGN_IN(jf) * ARRAY_IN(jpiglo-2,ipj-1,:,:,jf) 
     318               DO jl = 1, ipl; DO jk = 1, ipk 
     319                  ! 
     320                  ! last nn_hls lines (from ipj to ipj-nn_hls+1) : full 
     321                    DO jj = 1, nn_hls 
     322                       ij1 = ipj + 1        - jj           ! ends at: ipj + 1 - nn_hls 
     323                     ij2 = ipj - 2*nn_hls + jj           ! ends at: ipj - 2*nn_hls + nn_hls = ipj - nn_hls 
     324                     ! 
     325                     DO ji = 1, nn_hls-1          ! first nn_hls-1 points 
     326                        ii1 =            ji              ! ends at: nn_hls-1 
     327                        ii2 = 2*nn_hls - ji              ! ends at: 2*nn_hls - ( nn_hls - 1 ) = nn_hls + 1 
     328                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     329                     END DO 
     330                     DO ji = 1, 1                 ! point nn_hls 
     331                        ii1 = nn_hls + ji - 1 
     332                        ii2 = jpiglo - ii1 
     333                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     334                     END DO 
     335                     DO ji = 1, Ni0glo - 1        ! points from nn_hls+1 to jpiglo - nn_hls - 1  (note: Ni0glo = jpiglo - 2*nn_hls) 
     336                        ii1 =          nn_hls + ji       ! ends at: nn_hls + ( jpiglo - 2*nn_hls - 1 ) = jpiglo - nn_hls - 1 
     337                        ii2 = jpiglo - nn_hls - ji       ! ends at: jpiglo - nn_hls - ( jpiglo - 2*nn_hls - 1 ) = nn_hls + 1 
     338                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     339                     END DO 
     340                     DO ji = 1, 1                 ! point jpiglo - nn_hls 
     341                        ii1 = jpiglo - nn_hls + ji - 1 
     342                        ii2 = ii1 
     343                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     344                     END DO 
     345                     DO ji = 1, nn_hls            ! last nn_hls points 
     346                        ii1 = jpiglo - nn_hls + ji       ! ends at: jpiglo - nn_hls + nn_hls = jpiglo 
     347                        ii2 = jpiglo - nn_hls - ji       ! ends at: jpiglo - nn_hls - nn_hls = jpiglo - 2*nn_hls 
     348                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     349                     END DO 
     350                  END DO 
     351                  ! 
     352               END DO; END DO 
    154353            CASE ( 'V' )                               ! V-point 
    155                DO ji = 1, jpiglo 
    156                   ijt = jpiglo-ji+1 
    157                   ARRAY_IN(ji,ipj,:,:,jf) = SGN_IN(jf)  * ARRAY_IN(ijt,ipj-2,:,:,jf) 
    158                END DO 
    159                DO ji = jpiglo/2+1, jpiglo 
    160                   ijt = jpiglo-ji+1 
    161                   ARRAY_IN(ji,ipjm1,:,:,jf) = SGN_IN(jf)  * ARRAY_IN(ijt,ipjm1,:,:,jf) 
    162                END DO 
     354               DO jl = 1, ipl; DO jk = 1, ipk 
     355                  ! 
     356                  ! last nn_hls lines (from ipj to ipj-nn_hls+1) : full 
     357                    DO jj = 1, nn_hls 
     358                       ij1 = ipj            - jj + 1       ! ends at: ipj - nn_hls + 1 
     359                     ij2 = ipj - 2*nn_hls + jj - 1       ! ends at: ipj - 2*nn_hls + nn_hls - 1 = ipj - nn_hls - 1 
     360                     ! 
     361                     DO ji = 1, nn_hls            ! first nn_hls points 
     362                        ii1 =                ji          ! ends at: nn_hls 
     363                        ii2 = 2*nn_hls + 1 - ji          ! ends at: 2*nn_hls + 1 - nn_hls = nn_hls + 1 
     364                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     365                     END DO 
     366                     DO ji = 1, Ni0glo            ! points from nn_hls to jpiglo - nn_hls   (note: Ni0glo = jpiglo - 2*nn_hls) 
     367                        ii1 = nn_hls          + ji       ! ends at: nn_hls + jpiglo - 2*nn_hls = jpiglo - nn_hls 
     368                        ii2 = jpiglo - nn_hls - ji + 1   ! ends at: jpiglo - nn_hls - ( jpiglo - 2*nn_hls ) + 1 = nn_hls + 1 
     369                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     370                     END DO 
     371                     DO ji = 1, nn_hls            ! last nn_hls points 
     372                        ii1 = jpiglo - nn_hls + ji       ! ends at: jpiglo - nn_hls + nn_hls = jpiglo 
     373                        ii2 = jpiglo - nn_hls + 1 - ji   ! ends at: jpiglo - nn_hls + 1 - nn_hls = jpiglo - 2*nn_hls + 1 
     374                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     375                     END DO 
     376                  END DO    
     377                  ! 
     378                  ! line number ipj-nn_hls : right half 
     379                    DO jj = 1, 1 
     380                     ij1 = ipj - nn_hls 
     381                     ij2 = ij1   ! same line 
     382                     ! 
     383                     DO ji = 1, Ni0glo/2          ! points from jpiglo/2+1 to jpiglo - nn_hls   (note: Ni0glo = jpiglo - 2*nn_hls) 
     384                        ii1 = jpiglo/2 + ji              ! ends at: jpiglo/2 + (jpiglo/2 - nn_hls) = jpiglo - nn_hls 
     385                        ii2 = jpiglo/2 - ji + 1          ! ends at: jpiglo/2 - (jpiglo/2 - nn_hls) + 1 = nn_hls + 1 
     386                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     387                     END DO 
     388                     DO ji = 1, nn_hls            ! first nn_hls points: redo them just in case (if e-w periodocity already done) 
     389                        !                         ! as we just changed points jpiglo-2nn_hls+1 to jpiglo-nn_hls   
     390                        ii1 =                ji          ! ends at: nn_hls 
     391                        ii2 = 2*nn_hls + 1 - ji          ! ends at: 2*nn_hls + 1 - nn_hls = nn_hls + 1 
     392                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     393                     END DO 
     394                     !                            ! last nn_hls points: have been / will done by e-w periodicity  
     395                  END DO 
     396                  ! 
     397               END DO; END DO 
    163398            CASE ( 'F' )                               ! F-point 
    164                DO ji = 1, jpiglo-1 
    165                   iju = jpiglo-ji 
    166                   ARRAY_IN(ji,ipj  ,:,:,jf) = SGN_IN(jf)  * ARRAY_IN(iju,ipj-2,:,:,jf) 
    167                END DO 
    168                ARRAY_IN(jpiglo,ipj,:,:,jf) = SGN_IN(jf)   * ARRAY_IN(jpiglo-2,ipj-2,:,:,jf) 
    169                DO ji = jpiglo/2+1, jpiglo-1 
    170                   iju = jpiglo-ji 
    171                   ARRAY_IN(ji,ipjm1,:,:,jf) = SGN_IN(jf)  * ARRAY_IN(iju,ipjm1,:,:,jf) 
    172                END DO 
    173             END SELECT 
     399               DO jl = 1, ipl; DO jk = 1, ipk 
     400                  ! 
     401                  ! last nn_hls lines (from ipj to ipj-nn_hls+1) : full 
     402                    DO jj = 1, nn_hls 
     403                       ij1 = ipj            - jj + 1       ! ends at: ipj - nn_hls + 1 
     404                     ij2 = ipj - 2*nn_hls + jj - 1       ! ends at: ipj - 2*nn_hls + nn_hls - 1 = ipj - nn_hls - 1 
     405                     ! 
     406                     DO ji = 1, nn_hls-1          ! first nn_hls-1 points 
     407                        ii1 =            ji              ! ends at: nn_hls-1 
     408                        ii2 = 2*nn_hls - ji              ! ends at: 2*nn_hls - ( nn_hls - 1 ) = nn_hls + 1 
     409                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     410                     END DO 
     411                     DO ji = 1, 1                 ! point nn_hls 
     412                        ii1 = nn_hls + ji - 1 
     413                        ii2 = jpiglo - ii1 
     414                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     415                     END DO 
     416                     DO ji = 1, Ni0glo - 1        ! points from nn_hls+1 to jpiglo - nn_hls - 1  (note: Ni0glo = jpiglo - 2*nn_hls) 
     417                        ii1 =          nn_hls + ji       ! ends at: nn_hls + ( jpiglo - 2*nn_hls - 1 ) = jpiglo - nn_hls - 1 
     418                        ii2 = jpiglo - nn_hls - ji       ! ends at: jpiglo - nn_hls - ( jpiglo - 2*nn_hls - 1 ) = nn_hls + 1 
     419                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     420                     END DO 
     421                     DO ji = 1, 1                 ! point jpiglo - nn_hls 
     422                        ii1 = jpiglo - nn_hls + ji - 1 
     423                        ii2 = ii1 
     424                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     425                     END DO 
     426                     DO ji = 1, nn_hls            ! last nn_hls points 
     427                        ii1 = jpiglo - nn_hls + ji       ! ends at: jpiglo - nn_hls + nn_hls = jpiglo 
     428                        ii2 = jpiglo - nn_hls - ji       ! ends at: jpiglo - nn_hls - nn_hls = jpiglo - 2*nn_hls 
     429                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     430                     END DO 
     431                  END DO    
     432                  ! 
     433                  ! line number ipj-nn_hls : right half 
     434                    DO jj = 1, 1 
     435                     ij1 = ipj - nn_hls 
     436                     ij2 = ij1   ! same line 
     437                     ! 
     438                     DO ji = 1, Ni0glo/2-1        ! points from jpiglo/2+1 to jpiglo - nn_hls-1  (note: Ni0glo = jpiglo - 2*nn_hls) 
     439                        ii1 = jpiglo/2 + ji              ! ends at: jpiglo/2 + (jpiglo/2 - nn_hls) = jpiglo - nn_hls 
     440                        ii2 = jpiglo/2 - ji              ! ends at: jpiglo/2 - (jpiglo/2 - nn_hls - 1 ) = nn_hls + 1 
     441                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     442                     END DO 
     443                     DO ji = 1, nn_hls-1          ! first nn_hls-1 points: redo them just in case (if e-w periodocity already done) 
     444                        !                         ! as we just changed points jpiglo-2nn_hls+1 to jpiglo-nn_hl-1   
     445                        ii1 =            ji              ! ends at: nn_hls 
     446                        ii2 = 2*nn_hls - ji              ! ends at: 2*nn_hls - ( nn_hls - 1 ) = nn_hls + 1 
     447                        ARRAY_IN(ii1,ij1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ii2,ij2,jk,jl,jf) 
     448                     END DO 
     449                     !                            ! last nn_hls points: have been / will done by e-w periodicity  
     450                  END DO 
     451                  ! 
     452               END DO; END DO 
     453            END SELECT   ! NAT_IN(jf) 
    174454            ! 
    175          CASE DEFAULT                           ! *  closed : the code probably never go through 
    176             ! 
    177             SELECT CASE ( NAT_IN(jf) ) 
    178             CASE ( 'T' , 'U' , 'V' , 'W' )             ! T-, U-, V-, W-points 
    179                ARRAY_IN(:, 1 ,:,:,jf) = 0._wp 
    180                ARRAY_IN(:,ipj,:,:,jf) = 0._wp 
    181             CASE ( 'F' )                               ! F-point 
    182                ARRAY_IN(:,ipj,:,:,jf) = 0._wp 
    183             END SELECT 
    184             ! 
    185          END SELECT     !  npolj 
     455         END SELECT   ! npolj 
    186456         ! 
    187       END DO 
     457      END DO   ! ipf 
    188458      ! 
    189459   END SUBROUTINE ROUTINE_NFD 
     
    194464#undef NAT_IN 
    195465#undef SGN_IN 
     466#undef J_SIZE 
    196467#undef K_SIZE 
    197468#undef L_SIZE 
  • NEMO/trunk/src/OCE/LBC/lbc_nfd_nogather_generic.h90

    r13226 r13286  
    6060#      define L_SIZE(ptab)          SIZE(ptab,4) 
    6161#   endif 
    62 #   define ARRAY2_IN(i,j,k,l,f)  ptab2(i,j,k,l) 
    6362#   define J_SIZE(ptab2)             SIZE(ptab2,2) 
     63#   define ARRAY2_IN(i,j,k,l,f)   ptab2(i,j,k,l) 
    6464#   if defined SINGLE_PRECISION 
    6565#      define ARRAY_TYPE(i,j,k,l,f)     REAL(sp),INTENT(inout)::ARRAY_IN(i,j,k,l,f) 
     
    8282      !! 
    8383      !!---------------------------------------------------------------------- 
    84       ARRAY_TYPE(:,:,:,:,:)                             ! array or pointer of arrays on which the boundary condition is applied 
    85       ARRAY2_TYPE(:,:,:,:,:)                            ! array or pointer of arrays on which the boundary condition is applied 
     84      ARRAY_TYPE(:,:,:,:,:) 
     85      ARRAY2_TYPE(:,:,:,:,:)  
    8686      CHARACTER(len=1) , INTENT(in   ) ::   NAT_IN(:)   ! nature of array grid-points 
    8787      REAL(wp)         , INTENT(in   ) ::   SGN_IN(:)   ! sign used across the north fold boundary 
    8888      INTEGER, OPTIONAL, INTENT(in   ) ::   kfld        ! number of pt3d arrays 
    8989      ! 
    90       INTEGER  ::    ji,  jj,   jk,     jl,   jh,  jf   ! dummy loop indices 
    91       INTEGER  ::   ipi, ipj,  ipk,    ipl,  ipf        ! dimension of the input array 
    92       INTEGER  ::   ijt, iju, ijpj, ijpjp1, ijta, ijua, jia, startloop, endloop 
     90      INTEGER  ::    ji,  jj,   jk, jn, ii,   jl,   jh,  jf   ! dummy loop indices 
     91      INTEGER  ::   ipi, ipj,  ipk,    ipl,  ipf, iij, ijj   ! dimension of the input array 
     92      INTEGER  ::   ijt, iju, ijta, ijua, jia, startloop, endloop 
    9393      LOGICAL  ::   l_fast_exchanges 
    9494      !!---------------------------------------------------------------------- 
     
    100100      ! Security check for further developments 
    101101      IF ( ipf > 1 ) CALL ctl_stop( 'STOP', 'lbc_nfd_nogather: multiple fields not allowed. Revise implementation...' ) 
    102       ! 
    103       ijpj   = 1    ! index of first modified line  
    104       ijpjp1 = 2    ! index + 1 
    105        
    106102      ! 2nd dimension determines exchange speed 
    107103      IF (ipj == 1 ) THEN 
     
    120116            ! 
    121117            CASE ( 'T' , 'W' )                         ! T-, W-point 
    122                IF ( nimpp /= 1 ) THEN   ;   startloop = 1 
    123                ELSE                     ;   startloop = 2 
    124                ENDIF 
    125                ! 
    126                DO jl = 1, ipl; DO jk = 1, ipk 
    127                   DO ji = startloop, nlci 
    128                      ijt = jpiglo - ji - nimpp - nfiimpp(isendto(1),jpnj) + 4 
    129                      ARRAY_IN(ji,nlcj,jk,jl,jf) = SGN_IN(jf) * ARRAY2_IN(ijt,ijpj,jk,jl,jf) 
     118               IF ( nimpp /= 1 ) THEN  ;  startloop = 1  
     119               ELSE                    ;  startloop = 1 + nn_hls 
     120               ENDIF 
     121               ! 
     122               DO jl = 1, ipl; DO jk = 1, ipk 
     123                    DO jj = 1, nn_hls 
     124                       ijj = jpj -jj +1 
     125                     DO ji = startloop, jpi 
     126                     ijt = jpiglo - ji - nimpp - nfimpp(isendto(1)) + 4 
     127                        ARRAY_IN(ji,ijj,jk,jl,jf) = SGN_IN(jf) * ARRAY2_IN(ijt,jj,jk,jl,jf) 
     128                     END DO 
    130129                  END DO 
    131130               END DO; END DO 
    132131               IF( nimpp == 1 ) THEN 
    133132                  DO jl = 1, ipl; DO jk = 1, ipk 
    134                      ARRAY_IN(1,nlcj,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(3,nlcj-2,jk,jl,jf) 
    135                   END DO; END DO 
    136                ENDIF 
    137                ! 
    138                IF ( .NOT. l_fast_exchanges ) THEN 
    139                   IF( nimpp >= jpiglo/2+1 ) THEN 
     133                     DO jj = 1, nn_hls 
     134                     ijj = jpj -jj +1 
     135                     DO ii = 0, nn_hls-1 
     136                        ARRAY_IN(ii+1,ijj,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(2*nn_hls-ii+1,jpj-2*nn_hls+jj-1,jk,jl,jf) 
     137                     END DO 
     138                     END DO 
     139                  END DO; END DO 
     140               ENDIF               
     141               ! 
     142               IF ( .NOT. l_fast_exchanges ) THEN 
     143                  IF( nimpp >= Ni0glo/2+2 ) THEN 
    140144                     startloop = 1 
    141                   ELSEIF( nimpp+nlci-1 >= jpiglo/2+1 .AND. nimpp < jpiglo/2+1 ) THEN 
    142                      startloop = jpiglo/2+1 - nimpp + 1 
    143                   ELSE 
    144                      startloop = nlci + 1 
    145                   ENDIF 
    146                   IF( startloop <= nlci ) THEN 
     145                  ELSEIF( nimpp+jpi-1 >= Ni0glo/2+2 .AND. nimpp < Ni0glo/2+2 ) THEN 
     146                     startloop = Ni0glo/2+2 - nimpp + nn_hls 
     147                  ELSE 
     148                     startloop = jpi + 1 
     149                  ENDIF 
     150                  IF( startloop <= jpi ) THEN 
    147151                     DO jl = 1, ipl; DO jk = 1, ipk 
    148                         DO ji = startloop, nlci 
    149                            ijt  = jpiglo - ji - nimpp - nfiimpp(isendto(1),jpnj) + 4 
     152                        DO ji = startloop, jpi 
     153                           ijt  = jpiglo - ji - nimpp - nfimpp(isendto(1)) + 4 
    150154                           jia  = ji + nimpp - 1 
    151155                           ijta = jpiglo - jia + 2 
    152156                           IF( ijta >= startloop+nimpp-1 .AND. ijta < jia ) THEN 
    153                               ARRAY_IN(ji,nlcj-1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ijta-nimpp+1,nlcj-1,jk,jl,jf) 
     157                              ARRAY_IN(ji,jpj-nn_hls,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ijta-nimpp+nn_hls,jpj-nn_hls,jk,jl,jf) 
    154158                           ELSE 
    155                               ARRAY_IN(ji,nlcj-1,jk,jl,jf) = SGN_IN(jf) * ARRAY2_IN(ijt,ijpjp1,jk,jl,jf) 
     159                              ARRAY_IN(ji,jpj-nn_hls,jk,jl,jf) = SGN_IN(jf) * ARRAY2_IN(ijt,nn_hls+1,jk,jl,jf) 
    156160                           ENDIF 
    157161                        END DO 
     
    159163                  ENDIF 
    160164               ENDIF 
    161  
    162165            CASE ( 'U' )                                     ! U-point 
    163                IF( nimpp + nlci - 1 /= jpiglo ) THEN 
    164                   endloop = nlci 
     166               IF( nimpp + jpi - 1 /= jpiglo ) THEN 
     167                  endloop = jpi 
    165168               ELSE 
    166                   endloop = nlci - 1 
    167                ENDIF 
    168                DO jl = 1, ipl; DO jk = 1, ipk 
    169                   DO ji = 1, endloop 
    170                      iju = jpiglo - ji - nimpp - nfiimpp(isendto(1),jpnj) + 3 
    171                      ARRAY_IN(ji,nlcj,jk,jl,jf) = SGN_IN(jf) * ARRAY2_IN(iju,ijpj,jk,jl,jf) 
     169                  endloop = jpi - nn_hls 
     170               ENDIF 
     171               DO jl = 1, ipl; DO jk = 1, ipk 
     172        DO jj = 1, nn_hls 
     173              ijj = jpj -jj +1 
     174                     DO ji = 1, endloop 
     175                        iju = jpiglo - ji - nimpp - nfimpp(isendto(1)) + 3 
     176                        ARRAY_IN(ji,ijj,jk,jl,jf) = SGN_IN(jf) * ARRAY2_IN(iju,jj,jk,jl,jf) 
     177                     END DO 
    172178                  END DO 
    173179               END DO; END DO 
    174180               IF (nimpp .eq. 1) THEN 
    175                   ARRAY_IN(1,nlcj,:,:,jf) = SGN_IN(jf) * ARRAY_IN(2,nlcj-2,:,:,jf) 
    176                ENDIF 
    177                IF((nimpp + nlci - 1) .eq. jpiglo) THEN 
    178                   ARRAY_IN(nlci,nlcj,:,:,jf) = SGN_IN(jf) * ARRAY_IN(nlci-1,nlcj-2,:,:,jf) 
    179                ENDIF 
    180                ! 
    181                IF ( .NOT. l_fast_exchanges ) THEN 
    182                   IF( nimpp + nlci - 1 /= jpiglo ) THEN 
    183                      endloop = nlci 
    184                   ELSE 
    185                      endloop = nlci - 1 
    186                   ENDIF 
    187                   IF( nimpp >= jpiglo/2 ) THEN 
    188                      startloop = 1 
    189                      ELSEIF( ( nimpp+nlci-1 >= jpiglo/2 ) .AND. ( nimpp < jpiglo/2 ) ) THEN 
    190                      startloop = jpiglo/2 - nimpp + 1 
     181        DO jj = 1, nn_hls 
     182           ijj = jpj -jj +1 
     183           DO ii = 0, nn_hls-1 
     184         ARRAY_IN(ii+1,ijj,:,:,jf) = SGN_IN(jf) * ARRAY_IN(2*nn_hls-ii,jpj-2*nn_hls+jj-1,:,:,jf) 
     185           END DO 
     186                  END DO 
     187               ENDIF 
     188               IF((nimpp + jpi - 1) .eq. jpiglo) THEN 
     189                  DO jj = 1, nn_hls 
     190                       ijj = jpj -jj +1 
     191         DO ii = 1, nn_hls 
     192               ARRAY_IN(jpi-ii+1,ijj,:,:,jf) = SGN_IN(jf) * ARRAY_IN(jpi-2*nn_hls+ii,jpj-2*nn_hls+jj-1,:,:,jf) 
     193         END DO 
     194        END DO 
     195               ENDIF 
     196               ! 
     197               IF ( .NOT. l_fast_exchanges ) THEN 
     198                  IF( nimpp + jpi - 1 /= jpiglo ) THEN 
     199                     endloop = jpi 
     200                  ELSE 
     201                     endloop = jpi - nn_hls 
     202                  ENDIF 
     203                  IF( nimpp >= Ni0glo/2+1 ) THEN 
     204                     startloop = nn_hls 
     205                  ELSEIF( ( nimpp + jpi - 1 >= Ni0glo/2+1 ) .AND. ( nimpp < Ni0glo/2+1 ) ) THEN 
     206                     startloop = Ni0glo/2+1 - nimpp + nn_hls  
    191207                  ELSE 
    192208                     startloop = endloop + 1 
     
    195211                  DO jl = 1, ipl; DO jk = 1, ipk 
    196212                     DO ji = startloop, endloop 
    197                         iju = jpiglo - ji - nimpp - nfiimpp(isendto(1),jpnj) + 3 
    198                         jia = ji + nimpp - 1 
    199                         ijua = jpiglo - jia + 1 
     213                        iju = jpiglo - ji - nimpp - nfimpp(isendto(1)) + 3 
     214                        jia = ji + nimpp - 1  
     215                        ijua = jpiglo - jia + 1  
    200216                        IF( ijua >= startloop+nimpp-1 .AND. ijua < jia ) THEN 
    201                            ARRAY_IN(ji,nlcj-1,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ijua-nimpp+1,nlcj-1,jk,jl,jf) 
     217                           ARRAY_IN(ji,jpj-nn_hls,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(ijua-nimpp+1,jpj-nn_hls,jk,jl,jf) 
    202218                        ELSE 
    203                            ARRAY_IN(ji,nlcj-1,jk,jl,jf) = SGN_IN(jf) * ARRAY2_IN(iju,ijpjp1,jk,jl,jf) 
     219                           ARRAY_IN(ji,jpj-nn_hls,jk,jl,jf) = SGN_IN(jf) * ARRAY2_IN(iju,nn_hls+1,jk,jl,jf) 
    204220                        ENDIF 
    205221                     END DO 
     
    210226            CASE ( 'V' )                                     ! V-point 
    211227               IF( nimpp /= 1 ) THEN 
    212                  startloop = 1 
     228                 startloop = 1  
    213229               ELSE 
    214                  startloop = 2 
    215                ENDIF 
    216                IF ( .NOT. l_fast_exchanges ) THEN 
    217                   DO jl = 1, ipl; DO jk = 1, ipk 
    218                      DO ji = startloop, nlci 
    219                         ijt=jpiglo - ji - nimpp - nfiimpp(isendto(1),jpnj) + 4 
    220                         ARRAY_IN(ji,nlcj-1,jk,jl,jf) = SGN_IN(jf) * ARRAY2_IN(ijt,ijpjp1,jk,jl,jf) 
    221                      END DO 
    222                   END DO; END DO 
    223                ENDIF 
    224                DO jl = 1, ipl; DO jk = 1, ipk 
    225                   DO ji = startloop, nlci 
    226                      ijt=jpiglo - ji - nimpp - nfiimpp(isendto(1),jpnj) + 4 
    227                      ARRAY_IN(ji,nlcj,jk,jl,jf) = SGN_IN(jf) * ARRAY2_IN(ijt,ijpj,jk,jl,jf) 
     230                 startloop = 1 + nn_hls 
     231               ENDIF 
     232               IF ( .NOT. l_fast_exchanges ) THEN 
     233                  DO jl = 1, ipl; DO jk = 1, ipk 
     234                       DO jj = 2, nn_hls+1 
     235                     ijj = jpj -jj +1 
     236                        DO ji = startloop, jpi 
     237                           ijt=jpiglo - ji - nimpp - nfimpp(isendto(1)) + 4 
     238                           ARRAY_IN(ji,ijj,jk,jl,jf) = SGN_IN(jf) * ARRAY2_IN(ijt,jj,jk,jl,jf) 
     239                        END DO 
     240                    END DO 
     241                  END DO; END DO 
     242               ENDIF 
     243               DO jl = 1, ipl; DO jk = 1, ipk 
     244                  DO ji = startloop, jpi 
     245                     ijt=jpiglo - ji - nimpp - nfimpp(isendto(1)) + 4 
     246                     ARRAY_IN(ji,jpj,jk,jl,jf) = SGN_IN(jf) * ARRAY2_IN(ijt,1,jk,jl,jf) 
    228247                  END DO 
    229248               END DO; END DO 
    230249               IF (nimpp .eq. 1) THEN 
    231                   ARRAY_IN(1,nlcj,:,:,jf) = SGN_IN(jf) * ARRAY_IN(3,nlcj-3,:,:,jf) 
     250        DO jj = 1, nn_hls 
     251                       ijj = jpj-jj+1 
     252                       DO ii = 0, nn_hls-1 
     253                        ARRAY_IN(ii+1,ijj,:,:,jf) = SGN_IN(jf) * ARRAY_IN(2*nn_hls-ii+1,jpj-2*nn_hls+jj-1,:,:,jf) 
     254           END DO 
     255        END DO 
    232256               ENDIF 
    233257            CASE ( 'F' )                                     ! F-point 
    234                IF( nimpp + nlci - 1 /= jpiglo ) THEN 
    235                   endloop = nlci 
     258               IF( nimpp + jpi - 1 /= jpiglo ) THEN 
     259                  endloop = jpi 
    236260               ELSE 
    237                   endloop = nlci - 1 
    238                ENDIF 
    239                IF ( .NOT. l_fast_exchanges ) THEN 
    240                   DO jl = 1, ipl; DO jk = 1, ipk 
    241                      DO ji = 1, endloop 
    242                         iju = jpiglo - ji - nimpp - nfiimpp(isendto(1),jpnj) + 3 
    243                         ARRAY_IN(ji,nlcj-1,jk,jl,jf) = SGN_IN(jf) * ARRAY2_IN(iju,ijpjp1,jk,jl,jf) 
    244                      END DO 
     261                  endloop = jpi - nn_hls 
     262               ENDIF 
     263               IF ( .NOT. l_fast_exchanges ) THEN 
     264                  DO jl = 1, ipl; DO jk = 1, ipk 
     265                       DO jj = 2, nn_hls+1 
     266                     ijj = jpj -jj +1 
     267                        DO ji = 1, endloop 
     268                           iju = jpiglo - ji - nimpp - nfimpp(isendto(1)) + 3 
     269                           ARRAY_IN(ji,ijj,jk,jl,jf) = SGN_IN(jf) * ARRAY2_IN(iju,jj,jk,jl,jf) 
     270                        END DO 
     271                    END DO 
    245272                  END DO; END DO 
    246273               ENDIF 
    247274               DO jl = 1, ipl; DO jk = 1, ipk 
    248275                  DO ji = 1, endloop 
    249                      iju = jpiglo - ji - nimpp - nfiimpp(isendto(1),jpnj) + 3 
    250                      ARRAY_IN(ji,nlcj,jk,jl,jf) = SGN_IN(jf) * ARRAY2_IN(iju,ijpj,jk,jl,jf) 
    251                   END DO 
    252                END DO; END DO 
    253                IF (nimpp .eq. 1) THEN 
    254                   ARRAY_IN(1,nlcj,:,:,jf) = SGN_IN(jf) * ARRAY_IN(2,nlcj-3,:,:,jf) 
    255                   IF ( .NOT. l_fast_exchanges ) & 
    256                      ARRAY_IN(1,nlcj-1,:,:,jf) = SGN_IN(jf) * ARRAY_IN(2,nlcj-2,:,:,jf) 
    257                ENDIF 
    258                IF((nimpp + nlci - 1) .eq. jpiglo) THEN 
    259                   ARRAY_IN(nlci,nlcj,:,:,jf) = SGN_IN(jf) * ARRAY_IN(nlci-1,nlcj-3,:,:,jf) 
    260                   IF ( .NOT. l_fast_exchanges ) & 
    261                      ARRAY_IN(nlci,nlcj-1,:,:,jf) = SGN_IN(jf) * ARRAY_IN(nlci-1,nlcj-2,:,:,jf) 
    262                ENDIF 
    263                ! 
    264             END SELECT 
     276                     iju = jpiglo - ji - nimpp - nfimpp(isendto(1)) + 3 
     277                     ARRAY_IN(ji,jpj,jk,jl,jf) = SGN_IN(jf) * ARRAY2_IN(iju,1,jk,jl,jf) 
     278                  END DO 
     279               END DO; END DO 
     280      IF (nimpp .eq. 1) THEN                
     281         DO ii = 1, nn_hls 
     282                 ARRAY_IN(ii,jpj,:,:,jf) = SGN_IN(jf) * ARRAY_IN(2*nn_hls-ii,jpj-2*nn_hls-1,:,:,jf) 
     283         END DO 
     284         IF ( .NOT. l_fast_exchanges ) THEN 
     285            DO jj = 1, nn_hls 
     286                      ijj = jpj -jj 
     287                      DO ii = 0, nn_hls-1 
     288                         ARRAY_IN(ii+1,ijj,:,:,jf) = SGN_IN(jf) * ARRAY_IN(2*nn_hls-ii,jpj-2*nn_hls+jj-1,:,:,jf) 
     289                   END DO 
     290                      END DO 
     291                     ENDIF 
     292      ENDIF 
     293      IF((nimpp + jpi - 1 ) .eq. jpiglo) THEN 
     294                   DO ii = 1, nn_hls 
     295                 ARRAY_IN(jpi-ii+1,jpj,:,:,jf) = SGN_IN(jf) * ARRAY_IN(jpi-2*nn_hls+ii,jpj-2*nn_hls-1,:,:,jf) 
     296         END DO 
     297         IF ( .NOT. l_fast_exchanges ) THEN 
     298            DO jj = 1, nn_hls 
     299                           ijj = jpj -jj 
     300                      DO ii = 1, nn_hls 
     301                         ARRAY_IN(jpi-ii+1,ijj,:,:,jf) = SGN_IN(jf) * ARRAY_IN(jpi-2*nn_hls+ii,jpj-2*nn_hls+jj-1,:,:,jf) 
     302                         END DO 
     303                      END DO 
     304                     ENDIF 
     305                  ENDIF 
     306                  ! 
     307       END SELECT 
    265308            ! 
    266309         CASE ( 5, 6 )                        ! *  North fold  F-point pivot 
     
    269312            CASE ( 'T' , 'W' )                               ! T-, W-point 
    270313               DO jl = 1, ipl; DO jk = 1, ipk 
    271                   DO ji = 1, nlci 
    272                      ijt = jpiglo - ji - nimpp - nfiimpp(isendto(1),jpnj) + 3 
    273                      ARRAY_IN(ji,nlcj,jk,jl,jf) = SGN_IN(jf) * ARRAY2_IN(ijt,ijpj,jk,jl,jf) 
    274                   END DO 
     314        DO jj = 1, nn_hls 
     315           ijj = jpj-jj+1 
     316           DO ji = 1, jpi 
     317                        ijt = jpiglo - ji - nimpp - nfimpp(isendto(1)) + 3 
     318                        ARRAY_IN(ji,ijj,jk,jl,jf) = SGN_IN(jf) * ARRAY2_IN(ijt,jj,jk,jl,jf) 
     319                     END DO 
     320        END DO 
    275321               END DO; END DO 
    276322               ! 
    277323            CASE ( 'U' )                                     ! U-point 
    278                IF( nimpp + nlci - 1 /= jpiglo ) THEN 
    279                   endloop = nlci 
     324               IF( nimpp + jpi - 1 /= jpiglo ) THEN 
     325                  endloop = jpi 
    280326               ELSE 
    281                   endloop = nlci - 1 
    282                ENDIF 
    283                DO jl = 1, ipl; DO jk = 1, ipk 
    284                   DO ji = 1, endloop 
    285                      iju = jpiglo - ji - nimpp - nfiimpp(isendto(1),jpnj) + 2 
    286                      ARRAY_IN(ji,nlcj,jk,jl,jf) = SGN_IN(jf) * ARRAY2_IN(iju,ijpj,jk,jl,jf) 
    287                   END DO 
    288                END DO; END DO 
    289                IF((nimpp + nlci - 1) .eq. jpiglo) THEN 
    290                   DO jl = 1, ipl; DO jk = 1, ipk 
    291                      ARRAY_IN(nlci,nlcj,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(nlci-2,nlcj-1,jk,jl,jf) 
     327                  endloop = jpi - nn_hls 
     328               ENDIF 
     329               DO jl = 1, ipl; DO jk = 1, ipk 
     330        DO jj = 1, nn_hls 
     331           ijj = jpj-jj+1 
     332                     DO ji = 1, endloop 
     333                        iju = jpiglo - ji - nimpp - nfimpp(isendto(1)) + 2 
     334                        ARRAY_IN(ji,ijj,jk,jl,jf) = SGN_IN(jf) * ARRAY2_IN(iju,jj,jk,jl,jf) 
     335                     END DO 
     336                  END DO 
     337               END DO; END DO 
     338               IF(nimpp + jpi - 1 .eq. jpiglo) THEN 
     339                  DO jl = 1, ipl; DO jk = 1, ipk 
     340                     DO jj = 1, nn_hls 
     341                          ijj = jpj-jj+1 
     342                        DO ii = 1, nn_hls 
     343            iij = jpi-ii+1 
     344                           ARRAY_IN(iij,ijj,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(jpi-2*nn_hls+ii-1,jpj-2*nn_hls+jj,jk,jl,jf) 
     345                        END DO 
     346                     END DO 
    292347                  END DO; END DO 
    293348               ENDIF 
     
    295350            CASE ( 'V' )                                     ! V-point 
    296351               DO jl = 1, ipl; DO jk = 1, ipk 
    297                   DO ji = 1, nlci 
    298                      ijt = jpiglo - ji - nimpp - nfiimpp(isendto(1),jpnj) + 3 
    299                      ARRAY_IN(ji,nlcj,jk,jl,jf) = SGN_IN(jf) * ARRAY2_IN(ijt,ijpj,jk,jl,jf) 
     352        DO jj = 1, nn_hls 
     353           ijj = jpj -jj +1 
     354                     DO ji = 1, jpi 
     355                        ijt = jpiglo - ji - nimpp - nfimpp(isendto(1)) + 3 
     356                        ARRAY_IN(ji,ijj,jk,jl,jf) = SGN_IN(jf) * ARRAY2_IN(ijt,jj,jk,jl,jf) 
     357                     END DO 
    300358                  END DO 
    301359               END DO; END DO 
    302360 
    303361               IF ( .NOT. l_fast_exchanges ) THEN 
    304                   IF( nimpp >= jpiglo/2+1 ) THEN 
     362                  IF( nimpp >= Ni0glo/2+2 ) THEN 
    305363                     startloop = 1 
    306                   ELSEIF( nimpp+nlci-1 >= jpiglo/2+1 .AND. nimpp < jpiglo/2+1 ) THEN 
    307                      startloop = jpiglo/2+1 - nimpp + 1 
    308                   ELSE 
    309                      startloop = nlci + 1 
    310                   ENDIF 
    311                   IF( startloop <= nlci ) THEN 
    312                   DO jl = 1, ipl; DO jk = 1, ipk 
    313                      DO ji = startloop, nlci 
    314                         ijt = jpiglo - ji - nimpp - nfiimpp(isendto(1),jpnj) + 3 
    315                         ARRAY_IN(ji,nlcj-1,jk,jl,jf) = SGN_IN(jf) * ARRAY2_IN(ijt,ijpjp1,jk,jl,jf) 
    316                      END DO 
     364                  ELSEIF( nimpp+jpi-1 >= Ni0glo/2+2 .AND. nimpp < Ni0glo/2+2 ) THEN 
     365                     startloop = Ni0glo/2+2 - nimpp + nn_hls 
     366                  ELSE 
     367                     startloop = jpi + 1 
     368                  ENDIF 
     369                  IF( startloop <= jpi ) THEN 
     370                  DO jl = 1, ipl; DO jk = 1, ipk 
     371                        DO ji = startloop, jpi 
     372                        ijt = jpiglo - ji - nimpp - nfimpp(isendto(1)) + 3 
     373                           ARRAY_IN(ji,jpj-nn_hls,jk,jl,jf) = SGN_IN(jf) * ARRAY2_IN(ijt,nn_hls+1,jk,jl,jf) 
     374                        END DO 
    317375                  END DO; END DO 
    318376                  ENDIF 
     
    320378               ! 
    321379            CASE ( 'F' )                               ! F-point 
    322                IF( nimpp + nlci - 1 /= jpiglo ) THEN 
    323                   endloop = nlci 
     380               IF( nimpp + jpi - 1 /= jpiglo ) THEN 
     381                  endloop = jpi 
    324382               ELSE 
    325                   endloop = nlci - 1 
    326                ENDIF 
    327                DO jl = 1, ipl; DO jk = 1, ipk 
    328                   DO ji = 1, endloop 
    329                      iju = jpiglo - ji - nimpp - nfiimpp(isendto(1),jpnj) + 2 
    330                      ARRAY_IN(ji,nlcj ,jk,jl,jf) = SGN_IN(jf) * ARRAY2_IN(iju,ijpj,jk,jl,jf) 
    331                   END DO 
    332                END DO; END DO 
    333                IF((nimpp + nlci - 1) .eq. jpiglo) THEN 
    334                   DO jl = 1, ipl; DO jk = 1, ipk 
    335                      ARRAY_IN(nlci,nlcj,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(nlci-2,nlcj-2,jk,jl,jf) 
    336                   END DO; END DO 
    337                ENDIF 
    338                ! 
    339                IF ( .NOT. l_fast_exchanges ) THEN 
    340                   IF( nimpp + nlci - 1 /= jpiglo ) THEN 
    341                      endloop = nlci 
    342                   ELSE 
    343                      endloop = nlci - 1 
    344                   ENDIF 
    345                   IF( nimpp >= jpiglo/2+1 ) THEN 
    346                      startloop = 1 
    347                   ELSEIF( nimpp+nlci-1 >= jpiglo/2+1 .AND. nimpp < jpiglo/2+1 ) THEN 
    348                      startloop = jpiglo/2+1 - nimpp + 1 
     383                  endloop = jpi - nn_hls 
     384               ENDIF 
     385               DO jl = 1, ipl; DO jk = 1, ipk 
     386        DO jj = 1, nn_hls 
     387          ijj = jpj -jj +1 
     388                    DO ji = 1, endloop 
     389                       iju = jpiglo - ji - nimpp - nfimpp(isendto(1)) + 2 
     390                       ARRAY_IN(ji,ijj ,jk,jl,jf) = SGN_IN(jf) * ARRAY2_IN(iju,jj,jk,jl,jf) 
     391                     END DO 
     392                  END DO 
     393               END DO; END DO 
     394               IF((nimpp + jpi - 1) .eq. jpiglo) THEN 
     395                  DO jl = 1, ipl; DO jk = 1, ipk 
     396                     DO jj = 1, nn_hls 
     397                        ijj = jpj -jj +1 
     398                        DO ii = 1, nn_hls 
     399            iij = jpi -ii+1 
     400                           ARRAY_IN(iij,ijj,jk,jl,jf) = SGN_IN(jf) * ARRAY_IN(jpi-2*nn_hls+ii-1,jpj-2*nn_hls+jj-1,jk,jl,jf) 
     401                        END DO 
     402                     END DO 
     403                  END DO; END DO 
     404               ENDIF 
     405               ! 
     406               IF ( .NOT. l_fast_exchanges ) THEN 
     407                  IF( nimpp + jpi - 1 /= jpiglo ) THEN 
     408                     endloop = jpi 
     409                  ELSE 
     410                     endloop = jpi - nn_hls 
     411                  ENDIF 
     412                  IF( nimpp >= Ni0glo/2+2 ) THEN 
     413                     startloop = 1  
     414                  ELSEIF( nimpp+jpi-1 >= Ni0glo/2+2 .AND. nimpp < Ni0glo/2+2 ) THEN 
     415                     startloop = Ni0glo/2+2 - nimpp + nn_hls 
    349416                  ELSE 
    350417                     startloop = endloop + 1 
     
    353420                     DO jl = 1, ipl; DO jk = 1, ipk 
    354421                        DO ji = startloop, endloop 
    355                            iju = jpiglo - ji - nimpp - nfiimpp(isendto(1),jpnj) + 2 
    356                            ARRAY_IN(ji,nlcj-1,jk,jl,jf) = SGN_IN(jf) * ARRAY2_IN(iju,ijpjp1,jk,jl,jf) 
     422                           iju = jpiglo - ji - nimpp - nfimpp(isendto(1)) + 2 
     423                           ARRAY_IN(ji,jpj-nn_hls,jk,jl,jf) = SGN_IN(jf) * ARRAY2_IN(iju,nn_hls+1,jk,jl,jf) 
    357424                        END DO 
    358425                     END DO; END DO 
  • NEMO/trunk/src/OCE/LBC/lbcnfd.F90

    r13226 r13286  
    7070 
    7171   INTEGER, PUBLIC, PARAMETER            ::   jpmaxngh = 3               !: 
    72    INTEGER, PUBLIC                       ::   nsndto, nfsloop, nfeloop   !: 
     72   INTEGER, PUBLIC                       ::   nsndto                     !: 
    7373   INTEGER, PUBLIC, DIMENSION (jpmaxngh) ::   isendto                    !: processes to which communicate 
     74   INTEGER, PUBLIC                       ::   ijpj 
    7475 
    7576   !!---------------------------------------------------------------------- 
  • NEMO/trunk/src/OCE/LBC/lib_mpp.F90

    r13226 r13286  
    10981098      ! Look for how many procs on the northern boundary 
    10991099      ndim_rank_north = 0 
    1100       DO jjproc = 1, jpnij 
    1101          IF( njmppt(jjproc) == njmppmax )   ndim_rank_north = ndim_rank_north + 1 
     1100      DO jjproc = 1, jpni 
     1101         IF( nfproc(jjproc) /= -1 )   ndim_rank_north = ndim_rank_north + 1 
    11021102      END DO 
    11031103      ! 
     
    11091109      ! Note : the rank start at 0 in MPI 
    11101110      ii = 0 
    1111       DO ji = 1, jpnij 
    1112          IF ( njmppt(ji) == njmppmax   ) THEN 
     1111      DO ji = 1, jpni 
     1112         IF ( nfproc(ji) /= -1   ) THEN 
    11131113            ii=ii+1 
    1114             nrank_north(ii)=ji-1 
     1114            nrank_north(ii)=nfproc(ji) 
    11151115         END IF 
    11161116      END DO 
  • NEMO/trunk/src/OCE/LBC/mpp_lbc_north_icb_generic.h90

    r13226 r13286  
    3636      ! 
    3737      INTEGER ::   ji, jj, jr 
    38       INTEGER ::   ierr, itaille, ildi, ilei, iilb 
    39       INTEGER ::   ipj, ij, iproc 
     38      INTEGER ::   ierr, itaille 
     39      INTEGER ::   ipj, ij, iproc, ijnr, ii1, ipi, impp 
    4040      ! 
    4141      REAL(PRECISION), DIMENSION(:,:)  , ALLOCATABLE  ::  ztab_e, znorthloc_e 
     
    4747      ALLOCATE(        ztab_e(jpiglo, 1-kextj:ipj+kextj)       ,       & 
    4848     &            znorthloc_e(jpimax, 1-kextj:ipj+kextj)       ,       & 
    49      &          znorthgloio_e(jpimax, 1-kextj:ipj+kextj,jpni)    ) 
     49     &          znorthgloio_e(jpimax, 1-kextj:ipj+kextj,ndim_rank_north)    ) 
    5050      ! 
    5151# if defined SINGLE_PRECISION 
     
    7373      IF( ln_timing ) CALL tic_tac(.FALSE.) 
    7474      ! 
     75      ijnr = 0 
    7576      DO jr = 1, ndim_rank_north            ! recover the global north array 
    76          iproc = nrank_north(jr) + 1 
    77          ildi = nldit (iproc) 
    78          ilei = nleit (iproc) 
    79          iilb = nimppt(iproc) 
    80          DO jj = 1-kextj, ipj+kextj 
    81             DO ji = ildi, ilei 
    82                ztab_e(ji+iilb-1,jj) = znorthgloio_e(ji,jj,jr) 
     77         iproc = nfproc(jr) 
     78         IF( iproc /= -1 ) THEN 
     79            impp = nfimpp(jr) 
     80            ipi  = nfjpi(jr) 
     81            ijnr = ijnr + 1 
     82            DO jj = 1-kextj, ipj+kextj 
     83               DO ji = 1, ipi 
     84                  ii1 = impp + ji - 1       ! corresponds to mig(ji) but for subdomain iproc 
     85                  ztab_e(ii1,jj) = znorthgloio_e(ji,jj,ijnr) 
     86               END DO 
    8387            END DO 
    84          END DO 
     88         ENDIF 
    8589      END DO 
    8690 
  • NEMO/trunk/src/OCE/LBC/mpp_lnk_generic.h90

    r13226 r13286  
    7272 
    7373#if defined MULTI 
    74    SUBROUTINE ROUTINE_LNK( cdname, ptab, cd_nat, psgn, kfld, kfillmode, pfillval, lsend, lrecv, ihlcom ) 
     74   SUBROUTINE ROUTINE_LNK( cdname, ptab, cd_nat, psgn, kfld, kfillmode, pfillval, lsend, lrecv ) 
    7575      INTEGER             , INTENT(in   ) ::   kfld        ! number of pt3d arrays 
    7676#else 
    77    SUBROUTINE ROUTINE_LNK( cdname, ptab, cd_nat, psgn      , kfillmode, pfillval, lsend, lrecv, ihlcom ) 
     77   SUBROUTINE ROUTINE_LNK( cdname, ptab, cd_nat, psgn      , kfillmode, pfillval, lsend, lrecv ) 
    7878#endif 
    7979      ARRAY_TYPE(:,:,:,:,:)                                        ! array or pointer of arrays on which the boundary condition is applied 
     
    8484      REAL(wp),             OPTIONAL, INTENT(in   ) ::   pfillval    ! background value (used at closed boundaries) 
    8585      LOGICAL, DIMENSION(4),OPTIONAL, INTENT(in   ) ::   lsend, lrecv  ! communication with other 4 proc 
    86       INTEGER              ,OPTIONAL, INTENT(in   ) ::   ihlcom        ! number of ranks and rows to be communicated 
    8786      ! 
    8887      INTEGER  ::    ji,  jj,  jk,  jl,  jf      ! dummy loop indices 
     
    9291      INTEGER  ::   ierr 
    9392      INTEGER  ::   ifill_we, ifill_ea, ifill_so, ifill_no 
    94       INTEGER  ::   ihl                          ! number of ranks and rows to be communicated  
    95       REAL(PRECISION) ::   zland 
     93      REAL(wp) ::   zland 
    9694      INTEGER , DIMENSION(MPI_STATUS_SIZE)        ::   istat          ! for mpi_isend 
    9795      REAL(PRECISION), DIMENSION(:,:,:,:,:), ALLOCATABLE ::   zsnd_we, zrcv_we, zsnd_ea, zrcv_ea   ! east -west  & west - east  halos 
     
    109107      ipl = L_SIZE(ptab)   ! 4th    - 
    110108      ipf = F_SIZE(ptab)   ! 5th    -      use in "multi" case (array of pointers) 
    111       ! 
    112       IF( PRESENT(ihlcom) ) THEN   ;   ihl = ihlcom 
    113       ELSE                         ;   ihl = 1 
    114       END IF 
    115109      ! 
    116110      IF( narea == 1 .AND. numcom == -1 ) CALL mpp_report( cdname, ipk, ipl, ipf, ld_lbc = .TRUE. ) 
     
    175169      ! 
    176170      ! Must exchange the whole column (from 1 to jpj) to get the corners if we have no south/north neighbourg 
    177       isize = ihl * jpj * ipk * ipl * ipf       
     171      isize = nn_hls * jpj * ipk * ipl * ipf       
    178172      ! 
    179173      ! Allocate local temporary arrays to be sent/received. Fill arrays to be sent 
    180       IF( llsend_we )   ALLOCATE( zsnd_we(ihl,jpj,ipk,ipl,ipf) ) 
    181       IF( llsend_ea )   ALLOCATE( zsnd_ea(ihl,jpj,ipk,ipl,ipf) ) 
    182       IF( llrecv_we )   ALLOCATE( zrcv_we(ihl,jpj,ipk,ipl,ipf) ) 
    183       IF( llrecv_ea )   ALLOCATE( zrcv_ea(ihl,jpj,ipk,ipl,ipf) ) 
     174      IF( llsend_we )   ALLOCATE( zsnd_we(nn_hls,jpj,ipk,ipl,ipf) ) 
     175      IF( llsend_ea )   ALLOCATE( zsnd_ea(nn_hls,jpj,ipk,ipl,ipf) ) 
     176      IF( llrecv_we )   ALLOCATE( zrcv_we(nn_hls,jpj,ipk,ipl,ipf) ) 
     177      IF( llrecv_ea )   ALLOCATE( zrcv_ea(nn_hls,jpj,ipk,ipl,ipf) ) 
    184178      ! 
    185179      IF( llsend_we ) THEN   ! copy western side of the inner mpi domain in local temporary array to be sent by MPI 
    186          ishift = ihl 
    187          DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, jpj   ;   DO ji = 1, ihl 
    188             zsnd_we(ji,jj,jk,jl,jf) = ARRAY_IN(ishift+ji,jj,jk,jl,jf)   ! ihl + 1 -> 2*ihl 
     180         ishift = nn_hls 
     181         DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, jpj   ;   DO ji = 1, nn_hls 
     182            zsnd_we(ji,jj,jk,jl,jf) = ARRAY_IN(ishift+ji,jj,jk,jl,jf)   ! nn_hls + 1 -> 2*nn_hls 
    189183         END DO   ;   END DO   ;   END DO   ;   END DO   ;   END DO 
    190184      ENDIF 
    191185      ! 
    192186      IF(llsend_ea  ) THEN   ! copy eastern side of the inner mpi domain in local temporary array to be sent by MPI 
    193          ishift = jpi - 2 * ihl 
    194          DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, jpj   ;   DO ji = 1, ihl 
    195             zsnd_ea(ji,jj,jk,jl,jf) = ARRAY_IN(ishift+ji,jj,jk,jl,jf)   ! jpi - 2*ihl + 1 -> jpi - ihl 
     187         ishift = jpi - 2 * nn_hls 
     188         DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, jpj   ;   DO ji = 1, nn_hls 
     189            zsnd_ea(ji,jj,jk,jl,jf) = ARRAY_IN(ishift+ji,jj,jk,jl,jf)   ! jpi - 2*nn_hls + 1 -> jpi - nn_hls 
    196190         END DO   ;   END DO   ;   END DO   ;   END DO   ;   END DO 
    197191      ENDIF 
     
    215209      ! 2.1 fill weastern halo 
    216210      ! ---------------------- 
    217       ! ishift = 0                         ! fill halo from ji = 1 to ihl 
     211      ! ishift = 0                         ! fill halo from ji = 1 to nn_hls 
    218212      SELECT CASE ( ifill_we ) 
    219213      CASE ( jpfillnothing )               ! no filling  
    220214      CASE ( jpfillmpi   )                 ! use data received by MPI  
    221          DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, jpj   ;   DO ji = 1, ihl 
    222             ARRAY_IN(ji,jj,jk,jl,jf) = zrcv_we(ji,jj,jk,jl,jf)   ! 1 -> ihl 
    223          END DO;   END DO   ;   END DO   ;   END DO   ;   END DO 
     215         DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, jpj   ;   DO ji = 1, nn_hls 
     216            ARRAY_IN(ji,jj,jk,jl,jf) = zrcv_we(ji,jj,jk,jl,jf)   ! 1 -> nn_hls 
     217         END DO   ;   END DO   ;   END DO   ;   END DO   ;   END DO 
    224218      CASE ( jpfillperio )                 ! use east-weast periodicity 
    225          ishift2 = jpi - 2 * ihl 
    226          DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, jpj   ;   DO ji = 1, ihl 
     219         ishift2 = jpi - 2 * nn_hls 
     220         DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, jpj   ;   DO ji = 1, nn_hls 
    227221            ARRAY_IN(ji,jj,jk,jl,jf) = ARRAY_IN(ishift2+ji,jj,jk,jl,jf) 
    228          END DO;   END DO   ;   END DO   ;   END DO   ;   END DO 
     222         END DO   ;   END DO   ;   END DO   ;   END DO   ;   END DO 
    229223      CASE ( jpfillcopy  )                 ! filling with inner domain values 
    230          DO jf = 1, ipf                               ! number of arrays to be treated 
    231             IF( .NOT. NAT_IN(jf) == 'F' ) THEN        ! do nothing for F point 
    232                DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, jpj   ;   DO ji = 1, ihl 
    233                   ARRAY_IN(ji,jj,jk,jl,jf) = ARRAY_IN(ihl+1,jj,jk,jl,jf) 
    234                END DO   ;   END DO   ;   END DO   ;   END DO 
    235             ENDIF 
    236          END DO 
     224         DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, jpj   ;   DO ji = 1, nn_hls 
     225            ARRAY_IN(ji,jj,jk,jl,jf) = ARRAY_IN(nn_hls+1,jj,jk,jl,jf) 
     226         END DO   ;   END DO   ;   END DO   ;   END DO   ;   END DO 
    237227      CASE ( jpfillcst   )                 ! filling with constant value 
    238          DO jf = 1, ipf                               ! number of arrays to be treated 
    239             IF( .NOT. NAT_IN(jf) == 'F' ) THEN        ! do nothing for F point 
    240                DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, jpj   ;   DO ji = 1, ihl 
    241                   ARRAY_IN(ji,jj,jk,jl,jf) = zland 
    242                END DO;   END DO   ;   END DO   ;   END DO 
    243             ENDIF 
    244          END DO 
     228         DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, jpj   ;   DO ji = 1, nn_hls 
     229            ARRAY_IN(ji,jj,jk,jl,jf) = zland 
     230         END DO   ;   END DO   ;   END DO   ;   END DO   ;   END DO 
    245231      END SELECT 
    246232      ! 
    247233      ! 2.2 fill eastern halo 
    248234      ! --------------------- 
    249       ishift = jpi - ihl                ! fill halo from ji = jpi-ihl+1 to jpi  
     235      ishift = jpi - nn_hls                ! fill halo from ji = jpi-nn_hls+1 to jpi  
    250236      SELECT CASE ( ifill_ea ) 
    251237      CASE ( jpfillnothing )               ! no filling  
    252238      CASE ( jpfillmpi   )                 ! use data received by MPI  
    253          DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, jpj   ;   DO ji = 1, ihl 
    254             ARRAY_IN(ishift+ji,jj,jk,jl,jf) = zrcv_ea(ji,jj,jk,jl,jf)   ! jpi - ihl + 1 -> jpi 
     239         DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, jpj   ;   DO ji = 1, nn_hls 
     240            ARRAY_IN(ishift+ji,jj,jk,jl,jf) = zrcv_ea(ji,jj,jk,jl,jf)   ! jpi - nn_hls + 1 -> jpi 
    255241         END DO   ;   END DO   ;   END DO   ;   END DO   ;   END DO 
    256242      CASE ( jpfillperio )                 ! use east-weast periodicity 
    257          ishift2 = ihl 
    258          DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, jpj   ;   DO ji = 1, ihl 
     243         ishift2 = nn_hls 
     244         DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, jpj   ;   DO ji = 1, nn_hls 
    259245            ARRAY_IN(ishift+ji,jj,jk,jl,jf) = ARRAY_IN(ishift2+ji,jj,jk,jl,jf) 
    260246         END DO   ;   END DO   ;   END DO   ;   END DO   ;   END DO 
    261247      CASE ( jpfillcopy  )                 ! filling with inner domain values 
    262          DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, jpj   ;   DO ji = 1, ihl 
     248         DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, jpj   ;   DO ji = 1, nn_hls 
    263249            ARRAY_IN(ishift+ji,jj,jk,jl,jf) = ARRAY_IN(ishift,jj,jk,jl,jf) 
    264250         END DO   ;   END DO   ;   END DO   ;   END DO   ;   END DO 
    265251      CASE ( jpfillcst   )                 ! filling with constant value 
    266          DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, jpj   ;   DO ji = 1, ihl 
     252         DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, jpj   ;   DO ji = 1, nn_hls 
    267253            ARRAY_IN(ishift+ji,jj,jk,jl,jf) = zland 
    268          END DO;   END DO   ;   END DO   ;   END DO   ;   END DO 
     254         END DO   ;   END DO   ;   END DO   ;   END DO   ;   END DO 
    269255      END SELECT 
    270256      ! 
     
    278264         ! 
    279265         SELECT CASE ( jpni ) 
    280          CASE ( 1 )     ;   CALL lbc_nfd( ptab, NAT_IN(:), SGN_IN(:) OPT_K(:) )   ! only 1 northern proc, no mpp 
    281          CASE DEFAULT   ;   CALL mpp_nfd( ptab, NAT_IN(:), SGN_IN(:) OPT_K(:) )   ! for all northern procs. 
     266         CASE ( 1 )     ;   CALL lbc_nfd( ptab, NAT_IN(:), SGN_IN(:)                  OPT_K(:) )   ! only 1 northern proc, no mpp 
     267         CASE DEFAULT   ;   CALL mpp_nfd( ptab, NAT_IN(:), SGN_IN(:), ifill_no, zland OPT_K(:) )   ! for all northern procs. 
    282268         END SELECT 
    283269         ! 
     
    290276      ! ---------------------------------------------------- ! 
    291277      ! 
    292       IF( llsend_so )   ALLOCATE( zsnd_so(jpi,ihl,ipk,ipl,ipf) ) 
    293       IF( llsend_no )   ALLOCATE( zsnd_no(jpi,ihl,ipk,ipl,ipf) ) 
    294       IF( llrecv_so )   ALLOCATE( zrcv_so(jpi,ihl,ipk,ipl,ipf) ) 
    295       IF( llrecv_no )   ALLOCATE( zrcv_no(jpi,ihl,ipk,ipl,ipf) ) 
    296       ! 
    297       isize = jpi * ihl * ipk * ipl * ipf       
     278      IF( llsend_so )   ALLOCATE( zsnd_so(jpi,nn_hls,ipk,ipl,ipf) ) 
     279      IF( llsend_no )   ALLOCATE( zsnd_no(jpi,nn_hls,ipk,ipl,ipf) ) 
     280      IF( llrecv_so )   ALLOCATE( zrcv_so(jpi,nn_hls,ipk,ipl,ipf) ) 
     281      IF( llrecv_no )   ALLOCATE( zrcv_no(jpi,nn_hls,ipk,ipl,ipf) ) 
     282      ! 
     283      isize = jpi * nn_hls * ipk * ipl * ipf       
    298284 
    299285      ! allocate local temporary arrays to be sent/received. Fill arrays to be sent 
    300286      IF( llsend_so ) THEN   ! copy sourhern side of the inner mpi domain in local temporary array to be sent by MPI 
    301          ishift = ihl 
    302          DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, ihl   ;   DO ji = 1, jpi 
    303             zsnd_so(ji,jj,jk,jl,jf) = ARRAY_IN(ji,ishift+jj,jk,jl,jf)   ! ihl+1 -> 2*ihl 
     287         ishift = nn_hls 
     288         DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, nn_hls   ;   DO ji = 1, jpi 
     289            zsnd_so(ji,jj,jk,jl,jf) = ARRAY_IN(ji,ishift+jj,jk,jl,jf)   ! nn_hls+1 -> 2*nn_hls 
    304290         END DO   ;   END DO   ;   END DO   ;   END DO   ;   END DO 
    305291      ENDIF 
    306292      ! 
    307293      IF( llsend_no ) THEN   ! copy eastern side of the inner mpi domain in local temporary array to be sent by MPI 
    308          ishift = jpj - 2 * ihl 
    309          DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, ihl   ;   DO ji = 1, jpi 
    310             zsnd_no(ji,jj,jk,jl,jf) = ARRAY_IN(ji,ishift+jj,jk,jl,jf)   ! jpj-2*ihl+1 -> jpj-ihl 
     294         ishift = jpj - 2 * nn_hls 
     295         DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, nn_hls   ;   DO ji = 1, jpi 
     296            zsnd_no(ji,jj,jk,jl,jf) = ARRAY_IN(ji,ishift+jj,jk,jl,jf)   ! jpj-2*nn_hls+1 -> jpj-nn_hls 
    311297         END DO   ;   END DO   ;   END DO   ;   END DO   ;   END DO 
    312298      ENDIF 
     
    329315      ! 5.1 fill southern halo 
    330316      ! ---------------------- 
    331       ! ishift = 0                         ! fill halo from jj = 1 to ihl 
     317      ! ishift = 0                         ! fill halo from jj = 1 to nn_hls 
    332318      SELECT CASE ( ifill_so ) 
    333319      CASE ( jpfillnothing )               ! no filling  
    334320      CASE ( jpfillmpi   )                 ! use data received by MPI  
    335          DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, ihl   ;   DO ji = 1, jpi 
    336             ARRAY_IN(ji,jj,jk,jl,jf) = zrcv_so(ji,jj,jk,jl,jf)   ! 1 -> ihl 
    337          END DO;   END DO   ;   END DO   ;   END DO   ;   END DO 
     321         DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, nn_hls   ;   DO ji = 1, jpi 
     322            ARRAY_IN(ji,jj,jk,jl,jf) = zrcv_so(ji,jj,jk,jl,jf)   ! 1 -> nn_hls 
     323         END DO   ;   END DO   ;   END DO   ;   END DO   ;   END DO 
    338324      CASE ( jpfillperio )                 ! use north-south periodicity 
    339          ishift2 = jpj - 2 * ihl 
    340          DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, ihl   ;   DO ji = 1, jpi 
     325         ishift2 = jpj - 2 * nn_hls 
     326         DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, nn_hls   ;   DO ji = 1, jpi 
    341327            ARRAY_IN(ji,jj,jk,jl,jf) = ARRAY_IN(ji,ishift2+jj,jk,jl,jf) 
    342          END DO;   END DO   ;   END DO   ;   END DO   ;   END DO 
     328         END DO   ;   END DO   ;   END DO   ;   END DO   ;   END DO 
    343329      CASE ( jpfillcopy  )                 ! filling with inner domain values 
    344          DO jf = 1, ipf                               ! number of arrays to be treated 
    345             IF( .NOT. NAT_IN(jf) == 'F' ) THEN        ! do nothing for F point 
    346                DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, ihl   ;   DO ji = 1, jpi 
    347                   ARRAY_IN(ji,jj,jk,jl,jf) = ARRAY_IN(ji,ihl+1,jk,jl,jf) 
    348                END DO   ;   END DO   ;   END DO   ;   END DO 
    349             ENDIF 
    350          END DO 
     330         DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, nn_hls   ;   DO ji = 1, jpi 
     331            ARRAY_IN(ji,jj,jk,jl,jf) = ARRAY_IN(ji,nn_hls+1,jk,jl,jf) 
     332         END DO   ;   END DO   ;   END DO   ;   END DO   ;   END DO 
    351333      CASE ( jpfillcst   )                 ! filling with constant value 
    352          DO jf = 1, ipf                               ! number of arrays to be treated 
    353             IF( .NOT. NAT_IN(jf) == 'F' ) THEN        ! do nothing for F point 
    354                DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, ihl   ;   DO ji = 1, jpi  
    355                   ARRAY_IN(ji,jj,jk,jl,jf) = zland 
    356                END DO;   END DO   ;   END DO   ;   END DO 
    357             ENDIF 
    358          END DO 
     334         DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, nn_hls   ;   DO ji = 1, jpi  
     335            ARRAY_IN(ji,jj,jk,jl,jf) = zland 
     336         END DO   ;   END DO   ;   END DO   ;   END DO   ;   END DO 
    359337      END SELECT 
    360338      ! 
    361339      ! 5.2 fill northern halo 
    362340      ! ---------------------- 
    363       ishift = jpj - ihl                ! fill halo from jj = jpj-ihl+1 to jpj  
     341      ishift = jpj - nn_hls                ! fill halo from jj = jpj-nn_hls+1 to jpj  
    364342      SELECT CASE ( ifill_no ) 
    365343      CASE ( jpfillnothing )               ! no filling  
    366344      CASE ( jpfillmpi   )                 ! use data received by MPI  
    367          DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, ihl   ;   DO ji = 1, jpi 
    368             ARRAY_IN(ji,ishift+jj,jk,jl,jf) = zrcv_no(ji,jj,jk,jl,jf)   ! jpj-ihl+1 -> jpj 
     345         DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, nn_hls   ;   DO ji = 1, jpi 
     346            ARRAY_IN(ji,ishift+jj,jk,jl,jf) = zrcv_no(ji,jj,jk,jl,jf)   ! jpj-nn_hls+1 -> jpj 
    369347         END DO   ;   END DO   ;   END DO   ;   END DO   ;   END DO 
    370348      CASE ( jpfillperio )                 ! use north-south periodicity 
    371          ishift2 = ihl 
    372          DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, ihl   ;   DO ji = 1, jpi 
     349         ishift2 = nn_hls 
     350         DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, nn_hls   ;   DO ji = 1, jpi 
    373351            ARRAY_IN(ji,ishift+jj,jk,jl,jf) = ARRAY_IN(ji,ishift2+jj,jk,jl,jf) 
    374          END DO;   END DO   ;   END DO   ;   END DO   ;   END DO 
     352         END DO   ;   END DO   ;   END DO   ;   END DO   ;   END DO 
    375353      CASE ( jpfillcopy  )                 ! filling with inner domain values 
    376          DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, ihl   ;   DO ji = 1, jpi 
     354         DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, nn_hls   ;   DO ji = 1, jpi 
    377355            ARRAY_IN(ji,ishift+jj,jk,jl,jf) = ARRAY_IN(ji,ishift,jk,jl,jf) 
    378          END DO;   END DO   ;   END DO   ;   END DO   ;   END DO 
     356         END DO   ;   END DO   ;   END DO   ;   END DO   ;   END DO 
    379357      CASE ( jpfillcst   )                 ! filling with constant value 
    380          DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, ihl   ;   DO ji = 1, jpi 
     358         DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk   ;   DO jj = 1, nn_hls   ;   DO ji = 1, jpi 
    381359            ARRAY_IN(ji,ishift+jj,jk,jl,jf) = zland 
    382          END DO;   END DO   ;   END DO   ;   END DO   ;   END DO 
     360         END DO   ;   END DO   ;   END DO   ;   END DO   ;   END DO 
    383361      END SELECT 
    384362      ! 
     
    410388      ! 
    411389   END SUBROUTINE ROUTINE_LNK 
    412  
     390#undef PRECISION 
     391#undef SENDROUTINE 
     392#undef RECVROUTINE 
    413393#undef ARRAY_TYPE 
    414394#undef NAT_IN 
  • NEMO/trunk/src/OCE/LBC/mpp_lnk_icb_generic.h90

    r13226 r13286  
    105105      SELECT CASE ( nbondi )      ! Read Dirichlet lateral conditions 
    106106      CASE ( -1, 0, 1 )                ! all exept 2 (i.e. close case) 
    107          iihom = jpi-nreci-kexti 
     107         iihom = jpi - (2 * nn_hls) -kexti 
    108108         DO jl = 1, ipreci 
    109109            r2dew(:,jl,1) = pt2d(nn_hls+jl,:) 
     
    165165      ! 
    166166      IF( nbondj /= 2 ) THEN      ! Read Dirichlet lateral conditions 
    167          ijhom = jpj-nrecj-kextj 
     167         ijhom = jpj - (2 * nn_hls) - kextj 
    168168         DO jl = 1, iprecj 
    169169            r2dsn(:,jl,1) = pt2d(:,ijhom +jl) 
  • NEMO/trunk/src/OCE/LBC/mpp_loc_generic.h90

    r13226 r13286  
    109109#undef PRECISION 
    110110#undef ARRAY_TYPE 
    111 #undef MAX_TYPE 
     111#undef MASK_TYPE 
    112112#undef ARRAY_IN 
    113113#undef MASK_IN 
  • NEMO/trunk/src/OCE/LBC/mpp_nfd_generic.h90

    r13226 r13286  
    7474# endif 
    7575 
    76    SUBROUTINE ROUTINE_NFD( ptab, cd_nat, psgn, kfld ) 
     76   SUBROUTINE ROUTINE_NFD( ptab, cd_nat, psgn, kfillmode, pfillval, kfld ) 
    7777      !!---------------------------------------------------------------------- 
    7878      ARRAY_TYPE(:,:,:,:,:)   ! array or pointer of arrays on which the boundary condition is applied 
    7979      CHARACTER(len=1) , INTENT(in   ) ::   NAT_IN(:)   ! nature of array grid-points 
    8080      REAL(wp)         , INTENT(in   ) ::   SGN_IN(:)   ! sign used across the north fold boundary 
     81      INTEGER          , INTENT(in   ) ::   kfillmode   ! filling method for halo over land  
     82      REAL(wp)         , INTENT(in   ) ::   pfillval    ! background value (used at closed boundaries) 
    8183      INTEGER, OPTIONAL, INTENT(in   ) ::   kfld        ! number of pt3d arrays 
    8284      ! 
     85      LOGICAL  ::   ll_add_line 
    8386      INTEGER  ::   ji,  jj,  jk,  jl, jh, jf, jr   ! dummy loop indices 
    84       INTEGER  ::   ipi, ipj, ipk, ipl, ipf         ! dimension of the input array 
     87      INTEGER  ::   ipi, ipj, ipj2, ipk, ipl, ipf   ! dimension of the input array 
    8588      INTEGER  ::   imigr, iihom, ijhom             ! local integers 
    86       INTEGER  ::   ierr, ibuffsize, ilci, ildi, ilei, iilb 
    87       INTEGER  ::   ij, iproc 
     89      INTEGER  ::   ierr, ibuffsize, iis0, iie0, impp 
     90      INTEGER  ::   ii1, ii2, ij1, ij2 
     91      INTEGER  ::   ipimax, i0max 
     92      INTEGER  ::   ij, iproc, ipni, ijnr 
    8893      INTEGER, DIMENSION (jpmaxngh)       ::   ml_req_nf   ! for mpi_isend when avoiding mpi_allgather 
    8994      INTEGER                             ::   ml_err      ! for mpi_isend when avoiding mpi_allgather 
    9095      INTEGER, DIMENSION(MPI_STATUS_SIZE) ::   ml_stat     ! for mpi_isend when avoiding mpi_allgather 
    9196      !                                                    ! Workspace for message transfers avoiding mpi_allgather 
    92       INTEGER                             ::   ipf_j       ! sum of lines for all multi fields 
    93       INTEGER                             ::   js          ! counter 
    94       INTEGER, DIMENSION(:,:),          ALLOCATABLE ::   jj_s  ! position of sent lines 
    95       INTEGER, DIMENSION(:),            ALLOCATABLE ::   ipj_s ! number of sent lines 
    96       REAL(PRECISION), DIMENSION(:,:,:)      , ALLOCATABLE ::   ztabl 
    97       REAL(PRECISION), DIMENSION(:,:,:,:,:)  , ALLOCATABLE ::   ztab, ztabr 
    98       REAL(PRECISION), DIMENSION(:,:,:,:,:)  , ALLOCATABLE ::   znorthloc, zfoldwk       
    99       REAL(PRECISION), DIMENSION(:,:,:,:,:,:), ALLOCATABLE ::   znorthgloio 
     97      INTEGER                             ::   ipj_b       ! sum of lines for all multi fields 
     98      INTEGER                             ::   i012        ! 0, 1 or 2 
     99      INTEGER , DIMENSION(:,:)        , ALLOCATABLE ::   jj_s  ! position of sent lines 
     100      INTEGER , DIMENSION(:,:)        , ALLOCATABLE ::   jj_b  ! position of buffer lines 
     101      INTEGER , DIMENSION(:)          , ALLOCATABLE ::   ipj_s ! number of sent lines 
     102      REAL(PRECISION), DIMENSION(:,:,:,:)    , ALLOCATABLE ::   ztabb, ztabr, ztabw  ! buffer, receive and work arrays 
     103      REAL(PRECISION), DIMENSION(:,:,:,:,:)  , ALLOCATABLE ::   ztabglo, znorthloc 
     104      REAL(PRECISION), DIMENSION(:,:,:,:,:,:), ALLOCATABLE ::   znorthglo 
    100105      !!---------------------------------------------------------------------- 
    101106      ! 
     
    106111      IF( l_north_nogather ) THEN      !==  no allgather exchanges  ==! 
    107112 
    108          ALLOCATE(ipj_s(ipf)) 
    109  
    110          ipj      = 2            ! Max 2nd dimension of message transfers (last two j-line only) 
    111          ipj_s(:) = 1            ! Real 2nd dimension of message transfers (depending on perf requirement) 
    112                                  ! by default, only one line is exchanged 
    113  
    114          ALLOCATE( jj_s(ipf,2) ) 
    115  
    116          ! re-define number of exchanged lines : 
    117          !  must be two during the first two time steps 
    118          !  to correct possible incoherent values on North fold lines from restart  
    119  
     113         !   ---   define number of exchanged lines   --- 
     114         ! 
     115         ! In theory we should exchange only nn_hls lines. 
     116         ! 
     117         ! However, some other points are duplicated in the north pole folding: 
     118         !  - jperio=[34], grid=T : half of the last line (jpiglo/2+2:jpiglo-nn_hls) 
     119         !  - jperio=[34], grid=U : half of the last line (jpiglo/2+1:jpiglo-nn_hls) 
     120         !  - jperio=[34], grid=V : all the last line nn_hls+1 and (nn_hls+2:jpiglo-nn_hls) 
     121         !  - jperio=[34], grid=F : all the last line (nn_hls+1:jpiglo-nn_hls) 
     122         !  - jperio=[56], grid=T : 2 points of the last line (jpiglo/2+1 and jpglo-nn_hls) 
     123         !  - jperio=[56], grid=U : no points are duplicated 
     124         !  - jperio=[56], grid=V : half of the last line (jpiglo/2+1:jpiglo-nn_hls) 
     125         !  - jperio=[56], grid=F : half of the last line (jpiglo/2+1:jpiglo-nn_hls-1) 
     126         ! The order of the calculations may differ for these duplicated points (as, for example jj+1 becomes jj-1) 
     127         ! This explain why these duplicated points may have different values even if they are at the exact same location. 
     128         ! In consequence, we may want to force the folding on these points by setting l_full_nf_update = .TRUE. 
     129         ! This is slightly slower but necessary to avoid different values on identical grid points!! 
     130         ! 
    120131         !!!!!!!!!           temporary switch off this optimisation ==> force TRUE           !!!!!!!! 
    121132         !!!!!!!!!  needed to get the same results without agrif and with agrif and no zoom  !!!!!!!! 
    122133         !!!!!!!!!                    I don't know why we must do that...                    !!!!!!!! 
    123134         l_full_nf_update = .TRUE. 
    124  
    125          ! Two lines update (slower but necessary to avoid different values ion identical grid points 
    126          IF ( l_full_nf_update .OR.                          &    ! if coupling fields 
    127               ( ncom_stp == nit000 .AND. .NOT. ln_rstart ) ) &    ! at first time step, if not restart 
    128             ipj_s(:) = 2 
     135         ! also force it if not restart during the first 2 steps (leap frog?) 
     136         ll_add_line = l_full_nf_update .OR. ( ncom_stp <= nit000+1 .AND. .NOT. ln_rstart ) 
     137          
     138         ALLOCATE(ipj_s(ipf))                ! how many lines do we exchange? 
     139         IF( ll_add_line ) THEN 
     140            DO jf = 1, ipf                      ! Loop over the number of arrays to be processed 
     141               ipj_s(jf) = nn_hls + COUNT( (/ npolj == 3 .OR. npolj == 4 .OR. NAT_IN(jf) == 'V' .OR. NAT_IN(jf) == 'F' /) )  
     142            END DO 
     143         ELSE 
     144            ipj_s(:) = nn_hls 
     145         ENDIF 
     146          
     147         ipj   = MAXVAL(ipj_s(:))            ! Max 2nd dimension of message transfers 
     148         ipj_b = SUM(   ipj_s(:))            ! Total number of lines to be exchanged 
     149         ALLOCATE( jj_s(ipj, ipf), jj_b(ipj, ipf) ) 
    129150 
    130151         ! Index of modifying lines in input 
     152         ij1 = 0 
    131153         DO jf = 1, ipf                      ! Loop over the number of arrays to be processed 
    132154            ! 
    133155            SELECT CASE ( npolj ) 
    134             ! 
    135156            CASE ( 3, 4 )                       ! *  North fold  T-point pivot 
    136                ! 
    137157               SELECT CASE ( NAT_IN(jf) ) 
    138                ! 
    139                CASE ( 'T' , 'W' ,'U' )                            ! T-, U-, W-point 
    140                   jj_s(jf,1) = nlcj - 2 ;  jj_s(jf,2) = nlcj - 1 
    141                CASE ( 'V' , 'F' )                                 ! V-, F-point 
    142                   jj_s(jf,1) = nlcj - 3 ;  jj_s(jf,2) = nlcj - 2 
     158               CASE ( 'T', 'W', 'U' )   ;   i012 = 1   ! T-, U-, W-point 
     159               CASE ( 'V', 'F'      )   ;   i012 = 2   ! V-, F-point 
    143160               END SELECT 
    144             ! 
    145             CASE ( 5, 6 )                        ! *  North fold  F-point pivot 
     161            CASE ( 5, 6 )                       ! *  North fold  F-point pivot 
    146162               SELECT CASE ( NAT_IN(jf) ) 
    147                ! 
    148                CASE ( 'T' , 'W' ,'U' )                            ! T-, U-, W-point 
    149                   jj_s(jf,1) = nlcj - 1       
    150                   ipj_s(jf) = 1                  ! need only one line anyway 
    151                CASE ( 'V' , 'F' )                                 ! V-, F-point 
    152                   jj_s(jf,1) = nlcj - 2 ;  jj_s(jf,2) = nlcj - 1 
     163               CASE ( 'T', 'W', 'U' )   ;   i012 = 0   ! T-, U-, W-point 
     164               CASE ( 'V', 'F'      )   ;   i012 = 1   ! V-, F-point 
    153165               END SELECT 
    154             ! 
    155166            END SELECT 
    156             ! 
    157          ENDDO 
    158          !  
    159          ipf_j = sum (ipj_s(:))      ! Total number of lines to be exchanged 
    160          ! 
    161          ALLOCATE( znorthloc(jpimax,ipf_j,ipk,ipl,1) ) 
    162          ! 
    163          js = 0 
    164          DO jf = 1, ipf                      ! Loop over the number of arrays to be processed 
     167               ! 
    165168            DO jj = 1, ipj_s(jf) 
    166                js = js + 1 
    167                DO jl = 1, ipl 
    168                   DO jk = 1, ipk 
    169                      znorthloc(1:jpi,js,jk,jl,1) = ARRAY_IN(1:jpi,jj_s(jf,jj),jk,jl,jf) 
    170                   END DO 
    171                END DO 
     169               ij1 = ij1 + 1 
     170               jj_b(jj,jf) = ij1 
     171               jj_s(jj,jf) = jpj - 2*nn_hls + jj - i012 
    172172            END DO 
     173            ! 
    173174         END DO 
    174175         ! 
    175          ibuffsize = jpimax * ipf_j * ipk * ipl 
    176          ! 
    177          ALLOCATE( zfoldwk(jpimax,ipf_j,ipk,ipl,1) ) 
    178          ALLOCATE( ztabr(jpimax*jpmaxngh,ipj,ipk,ipl,ipf) )  
    179          ! when some processors of the north fold are suppressed,  
    180          ! values of ztab* arrays corresponding to these suppressed domain won't be defined  
    181          ! and we need a default definition to 0. 
    182          ! a better test should be: a testing if "suppressed land-processors" belongs to the north-pole folding 
    183          IF ( jpni*jpnj /= jpnij ) ztabr(:,:,:,:,:) = 0._wp 
     176         ALLOCATE( ztabb(jpimax,ipj_b,ipk,ipl) )   ! store all the data to be sent in a buffer array 
     177         ibuffsize = jpimax * ipj_b * ipk * ipl 
     178         ! 
     179         DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk 
     180            DO jj = 1, ipj_s(jf) 
     181               ij1 = jj_b(jj,jf) 
     182               ij2 = jj_s(jj,jf) 
     183               DO ji = 1, jpi 
     184                  ztabb(ji,ij1,jk,jl) = ARRAY_IN(ji,ij2,jk,jl,jf) 
     185               END DO 
     186               DO ji = jpi+1, jpimax 
     187                  ztabb(ji,ij1,jk,jl) = HUGE(0._wp)   ! avoid sending uninitialized values (make sure we don't use it) 
     188               END DO 
     189            END DO 
     190         END DO   ;   END DO   ;   END DO 
    184191         ! 
    185192         ! start waiting time measurement 
    186193         IF( ln_timing ) CALL tic_tac(.TRUE.) 
    187194         ! 
     195         ! send the data as soon as possible 
    188196         DO jr = 1, nsndto 
    189             IF( nfipproc(isendto(jr),jpnj) /= narea-1 .AND. nfipproc(isendto(jr),jpnj) /= -1 ) THEN 
    190                CALL SENDROUTINE( 5, znorthloc, ibuffsize, nfipproc(isendto(jr),jpnj), ml_req_nf(jr) ) 
     197            iproc = nfproc(isendto(jr)) 
     198            IF( iproc /= narea-1 .AND. iproc /= -1 ) THEN 
     199               CALL SENDROUTINE( 5, ztabb, ibuffsize, iproc, ml_req_nf(jr) ) 
    191200            ENDIF 
    192201         END DO 
    193202         ! 
     203         ipimax = jpimax * jpmaxngh 
     204         ALLOCATE( ztabw(jpimax,ipj_b,ipk,ipl), ztabr(ipimax,ipj_b,ipk,ipl) )  
     205         ! 
     206         DO jr = 1, nsndto 
     207            ! 
     208            ipni  = isendto(jr) 
     209            iproc = nfproc(ipni) 
     210            ipi   = nfjpi (ipni) 
     211            ! 
     212            IF( ipni ==   1  ) THEN   ;   iis0 =   1            ! domain  left side: as e-w comm already done -> from 1st column 
     213            ELSE                      ;   iis0 =   1 + nn_hls   ! default: -> from inner domain  
     214            ENDIF 
     215            IF( ipni == jpni ) THEN   ;   iie0 = ipi            ! domain right side: as e-w comm already done -> until last column 
     216            ELSE                      ;   iie0 = ipi - nn_hls   ! default: -> until inner domain  
     217            ENDIF 
     218            impp = nfimpp(ipni) - nfimpp(isendto(1)) 
     219            ! 
     220            IF(           iproc == -1 ) THEN   ! No neighbour (land proc that was suppressed) 
     221               ! 
     222               SELECT CASE ( kfillmode ) 
     223               CASE ( jpfillnothing )               ! no filling  
     224               CASE ( jpfillcopy    )               ! filling with inner domain values 
     225                  DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk 
     226                     DO jj = 1, ipj_s(jf) 
     227                        ij1 = jj_b(jj,jf) 
     228                        ij2 = jj_s(jj,jf) 
     229                        DO ji = iis0, iie0 
     230                           ztabr(impp+ji,ij1,jk,jl) = ARRAY_IN(Nis0,ij2,jk,jl,jf)   ! chose to take the 1st iner domain point 
     231                        END DO 
     232                     END DO 
     233                  END DO   ;   END DO   ;   END DO 
     234               CASE ( jpfillcst     )               ! filling with constant value 
     235                  DO jl = 1, ipl   ;   DO jk = 1, ipk 
     236                     DO jj = 1, ipj_b 
     237                        DO ji = iis0, iie0 
     238                           ztabr(impp+ji,jj,jk,jl) = pfillval 
     239                        END DO 
     240                     END DO 
     241                  END DO   ;   END DO 
     242               END SELECT 
     243               ! 
     244            ELSE IF( iproc == narea-1 ) THEN   ! get data from myself! 
     245               ! 
     246               DO jf = 1, ipf   ;   DO jl = 1, ipl  ;   DO jk = 1, ipk 
     247                  DO jj = 1, ipj_s(jf) 
     248                     ij1 = jj_b(jj,jf) 
     249                     ij2 = jj_s(jj,jf) 
     250                     DO ji = iis0, iie0 
     251                        ztabr(impp+ji,ij1,jk,jl) = ARRAY_IN(ji,ij2,jk,jl,jf) 
     252                     END DO 
     253                  END DO 
     254               END DO   ;   END DO   ;   END DO 
     255               ! 
     256            ELSE                               ! get data from a neighbour trough communication 
     257               !   
     258               CALL RECVROUTINE(5, ztabw, ibuffsize, iproc) 
     259               DO jl = 1, ipl   ;   DO jk = 1, ipk 
     260                  DO jj = 1, ipj_b 
     261                     DO ji = iis0, iie0 
     262                        ztabr(impp+ji,jj,jk,jl) = ztabw(ji,jj,jk,jl) 
     263                     END DO 
     264                  END DO 
     265               END DO   ;   END DO 
     266                
     267            ENDIF 
     268            ! 
     269         END DO   ! nsndto 
     270         ! 
     271         IF( ln_timing ) CALL tic_tac(.FALSE.) 
     272         ! 
     273         ! North fold boundary condition 
     274         ! 
     275         DO jf = 1, ipf 
     276            ij1 = jj_b(       1 ,jf) 
     277            ij2 = jj_b(ipj_s(jf),jf) 
     278            CALL lbc_nfd_nogather( ARRAY_IN(:,:,:,:,jf), ztabr(:,ij1:ij2,:,:), cd_nat LBC_ARG, psgn LBC_ARG ) 
     279         END DO 
     280         ! 
     281         DEALLOCATE( ztabr, ztabw, jj_s, jj_b, ipj_s ) 
     282         ! 
    194283         DO jr = 1,nsndto 
    195             iproc = nfipproc(isendto(jr),jpnj) 
    196             IF(iproc /= -1) THEN 
    197                iilb = nimppt(iproc+1) 
    198                ilci = nlcit (iproc+1) 
    199                ildi = nldit (iproc+1) 
    200                ilei = nleit (iproc+1) 
    201                IF( iilb            ==      1 )   ildi = 1      ! e-w boundary already done -> force to take 1st column 
    202                IF( iilb + ilci - 1 == jpiglo )   ilei = ilci   ! e-w boundary already done -> force to take last column 
    203                iilb = nfiimpp(isendto(jr),jpnj) - nfiimpp(isendto(1),jpnj) 
    204             ENDIF 
     284            iproc = nfproc(isendto(jr)) 
    205285            IF( iproc /= narea-1 .AND. iproc /= -1 ) THEN 
    206                CALL RECVROUTINE(5, zfoldwk, ibuffsize, iproc) 
    207                js = 0 
    208                DO jf = 1, ipf ; DO jj = 1, ipj_s(jf) 
    209                   js = js + 1 
    210                   DO jl = 1, ipl 
    211                      DO jk = 1, ipk 
    212                         DO ji = ildi, ilei 
    213                            ztabr(iilb+ji,jj,jk,jl,jf) = zfoldwk(ji,js,jk,jl,1) 
    214                         END DO 
    215                      END DO 
    216                   END DO 
    217                END DO; END DO 
    218             ELSE IF( iproc == narea-1 ) THEN 
    219                DO jf = 1, ipf ; DO jj = 1, ipj_s(jf) 
    220                   DO jl = 1, ipl 
    221                      DO jk = 1, ipk 
    222                         DO ji = ildi, ilei 
    223                            ztabr(iilb+ji,jj,jk,jl,jf) = ARRAY_IN(ji,jj_s(jf,jj),jk,jl,jf) 
    224                         END DO 
    225                      END DO 
    226                   END DO 
    227                END DO; END DO 
     286               CALL mpi_wait( ml_req_nf(jr), ml_stat, ml_err )   ! put the wait at the very end just before the deallocate 
    228287            ENDIF 
    229288         END DO 
    230          DO jr = 1,nsndto 
    231             IF( nfipproc(isendto(jr),jpnj) /= narea-1 .AND. nfipproc(isendto(jr),jpnj) /= -1 ) THEN 
    232                CALL mpi_wait( ml_req_nf(jr), ml_stat, ml_err ) 
    233             ENDIF 
    234          END DO 
    235          ! 
    236          IF( ln_timing ) CALL tic_tac(.FALSE.) 
    237          ! 
    238          ! North fold boundary condition 
    239          ! 
    240          DO jf = 1, ipf 
    241             CALL lbc_nfd_nogather( ARRAY_IN(:,:,:,:,jf), ztabr(:,1:ipj_s(jf),:,:,jf), cd_nat LBC_ARG, psgn LBC_ARG ) 
    242          END DO 
    243          ! 
    244          DEALLOCATE( zfoldwk, ztabr, jj_s, ipj_s ) 
     289         DEALLOCATE( ztabb ) 
    245290         ! 
    246291      ELSE                             !==  allgather exchanges  ==! 
    247292         ! 
    248          ipj   = 4            ! 2nd dimension of message transfers (last j-lines) 
    249          ! 
    250          ALLOCATE( znorthloc(jpimax,ipj,ipk,ipl,ipf) ) 
    251          ! 
    252          DO jf = 1, ipf                ! put in znorthloc the last ipj j-lines of ptab 
    253             DO jl = 1, ipl 
    254                DO jk = 1, ipk 
    255                   DO jj = nlcj - ipj +1, nlcj 
    256                      ij = jj - nlcj + ipj 
    257                      znorthloc(1:jpi,ij,jk,jl,jf) = ARRAY_IN(1:jpi,jj,jk,jl,jf) 
    258                   END DO 
     293         ! how many lines do we exchange at max? -> ipj    (no further optimizations in this case...) 
     294         ipj =      nn_hls + 2 
     295         ! how many lines do we     need at max? -> ipj2   (no further optimizations in this case...) 
     296         ipj2 = 2 * nn_hls + 2 
     297         ! 
     298         i0max = jpimax - 2 * nn_hls 
     299         ibuffsize = i0max * ipj * ipk * ipl * ipf 
     300         ALLOCATE( znorthloc(i0max,ipj,ipk,ipl,ipf), znorthglo(i0max,ipj,ipk,ipl,ipf,ndim_rank_north) ) 
     301         ! 
     302         DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk               ! put in znorthloc ipj j-lines of ptab 
     303            DO jj = 1, ipj 
     304               ij2 = jpj - ipj2 + jj                        ! the first ipj lines of the last ipj2 lines 
     305               DO ji = 1, Ni_0 
     306                  ii2 = Nis0 - 1 + ji                       ! inner domain: Nis0 to Nie0 
     307                  znorthloc(ji,jj,jk,jl,jf) = ARRAY_IN(ii2,ij2,jk,jl,jf) 
     308               END DO 
     309               DO ji = Ni_0+1, i0max 
     310                  znorthloc(ji,jj,jk,jl,jf) = HUGE(0._wp)   ! avoid sending uninitialized values (make sure we don't use it) 
    259311               END DO 
    260312            END DO 
    261          END DO 
    262          ! 
    263          ibuffsize = jpimax * ipj * ipk * ipl * ipf 
    264          ! 
    265          ALLOCATE( ztab       (jpiglo,ipj,ipk,ipl,ipf     ) ) 
    266          ALLOCATE( znorthgloio(jpimax,ipj,ipk,ipl,ipf,jpni) ) 
    267          ! 
    268          ! when some processors of the north fold are suppressed, 
    269          ! values of ztab* arrays corresponding to these suppressed domain won't be defined 
    270          ! and we need a default definition to 0. 
    271          ! a better test should be: a testing if "suppressed land-processors" belongs to the north-pole folding 
    272          IF ( jpni*jpnj /= jpnij ) ztab(:,:,:,:,:) = 0._wp 
     313         END DO   ;   END DO   ;   END DO 
    273314         ! 
    274315         ! start waiting time measurement 
    275316         IF( ln_timing ) CALL tic_tac(.TRUE.) 
    276          CALL MPI_ALLGATHER( znorthloc  , ibuffsize, MPI_TYPE,                & 
    277             &                znorthgloio, ibuffsize, MPI_TYPE, ncomm_north, ierr ) 
    278          ! 
     317         CALL MPI_ALLGATHER( znorthloc, ibuffsize, MPI_TYPE, znorthglo, ibuffsize, MPI_TYPE, ncomm_north, ierr ) 
    279318         ! stop waiting time measurement 
    280319         IF( ln_timing ) CALL tic_tac(.FALSE.) 
    281          ! 
    282          DO jr = 1, ndim_rank_north         ! recover the global north array 
    283             iproc = nrank_north(jr) + 1 
    284             iilb  = nimppt(iproc) 
    285             ilci  = nlcit (iproc) 
    286             ildi  = nldit (iproc) 
    287             ilei  = nleit (iproc) 
    288             IF( iilb            ==      1 )   ildi = 1      ! e-w boundary already done -> force to take 1st column 
    289             IF( iilb + ilci - 1 == jpiglo )   ilei = ilci   ! e-w boundary already done -> force to take last column 
    290             DO jf = 1, ipf 
    291                DO jl = 1, ipl 
    292                   DO jk = 1, ipk 
     320         DEALLOCATE( znorthloc ) 
     321         ALLOCATE( ztabglo(jpiglo,ipj2,ipk,ipl,ipf) ) 
     322         ! 
     323         ! need to fill only the first ipj lines of ztabglo as lbc_nfd don't use the last nn_hls lines 
     324         ijnr = 0 
     325         DO jr = 1, jpni                                                        ! recover the global north array 
     326            iproc = nfproc(jr) 
     327            impp  = nfimpp(jr) 
     328            ipi   = nfjpi( jr) - 2 * nn_hls                       ! corresponds to Ni_0 but for subdomain iproc 
     329            IF( iproc == -1 ) THEN   ! No neighbour (land proc that was suppressed) 
     330              ! 
     331               SELECT CASE ( kfillmode ) 
     332               CASE ( jpfillnothing )               ! no filling  
     333               CASE ( jpfillcopy    )               ! filling with inner domain values 
     334                  DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk 
    293335                     DO jj = 1, ipj 
    294                         DO ji = ildi, ilei 
    295                            ztab(ji+iilb-1,jj,jk,jl,jf) = znorthgloio(ji,jj,jk,jl,jf,jr) 
     336                        ij2 = jpj - ipj2 + jj                    ! the first ipj lines of the last ipj2 lines 
     337                        DO ji = 1, ipi 
     338                           ii1 = impp + nn_hls + ji - 1          ! corresponds to mig(nn_hls + ji) but for subdomain iproc 
     339                           ztabglo(ii1,jj,jk,jl,jf) = ARRAY_IN(Nis0,ij2,jk,jl,jf)   ! chose to take the 1st iner domain point 
    296340                        END DO 
    297341                     END DO 
     342                  END DO   ;   END DO   ;   END DO 
     343               CASE ( jpfillcst     )               ! filling with constant value 
     344                  DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk 
     345                     DO jj = 1, ipj 
     346                        DO ji = 1, ipi 
     347                           ii1 = impp + nn_hls + ji - 1          ! corresponds to mig(nn_hls + ji) but for subdomain iproc 
     348                           ztabglo(ii1,jj,jk,jl,jf) = pfillval 
     349                        END DO 
     350                     END DO 
     351                 END DO   ;   END DO   ;   END DO 
     352               END SELECT 
     353               ! 
     354            ELSE 
     355               ijnr = ijnr + 1 
     356               DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk 
     357                  DO jj = 1, ipj 
     358                     DO ji = 1, ipi 
     359                        ii1 = impp + nn_hls + ji - 1             ! corresponds to mig(nn_hls + ji) but for subdomain iproc 
     360                        ztabglo(ii1,jj,jk,jl,jf) = znorthglo(ji,jj,jk,jl,jf,ijnr) 
     361                     END DO 
    298362                  END DO 
     363               END DO   ;   END DO   ;   END DO 
     364            ENDIF 
     365            ! 
     366         END DO   ! jpni 
     367         DEALLOCATE( znorthglo ) 
     368         ! 
     369         DO jf = 1, ipf 
     370            CALL lbc_nfd( ztabglo(:,:,:,:,jf), cd_nat LBC_ARG, psgn LBC_ARG )   ! North fold boundary condition 
     371            DO jl = 1, ipl   ;   DO jk = 1, ipk                  ! e-w periodicity 
     372               DO jj = 1, nn_hls + 1 
     373                  ij1 = ipj2 - (nn_hls + 1) + jj                 ! need only the last nn_hls + 1 lines until ipj2 
     374                  ztabglo(              1:nn_hls,ij1,jk,jl,jf) = ztabglo(jpiglo-2*nn_hls+1:jpiglo-nn_hls,ij1,jk,jl,jf) 
     375                  ztabglo(jpiglo-nn_hls+1:jpiglo,ij1,jk,jl,jf) = ztabglo(         nn_hls+1:     2*nn_hls,ij1,jk,jl,jf) 
     376               END DO 
     377            END DO   ;   END DO 
     378         END DO      
     379         ! 
     380         DO jf = 1, ipf   ;   DO jl = 1, ipl   ;   DO jk = 1, ipk               ! Scatter back to ARRAY_IN 
     381            DO jj = 1, nn_hls + 1 
     382               ij1 = jpj  - (nn_hls + 1) + jj   ! last nn_hls + 1 lines until jpj 
     383               ij2 = ipj2 - (nn_hls + 1) + jj   ! last nn_hls + 1 lines until ipj2 
     384               DO ji= 1, jpi 
     385                  ii2 = mig(ji) 
     386                  ARRAY_IN(ji,ij1,jk,jl,jf) = ztabglo(ii2,ij2,jk,jl,jf) 
    299387               END DO 
    300388            END DO 
    301          END DO 
    302          DO jf = 1, ipf 
    303             CALL lbc_nfd( ztab(:,:,:,:,jf), cd_nat LBC_ARG, psgn LBC_ARG )   ! North fold boundary condition 
    304          END DO 
    305          ! 
    306          DO jf = 1, ipf 
    307             DO jl = 1, ipl 
    308                DO jk = 1, ipk 
    309                   DO jj = nlcj-ipj+1, nlcj             ! Scatter back to ARRAY_IN 
    310                      ij = jj - nlcj + ipj 
    311                      DO ji= 1, nlci 
    312                         ARRAY_IN(ji,jj,jk,jl,jf) = ztab(ji+nimpp-1,ij,jk,jl,jf) 
    313                      END DO 
    314                   END DO 
    315                END DO 
    316             END DO 
    317          END DO 
    318          ! 
    319       ! 
    320          DEALLOCATE( ztab ) 
    321          DEALLOCATE( znorthgloio ) 
    322       ENDIF 
    323       ! 
    324       DEALLOCATE( znorthloc ) 
     389         END DO   ;   END DO   ;   END DO 
     390         ! 
     391         DEALLOCATE( ztabglo ) 
     392         ! 
     393      ENDIF   ! l_north_nogather 
    325394      ! 
    326395   END SUBROUTINE ROUTINE_NFD 
  • NEMO/trunk/src/OCE/LBC/mppini.F90

    r13216 r13286  
    88   !!            8.0  !  1998-05  (M. Imbard, J. Escobar, L. Colombet )  SHMEM and MPI versions 
    99   !!  NEMO      1.0  !  2004-01  (G. Madec, J.M Molines)  F90 : free form , north fold jpni > 1 
    10    !!            3.4  ! 2011-10  (A. C. Coward, NOCS & J. Donners, PRACE) add mpp_init_nfdcom 
    11    !!            3.   ! 2013-06  (I. Epicoco, S. Mocavero, CMCC) mpp_init_nfdcom: setup avoiding MPI communication  
     10   !!            3.4  !  2011-10  (A. C. Coward, NOCS & J. Donners, PRACE)  add init_nfdcom 
     11   !!            3.   !  2013-06  (I. Epicoco, S. Mocavero, CMCC)  init_nfdcom: setup avoiding MPI communication  
    1212   !!            4.0  !  2016-06  (G. Madec)  use domain configuration file instead of bathymetry file 
    1313   !!            4.0  !  2017-06  (J.M. Molines, T. Lovato) merge of mppini and mppini_2 
     
    1515 
    1616   !!---------------------------------------------------------------------- 
    17    !!  mpp_init          : Lay out the global domain over processors with/without land processor elimination 
    18    !!  mpp_init_mask     : Read global bathymetric information to facilitate land suppression 
    19    !!  mpp_init_ioipsl   : IOIPSL initialization in mpp  
    20    !!  mpp_init_partition: Calculate MPP domain decomposition 
    21    !!  factorise         : Calculate the factors of the no. of MPI processes 
    22    !!  mpp_init_nfdcom   : Setup for north fold exchanges with explicit point-to-point messaging 
     17   !!  mpp_init       : Lay out the global domain over processors with/without land processor elimination 
     18   !!      init_ioipsl: IOIPSL initialization in mpp  
     19   !!      init_nfdcom: Setup for north fold exchanges with explicit point-to-point messaging 
     20   !!      init_doloop: set the starting/ending indices of DO-loop used in do_loop_substitute  
    2321   !!---------------------------------------------------------------------- 
    2422   USE dom_oce        ! ocean space and time domain 
    2523   USE bdy_oce        ! open BounDarY   
    2624   ! 
    27    USE lbcnfd  , ONLY : isendto, nsndto, nfsloop, nfeloop  ! Setup of north fold exchanges  
     25   USE lbcnfd  , ONLY : isendto, nsndto ! Setup of north fold exchanges  
    2826   USE lib_mpp        ! distribued memory computing library 
    2927   USE iom            ! nemo I/O library  
     
    3432   PRIVATE 
    3533 
    36    PUBLIC mpp_init       ! called by opa.F90 
    37  
    38    INTEGER :: numbot = -1  ! 'bottom_level' local logical unit 
    39    INTEGER :: numbdy = -1  ! 'bdy_msk'      local logical unit 
     34   PUBLIC   mpp_init       ! called by nemogcm.F90 
     35   PUBLIC   mpp_getnum     ! called by prtctl 
     36   PUBLIC   mpp_basesplit  ! called by prtctl 
     37   PUBLIC   mpp_is_ocean   ! called by prtctl 
     38    
     39   INTEGER ::   numbot = -1   ! 'bottom_level' local logical unit 
     40   INTEGER ::   numbdy = -1   ! 'bdy_msk'      local logical unit 
    4041    
    4142   !!---------------------------------------------------------------------- 
     
    6162      !!---------------------------------------------------------------------- 
    6263      ! 
     64      jpiglo = Ni0glo 
     65      jpjglo = Nj0glo 
    6366      jpimax = jpiglo 
    6467      jpjmax = jpjglo 
     
    6669      jpj    = jpjglo 
    6770      jpk    = jpkglo 
    68       jpim1  = jpi-1                                            ! inner domain indices 
    69       jpjm1  = jpj-1                                            !   "           " 
    70       jpkm1  = MAX( 1, jpk-1 )                                  !   "           " 
     71      jpim1  = jpi-1                         ! inner domain indices 
     72      jpjm1  = jpj-1                         !   "           " 
     73      jpkm1  = MAX( 1, jpk-1 )               !   "           " 
     74      ! 
     75      CALL init_doloop                       ! set start/end indices or do-loop depending on the halo width value (nn_hls)  
     76      ! 
    7177      jpij   = jpi*jpj 
    7278      jpni   = 1 
    7379      jpnj   = 1 
    7480      jpnij  = jpni*jpnj 
    75       nimpp  = 1           !  
     81      nn_hls = 1 
     82      nimpp  = 1 
    7683      njmpp  = 1 
    77       nlci   = jpi 
    78       nlcj   = jpj 
    79       nldi   = 1 
    80       nldj   = 1 
    81       nlei   = jpi 
    82       nlej   = jpj 
    8384      nbondi = 2 
    8485      nbondj = 2 
     
    135136      !!                    njmpp     : latitudinal  index 
    136137      !!                    narea     : number for local area 
    137       !!                    nlci      : first dimension 
    138       !!                    nlcj      : second dimension 
    139138      !!                    nbondi    : mark for "east-west local boundary" 
    140139      !!                    nbondj    : mark for "north-south local boundary" 
     
    147146      INTEGER ::   ji, jj, jn, jproc, jarea   ! dummy loop indices 
    148147      INTEGER ::   inijmin 
    149       INTEGER ::   i2add 
    150148      INTEGER ::   inum                       ! local logical unit 
    151       INTEGER ::   idir, ifreq, icont         ! local integers 
     149      INTEGER ::   idir, ifreq                ! local integers 
    152150      INTEGER ::   ii, il1, ili, imil         !   -       - 
    153151      INTEGER ::   ij, il2, ilj, ijm1         !   -       - 
     
    162160      INTEGER, ALLOCATABLE, DIMENSION(:)     ::   iin, ii_nono, ii_noea          ! 1D workspace 
    163161      INTEGER, ALLOCATABLE, DIMENSION(:)     ::   ijn, ii_noso, ii_nowe          !  -     - 
    164       INTEGER, ALLOCATABLE, DIMENSION(:,:) ::   iimppt, ilci, ibondi, ipproc   ! 2D workspace 
    165       INTEGER, ALLOCATABLE, DIMENSION(:,:) ::   ijmppt, ilcj, ibondj, ipolj    !  -     - 
    166       INTEGER, ALLOCATABLE, DIMENSION(:,:) ::   ilei, ildi, iono, ioea         !  -     - 
    167       INTEGER, ALLOCATABLE, DIMENSION(:,:) ::   ilej, ildj, ioso, iowe         !  -     - 
     162      INTEGER, ALLOCATABLE, DIMENSION(:,:) ::   iimppt, ijpi, ibondi, ipproc   ! 2D workspace 
     163      INTEGER, ALLOCATABLE, DIMENSION(:,:) ::   ijmppt, ijpj, ibondj, ipolj    !  -     - 
     164      INTEGER, ALLOCATABLE, DIMENSION(:,:) ::   iie0, iis0, iono, ioea         !  -     - 
     165      INTEGER, ALLOCATABLE, DIMENSION(:,:) ::   ije0, ijs0, ioso, iowe         !  -     - 
    168166      LOGICAL, ALLOCATABLE, DIMENSION(:,:) ::   llisoce                        !  -     - 
    169167      NAMELIST/nambdy/ ln_bdy, nb_bdy, ln_coords_file, cn_coords_file,           & 
     
    173171           &             cn_ice, nn_ice_dta,                                     & 
    174172           &             ln_vol, nn_volctl, nn_rimwidth 
    175       NAMELIST/nammpp/ jpni, jpnj, ln_nnogather, ln_listonly 
     173      NAMELIST/nammpp/ jpni, jpnj, nn_hls, ln_nnogather, ln_listonly 
    176174      !!---------------------------------------------------------------------- 
    177175      ! 
     
    186184902   IF( ios >  0 )   CALL ctl_nam ( ios , 'nammpp in configuration namelist' )    
    187185      ! 
     186      nn_hls = MAX(1, nn_hls)   ! nn_hls must be > 0 
    188187      IF(lwp) THEN 
    189188            WRITE(numout,*) '   Namelist nammpp' 
     
    195194         ENDIF 
    196195            WRITE(numout,*) '      avoid use of mpi_allgather at the north fold  ln_nnogather = ', ln_nnogather 
     196            WRITE(numout,*) '      halo width (applies to both rows and columns)       nn_hls = ', nn_hls 
    197197      ENDIF 
    198198      ! 
    199199      IF(lwm)   WRITE( numond, nammpp ) 
    200  
     200      ! 
     201!!!------------------------------------ 
     202!!!  nn_hls shloud be read in nammpp 
     203!!!------------------------------------ 
     204      jpiglo = Ni0glo + 2 * nn_hls 
     205      jpjglo = Nj0glo + 2 * nn_hls 
     206      ! 
    201207      ! do we need to take into account bdy_msk? 
    202208      READ  ( numnam_ref, nambdy, IOSTAT = ios, ERR = 903) 
     
    208214      IF( ln_bdy .AND. ln_mask_file ) CALL iom_open( cn_mask_file, numbdy ) 
    209215      ! 
    210       IF( ln_listonly )   CALL mpp_init_bestpartition( MAX(mppsize,jpni*jpnj), ldlist = .TRUE. )   ! must be done by all core 
     216      IF( ln_listonly )   CALL bestpartition( MAX(mppsize,jpni*jpnj), ldlist = .TRUE. )   ! must be done by all core 
    211217      ! 
    212218      !  1. Dimension arrays for subdomains 
    213219      ! ----------------------------------- 
    214220      ! 
    215       ! If dimensions of processor grid weren't specified in the namelist file 
     221      ! If dimensions of processors grid weren't specified in the namelist file 
    216222      ! then we calculate them here now that we have our communicator size 
    217223      IF(lwp) THEN 
     
    221227      ENDIF 
    222228      IF( jpni < 1 .OR. jpnj < 1 ) THEN 
    223          CALL mpp_init_bestpartition( mppsize, jpni, jpnj )           ! best mpi decomposition for mppsize mpi processes 
     229         CALL bestpartition( mppsize, jpni, jpnj )           ! best mpi decomposition for mppsize mpi processes 
    224230         llauto = .TRUE. 
    225231         llbest = .TRUE. 
    226232      ELSE 
    227233         llauto = .FALSE. 
    228          CALL mpp_init_bestpartition( mppsize, inbi, inbj, icnt2 )    ! best mpi decomposition for mppsize mpi processes 
     234         CALL bestpartition( mppsize, inbi, inbj, icnt2 )    ! best mpi decomposition for mppsize mpi processes 
    229235         ! largest subdomain size for mpi decoposition jpni*jpnj given in the namelist 
    230          CALL mpp_basic_decomposition( jpni, jpnj, jpimax, jpjmax ) 
    231          ! largest subdomain size for mpi decoposition inbi*inbj given by mpp_init_bestpartition 
    232          CALL mpp_basic_decomposition( inbi, inbj,  iimax,  ijmax ) 
     236         CALL mpp_basesplit( jpiglo, jpjglo, nn_hls, jpni, jpnj, jpimax, jpjmax ) 
     237         ! largest subdomain size for mpi decoposition inbi*inbj given by bestpartition 
     238         CALL mpp_basesplit( jpiglo, jpjglo, nn_hls, inbi, inbj,  iimax,  ijmax ) 
    233239         icnt1 = jpni*jpnj - mppsize   ! number of land subdomains that should be removed to use mppsize mpi processes 
    234240         IF(lwp) THEN 
     
    261267      ! look for land mpi subdomains... 
    262268      ALLOCATE( llisoce(jpni,jpnj) ) 
    263       CALL mpp_init_isoce( jpni, jpnj, llisoce ) 
     269      CALL mpp_is_ocean( llisoce ) 
    264270      inijmin = COUNT( llisoce )   ! number of oce subdomains 
    265271 
     
    270276         WRITE(ctmp4,*) '   ==>>> There is the list of best domain decompositions you should use: ' 
    271277         CALL ctl_stop( ctmp1, ctmp2, ctmp3, ' ', ctmp4, ' ' ) 
    272          CALL mpp_init_bestpartition( mppsize, ldlist = .TRUE. )   ! must be done by all core 
     278         CALL bestpartition( mppsize, ldlist = .TRUE. )   ! must be done by all core 
    273279      ENDIF 
    274280 
     
    294300            WRITE(numout,*) 
    295301         ENDIF 
    296          CALL mpp_init_bestpartition( mppsize, ldlist = .TRUE. )   ! must be done by all core 
     302         CALL bestpartition( mppsize, ldlist = .TRUE. )   ! must be done by all core 
    297303      ENDIF 
    298304 
     
    3193259003  FORMAT (a, i5) 
    320326 
    321       IF( numbot /= -1 )   CALL iom_close( numbot ) 
    322       IF( numbdy /= -1 )   CALL iom_close( numbdy ) 
    323      
    324       ALLOCATE(  nfiimpp(jpni,jpnj), nfipproc(jpni,jpnj), nfilcit(jpni,jpnj) ,    & 
    325          &       nimppt(jpnij) , ibonit(jpnij) , nlcit(jpnij) , nlcjt(jpnij) ,    & 
    326          &       njmppt(jpnij) , ibonjt(jpnij) , nldit(jpnij) , nldjt(jpnij) ,    & 
    327          &                                       nleit(jpnij) , nlejt(jpnij) ,    & 
     327      ALLOCATE(  nfimpp(jpni ) , nfproc(jpni ) ,   nfjpi(jpni ) ,                     & 
     328         &       nimppt(jpnij) , ibonit(jpnij) ,  jpiall(jpnij) ,  jpjall(jpnij) ,    & 
     329         &       njmppt(jpnij) , ibonjt(jpnij) , nis0all(jpnij) , njs0all(jpnij) ,    & 
     330         &                                       nie0all(jpnij) , nje0all(jpnij) ,    & 
    328331         &       iin(jpnij), ii_nono(jpnij), ii_noea(jpnij),   & 
    329332         &       ijn(jpnij), ii_noso(jpnij), ii_nowe(jpnij),   & 
    330          &       iimppt(jpni,jpnj), ilci(jpni,jpnj), ibondi(jpni,jpnj), ipproc(jpni,jpnj),   & 
    331          &       ijmppt(jpni,jpnj), ilcj(jpni,jpnj), ibondj(jpni,jpnj), ipolj(jpni,jpnj),   & 
    332          &       ilei(jpni,jpnj), ildi(jpni,jpnj), iono(jpni,jpnj), ioea(jpni,jpnj),   & 
    333          &       ilej(jpni,jpnj), ildj(jpni,jpnj), ioso(jpni,jpnj), iowe(jpni,jpnj),   & 
     333         &       iimppt(jpni,jpnj), ijpi(jpni,jpnj), ibondi(jpni,jpnj), ipproc(jpni,jpnj),   & 
     334         &       ijmppt(jpni,jpnj), ijpj(jpni,jpnj), ibondj(jpni,jpnj), ipolj(jpni,jpnj),   & 
     335         &         iie0(jpni,jpnj), iis0(jpni,jpnj),   iono(jpni,jpnj),  ioea(jpni,jpnj),   & 
     336         &         ije0(jpni,jpnj), ijs0(jpni,jpnj),   ioso(jpni,jpnj),  iowe(jpni,jpnj),   & 
    334337         &       STAT=ierr ) 
    335338      CALL mpp_sum( 'mppini', ierr ) 
     
    345348      ! ----------------------------------- 
    346349      ! 
    347       nreci = 2 * nn_hls 
    348       nrecj = 2 * nn_hls 
    349       CALL mpp_basic_decomposition( jpni, jpnj, jpimax, jpjmax, iimppt, ijmppt, ilci, ilcj ) 
    350       nfiimpp(:,:) = iimppt(:,:) 
    351       nfilcit(:,:) = ilci(:,:) 
     350      CALL mpp_basesplit( jpiglo, jpjglo, nn_hls, jpni, jpnj, jpimax, jpjmax, iimppt, ijmppt, ijpi, ijpj ) 
     351      CALL mpp_getnum( llisoce, ipproc, iin, ijn ) 
     352      ! 
     353      !DO jn = 1, jpni 
     354      !   jproc = ipproc(jn,jpnj) 
     355      !   ii = iin(jproc+1) 
     356      !   ij = ijn(jproc+1) 
     357      !   nfproc(jn) = jproc 
     358      !   nfimpp(jn) = iimppt(ii,ij) 
     359      !   nfjpi (jn) =   ijpi(ii,ij) 
     360      !END DO 
     361      nfproc(:) = ipproc(:,jpnj)  
     362      nfimpp(:) = iimppt(:,jpnj)  
     363      nfjpi (:) =   ijpi(:,jpnj) 
    352364      ! 
    353365      IF(lwp) THEN 
     
    358370         WRITE(numout,*) '      jpni = ', jpni   
    359371         WRITE(numout,*) '      jpnj = ', jpnj 
     372         WRITE(numout,*) '     jpnij = ', jpnij 
    360373         WRITE(numout,*) 
    361          WRITE(numout,*) '      sum ilci(i,1) = ', sum(ilci(:,1)), ' jpiglo = ', jpiglo 
    362          WRITE(numout,*) '      sum ilcj(1,j) = ', sum(ilcj(1,:)), ' jpjglo = ', jpjglo 
     374         WRITE(numout,*) '      sum ijpi(i,1) = ', sum(ijpi(:,1)), ' jpiglo = ', jpiglo 
     375         WRITE(numout,*) '      sum ijpj(1,j) = ', sum(ijpj(1,:)), ' jpjglo = ', jpjglo 
    363376      ENDIF 
    364377      
     
    375388         ii = 1 + MOD(iarea0,jpni) 
    376389         ij = 1 +     iarea0/jpni 
    377          ili = ilci(ii,ij) 
    378          ilj = ilcj(ii,ij) 
     390         ili = ijpi(ii,ij) 
     391         ilj = ijpj(ii,ij) 
    379392         ibondi(ii,ij) = 0                         ! default: has e-w neighbours 
    380393         IF( ii   ==    1 )   ibondi(ii,ij) = -1   ! first column, has only e neighbour 
     
    391404         ioea(ii,ij) = iarea0 + 1 
    392405         iono(ii,ij) = iarea0 + jpni 
    393          ildi(ii,ij) =  1  + nn_hls 
    394          ilei(ii,ij) = ili - nn_hls 
    395          ildj(ii,ij) =  1  + nn_hls 
    396          ilej(ii,ij) = ilj - nn_hls 
     406         iis0(ii,ij) =  1  + nn_hls 
     407         iie0(ii,ij) = ili - nn_hls 
     408         ijs0(ii,ij) =  1  + nn_hls 
     409         ije0(ii,ij) = ilj - nn_hls 
    397410 
    398411         ! East-West periodicity: change ibondi, ioea, iowe 
     
    432445      ! ---------------------------- 
    433446      ! 
    434       ! specify which subdomains are oce subdomains; other are land subdomains 
    435       ipproc(:,:) = -1 
    436       icont = -1 
    437       DO jarea = 1, jpni*jpnj 
    438          iarea0 = jarea - 1 
    439          ii = 1 + MOD(iarea0,jpni) 
    440          ij = 1 +     iarea0/jpni 
    441          IF( llisoce(ii,ij) ) THEN 
    442             icont = icont + 1 
    443             ipproc(ii,ij) = icont 
    444             iin(icont+1) = ii 
    445             ijn(icont+1) = ij 
    446          ENDIF 
    447       END DO 
    448       ! if needed add some land subdomains to reach jpnij active subdomains 
    449       i2add = jpnij - inijmin 
    450       DO jarea = 1, jpni*jpnj 
    451          iarea0 = jarea - 1 
    452          ii = 1 + MOD(iarea0,jpni) 
    453          ij = 1 +     iarea0/jpni 
    454          IF( .NOT. llisoce(ii,ij) .AND. i2add > 0 ) THEN 
    455             icont = icont + 1 
    456             ipproc(ii,ij) = icont 
    457             iin(icont+1) = ii 
    458             ijn(icont+1) = ij 
    459             i2add = i2add - 1 
    460          ENDIF 
    461       END DO 
    462       nfipproc(:,:) = ipproc(:,:) 
    463  
    464447      ! neighbour treatment: change ibondi, ibondj if next to a land zone 
    465448      DO jarea = 1, jpni*jpnj 
     
    500483         ENDIF 
    501484      END DO 
    502  
    503       ! Update il[de][ij] according to modified ibond[ij] 
    504       ! ---------------------- 
    505       DO jproc = 1, jpnij 
    506          ii = iin(jproc) 
    507          ij = ijn(jproc) 
    508          IF( ibondi(ii,ij) == -1 .OR. ibondi(ii,ij) == 2 ) ildi(ii,ij) =  1 
    509          IF( ibondi(ii,ij) ==  1 .OR. ibondi(ii,ij) == 2 ) ilei(ii,ij) = ilci(ii,ij) 
    510          IF( ibondj(ii,ij) == -1 .OR. ibondj(ii,ij) == 2 ) ildj(ii,ij) =  1 
    511          IF( ibondj(ii,ij) ==  1 .OR. ibondj(ii,ij) == 2 ) ilej(ii,ij) = ilcj(ii,ij) 
    512       END DO 
    513485       
    514486      ! 5. Subdomain print 
     
    523495            DO jj = jpnj, 1, -1 
    524496               WRITE(numout,9403) ('   ',ji=il1,il2-1) 
    525                WRITE(numout,9402) jj, (ilci(ji,jj),ilcj(ji,jj),ji=il1,il2) 
     497               WRITE(numout,9402) jj, (ijpi(ji,jj),ijpj(ji,jj),ji=il1,il2) 
    526498               WRITE(numout,9404) (ipproc(ji,jj),ji=il1,il2) 
    527499               WRITE(numout,9403) ('   ',ji=il1,il2-1) 
     
    580552      noea = ii_noea(narea) 
    581553      nono = ii_nono(narea) 
    582       nlci = ilci(ii,ij)   
    583       nldi = ildi(ii,ij) 
    584       nlei = ilei(ii,ij) 
    585       nlcj = ilcj(ii,ij)   
    586       nldj = ildj(ii,ij) 
    587       nlej = ilej(ii,ij) 
     554      jpi    = ijpi(ii,ij)   
     555!!$      Nis0  = iis0(ii,ij) 
     556!!$      Nie0  = iie0(ii,ij) 
     557      jpj    = ijpj(ii,ij)   
     558!!$      Njs0  = ijs0(ii,ij) 
     559!!$      Nje0  = ije0(ii,ij) 
    588560      nbondi = ibondi(ii,ij) 
    589561      nbondj = ibondj(ii,ij) 
    590562      nimpp = iimppt(ii,ij)   
    591563      njmpp = ijmppt(ii,ij) 
    592       jpi = nlci 
    593       jpj = nlcj 
    594       jpk = jpkglo                                             ! third dim 
    595 #if defined key_agrif 
    596       ! simple trick to use same vertical grid as parent but different number of levels:  
    597       ! Save maximum number of levels in jpkglo, then define all vertical grids with this number. 
    598       ! Suppress once vertical online interpolation is ok 
    599 !!$      IF(.NOT.Agrif_Root())   jpkglo = Agrif_Parent( jpkglo ) 
    600 #endif 
    601       jpim1 = jpi-1                                            ! inner domain indices 
    602       jpjm1 = jpj-1                                            !   "           " 
    603       jpkm1 = MAX( 1, jpk-1 )                                  !   "           " 
    604       jpij  = jpi*jpj                                          !  jpi x j 
     564      jpk = jpkglo                              ! third dim 
     565      ! 
     566      CALL init_doloop                          ! set start/end indices of do-loop, depending on the halo width value (nn_hls)  
     567      ! 
     568      jpim1 = jpi-1                             ! inner domain indices 
     569      jpjm1 = jpj-1                             !   "           " 
     570      jpkm1 = MAX( 1, jpk-1 )                   !   "           " 
     571      jpij  = jpi*jpj                           !  jpi x j 
    605572      DO jproc = 1, jpnij 
    606573         ii = iin(jproc) 
    607574         ij = ijn(jproc) 
    608          nlcit(jproc) = ilci(ii,ij) 
    609          nldit(jproc) = ildi(ii,ij) 
    610          nleit(jproc) = ilei(ii,ij) 
    611          nlcjt(jproc) = ilcj(ii,ij) 
    612          nldjt(jproc) = ildj(ii,ij) 
    613          nlejt(jproc) = ilej(ii,ij) 
     575         jpiall (jproc) = ijpi(ii,ij) 
     576         nis0all(jproc) = iis0(ii,ij) 
     577         nie0all(jproc) = iie0(ii,ij) 
     578         jpjall (jproc) = ijpj(ii,ij) 
     579         njs0all(jproc) = ijs0(ii,ij) 
     580         nje0all(jproc) = ije0(ii,ij) 
    614581         ibonit(jproc) = ibondi(ii,ij) 
    615582         ibonjt(jproc) = ibondj(ii,ij) 
     
    625592         WRITE(inum,'(6i8,a,3i8,a)') jpnij,jpimax,jpjmax,jpk,jpiglo,jpjglo,& 
    626593   &           ' ( local: ',narea,jpi,jpj,' )' 
    627          WRITE(inum,'(a)') 'nproc nlci nlcj nldi nldj nlei nlej nimp njmp nono noso nowe noea nbondi nbondj ' 
     594         WRITE(inum,'(a)') 'nproc jpi jpj Nis0 Njs0 Nie0 Nje0 nimp njmp nono noso nowe noea nbondi nbondj ' 
    628595 
    629596         DO jproc = 1, jpnij 
    630             WRITE(inum,'(13i5,2i7)')   jproc-1, nlcit  (jproc), nlcjt  (jproc),   & 
    631                &                                nldit  (jproc), nldjt  (jproc),   & 
    632                &                                nleit  (jproc), nlejt  (jproc),   & 
     597            WRITE(inum,'(13i5,2i7)')   jproc-1,  jpiall(jproc),  jpjall(jproc),   & 
     598               &                                nis0all(jproc), njs0all(jproc),   & 
     599               &                                nie0all(jproc), nje0all(jproc),   & 
    633600               &                                nimppt (jproc), njmppt (jproc),   &  
    634601               &                                ii_nono(jproc), ii_noso(jproc),   & 
     
    664631         WRITE(numout,*) '    l_Iperio = ', l_Iperio 
    665632         WRITE(numout,*) '    l_Jperio = ', l_Jperio 
    666          WRITE(numout,*) '      nlci   = ', nlci 
    667          WRITE(numout,*) '      nlcj   = ', nlcj 
    668633         WRITE(numout,*) '      nimpp  = ', nimpp 
    669634         WRITE(numout,*) '      njmpp  = ', njmpp 
    670          WRITE(numout,*) '      nreci  = ', nreci   
    671          WRITE(numout,*) '      nrecj  = ', nrecj   
    672          WRITE(numout,*) '      nn_hls = ', nn_hls  
    673635      ENDIF 
    674636 
     
    692654      ENDIF 
    693655      ! 
    694       CALL mpp_init_ioipsl       ! Prepare NetCDF output file (if necessary) 
     656      CALL init_ioipsl       ! Prepare NetCDF output file (if necessary) 
    695657      !       
    696658      IF (( jperio >= 3 .AND. jperio <= 6 .AND. jpni > 1 ).AND.( ln_nnogather )) THEN 
    697          CALL mpp_init_nfdcom     ! northfold neighbour lists 
     659         CALL init_nfdcom     ! northfold neighbour lists 
    698660         IF (llwrtlay) THEN 
    699661            WRITE(inum,*) 
    700662            WRITE(inum,*) 
    701663            WRITE(inum,*) 'north fold exchanges with explicit point-to-point messaging :' 
    702             WRITE(inum,*) 'nfsloop : ', nfsloop 
    703             WRITE(inum,*) 'nfeloop : ', nfeloop 
    704664            WRITE(inum,*) 'nsndto : ', nsndto 
    705665            WRITE(inum,*) 'isendto : ', isendto 
     
    711671      DEALLOCATE(iin, ijn, ii_nono, ii_noea, ii_noso, ii_nowe,    & 
    712672         &       iimppt, ijmppt, ibondi, ibondj, ipproc, ipolj,   & 
    713          &       ilci, ilcj, ilei, ilej, ildi, ildj,              & 
     673         &       ijpi, ijpj, iie0, ije0, iis0, ijs0,              & 
    714674         &       iono, ioea, ioso, iowe, llisoce) 
    715675      ! 
     
    717677 
    718678 
    719     SUBROUTINE mpp_basic_decomposition( knbi, knbj, kimax, kjmax, kimppt, kjmppt, klci, klcj) 
    720       !!---------------------------------------------------------------------- 
    721       !!                  ***  ROUTINE mpp_basic_decomposition  *** 
     679    SUBROUTINE mpp_basesplit( kiglo, kjglo, khls, knbi, knbj, kimax, kjmax, kimppt, kjmppt, klci, klcj) 
     680      !!---------------------------------------------------------------------- 
     681      !!                  ***  ROUTINE mpp_basesplit  *** 
    722682      !!                     
    723683      !! ** Purpose :   Lay out the global domain over processors. 
     
    731691      !!                    klcj       : second dimension 
    732692      !!---------------------------------------------------------------------- 
     693      INTEGER,                                 INTENT(in   ) ::   kiglo, kjglo 
     694      INTEGER,                                 INTENT(in   ) ::   khls 
    733695      INTEGER,                                 INTENT(in   ) ::   knbi, knbj 
    734696      INTEGER,                                 INTENT(  out) ::   kimax, kjmax 
     
    737699      ! 
    738700      INTEGER ::   ji, jj 
     701      INTEGER ::   i2hls  
    739702      INTEGER ::   iresti, irestj, irm, ijpjmin 
    740       INTEGER ::   ireci, irecj 
    741       !!---------------------------------------------------------------------- 
     703      !!---------------------------------------------------------------------- 
     704      i2hls = 2*khls 
    742705      ! 
    743706#if defined key_nemocice_decomp 
    744       kimax = ( nx_global+2-2*nn_hls + (knbi-1) ) / knbi + 2*nn_hls    ! first  dim. 
    745       kjmax = ( ny_global+2-2*nn_hls + (knbj-1) ) / knbj + 2*nn_hls    ! second dim.  
     707      kimax = ( nx_global+2-i2hls + (knbi-1) ) / knbi + i2hls    ! first  dim. 
     708      kjmax = ( ny_global+2-i2hls + (knbj-1) ) / knbj + i2hls    ! second dim.  
    746709#else 
    747       kimax = ( jpiglo - 2*nn_hls + (knbi-1) ) / knbi + 2*nn_hls    ! first  dim. 
    748       kjmax = ( jpjglo - 2*nn_hls + (knbj-1) ) / knbj + 2*nn_hls    ! second dim. 
     710      kimax = ( kiglo - i2hls + (knbi-1) ) / knbi + i2hls    ! first  dim. 
     711      kjmax = ( kjglo - i2hls + (knbj-1) ) / knbj + i2hls    ! second dim. 
    749712#endif 
    750713      IF( .NOT. PRESENT(kimppt) ) RETURN 
     
    753716      ! ----------------------------------- 
    754717      !  Computation of local domain sizes klci() klcj() 
    755       !  These dimensions depend on global sizes knbi,knbj and jpiglo,jpjglo 
     718      !  These dimensions depend on global sizes knbi,knbj and kiglo,kjglo 
    756719      !  The subdomains are squares lesser than or equal to the global 
    757720      !  dimensions divided by the number of processors minus the overlap array. 
    758721      ! 
    759       ireci = 2 * nn_hls 
    760       irecj = 2 * nn_hls 
    761       iresti = 1 + MOD( jpiglo - ireci -1 , knbi ) 
    762       irestj = 1 + MOD( jpjglo - irecj -1 , knbj ) 
     722      iresti = 1 + MOD( kiglo - i2hls - 1 , knbi ) 
     723      irestj = 1 + MOD( kjglo - i2hls - 1 , knbj ) 
    763724      ! 
    764725      !  Need to use kimax and kjmax here since jpi and jpj not yet defined 
    765726#if defined key_nemocice_decomp 
    766727      ! Change padding to be consistent with CICE 
    767       klci(1:knbi-1      ,:) = kimax 
    768       klci(knbi          ,:) = jpiglo - (knbi - 1) * (kimax - nreci) 
    769       klcj(:,      1:knbj-1) = kjmax 
    770       klcj(:,          knbj) = jpjglo - (knbj - 1) * (kjmax - nrecj) 
     728      klci(1:knbi-1,:       ) = kimax 
     729      klci(  knbi  ,:       ) = kiglo - (knbi - 1) * (kimax - i2hls) 
     730      klcj(:       ,1:knbj-1) = kjmax 
     731      klcj(:       ,  knbj  ) = kjglo - (knbj - 1) * (kjmax - i2hls) 
    771732#else 
    772733      klci(1:iresti      ,:) = kimax 
    773734      klci(iresti+1:knbi ,:) = kimax-1 
    774       IF( MINVAL(klci) < 3 ) THEN 
    775          WRITE(ctmp1,*) '   mpp_basic_decomposition: minimum value of jpi must be >= 3' 
     735      IF( MINVAL(klci) < 2*i2hls ) THEN 
     736         WRITE(ctmp1,*) '   mpp_basesplit: minimum value of jpi must be >= ', 2*i2hls 
    776737         WRITE(ctmp2,*) '   We have ', MINVAL(klci) 
    777738        CALL ctl_stop( 'STOP', ctmp1, ctmp2 ) 
     
    779740      IF( jperio == 3 .OR. jperio == 4 .OR. jperio == 5 .OR. jperio == 6 ) THEN 
    780741         ! minimize the size of the last row to compensate for the north pole folding coast 
    781          IF( jperio == 3 .OR. jperio == 4 )   ijpjmin = 5   ! V and F folding involves line jpj-3 that must not be south boundary 
    782          IF( jperio == 5 .OR. jperio == 6 )   ijpjmin = 4   ! V and F folding involves line jpj-2 that must not be south boundary 
    783          irm = knbj - irestj                                    ! total number of lines to be removed 
    784          klcj(:,            knbj) = MAX( ijpjmin, kjmax-irm )   ! we must have jpj >= ijpjmin in the last row 
    785          irm = irm - ( kjmax - klcj(1,knbj) )                   ! remaining number of lines to remove  
    786          irestj = knbj - 1 - irm                         
    787          klcj(:,        1:irestj) = kjmax 
     742         IF( jperio == 3 .OR. jperio == 4 )   ijpjmin = 2+3*khls   ! V and F folding must be outside of southern halos 
     743         IF( jperio == 5 .OR. jperio == 6 )   ijpjmin = 1+3*khls   ! V and F folding must be outside of southern halos 
     744         irm = knbj - irestj                                       ! total number of lines to be removed 
     745         klcj(:,knbj) = MAX( ijpjmin, kjmax-irm )                  ! we must have jpj >= ijpjmin in the last row 
     746         irm = irm - ( kjmax - klcj(1,knbj) )                      ! remaining number of lines to remove  
     747         irestj = knbj - 1 - irm 
    788748         klcj(:, irestj+1:knbj-1) = kjmax-1 
    789749      ELSE 
    790          ijpjmin = 3 
    791          klcj(:,      1:irestj) = kjmax 
    792          klcj(:, irestj+1:knbj) = kjmax-1 
    793       ENDIF 
    794       IF( MINVAL(klcj) < ijpjmin ) THEN 
    795          WRITE(ctmp1,*) '   mpp_basic_decomposition: minimum value of jpj must be >= ', ijpjmin 
     750         klcj(:, irestj+1:knbj  ) = kjmax-1 
     751      ENDIF 
     752      klcj(:,1:irestj) = kjmax 
     753      IF( MINVAL(klcj) < 2*i2hls ) THEN 
     754         WRITE(ctmp1,*) '   mpp_basesplit: minimum value of jpj must be >= ', 2*i2hls 
    796755         WRITE(ctmp2,*) '   We have ', MINVAL(klcj) 
    797756         CALL ctl_stop( 'STOP', ctmp1, ctmp2 ) 
     
    807766         DO jj = 1, knbj 
    808767            DO ji = 2, knbi 
    809                kimppt(ji,jj) = kimppt(ji-1,jj) + klci(ji-1,jj) - ireci 
     768               kimppt(ji,jj) = kimppt(ji-1,jj) + klci(ji-1,jj) - i2hls 
    810769            END DO 
    811770         END DO 
     
    815774         DO jj = 2, knbj 
    816775            DO ji = 1, knbi 
    817                kjmppt(ji,jj) = kjmppt(ji,jj-1) + klcj(ji,jj-1) - irecj 
     776               kjmppt(ji,jj) = kjmppt(ji,jj-1) + klcj(ji,jj-1) - i2hls 
    818777            END DO 
    819778         END DO 
    820779      ENDIF 
    821780       
    822    END SUBROUTINE mpp_basic_decomposition 
    823  
    824  
    825    SUBROUTINE mpp_init_bestpartition( knbij, knbi, knbj, knbcnt, ldlist ) 
    826       !!---------------------------------------------------------------------- 
    827       !!                 ***  ROUTINE mpp_init_bestpartition  *** 
     781   END SUBROUTINE mpp_basesplit 
     782 
     783 
     784   SUBROUTINE bestpartition( knbij, knbi, knbj, knbcnt, ldlist ) 
     785      !!---------------------------------------------------------------------- 
     786      !!                 ***  ROUTINE bestpartition  *** 
    828787      !! 
    829788      !! ** Purpose : 
     
    867826      inbimax = 0 
    868827      inbjmax = 0 
    869       isziref = jpiglo*jpjglo+1 
    870       iszjref = jpiglo*jpjglo+1 
     828      isziref = Ni0glo*Nj0glo+1 
     829      iszjref = Ni0glo*Nj0glo+1 
    871830      ! 
    872831      ! get the list of knbi that gives a smaller jpimax than knbi-1 
     
    876835         iszitst = ( nx_global+2-2*nn_hls + (ji-1) ) / ji + 2*nn_hls    ! first  dim. 
    877836#else 
    878          iszitst = ( jpiglo - 2*nn_hls + (ji-1) ) / ji + 2*nn_hls 
     837         iszitst = ( Ni0glo + (ji-1) ) / ji + 2*nn_hls 
    879838#endif 
    880839         IF( iszitst < isziref ) THEN 
     
    887846         iszjtst = ( ny_global+2-2*nn_hls + (ji-1) ) / ji + 2*nn_hls    ! first  dim. 
    888847#else 
    889          iszjtst = ( jpjglo - 2*nn_hls + (ji-1) ) / ji + 2*nn_hls 
     848         iszjtst = ( Nj0glo + (ji-1) ) / ji + 2*nn_hls 
    890849#endif 
    891850         IF( iszjtst < iszjref ) THEN 
     
    927886      iszij1(:) = iszi1(:) * iszj1(:) 
    928887 
    929       ! if therr is no land and no print 
     888      ! if there is no land and no print 
    930889      IF( .NOT. llist .AND. numbot == -1 .AND. numbdy == -1 ) THEN 
    931890         ! get the smaller partition which gives the smallest subdomain size 
     
    942901      isz0 = 0                                                  ! number of best partitions      
    943902      inbij = 1                                                 ! start with the min value of inbij1 => 1 
    944       iszij = jpiglo*jpjglo+1                                   ! default: larger than global domain 
     903      iszij = Ni0glo*Nj0glo+1                                   ! default: larger than global domain 
    945904      DO WHILE( inbij <= inbijmax )                             ! if we did not reach the max of inbij1 
    946905         ii = MINLOC(iszij1, mask = inbij1 == inbij, dim = 1)   ! warning: send back the first occurence if multiple results 
     
    975934         ji = isz0   ! initialization with the largest value 
    976935         ALLOCATE( llisoce(inbi0(ji), inbj0(ji)) ) 
    977          CALL mpp_init_isoce( inbi0(ji), inbj0(ji), llisoce ) ! Warning: must be call by all cores (call mpp_sum) 
     936         CALL mpp_is_ocean( llisoce )  ! Warning: must be call by all cores (call mpp_sum) 
    978937         inbijold = COUNT(llisoce) 
    979938         DEALLOCATE( llisoce ) 
    980939         DO ji =isz0-1,1,-1 
    981940            ALLOCATE( llisoce(inbi0(ji), inbj0(ji)) ) 
    982             CALL mpp_init_isoce( inbi0(ji), inbj0(ji), llisoce ) ! Warning: must be call by all cores (call mpp_sum) 
     941            CALL mpp_is_ocean( llisoce )  ! Warning: must be call by all cores (call mpp_sum) 
    983942            inbij = COUNT(llisoce) 
    984943            DEALLOCATE( llisoce ) 
     
    1006965         ii = ii -1  
    1007966         ALLOCATE( llisoce(inbi0(ii), inbj0(ii)) ) 
    1008          CALL mpp_init_isoce( inbi0(ii), inbj0(ii), llisoce )            ! must be done by all core 
     967         CALL mpp_is_ocean( llisoce )            ! must be done by all core 
    1009968         inbij = COUNT(llisoce) 
    1010969         DEALLOCATE( llisoce ) 
     
    1015974      DEALLOCATE( inbi0, inbj0 ) 
    1016975      ! 
    1017    END SUBROUTINE mpp_init_bestpartition 
     976   END SUBROUTINE bestpartition 
    1018977    
    1019978    
     
    1024983      !! ** Purpose : the the proportion of land points in the surface land-sea mask 
    1025984      !! 
    1026       !! ** Method  : read iproc strips (of length jpiglo) of the land-sea mask 
     985      !! ** Method  : read iproc strips (of length Ni0glo) of the land-sea mask 
    1027986      !!---------------------------------------------------------------------- 
    1028987      REAL(wp), INTENT(  out) :: propland    ! proportion of land points in the global domain (between 0 and 1) 
     
    10411000 
    10421001      ! number of processes reading the bathymetry file  
    1043       iproc = MINVAL( (/mppsize, jpjglo/2, 100/) )  ! read a least 2 lines, no more that 100 processes reading at the same time 
     1002      iproc = MINVAL( (/mppsize, Nj0glo/2, 100/) )  ! read a least 2 lines, no more that 100 processes reading at the same time 
    10441003       
    10451004      ! we want to read iproc strips of the land-sea mask. -> pick up iproc processes every idiv processes starting at 1 
     
    10511010      IF( MOD( narea-1, idiv ) == 0 .AND. iarea < iproc ) THEN   ! beware idiv can be = to 1 
    10521011         ! 
    1053          ijsz = jpjglo / iproc                                               ! width of the stripe to read 
    1054          IF( iarea < MOD(jpjglo,iproc) ) ijsz = ijsz + 1 
    1055          ijstr = iarea*(jpjglo/iproc) + MIN(iarea, MOD(jpjglo,iproc)) + 1    ! starting j position of the reading 
    1056          ! 
    1057          ALLOCATE( lloce(jpiglo, ijsz) )                                     ! allocate the strip 
    1058          CALL mpp_init_readbot_strip( ijstr, ijsz, lloce ) 
     1012         ijsz = Nj0glo / iproc                                               ! width of the stripe to read 
     1013         IF( iarea < MOD(Nj0glo,iproc) ) ijsz = ijsz + 1 
     1014         ijstr = iarea*(Nj0glo/iproc) + MIN(iarea, MOD(Nj0glo,iproc)) + 1    ! starting j position of the reading 
     1015         ! 
     1016         ALLOCATE( lloce(Ni0glo, ijsz) )                                     ! allocate the strip 
     1017         CALL readbot_strip( ijstr, ijsz, lloce ) 
    10591018         inboce = COUNT(lloce)                                               ! number of ocean point in the stripe 
    10601019         DEALLOCATE(lloce) 
     
    10651024      CALL mpp_sum( 'mppini', inboce )   ! total number of ocean points over the global domain 
    10661025      ! 
    1067       propland = REAL( jpiglo*jpjglo - inboce, wp ) / REAL( jpiglo*jpjglo, wp )  
     1026      propland = REAL( Ni0glo*Nj0glo - inboce, wp ) / REAL( Ni0glo*Nj0glo, wp )  
    10681027      ! 
    10691028   END SUBROUTINE mpp_init_landprop 
    10701029    
    10711030    
    1072    SUBROUTINE mpp_init_isoce( knbi, knbj, ldisoce ) 
    1073       !!---------------------------------------------------------------------- 
    1074       !!                  ***  ROUTINE mpp_init_nboce  *** 
    1075       !! 
    1076       !! ** Purpose : check for a mpi domain decomposition knbi x knbj which 
    1077       !!              subdomains contain at least 1 ocean point 
    1078       !! 
    1079       !! ** Method  : read knbj strips (of length jpiglo) of the land-sea mask 
    1080       !!---------------------------------------------------------------------- 
    1081       INTEGER,                       INTENT(in   ) ::   knbi, knbj     ! domain decomposition 
    1082       LOGICAL, DIMENSION(knbi,knbj), INTENT(  out) ::   ldisoce        ! .true. if a sub domain constains 1 ocean point  
    1083       ! 
    1084       INTEGER, DIMENSION(knbi,knbj) ::   inboce                        ! number oce oce pint in each mpi subdomain 
    1085       INTEGER, DIMENSION(knbi*knbj) ::   inboce_1d 
     1031   SUBROUTINE mpp_is_ocean( ldisoce ) 
     1032      !!---------------------------------------------------------------------- 
     1033      !!                  ***  ROUTINE mpp_is_ocean  *** 
     1034      !! 
     1035      !! ** Purpose : Check for a mpi domain decomposition inbi x inbj which 
     1036      !!              subdomains, including 1 halo (even if nn_hls>1), contain 
     1037      !!              at least 1 ocean point. 
     1038      !!              We must indeed ensure that each subdomain that is a neighbour 
     1039      !!              of a land subdomain as only land points on its boundary 
     1040      !!              (inside the inner subdomain) with the land subdomain. 
     1041      !!              This is needed to get the proper bondary conditions on 
     1042      !!              a subdomain with a closed boundary. 
     1043      !! 
     1044      !! ** Method  : read inbj strips (of length Ni0glo) of the land-sea mask 
     1045      !!---------------------------------------------------------------------- 
     1046      LOGICAL, DIMENSION(:,:), INTENT(  out) ::   ldisoce        ! .true. if a sub domain constains 1 ocean point  
     1047      ! 
    10861048      INTEGER :: idiv, iimax, ijmax, iarea 
     1049      INTEGER :: inbi, inbj, inx, iny, inry, isty 
    10871050      INTEGER :: ji, jn 
    1088       LOGICAL, ALLOCATABLE, DIMENSION(:,:) ::   lloce                  ! lloce(i,j) = .true. if the point (i,j) is ocean  
    1089       INTEGER, ALLOCATABLE, DIMENSION(:,:) ::   iimppt, ilci 
    1090       INTEGER, ALLOCATABLE, DIMENSION(:,:) ::   ijmppt, ilcj 
     1051      INTEGER, ALLOCATABLE, DIMENSION(:,:) ::   inboce           ! number oce oce pint in each mpi subdomain 
     1052      INTEGER, ALLOCATABLE, DIMENSION(:  ) ::   inboce_1d 
     1053      INTEGER, ALLOCATABLE, DIMENSION(:,:) ::   iimppt, ijpi 
     1054      INTEGER, ALLOCATABLE, DIMENSION(:,:) ::   ijmppt, ijpj 
     1055      LOGICAL, ALLOCATABLE, DIMENSION(:,:) ::   lloce            ! lloce(i,j) = .true. if the point (i,j) is ocean  
    10911056      !!---------------------------------------------------------------------- 
    10921057      ! do nothing if there is no land-sea mask 
     
    10951060         RETURN 
    10961061      ENDIF 
    1097  
    1098       ! we want to read knbj strips of the land-sea mask. -> pick up knbj processes every idiv processes starting at 1 
    1099       IF           ( knbj == 1 ) THEN   ;   idiv = mppsize 
    1100       ELSE IF ( mppsize < knbj ) THEN   ;   idiv = 1 
    1101       ELSE                              ;   idiv = ( mppsize - 1 ) / ( knbj - 1 ) 
    1102       ENDIF 
     1062      ! 
     1063      inbi = SIZE( ldisoce, dim = 1 ) 
     1064      inbj = SIZE( ldisoce, dim = 2 ) 
     1065      ! 
     1066      ! we want to read inbj strips of the land-sea mask. -> pick up inbj processes every idiv processes starting at 1 
     1067      IF           ( inbj == 1 ) THEN   ;   idiv = mppsize 
     1068      ELSE IF ( mppsize < inbj ) THEN   ;   idiv = 1 
     1069      ELSE                              ;   idiv = ( mppsize - 1 ) / ( inbj - 1 ) 
     1070      ENDIF 
     1071      ! 
     1072      ALLOCATE( inboce(inbi,inbj), inboce_1d(inbi*inbj) ) 
    11031073      inboce(:,:) = 0          ! default no ocean point found 
    1104  
    1105       DO jn = 0, (knbj-1)/mppsize   ! if mppsize < knbj : more strips than mpi processes (because of potential land domains) 
    1106          ! 
    1107          iarea = (narea-1)/idiv + jn * mppsize   ! involed process number (starting counting at 0) 
    1108          IF( MOD( narea-1, idiv ) == 0 .AND. iarea < knbj ) THEN   ! beware idiv can be = to 1 
     1074      ! 
     1075      DO jn = 0, (inbj-1)/mppsize   ! if mppsize < inbj : more strips than mpi processes (because of potential land domains) 
     1076         ! 
     1077         iarea = (narea-1)/idiv + jn * mppsize + 1                     ! involed process number (starting counting at 1) 
     1078         IF( MOD( narea-1, idiv ) == 0 .AND. iarea <= inbj ) THEN      ! beware idiv can be = to 1 
    11091079            ! 
    1110             ALLOCATE( iimppt(knbi,knbj), ijmppt(knbi,knbj), ilci(knbi,knbj), ilcj(knbi,knbj) ) 
    1111             CALL mpp_basic_decomposition( knbi, knbj, iimax, ijmax, iimppt, ijmppt, ilci, ilcj ) 
     1080            ALLOCATE( iimppt(inbi,inbj), ijmppt(inbi,inbj), ijpi(inbi,inbj), ijpj(inbi,inbj) ) 
     1081            CALL mpp_basesplit( Ni0glo, Nj0glo, 0, inbi, inbj, iimax, ijmax, iimppt, ijmppt, ijpi, ijpj ) 
    11121082            ! 
    1113             ALLOCATE( lloce(jpiglo, ilcj(1,iarea+1)) )                                         ! allocate the strip 
    1114             CALL mpp_init_readbot_strip( ijmppt(1,iarea+1), ilcj(1,iarea+1), lloce )           ! read the strip 
    1115             DO  ji = 1, knbi 
    1116                inboce(ji,iarea+1) = COUNT( lloce(iimppt(ji,1):iimppt(ji,1)+ilci(ji,1)-1,:) )   ! number of ocean point in subdomain 
     1083            inx = Ni0glo + 2   ;   iny = ijpj(1,iarea) + 2             ! strip size + 1 halo on each direction (even if nn_hls>1) 
     1084            ALLOCATE( lloce(inx, iny) )                                ! allocate the strip 
     1085            inry = iny - COUNT( (/ iarea == 1, iarea == inbj /) )      ! number of point to read in y-direction 
     1086            isty = 1 + COUNT( (/ iarea == 1 /) )                       ! read from the first or the second line? 
     1087            CALL readbot_strip( ijmppt(1,iarea) - 2 + isty, inry, lloce(2:inx-1, isty:inry+isty-1) )   ! read the strip 
     1088            !  
     1089            IF( iarea == 1    ) THEN                                   ! the first line was not read 
     1090               IF( jperio == 2 .OR. jperio == 7 ) THEN                 !   north-south periodocity 
     1091                  CALL readbot_strip( Nj0glo, 1, lloce(2:inx-1, 1) )   !   read the last line -> first line of lloce 
     1092               ELSE 
     1093                  lloce(2:inx-1,  1) = .FALSE.                         !   closed boundary 
     1094               ENDIF 
     1095            ENDIF 
     1096            IF( iarea == inbj ) THEN                                   ! the last line was not read 
     1097               IF( jperio == 2 .OR. jperio == 7 ) THEN                 !   north-south periodocity 
     1098                  CALL readbot_strip( 1, 1, lloce(2:inx-1,iny) )       !      read the first line -> last line of lloce 
     1099               ELSEIF( jperio == 3 .OR. jperio == 4 ) THEN             !   north-pole folding T-pivot, T-point  
     1100                  lloce(2,iny) = lloce(2,iny-2)                        !      here we have 1 halo (even if nn_hls>1) 
     1101                  DO ji = 3,inx-1 
     1102                     lloce(ji,iny  ) = lloce(inx-ji+2,iny-2)           !      ok, we have at least 3 lines 
     1103                  END DO 
     1104                  DO ji = inx/2+2,inx-1 
     1105                     lloce(ji,iny-1) = lloce(inx-ji+2,iny-1) 
     1106                  END DO 
     1107               ELSEIF( jperio == 5 .OR. jperio == 6 ) THEN             !   north-pole folding F-pivot, T-point, 1 halo 
     1108                  lloce(inx/2+1,iny-1) = lloce(inx/2,iny-1)            !      here we have 1 halo (even if nn_hls>1) 
     1109                  lloce(inx  -1,iny-1) = lloce(2    ,iny-1) 
     1110                  DO ji = 2,inx-1 
     1111                     lloce(ji,iny) = lloce(inx-ji+1,iny-1) 
     1112                  END DO 
     1113               ELSE                                                    !   closed boundary 
     1114                  lloce(2:inx-1,iny) = .FALSE. 
     1115               ENDIF 
     1116            ENDIF 
     1117            !                                                          ! first and last column were not read 
     1118            IF( jperio == 1 .OR. jperio == 4 .OR. jperio == 6 .OR. jperio == 7 ) THEN 
     1119               lloce(1,:) = lloce(inx-1,:)   ;   lloce(inx,:) = lloce(2,:)   ! east-west periodocity 
     1120            ELSE 
     1121               lloce(1,:) = .FALSE.          ;   lloce(inx,:) = .FALSE.      ! closed boundary 
     1122            ENDIF 
     1123            ! 
     1124            DO  ji = 1, inbi 
     1125               inboce(ji,iarea) = COUNT( lloce(iimppt(ji,1):iimppt(ji,1)+ijpi(ji,1)+1,:) )   ! lloce as 2 points more than Ni0glo 
    11171126            END DO 
    11181127            ! 
    11191128            DEALLOCATE(lloce) 
    1120             DEALLOCATE(iimppt, ijmppt, ilci, ilcj) 
     1129            DEALLOCATE(iimppt, ijmppt, ijpi, ijpj) 
    11211130            ! 
    11221131         ENDIF 
    11231132      END DO 
    11241133    
    1125       inboce_1d = RESHAPE(inboce, (/ knbi*knbj /)) 
     1134      inboce_1d = RESHAPE(inboce, (/ inbi*inbj /)) 
    11261135      CALL mpp_sum( 'mppini', inboce_1d ) 
    1127       inboce = RESHAPE(inboce_1d, (/knbi, knbj/)) 
     1136      inboce = RESHAPE(inboce_1d, (/inbi, inbj/)) 
    11281137      ldisoce(:,:) = inboce(:,:) /= 0 
    1129       ! 
    1130    END SUBROUTINE mpp_init_isoce 
     1138      DEALLOCATE(inboce, inboce_1d) 
     1139      ! 
     1140   END SUBROUTINE mpp_is_ocean 
    11311141    
    11321142    
    1133    SUBROUTINE mpp_init_readbot_strip( kjstr, kjcnt, ldoce ) 
    1134       !!---------------------------------------------------------------------- 
    1135       !!                  ***  ROUTINE mpp_init_readbot_strip  *** 
     1143   SUBROUTINE readbot_strip( kjstr, kjcnt, ldoce ) 
     1144      !!---------------------------------------------------------------------- 
     1145      !!                  ***  ROUTINE readbot_strip  *** 
    11361146      !! 
    11371147      !! ** Purpose : Read relevant bathymetric information in order to 
     
    11391149      !!              of land domains, in an mpp computation. 
    11401150      !! 
    1141       !! ** Method  : read stipe of size (jpiglo,...) 
    1142       !!---------------------------------------------------------------------- 
    1143       INTEGER                         , INTENT(in   ) :: kjstr       ! starting j position of the reading 
    1144       INTEGER                         , INTENT(in   ) :: kjcnt       ! number of lines to read 
    1145       LOGICAL, DIMENSION(jpiglo,kjcnt), INTENT(  out) :: ldoce       ! ldoce(i,j) = .true. if the point (i,j) is ocean  
     1151      !! ** Method  : read stipe of size (Ni0glo,...) 
     1152      !!---------------------------------------------------------------------- 
     1153      INTEGER                         , INTENT(in   ) ::   kjstr       ! starting j position of the reading 
     1154      INTEGER                         , INTENT(in   ) ::   kjcnt       ! number of lines to read 
     1155      LOGICAL, DIMENSION(Ni0glo,kjcnt), INTENT(  out) ::  ldoce       ! ldoce(i,j) = .true. if the point (i,j) is ocean  
    11461156      ! 
    11471157      INTEGER                           ::   inumsave                ! local logical unit 
    1148       REAL(wp), DIMENSION(jpiglo,kjcnt) ::   zbot, zbdy  
     1158      REAL(wp), DIMENSION(Ni0glo,kjcnt) ::   zbot, zbdy  
    11491159      !!---------------------------------------------------------------------- 
    11501160      ! 
    11511161      inumsave = numout   ;   numout = numnul   !   redirect all print to /dev/null 
    11521162      ! 
    1153       IF( numbot /= -1 ) THEN 
    1154          CALL iom_get( numbot, jpdom_unknown, 'bottom_level', zbot, kstart = (/1,kjstr/), kcount = (/jpiglo, kjcnt/) ) 
     1163      IF( numbot /= -1 ) THEN    
     1164         CALL iom_get( numbot, jpdom_unknown, 'bottom_level', zbot, kstart = (/1,kjstr/), kcount = (/Ni0glo, kjcnt/) ) 
    11551165      ELSE 
    1156          zbot(:,:) = 1.                         ! put a non-null value 
    1157       ENDIF 
    1158  
    1159        IF( numbdy /= -1 ) THEN                  ! Adjust with bdy_msk if it exists     
    1160          CALL iom_get ( numbdy, jpdom_unknown, 'bdy_msk', zbdy, kstart = (/1,kjstr/), kcount = (/jpiglo, kjcnt/) ) 
     1166         zbot(:,:) = 1._wp                      ! put a non-null value 
     1167      ENDIF 
     1168      ! 
     1169      IF( numbdy /= -1 ) THEN                   ! Adjust with bdy_msk if it exists     
     1170         CALL iom_get ( numbdy, jpdom_unknown,     'bdy_msk', zbdy, kstart = (/1,kjstr/), kcount = (/Ni0glo, kjcnt/) ) 
    11611171         zbot(:,:) = zbot(:,:) * zbdy(:,:) 
    11621172      ENDIF 
    11631173      ! 
    1164       ldoce(:,:) = zbot(:,:) > 0. 
     1174      ldoce(:,:) = zbot(:,:) > 0._wp 
    11651175      numout = inumsave 
    11661176      ! 
    1167    END SUBROUTINE mpp_init_readbot_strip 
    1168  
    1169  
    1170    SUBROUTINE mpp_init_ioipsl 
    1171       !!---------------------------------------------------------------------- 
    1172       !!                  ***  ROUTINE mpp_init_ioipsl  *** 
     1177   END SUBROUTINE readbot_strip 
     1178 
     1179 
     1180   SUBROUTINE mpp_getnum( ldisoce, kproc, kipos, kjpos ) 
     1181      !!---------------------------------------------------------------------- 
     1182      !!                  ***  ROUTINE mpp_getnum  *** 
     1183      !! 
     1184      !! ** Purpose : give a number to each MPI subdomains (starting at 0) 
     1185      !! 
     1186      !! ** Method  : start from bottom left. First skip land subdomain, and finally use them if needed 
     1187      !!---------------------------------------------------------------------- 
     1188      LOGICAL, DIMENSION(:,:), INTENT(in   ) ::   ldisoce     ! F if land process 
     1189      INTEGER, DIMENSION(:,:), INTENT(  out) ::   kproc       ! subdomain number (-1 if supressed, starting at 0) 
     1190      INTEGER, DIMENSION(  :), INTENT(  out) ::   kipos       ! i-position of the subdomain (from 1 to jpni) 
     1191      INTEGER, DIMENSION(  :), INTENT(  out) ::   kjpos       ! j-position of the subdomain (from 1 to jpnj) 
     1192      ! 
     1193      INTEGER :: ii, ij, jarea, iarea0 
     1194      INTEGER :: icont, i2add , ini, inj, inij 
     1195      !!---------------------------------------------------------------------- 
     1196      ! 
     1197      ini = SIZE(ldisoce, dim = 1) 
     1198      inj = SIZE(ldisoce, dim = 2) 
     1199      inij = SIZE(kipos) 
     1200      ! 
     1201      ! specify which subdomains are oce subdomains; other are land subdomains 
     1202      kproc(:,:) = -1 
     1203      icont = -1 
     1204      DO jarea = 1, ini*inj 
     1205         iarea0 = jarea - 1 
     1206         ii = 1 + MOD(iarea0,ini) 
     1207         ij = 1 +     iarea0/ini 
     1208         IF( ldisoce(ii,ij) ) THEN 
     1209            icont = icont + 1 
     1210            kproc(ii,ij) = icont 
     1211            kipos(icont+1) = ii 
     1212            kjpos(icont+1) = ij 
     1213         ENDIF 
     1214      END DO 
     1215      ! if needed add some land subdomains to reach inij active subdomains 
     1216      i2add = inij - COUNT( ldisoce ) 
     1217      DO jarea = 1, ini*inj 
     1218         iarea0 = jarea - 1 
     1219         ii = 1 + MOD(iarea0,ini) 
     1220         ij = 1 +     iarea0/ini 
     1221         IF( .NOT. ldisoce(ii,ij) .AND. i2add > 0 ) THEN 
     1222            icont = icont + 1 
     1223            kproc(ii,ij) = icont 
     1224            kipos(icont+1) = ii 
     1225            kjpos(icont+1) = ij 
     1226            i2add = i2add - 1 
     1227         ENDIF 
     1228      END DO 
     1229      ! 
     1230   END SUBROUTINE mpp_getnum 
     1231 
     1232 
     1233   SUBROUTINE init_ioipsl 
     1234      !!---------------------------------------------------------------------- 
     1235      !!                  ***  ROUTINE init_ioipsl  *** 
    11731236      !! 
    11741237      !! ** Purpose :    
     
    11871250      ! Set idompar values equivalent to the jpdom_local_noextra definition 
    11881251      ! used in IOM. This works even if jpnij .ne. jpni*jpnj. 
    1189       iglo(1) = jpiglo 
    1190       iglo(2) = jpjglo 
    1191       iloc(1) = nlci 
    1192       iloc(2) = nlcj 
    1193       iabsf(1) = nimppt(narea) 
    1194       iabsf(2) = njmppt(narea) 
     1252      iglo( :) = (/ Ni0glo, Nj0glo /) 
     1253      iloc( :) = (/ Ni_0  , Nj_0   /) 
     1254      iabsf(:) = (/ Nis0  , Njs0   /) + (/ nimpp, njmpp /) - 1 - nn_hls   ! corresponds to mig0(Nis0) but mig0 is not yet defined! 
    11951255      iabsl(:) = iabsf(:) + iloc(:) - 1 
    1196       ihals(1) = nldi - 1 
    1197       ihals(2) = nldj - 1 
    1198       ihale(1) = nlci - nlei 
    1199       ihale(2) = nlcj - nlej 
    1200       idid(1) = 1 
    1201       idid(2) = 2 
     1256      ihals(:) = (/ 0     , 0      /) 
     1257      ihale(:) = (/ 0     , 0      /) 
     1258      idid( :) = (/ 1     , 2      /) 
    12021259 
    12031260      IF(lwp) THEN 
    12041261          WRITE(numout,*) 
    1205           WRITE(numout,*) 'mpp_init_ioipsl :   iloc  = ', iloc (1), iloc (2) 
    1206           WRITE(numout,*) '~~~~~~~~~~~~~~~     iabsf = ', iabsf(1), iabsf(2) 
    1207           WRITE(numout,*) '                    ihals = ', ihals(1), ihals(2) 
    1208           WRITE(numout,*) '                    ihale = ', ihale(1), ihale(2) 
     1262          WRITE(numout,*) 'mpp init_ioipsl :   iloc  = ', iloc 
     1263          WRITE(numout,*) '~~~~~~~~~~~~~~~     iabsf = ', iabsf 
     1264          WRITE(numout,*) '                    ihals = ', ihals 
     1265          WRITE(numout,*) '                    ihale = ', ihale 
    12091266      ENDIF 
    12101267      ! 
    12111268      CALL flio_dom_set ( jpnij, nproc, idid, iglo, iloc, iabsf, iabsl, ihals, ihale, 'BOX', nidom) 
    12121269      ! 
    1213    END SUBROUTINE mpp_init_ioipsl   
    1214  
    1215  
    1216    SUBROUTINE mpp_init_nfdcom 
    1217       !!---------------------------------------------------------------------- 
    1218       !!                     ***  ROUTINE  mpp_init_nfdcom  *** 
     1270   END SUBROUTINE init_ioipsl   
     1271 
     1272 
     1273   SUBROUTINE init_nfdcom 
     1274      !!---------------------------------------------------------------------- 
     1275      !!                     ***  ROUTINE  init_nfdcom  *** 
    12191276      !! ** Purpose :   Setup for north fold exchanges with explicit  
    12201277      !!                point-to-point messaging 
     
    12261283      !!---------------------------------------------------------------------- 
    12271284      INTEGER  ::   sxM, dxM, sxT, dxT, jn 
    1228       INTEGER  ::   njmppmax 
    1229       !!---------------------------------------------------------------------- 
    1230       ! 
    1231       njmppmax = MAXVAL( njmppt ) 
     1285      !!---------------------------------------------------------------------- 
    12321286      ! 
    12331287      !initializes the north-fold communication variables 
     
    12351289      nsndto     = 0 
    12361290      ! 
    1237       IF ( njmpp == njmppmax ) THEN      ! if I am a process in the north 
     1291      IF ( njmpp == MAXVAL( njmppt ) ) THEN      ! if I am a process in the north 
    12381292         ! 
    12391293         !sxM is the first point (in the global domain) needed to compute the north-fold for the current process 
    1240          sxM = jpiglo - nimppt(narea) - nlcit(narea) + 1 
     1294         sxM = jpiglo - nimppt(narea) - jpiall(narea) + 1 
    12411295         !dxM is the last point (in the global domain) needed to compute the north-fold for the current process 
    12421296         dxM = jpiglo - nimppt(narea) + 2 
     
    12471301         DO jn = 1, jpni 
    12481302            ! 
    1249             sxT = nfiimpp(jn, jpnj)                            ! sxT = 1st  point (in the global domain) of the jn process 
    1250             dxT = nfiimpp(jn, jpnj) + nfilcit(jn, jpnj) - 1    ! dxT = last point (in the global domain) of the jn process 
     1303            sxT = nfimpp(jn)                    ! sxT = 1st  point (in the global domain) of the jn process 
     1304            dxT = nfimpp(jn) + nfjpi(jn) - 1    ! dxT = last point (in the global domain) of the jn process 
    12511305            ! 
    12521306            IF    ( sxT < sxM  .AND.  sxM < dxT ) THEN 
     
    12621316            ! 
    12631317         END DO 
    1264          nfsloop = 1 
    1265          nfeloop = nlci 
    1266          DO jn = 2,jpni-1 
    1267             IF( nfipproc(jn,jpnj) == (narea - 1) ) THEN 
    1268                IF( nfipproc(jn-1,jpnj) == -1 )   nfsloop = nldi 
    1269                IF( nfipproc(jn+1,jpnj) == -1 )   nfeloop = nlei 
    1270             ENDIF 
    1271          END DO 
    12721318         ! 
    12731319      ENDIF 
    12741320      l_north_nogather = .TRUE. 
    12751321      ! 
    1276    END SUBROUTINE mpp_init_nfdcom 
    1277  
     1322   END SUBROUTINE init_nfdcom 
    12781323 
    12791324#endif 
    12801325 
     1326   SUBROUTINE init_doloop 
     1327      !!---------------------------------------------------------------------- 
     1328      !!                  ***  ROUTINE init_doloop  *** 
     1329      !! 
     1330      !! ** Purpose :   set the starting/ending indices of DO-loop 
     1331      !!              These indices are used in do_loop_substitute.h90 
     1332      !!---------------------------------------------------------------------- 
     1333      ! 
     1334      Nis0 =   1+nn_hls   ;   Nis1 = Nis0-1   ;   Nis2 = MAX(  1, Nis0-2) 
     1335      Njs0 =   1+nn_hls   ;   Njs1 = Njs0-1   ;   Njs2 = MAX(  1, Njs0-2)   
     1336      !                                                  
     1337      Nie0 = jpi-nn_hls   ;   Nie1 = Nie0+1   ;   Nie2 = MIN(jpi, Nie0+2) 
     1338      Nje0 = jpj-nn_hls   ;   Nje1 = Nje0+1   ;   Nje2 = MIN(jpj, Nje0+2) 
     1339      ! 
     1340      IF( nn_hls == 1 ) THEN          !* halo size of 1 
     1341         ! 
     1342         Nis1nxt2 = Nis0   ;   Njs1nxt2 = Njs0 
     1343         Nie1nxt2 = Nie0   ;   Nje1nxt2 = Nje0 
     1344         ! 
     1345      ELSE                            !* larger halo size...  
     1346         ! 
     1347         Nis1nxt2 = Nis1   ;   Njs1nxt2 = Njs1 
     1348         Nie1nxt2 = Nie1   ;   Nje1nxt2 = Nje1 
     1349         ! 
     1350      ENDIF 
     1351      ! 
     1352      Ni_0 = Nie0 - Nis0 + 1 
     1353      Nj_0 = Nje0 - Njs0 + 1 
     1354      Ni_1 = Nie1 - Nis1 + 1 
     1355      Nj_1 = Nje1 - Njs1 + 1 
     1356      Ni_2 = Nie2 - Nis2 + 1 
     1357      Nj_2 = Nje2 - Njs2 + 1 
     1358      ! 
     1359   END SUBROUTINE init_doloop 
     1360    
    12811361   !!====================================================================== 
    12821362END MODULE mppini 
Note: See TracChangeset for help on using the changeset viewer.