














































C $Header$




































































 


































































































































































 


















































































































































































































 



















































 










 








































































































































































































































 










                                
                                

                                
                                

                                
                                

                                



















































































      subroutine Exact__boundary(cctk_dim,cctk_gsh,cctk_lsh,cctk_lbnd,cc
     &tk_ubnd,cctk_tile_min,cctk_tile_max,cctk_ash,cctk_alignment,cctk_a
     &lignment_offset,cctk_from,cctk_to,cctk_bbox,cctk_delta_time,cctk_t
     &ime,cctk_delta_space,cctk_origin_space,cctk_levfac,cctk_levoff,cct
     &k_levoffdenom,cctk_timefac,cctk_convlevel,cctk_convfac,cctk_nghost
     &zones,cctk_iteration,cctkGH,cctk_ash1,cctk_ash2,cctk_ash3, slicet,
     &slicetmp1t,slicetmp1x,slicetmp1y,slicetmp1z,slicetmp2t,slicetmp2x,
     &slicetmp2y,slicetmp2z,slicex,slicey,slicez, Bertotti___Lambda,Kasn
     &er_generalized___p1,Kasner_generalized___p2,Kasner_like___q,Lemait
     &re___Lambda,Lemaitre___R0,Lemaitre___epsilon0,Lemaitre___kappa,Sch
     &warzschild_Lemaitre___Lambda,Schwarzschild_Lemaitre___mass,anti_de
     &_Sitter_Lambda___scale,constant_density_star___mass,constant_densi
     &ty_star___radius,de_Sitter_Lambda___scale,de_Sitter___scale,decode
     &d_exact_model, active_slicing_handle,alp,alp_p,alp_p_p,betax,betax
     &_p,betax_p_p,betay,betay_p,betay_p_p,betaz,betaz_p,betaz_p_p,coars
     &e_dx,coarse_dy,coarse_dz,conformal_state,dtalp,dtalp_p,dtalp_p_p,d
     &tbetax,dtbetax_p,dtbetax_p_p,dtbetay,dtbetay_p,dtbetay_p_p,dtbetaz
     &,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,kxz
     &,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,shift_
     &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 :: 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 :: dtalp (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_dtalp = kind(dtalp)
      REAL*8 :: dtbetax (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_dtbetax = kind(dtbetax)
      REAL*8 :: dtbetay (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_dtbetay = kind(dtbetay)
      REAL*8 :: dtbetaz (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_dtbetaz = kind(dtbetaz)
      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 :: betax (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_betax = kind(betax)
      REAL*8 :: betay (cctk_ash1,cctk_ash2,cctk_ash3)
      integer, parameter :: cctki_use_betay = kind(betay)
      REAL*8 :: 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) :: 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) :: slicet
      integer, parameter :: cctki_use_slicet = kind(slicet)
      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) :: slicetmp2t
      integer, parameter :: cctki_use_slicetmp2t = kind(slicetmp2t)
      characTer*8, intent(IN) :: slicetmp2x
      integer, parameter :: cctki_use_slicetmp2x = kind(slicetmp2x)
      characTer*8, intent(IN) :: slicetmp2y
      integer, parameter :: cctki_use_slicetmp2y = kind(slicetmp2y)
      characTer*8, intent(IN) :: slicetmp2z
      integer, parameter :: cctki_use_slicetmp2z = kind(slicetmp2z)
      characTer*8, intent(IN) :: slicex
      integer, parameter :: cctki_use_slicex = kind(slicex)
      characTer*8, intent(IN) :: slicey
      integer, parameter :: cctki_use_slicey = kind(slicey)
      characTer*8, intent(IN) :: slicez
      integer, parameter :: cctki_use_slicez = kind(slicez)
      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_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_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_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_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)

      integer i,j,k
      integer nx,ny,nz

      REAL*8 tplusone
      REAL*8 
     $     dxgxxjunk, dxgyyjunk, dxgzzjunk, 
     $     dxgxyjunk, dxgyzjunk, dxgxzjunk,
     $     dygxxjunk, dygyyjunk, dygzzjunk, 
     $     dygxyjunk, dygyzjunk, dygxzjunk,
     $     dzgxxjunk, dzgyyjunk, dzgzzjunk, 
     $     dzgxyjunk, dzgyzjunk, dzgxzjunk,
     $     axjunk, ayjunk, azjunk, 
     $     bxxjunk, bxyjunk, bxzjunk, 
     $     byxjunk, byyjunk, byzjunk, 
     $     bzxjunk, bzyjunk, bzzjunk
      REAL*8
     $     exact_psi,
     $     exact_psix, exact_psiy, exact_psiz,
     $     exact_psixx, exact_psiyy, exact_psizz,
     $     exact_psixy, exact_psiyz, exact_psixz

C     Grid parameters.

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

C     Initialize the psi of exact
C     (also to tell the models about the conformal_state)
                  if (conformal_state .ne. 0) then
                    exact_psi = 1.0D0
                  else
                    exact_psi = 0.0D0
                  end if
                  exact_psix = 0.0D0
                  exact_psiy = 0.0D0
                  exact_psiz = 0.0D0
                  exact_psixx = 0.0D0
                  exact_psiyy = 0.0D0
                  exact_psizz = 0.0D0
                  exact_psixy = 0.0D0
                  exact_psiyz = 0.0D0
                  exact_psixz = 0.0D0

C     Set all initial data including dijk and vi on all points which 
C     are on the boundary of the domain if it really is the boundary
C     of the complete grid. Treat all six sides of the grid cube this way.

c
c
c

      tplusone = cctk_time + cctk_delta_time

C     Note we also always set the lapse and shift at the boundaries at
C     time t+1. This is to provide boundary conditions for testing
C     elliptic gauge conditions. If they are not used, they will be
C     overwritten by Exact__gauge.


      if (cctk_bbox(1) .eq. 1) then 
         i=1
         do j=1,ny
            do k=1,nz
               call Exact__Bona_Masso_data(                             
     &                   decoded_exact_model,                           
     &                         x(i,j,k), y(i,j,k), z(i,j,k), tplusone,  
     &                               gxx(i,j,k), gyy(i,j,k), gzz(i,j,k),
     &                                     gxy(i,j,k), gyz(i,j,k), gxz(i
     &,j,k),                                     kxx(i,j,k), kyy(i,j,k),
     & kzz(i,j,k),                                     kxy(i,j,k), kyz(i
     &,j,k), kxz(i,j,k),                                     exact_psi, 
     &                                                             exact
     &_psix, exact_psiy, exact_psiz,                                    
     & exact_psixx, exact_psiyy, exact_psizz,                           
     &       exact_psixy, exact_psiyz, exact_psixz,                     
     &             dxgxxjunk, dxgyyjunk, dxgzzjunk,                     
     &                   dxgxyjunk, dxgyzjunk, dxgxzjunk,               
     &                         dygxxjunk, dygyyjunk, dygzzjunk,         
     &                               dygxyjunk, dygyzjunk, dygxzjunk,   
     &                                     dzgxxjunk, dzgyyjunk, dzgzzju
     &nk,                                        dzgxyjunk, dzgyzjunk, d
     &zgxzjunk,                                        alp(i,j,k), dtalp
     &(i,j,k),                                               axjunk, ayj
     &unk, azjunk,                                                 betax
     &(i,j,k), betay(i,j,k), betaz(i,j,k),                              
     & dtbetax(i,j,k), dtbetay(i,j,k), dtbetaz(i,j,k),                  
     &       bxxjunk, bxyjunk, bxzjunk,                                 
     &             byxjunk, byyjunk, byzjunk,                           
     &                   bzxjunk, bzyjunk, bzzjunk)
            end do
         end do
      end if

      if (cctk_bbox(2) .eq. 1) then 
         i=nx
         do j=1,ny
            do k=1,nz
               call Exact__Bona_Masso_data(                             
     &                   decoded_exact_model,                           
     &                         x(i,j,k), y(i,j,k), z(i,j,k), tplusone,  
     &                               gxx(i,j,k), gyy(i,j,k), gzz(i,j,k),
     &                                     gxy(i,j,k), gyz(i,j,k), gxz(i
     &,j,k),                                     kxx(i,j,k), kyy(i,j,k),
     & kzz(i,j,k),                                     kxy(i,j,k), kyz(i
     &,j,k), kxz(i,j,k),                                     exact_psi, 
     &                                                             exact
     &_psix, exact_psiy, exact_psiz,                                    
     & exact_psixx, exact_psiyy, exact_psizz,                           
     &       exact_psixy, exact_psiyz, exact_psixz,                     
     &             dxgxxjunk, dxgyyjunk, dxgzzjunk,                     
     &                   dxgxyjunk, dxgyzjunk, dxgxzjunk,               
     &                         dygxxjunk, dygyyjunk, dygzzjunk,         
     &                               dygxyjunk, dygyzjunk, dygxzjunk,   
     &                                     dzgxxjunk, dzgyyjunk, dzgzzju
     &nk,                                        dzgxyjunk, dzgyzjunk, d
     &zgxzjunk,                                        alp(i,j,k), dtalp
     &(i,j,k),                                               axjunk, ayj
     &unk, azjunk,                                                 betax
     &(i,j,k), betay(i,j,k), betaz(i,j,k),                              
     & dtbetax(i,j,k), dtbetay(i,j,k), dtbetaz(i,j,k),                  
     &       bxxjunk, bxyjunk, bxzjunk,                                 
     &             byxjunk, byyjunk, byzjunk,                           
     &                   bzxjunk, bzyjunk, bzzjunk)
            end do
         end do
      end if

      if (cctk_bbox(3) .eq. 1) then 
         j=1
         do i=1,nx
            do k=1,nz
               call Exact__Bona_Masso_data(                             
     &                   decoded_exact_model,                           
     &                         x(i,j,k), y(i,j,k), z(i,j,k), tplusone,  
     &                               gxx(i,j,k), gyy(i,j,k), gzz(i,j,k),
     &                                     gxy(i,j,k), gyz(i,j,k), gxz(i
     &,j,k),                                     kxx(i,j,k), kyy(i,j,k),
     & kzz(i,j,k),                                     kxy(i,j,k), kyz(i
     &,j,k), kxz(i,j,k),                                     exact_psi, 
     &                                                             exact
     &_psix, exact_psiy, exact_psiz,                                    
     & exact_psixx, exact_psiyy, exact_psizz,                           
     &       exact_psixy, exact_psiyz, exact_psixz,                     
     &             dxgxxjunk, dxgyyjunk, dxgzzjunk,                     
     &                   dxgxyjunk, dxgyzjunk, dxgxzjunk,               
     &                         dygxxjunk, dygyyjunk, dygzzjunk,         
     &                               dygxyjunk, dygyzjunk, dygxzjunk,   
     &                                     dzgxxjunk, dzgyyjunk, dzgzzju
     &nk,                                        dzgxyjunk, dzgyzjunk, d
     &zgxzjunk,                                        alp(i,j,k), dtalp
     &(i,j,k),                                               axjunk, ayj
     &unk, azjunk,                                                 betax
     &(i,j,k), betay(i,j,k), betaz(i,j,k),                              
     & dtbetax(i,j,k), dtbetay(i,j,k), dtbetaz(i,j,k),                  
     &       bxxjunk, bxyjunk, bxzjunk,                                 
     &             byxjunk, byyjunk, byzjunk,                           
     &                   bzxjunk, bzyjunk, bzzjunk)
            end do
         end do
      end if

      if (cctk_bbox(4) .eq. 1) then 
         j=ny
         do i=1,nx
            do k=1,nz
               call Exact__Bona_Masso_data(                             
     &                   decoded_exact_model,                           
     &                         x(i,j,k), y(i,j,k), z(i,j,k), tplusone,  
     &                               gxx(i,j,k), gyy(i,j,k), gzz(i,j,k),
     &                                     gxy(i,j,k), gyz(i,j,k), gxz(i
     &,j,k),                                     kxx(i,j,k), kyy(i,j,k),
     & kzz(i,j,k),                                     kxy(i,j,k), kyz(i
     &,j,k), kxz(i,j,k),                                     exact_psi, 
     &                                                             exact
     &_psix, exact_psiy, exact_psiz,                                    
     & exact_psixx, exact_psiyy, exact_psizz,                           
     &       exact_psixy, exact_psiyz, exact_psixz,                     
     &             dxgxxjunk, dxgyyjunk, dxgzzjunk,                     
     &                   dxgxyjunk, dxgyzjunk, dxgxzjunk,               
     &                         dygxxjunk, dygyyjunk, dygzzjunk,         
     &                               dygxyjunk, dygyzjunk, dygxzjunk,   
     &                                     dzgxxjunk, dzgyyjunk, dzgzzju
     &nk,                                        dzgxyjunk, dzgyzjunk, d
     &zgxzjunk,                                        alp(i,j,k), dtalp
     &(i,j,k),                                               axjunk, ayj
     &unk, azjunk,                                                 betax
     &(i,j,k), betay(i,j,k), betaz(i,j,k),                              
     & dtbetax(i,j,k), dtbetay(i,j,k), dtbetaz(i,j,k),                  
     &       bxxjunk, bxyjunk, bxzjunk,                                 
     &             byxjunk, byyjunk, byzjunk,                           
     &                   bzxjunk, bzyjunk, bzzjunk)
           end do
         end do
      end if

      if (cctk_bbox(5) .eq. 1) then 
         k=1
         do j=1,ny
            do i=1,nx
               call Exact__Bona_Masso_data(                             
     &                   decoded_exact_model,                           
     &                         x(i,j,k), y(i,j,k), z(i,j,k), tplusone,  
     &                               gxx(i,j,k), gyy(i,j,k), gzz(i,j,k),
     &                                     gxy(i,j,k), gyz(i,j,k), gxz(i
     &,j,k),                                     kxx(i,j,k), kyy(i,j,k),
     & kzz(i,j,k),                                     kxy(i,j,k), kyz(i
     &,j,k), kxz(i,j,k),                                     exact_psi, 
     &                                                             exact
     &_psix, exact_psiy, exact_psiz,                                    
     & exact_psixx, exact_psiyy, exact_psizz,                           
     &       exact_psixy, exact_psiyz, exact_psixz,                     
     &             dxgxxjunk, dxgyyjunk, dxgzzjunk,                     
     &                   dxgxyjunk, dxgyzjunk, dxgxzjunk,               
     &                         dygxxjunk, dygyyjunk, dygzzjunk,         
     &                               dygxyjunk, dygyzjunk, dygxzjunk,   
     &                                     dzgxxjunk, dzgyyjunk, dzgzzju
     &nk,                                        dzgxyjunk, dzgyzjunk, d
     &zgxzjunk,                                        alp(i,j,k), dtalp
     &(i,j,k),                                               axjunk, ayj
     &unk, azjunk,                                                 betax
     &(i,j,k), betay(i,j,k), betaz(i,j,k),                              
     & dtbetax(i,j,k), dtbetay(i,j,k), dtbetaz(i,j,k),                  
     &       bxxjunk, bxyjunk, bxzjunk,                                 
     &             byxjunk, byyjunk, byzjunk,                           
     &                   bzxjunk, bzyjunk, bzzjunk)
            end do
         end do
      end if

      if (cctk_bbox(6) .eq. 1) then 
         k=nz
         do j=1,ny
            do i=1,nx
               call Exact__Bona_Masso_data(                             
     &                   decoded_exact_model,                           
     &                         x(i,j,k), y(i,j,k), z(i,j,k), tplusone,  
     &                               gxx(i,j,k), gyy(i,j,k), gzz(i,j,k),
     &                                     gxy(i,j,k), gyz(i,j,k), gxz(i
     &,j,k),                                     kxx(i,j,k), kyy(i,j,k),
     & kzz(i,j,k),                                     kxy(i,j,k), kyz(i
     &,j,k), kxz(i,j,k),                                     exact_psi, 
     &                                                             exact
     &_psix, exact_psiy, exact_psiz,                                    
     & exact_psixx, exact_psiyy, exact_psizz,                           
     &       exact_psixy, exact_psiyz, exact_psixz,                     
     &             dxgxxjunk, dxgyyjunk, dxgzzjunk,                     
     &                   dxgxyjunk, dxgyzjunk, dxgxzjunk,               
     &                         dygxxjunk, dygyyjunk, dygzzjunk,         
     &                               dygxyjunk, dygyzjunk, dygxzjunk,   
     &                                     dzgxxjunk, dzgyyjunk, dzgzzju
     &nk,                                        dzgxyjunk, dzgyzjunk, d
     &zgxzjunk,                                        alp(i,j,k), dtalp
     &(i,j,k),                                               axjunk, ayj
     &unk, azjunk,                                                 betax
     &(i,j,k), betay(i,j,k), betaz(i,j,k),                              
     & dtbetax(i,j,k), dtbetay(i,j,k), dtbetaz(i,j,k),                  
     &       bxxjunk, bxyjunk, bxzjunk,                                 
     &             byxjunk, byyjunk, byzjunk,                           
     &                   bzxjunk, bzyjunk, bzzjunk)
            end do
         end do
      end if

      return
      end
