--- trunk/Sources/filtrez/inifilr.f	2015/04/29 15:47:56	134
+++ trunk/Sources/filtrez/inifilr.f	2015/07/29 09:52:33	165
@@ -1,395 +1,292 @@
 module inifilr_m
 
-  use dimens_m, only: iim
-
   IMPLICIT NONE
 
-  INTEGER jfiltnu, jfiltsu, jfiltnv, jfiltsv
-  INTEGER, PARAMETER:: nfilun=3, nfilus=2, nfilvn=2, nfilvs=2
+  ! North:
+
+  INTEGER jfiltnu, jfiltnv
+  ! index of the last scalar line filtered in northern hemisphere
+
+  real, allocatable:: matriceun(:, :, :) ! (iim, iim, 2:jfiltnu)
+  ! matrice filtre pour les champs situes sur la grille scalaire
+
+  real, allocatable:: matrinvn(:, :, :) ! (iim, iim, 2:jfiltnu)
+  ! matrice filtre pour les champs situes sur la grille scalaire, pour
+  ! le filtre inverse
+
+  real, allocatable:: matricevn(:, :, :) ! (iim, iim, jfiltnv)
+  ! matrice filtre pour les champs situes sur la grille de V ou de Z
 
-  real matriceun(iim,iim,nfilun), matriceus(iim,iim,nfilus)
-  real matricevn(iim,iim,nfilvn), matricevs(iim,iim,nfilvs)
-  real matrinvn(iim,iim,nfilun), matrinvs(iim,iim,nfilus)
+  ! South:
 
-  private iim, nfilun, nfilus, nfilvn, nfilvs
+  integer jfiltsu, jfiltsv
+  ! index of the first line filtered in southern hemisphere
+
+  real, allocatable:: matriceus(:, :, :) ! (iim, iim, jfiltsu:jjm)
+  ! matrice filtre pour les champs situes sur la grille scalaire
+
+  real, allocatable:: matrinvs(:, :, :) ! (iim, iim, jfiltsu:jjm)
+  ! matrice filtre pour les champs situes sur la grille scalaire, pour
+  ! le filtre inverse
+
+  real, allocatable:: matricevs(:, :, :) ! (iim, iim, jfiltsv:jjm)
+  ! matrice filtre pour les champs situes sur la grille de V ou de Z
 
 contains
 
   SUBROUTINE inifilr
 
-    ! From filtrez/inifilr.F, version 1.1.1.1 2004/05/19 12:53:09
+    ! From filtrez/inifilr.F, version 1.1.1.1, 2004/05/19 12:53:09
     ! H. Upadhyaya, O. Sharma
 
-    ! This routine computes the eigenfunctions of the laplacian on the
-    ! stretched grid, and the filtering coefficients.
-    ! We designate:
-    ! eignfn eigenfunctions of the discrete laplacian
-    ! eigenvl eigenvalues
-    ! jfiltn index of the last scalar line filtered in NH
-    ! jfilts index of the first line filtered in SH
-    ! modfrst index of the mode from where modes are filtered
-    ! modemax maximum number of modes (im)
-    ! coefil filtering coefficients (lamda_max * cos(rlat) / lamda)
-    ! sdd SQRT(dx)
-
-    ! The modes are filtered from modfrst to modemax.
-
-    USE coefils, ONLY : coefilu, coefilu2, coefilv, coefilv2, eignfnu, &
-         eignfnv, modfrstu, modfrstv
-    USE comgeom, ONLY : rlatu, rlatv, xprimu
+    ! This procedure computes the filtering coefficients for scalar
+    ! lines and meridional wind v lines. The modes are filtered from
+    ! modfrst to iim. We filter all those latitude lines where coefil
+    ! < 1. No filtering at poles. colat0 is to be used when alpha
+    ! (stretching coefficient) is set equal to zero for the regular
+    ! grid case.
+
     USE dimens_m, ONLY : iim, jjm
+    USE dynetat0_m, ONLY : rlatu, rlatv, xprimu, grossismx
     use inifgn_m, only: inifgn
+    use jumble, only: new_unit
     use nr_util, only: pi
-    USE serre, ONLY : grossismx
 
     ! Local:
-    REAL dlatu(jjm)
-    REAL rlamda(2: iim), eignvl(iim)
 
-    REAL lamdamax, cof
-    INTEGER i, j, modemax, imx, k, kf
-    REAL dymin, colat0
-    REAL eignft(iim, iim), coff
+    REAL dlatu(jjm)
+    REAL rlamda(2:iim)
+    real eignvl(iim) ! eigenvalues sorted in descending order (<= 0)
+    INTEGER i, j, unit
+    REAL colat0 ! > 0
+    REAL eignft(iim, iim)
+
+    real eignfnu(iim, iim), eignfnv(iim, iim)
+    ! eigenvectors of the discrete second derivative with respect to longitude
+
+    ! Filtering coefficients (lamda_max * cos(rlat) / lamda):
+    real coefil(iim)
+
+    ! Index of the mode from where modes are filtered:
+    integer, allocatable:: modfrstnu(:) ! (2:jfiltnu)
+    integer, allocatable:: modfrstsu(:) ! (jfiltsu:jjm)
+    integer, allocatable:: modfrstnv(:) ! (jfiltnv)
+    integer, allocatable:: modfrstsv(:) ! (jfiltsv:jjm)
 
     !-----------------------------------------------------------
 
     print *, "Call sequence information: inifilr"
 
-    CALL inifgn(eignvl)
-
-    PRINT *, 'EIGNVL '
-    PRINT "(1X, 5E13.6)", eignvl
-
-    ! compute eigenvalues and eigenfunctions
-    ! compute the filtering coefficients for scalar lines and
-    ! meridional wind v-lines
-    ! we filter all those latitude lines where coefil < 1
-    ! NO FILTERING AT POLES
-    ! colat0 is to be used when alpha (stretching coefficient)
-    ! is set equal to zero for the regular grid case
+    CALL inifgn(eignvl, eignfnu, eignfnv)
 
     ! Calcul de colat0
-
-    DO j = 1, jjm
-       dlatu(j) = rlatu(j) - rlatu(j+1)
-    END DO
-
-    dymin = dlatu(1)
-    DO j = 2, jjm
-       dymin = min(dymin, dlatu(j))
-    END DO
-
-    colat0 = min(0.5, dymin / minval(xprimu(:iim)))
-
+    forall (j = 1:jjm) dlatu(j) = rlatu(j) - rlatu(j + 1)
+    colat0 = min(0.5, minval(dlatu) / minval(xprimu(:iim)))
     PRINT *, 'colat0 = ', colat0
 
-    lamdamax = iim / (pi * colat0 / grossismx)
-    rlamda = lamdamax / sqrt(abs(eignvl(2: iim)))
-
-    DO j = 1, jjm
-       DO i = 1, iim
-          coefilu(i, j) = 0.
-          coefilv(i, j) = 0.
-          coefilu2(i, j) = 0.
-          coefilv2(i, j) = 0.
-       end DO
-    END DO
-
-    ! Determination de jfiltnu, jfiltnv, jfiltsu, jfiltsv
-
-    modemax = iim
-    imx = iim
-
-    PRINT *, 'TRUNCATION AT ', imx
-
-    DO j = 2, jjm / 2 + 1
-       IF (cos(rlatu(j)) / colat0 < 1. &
-            .and. rlamda(imx) * cos(rlatu(j)) < 1.) jfiltnu = j
+    rlamda = iim / (pi * colat0 / grossismx) / sqrt(- eignvl(2: iim))
 
-       IF (cos(rlatu(jjm - j + 2)) / colat0 < 1. &
-            .and. rlamda(imx) * cos(rlatu(jjm - j + 2)) < 1.) &
-            jfiltsu = jjm - j + 2
-    END DO
-
-    DO j = 1, jjm/2
-       cof = cos(rlatv(j))/colat0
-       IF (cof < 1.) THEN
-          IF (rlamda(imx)*cos(rlatv(j)) < 1.) jfiltnv = j
-       END IF
-
-       cof = cos(rlatv(jjm-j+1))/colat0
-       IF (cof < 1.) THEN
-          IF (rlamda(imx)*cos(rlatv(jjm-j+1)) < 1.) jfiltsv = jjm - j + 1
-       END IF
-    END DO
-
-    IF (jfiltnu <= 0) jfiltnu = 1
-    IF (jfiltnu > jjm/2+1) THEN
-       PRINT *, 'jfiltnu en dehors des valeurs acceptables ', jfiltnu
-       STOP 1
-    END IF
+    ! D\'etermination de jfilt[ns][uv] :
 
