Modified logic for choice of upwind scheme, so that it now uses

admmacros_advectionx,y,z, to be consistent with other macros
in this thorn. (Previously an 'advection' parameter was tested,
as well as a local check for enough grid points in the required
direction.)


git-svn-id: http://svn.einsteintoolkit.org/cactus/EinsteinBase/ADMMacros/trunk@46 b1d164ef-f17a-46e7-89d4-021c7118ef4e

1 files changed, 196 insertions, 190 deletions

diff --git a/src/macro/LIEK_guts.h b/src/macro/LIEK_guts.h
index dabbbf1..b18b3f9 100644
--- a/src/macro/LIEK_guts.h
+++ b/src/macro/LIEK_guts.h
@@ -31,309 +31,315 @@
       LIEK_LKXZ = 0.0D0
       LIEK_LKYZ = 0.0D0
 
-      if (CCTK_Equals(advection,'center').eq.1) then
+      if (admmacros_advectionx .eq. 0) then /* CENTER X */
+         
+         LIEK_LKXX = LIEK_LKXX + DXDK_DXDKXX*LIEK_BX
 
-         LIEK_LKXX = DXDK_DXDKXX*LIEK_BX + DYDK_DYDKXX*LIEK_BY \
-           + DZDK_DZDKXX*LIEK_BZ
+         LIEK_LKYY = LIEK_LKYY + DXDK_DXDKYY*LIEK_BX
 
-         LIEK_LKYY = DXDK_DXDKYY*LIEK_BX + DYDK_DYDKYY*LIEK_BY \
-           + DZDK_DZDKYY*LIEK_BZ
+         LIEK_LKZZ = LIEK_LKZZ + DXDK_DXDKZZ*LIEK_BX
 
-         LIEK_LKZZ = DXDK_DXDKZZ*LIEK_BX + DYDK_DYDKZZ*LIEK_BY \
-           + DZDK_DZDKZZ*LIEK_BZ
+         LIEK_LKXY = LIEK_LKXY + DXDK_DXDKXY*LIEK_BX
 
-         LIEK_LKXY = DXDK_DXDKXY*LIEK_BX + DYDK_DYDKXY*LIEK_BY \
-           + DZDK_DZDKXY*LIEK_BZ
+         LIEK_LKXZ = LIEK_LKXZ + DXDK_DXDKXZ*LIEK_BX
 
-         LIEK_LKXZ = DXDK_DXDKXZ*LIEK_BX + DYDK_DYDKXZ*LIEK_BY \
-           + DZDK_DZDKXZ*LIEK_BZ
+         LIEK_LKYZ = LIEK_LKYZ + DXDK_DXDKYZ*LIEK_BX
 
-         LIEK_LKYZ = DXDK_DXDKYZ*LIEK_BX + DYDK_DYDKYZ*LIEK_BY \
-           + DZDK_DZDKYZ*LIEK_BZ
+      else if (admmacros_advectionx .eq. 1) then /* UPWIND1 X */
 
-      else if ((CCTK_Equals(advection,'upwind1').eq.1).or. \
-        (i.eq.2).or.(i.eq.cctk_lsh(1)-1).or. \
-        (j.eq.2).or.(j.eq.cctk_lsh(2)-1).or. \
-        (k.eq.2).or.(k.eq.cctk_lsh(3)-1)) then
+         LIEK_LKXX = LIEK_LKXX + LIEK_BX \
+         *(kxx(i+1,j,k) - kxx(i,j,k))/dx
 
-         if (LIEK_BX.gt.0.0D0) then
+         LIEK_LKYY = LIEK_LKYY + LIEK_BX \
+         *(kyy(i+1,j,k) - kyy(i,j,k))/dx
 
-            LIEK_LKXX = LIEK_LKXX + LIEK_BX \
-              *(kxx(i+1,j,k) - kxx(i,j,k))/dx
+         LIEK_LKZZ = LIEK_LKZZ + LIEK_BX \
+         *(kzz(i+1,j,k) - kzz(i,j,k))/dx
 
-            LIEK_LKYY = LIEK_LKYY + LIEK_BX \
-              *(kyy(i+1,j,k) - kyy(i,j,k))/dx
+         LIEK_LKXY = LIEK_LKXY + LIEK_BX \
+         *(kxy(i+1,j,k) - kxy(i,j,k))/dx
 
-            LIEK_LKZZ = LIEK_LKZZ + LIEK_BX \
-              *(kzz(i+1,j,k) - kzz(i,j,k))/dx
+         LIEK_LKXZ = LIEK_LKXZ + LIEK_BX \
+         *(kxz(i+1,j,k) - kxz(i,j,k))/dx
 
-            LIEK_LKXY = LIEK_LKXY + LIEK_BX \
-              *(kxy(i+1,j,k) - kxy(i,j,k))/dx
+         LIEK_LKYZ = LIEK_LKYZ + LIEK_BX \
+         *(kyz(i+1,j,k) - kyz(i,j,k))/dx
 
