














































C     Extract Cauchy data from the slice x^A(x^i) stored in slicex,
C     slicey, slicez, slicet, and calculate dx^A/dt.
C $Header$




































































 


































































































































































 


















































































































































































































 



















































 










 








































































































































































































































 










                                
                                

                                
                                

                                
                                

                                









































































c
c

c

c
c
c
c
c
c
c
c
c

c

      subroutine Exact__slice_data(cctk_dim,cctk_gsh,cctk_lsh,cctk_lbnd,
     &cctk_ubnd,cctk_tile_min,cctk_tile_max,cctk_ash,cctk_alignment,cctk
     &_alignment_offset,cctk_from,cctk_to,cctk_bbox,cctk_delta_time,cctk
     &_time,cctk_delta_space,cctk_origin_space,cctk_levfac,cctk_levoff,c
     &ctk_levoffdenom,cctk_timefac,cctk_convlevel,cctk_convfac,cctk_ngho
     &stzones,cctk_iteration,cctkGH,cctk_ash1,cctk_ash2,cctk_ash3, slice
     &t,slicetmp1t,slicetmp1x,slicetmp1y,slicetmp1z,slicetmp2t,slicetmp2
     &x,slicetmp2y,slicetmp2z,slicex,slicey,slicez, Bertotti___Lambda,Ka
     &sner_generalized___p1,Kasner_generalized___p2,Kasner_like___q,Lema
     &itre___Lambda,Lemaitre___R0,Lemaitre___epsilon0,Lemaitre___kappa,S
     &chwarzschild_Lemaitre___Lambda,Schwarzschild_Lemaitre___mass,anti_
     &de_Sitter_Lambda___scale,constant_density_star___mass,constant_den
     &sity_star___radius,de_Sitter_Lambda___scale,de_Sitter___scale,deco
     &ded_exact_model, active_slicing_handle,alp,alp_p,alp_p_p,betax,bet
     &ax_p,betax_p_p,betay,betay_p,betay_p_p,betaz,betaz_p,betaz_p_p,coa
     &rse_dx,coarse_dy,coarse_dz,conformal_state,dtalp,dtalp_p,dtalp_p_p
     &,dtbetax,dtbetax_p,dtbetax_p_p,dtbetay,dtbetay_p,dtbetay_p_p,dtbet
     &az,dtbetaz_p,dtbetaz_p_p,dtlapse_state,dtshift_state,gxx,gxx_p,gxx
     &_p_p,gxy,gxy_p,gxy_p_p,gxz,gxz_p,gxz_p_p,gyy,gyy_p,gyy_p_p,gyz,gyz
     &_p,gyz_p_p,gzz,gzz_p,gzz_p_p,kxx,kxx_p,kxx_p_p,kxy,kxy_p,kxy_p_p,k
     &xz,kxz_p,kxz_p_p,kyy,kyy_p,kyy_p_p,kyz,kyz_p,kyz_p_p,kzz,kzz_p,kzz
     &_p_p,psi,psix,psixx,psixy,psixz,psiy,psiyy,psiyz,psiz,psizz,r,shif
     &t_state,x,y,z)
      implicit none

      INTEGER cctk_dim
      integer, parameter :: cctki_use_cctk_dim = kind(cctk_dim)
      INTEGER cctk_gsh (cctk_dim)
      integer, parameter :: cctki_use_cctk_gsh = kind(cctk_gsh)
      INTEGER cctk_lsh (cctk_dim)
      integer, parameter :: cctki_use_cctk_lsh = kind(cctk_lsh)
      INTEGER cctk_lbnd (cctk_dim)
      integer, parameter :: cctki_use_cctk_lbnd = kind(cctk_lbnd)
      INTEGER cctk_ubnd (cctk_dim)
      integer, parameter :: cctki_use_cctk_ubnd = kind(cctk_ubnd)
      INTEGER cctk_tile_min (cctk_dim)
      integer, parameter :: cctki_use_cctk_tile_min = kind(cctk_tile_min
     &)
      INTEGER cctk_tile_max (cctk_dim)
      integer, parameter :: cctki_use_cctk_tile_max = kind(cctk_tile_max
     &)
      INTEGER cctk_ash (cctk_dim)
      integer, parameter :: cctki_use_cctk_ash = kind(cctk_ash)
      INTEGER cctk_alignment
      integer, parameter :: cctki_use_cctk_alignment = kind(cctk_alignme
     &nt)
      INTEGER cctk_alignment_offset
      integer, parameter :: cctki_use_cctk_alignment_offset = kind(cctk_
     &alignment_offset)
      INTEGER cctk_from (cctk_dim)
      integer, parameter :: cctki_use_cctk_from = kind(cctk_from)
      INTEGER cctk_to (cctk_dim)
      integer, parameter :: cctki_use_cctk_to = kind(cctk_to)
      INTEGER cctk_bbox (2*cctk_dim)
      integer, parameter :: cctki_use_cctk_bbox = kind(cctk_bbox)
      REAL*8 cctk_delta_time
      integer, parameter :: cctki_use_cctk_delta_time = kind(cctk_delta_
     &time)
      REAL*8 cctk_time
      integer, parameter :: cctki_use_cctk_time = kind(cctk_time)
      REAL*8 cctk_delta_space (cctk_dim)
      integer, parameter :: cctki_use_cctk_delta_space = kind(cctk_delta
     &_space)
      REAL*8 cctk_origin_space (cctk_dim)
      integer, parameter :: cctki_use_cctk_origin_space = kind(cctk_orig
     &in_space)
      INTEGER cctk_levfac (cctk_dim)
      integer, parameter :: cctki_use_cctk_levfac = kind(cctk_levfac)
      INTEGER cctk_levoff (cctk_dim)
      integer, parameter :: cctki_use_cctk_levoff = kind(cctk_levoff)
      INTEGER cctk_levoffdenom (cctk_dim)
      integer, parameter :: cctki_use_cctk_levoffdenom = kind(cctk_levof
     &fdenom)
      INTEGER cctk_timefac
      integer, parameter :: cctki_use_cctk_timefac = kind(cctk_timefac)
      INTEGER cctk_convlevel
      integer, parameter :: cctki_use_cctk_convlevel = kind(cctk_convlev
     &el)
      INTEGER cctk_convfac
      integer, parameter :: cctki_use_cctk_convfac = kind(cctk_convfac)
      INTEGER cctk_nghostzones (cctk_dim)
      integer, parameter :: cctki_use_cctk_nghostzones = kind(cctk_nghos
     &tzones)
      INTEGER cctk_iteration
      integer, parameter :: cctki_use_cctk_iteration = kind(cctk_iterati
     &on)
      integer*8 cctkGH
      integer, parameter :: cctki_use_cctkGH = kind(cctkGH)
      INTEGER cctk_ash1
      integer, parameter :: cctki_use_cctk_ash1 = kind(cctk_ash1)
      INTEGER cctk_ash2
      integer, parameter :: cctki_use_cctk_ash2 = kind(cctk_ash2)
      INTEGER cctk_ash3
      integer, parameter :: cctki_use_cctk_ash3 = kind(cctk_ash3)
      REAL*8, iNteNt(iN) :: alp (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_alp = kind(alp)
      REAL*8 :: kxx (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_kxx = kind(kxx)
      REAL*8 :: kxy (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_kxy = kind(kxy)
      REAL*8 :: kxz (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_kxz = kind(kxz)
      REAL*8 :: kyy (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_kyy = kind(kyy)
      REAL*8 :: kyz (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_kyz = kind(kyz)
      REAL*8 :: kzz (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_kzz = kind(kzz)
      REAL*8 :: gxx (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_gxx = kind(gxx)
      REAL*8 :: gxy (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_gxy = kind(gxy)
      REAL*8 :: gxz (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_gxz = kind(gxz)
      REAL*8 :: gyy (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_gyy = kind(gyy)
      REAL*8 :: gyz (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_gyz = kind(gyz)
      REAL*8 :: gzz (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_gzz = kind(gzz)
      REAL*8, iNteNt(iN) :: betax (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_betax = kind(betax)
      REAL*8, iNteNt(iN) :: betay (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_betay = kind(betay)
      REAL*8, iNteNt(iN) :: betaz (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_betaz = kind(betaz)
      INTEGER*4, iNteNt(iN) :: decoded_exact_model
      integer, parameter :: cctki_use_decoded_exact_model = kind(decoded
     &_exact_model)
      REAL*8, iNteNt(iN) :: slicet (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_slicet = kind(slicet)
      REAL*8, iNteNt(iN) :: slicex (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_slicex = kind(slicex)
      REAL*8, iNteNt(iN) :: slicey (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_slicey = kind(slicey)
      REAL*8, iNteNt(iN) :: slicez (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_slicez = kind(slicez)
      REAL*8 :: slicetmp2t (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_slicetmp2t = kind(slicetmp2t)
      REAL*8 :: slicetmp2x (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_slicetmp2x = kind(slicetmp2x)
      REAL*8 :: slicetmp2y (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_slicetmp2y = kind(slicetmp2y)
      REAL*8 :: slicetmp2z (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_slicetmp2z = kind(slicetmp2z)
      REAL*8, iNteNt(iN) :: x (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_x = kind(x)
      REAL*8, iNteNt(iN) :: y (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_y = kind(y)
      REAL*8, iNteNt(iN) :: z (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_z = kind(z)
      INTEGER*4, iNteNt(iN) :: conformal_state
      integer, parameter :: cctki_use_conformal_state = kind(conformal_s
     &tate)
      characTer*8, intent(IN) :: slicetmp1t
      integer, parameter :: cctki_use_slicetmp1t = kind(slicetmp1t)
      characTer*8, intent(IN) :: slicetmp1x
      integer, parameter :: cctki_use_slicetmp1x = kind(slicetmp1x)
      characTer*8, intent(IN) :: slicetmp1y
      integer, parameter :: cctki_use_slicetmp1y = kind(slicetmp1y)
      characTer*8, intent(IN) :: slicetmp1z
      integer, parameter :: cctki_use_slicetmp1z = kind(slicetmp1z)
      characTer*8, intent(IN) :: bertotti___lambda
      integer, parameter :: cctki_use_bertotti___lambda = kind(bertotti_
     &__lambda)
      characTer*8, intent(IN) :: kasner_generalized___p1
      integer, parameter :: cctki_use_kasner_generalized___p1 = kind(kas
     &ner_generalized___p1)
      characTer*8, intent(IN) :: kasner_generalized___p2
      integer, parameter :: cctki_use_kasner_generalized___p2 = kind(kas
     &ner_generalized___p2)
      characTer*8, intent(IN) :: kasner_like___q
      integer, parameter :: cctki_use_kasner_like___q = kind(kasner_like
     &___q)
      characTer*8, intent(IN) :: lemaitre___lambda
      integer, parameter :: cctki_use_lemaitre___lambda = kind(lemaitre_
     &__lambda)
      characTer*8, intent(IN) :: lemaitre___r0
      integer, parameter :: cctki_use_lemaitre___r0 = kind(lemaitre___r0
     &)
      characTer*8, intent(IN) :: lemaitre___epsilon0
      integer, parameter :: cctki_use_lemaitre___epsilon0 = kind(lemaitr
     &e___epsilon0)
      characTer*8, intent(IN) :: lemaitre___kappa
      integer, parameter :: cctki_use_lemaitre___kappa = kind(lemaitre__
     &_kappa)
      characTer*8, intent(IN) :: schwarzschild_lemaitre___lambda
      integer, parameter :: cctki_use_schwarzschild_lemaitre___lambda = 
     &kind(schwarzschild_lemaitre___lambda)
      characTer*8, intent(IN) :: schwarzschild_lemaitre___mass
      integer, parameter :: cctki_use_schwarzschild_lemaitre___mass = ki
     &nd(schwarzschild_lemaitre___mass)
      characTer*8, intent(IN) :: anti_de_sitter_lambda___scale
      integer, parameter :: cctki_use_anti_de_sitter_lambda___scale = ki
     &nd(anti_de_sitter_lambda___scale)
      characTer*8, intent(IN) :: constant_density_star___mass
      integer, parameter :: cctki_use_constant_density_star___mass = kin
     &d(constant_density_star___mass)
      characTer*8, intent(IN) :: constant_density_star___radius
      integer, parameter :: cctki_use_constant_density_star___radius = k
     &ind(constant_density_star___radius)
      characTer*8, intent(IN) :: de_sitter_lambda___scale
      integer, parameter :: cctki_use_de_sitter_lambda___scale = kind(de
     &_sitter_lambda___scale)
      characTer*8, intent(IN) :: de_sitter___scale
      integer, parameter :: cctki_use_de_sitter___scale = kind(de_sitter
     &___scale)
      characTer*8, intent(IN) :: active_slicing_handle
      integer, parameter :: cctki_use_active_slicing_handle = kind(activ
     &e_slicing_handle)
      characTer*8, intent(IN) :: alp_p
      integer, parameter :: cctki_use_alp_p = kind(alp_p)
      characTer*8, intent(IN) :: alp_p_p
      integer, parameter :: cctki_use_alp_p_p = kind(alp_p_p)
      characTer*8, intent(IN) :: betax_p
      integer, parameter :: cctki_use_betax_p = kind(betax_p)
      characTer*8, intent(IN) :: betax_p_p
      integer, parameter :: cctki_use_betax_p_p = kind(betax_p_p)
      characTer*8, intent(IN) :: betay_p
      integer, parameter :: cctki_use_betay_p = kind(betay_p)
      characTer*8, intent(IN) :: betay_p_p
      integer, parameter :: cctki_use_betay_p_p = kind(betay_p_p)
      characTer*8, intent(IN) :: betaz_p
      integer, parameter :: cctki_use_betaz_p = kind(betaz_p)
      characTer*8, intent(IN) :: betaz_p_p
      integer, parameter :: cctki_use_betaz_p_p = kind(betaz_p_p)
      characTer*8, intent(IN) :: coarse_dx
      integer, parameter :: cctki_use_coarse_dx = kind(coarse_dx)
      characTer*8, intent(IN) :: coarse_dy
      integer, parameter :: cctki_use_coarse_dy = kind(coarse_dy)
      characTer*8, intent(IN) :: coarse_dz
      integer, parameter :: cctki_use_coarse_dz = kind(coarse_dz)
      characTer*8, intent(IN) :: dtalp
      integer, parameter :: cctki_use_dtalp = kind(dtalp)
      characTer*8, intent(IN) :: dtalp_p
      integer, parameter :: cctki_use_dtalp_p = kind(dtalp_p)
      characTer*8, intent(IN) :: dtalp_p_p
      integer, parameter :: cctki_use_dtalp_p_p = kind(dtalp_p_p)
      characTer*8, intent(IN) :: dtbetax
      integer, parameter :: cctki_use_dtbetax = kind(dtbetax)
      characTer*8, intent(IN) :: dtbetax_p
      integer, parameter :: cctki_use_dtbetax_p = kind(dtbetax_p)
      characTer*8, intent(IN) :: dtbetax_p_p
      integer, parameter :: cctki_use_dtbetax_p_p = kind(dtbetax_p_p)
      characTer*8, intent(IN) :: dtbetay
      integer, parameter :: cctki_use_dtbetay = kind(dtbetay)
      characTer*8, intent(IN) :: dtbetay_p
      integer, parameter :: cctki_use_dtbetay_p = kind(dtbetay_p)
      characTer*8, intent(IN) :: dtbetay_p_p
      integer, parameter :: cctki_use_dtbetay_p_p = kind(dtbetay_p_p)
      characTer*8, intent(IN) :: dtbetaz
      integer, parameter :: cctki_use_dtbetaz = kind(dtbetaz)
      characTer*8, intent(IN) :: dtbetaz_p
      integer, parameter :: cctki_use_dtbetaz_p = kind(dtbetaz_p)
      characTer*8, intent(IN) :: dtbetaz_p_p
      integer, parameter :: cctki_use_dtbetaz_p_p = kind(dtbetaz_p_p)
      characTer*8, intent(IN) :: dtlapse_state
      integer, parameter :: cctki_use_dtlapse_state = kind(dtlapse_state
     &)
      characTer*8, intent(IN) :: dtshift_state
      integer, parameter :: cctki_use_dtshift_state = kind(dtshift_state
     &)
      characTer*8, intent(IN) :: gxx_p
      integer, parameter :: cctki_use_gxx_p = kind(gxx_p)
      characTer*8, intent(IN) :: gxx_p_p
      integer, parameter :: cctki_use_gxx_p_p = kind(gxx_p_p)
      characTer*8, intent(IN) :: gxy_p
      integer, parameter :: cctki_use_gxy_p = kind(gxy_p)
      characTer*8, intent(IN) :: gxy_p_p
      integer, parameter :: cctki_use_gxy_p_p = kind(gxy_p_p)
      characTer*8, intent(IN) :: gxz_p
      integer, parameter :: cctki_use_gxz_p = kind(gxz_p)
      characTer*8, intent(IN) :: gxz_p_p
      integer, parameter :: cctki_use_gxz_p_p = kind(gxz_p_p)
      characTer*8, intent(IN) :: gyy_p
      integer, parameter :: cctki_use_gyy_p = kind(gyy_p)
      characTer*8, intent(IN) :: gyy_p_p
      integer, parameter :: cctki_use_gyy_p_p = kind(gyy_p_p)
      characTer*8, intent(IN) :: gyz_p
      integer, parameter :: cctki_use_gyz_p = kind(gyz_p)
      characTer*8, intent(IN) :: gyz_p_p
      integer, parameter :: cctki_use_gyz_p_p = kind(gyz_p_p)
      characTer*8, intent(IN) :: gzz_p
      integer, parameter :: cctki_use_gzz_p = kind(gzz_p)
      characTer*8, intent(IN) :: gzz_p_p
      integer, parameter :: cctki_use_gzz_p_p = kind(gzz_p_p)
      characTer*8, intent(IN) :: kxx_p
      integer, parameter :: cctki_use_kxx_p = kind(kxx_p)
      characTer*8, intent(IN) :: kxx_p_p
      integer, parameter :: cctki_use_kxx_p_p = kind(kxx_p_p)
      characTer*8, intent(IN) :: kxy_p
      integer, parameter :: cctki_use_kxy_p = kind(kxy_p)
      characTer*8, intent(IN) :: kxy_p_p
      integer, parameter :: cctki_use_kxy_p_p = kind(kxy_p_p)
      characTer*8, intent(IN) :: kxz_p
      integer, parameter :: cctki_use_kxz_p = kind(kxz_p)
      characTer*8, intent(IN) :: kxz_p_p
      integer, parameter :: cctki_use_kxz_p_p = kind(kxz_p_p)
      characTer*8, intent(IN) :: kyy_p
      integer, parameter :: cctki_use_kyy_p = kind(kyy_p)
      characTer*8, intent(IN) :: kyy_p_p
      integer, parameter :: cctki_use_kyy_p_p = kind(kyy_p_p)
      characTer*8, intent(IN) :: kyz_p
      integer, parameter :: cctki_use_kyz_p = kind(kyz_p)
      characTer*8, intent(IN) :: kyz_p_p
      integer, parameter :: cctki_use_kyz_p_p = kind(kyz_p_p)
      characTer*8, intent(IN) :: kzz_p
      integer, parameter :: cctki_use_kzz_p = kind(kzz_p)
      characTer*8, intent(IN) :: kzz_p_p
      integer, parameter :: cctki_use_kzz_p_p = kind(kzz_p_p)
      characTer*8, intent(IN) :: psi
      integer, parameter :: cctki_use_psi = kind(psi)
      characTer*8, intent(IN) :: psix
      integer, parameter :: cctki_use_psix = kind(psix)
      characTer*8, intent(IN) :: psixx
      integer, parameter :: cctki_use_psixx = kind(psixx)
      characTer*8, intent(IN) :: psixy
      integer, parameter :: cctki_use_psixy = kind(psixy)
      characTer*8, intent(IN) :: psixz
      integer, parameter :: cctki_use_psixz = kind(psixz)
      characTer*8, intent(IN) :: psiy
      integer, parameter :: cctki_use_psiy = kind(psiy)
      characTer*8, intent(IN) :: psiyy
      integer, parameter :: cctki_use_psiyy = kind(psiyy)
      characTer*8, intent(IN) :: psiyz
      integer, parameter :: cctki_use_psiyz = kind(psiyz)
      characTer*8, intent(IN) :: psiz
      integer, parameter :: cctki_use_psiz = kind(psiz)
      characTer*8, intent(IN) :: psizz
      integer, parameter :: cctki_use_psizz = kind(psizz)
      characTer*8, intent(IN) :: r
      integer, parameter :: cctki_use_r = kind(r)
      characTer*8, intent(IN) :: shift_state
      integer, parameter :: cctki_use_shift_state = kind(shift_state)

c

      integer i, j, k, l, m, n, p, q
      integer nx,ny,nz
      integer ierr

      REAL*8 s1d(4,3), nd(4), nu(4), norm, gd(4,4), gu(4,4), g3(3,3),
     $   gd_p(4,4), gd_m(4,4), gd1d(4,4,4), s2d(4,3,3), k3(3,3), 
     $   ex_eps, dx, dy, dz, exact_psi
      parameter (ex_eps=1.d-6)

C     Grid parameters.

      nx = cctk_lsh(1)
      ny = cctk_lsh(2)
      nz = cctk_lsh(3)

      dx = (cctk_delta_space(1)/cctk_levfac(1))
      dy = (cctk_delta_space(2)/cctk_levfac(2))
      dz = (cctk_delta_space(3)/cctk_levfac(3))

C     Sum over interior points on the slice.

      do k=2,nz-1
         do j=2,ny-1
            do i=2,nx-1

C     Calculate first derivatives of slice coordinates.

               s1d(1,1) = 0.5d0 * (slicex(i+1,j,k) - slicex(i-1,j,k))/dx
     &
               s1d(1,2) = 0.5d0 * (slicex(i,j+1,k) - slicex(i,j-1,k))/dy
     &
               s1d(1,3) = 0.5d0 * (slicex(i,j,k+1) - slicex(i,j,k-1))/dz
     &

               s1d(2,1) = 0.5d0 * (slicey(i+1,j,k) - slicey(i-1,j,k))/dx
     &
               s1d(2,2) = 0.5d0 * (slicey(i,j+1,k) - slicey(i,j-1,k))/dy
     &
               s1d(2,3) = 0.5d0 * (slicey(i,j,k+1) - slicey(i,j,k-1))/dz
     &

               s1d(3,1) = 0.5d0 * (slicez(i+1,j,k) - slicez(i-1,j,k))/dx
     &
               s1d(3,2) = 0.5d0 * (slicez(i,j+1,k) - slicez(i,j-1,k))/dy
     &
               s1d(3,3) = 0.5d0 * (slicez(i,j,k+1) - slicez(i,j,k-1))/dz
     &

               s1d(4,1) = 0.5d0 * (slicet(i+1,j,k) - slicet(i-1,j,k))/dx
     &
               s1d(4,2) = 0.5d0 * (slicet(i,j+1,k) - slicet(i,j-1,k))/dy
     &
               s1d(4,3) = 0.5d0 * (slicet(i,j,k+1) - slicet(i,j,k-1))/dz
     &

C     Preset the conformal factor
               if (conformal_state .ne. 0) then
                 exact_psi=1.0d0
               else
                 exact_psi=0.0d0
               end if
               
C     Now we need the exact solution metric in the preferred coordinates x^A.

               call Exact__metric(
     $              decoded_exact_model,
     $              slicex(i,j,k), slicey(i,j,k), slicez(i,j,k), 
     $              slicet(i,j,k),
     $              gd(4,4), gd(1,4), gd(2,4), gd(3,4),
     $              gd(1,1), gd(2,2), gd(3,3), gd(1,2), gd(2,3), gd(1,3)
     &,
     $              gu(4,4), gu(1,4), gu(2,4), gu(3,4),
     $              gu(1,1), gu(2,2), gu(3,3), gu(1,2), gu(2,3), gu(1,3)
     &,
     $              exact_psi)

C     Calculate n^A and dx^A/dt


C slice_normal.inc -- common code for computing n^A and dx^A/dt,
C                     used in ../slice_data.F and ../slice_evolve.F
C $Header$

C     Fill in remaining components of metric.
      do m=1,4
         do n=1,m-1
            gu(m,n) = gu(n,m)
            gd(m,n) = gd(n,m)
         end do
      end do

C     Calculate normal vector with respect to the slice, with indices down,
C     and not yet normalized.
C     n_A = epsilon_ABCD X^A_,1 X^B_,2 X^C_,3.
C     Easiest to hardwired this with an editor.
               nd(1) = s1d(2,1)*s1d(3,2)*s1d(4,3)
     $              + s1d(3,1)*s1d(4,2)*s1d(2,3)
     $              + s1d(4,1)*s1d(2,2)*s1d(3,3)
     $              - s1d(2,1)*s1d(4,2)*s1d(3,3)
     $              - s1d(4,1)*s1d(3,2)*s1d(2,3)
     $              - s1d(3,1)*s1d(2,2)*s1d(4,3)

               nd(2) = - s1d(3,1)*s1d(4,2)*s1d(1,3)
     $              - s1d(4,1)*s1d(1,2)*s1d(3,3)
     $              -s1d(1,1)*s1d(3,2)*s1d(4,3)
     $              + s1d(3,1)*s1d(1,2)*s1d(4,3)
     $              + s1d(1,1)*s1d(4,2)*s1d(3,3)
     $              + s1d(4,1)*s1d(3,2)*s1d(1,3)

               nd(3) = s1d(4,1)*s1d(1,2)*s1d(2,3)
     $              + s1d(1,1)*s1d(2,2)*s1d(4,3)
     $              + s1d(2,1)*s1d(4,2)*s1d(1,3)
     $              - s1d(4,1)*s1d(2,2)*s1d(1,3)
     $              - s1d(2,1)*s1d(1,2)*s1d(4,3)
     $              - s1d(1,1)*s1d(4,2)*s1d(2,3)

               nd(4) = s1d(1,1)*s1d(2,2)*s1d(3,3)
     $              + s1d(2,1)*s1d(3,2)*s1d(1,3)
     $              + s1d(3,1)*s1d(1,2)*s1d(2,3)
     $              - s1d(1,1)*s1d(3,2)*s1d(2,3)
     $              - s1d(3,1)*s1d(2,2)*s1d(1,3)
     $              - s1d(2,1)*s1d(1,2)*s1d(3,3)

C     Normalize normal vector and raise its index, both with the exact
C     solution metric.
C     - N^2 = g^AB n_A n_B).
               norm = 0.d0
               do m=1,4
                  do n=1,4
                     norm = norm + nd(m) * nd(n) * gu(m,n)
                  end do
               end do
C     Debugging test.
               if (norm .ge. 0.d0) then
                  write(6,*) 'slice normal no longer timelike'
                  write(6,*) 'grid point', i, j, k
                  write(6,*) 'x^i', x(i,j,k), y(i,j,k), z(i,j,k)
                  write(6,*) 'x^A', slicex(i,j,k), slicey(i,j,k), 
     $                 slicez(i,j,k), slicet(i,j,k)
                  write(6,*) 'n_A', nd(1), nd(2), nd(3), nd(4)
                  write(6,*) 'n_A n^A', norm
                  write(6,*)  'dx^A/dx^i'
                  do m=1,4
                     do n=1,3
                        write(6,*) m, n, s1d(m,n)
                     end do
                  end do
                  write(6,*)  'g^AB'
                  do m=1,4
                     do n=1,4
                        write(6,*) m, n, gu(m,n)
                     end do
                  end do
                  call CCTK_Warn(0,75,"slice_data.F","Exact", "aborting"
     &)
               end if
C     And now n^A = - 1/N g^AB n_B. (Sign so that it is future-pointing.)
               do m=1,4
                  nu(m) = 0.d0
                  do n=1,4
                     nu(m) = nu(m) + gu(m,n) * nd(n)
                  end do
                  nu(m) = - nu(m) / sqrt(-norm)
               end do

C     dX^A/dt = alpha n^A + beta^i X^A_,i. Store as a GF.
               slicetmp2x(i,j,k) = alp(i,j,k) * nu(1)
     $              + betax(i,j,k) * s1d(1,1)
     $              + betay(i,j,k) * s1d(1,2)
     $              + betaz(i,j,k) * s1d(1,3) 

               slicetmp2y(i,j,k) = alp(i,j,k) * nu(2)
     $              + betax(i,j,k) * s1d(2,1)
     $              + betay(i,j,k) * s1d(2,2)
     $              + betaz(i,j,k) * s1d(2,3) 

               slicetmp2z(i,j,k) = alp(i,j,k) * nu(3)
     $              + betax(i,j,k) * s1d(3,1)
     $              + betay(i,j,k) * s1d(3,2)
     $              + betaz(i,j,k) * s1d(3,3) 

               slicetmp2t(i,j,k) = alp(i,j,k) * nu(4)
     $              + betax(i,j,k) * s1d(4,1)
     $              + betay(i,j,k) * s1d(4,2)
     $              + betaz(i,j,k) * s1d(4,3) 



C     Calculate g_ij = X^A,i X^B,j g_AB, at first in a temp.

               g3 = 0.d0

               do p=1,3
                  do q=p,3
                     do m=1,4
                        do n=1,4
                           g3(p,q) = g3(p,q) 
     $                          + s1d(m,p) * s1d(n,q) * gd(m,n)
                        end do
                     end do
                  end do
               end do

               gxx(i,j,k) = g3(1,1)
               gxy(i,j,k) = g3(1,2)
               gxz(i,j,k) = g3(1,3)
               gyy(i,j,k) = g3(2,2)
               gyz(i,j,k) = g3(2,3)
               gzz(i,j,k) = g3(3,3)

C     Calculate x^A,ij. Do this by hand, and loop over first index 
C     with an editor (hint for proofreading).

               s2d(1,1,1) = (slicex(i+1,j,k) + slicex(i-1,j,k) 
     $              - 2.d0 * slicex(i,j,k)) / dx**2 
               s2d(1,2,2) = (slicex(i,j+1,k) + slicex(i,j-1,k) 
     $              - 2.d0 * slicex(i,j,k)) / dy**2 
               s2d(1,3,3) = (slicex(i,j,k+1) + slicex(i,j,k-1) 
     $              - 2.d0 * slicex(i,j,k)) / dz**2 
               s2d(1,1,2) = (slicex(i+1,j+1,k) - slicex(i-1,j+1,k)
     $              - slicex(i+1,j-1,k) + slicex(i-1,j-1,k)) / (4.*dx*dy
     &)
               s2d(1,1,3) = (slicex(i+1,j,k+1) - slicex(i-1,j,k+1)
     $              - slicex(i+1,j,k-1) + slicex(i-1,j,k-1)) / (4.*dy*dz
     &)
               s2d(1,2,3) = (slicex(i,j+1,k+1) - slicex(i,j-1,k+1)
     $              - slicex(i,j+1,k-1) + slicex(i,j-1,k-1)) / (4.*dx*dz
     &)
               s2d(1,2,1) = s2d(1,1,2)
               s2d(1,3,2) = s2d(1,2,3)
               s2d(1,3,1) = s2d(1,1,3)

               s2d(2,1,1) = (slicey(i+1,j,k) + slicey(i-1,j,k) 
     $              - 2.d0 * slicey(i,j,k)) / dx**2 
               s2d(2,2,2) = (slicey(i,j+1,k) + slicey(i,j-1,k) 
     $              - 2.d0 * slicey(i,j,k)) / dy**2 
               s2d(2,3,3) = (slicey(i,j,k+1) + slicey(i,j,k-1) 
     $              - 2.d0 * slicey(i,j,k)) / dz**2 
               s2d(2,1,2) = (slicey(i+1,j+1,k) - slicey(i-1,j+1,k)
     $              - slicey(i+1,j-1,k) + slicey(i-1,j-1,k)) / (4.*dx*dy
     &)
               s2d(2,1,3) = (slicey(i+1,j,k+1) - slicey(i-1,j,k+1)
     $              - slicey(i+1,j,k-1) + slicey(i-1,j,k-1)) / (4.*dy*dz
     &)
               s2d(2,2,3) = (slicey(i,j+1,k+1) - slicey(i,j-1,k+1)
     $              - slicey(i,j+1,k-1) + slicey(i,j-1,k-1)) / (4.*dx*dz
     &)
               s2d(2,2,1) = s2d(2,1,2)
               s2d(2,3,2) = s2d(2,2,3)
               s2d(2,3,1) = s2d(2,1,3)

               s2d(3,1,1) = (slicez(i+1,j,k) + slicez(i-1,j,k) 
     $              - 2.d0 * slicez(i,j,k)) / dx**2 
               s2d(3,2,2) = (slicez(i,j+1,k) + slicez(i,j-1,k) 
     $              - 2.d0 * slicez(i,j,k)) / dy**2 
               s2d(3,3,3) = (slicez(i,j,k+1) + slicez(i,j,k-1) 
     $              - 2.d0 * slicez(i,j,k)) / dz**2 
               s2d(3,1,2) = (slicez(i+1,j+1,k) - slicez(i-1,j+1,k)
     $              - slicez(i+1,j-1,k) + slicez(i-1,j-1,k)) / (4.*dx*dy
     &)
               s2d(3,1,3) = (slicez(i+1,j,k+1) - slicez(i-1,j,k+1)
     $              - slicez(i+1,j,k-1) + slicez(i-1,j,k-1)) / (4.*dy*dz
     &)
               s2d(3,2,3) = (slicez(i,j+1,k+1) - slicez(i,j-1,k+1)
     $              - slicez(i,j+1,k-1) + slicez(i,j-1,k-1)) / (4.*dx*dz
     &)
               s2d(3,2,1) = s2d(3,1,2)
               s2d(3,3,2) = s2d(3,2,3)
               s2d(3,3,1) = s2d(3,1,3)

               s2d(4,1,1) = (slicet(i+1,j,k) + slicet(i-1,j,k) 
     $              - 2.d0 * slicet(i,j,k)) / dx**2 
               s2d(4,2,2) = (slicet(i,j+1,k) + slicet(i,j-1,k) 
     $              - 2.d0 * slicet(i,j,k)) / dy**2 
               s2d(4,3,3) = (slicet(i,j,k+1) + slicet(i,j,k-1) 
     $              - 2.d0 * slicet(i,j,k)) / dz**2 
               s2d(4,1,2) = (slicet(i+1,j+1,k) - slicet(i-1,j+1,k)
     $              - slicet(i+1,j-1,k) + slicet(i-1,j-1,k)) / (4.*dx*dy
     &)
               s2d(4,1,3) = (slicet(i+1,j,k+1) - slicet(i-1,j,k+1)
     $              - slicet(i+1,j,k-1) + slicet(i-1,j,k-1)) / (4.*dy*dz
     &)
               s2d(4,2,3) = (slicet(i,j+1,k+1) - slicet(i,j-1,k+1)
     $              - slicet(i,j+1,k-1) + slicet(i,j-1,k-1)) / (4.*dx*dz
     &)
               s2d(4,2,1) = s2d(4,1,2)
               s2d(4,3,2) = s2d(4,2,3)
               s2d(4,3,1) = s2d(4,1,3)


C     Calculate g_AB,C. Need to sum explicitly over C. Do this with 
C     the editor.

C     Preset the conformal factor
               if (conformal_state .ne. 0) then
                 exact_psi=1.0d0
               else
                 exact_psi=0.0d0
               end if
               call Exact__metric(
     $              decoded_exact_model,
     $              slicex(i,j,k)+ex_eps, slicey(i,j,k), slicez(i,j,k), 
     &
     $              slicet(i,j,k),
     $              gd_p(4,4), gd_p(1,4), gd_p(2,4), gd_p(3,4),
     $              gd_p(1,1), gd_p(2,2), gd_p(3,3), 
     $              gd_p(1,2), gd_p(2,3), gd_p(1,3),
     $              gu(4,4), gu(1,4), gu(2,4), gu(3,4),
     $              gu(1,1), gu(2,2), gu(3,3), 
     $              gu(1,2), gu(2,3), gu(1,3), exact_psi)

C     Preset the conformal factor
               if (conformal_state .ne. 0) then
                 exact_psi=1.0d0
               else
                 exact_psi=0.0d0
               end if
               call Exact__metric(
     $              decoded_exact_model,
     $              slicex(i,j,k)-ex_eps, slicey(i,j,k), slicez(i,j,k), 
     &
     $              slicet(i,j,k),
     $              gd_m(4,4), gd_m(1,4), gd_m(2,4), gd_m(3,4),
     $              gd_m(1,1), gd_m(2,2), gd_m(3,3), 
     $              gd_m(1,2), gd_m(2,3), gd_m(1,3),
     $              gu(4,4), gu(1,4), gu(2,4), gu(3,4),
     $              gu(1,1), gu(2,2), gu(3,3), 
     $              gu(1,2), gu(2,3), gu(1,3), exact_psi)
               do m=1,4
                  do n=m,4
                     gd1d(m,n,1) = (gd_p(m,n) - gd_m(m,n)) / (2.*ex_eps)
     &
                  end do
               end do

C     Preset the conformal factor
               if (conformal_state .ne. 0) then
                 exact_psi=1.0d0
               else
                 exact_psi=0.0d0
               end if
               call Exact__metric(
     $              decoded_exact_model,
     $              slicex(i,j,k), slicey(i,j,k)+ex_eps, slicez(i,j,k), 
     &
     $              slicet(i,j,k),
     $              gd_p(4,4), gd_p(1,4), gd_p(2,4), gd_p(3,4),
     $              gd_p(1,1), gd_p(2,2), gd_p(3,3), 
     $              gd_p(1,2), gd_p(2,3), gd_p(1,3),
     $              gu(4,4), gu(1,4), gu(2,4), gu(3,4),
     $              gu(1,1), gu(2,2), gu(3,3), 
     $              gu(1,2), gu(2,3), gu(1,3), exact_psi)
               
C     Preset the conformal factor
               if (conformal_state .ne. 0) then
                 exact_psi=1.0d0
               else
                 exact_psi=0.0d0
               end if
               call Exact__metric(
     $              decoded_exact_model,
     $              slicex(i,j,k), slicey(i,j,k)-ex_eps, slicez(i,j,k), 
     &
     $              slicet(i,j,k),
     $              gd_m(4,4), gd_m(1,4), gd_m(2,4), gd_m(3,4),
     $              gd_m(1,1), gd_m(2,2), gd_m(3,3), 
     $              gd_m(1,2), gd_m(2,3), gd_m(1,3),
     $              gu(4,4), gu(1,4), gu(2,4), gu(3,4),
     $              gu(1,1), gu(2,2), gu(3,3), 
     $              gu(1,2), gu(2,3), gu(1,3), exact_psi)
               do m=1,4
                  do n=m,4
                     gd1d(m,n,2) = (gd_p(m,n) - gd_m(m,n)) / (2.*ex_eps)
     &
                  end do
               end do

               
C     Preset the conformal factor
               if (conformal_state .ne. 0) then
                 exact_psi=1.0d0
               else
                 exact_psi=0.0d0
               end if
               call Exact__metric(
     $              decoded_exact_model,
     $              slicex(i,j,k), slicey(i,j,k), slicez(i,j,k)+ex_eps, 
     &
     $              slicet(i,j,k),
     $              gd_p(4,4), gd_p(1,4), gd_p(2,4), gd_p(3,4),
     $              gd_p(1,1), gd_p(2,2), gd_p(3,3), 
     $              gd_p(1,2), gd_p(2,3), gd_p(1,3),
     $              gu(4,4), gu(1,4), gu(2,4), gu(3,4),
     $              gu(1,1), gu(2,2), gu(3,3), 
     $              gu(1,2), gu(2,3), gu(1,3), exact_psi)
               
C     Preset the conformal factor
               if (conformal_state .ne. 0) then
                 exact_psi=1.0d0
               else
                 exact_psi=0.0d0
               end if
               call Exact__metric(
     $              decoded_exact_model,
     $              slicex(i,j,k), slicey(i,j,k), slicez(i,j,k)-ex_eps, 
     &
     $              slicet(i,j,k),
     $              gd_m(4,4), gd_m(1,4), gd_m(2,4), gd_m(3,4),
     $              gd_m(1,1), gd_m(2,2), gd_m(3,3), 
     $              gd_m(1,2), gd_m(2,3), gd_m(1,3),
     $              gu(4,4), gu(1,4), gu(2,4), gu(3,4),
     $              gu(1,1), gu(2,2), gu(3,3), 
     $              gu(1,2), gu(2,3), gu(1,3), exact_psi)
               do m=1,4
                  do n=m,4
                     gd1d(m,n,3) = (gd_p(m,n) - gd_m(m,n)) / (2.*ex_eps)
     &
                  end do
               end do

               
C     Preset the conformal factor
               if (conformal_state .ne. 0) then
                 exact_psi=1.0d0
               else
                 exact_psi=0.0d0
               end if
               call Exact__metric(
     $              decoded_exact_model,
     $              slicex(i,j,k), slicey(i,j,k), slicez(i,j,k), 
     $              slicet(i,j,k)+ex_eps,
     $              gd_p(4,4), gd_p(1,4), gd_p(2,4), gd_p(3,4),
     $              gd_p(1,1), gd_p(2,2), gd_p(3,3), 
     $              gd_p(1,2), gd_p(2,3), gd_p(1,3),
     $              gu(4,4), gu(1,4), gu(2,4), gu(3,4),
     $              gu(1,1), gu(2,2), gu(3,3), 
     $              gu(1,2), gu(2,3), gu(1,3), exact_psi)
               
C     Preset the conformal factor
               if (conformal_state .ne. 0) then
                 exact_psi=1.0d0
               else
                 exact_psi=0.0d0
               end if
               call Exact__metric(
     $              decoded_exact_model,
     $              slicex(i,j,k), slicey(i,j,k), slicez(i,j,k), 
     $              slicet(i,j,k)-ex_eps,
     $              gd_m(4,4), gd_m(1,4), gd_m(2,4), gd_m(3,4),
     $              gd_m(1,1), gd_m(2,2), gd_m(3,3), 
     $              gd_m(1,2), gd_m(2,3), gd_m(1,3),
     $              gu(4,4), gu(1,4), gu(2,4), gu(3,4),
     $              gu(1,1), gu(2,2), gu(3,3), 
     $              gu(1,2), gu(2,3), gu(1,3), exact_psi)
               do m=1,4
                  do n=m,4
                     gd1d(m,n,4) = (gd_p(m,n) - gd_m(m,n)) / (2.*ex_eps)
     &
                  end do
               end do

C     Fill in remaining components of metric derivative.

               do l=1,4
                  do m=1,4
                     do n=1,m-1
                        gd1d(m,n,l) = gd1d(n,m,l)
                     end do
                  end do
               end do

C     Calculate K_ij.

               k3 = 0.d0
               do p=1,3
                  do q=p,3
                     do l=1,4
                        do m=1,4
                           k3(p,q) = k3(p,q) 
     $                          + s2d(l,p,q) * nu(m) * gd(l,m)
                           do n=1,4
                              k3(p,q) = k3(p,q) + 0.5d0 * (
     $                             s1d(l,p) * s1d(n,q) * nu(m)
     $                             + s1d(n,p) * s1d(m,q) * nu(l)
     $                             - s1d(l,p) * s1d(m,q) * nu(n) )
     $                             * gd1d(l,m,n)
                           end do
                        end do
                     end do
                  end do
               end do

               kxx(i,j,k) = - k3(1,1)
               kxy(i,j,k) = - k3(1,2)
               kxz(i,j,k) = - k3(1,3)
               kyy(i,j,k) = - k3(2,2)
               kyz(i,j,k) = - k3(2,3)
               kzz(i,j,k) = - k3(3,3)

            end do
         end do
      end do

C     Synchronize and bound slicetmp2, which contains dx^A/dt.

      call Exact__linear_extrap_one_bndry(cctk_dim,cctk_gsh,cctk_lsh,cct
     &k_lbnd,cctk_ubnd,cctk_tile_min,cctk_tile_max,cctk_ash,cctk_alignme
     &nt,cctk_alignment_offset,cctk_from,cctk_to,cctk_bbox,cctk_delta_ti
     &me,cctk_time,cctk_delta_space,cctk_origin_space,cctk_levfac,cctk_l
     &evoff,cctk_levoffdenom,cctk_timefac,cctk_convlevel,cctk_convfac,cc
     &tk_nghostzones,cctk_iteration,cctkGH,cctk_ash1,cctk_ash2,cctk_ash3
     &, slicet,slicetmp1t,slicetmp1x,slicetmp1y,slicetmp1z,slicetmp2t,sl
     &icetmp2x,slicetmp2y,slicetmp2z,slicex,slicey,slicez, Bertotti___La
     &mbda,Kasner_generalized___p1,Kasner_generalized___p2,Kasner_like__
     &_q,Lemaitre___Lambda,Lemaitre___R0,Lemaitre___epsilon0,Lemaitre___
     &kappa,Schwarzschild_Lemaitre___Lambda,Schwarzschild_Lemaitre___mas
     &s,anti_de_Sitter_Lambda___scale,constant_density_star___mass,const
     &ant_density_star___radius,de_Sitter_Lambda___scale,de_Sitter___sca
     &le,decoded_exact_model, active_slicing_handle,alp,alp_p,alp_p_p,be
     &tax,betax_p,betax_p_p,betay,betay_p,betay_p_p,betaz,betaz_p,betaz_
     &p_p,coarse_dx,coarse_dy,coarse_dz,conformal_state,dtalp,dtalp_p,dt
     &alp_p_p,dtbetax,dtbetax_p,dtbetax_p_p,dtbetay,dtbetay_p,dtbetay_p_
     &p,dtbetaz,dtbetaz_p,dtbetaz_p_p,dtlapse_state,dtshift_state,gxx,gx
     &x_p,gxx_p_p,gxy,gxy_p,gxy_p_p,gxz,gxz_p,gxz_p_p,gyy,gyy_p,gyy_p_p,
     &gyz,gyz_p,gyz_p_p,gzz,gzz_p,gzz_p_p,kxx,kxx_p,kxx_p_p,kxy,kxy_p,kx
     &y_p_p,kxz,kxz_p,kxz_p_p,kyy,kyy_p,kyy_p_p,kyz,kyz_p,kyz_p_p,kzz,kz
     &z_p,kzz_p_p,psi,psix,psixx,psixy,psixz,psiy,psiyy,psiyz,psiz,psizz
     &,r,shift_state,x,y,z,slicetmp2x)
      call Exact__linear_extrap_one_bndry(cctk_dim,cctk_gsh,cctk_lsh,cct
     &k_lbnd,cctk_ubnd,cctk_tile_min,cctk_tile_max,cctk_ash,cctk_alignme
     &nt,cctk_alignment_offset,cctk_from,cctk_to,cctk_bbox,cctk_delta_ti
     &me,cctk_time,cctk_delta_space,cctk_origin_space,cctk_levfac,cctk_l
     &evoff,cctk_levoffdenom,cctk_timefac,cctk_convlevel,cctk_convfac,cc
     &tk_nghostzones,cctk_iteration,cctkGH,cctk_ash1,cctk_ash2,cctk_ash3
     &, slicet,slicetmp1t,slicetmp1x,slicetmp1y,slicetmp1z,slicetmp2t,sl
     &icetmp2x,slicetmp2y,slicetmp2z,slicex,slicey,slicez, Bertotti___La
     &mbda,Kasner_generalized___p1,Kasner_generalized___p2,Kasner_like__
     &_q,Lemaitre___Lambda,Lemaitre___R0,Lemaitre___epsilon0,Lemaitre___
     &kappa,Schwarzschild_Lemaitre___Lambda,Schwarzschild_Lemaitre___mas
     &s,anti_de_Sitter_Lambda___scale,constant_density_star___mass,const
     &ant_density_star___radius,de_Sitter_Lambda___scale,de_Sitter___sca
     &le,decoded_exact_model, active_slicing_handle,alp,alp_p,alp_p_p,be
     &tax,betax_p,betax_p_p,betay,betay_p,betay_p_p,betaz,betaz_p,betaz_
     &p_p,coarse_dx,coarse_dy,coarse_dz,conformal_state,dtalp,dtalp_p,dt
     &alp_p_p,dtbetax,dtbetax_p,dtbetax_p_p,dtbetay,dtbetay_p,dtbetay_p_
     &p,dtbetaz,dtbetaz_p,dtbetaz_p_p,dtlapse_state,dtshift_state,gxx,gx
     &x_p,gxx_p_p,gxy,gxy_p,gxy_p_p,gxz,gxz_p,gxz_p_p,gyy,gyy_p,gyy_p_p,
     &gyz,gyz_p,gyz_p_p,gzz,gzz_p,gzz_p_p,kxx,kxx_p,kxx_p_p,kxy,kxy_p,kx
     &y_p_p,kxz,kxz_p,kxz_p_p,kyy,kyy_p,kyy_p_p,kyz,kyz_p,kyz_p_p,kzz,kz
     &z_p,kzz_p_p,psi,psix,psixx,psixy,psixz,psiy,psiyy,psiyz,psiz,psizz
     &,r,shift_state,x,y,z,slicetmp2y)
      call Exact__linear_extrap_one_bndry(cctk_dim,cctk_gsh,cctk_lsh,cct
     &k_lbnd,cctk_ubnd,cctk_tile_min,cctk_tile_max,cctk_ash,cctk_alignme
     &nt,cctk_alignment_offset,cctk_from,cctk_to,cctk_bbox,cctk_delta_ti
     &me,cctk_time,cctk_delta_space,cctk_origin_space,cctk_levfac,cctk_l
     &evoff,cctk_levoffdenom,cctk_timefac,cctk_convlevel,cctk_convfac,cc
     &tk_nghostzones,cctk_iteration,cctkGH,cctk_ash1,cctk_ash2,cctk_ash3
     &, slicet,slicetmp1t,slicetmp1x,slicetmp1y,slicetmp1z,slicetmp2t,sl
     &icetmp2x,slicetmp2y,slicetmp2z,slicex,slicey,slicez, Bertotti___La
     &mbda,Kasner_generalized___p1,Kasner_generalized___p2,Kasner_like__
     &_q,Lemaitre___Lambda,Lemaitre___R0,Lemaitre___epsilon0,Lemaitre___
     &kappa,Schwarzschild_Lemaitre___Lambda,Schwarzschild_Lemaitre___mas
     &s,anti_de_Sitter_Lambda___scale,constant_density_star___mass,const
     &ant_density_star___radius,de_Sitter_Lambda___scale,de_Sitter___sca
     &le,decoded_exact_model, active_slicing_handle,alp,alp_p,alp_p_p,be
     &tax,betax_p,betax_p_p,betay,betay_p,betay_p_p,betaz,betaz_p,betaz_
     &p_p,coarse_dx,coarse_dy,coarse_dz,conformal_state,dtalp,dtalp_p,dt
     &alp_p_p,dtbetax,dtbetax_p,dtbetax_p_p,dtbetay,dtbetay_p,dtbetay_p_
     &p,dtbetaz,dtbetaz_p,dtbetaz_p_p,dtlapse_state,dtshift_state,gxx,gx
     &x_p,gxx_p_p,gxy,gxy_p,gxy_p_p,gxz,gxz_p,gxz_p_p,gyy,gyy_p,gyy_p_p,
     &gyz,gyz_p,gyz_p_p,gzz,gzz_p,gzz_p_p,kxx,kxx_p,kxx_p_p,kxy,kxy_p,kx
     &y_p_p,kxz,kxz_p,kxz_p_p,kyy,kyy_p,kyy_p_p,kyz,kyz_p,kyz_p_p,kzz,kz
     &z_p,kzz_p_p,psi,psix,psixx,psixy,psixz,psiy,psiyy,psiyz,psiz,psizz
     &,r,shift_state,x,y,z,slicetmp2z)
      call Exact__linear_extrap_one_bndry(cctk_dim,cctk_gsh,cctk_lsh,cct
     &k_lbnd,cctk_ubnd,cctk_tile_min,cctk_tile_max,cctk_ash,cctk_alignme
     &nt,cctk_alignment_offset,cctk_from,cctk_to,cctk_bbox,cctk_delta_ti
     &me,cctk_time,cctk_delta_space,cctk_origin_space,cctk_levfac,cctk_l
     &evoff,cctk_levoffdenom,cctk_timefac,cctk_convlevel,cctk_convfac,cc
     &tk_nghostzones,cctk_iteration,cctkGH,cctk_ash1,cctk_ash2,cctk_ash3
     &, slicet,slicetmp1t,slicetmp1x,slicetmp1y,slicetmp1z,slicetmp2t,sl
     &icetmp2x,slicetmp2y,slicetmp2z,slicex,slicey,slicez, Bertotti___La
     &mbda,Kasner_generalized___p1,Kasner_generalized___p2,Kasner_like__
     &_q,Lemaitre___Lambda,Lemaitre___R0,Lemaitre___epsilon0,Lemaitre___
     &kappa,Schwarzschild_Lemaitre___Lambda,Schwarzschild_Lemaitre___mas
     &s,anti_de_Sitter_Lambda___scale,constant_density_star___mass,const
     &ant_density_star___radius,de_Sitter_Lambda___scale,de_Sitter___sca
     &le,decoded_exact_model, active_slicing_handle,alp,alp_p,alp_p_p,be
     &tax,betax_p,betax_p_p,betay,betay_p,betay_p_p,betaz,betaz_p,betaz_
     &p_p,coarse_dx,coarse_dy,coarse_dz,conformal_state,dtalp,dtalp_p,dt
     &alp_p_p,dtbetax,dtbetax_p,dtbetax_p_p,dtbetay,dtbetay_p,dtbetay_p_
     &p,dtbetaz,dtbetaz_p,dtbetaz_p_p,dtlapse_state,dtshift_state,gxx,gx
     &x_p,gxx_p_p,gxy,gxy_p,gxy_p_p,gxz,gxz_p,gxz_p_p,gyy,gyy_p,gyy_p_p,
     &gyz,gyz_p,gyz_p_p,gzz,gzz_p,gzz_p_p,kxx,kxx_p,kxx_p_p,kxy,kxy_p,kx
     &y_p_p,kxz,kxz_p,kxz_p_p,kyy,kyy_p,kyy_p_p,kyz,kyz_p,kyz_p_p,kzz,kz
     &z_p,kzz_p_p,psi,psix,psixx,psixy,psixz,psiy,psiyy,psiyz,psiz,psizz
     &,r,shift_state,x,y,z,slicetmp2t)
 
      call CCTK_SyncGroup(ierr,cctkGH,"Exact::Exact_slicetemp2")

C     Bound and synchronize the 3-metric and extrinsic curvature.

      call Exact__linear_extrap_one_bndry(cctk_dim,cctk_gsh,cctk_lsh,cct
     &k_lbnd,cctk_ubnd,cctk_tile_min,cctk_tile_max,cctk_ash,cctk_alignme
     &nt,cctk_alignment_offset,cctk_from,cctk_to,cctk_bbox,cctk_delta_ti
     &me,cctk_time,cctk_delta_space,cctk_origin_space,cctk_levfac,cctk_l
     &evoff,cctk_levoffdenom,cctk_timefac,cctk_convlevel,cctk_convfac,cc
     &tk_nghostzones,cctk_iteration,cctkGH,cctk_ash1,cctk_ash2,cctk_ash3
     &, slicet,slicetmp1t,slicetmp1x,slicetmp1y,slicetmp1z,slicetmp2t,sl
     &icetmp2x,slicetmp2y,slicetmp2z,slicex,slicey,slicez, Bertotti___La
     &mbda,Kasner_generalized___p1,Kasner_generalized___p2,Kasner_like__
     &_q,Lemaitre___Lambda,Lemaitre___R0,Lemaitre___epsilon0,Lemaitre___
     &kappa,Schwarzschild_Lemaitre___Lambda,Schwarzschild_Lemaitre___mas
     &s,anti_de_Sitter_Lambda___scale,constant_density_star___mass,const
     &ant_density_star___radius,de_Sitter_Lambda___scale,de_Sitter___sca
     &le,decoded_exact_model, active_slicing_handle,alp,alp_p,alp_p_p,be
     &tax,betax_p,betax_p_p,betay,betay_p,betay_p_p,betaz,betaz_p,betaz_
     &p_p,coarse_dx,coarse_dy,coarse_dz,conformal_state,dtalp,dtalp_p,dt
     &alp_p_p,dtbetax,dtbetax_p,dtbetax_p_p,dtbetay,dtbetay_p,dtbetay_p_
     &p,dtbetaz,dtbetaz_p,dtbetaz_p_p,dtlapse_state,dtshift_state,gxx,gx
     &x_p,gxx_p_p,gxy,gxy_p,gxy_p_p,gxz,gxz_p,gxz_p_p,gyy,gyy_p,gyy_p_p,
     &gyz,gyz_p,gyz_p_p,gzz,gzz_p,gzz_p_p,kxx,kxx_p,kxx_p_p,kxy,kxy_p,kx
     &y_p_p,kxz,kxz_p,kxz_p_p,kyy,kyy_p,kyy_p_p,kyz,kyz_p,kyz_p_p,kzz,kz
     &z_p,kzz_p_p,psi,psix,psixx,psixy,psixz,psiy,psiyy,psiyz,psiz,psizz
     &,r,shift_state,x,y,z,gxx)
      call Exact__linear_extrap_one_bndry(cctk_dim,cctk_gsh,cctk_lsh,cct
     &k_lbnd,cctk_ubnd,cctk_tile_min,cctk_tile_max,cctk_ash,cctk_alignme
     &nt,cctk_alignment_offset,cctk_from,cctk_to,cctk_bbox,cctk_delta_ti
     &me,cctk_time,cctk_delta_space,cctk_origin_space,cctk_levfac,cctk_l
     &evoff,cctk_levoffdenom,cctk_timefac,cctk_convlevel,cctk_convfac,cc
     &tk_nghostzones,cctk_iteration,cctkGH,cctk_ash1,cctk_ash2,cctk_ash3
     &, slicet,slicetmp1t,slicetmp1x,slicetmp1y,slicetmp1z,slicetmp2t,sl
     &icetmp2x,slicetmp2y,slicetmp2z,slicex,slicey,slicez, Bertotti___La
     &mbda,Kasner_generalized___p1,Kasner_generalized___p2,Kasner_like__
     &_q,Lemaitre___Lambda,Lemaitre___R0,Lemaitre___epsilon0,Lemaitre___
     &kappa,Schwarzschild_Lemaitre___Lambda,Schwarzschild_Lemaitre___mas
     &s,anti_de_Sitter_Lambda___scale,constant_density_star___mass,const
     &ant_density_star___radius,de_Sitter_Lambda___scale,de_Sitter___sca
     &le,decoded_exact_model, active_slicing_handle,alp,alp_p,alp_p_p,be
     &tax,betax_p,betax_p_p,betay,betay_p,betay_p_p,betaz,betaz_p,betaz_
     &p_p,coarse_dx,coarse_dy,coarse_dz,conformal_state,dtalp,dtalp_p,dt
     &alp_p_p,dtbetax,dtbetax_p,dtbetax_p_p,dtbetay,dtbetay_p,dtbetay_p_
     &p,dtbetaz,dtbetaz_p,dtbetaz_p_p,dtlapse_state,dtshift_state,gxx,gx
     &x_p,gxx_p_p,gxy,gxy_p,gxy_p_p,gxz,gxz_p,gxz_p_p,gyy,gyy_p,gyy_p_p,
     &gyz,gyz_p,gyz_p_p,gzz,gzz_p,gzz_p_p,kxx,kxx_p,kxx_p_p,kxy,kxy_p,kx
     &y_p_p,kxz,kxz_p,kxz_p_p,kyy,kyy_p,kyy_p_p,kyz,kyz_p,kyz_p_p,kzz,kz
     &z_p,kzz_p_p,psi,psix,psixx,psixy,psixz,psiy,psiyy,psiyz,psiz,psizz
     &,r,shift_state,x,y,z,gxy)
      call Exact__linear_extrap_one_bndry(cctk_dim,cctk_gsh,cctk_lsh,cct
     &k_lbnd,cctk_ubnd,cctk_tile_min,cctk_tile_max,cctk_ash,cctk_alignme
     &nt,cctk_alignment_offset,cctk_from,cctk_to,cctk_bbox,cctk_delta_ti
     &me,cctk_time,cctk_delta_space,cctk_origin_space,cctk_levfac,cctk_l
     &evoff,cctk_levoffdenom,cctk_timefac,cctk_convlevel,cctk_convfac,cc
     &tk_nghostzones,cctk_iteration,cctkGH,cctk_ash1,cctk_ash2,cctk_ash3
     &, slicet,slicetmp1t,slicetmp1x,slicetmp1y,slicetmp1z,slicetmp2t,sl
     &icetmp2x,slicetmp2y,slicetmp2z,slicex,slicey,slicez, Bertotti___La
     &mbda,Kasner_generalized___p1,Kasner_generalized___p2,Kasner_like__
     &_q,Lemaitre___Lambda,Lemaitre___R0,Lemaitre___epsilon0,Lemaitre___
     &kappa,Schwarzschild_Lemaitre___Lambda,Schwarzschild_Lemaitre___mas
     &s,anti_de_Sitter_Lambda___scale,constant_density_star___mass,const
     &ant_density_star___radius,de_Sitter_Lambda___scale,de_Sitter___sca
     &le,decoded_exact_model, active_slicing_handle,alp,alp_p,alp_p_p,be
     &tax,betax_p,betax_p_p,betay,betay_p,betay_p_p,betaz,betaz_p,betaz_
     &p_p,coarse_dx,coarse_dy,coarse_dz,conformal_state,dtalp,dtalp_p,dt
     &alp_p_p,dtbetax,dtbetax_p,dtbetax_p_p,dtbetay,dtbetay_p,dtbetay_p_
     &p,dtbetaz,dtbetaz_p,dtbetaz_p_p,dtlapse_state,dtshift_state,gxx,gx
     &x_p,gxx_p_p,gxy,gxy_p,gxy_p_p,gxz,gxz_p,gxz_p_p,gyy,gyy_p,gyy_p_p,
     &gyz,gyz_p,gyz_p_p,gzz,gzz_p,gzz_p_p,kxx,kxx_p,kxx_p_p,kxy,kxy_p,kx
     &y_p_p,kxz,kxz_p,kxz_p_p,kyy,kyy_p,kyy_p_p,kyz,kyz_p,kyz_p_p,kzz,kz
     &z_p,kzz_p_p,psi,psix,psixx,psixy,psixz,psiy,psiyy,psiyz,psiz,psizz
     &,r,shift_state,x,y,z,gxz)
      call Exact__linear_extrap_one_bndry(cctk_dim,cctk_gsh,cctk_lsh,cct
     &k_lbnd,cctk_ubnd,cctk_tile_min,cctk_tile_max,cctk_ash,cctk_alignme
     &nt,cctk_alignment_offset,cctk_from,cctk_to,cctk_bbox,cctk_delta_ti
     &me,cctk_time,cctk_delta_space,cctk_origin_space,cctk_levfac,cctk_l
     &evoff,cctk_levoffdenom,cctk_timefac,cctk_convlevel,cctk_convfac,cc
     &tk_nghostzones,cctk_iteration,cctkGH,cctk_ash1,cctk_ash2,cctk_ash3
     &, slicet,slicetmp1t,slicetmp1x,slicetmp1y,slicetmp1z,slicetmp2t,sl
     &icetmp2x,slicetmp2y,slicetmp2z,slicex,slicey,slicez, Bertotti___La
     &mbda,Kasner_generalized___p1,Kasner_generalized___p2,Kasner_like__
     &_q,Lemaitre___Lambda,Lemaitre___R0,Lemaitre___epsilon0,Lemaitre___
     &kappa,Schwarzschild_Lemaitre___Lambda,Schwarzschild_Lemaitre___mas
     &s,anti_de_Sitter_Lambda___scale,constant_density_star___mass,const
     &ant_density_star___radius,de_Sitter_Lambda___scale,de_Sitter___sca
     &le,decoded_exact_model, active_slicing_handle,alp,alp_p,alp_p_p,be
     &tax,betax_p,betax_p_p,betay,betay_p,betay_p_p,betaz,betaz_p,betaz_
     &p_p,coarse_dx,coarse_dy,coarse_dz,conformal_state,dtalp,dtalp_p,dt
     &alp_p_p,dtbetax,dtbetax_p,dtbetax_p_p,dtbetay,dtbetay_p,dtbetay_p_
     &p,dtbetaz,dtbetaz_p,dtbetaz_p_p,dtlapse_state,dtshift_state,gxx,gx
     &x_p,gxx_p_p,gxy,gxy_p,gxy_p_p,gxz,gxz_p,gxz_p_p,gyy,gyy_p,gyy_p_p,
     &gyz,gyz_p,gyz_p_p,gzz,gzz_p,gzz_p_p,kxx,kxx_p,kxx_p_p,kxy,kxy_p,kx
     &y_p_p,kxz,kxz_p,kxz_p_p,kyy,kyy_p,kyy_p_p,kyz,kyz_p,kyz_p_p,kzz,kz
     &z_p,kzz_p_p,psi,psix,psixx,psixy,psixz,psiy,psiyy,psiyz,psiz,psizz
     &,r,shift_state,x,y,z,gyy)
      call Exact__linear_extrap_one_bndry(cctk_dim,cctk_gsh,cctk_lsh,cct
     &k_lbnd,cctk_ubnd,cctk_tile_min,cctk_tile_max,cctk_ash,cctk_alignme
     &nt,cctk_alignment_offset,cctk_from,cctk_to,cctk_bbox,cctk_delta_ti
     &me,cctk_time,cctk_delta_space,cctk_origin_space,cctk_levfac,cctk_l
     &evoff,cctk_levoffdenom,cctk_timefac,cctk_convlevel,cctk_convfac,cc
     &tk_nghostzones,cctk_iteration,cctkGH,cctk_ash1,cctk_ash2,cctk_ash3
     &, slicet,slicetmp1t,slicetmp1x,slicetmp1y,slicetmp1z,slicetmp2t,sl
     &icetmp2x,slicetmp2y,slicetmp2z,slicex,slicey,slicez, Bertotti___La
     &mbda,Kasner_generalized___p1,Kasner_generalized___p2,Kasner_like__
     &_q,Lemaitre___Lambda,Lemaitre___R0,Lemaitre___epsilon0,Lemaitre___
     &kappa,Schwarzschild_Lemaitre___Lambda,Schwarzschild_Lemaitre___mas
     &s,anti_de_Sitter_Lambda___scale,constant_density_star___mass,const
     &ant_density_star___radius,de_Sitter_Lambda___scale,de_Sitter___sca
     &le,decoded_exact_model, active_slicing_handle,alp,alp_p,alp_p_p,be
     &tax,betax_p,betax_p_p,betay,betay_p,betay_p_p,betaz,betaz_p,betaz_
     &p_p,coarse_dx,coarse_dy,coarse_dz,conformal_state,dtalp,dtalp_p,dt
     &alp_p_p,dtbetax,dtbetax_p,dtbetax_p_p,dtbetay,dtbetay_p,dtbetay_p_
     &p,dtbetaz,dtbetaz_p,dtbetaz_p_p,dtlapse_state,dtshift_state,gxx,gx
     &x_p,gxx_p_p,gxy,gxy_p,gxy_p_p,gxz,gxz_p,gxz_p_p,gyy,gyy_p,gyy_p_p,
     &gyz,gyz_p,gyz_p_p,gzz,gzz_p,gzz_p_p,kxx,kxx_p,kxx_p_p,kxy,kxy_p,kx
     &y_p_p,kxz,kxz_p,kxz_p_p,kyy,kyy_p,kyy_p_p,kyz,kyz_p,kyz_p_p,kzz,kz
     &z_p,kzz_p_p,psi,psix,psixx,psixy,psixz,psiy,psiyy,psiyz,psiz,psizz
     &,r,shift_state,x,y,z,gyz)
      call Exact__linear_extrap_one_bndry(cctk_dim,cctk_gsh,cctk_lsh,cct
     &k_lbnd,cctk_ubnd,cctk_tile_min,cctk_tile_max,cctk_ash,cctk_alignme
     &nt,cctk_alignment_offset,cctk_from,cctk_to,cctk_bbox,cctk_delta_ti
     &me,cctk_time,cctk_delta_space,cctk_origin_space,cctk_levfac,cctk_l
     &evoff,cctk_levoffdenom,cctk_timefac,cctk_convlevel,cctk_convfac,cc
     &tk_nghostzones,cctk_iteration,cctkGH,cctk_ash1,cctk_ash2,cctk_ash3
     &, slicet,slicetmp1t,slicetmp1x,slicetmp1y,slicetmp1z,slicetmp2t,sl
     &icetmp2x,slicetmp2y,slicetmp2z,slicex,slicey,slicez, Bertotti___La
     &mbda,Kasner_generalized___p1,Kasner_generalized___p2,Kasner_like__
     &_q,Lemaitre___Lambda,Lemaitre___R0,Lemaitre___epsilon0,Lemaitre___
     &kappa,Schwarzschild_Lemaitre___Lambda,Schwarzschild_Lemaitre___mas
     &s,anti_de_Sitter_Lambda___scale,constant_density_star___mass,const
     &ant_density_star___radius,de_Sitter_Lambda___scale,de_Sitter___sca
     &le,decoded_exact_model, active_slicing_handle,alp,alp_p,alp_p_p,be
     &tax,betax_p,betax_p_p,betay,betay_p,betay_p_p,betaz,betaz_p,betaz_
     &p_p,coarse_dx,coarse_dy,coarse_dz,conformal_state,dtalp,dtalp_p,dt
     &alp_p_p,dtbetax,dtbetax_p,dtbetax_p_p,dtbetay,dtbetay_p,dtbetay_p_
     &p,dtbetaz,dtbetaz_p,dtbetaz_p_p,dtlapse_state,dtshift_state,gxx,gx
     &x_p,gxx_p_p,gxy,gxy_p,gxy_p_p,gxz,gxz_p,gxz_p_p,gyy,gyy_p,gyy_p_p,
     &gyz,gyz_p,gyz_p_p,gzz,gzz_p,gzz_p_p,kxx,kxx_p,kxx_p_p,kxy,kxy_p,kx
     &y_p_p,kxz,kxz_p,kxz_p_p,kyy,kyy_p,kyy_p_p,kyz,kyz_p,kyz_p_p,kzz,kz
     &z_p,kzz_p_p,psi,psix,psixx,psixy,psixz,psiy,psiyy,psiyz,psiz,psizz
     &,r,shift_state,x,y,z,gzz)

      call CCTK_SyncGroup(ierr,cctkGH,"admbase::metric")

      call Exact__linear_extrap_one_bndry(cctk_dim,cctk_gsh,cctk_lsh,cct
     &k_lbnd,cctk_ubnd,cctk_tile_min,cctk_tile_max,cctk_ash,cctk_alignme
     &nt,cctk_alignment_offset,cctk_from,cctk_to,cctk_bbox,cctk_delta_ti
     &me,cctk_time,cctk_delta_space,cctk_origin_space,cctk_levfac,cctk_l
     &evoff,cctk_levoffdenom,cctk_timefac,cctk_convlevel,cctk_convfac,cc
     &tk_nghostzones,cctk_iteration,cctkGH,cctk_ash1,cctk_ash2,cctk_ash3
     &, slicet,slicetmp1t,slicetmp1x,slicetmp1y,slicetmp1z,slicetmp2t,sl
     &icetmp2x,slicetmp2y,slicetmp2z,slicex,slicey,slicez, Bertotti___La
     &mbda,Kasner_generalized___p1,Kasner_generalized___p2,Kasner_like__
     &_q,Lemaitre___Lambda,Lemaitre___R0,Lemaitre___epsilon0,Lemaitre___
     &kappa,Schwarzschild_Lemaitre___Lambda,Schwarzschild_Lemaitre___mas
     &s,anti_de_Sitter_Lambda___scale,constant_density_star___mass,const
     &ant_density_star___radius,de_Sitter_Lambda___scale,de_Sitter___sca
     &le,decoded_exact_model, active_slicing_handle,alp,alp_p,alp_p_p,be
     &tax,betax_p,betax_p_p,betay,betay_p,betay_p_p,betaz,betaz_p,betaz_
     &p_p,coarse_dx,coarse_dy,coarse_dz,conformal_state,dtalp,dtalp_p,dt
     &alp_p_p,dtbetax,dtbetax_p,dtbetax_p_p,dtbetay,dtbetay_p,dtbetay_p_
     &p,dtbetaz,dtbetaz_p,dtbetaz_p_p,dtlapse_state,dtshift_state,gxx,gx
     &x_p,gxx_p_p,gxy,gxy_p,gxy_p_p,gxz,gxz_p,gxz_p_p,gyy,gyy_p,gyy_p_p,
     &gyz,gyz_p,gyz_p_p,gzz,gzz_p,gzz_p_p,kxx,kxx_p,kxx_p_p,kxy,kxy_p,kx
     &y_p_p,kxz,kxz_p,kxz_p_p,kyy,kyy_p,kyy_p_p,kyz,kyz_p,kyz_p_p,kzz,kz
     &z_p,kzz_p_p,psi,psix,psixx,psixy,psixz,psiy,psiyy,psiyz,psiz,psizz
     &,r,shift_state,x,y,z,kxx)
      call Exact__linear_extrap_one_bndry(cctk_dim,cctk_gsh,cctk_lsh,cct
     &k_lbnd,cctk_ubnd,cctk_tile_min,cctk_tile_max,cctk_ash,cctk_alignme
     &nt,cctk_alignment_offset,cctk_from,cctk_to,cctk_bbox,cctk_delta_ti
     &me,cctk_time,cctk_delta_space,cctk_origin_space,cctk_levfac,cctk_l
     &evoff,cctk_levoffdenom,cctk_timefac,cctk_convlevel,cctk_convfac,cc
     &tk_nghostzones,cctk_iteration,cctkGH,cctk_ash1,cctk_ash2,cctk_ash3
     &, slicet,slicetmp1t,slicetmp1x,slicetmp1y,slicetmp1z,slicetmp2t,sl
     &icetmp2x,slicetmp2y,slicetmp2z,slicex,slicey,slicez, Bertotti___La
     &mbda,Kasner_generalized___p1,Kasner_generalized___p2,Kasner_like__
     &_q,Lemaitre___Lambda,Lemaitre___R0,Lemaitre___epsilon0,Lemaitre___
     &kappa,Schwarzschild_Lemaitre___Lambda,Schwarzschild_Lemaitre___mas
     &s,anti_de_Sitter_Lambda___scale,constant_density_star___mass,const
     &ant_density_star___radius,de_Sitter_Lambda___scale,de_Sitter___sca
     &le,decoded_exact_model, active_slicing_handle,alp,alp_p,alp_p_p,be
     &tax,betax_p,betax_p_p,betay,betay_p,betay_p_p,betaz,betaz_p,betaz_
     &p_p,coarse_dx,coarse_dy,coarse_dz,conformal_state,dtalp,dtalp_p,dt
     &alp_p_p,dtbetax,dtbetax_p,dtbetax_p_p,dtbetay,dtbetay_p,dtbetay_p_
     &p,dtbetaz,dtbetaz_p,dtbetaz_p_p,dtlapse_state,dtshift_state,gxx,gx
     &x_p,gxx_p_p,gxy,gxy_p,gxy_p_p,gxz,gxz_p,gxz_p_p,gyy,gyy_p,gyy_p_p,
     &gyz,gyz_p,gyz_p_p,gzz,gzz_p,gzz_p_p,kxx,kxx_p,kxx_p_p,kxy,kxy_p,kx
     &y_p_p,kxz,kxz_p,kxz_p_p,kyy,kyy_p,kyy_p_p,kyz,kyz_p,kyz_p_p,kzz,kz
     &z_p,kzz_p_p,psi,psix,psixx,psixy,psixz,psiy,psiyy,psiyz,psiz,psizz
     &,r,shift_state,x,y,z,kxy)
      call Exact__linear_extrap_one_bndry(cctk_dim,cctk_gsh,cctk_lsh,cct
     &k_lbnd,cctk_ubnd,cctk_tile_min,cctk_tile_max,cctk_ash,cctk_alignme
     &nt,cctk_alignment_offset,cctk_from,cctk_to,cctk_bbox,cctk_delta_ti
     &me,cctk_time,cctk_delta_space,cctk_origin_space,cctk_levfac,cctk_l
     &evoff,cctk_levoffdenom,cctk_timefac,cctk_convlevel,cctk_convfac,cc
     &tk_nghostzones,cctk_iteration,cctkGH,cctk_ash1,cctk_ash2,cctk_ash3
     &, slicet,slicetmp1t,slicetmp1x,slicetmp1y,slicetmp1z,slicetmp2t,sl
     &icetmp2x,slicetmp2y,slicetmp2z,slicex,slicey,slicez, Bertotti___La
     &mbda,Kasner_generalized___p1,Kasner_generalized___p2,Kasner_like__
     &_q,Lemaitre___Lambda,Lemaitre___R0,Lemaitre___epsilon0,Lemaitre___
     &kappa,Schwarzschild_Lemaitre___Lambda,Schwarzschild_Lemaitre___mas
     &s,anti_de_Sitter_Lambda___scale,constant_density_star___mass,const
     &ant_density_star___radius,de_Sitter_Lambda___scale,de_Sitter___sca
     &le,decoded_exact_model, active_slicing_handle,alp,alp_p,alp_p_p,be
     &tax,betax_p,betax_p_p,betay,betay_p,betay_p_p,betaz,betaz_p,betaz_
     &p_p,coarse_dx,coarse_dy,coarse_dz,conformal_state,dtalp,dtalp_p,dt
     &alp_p_p,dtbetax,dtbetax_p,dtbetax_p_p,dtbetay,dtbetay_p,dtbetay_p_
     &p,dtbetaz,dtbetaz_p,dtbetaz_p_p,dtlapse_state,dtshift_state,gxx,gx
     &x_p,gxx_p_p,gxy,gxy_p,gxy_p_p,gxz,gxz_p,gxz_p_p,gyy,gyy_p,gyy_p_p,
     &gyz,gyz_p,gyz_p_p,gzz,gzz_p,gzz_p_p,kxx,kxx_p,kxx_p_p,kxy,kxy_p,kx
     &y_p_p,kxz,kxz_p,kxz_p_p,kyy,kyy_p,kyy_p_p,kyz,kyz_p,kyz_p_p,kzz,kz
     &z_p,kzz_p_p,psi,psix,psixx,psixy,psixz,psiy,psiyy,psiyz,psiz,psizz
     &,r,shift_state,x,y,z,kxz)
      call Exact__linear_extrap_one_bndry(cctk_dim,cctk_gsh,cctk_lsh,cct
     &k_lbnd,cctk_ubnd,cctk_tile_min,cctk_tile_max,cctk_ash,cctk_alignme
     &nt,cctk_alignment_offset,cctk_from,cctk_to,cctk_bbox,cctk_delta_ti
     &me,cctk_time,cctk_delta_space,cctk_origin_space,cctk_levfac,cctk_l
     &evoff,cctk_levoffdenom,cctk_timefac,cctk_convlevel,cctk_convfac,cc
     &tk_nghostzones,cctk_iteration,cctkGH,cctk_ash1,cctk_ash2,cctk_ash3
     &, slicet,slicetmp1t,slicetmp1x,slicetmp1y,slicetmp1z,slicetmp2t,sl
     &icetmp2x,slicetmp2y,slicetmp2z,slicex,slicey,slicez, Bertotti___La
     &mbda,Kasner_generalized___p1,Kasner_generalized___p2,Kasner_like__
     &_q,Lemaitre___Lambda,Lemaitre___R0,Lemaitre___epsilon0,Lemaitre___
     &kappa,Schwarzschild_Lemaitre___Lambda,Schwarzschild_Lemaitre___mas
     &s,anti_de_Sitter_Lambda___scale,constant_density_star___mass,const
     &ant_density_star___radius,de_Sitter_Lambda___scale,de_Sitter___sca
     &le,decoded_exact_model, active_slicing_handle,alp,alp_p,alp_p_p,be
     &tax,betax_p,betax_p_p,betay,betay_p,betay_p_p,betaz,betaz_p,betaz_
     &p_p,coarse_dx,coarse_dy,coarse_dz,conformal_state,dtalp,dtalp_p,dt
     &alp_p_p,dtbetax,dtbetax_p,dtbetax_p_p,dtbetay,dtbetay_p,dtbetay_p_
     &p,dtbetaz,dtbetaz_p,dtbetaz_p_p,dtlapse_state,dtshift_state,gxx,gx
     &x_p,gxx_p_p,gxy,gxy_p,gxy_p_p,gxz,gxz_p,gxz_p_p,gyy,gyy_p,gyy_p_p,
     &gyz,gyz_p,gyz_p_p,gzz,gzz_p,gzz_p_p,kxx,kxx_p,kxx_p_p,kxy,kxy_p,kx
     &y_p_p,kxz,kxz_p,kxz_p_p,kyy,kyy_p,kyy_p_p,kyz,kyz_p,kyz_p_p,kzz,kz
     &z_p,kzz_p_p,psi,psix,psixx,psixy,psixz,psiy,psiyy,psiyz,psiz,psizz
     &,r,shift_state,x,y,z,kyy)
      call Exact__linear_extrap_one_bndry(cctk_dim,cctk_gsh,cctk_lsh,cct
     &k_lbnd,cctk_ubnd,cctk_tile_min,cctk_tile_max,cctk_ash,cctk_alignme
     &nt,cctk_alignment_offset,cctk_from,cctk_to,cctk_bbox,cctk_delta_ti
     &me,cctk_time,cctk_delta_space,cctk_origin_space,cctk_levfac,cctk_l
     &evoff,cctk_levoffdenom,cctk_timefac,cctk_convlevel,cctk_convfac,cc
     &tk_nghostzones,cctk_iteration,cctkGH,cctk_ash1,cctk_ash2,cctk_ash3
     &, slicet,slicetmp1t,slicetmp1x,slicetmp1y,slicetmp1z,slicetmp2t,sl
     &icetmp2x,slicetmp2y,slicetmp2z,slicex,slicey,slicez, Bertotti___La
     &mbda,Kasner_generalized___p1,Kasner_generalized___p2,Kasner_like__
     &_q,Lemaitre___Lambda,Lemaitre___R0,Lemaitre___epsilon0,Lemaitre___
     &kappa,Schwarzschild_Lemaitre___Lambda,Schwarzschild_Lemaitre___mas
     &s,anti_de_Sitter_Lambda___scale,constant_density_star___mass,const
     &ant_density_star___radius,de_Sitter_Lambda___scale,de_Sitter___sca
     &le,decoded_exact_model, active_slicing_handle,alp,alp_p,alp_p_p,be
     &tax,betax_p,betax_p_p,betay,betay_p,betay_p_p,betaz,betaz_p,betaz_
     &p_p,coarse_dx,coarse_dy,coarse_dz,conformal_state,dtalp,dtalp_p,dt
     &alp_p_p,dtbetax,dtbetax_p,dtbetax_p_p,dtbetay,dtbetay_p,dtbetay_p_
     &p,dtbetaz,dtbetaz_p,dtbetaz_p_p,dtlapse_state,dtshift_state,gxx,gx
     &x_p,gxx_p_p,gxy,gxy_p,gxy_p_p,gxz,gxz_p,gxz_p_p,gyy,gyy_p,gyy_p_p,
     &gyz,gyz_p,gyz_p_p,gzz,gzz_p,gzz_p_p,kxx,kxx_p,kxx_p_p,kxy,kxy_p,kx
     &y_p_p,kxz,kxz_p,kxz_p_p,kyy,kyy_p,kyy_p_p,kyz,kyz_p,kyz_p_p,kzz,kz
     &z_p,kzz_p_p,psi,psix,psixx,psixy,psixz,psiy,psiyy,psiyz,psiz,psizz
     &,r,shift_state,x,y,z,kyz)
      call Exact__linear_extrap_one_bndry(cctk_dim,cctk_gsh,cctk_lsh,cct
     &k_lbnd,cctk_ubnd,cctk_tile_min,cctk_tile_max,cctk_ash,cctk_alignme
     &nt,cctk_alignment_offset,cctk_from,cctk_to,cctk_bbox,cctk_delta_ti
     &me,cctk_time,cctk_delta_space,cctk_origin_space,cctk_levfac,cctk_l
     &evoff,cctk_levoffdenom,cctk_timefac,cctk_convlevel,cctk_convfac,cc
     &tk_nghostzones,cctk_iteration,cctkGH,cctk_ash1,cctk_ash2,cctk_ash3
     &, slicet,slicetmp1t,slicetmp1x,slicetmp1y,slicetmp1z,slicetmp2t,sl
     &icetmp2x,slicetmp2y,slicetmp2z,slicex,slicey,slicez, Bertotti___La
     &mbda,Kasner_generalized___p1,Kasner_generalized___p2,Kasner_like__
     &_q,Lemaitre___Lambda,Lemaitre___R0,Lemaitre___epsilon0,Lemaitre___
     &kappa,Schwarzschild_Lemaitre___Lambda,Schwarzschild_Lemaitre___mas
     &s,anti_de_Sitter_Lambda___scale,constant_density_star___mass,const
     &ant_density_star___radius,de_Sitter_Lambda___scale,de_Sitter___sca
     &le,decoded_exact_model, active_slicing_handle,alp,alp_p,alp_p_p,be
     &tax,betax_p,betax_p_p,betay,betay_p,betay_p_p,betaz,betaz_p,betaz_
     &p_p,coarse_dx,coarse_dy,coarse_dz,conformal_state,dtalp,dtalp_p,dt
     &alp_p_p,dtbetax,dtbetax_p,dtbetax_p_p,dtbetay,dtbetay_p,dtbetay_p_
     &p,dtbetaz,dtbetaz_p,dtbetaz_p_p,dtlapse_state,dtshift_state,gxx,gx
     &x_p,gxx_p_p,gxy,gxy_p,gxy_p_p,gxz,gxz_p,gxz_p_p,gyy,gyy_p,gyy_p_p,
     &gyz,gyz_p,gyz_p_p,gzz,gzz_p,gzz_p_p,kxx,kxx_p,kxx_p_p,kxy,kxy_p,kx
     &y_p_p,kxz,kxz_p,kxz_p_p,kyy,kyy_p,kyy_p_p,kyz,kyz_p,kyz_p_p,kzz,kz
     &z_p,kzz_p_p,psi,psix,psixx,psixy,psixz,psiy,psiyy,psiyz,psiz,psizz
     &,r,shift_state,x,y,z,kzz)

      call CCTK_SyncGroup(ierr,cctkGH,"admbase::curv")


      return
      end