-    IF (jfiltsu <= 0) jfiltsu = 1
-    IF (jfiltsu > jjm + 1) THEN
-       PRINT *, 'jfiltsu en dehors des valeurs acceptables ', jfiltsu
+    jfiltnu = (jjm + 1) / 2
+    do while (cos(rlatu(jfiltnu)) >= colat0 &
+         .or. rlamda(iim) * cos(rlatu(jfiltnu)) >= 1.)
+       jfiltnu = jfiltnu - 1
+    end do
+
+    jfiltsu = jjm / 2 + 2
+    do while (cos(rlatu(jfiltsu)) >= colat0 &
+         .or. rlamda(iim) * cos(rlatu(jfiltsu)) >= 1.)
+       jfiltsu = jfiltsu + 1
+    end do
+
+    jfiltnv = jjm / 2
+    do while ((cos(rlatv(jfiltnv)) >= colat0 &
+         .or. rlamda(iim) * cos(rlatv(jfiltnv)) >= 1.) .and. jfiltnv >= 2)
+       jfiltnv = jfiltnv - 1
+    end do
+
+    if (cos(rlatv(jfiltnv)) >= colat0 &
+         .or. rlamda(iim) * cos(rlatv(jfiltnv)) >= 1.) then
+       ! {jfiltnv == 1}
+       PRINT *, 'Could not find jfiltnv.'
        STOP 1
     END IF
 
-    IF (jfiltnv <= 0) jfiltnv = 1
-    IF (jfiltnv > jjm/2) THEN
-       PRINT *, 'jfiltnv en dehors des valeurs acceptables ', jfiltnv
+    jfiltsv = (jjm + 1)/ 2 + 1
+    do while ((cos(rlatv(jfiltsv)) >= colat0 &
+         .or. rlamda(iim) * cos(rlatv(jfiltsv)) >= 1.) .and. jfiltsv <= jjm - 1)
+       jfiltsv = jfiltsv + 1
+    end do
+
+    IF (cos(rlatv(jfiltsv)) >= colat0 &
+         .or. rlamda(iim) * cos(rlatv(jfiltsv)) >= 1.) THEN
+       ! {jfiltsv == jjm}
+       PRINT *, 'Could not find jfiltsv.'
        STOP 1
     END IF
 
-    IF (jfiltsv <= 0) jfiltsv = 1
-    IF (jfiltsv > jjm) THEN
-       PRINT *, 'jfiltsv en dehors des valeurs acceptables ', jfiltsv
-       STOP 1
-    END IF
+    PRINT *, 'jfiltnu =', jfiltnu
+    PRINT *, 'jfiltsu =', jfiltsu
+    PRINT *, 'jfiltnv =', jfiltnv
+    PRINT *, 'jfiltsv =', jfiltsv
 
-    PRINT *, 'jfiltnv jfiltsv jfiltnu jfiltsu ', jfiltnv, jfiltsv, jfiltnu, &
-         jfiltsu
+    ! D\'etermination de modfrst[ns][uv] :
 
-    ! Determination de coefilu, coefilv, n=modfrstu, modfrstv
-
-    DO j = 1, jjm
-       modfrstu(j) = iim
-       modfrstv(j) = iim
-    END DO
+    allocate(modfrstnu(2:jfiltnu), modfrstsu(jfiltsu:jjm))
+    allocate(modfrstnv(jfiltnv), modfrstsv(jfiltsv:jjm))
 
     DO j = 2, jfiltnu