-            LIEK_LKXZ = LIEK_LKXZ + LIEK_BX \
-              *(kxz(i+1,j,k) - kxz(i,j,k))/dx
+      else if (admmacros_advectionx .eq. -1) then /* UPWIND1 X */
 
-            LIEK_LKYZ = LIEK_LKYZ + LIEK_BX \
-              *(kyz(i+1,j,k) - kyz(i,j,k))/dx
+         LIEK_LKXX = LIEK_LKXX + LIEK_BX \
+         *(kxx(i,j,k) - kxx(i-1,j,k))/dx
 
-         else
+         LIEK_LKYY = LIEK_LKYY + LIEK_BX \
+         *(kyy(i,j,k) - kyy(i-1,j,k))/dx
 
-            LIEK_LKXX = LIEK_LKXX + LIEK_BX \
-              *(kxx(i,j,k) - kxx(i-1,j,k))/dx
+         LIEK_LKZZ = LIEK_LKZZ + LIEK_BX \
+         *(kzz(i,j,k) - kzz(i-1,j,k))/dx
 
-            LIEK_LKYY = LIEK_LKYY + LIEK_BX \
-              *(kyy(i,j,k) - kyy(i-1,j,k))/dx
+         LIEK_LKXY = LIEK_LKXY + LIEK_BX \
+         *(kxy(i,j,k) - kxy(i-1,j,k))/dx
 
-            LIEK_LKZZ = LIEK_LKZZ + LIEK_BX \
-              *(kzz(i,j,k) - kzz(i-1,j,k))/dx
+         LIEK_LKXZ = LIEK_LKXZ + LIEK_BX \
+         *(kxz(i,j,k) - kxz(i-1,j,k))/dx
 
-            LIEK_LKXY = LIEK_LKXY + LIEK_BX \
-              *(kxy(i,j,k) - kxy(i-1,j,k))/dx
+         LIEK_LKYZ = LIEK_LKYZ + LIEK_BX \
+         *(kyz(i,j,k) - kyz(i-1,j,k))/dx
 
-            LIEK_LKXZ = LIEK_LKXZ + LIEK_BX \
-              *(kxz(i,j,k) - kxz(i-1,j,k))/dx
+      else if (admmacros_advectionx .eq. 2) then /* UPWIND2 X */
 
-            LIEK_LKYZ = LIEK_LKYZ + LIEK_BX \
-              *(kyz(i,j,k) - kyz(i-1,j,k))/dx
+         LIEK_LKXX = LIEK_LKXX - 0.5D0*LIEK_BX/dx \
+         *(3.0D0*kxx(i,j,k) - 4.0D0*kxx(i+1,j,k) + kxx(i+2,j,k))
 
-         end if
+         LIEK_LKYY = LIEK_LKYY - 0.5D0*LIEK_BX/dx \
+         *(3.0D0*kyy(i,j,k) - 4.0D0*kyy(i+1,j,k) + kyy(i+2,j,k))
 
-         if (LIEK_BY.gt.0.0D0) then
+         LIEK_LKZZ = LIEK_LKZZ - 0.5D0*LIEK_BX/dx \
+         *(3.0D0*kzz(i,j,k) - 4.0D0*kzz(i+1,j,k) + kzz(i+2,j,k))
 
-            LIEK_LKXX = LIEK_LKXX + LIEK_BY \
-              *(kxx(i,j+1,k) - kxx(i,j,k))/dy
+         LIEK_LKXY = LIEK_LKXY - 0.5D0*LIEK_BX/dx \
+         *(3.0D0*kxy(i,j,k) - 4.0D0*kxy(i+1,j,k) + kxy(i+2,j,k))
 
-            LIEK_LKYY = LIEK_LKYY + LIEK_BY \
-              *(kyy(i,j+1,k) - kyy(i,j,k))/dy
+         LIEK_LKXZ = LIEK_LKXZ - 0.5D0*LIEK_BX/dx \
+         *(3.0D0*kxz(i,j,k) - 4.0D0*kxz(i+1,j,k) + kxz(i+2,j,k))
 
-            LIEK_LKZZ = LIEK_LKZZ + LIEK_BY \
-              *(kzz(i,j+1,k) - kzz(i,j,k))/dy
+         LIEK_LKYZ = LIEK_LKYZ - 0.5D0*LIEK_BX/dx \
+         *(3.0D0*kyz(i,j,k) - 4.0D0*kyz(i+1,j,k) + kyz(i+2,j,k))
 
-            LIEK_LKXY = LIEK_LKXY + LIEK_BY \
-              *(kxy(i,j+1,k) - kxy(i,j,k))/dy
+      else if (admmacros_advectionx .eq. -2) then /* UPWIND2 X */
 
-            LIEK_LKXZ = LIEK_LKXZ + LIEK_BY \
-              *(kxz(i,j+1,k) - kxz(i,j,k))/dy
+         LIEK_LKXX = LIEK_LKXX + 0.5D0*LIEK_BX/dx \
+         *(3.0D0*kxx(i,j,k) - 4.0D0*kxx(i-1,j,k) + kxx(i-2,j,k))
 
-            LIEK_LKYZ = LIEK_LKYZ + LIEK_BY \
-              *(kyz(i,j+1,k) - kyz(i,j,k))/dy
+         LIEK_LKYY = LIEK_LKYY + 0.5D0*LIEK_BX/dx \
+         *(3.0D0*kyy(i,j,k) - 4.0D0*kyy(i-1,j,k) + kyy(i-2,j,k))
 
-         else
+         LIEK_LKZZ = LIEK_LKZZ + 0.5D0*LIEK_BX/dx \
+         *(3.0D0*kzz(i,j,k) - 4.0D0*kzz(i-1,j,k) + kzz(i-2,j,k))
 
-            LIEK_LKXX = LIEK_LKXX + LIEK_BY \
-              *(kxx(i,j,k) - kxx(i,j-1,k))/dy
+         LIEK_LKXY = LIEK_LKXY + 0.5D0*LIEK_BX/dx \
+         *(3.0D0*kxy(i,j,k) - 4.0D0*kxy(i-1,j,k) + kxy(i-2,j,k))
 
-            LIEK_LKYY = LIEK_LKYY + LIEK_BY \
-              *(kyy(i,j,k) - kyy(i,j-1,k))/dy
+         LIEK_LKXZ = LIEK_LKXZ + 0.5D0*LIEK_BX/dx \
+         *(3.0D0*kxz(i,j,k) - 4.0D0*kxz(i-1,j,k) + kxz(i-2,j,k))
 
-            LIEK_LKZZ = LIEK_LKZZ + LIEK_BY \
-              *(kzz(i,j,k) - kzz(i,j-1,k))/dy
+         LIEK_LKYZ = LIEK_LKYZ + 0.5D0*LIEK_BX/dx \
+         *(3.0D0*kyz(i,j,k) - 4.0D0*kyz(i-1,j,k) + kyz(i-2,j,k))
 
-            LIEK_LKXY = LIEK_LKXY + LIEK_BY \
-              *(kxy(i,j,k) - kxy(i,j-1,k))/dy
+      end if
+
+
+      if (admmacros_advectiony .eq. 0) then /* CENTER Y */
+
+         LIEK_LKXX = LIEK_LKXX + DYDK_DYDKXX*LIEK_BY
+
+         LIEK_LKYY = LIEK_LKYY + DYDK_DYDKYY*LIEK_BY
 
-            LIEK_LKXZ = LIEK_LKXZ + LIEK_BY \
-              *(kxz(i,j,k) - kxz(i,j-1,k))/dy
+         LIEK_LKZZ = LIEK_LKZZ + DYDK_DYDKZZ*LIEK_BY
 
-            LIEK_LKYZ = LIEK_LKYZ + LIEK_BY \
-              *(kyz(i,j,k) - kyz(i,j-1,k))/dy
+         LIEK_LKXY = LIEK_LKXY + DYDK_DYDKXY*LIEK_BY
 
-         end if
+         LIEK_LKXZ = LIEK_LKXZ + DYDK_DYDKXZ*LIEK_BY
 
-         if (LIEK_BZ.gt.0.0D0) then
+         LIEK_LKYZ = LIEK_LKYZ + DYDK_DYDKYZ*LIEK_BY
 
-            LIEK_LKXX = LIEK_LKXX + LIEK_BZ \
-              *(kxx(i,j,k+1) - kxx(i,j,k))/dz
+      else if (admmacros_advectiony .eq. 1) then /* UPWIND1 Y */
 
-            LIEK_LKYY = LIEK_LKYY + LIEK_BZ \
-              *(kyy(i,j,k+1) - kyy(i,j,k))/dz
+         LIEK_LKXX = LIEK_LKXX + LIEK_BY \
+         *(kxx(i,j+1,k) - kxx(i,j,k))/dy
 
-            LIEK_LKZZ = LIEK_LKZZ + LIEK_BZ \
-              *(kzz(i,j,k+1) - kzz(i,j,k))/dz
+         LIEK_LKYY = LIEK_LKYY + LIEK_BY \
+         *(kyy(i,j+1,k) - kyy(i,j,k))/dy
 
-            LIEK_LKXY = LIEK_LKXY + LIEK_BZ \
-              *(kxy(i,j,k+1) - kxy(i,j,k))/dz
+         LIEK_LKZZ = LIEK_LKZZ + LIEK_BY \
+         *(kzz(i,j+1,k) - kzz(i,j,k))/dy
 