-       DO k = 2, modemax
-          cof = rlamda(k) * cos(rlatu(j))
-          IF (cof < 1.) exit
-       end DO
-       if (k == modemax + 1) cycle
-       modfrstu(j) = k
-
-       kf = modfrstu(j)
-       DO k = kf, modemax
-          cof = rlamda(k)*cos(rlatu(j))
-          coefilu(k, j) = cof - 1.
-          coefilu2(k, j) = cof*cof - 1.
-       end DO
+       modfrstnu(j) = 2
+       do while (rlamda(modfrstnu(j)) * cos(rlatu(j)) >= 1. &
+            .and. modfrstnu(j) <= iim - 1)
+          modfrstnu(j) = modfrstnu(j) + 1
+       end do
     END DO
 
     DO j = 1, jfiltnv
-       DO k = 2, modemax
-          cof = rlamda(k)*cos(rlatv(j))
-          IF (cof < 1.) exit
-       end DO
-       if (k == modemax + 1) cycle
-       modfrstv(j) = k
-
-       kf = modfrstv(j)
-       DO k = kf, modemax
-          cof = rlamda(k)*cos(rlatv(j))
-          coefilv(k, j) = cof - 1.
-          coefilv2(k, j) = cof*cof - 1.
-       end DO
+       modfrstnv(j) = 2
+       do while (rlamda(modfrstnv(j)) * cos(rlatv(j)) >= 1. &
+            .and. modfrstnv(j) <= iim - 1)
+          modfrstnv(j) = modfrstnv(j) + 1
+       end do
     end DO
 
     DO j = jfiltsu, jjm
-       DO k = 2, modemax
-          cof = rlamda(k)*cos(rlatu(j))
-          IF (cof < 1.) exit
-       end DO
-       if (k == modemax + 1) cycle
-       modfrstu(j) = k
-
-       kf = modfrstu(j)
-       DO k = kf, modemax
-          cof = rlamda(k)*cos(rlatu(j))
-          coefilu(k, j) = cof - 1.
-          coefilu2(k, j) = cof*cof - 1.
-       end DO
+       modfrstsu(j) = 2
+       do while (rlamda(modfrstsu(j)) * cos(rlatu(j)) >= 1. &
+            .and. modfrstsu(j) <= iim - 1)
+          modfrstsu(j) = modfrstsu(j) + 1
+       end do
     end DO
 
     DO j = jfiltsv, jjm
-       DO k = 2, modemax
-          cof = rlamda(k)*cos(rlatv(j))
-          IF (cof < 1.) exit
-       end DO
-       if (k == modemax + 1) cycle
-       modfrstv(j) = k
-
-       kf = modfrstv(j)
-       DO k = kf, modemax
-          cof = rlamda(k)*cos(rlatv(j))
-          coefilv(k, j) = cof - 1.
-          coefilv2(k, j) = cof*cof - 1.
-       end DO
-    END DO
+       modfrstsv(j) = 2
+       do while (rlamda(modfrstsv(j)) * cos(rlatv(j)) >= 1. &
+            .and. modfrstsv(j) <= iim - 1)
+          modfrstsv(j) = modfrstsv(j) + 1
+       end do
+    END DO
+
+    call new_unit(unit)
+
+    open(unit, file = "inifilr_out.txt", status = "replace", action = "write") 
+    write(unit, fmt = *) '"EIGNVL"', eignvl
+    close(unit)
+
+    open(unit, file = "modfrstnu.csv", status = "replace", action = "write") 
+    write(unit, fmt = *) '"rlatu (degrees north)" modfrstnu ' &
+         // '"rlamda(modfrstnu) * cos(rlatu) < 1"'
+    DO j = 2, jfiltnu
+       write(unit, fmt = *) rlatu(j) / pi * 180., modfrstnu(j), &
+            rlamda(modfrstnu(j)) * cos(rlatu(j)) < 1
+    end DO
+    close(unit)
 
-    IF (jfiltnv>=jjm/2 .OR. jfiltnu>=jjm/2) THEN
-       IF (jfiltnv == jfiltsv) jfiltsv = 1 + jfiltnv
-       IF (jfiltnu == jfiltsu) jfiltsu = 1 + jfiltnu
+    open(unit, file = "modfrstnv.csv", status = "replace", action = "write") 
+    write(unit, fmt = *) '"rlatv (degrees north)" modfrstnv ' &
+         // '"rlamda(modfrstnv) * cos(rlatv) < 1"'
+    DO j = 1, jfiltnv
+       write(unit, fmt = *) rlatv(j) / pi * 180., modfrstnv(j), &
+            rlamda(modfrstnv(j)) * cos(rlatv(j)) < 1
+    end DO
+    close(unit)
 