-            LIEK_LKXZ = LIEK_LKXZ + LIEK_BZ \
-              *(kxz(i,j,k+1) - kxz(i,j,k))/dz
+         LIEK_LKXY = LIEK_LKXY + LIEK_BY \
+         *(kxy(i,j+1,k) - kxy(i,j,k))/dy
 
-            LIEK_LKYZ = LIEK_LKYZ + LIEK_BZ \
-              *(kyz(i,j,k+1) - kyz(i,j,k))/dz
+         LIEK_LKXZ = LIEK_LKXZ + LIEK_BY \
+         *(kxz(i,j+1,k) - kxz(i,j,k))/dy
 
-         else
+         LIEK_LKYZ = LIEK_LKYZ + LIEK_BY \
+         *(kyz(i,j+1,k) - kyz(i,j,k))/dy
 
-            LIEK_LKXX = LIEK_LKXX + LIEK_BZ \
-              *(kxx(i,j,k) - kxx(i,j,k-1))/dz
+      else if (admmacros_advectiony .eq. -1) then /* UPWIND1 Y */
 
-            LIEK_LKYY = LIEK_LKYY + LIEK_BZ \
-              *(kyy(i,j,k) - kyy(i,j,k-1))/dz
+         LIEK_LKXX = LIEK_LKXX + LIEK_BY \
+         *(kxx(i,j,k) - kxx(i,j-1,k))/dy
 
-            LIEK_LKZZ = LIEK_LKZZ + LIEK_BZ \
-              *(kzz(i,j,k) - kzz(i,j,k-1))/dz
+         LIEK_LKYY = LIEK_LKYY + LIEK_BY \
+         *(kyy(i,j,k) - kyy(i,j-1,k))/dy
 
-            LIEK_LKXY = LIEK_LKXY + LIEK_BZ \
-              *(kxy(i,j,k) - kxy(i,j,k-1))/dz
+         LIEK_LKZZ = LIEK_LKZZ + LIEK_BY \
+         *(kzz(i,j,k) - kzz(i,j-1,k))/dy
 
-            LIEK_LKXZ = LIEK_LKXZ + LIEK_BZ \
-              *(kxz(i,j,k) - kxz(i,j,k-1))/dz
+         LIEK_LKXY = LIEK_LKXY + LIEK_BY \
+         *(kxy(i,j,k) - kxy(i,j-1,k))/dy
 
-            LIEK_LKYZ = LIEK_LKYZ + LIEK_BZ \
-              *(kyz(i,j,k) - kyz(i,j,k-1))/dz
+         LIEK_LKXZ = LIEK_LKXZ + LIEK_BY \
+         *(kxz(i,j,k) - kxz(i,j-1,k))/dy
 
-         end if
+         LIEK_LKYZ = LIEK_LKYZ + LIEK_BY \
+         *(kyz(i,j,k) - kyz(i,j-1,k))/dy
 
-      else if (CCTK_Equals(advection,'upwind2').eq.1) then
+      else if (admmacros_advectiony .eq. 2) then /* UPWIND2 Y */
 
-         if (LIEK_BX.gt.0.0D0) then
+         LIEK_LKXX = LIEK_LKXX - 0.5D0*LIEK_BY/dy \
+         *(3.0D0*kxx(i,j,k) - 4.0D0*kxx(i,j+1,k) + kxx(i,j+2,k))
 
-            LIEK_LKXX = LIEK_LKXX - 0.5D0*LIEK_BX/dx \
-              *(3.0D0*kxx(i,j,k) - 4.0D0*kxx(i+1,j,k) + kxx(i+2,j,k))
+         LIEK_LKYY = LIEK_LKYY - 0.5D0*LIEK_BY/dy \
+         *(3.0D0*kyy(i,j,k) - 4.0D0*kyy(i,j+1,k) + kyy(i,j+2,k))
 
-            LIEK_LKYY = LIEK_LKYY - 0.5D0*LIEK_BX/dx \
-              *(3.0D0*kyy(i,j,k) - 4.0D0*kyy(i+1,j,k) + kyy(i+2,j,k))
+         LIEK_LKZZ = LIEK_LKZZ - 0.5D0*LIEK_BY/dy \
+         *(3.0D0*kzz(i,j,k) - 4.0D0*kzz(i,j+1,k) + kzz(i,j+2,k))
 
-            LIEK_LKZZ = LIEK_LKZZ - 0.5D0*LIEK_BX/dx \
-              *(3.0D0*kzz(i,j,k) - 4.0D0*kzz(i+1,j,k) + kzz(i+2,j,k))
+         LIEK_LKXY = LIEK_LKXY - 0.5D0*LIEK_BY/dy \
+         *(3.0D0*kxy(i,j,k) - 4.0D0*kxy(i,j+1,k) + kxy(i,j+2,k))
 