-       PRINT *, 'jfiltnv jfiltsv jfiltnu jfiltsu', jfiltnv, jfiltsv, jfiltnu, &
-            jfiltsu
-    END IF
+    open(unit, file = "modfrstsu.csv", status = "replace", action = "write") 
+     write(unit, fmt = *) '"rlatu (degrees north)" modfrstsu ' &
+         // '"rlamda(modfrstsu) * cos(rlatu) < 1"'
+   DO j = jfiltsu, jjm
+       write(unit, fmt = *) rlatu(j) / pi * 180., modfrstsu(j), &
+            rlamda(modfrstsu(j)) * cos(rlatu(j)) < 1
+    end DO
+    close(unit)
 
-    PRINT *, 'Modes premiers v '
-    PRINT 334, modfrstv
-    PRINT *, 'Modes premiers u '
-    PRINT 334, modfrstu
-
-    IF (nfilun < jfiltnu) THEN
-       PRINT *, 'le parametre nfilun utilise pour la matrice ', &
-            'matriceun est trop petit ! '
-       PRINT *, 'Le changer dans parafilt.h et le mettre a ', jfiltnu
-       PRINT *, 'Pour information, nfilun, nfilus, nfilvn, nfilvs ', &
-            'doivent etre egaux successivement a ', jfiltnu, &
-            jjm - jfiltsu + 1, jfiltnv, jjm - jfiltsv + 1
-       STOP 1
-    END IF
-    IF (nfilun > jfiltnu+2) THEN
-       PRINT *, 'le parametre nfilun utilise pour la matrice ', &
-            'matriceun est trop grand ! Gachis de memoire ! '
-       PRINT *, 'Le changer dans parafilt.h et le mettre a ', jfiltnu
-       PRINT *, 'Pour information, nfilun, nfilus, nfilvn, nfilvs ', &
-            'doivent etre egaux successivement a ', &
-            jfiltnu, jjm - jfiltsu + 1, jfiltnv, jjm - jfiltsv + 1
-    END IF
-    IF (nfilus < jjm-jfiltsu+1) THEN
-       PRINT *, 'le parametre nfilus utilise pour la matrice ', &
-            'matriceus est trop petit ! '
-       PRINT *, 'Le changer dans parafilt.h et le mettre a ', &
-            jjm - jfiltsu + 1
-       PRINT *, 'Pour information , nfilun, nfilus, nfilvn, nfilvs ', &
-            'doivent etre egaux successivement a ', &
-            jfiltnu, jjm - jfiltsu + 1, jfiltnv, jjm - jfiltsv + 1
-       STOP 1
-    END IF
-    IF (nfilus > jjm-jfiltsu+3) THEN
-       PRINT *, 'le parametre nfilus utilise pour la matrice ', &
-            'matriceus est trop grand ! '
-       PRINT *, 'Le changer dans parafilt.h et le mettre a ', &
-            jjm - jfiltsu + 1
-       PRINT *, 'Pour information , nfilun, nfilus, nfilvn, nfilvs ', &
-            'doivent etre egaux successivement a ', &
-            jfiltnu, jjm - jfiltsu + 1, jfiltnv, jjm - jfiltsv + 1
-    END IF
-    IF (nfilvn < jfiltnv) THEN
-       PRINT *, 'le parametre nfilvn utilise pour la matrice ', &
-            'matricevn est trop petit ! '
-       PRINT *, 'Le changer dans parafilt.h et le mettre a ', jfiltnv
-       PRINT *, 'Pour information , nfilun, nfilus, nfilvn, nfilvs ', &
-            'doivent etre egaux successivement a ', &
-            jfiltnu, jjm - jfiltsu + 1, jfiltnv, jjm - jfiltsv + 1
-       STOP 1
-    END IF
-    IF (nfilvn > jfiltnv+2) THEN
-       PRINT *, 'le parametre nfilvn utilise pour la matrice ', &
-            'matricevn est trop grand ! Gachis de memoire ! '
-       PRINT *, 'Le changer dans parafilt.h et le mettre a ', jfiltnv
-       PRINT *, 'Pour information , nfilun, nfilus, nfilvn, nfilvs ', &
-            'doivent etre egaux successivement a ', &
-            jfiltnu, jjm - jfiltsu + 1, jfiltnv, jjm - jfiltsv + 1
-    END IF
-    IF (nfilvs < jjm-jfiltsv+1) THEN
-       PRINT *, 'le parametre nfilvs utilise pour la matrice ', &
-            'matricevs est trop petit ! Le changer dans parafilt.h '
-       PRINT *, 'Le changer dans parafilt.h et le mettre a ', &
-            jjm - jfiltsv + 1
-       PRINT *, 'Pour information , nfilun, nfilus, nfilvn, nfilvs ', &
-            'doivent etre egaux successivement a ', &
-            jfiltnu, jjm - jfiltsu + 1, jfiltnv, jjm - jfiltsv + 1
-       STOP 1
-    END IF
-    IF (nfilvs > jjm-jfiltsv+3) THEN
-       PRINT *, 'le parametre nfilvs utilise pour la matrice ', &
-            'matricevs est trop grand ! Gachis de memoire ! '
-       PRINT *, 'Le changer dans parafilt.h et le mettre a ', &
-            jjm - jfiltsv + 1
-       PRINT *, 'Pour information , nfilun, nfilus, nfilvn, nfilvs ', &
-            'doivent etre egaux successivement a ', &
-            jfiltnu, jjm - jfiltsu + 1, jfiltnv, jjm - jfiltsv + 1
-    END IF
+    open(unit, file = "modfrstsv.csv", status = "replace", action = "write") 
+    write(unit, fmt = *) '"rlatv (degrees north)" modfrstsv ' &
+         // '"rlamda(modfrstsv) * cos(rlatv) < 1"'
+    DO j = jfiltsv, jjm
+       write(unit, fmt = *) rlatv(j) / pi * 180., modfrstsv(j), &
+            rlamda(modfrstsv(j)) * cos(rlatv(j)) < 1
+    end DO
+    close(unit)
+
+    allocate(matriceun(iim, iim, 2:jfiltnu), matrinvn(iim, iim, 2:jfiltnu))
+    allocate(matricevn(iim, iim, jfiltnv))
+    allocate(matricevs(iim, iim, jfiltsv:jjm))
+    allocate(matriceus(iim, iim, jfiltsu:jjm), matrinvs(iim, iim, jfiltsu:jjm))
 