-            LIEK_LKXY = LIEK_LKXY - 0.5D0*LIEK_BX/dx \
-              *(3.0D0*kxy(i,j,k) - 4.0D0*kxy(i+1,j,k) + kxy(i+2,j,k))
+         LIEK_LKXZ = LIEK_LKXZ - 0.5D0*LIEK_BY/dy \
+         *(3.0D0*kxz(i,j,k) - 4.0D0*kxz(i,j+1,k) + kxz(i,j+2,k))
 
-            LIEK_LKXZ = LIEK_LKXZ - 0.5D0*LIEK_BX/dx \
-              *(3.0D0*kxz(i,j,k) - 4.0D0*kxz(i+1,j,k) + kxz(i+2,j,k))
+         LIEK_LKYZ = LIEK_LKYZ - 0.5D0*LIEK_BY/dy \
+         *(3.0D0*kyz(i,j,k) - 4.0D0*kyz(i,j+1,k) + kyz(i,j+2,k))
 
-            LIEK_LKYZ = LIEK_LKYZ - 0.5D0*LIEK_BX/dx \
-              *(3.0D0*kyz(i,j,k) - 4.0D0*kyz(i+1,j,k) + kyz(i+2,j,k))
+      else if (admmacros_advectiony .eq. -2) then /* UPWIND2 Y */
 
-         else
+         LIEK_LKXX = LIEK_LKXX + 0.5D0*LIEK_BY/dy \
+         *(3.0D0*kxx(i,j,k) - 4.0D0*kxx(i,j-1,k) + kxx(i,j-2,k))
 
-            LIEK_LKXX = LIEK_LKXX + 0.5D0*LIEK_BX/dx \
-              *(3.0D0*kxx(i,j,k) - 4.0D0*kxx(i-1,j,k) + kxx(i-2,j,k))
+         LIEK_LKYY = LIEK_LKYY + 0.5D0*LIEK_BY/dy \
+         *(3.0D0*kyy(i,j,k) - 4.0D0*kyy(i,j-1,k) + kyy(i,j-2,k))
 
-            LIEK_LKYY = LIEK_LKYY + 0.5D0*LIEK_BX/dx \
-              *(3.0D0*kyy(i,j,k) - 4.0D0*kyy(i-1,j,k) + kyy(i-2,j,k))
+         LIEK_LKZZ = LIEK_LKZZ + 0.5D0*LIEK_BY/dy \
+         *(3.0D0*kzz(i,j,k) - 4.0D0*kzz(i,j-1,k) + kzz(i,j-2,k))
 
-            LIEK_LKZZ = LIEK_LKZZ + 0.5D0*LIEK_BX/dx \
-              *(3.0D0*kzz(i,j,k) - 4.0D0*kzz(i-1,j,k) + kzz(i-2,j,k))
+         LIEK_LKXY = LIEK_LKXY + 0.5D0*LIEK_BY/dy \
+         *(3.0D0*kxy(i,j,k) - 4.0D0*kxy(i,j-1,k) + kxy(i,j-2,k))
 
-            LIEK_LKXY = LIEK_LKXY + 0.5D0*LIEK_BX/dx \
-              *(3.0D0*kxy(i,j,k) - 4.0D0*kxy(i-1,j,k) + kxy(i-2,j,k))
+         LIEK_LKXZ = LIEK_LKXZ + 0.5D0*LIEK_BY/dy \
+         *(3.0D0*kxz(i,j,k) - 4.0D0*kxz(i,j-1,k) + kxz(i,j-2,k))
 
-            LIEK_LKXZ = LIEK_LKXZ + 0.5D0*LIEK_BX/dx \
-              *(3.0D0*kxz(i,j,k) - 4.0D0*kxz(i-1,j,k) + kxz(i-2,j,k))
+         LIEK_LKYZ = LIEK_LKYZ + 0.5D0*LIEK_BY/dy \
+         *(3.0D0*kyz(i,j,k) - 4.0D0*kyz(i,j-1,k) + kyz(i,j-2,k))
 
-            LIEK_LKYZ = LIEK_LKYZ + 0.5D0*LIEK_BX/dx \
-              *(3.0D0*kyz(i,j,k) - 4.0D0*kyz(i-1,j,k) + kyz(i-2,j,k))
+      end if
+
+
+      if (admmacros_advectionz .eq. 0) then /* CENTER Z */
 
-         end if
+         LIEK_LKXX = LIEK_LKXX + DZDK_DZDKXX*LIEK_BZ
 
-         if (LIEK_BY.gt.0.0D0) then
+         LIEK_LKYY = LIEK_LKYY + DZDK_DZDKYY*LIEK_BZ
 