-    ! Calcul de la matrice filtre 'matriceu' pour les champs situes
-    ! sur la grille scalaire
+    ! Calcul de matriceu et matrinv
 
     DO j = 2, jfiltnu
-       DO i = 1, iim
-          IF (i < modfrstu(j)) then
-             coff = 0.
-          else
-             coff = coefilu(i, j)
-          end IF
-          eignft(i, :) = eignfnv(:, i)*coff
-       END DO
-       matriceun(:, :, j) = matmul(eignfnv, eignft)
+       if (rlamda(modfrstnu(j)) * cos(rlatu(j)) < 1.) then
+          DO i = modfrstnu(j), iim
+             coefil(i) = rlamda(i) * cos(rlatu(j)) - 1.
+          end DO
+
+          eignft(:modfrstnu(j) - 1, :) = 0.
+
+          forall (i = modfrstnu(j):iim) eignft(i, :) = eignfnv(:, i) * coefil(i)
+          matriceun(:, :, j) = matmul(eignfnv, eignft)
+
+          forall (i = modfrstnu(j):iim) eignft(i, :) = eignfnv(:, i) &
+               * coefil(i) / (1. + coefil(i))
+          matrinvn(:, :, j) = matmul(eignfnv, eignft)
+       else
+          matriceun(:, :, j) = 0.
+          matrinvn(:, :, j) = 0.
+       end if
     END DO
 
     DO j = jfiltsu, jjm
-       DO i = 1, iim
-          IF (i < modfrstu(j)) then
-             coff = 0.
-          else
-             coff = coefilu(i, j)
-          end IF
-          eignft(i, :) = eignfnv(:, i) * coff
-       END DO
-       matriceus(:, :, j - jfiltsu + 1) = matmul(eignfnv, eignft)
+       if (rlamda(modfrstsu(j)) * cos(rlatu(j)) < 1.) then
+          DO i = modfrstsu(j), iim
+             coefil(i) = rlamda(i) * cos(rlatu(j)) - 1.
+          end DO
+
+          eignft(:modfrstsu(j) - 1, :) = 0.
+
+          forall (i = modfrstsu(j):iim) eignft(i, :) = eignfnv(:, i) * coefil(i)
+          matriceus(:, :, j) = matmul(eignfnv, eignft)
+
+          forall (i = modfrstsu(j):iim) eignft(i, :) = eignfnv(:, i) &
+               * coefil(i) / (1. + coefil(i))
+          matrinvs(:, :, j) = matmul(eignfnv, eignft)
+       else
+          matriceus(:, :, j) = 0.
+          matrinvs(:, :, j) = 0.
+       end if
     END DO
 
-    ! Calcul de la matrice filtre 'matricev' pour les champs situes
-    ! sur la grille de V ou de Z
+    ! Calcul de matricev
 
     DO j = 1, jfiltnv
-       DO i = 1, iim
-          IF (i < modfrstv(j)) then
-             coff = 0.
-          else
-             coff = coefilv(i, j)
-          end IF
-          eignft(i, :) = eignfnu(:, i)*coff
-       END DO
-       matricevn(:, :, j) = matmul(eignfnu, eignft)
+       if (rlamda(modfrstnv(j)) * cos(rlatv(j)) < 1.) then
+          DO i = modfrstnv(j), iim
+             coefil(i) = rlamda(i) * cos(rlatv(j)) - 1.
+          end DO
+
+          eignft(:modfrstnv(j) - 1, :) = 0.
+          forall (i = modfrstnv(j):iim) eignft(i, :) = eignfnu(:, i) * coefil(i)
+          matricevn(:, :, j) = matmul(eignfnu, eignft)
+       else
+          matricevn(:, :, j) = 0.
+       end if
     END DO
 
     DO j = jfiltsv, jjm
-       DO i = 1, iim
-          IF (i < modfrstv(j)) then
-             coff = 0.
-          else
-             coff = coefilv(i, j)
-          end IF
-          eignft(i, :) = eignfnu(:, i)*coff
-       END DO
-       matricevs(:, :, j-jfiltsv+1) = matmul(eignfnu, eignft)
+       if (rlamda(modfrstsv(j)) * cos(rlatv(j)) < 1.) then
+          DO i = modfrstsv(j), iim
+             coefil(i) = rlamda(i) * cos(rlatv(j)) - 1.
+          end DO
+
+          eignft(:modfrstsv(j) - 1, :) = 0.
+          forall (i = modfrstsv(j):iim) eignft(i, :) = eignfnu(:, i) * coefil(i)
+          matricevs(:, :, j) = matmul(eignfnu, eignft)
+       else
+          matricevs(:, :, j) = 0.
+       end if
     END DO
 
-    ! Calcul de la matrice filtre 'matrinv' pour les champs situes
-    ! sur la grille scalaire , pour le filtre inverse
-
-    DO j = 2, jfiltnu
-       DO i = 1, iim
-          IF (i < modfrstu(j)) then
-             coff = 0.
-          else
-             coff = coefilu(i, j)/(1.+coefilu(i, j))
-          end IF
-          eignft(i, :) = eignfnv(:, i)*coff
-       END DO
-       matrinvn(:, :, j) = matmul(eignfnv, eignft)
-    END DO
-
-    DO j = jfiltsu, jjm
-       DO i = 1, iim
-          IF (i < modfrstu(j)) then
-             coff = 0.
-          else
-             coff = coefilu(i, j)/(1.+coefilu(i, j))
-          end IF
-          eignft(i, :) = eignfnv(:, i)*coff
-       END DO
-       matrinvs(:, :, j-jfiltsu+1) = matmul(eignfnv, eignft)
-    END DO
-
-334 FORMAT (1X, 24I3)
-
   END SUBROUTINE inifilr
 
 end module inifilr_m