-            LIEK_LKXX = LIEK_LKXX - 0.5D0*LIEK_BY/dy \
-              *(3.0D0*kxx(i,j,k) - 4.0D0*kxx(i,j+1,k) + kxx(i,j+2,k))
+         LIEK_LKZZ = LIEK_LKZZ + DZDK_DZDKZZ*LIEK_BZ
 
-            LIEK_LKYY = LIEK_LKYY - 0.5D0*LIEK_BY/dy \
-              *(3.0D0*kyy(i,j,k) - 4.0D0*kyy(i,j+1,k) + kyy(i,j+2,k))
+         LIEK_LKXY = LIEK_LKXY + DZDK_DZDKXY*LIEK_BZ
 
-            LIEK_LKZZ = LIEK_LKZZ - 0.5D0*LIEK_BY/dy \
-              *(3.0D0*kzz(i,j,k) - 4.0D0*kzz(i,j+1,k) + kzz(i,j+2,k))
+         LIEK_LKXZ = LIEK_LKXZ + DZDK_DZDKXZ*LIEK_BZ
 
-            LIEK_LKXY = LIEK_LKXY - 0.5D0*LIEK_BY/dy \
-              *(3.0D0*kxy(i,j,k) - 4.0D0*kxy(i,j+1,k) + kxy(i,j+2,k))
+         LIEK_LKYZ = LIEK_LKYZ + DZDK_DZDKYZ*LIEK_BZ
 
-            LIEK_LKXZ = LIEK_LKXZ - 0.5D0*LIEK_BY/dy \
-              *(3.0D0*kxz(i,j,k) - 4.0D0*kxz(i,j+1,k) + kxz(i,j+2,k))
+      else if (admmacros_advectionz .eq. 1) then /* UPWIND1 Z */
 
-            LIEK_LKYZ = LIEK_LKYZ - 0.5D0*LIEK_BY/dy \
-              *(3.0D0*kyz(i,j,k) - 4.0D0*kyz(i,j+1,k) + kyz(i,j+2,k))
+         LIEK_LKXX = LIEK_LKXX + LIEK_BZ \
+         *(kxx(i,j,k+1) - kxx(i,j,k))/dz
 
-         else
+         LIEK_LKYY = LIEK_LKYY + LIEK_BZ \
+         *(kyy(i,j,k+1) - kyy(i,j,k))/dz
 
-            LIEK_LKXX = LIEK_LKXX + 0.5D0*LIEK_BY/dy \
-              *(3.0D0*kxx(i,j,k) - 4.0D0*kxx(i,j-1,k) + kxx(i,j-2,k))
+         LIEK_LKZZ = LIEK_LKZZ + LIEK_BZ \
+         *(kzz(i,j,k+1) - kzz(i,j,k))/dz
 
-            LIEK_LKYY = LIEK_LKYY + 0.5D0*LIEK_BY/dy \
-              *(3.0D0*kyy(i,j,k) - 4.0D0*kyy(i,j-1,k) + kyy(i,j-2,k))
+         LIEK_LKXY = LIEK_LKXY + LIEK_BZ \
+         *(kxy(i,j,k+1) - kxy(i,j,k))/dz
 
-            LIEK_LKZZ = LIEK_LKZZ + 0.5D0*LIEK_BY/dy \
-              *(3.0D0*kzz(i,j,k) - 4.0D0*kzz(i,j-1,k) + kzz(i,j-2,k))
+         LIEK_LKXZ = LIEK_LKXZ + LIEK_BZ \
+         *(kxz(i,j,k+1) - kxz(i,j,k))/dz
 
-            LIEK_LKXY = LIEK_LKXY + 0.5D0*LIEK_BY/dy \
-              *(3.0D0*kxy(i,j,k) - 4.0D0*kxy(i,j-1,k) + kxy(i,j-2,k))
+         LIEK_LKYZ = LIEK_LKYZ + LIEK_BZ \
+         *(kyz(i,j,k+1) - kyz(i,j,k))/dz
 
-            LIEK_LKXZ = LIEK_LKXZ + 0.5D0*LIEK_BY/dy \
-              *(3.0D0*kxz(i,j,k) - 4.0D0*kxz(i,j-1,k) + kxz(i,j-2,k))
+      else if (admmacros_advectionz .eq. -1) then /* UPWIND1 Z */
 
-            LIEK_LKYZ = LIEK_LKYZ + 0.5D0*LIEK_BY/dy \
-              *(3.0D0*kyz(i,j,k) - 4.0D0*kyz(i,j-1,k) + kyz(i,j-2,k))
+         LIEK_LKXX = LIEK_LKXX + LIEK_BZ \
+         *(kxx(i,j,k) - kxx(i,j,k-1))/dz
 
-         end if
+         LIEK_LKYY = LIEK_LKYY + LIEK_BZ \
+         *(kyy(i,j,k) - kyy(i,j,k-1))/dz
 
-         if (LIEK_BZ.gt.0.0D0) then
+         LIEK_LKZZ = LIEK_LKZZ + LIEK_BZ \
+         *(kzz(i,j,k) - kzz(i,j,k-1))/dz
 
-            LIEK_LKXX = LIEK_LKXX - 0.5D0*LIEK_BZ/dz \
-              *(3.0D0*kxx(i,j,k) - 4.0D0*kxx(i,j,k+1) + kxx(i,j,k+2))
+         LIEK_LKXY = LIEK_LKXY + LIEK_BZ \
+         *(kxy(i,j,k) - kxy(i,j,k-1))/dz
 
-            LIEK_LKYY = LIEK_LKYY - 0.5D0*LIEK_BZ/dz \
-              *(3.0D0*kyy(i,j,k) - 4.0D0*kyy(i,j,k+1) + kyy(i,j,k+2))
+         LIEK_LKXZ = LIEK_LKXZ + LIEK_BZ \
+         *(kxz(i,j,k) - kxz(i,j,k-1))/dz
 
-            LIEK_LKZZ = LIEK_LKZZ - 0.5D0*LIEK_BZ/dz \
-              *(3.0D0*kzz(i,j,k) - 4.0D0*kzz(i,j,k+1) + kzz(i,j,k+2))
+      else if (admmacros_advectionz .eq. 2) then /* UPWIND2 Z */
 
-            LIEK_LKXY = LIEK_LKXY - 0.5D0*LIEK_BZ/dz \
-              *(3.0D0*kxy(i,j,k) - 4.0D0*kxy(i,j,k+1) + kxy(i,j,k+2))
+         LIEK_LKXX = LIEK_LKXX - 0.5D0*LIEK_BZ/dz \
+         *(3.0D0*kxx(i,j,k) - 4.0D0*kxx(i,j,k+1) + kxx(i,j,k+2))
 
-            LIEK_LKXZ = LIEK_LKXZ - 0.5D0*LIEK_BZ/dz \
-              *(3.0D0*kxz(i,j,k) - 4.0D0*kxz(i,j,k+1) + kxz(i,j,k+2))
+         LIEK_LKYY = LIEK_LKYY - 0.5D0*LIEK_BZ/dz \
+         *(3.0D0*kyy(i,j,k) - 4.0D0*kyy(i,j,k+1) + kyy(i,j,k+2))
 
-            LIEK_LKYZ = LIEK_LKYZ - 0.5D0*LIEK_BZ/dz \
-              *(3.0D0*kyz(i,j,k) - 4.0D0*kyz(i,j,k+1) + kyz(i,j,k+2))
+         LIEK_LKZZ = LIEK_LKZZ - 0.5D0*LIEK_BZ/dz \
+         *(3.0D0*kzz(i,j,k) - 4.0D0*kzz(i,j,k+1) + kzz(i,j,k+2))
 
-         else
+         LIEK_LKXY = LIEK_LKXY - 0.5D0*LIEK_BZ/dz \
+         *(3.0D0*kxy(i,j,k) - 4.0D0*kxy(i,j,k+1) + kxy(i,j,k+2))
 
-            LIEK_LKXX = LIEK_LKXX + 0.5D0*LIEK_BZ/dz \
-              *(3.0D0*kxx(i,j,k) - 4.0D0*kxx(i,j,k-1) + kxx(i,j,k-2))
+         LIEK_LKXZ = LIEK_LKXZ - 0.5D0*LIEK_BZ/dz \
+         *(3.0D0*kxz(i,j,k) - 4.0D0*kxz(i,j,k+1) + kxz(i,j,k+2))
 
-            LIEK_LKYY = LIEK_LKYY + 0.5D0*LIEK_BZ/dz \
-              *(3.0D0*kyy(i,j,k) - 4.0D0*kyy(i,j,k-1) + kyy(i,j,k-2))
+         LIEK_LKYZ = LIEK_LKYZ - 0.5D0*LIEK_BZ/dz \
+         *(3.0D0*kyz(i,j,k) - 4.0D0*kyz(i,j,k+1) + kyz(i,j,k+2))
 
-            LIEK_LKZZ = LIEK_LKZZ + 0.5D0*LIEK_BZ/dz \
-              *(3.0D0*kzz(i,j,k) - 4.0D0*kzz(i,j,k-1) + kzz(i,j,k-2))
+      else if (admmacros_advectionz .eq. -2) then /* UPWIND2 Z */
 
-            LIEK_LKXY = LIEK_LKXY + 0.5D0*LIEK_BZ/dz \
-              *(3.0D0*kxy(i,j,k) - 4.0D0*kxy(i,j,k-1) + kxy(i,j,k-2))
+         LIEK_LKXX = LIEK_LKXX + 0.5D0*LIEK_BZ/dz \
+         *(3.0D0*kxx(i,j,k) - 4.0D0*kxx(i,j,k-1) + kxx(i,j,k-2))
 
-            LIEK_LKXZ = LIEK_LKXZ + 0.5D0*LIEK_BZ/dz \
-              *(3.0D0*kxz(i,j,k) - 4.0D0*kxz(i,j,k-1) + kxz(i,j,k-2))
+         LIEK_LKYY = LIEK_LKYY + 0.5D0*LIEK_BZ/dz \
+         *(3.0D0*kyy(i,j,k) - 4.0D0*kyy(i,j,k-1) + kyy(i,j,k-2))
 
-            LIEK_LKYZ = LIEK_LKYZ + 0.5D0*LIEK_BZ/dz \
-              *(3.0D0*kyz(i,j,k) - 4.0D0*kyz(i,j,k-1) + kyz(i,j,k-2))
+         LIEK_LKZZ = LIEK_LKZZ + 0.5D0*LIEK_BZ/dz \
+         *(3.0D0*kzz(i,j,k) - 4.0D0*kzz(i,j,k-1) + kzz(i,j,k-2))
 
-         end if
+         LIEK_LKXY = LIEK_LKXY + 0.5D0*LIEK_BZ/dz \
+         *(3.0D0*kxy(i,j,k) - 4.0D0*kxy(i,j,k-1) + kxy(i,j,k-2))
 
+         LIEK_LKXZ = LIEK_LKXZ + 0.5D0*LIEK_BZ/dz \
+         *(3.0D0*kxz(i,j,k) - 4.0D0*kxz(i,j,k-1) + kxz(i,j,k-2))
+
+         LIEK_LKYZ = LIEK_LKYZ + 0.5D0*LIEK_BZ/dz \
+         *(3.0D0*kyz(i,j,k) - 4.0D0*kyz(i,j,k-1) + kyz(i,j,k-2))
       end if
 
-/*    Extra terms in the Lie derivative. */
+
+      /*    Extra terms in the Lie derivative. */
 
       LIEK_LKXX = LIEK_LKXX + 2.0D0*(DXDB_DXDBX*LIEK_KXX \
-        + DXDB_DXDBY*LIEK_KXY + DXDB_DXDBZ*LIEK_KXZ)
+      + DXDB_DXDBY*LIEK_KXY + DXDB_DXDBZ*LIEK_KXZ)
 
       LIEK_LKYY = LIEK_LKYY + 2.0D0*(DYDB_DYDBX*LIEK_KXY \
-        + DYDB_DYDBY*LIEK_KYY + DYDB_DYDBZ*LIEK_KYZ)
+      + DYDB_DYDBY*LIEK_KYY + DYDB_DYDBZ*LIEK_KYZ)
 
       LIEK_LKZZ = LIEK_LKZZ + 2.0D0*(DZDB_DZDBX*LIEK_KXZ \
-        + DZDB_DZDBY*LIEK_KYZ + DZDB_DZDBZ*LIEK_KZZ)
+      + DZDB_DZDBY*LIEK_KYZ + DZDB_DZDBZ*LIEK_KZZ)
 
       LIEK_LKXY = LIEK_LKXY + DYDB_DYDBX*LIEK_KXX + DXDB_DXDBY*LIEK_KYY \
-        + (DXDB_DXDBX + DYDB_DYDBY)*LIEK_KXY \
-        + DYDB_DYDBZ*LIEK_KXZ + DXDB_DXDBZ*LIEK_KYZ
+      + (DXDB_DXDBX + DYDB_DYDBY)*LIEK_KXY \
+      + DYDB_DYDBZ*LIEK_KXZ + DXDB_DXDBZ*LIEK_KYZ
 
       LIEK_LKXZ = LIEK_LKXZ + DZDB_DZDBX*LIEK_KXX + DXDB_DXDBZ*LIEK_KZZ \
-        + (DXDB_DXDBX + DZDB_DZDBZ)*LIEK_KXZ \
-        + DZDB_DZDBY*LIEK_KXY + DXDB_DXDBY*LIEK_KYZ
+      + (DXDB_DXDBX + DZDB_DZDBZ)*LIEK_KXZ \
+      + DZDB_DZDBY*LIEK_KXY + DXDB_DXDBY*LIEK_KYZ
 
       LIEK_LKYZ = LIEK_LKYZ + DZDB_DZDBY*LIEK_KYY + DYDB_DYDBZ*LIEK_KZZ \
-        + (DYDB_DYDBY + DZDB_DZDBZ)*LIEK_KYZ \
-        + DZDB_DZDBX*LIEK_KXY + DYDB_DYDBX*LIEK_KXZ
+      + (DYDB_DYDBY + DZDB_DZDBZ)*LIEK_KYZ \
+      + DZDB_DZDBX*LIEK_KXY + DYDB_DYDBX*LIEK_KXZ
 
 
 #endif