

















































































































 


































































































































































 


















































































































































































































 



















































 










 








































































































































































































































 










                                
                                

                                
                                

                                
                                

                                



















































































subroutine Exact_AddToTmunu(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_levo&
  &ff,cctk_levoffdenom,cctk_timefac,cctk_convlevel,cctk_convfac,cctk_nghostzones,cctk_iteration,cctkGH,cctk_ash1,cctk_ash2,cctk_ash&
  &3, slicet,slicetmp1t,slicetmp1x,slicetmp1y,slicetmp1z,slicetmp2t,slicetmp2x,slicetmp2y,slicetmp2z,slicex,slicey,slicez, Bertotti&
  &___Lambda,Kasner_generalized___p1,Kasner_generalized___p2,Kasner_like___q,Lemaitre___Lambda,Lemaitre___R0,Lemaitre___epsilon0,Le&
  &maitre___kappa,Schwarzschild_Lemaitre___Lambda,Schwarzschild_Lemaitre___mass,anti_de_Sitter_Lambda___scale,constant_density_star&
  &___mass,constant_density_star___radius,de_Sitter_Lambda___scale,de_Sitter___scale,decoded_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,coarse_dx,coarse_dy,coarse_dz,conformal_s&
  &tate,dtalp,dtalp_p,dtalp_p_p,dtbetax,dtbetax_p,dtbetax_p_p,dtbetay,dtbetay_p,dtbetay_p_p,dtbetaz,dtbetaz_p,dtbetaz_p_p,dtlapse_s&
  &tate,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,k&
  &xx,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_alignment)
  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_origin_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_levoffdenom)
  INTEGER cctk_timefac
  integer, parameter :: cctki_use_cctk_timefac = kind(cctk_timefac)
  INTEGER cctk_convlevel
  integer, parameter :: cctki_use_cctk_convlevel = kind(cctk_convlevel)
  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_nghostzones)
  INTEGER cctk_iteration
  integer, parameter :: cctki_use_cctk_iteration = kind(cctk_iteration)
  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 slicet (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_slicet = kind(slicet)
  REAL*8 slicetmp1t (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_slicetmp1t = kind(slicetmp1t)
  REAL*8 slicetmp1x (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_slicetmp1x = kind(slicetmp1x)
  REAL*8 slicetmp1y (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_slicetmp1y = kind(slicetmp1y)
  REAL*8 slicetmp1z (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_slicetmp1z = kind(slicetmp1z)
  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 slicex (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_slicex = kind(slicex)
  REAL*8 slicey (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_slicey = kind(slicey)
  REAL*8 slicez (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_slicez = kind(slicez)
  REAL*8 Bertotti___Lambda
  integer, parameter :: cctki_use_Bertotti___Lambda = kind(Bertotti___Lambda)
  REAL*8 Kasner_generalized___p1
  integer, parameter :: cctki_use_Kasner_generalized___p1 = kind(Kasner_generalized___p1)
  REAL*8 Kasner_generalized___p2
  integer, parameter :: cctki_use_Kasner_generalized___p2 = kind(Kasner_generalized___p2)
  REAL*8 Kasner_like___q
  integer, parameter :: cctki_use_Kasner_like___q = kind(Kasner_like___q)
  REAL*8 Lemaitre___Lambda
  integer, parameter :: cctki_use_Lemaitre___Lambda = kind(Lemaitre___Lambda)
  REAL*8 Lemaitre___R0
  integer, parameter :: cctki_use_Lemaitre___R0 = kind(Lemaitre___R0)
  REAL*8 Lemaitre___epsilon0
  integer, parameter :: cctki_use_Lemaitre___epsilon0 = kind(Lemaitre___epsilon0)
  REAL*8 Lemaitre___kappa
  integer, parameter :: cctki_use_Lemaitre___kappa = kind(Lemaitre___kappa)
  REAL*8 Schwarzschild_Lemaitre___Lambda
  integer, parameter :: cctki_use_Schwarzschild_Lemaitre___Lambda = kind(Schwarzschild_Lemaitre___Lambda)
  REAL*8 Schwarzschild_Lemaitre___mass
  integer, parameter :: cctki_use_Schwarzschild_Lemaitre___mass = kind(Schwarzschild_Lemaitre___mass)
  REAL*8 anti_de_Sitter_Lambda___scale
  integer, parameter :: cctki_use_anti_de_Sitter_Lambda___scale = kind(anti_de_Sitter_Lambda___scale)
  REAL*8 constant_density_star___mass
  integer, parameter :: cctki_use_constant_density_star___mass = kind(constant_density_star___mass)
  REAL*8 constant_density_star___radius
  integer, parameter :: cctki_use_constant_density_star___radius = kind(constant_density_star___radius)
  REAL*8 de_Sitter_Lambda___scale
  integer, parameter :: cctki_use_de_Sitter_Lambda___scale = kind(de_Sitter_Lambda___scale)
  REAL*8 de_Sitter___scale
  integer, parameter :: cctki_use_de_Sitter___scale = kind(de_Sitter___scale)
  INTEGER*4 decoded_exact_model
  integer, parameter :: cctki_use_decoded_exact_model = kind(decoded_exact_model)
  INTEGER*4 active_slicing_handle
  integer, parameter :: cctki_use_active_slicing_handle = kind(active_slicing_handle)
  REAL*8 alp (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_alp = kind(alp)
  REAL*8 alp_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_alp_p = kind(alp_p)
  REAL*8 alp_p_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_alp_p_p = kind(alp_p_p)
  REAL*8 betax (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_betax = kind(betax)
  REAL*8 betax_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_betax_p = kind(betax_p)
  REAL*8 betax_p_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_betax_p_p = kind(betax_p_p)
  REAL*8 betay (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_betay = kind(betay)
  REAL*8 betay_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_betay_p = kind(betay_p)
  REAL*8 betay_p_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_betay_p_p = kind(betay_p_p)
  REAL*8 betaz (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_betaz = kind(betaz)
  REAL*8 betaz_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_betaz_p = kind(betaz_p)
  REAL*8 betaz_p_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_betaz_p_p = kind(betaz_p_p)
  REAL*8 coarse_dx
  integer, parameter :: cctki_use_coarse_dx = kind(coarse_dx)
  REAL*8 coarse_dy
  integer, parameter :: cctki_use_coarse_dy = kind(coarse_dy)
  REAL*8 coarse_dz
  integer, parameter :: cctki_use_coarse_dz = kind(coarse_dz)
  INTEGER*4 conformal_state
  integer, parameter :: cctki_use_conformal_state = kind(conformal_state)
  REAL*8 dtalp (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_dtalp = kind(dtalp)
  REAL*8 dtalp_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_dtalp_p = kind(dtalp_p)
  REAL*8 dtalp_p_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_dtalp_p_p = kind(dtalp_p_p)
  REAL*8 dtbetax (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_dtbetax = kind(dtbetax)
  REAL*8 dtbetax_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_dtbetax_p = kind(dtbetax_p)
  REAL*8 dtbetax_p_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_dtbetax_p_p = kind(dtbetax_p_p)
  REAL*8 dtbetay (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_dtbetay = kind(dtbetay)
  REAL*8 dtbetay_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_dtbetay_p = kind(dtbetay_p)
  REAL*8 dtbetay_p_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_dtbetay_p_p = kind(dtbetay_p_p)
  REAL*8 dtbetaz (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_dtbetaz = kind(dtbetaz)
  REAL*8 dtbetaz_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_dtbetaz_p = kind(dtbetaz_p)
  REAL*8 dtbetaz_p_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_dtbetaz_p_p = kind(dtbetaz_p_p)
  INTEGER*4 dtlapse_state
  integer, parameter :: cctki_use_dtlapse_state = kind(dtlapse_state)
  INTEGER*4 dtshift_state
  integer, parameter :: cctki_use_dtshift_state = kind(dtshift_state)
  REAL*8 gxx (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_gxx = kind(gxx)
  REAL*8 gxx_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_gxx_p = kind(gxx_p)
  REAL*8 gxx_p_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_gxx_p_p = kind(gxx_p_p)
  REAL*8 gxy (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_gxy = kind(gxy)
  REAL*8 gxy_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_gxy_p = kind(gxy_p)
  REAL*8 gxy_p_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_gxy_p_p = kind(gxy_p_p)
  REAL*8 gxz (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_gxz = kind(gxz)
  REAL*8 gxz_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_gxz_p = kind(gxz_p)
  REAL*8 gxz_p_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_gxz_p_p = kind(gxz_p_p)
  REAL*8 gyy (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_gyy = kind(gyy)
  REAL*8 gyy_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_gyy_p = kind(gyy_p)
  REAL*8 gyy_p_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_gyy_p_p = kind(gyy_p_p)
  REAL*8 gyz (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_gyz = kind(gyz)
  REAL*8 gyz_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_gyz_p = kind(gyz_p)
  REAL*8 gyz_p_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_gyz_p_p = kind(gyz_p_p)
  REAL*8 gzz (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_gzz = kind(gzz)
  REAL*8 gzz_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_gzz_p = kind(gzz_p)
  REAL*8 gzz_p_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_gzz_p_p = kind(gzz_p_p)
  REAL*8 kxx (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_kxx = kind(kxx)
  REAL*8 kxx_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_kxx_p = kind(kxx_p)
  REAL*8 kxx_p_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_kxx_p_p = kind(kxx_p_p)
  REAL*8 kxy (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_kxy = kind(kxy)
  REAL*8 kxy_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_kxy_p = kind(kxy_p)
  REAL*8 kxy_p_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_kxy_p_p = kind(kxy_p_p)
  REAL*8 kxz (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_kxz = kind(kxz)
  REAL*8 kxz_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_kxz_p = kind(kxz_p)
  REAL*8 kxz_p_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_kxz_p_p = kind(kxz_p_p)
  REAL*8 kyy (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_kyy = kind(kyy)
  REAL*8 kyy_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_kyy_p = kind(kyy_p)
  REAL*8 kyy_p_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_kyy_p_p = kind(kyy_p_p)
  REAL*8 kyz (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_kyz = kind(kyz)
  REAL*8 kyz_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_kyz_p = kind(kyz_p)
  REAL*8 kyz_p_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_kyz_p_p = kind(kyz_p_p)
  REAL*8 kzz (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_kzz = kind(kzz)
  REAL*8 kzz_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_kzz_p = kind(kzz_p)
  REAL*8 kzz_p_p (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_kzz_p_p = kind(kzz_p_p)
  REAL*8 psi (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_psi = kind(psi)
  REAL*8 psix (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_psix = kind(psix)
  REAL*8 psixx (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_psixx = kind(psixx)
  REAL*8 psixy (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_psixy = kind(psixy)
  REAL*8 psixz (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_psixz = kind(psixz)
  REAL*8 psiy (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_psiy = kind(psiy)
  REAL*8 psiyy (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_psiyy = kind(psiyy)
  REAL*8 psiyz (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_psiyz = kind(psiyz)
  REAL*8 psiz (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_psiz = kind(psiz)
  REAL*8 psizz (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_psizz = kind(psizz)
  REAL*8 r (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_r = kind(r)
  INTEGER*4 shift_state
  integer, parameter :: cctki_use_shift_state = kind(shift_state)
  REAL*8 x (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_x = kind(x)
  REAL*8 y (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_y = kind(y)
  REAL*8 z (cctk_ash1,cctk_ash2,cctk_ash3)
  integer, parameter :: cctki_use_z = kind(z)
  REAL*8 Alvi__mass1
  integer, parameter :: cctki_use_Alvi__mass1 = kind(Alvi__mass1)
  REAL*8 Alvi__mass2
  integer, parameter :: cctki_use_Alvi__mass2 = kind(Alvi__mass2)
  REAL*8 Alvi__separation
  integer, parameter :: cctki_use_Alvi__separation = kind(Alvi__separation)
  REAL*8 Bertotti__Lambda
  integer, parameter :: cctki_use_Bertotti__Lambda = kind(Bertotti__Lambda)
  REAL*8 Bianchi_I__scale
  integer, parameter :: cctki_use_Bianchi_I__scale = kind(Bianchi_I__scale)
  REAL*8 Goedel__scale
  integer, parameter :: cctki_use_Goedel__scale = kind(Goedel__scale)
  REAL*8 Gowdy_wave__amplitude
  integer, parameter :: cctki_use_Gowdy_wave__amplitude = kind(Gowdy_wave__amplitude)
  REAL*8 Kasner_generalized__p1
  integer, parameter :: cctki_use_Kasner_generalized__p1 = kind(Kasner_generalized__p1)
  REAL*8 Kasner_generalized__p2
  integer, parameter :: cctki_use_Kasner_generalized__p2 = kind(Kasner_generalized__p2)
  REAL*8 Kasner_like__q
  integer, parameter :: cctki_use_Kasner_like__q = kind(Kasner_like__q)
  REAL*8 Kerr_BoyerLindquist__mass
  integer, parameter :: cctki_use_Kerr_BoyerLindquist__mass = kind(Kerr_BoyerLindquist__mass)
  REAL*8 Kerr_BoyerLindquist__spin
  integer, parameter :: cctki_use_Kerr_BoyerLindquist__spin = kind(Kerr_BoyerLindquist__spin)
  REAL*8 Kerr_KerrSchild__boost_v
  integer, parameter :: cctki_use_Kerr_KerrSchild__boost_v = kind(Kerr_KerrSchild__boost_v)
  REAL*8 Kerr_KerrSchild__epsilon
  integer, parameter :: cctki_use_Kerr_KerrSchild__epsilon = kind(Kerr_KerrSchild__epsilon)
  REAL*8 Kerr_KerrSchild__mass
  integer, parameter :: cctki_use_Kerr_KerrSchild__mass = kind(Kerr_KerrSchild__mass)
  REAL*8 Kerr_KerrSchild__spin
  integer, parameter :: cctki_use_Kerr_KerrSchild__spin = kind(Kerr_KerrSchild__spin)
  REAL*8 Kerr_KerrSchild__t
  integer, parameter :: cctki_use_Kerr_KerrSchild__t = kind(Kerr_KerrSchild__t)
  REAL*8 Kerr_KerrSchild__x
  integer, parameter :: cctki_use_Kerr_KerrSchild__x = kind(Kerr_KerrSchild__x)
  REAL*8 Kerr_KerrSchild__y
  integer, parameter :: cctki_use_Kerr_KerrSchild__y = kind(Kerr_KerrSchild__y)
  REAL*8 Kerr_KerrSchild__z
  integer, parameter :: cctki_use_Kerr_KerrSchild__z = kind(Kerr_KerrSchild__z)
  REAL*8 Lemaitre__Lambda
  integer, parameter :: cctki_use_Lemaitre__Lambda = kind(Lemaitre__Lambda)
  REAL*8 Lemaitre__R0
  integer, parameter :: cctki_use_Lemaitre__R0 = kind(Lemaitre__R0)
  REAL*8 Lemaitre__epsilon0
  integer, parameter :: cctki_use_Lemaitre__epsilon0 = kind(Lemaitre__epsilon0)
  REAL*8 Lemaitre__kappa
  integer, parameter :: cctki_use_Lemaitre__kappa = kind(Lemaitre__kappa)
  REAL*8 Minkowski_conf_wave__amplitude
  integer, parameter :: cctki_use_Minkowski_conf_wave__amplitude = kind(Minkowski_conf_wave__amplitude)
  REAL*8 Minkowski_conf_wave__wavelength
  integer, parameter :: cctki_use_Minkowski_conf_wave__wavelength = kind(Minkowski_conf_wave__wavelength)
  REAL*8 Minkowski_funny__amplitude
  integer, parameter :: cctki_use_Minkowski_funny__amplitude = kind(Minkowski_funny__amplitude)
  REAL*8 Minkowski_funny__sigma
  integer, parameter :: cctki_use_Minkowski_funny__sigma = kind(Minkowski_funny__sigma)
  REAL*8 Minkowski_gauge_wave__amplitude
  integer, parameter :: cctki_use_Minkowski_gauge_wave__amplitude = kind(Minkowski_gauge_wave__amplitude)
  REAL*8 Minkowski_gauge_wave__lambda
  integer, parameter :: cctki_use_Minkowski_gauge_wave__lambda = kind(Minkowski_gauge_wave__lambda)
  REAL*8 Minkowski_gauge_wave__omega
  integer, parameter :: cctki_use_Minkowski_gauge_wave__omega = kind(Minkowski_gauge_wave__omega)
  REAL*8 Minkowski_gauge_wave__phase
  integer, parameter :: cctki_use_Minkowski_gauge_wave__phase = kind(Minkowski_gauge_wave__phase)
  REAL*8 Minkowski_shift__amplitude
  integer, parameter :: cctki_use_Minkowski_shift__amplitude = kind(Minkowski_shift__amplitude)
  REAL*8 Minkowski_shift__sigma
  integer, parameter :: cctki_use_Minkowski_shift__sigma = kind(Minkowski_shift__sigma)
  REAL*8 Schwarzschild_BL__epsilon
  integer, parameter :: cctki_use_Schwarzschild_BL__epsilon = kind(Schwarzschild_BL__epsilon)
  REAL*8 Schwarzschild_BL__mass
  integer, parameter :: cctki_use_Schwarzschild_BL__mass = kind(Schwarzschild_BL__mass)
  REAL*8 Schwarzschild_EF__epsilon
  integer, parameter :: cctki_use_Schwarzschild_EF__epsilon = kind(Schwarzschild_EF__epsilon)
  REAL*8 Schwarzschild_EF__mass
  integer, parameter :: cctki_use_Schwarzschild_EF__mass = kind(Schwarzschild_EF__mass)
  REAL*8 Schwarzschild_Lemaitre__Lambda
  integer, parameter :: cctki_use_Schwarzschild_Lemaitre__Lambda = kind(Schwarzschild_Lemaitre__Lambda)
  REAL*8 Schwarzschild_Lemaitre__mass
  integer, parameter :: cctki_use_Schwarzschild_Lemaitre__mass = kind(Schwarzschild_Lemaitre__mass)
  REAL*8 Schwarzschild_Novikov__epsilon
  integer, parameter :: cctki_use_Schwarzschild_Novikov__epsilon = kind(Schwarzschild_Novikov__epsilon)
  REAL*8 Schwarzschild_Novikov__mass
  integer, parameter :: cctki_use_Schwarzschild_Novikov__mass = kind(Schwarzschild_Novikov__mass)
  REAL*8 Schwarzschild_PG__epsilon
  integer, parameter :: cctki_use_Schwarzschild_PG__epsilon = kind(Schwarzschild_PG__epsilon)
  REAL*8 Schwarzschild_PG__mass
  integer, parameter :: cctki_use_Schwarzschild_PG__mass = kind(Schwarzschild_PG__mass)
  REAL*8 Thorne_fakebinary__Omega0
  integer, parameter :: cctki_use_Thorne_fakebinary__Omega0 = kind(Thorne_fakebinary__Omega0)
  REAL*8 Thorne_fakebinary__epsilon
  integer, parameter :: cctki_use_Thorne_fakebinary__epsilon = kind(Thorne_fakebinary__epsilon)
  REAL*8 Thorne_fakebinary__mass
  integer, parameter :: cctki_use_Thorne_fakebinary__mass = kind(Thorne_fakebinary__mass)
  REAL*8 Thorne_fakebinary__separation
  integer, parameter :: cctki_use_Thorne_fakebinary__separation = kind(Thorne_fakebinary__separation)
  REAL*8 Thorne_fakebinary__smoothing
  integer, parameter :: cctki_use_Thorne_fakebinary__smoothing = kind(Thorne_fakebinary__smoothing)
  REAL*8 anti_de_Sitter_Lambda__scale
  integer, parameter :: cctki_use_anti_de_Sitter_Lambda__scale = kind(anti_de_Sitter_Lambda__scale)
  REAL*8 boost_rotation_symmetric__amp
  integer, parameter :: cctki_use_boost_rotation_symmetric__amp = kind(boost_rotation_symmetric__amp)
  REAL*8 boost_rotation_symmetric__min_d
  integer, parameter :: cctki_use_boost_rotation_symmetric__min_d = kind(boost_rotation_symmetric__min_d)
  REAL*8 boost_rotation_symmetric__scale
  integer, parameter :: cctki_use_boost_rotation_symmetric__scale = kind(boost_rotation_symmetric__scale)
  REAL*8 bowl__center
  integer, parameter :: cctki_use_bowl__center = kind(bowl__center)
  REAL*8 bowl__sigma
  integer, parameter :: cctki_use_bowl__sigma = kind(bowl__sigma)
  REAL*8 bowl__sigma_t
  integer, parameter :: cctki_use_bowl__sigma_t = kind(bowl__sigma_t)
  REAL*8 bowl__strength
  integer, parameter :: cctki_use_bowl__strength = kind(bowl__strength)
  REAL*8 bowl__t0
  integer, parameter :: cctki_use_bowl__t0 = kind(bowl__t0)
  REAL*8 bowl__x_scale
  integer, parameter :: cctki_use_bowl__x_scale = kind(bowl__x_scale)
  REAL*8 bowl__y_scale
  integer, parameter :: cctki_use_bowl__y_scale = kind(bowl__y_scale)
  REAL*8 bowl__z_scale
  integer, parameter :: cctki_use_bowl__z_scale = kind(bowl__z_scale)
  REAL*8 constant_density_star__mass
  integer, parameter :: cctki_use_constant_density_star__mass = kind(constant_density_star__mass)
  REAL*8 constant_density_star__radius
  integer, parameter :: cctki_use_constant_density_star__radius = kind(constant_density_star__radius)
  REAL*8 de_Sitter_Lambda__scale
  integer, parameter :: cctki_use_de_Sitter_Lambda__scale = kind(de_Sitter_Lambda__scale)
  REAL*8 de_Sitter__scale
  integer, parameter :: cctki_use_de_Sitter__scale = kind(de_Sitter__scale)
  REAL*8 multi_BH__Hubble
  integer, parameter :: cctki_use_multi_BH__Hubble = kind(multi_BH__Hubble)
  REAL*8 multi_BH__mass1
  integer, parameter :: cctki_use_multi_BH__mass1 = kind(multi_BH__mass1)
  REAL*8 multi_BH__mass2
  integer, parameter :: cctki_use_multi_BH__mass2 = kind(multi_BH__mass2)
  REAL*8 multi_BH__mass3
  integer, parameter :: cctki_use_multi_BH__mass3 = kind(multi_BH__mass3)
  REAL*8 multi_BH__mass4
  integer, parameter :: cctki_use_multi_BH__mass4 = kind(multi_BH__mass4)
  REAL*8 multi_BH__x1
  integer, parameter :: cctki_use_multi_BH__x1 = kind(multi_BH__x1)
  REAL*8 multi_BH__x2
  integer, parameter :: cctki_use_multi_BH__x2 = kind(multi_BH__x2)
  REAL*8 multi_BH__x3
  integer, parameter :: cctki_use_multi_BH__x3 = kind(multi_BH__x3)
  REAL*8 multi_BH__x4
  integer, parameter :: cctki_use_multi_BH__x4 = kind(multi_BH__x4)
  REAL*8 multi_BH__y1
  integer, parameter :: cctki_use_multi_BH__y1 = kind(multi_BH__y1)
  REAL*8 multi_BH__y2
  integer, parameter :: cctki_use_multi_BH__y2 = kind(multi_BH__y2)
  REAL*8 multi_BH__y3
  integer, parameter :: cctki_use_multi_BH__y3 = kind(multi_BH__y3)
  REAL*8 multi_BH__y4
  integer, parameter :: cctki_use_multi_BH__y4 = kind(multi_BH__y4)
  REAL*8 multi_BH__z1
  integer, parameter :: cctki_use_multi_BH__z1 = kind(multi_BH__z1)
  REAL*8 multi_BH__z2
  integer, parameter :: cctki_use_multi_BH__z2 = kind(multi_BH__z2)
  REAL*8 multi_BH__z3
  integer, parameter :: cctki_use_multi_BH__z3 = kind(multi_BH__z3)
  REAL*8 multi_BH__z4
  integer, parameter :: cctki_use_multi_BH__z4 = kind(multi_BH__z4)
  integer*8 Minkowski_gauge_wave__what_fn
  integer, parameter :: cctki_use_Minkowski_gauge_wave__what_fn = kind(Minkowski_gauge_wave__what_fn)
  integer*8 Thorne_fakebinary__atype
  integer, parameter :: cctki_use_Thorne_fakebinary__atype = kind(Thorne_fakebinary__atype)
  integer*8 bowl__shape
  integer, parameter :: cctki_use_bowl__shape = kind(bowl__shape)
  integer*8 exact_model
  integer, parameter :: cctki_use_exact_model = kind(exact_model)
  INTEGER*4 Kerr_KerrSchild__parabolic
  integer, parameter :: cctki_use_Kerr_KerrSchild__parabolic = kind(Kerr_KerrSchild__parabolic)
  INTEGER*4 Kerr_KerrSchild__power
  integer, parameter :: cctki_use_Kerr_KerrSchild__power = kind(Kerr_KerrSchild__power)
  INTEGER*4 Minkowski_conf_wave__direction
  integer, parameter :: cctki_use_Minkowski_conf_wave__direction = kind(Minkowski_conf_wave__direction)
  INTEGER*4 Minkowski_gauge_wave__diagonal
  integer, parameter :: cctki_use_Minkowski_gauge_wave__diagonal = kind(Minkowski_gauge_wave__diagonal)
  INTEGER*4 Thorne_fakebinary__retarded
  integer, parameter :: cctki_use_Thorne_fakebinary__retarded = kind(Thorne_fakebinary__retarded)
  INTEGER*4 bowl__evolve
  integer, parameter :: cctki_use_bowl__evolve = kind(bowl__evolve)
  INTEGER*4 multi_BH__nBH
  integer, parameter :: cctki_use_multi_BH__nBH = kind(multi_BH__nBH)
  COMMON /exactrest/Alvi__mass1, Alvi__mass2, Alvi__separation, Bertotti__Lambda, Bianchi_I__scale, Goedel__scale, Gowdy_wave__ampl&
  &itude, Kasner_generalized__p1, Kasner_generalized__p2, Kasner_like__q, Kerr_BoyerLindquist__mass, Kerr_BoyerLindquist__spin, Ker&
  &r_KerrSchild__boost_v, Kerr_KerrSchild__epsilon, Kerr_KerrSchild__mass, Kerr_KerrSchild__spin, Kerr_KerrSchild__t, Kerr_KerrSchi&
  &ld__x, Kerr_KerrSchild__y, Kerr_KerrSchild__z, Lemaitre__Lambda, Lemaitre__R0, Lemaitre__epsilon0, Lemaitre__kappa, Minkowski_co&
  &nf_wave__amplitude, Minkowski_conf_wave__wavelength, Minkowski_funny__amplitude, Minkowski_funny__sigma, Minkowski_gauge_wave__a&
  &mplitude, Minkowski_gauge_wave__lambda, Minkowski_gauge_wave__omega, Minkowski_gauge_wave__phase, Minkowski_shift__amplitude, Mi&
  &nkowski_shift__sigma, Schwarzschild_BL__epsilon, Schwarzschild_BL__mass, Schwarzschild_EF__epsilon, Schwarzschild_EF__mass, Schw&
  &arzschild_Lemaitre__Lambda, Schwarzschild_Lemaitre__mass, Schwarzschild_Novikov__epsilon, Schwarzschild_Novikov__mass, Schwarzsc&
  &hild_PG__epsilon, Schwarzschild_PG__mass, Thorne_fakebinary__Omega0, Thorne_fakebinary__epsilon, Thorne_fakebinary__mass, Thorne&
  &_fakebinary__separation, Thorne_fakebinary__smoothing, anti_de_Sitter_Lambda__scale, boost_rotation_symmetric__amp, boost_rotati&
  &on_symmetric__min_d, boost_rotation_symmetric__scale, bowl__center, bowl__sigma, bowl__sigma_t, bowl__strength, bowl__t0, bowl__&
  &x_scale, bowl__y_scale, bowl__z_scale, constant_density_star__mass, constant_density_star__radius, de_Sitter_Lambda__scale, de_S&
  &itter__scale, multi_BH__Hubble, multi_BH__mass1, multi_BH__mass2, multi_BH__mass3, multi_BH__mass4, multi_BH__x1, multi_BH__x2, &
  &multi_BH__x3, multi_BH__x4, multi_BH__y1, multi_BH__y2, multi_BH__y3, multi_BH__y4, multi_BH__z1, multi_BH__z2, multi_BH__z3, mu&
  &lti_BH__z4, Minkowski_gauge_wave__what_fn, Thorne_fakebinary__atype, bowl__shape, exact_model, Kerr_KerrSchild__parabolic, Kerr_&
  &KerrSchild__power, Minkowski_conf_wave__direction, Minkowski_gauge_wave__diagonal, Thorne_fakebinary__retarded, bowl__evolve, mu&
  &lti_BH__nBH
  REAL*8 boost_vx
  integer, parameter :: cctki_use_boost_vx = kind(boost_vx)
  REAL*8 boost_vy
  integer, parameter :: cctki_use_boost_vy = kind(boost_vy)
  REAL*8 boost_vz
  integer, parameter :: cctki_use_boost_vz = kind(boost_vz)
  REAL*8 exact_eps
  integer, parameter :: cctki_use_exact_eps = kind(exact_eps)
  REAL*8 exblend_rout
  integer, parameter :: cctki_use_exblend_rout = kind(exblend_rout)
  REAL*8 exblend_width
  integer, parameter :: cctki_use_exblend_width = kind(exblend_width)
  REAL*8 rotation_euler_phi
  integer, parameter :: cctki_use_rotation_euler_phi = kind(rotation_euler_phi)
  REAL*8 rotation_euler_psi
  integer, parameter :: cctki_use_rotation_euler_psi = kind(rotation_euler_psi)
  REAL*8 rotation_euler_theta
  integer, parameter :: cctki_use_rotation_euler_theta = kind(rotation_euler_theta)
  REAL*8 shift_add_x
  integer, parameter :: cctki_use_shift_add_x = kind(shift_add_x)
  REAL*8 shift_add_y
  integer, parameter :: cctki_use_shift_add_y = kind(shift_add_y)
  REAL*8 shift_add_z
  integer, parameter :: cctki_use_shift_add_z = kind(shift_add_z)
  REAL*8 slice_Gauss_ampl
  integer, parameter :: cctki_use_slice_Gauss_ampl = kind(slice_Gauss_ampl)
  REAL*8 slice_Gauss_width
  integer, parameter :: cctki_use_slice_Gauss_width = kind(slice_Gauss_width)
  integer*8 overwrite_boundary
  integer, parameter :: cctki_use_overwrite_boundary = kind(overwrite_boundary)
  INTEGER*4 exact_order
  integer, parameter :: cctki_use_exact_order = kind(exact_order)
  INTEGER*4 exblend_Ks
  integer, parameter :: cctki_use_exblend_Ks = kind(exblend_Ks)
  INTEGER*4 exblend_gauge
  integer, parameter :: cctki_use_exblend_gauge = kind(exblend_gauge)
  INTEGER*4 exblend_gs
  integer, parameter :: cctki_use_exblend_gs = kind(exblend_gs)
  COMMON /Exactpriv/boost_vx, boost_vy, boost_vz, exact_eps, exblend_rout, exblend_width, rotation_euler_phi, rotation_euler_psi, r&
  &otation_euler_theta, shift_add_x, shift_add_y, shift_add_z, slice_Gauss_ampl, slice_Gauss_width, overwrite_boundary, exact_order&
  &, exblend_Ks, exblend_gauge, exblend_gs
  integer*8 CCTKH0
  integer, parameter :: cctki_use_CCTKH0 = kind(CCTKH0)
  integer*8 dtlapse_evolution_method
  integer, parameter :: cctki_use_dtlapse_evolution_method = kind(dtlapse_evolution_method)
  integer*8 dtshift_evolution_method
  integer, parameter :: cctki_use_dtshift_evolution_method = kind(dtshift_evolution_method)
  integer*8 evolution_method
  integer, parameter :: cctki_use_evolution_method = kind(evolution_method)
  integer*8 initial_data
  integer, parameter :: cctki_use_initial_data = kind(initial_data)
  integer*8 initial_dtlapse
  integer, parameter :: cctki_use_initial_dtlapse = kind(initial_dtlapse)
  integer*8 initial_dtshift
  integer, parameter :: cctki_use_initial_dtshift = kind(initial_dtshift)
  integer*8 initial_lapse
  integer, parameter :: cctki_use_initial_lapse = kind(initial_lapse)
  integer*8 initial_shift
  integer, parameter :: cctki_use_initial_shift = kind(initial_shift)
  integer*8 lapse_evolution_method
  integer, parameter :: cctki_use_lapse_evolution_method = kind(lapse_evolution_method)
  integer*8 CCTKH1
  integer, parameter :: cctki_use_CCTKH1 = kind(CCTKH1)
  integer*8 CCTKH3
  integer, parameter :: cctki_use_CCTKH3 = kind(CCTKH3)
  integer*8 metric_type
  integer, parameter :: cctki_use_metric_type = kind(metric_type)
  integer*8 shift_evolution_method
  integer, parameter :: cctki_use_shift_evolution_method = kind(shift_evolution_method)
  integer*8 CCTKH5
  integer, parameter :: cctki_use_CCTKH5 = kind(CCTKH5)
  INTEGER*4 CCTKH2
  integer, parameter :: cctki_use_CCTKH2 = kind(CCTKH2)
  INTEGER*4 CCTKH4
  integer, parameter :: cctki_use_CCTKH4 = kind(CCTKH4)
  INTEGER*4 CCTKH6
  integer, parameter :: cctki_use_CCTKH6 = kind(CCTKH6)
  COMMON /ADMBASErest/CCTKH0, dtlapse_evolution_method, dtshift_evolution_method, evolution_method, initial_data, initial_dtlapse, &
  &initial_dtshift, initial_lapse, initial_shift, lapse_evolution_method, CCTKH1, CCTKH3, metric_type, shift_evolution_method, CCTK&
  &H5, CCTKH2, CCTKH4, CCTKH6
  integer*8 conformal_storage
  integer, parameter :: cctki_use_conformal_storage = kind(conformal_storage)
  COMMON /STATICCONFORMALrest/conformal_storage
  interface
  integer*8 function CCTK_PointerTo (var)
  implicit none
  type(*),dimension(..),TARGET :: var
  end function CCTK_PointerTo
  end interface
  interface
  integer function CCTK_Equals (arg1, arg2)
  implicit none
  integer*8 arg1
  character(*) arg2
  end function CCTK_Equals
  integer function CCTK_MyProc (cctkGH)
  implicit none
  integer*8 cctkGH
  end function CCTK_MyProc
  integer function CCTK_nProcs (cctkGH)
  implicit none
  integer*8 cctkGH
  end function CCTK_nProcs
  integer function CCTK_IsThornActive (name)
  implicit none
  character(*) name
  end function CCTK_IsThornActive
  integer*8 function CCTK_NullPointer ()
  implicit none
  end function CCTK_NullPointer
  end interface
  interface
  INTEGER*4 function Boundary_RegisterPhysicalBC (GH, function_pointer, bc_name)
  implicit none
  integer*8 GH
  external function_pointer
  INTEGER*4 function_pointer
  character(*) bc_name
  end function Boundary_RegisterPhysicalBC
  end interface
  interface
  INTEGER*4 function Boundary_SelectGroupForBC (GH, faces, boundary_width, table_handle, group_name, bc_name)
  implicit none
  integer*8 GH
  INTEGER*4 faces
  INTEGER*4 boundary_width
  INTEGER*4 table_handle
  character(*) group_name
  character(*) bc_name
  end function Boundary_SelectGroupForBC
  end interface
  interface
  INTEGER*4 function Driver_NotifyDataModified (cctkGH, variables, tls, nvariables, where)
  implicit none
  integer*8 cctkGH
  INTEGER*4 variables(*)
  INTEGER*4 tls(*)
  INTEGER*4 nvariables
  INTEGER*4 where(*)
  end function Driver_NotifyDataModified
  end interface
  interface
  INTEGER*4 function Driver_RequireValidData (cctkGH, variables, tls, nvariables, where)
  implicit none
  integer*8 cctkGH
  INTEGER*4 variables(*)
  INTEGER*4 tls(*)
  INTEGER*4 nvariables
  INTEGER*4 where(*)
  end function Driver_RequireValidData
  end interface


  integer :: Exact_AddToTmunu_all0_idir,Exact_AddToTmunu_all0_jdir,Exact_AddToTmunu_all0_kdir
  integer :: Exact_AddToTmunu_all0_imin,Exact_AddToTmunu_all0_jmin,Exact_AddToTmunu_all0_kmin
  integer :: Exact_AddToTmunu_all0_imax,Exact_AddToTmunu_all0_jmax,Exact_AddToTmunu_all0_kmax
  integer :: Exact_AddToTmunu_all0_iash,Exact_AddToTmunu_all0_jash,Exact_AddToTmunu_all0_kash
  integer :: Exact_AddToTmunu_all0_istr
  integer :: Exact_AddToTmunu_all1_ni,Exact_AddToTmunu_all1_nj,Exact_AddToTmunu_all1_nk
  integer :: Exact_AddToTmunu3_dummy_imin, Exact_AddToTmunu3_dummy_imax

  integer :: i,j,k


  REAL*8  unu,doi,trei,rr,kkkk
  REAL*8  aaaa,bbbb,aaaa1,bbbb1,kkkk1,r3,bass,term1,term2
  REAL*8  unu1, raz, raz2, razsch2, coefsch, pppsch, unusch
  REAL*8  treiori
  REAL*8  star_m, star_r
  REAL*8, dimension(cctk_ash(1),cctk_ash(2),cctk_ash(3)) :: eTxx, eTxy, &
             eTxz, eTyy, eTyz, eTzz, eTtx, eTty, eTtz, eTtt
  integer*8 pTxx, pTxy, pTxz, pTyy, pTyz, pTzz, pTtx, pTty, pTtz, pTtt
  integer :: vi_eTxx, vi_eTxy, vi_eTxz, vi_eTyy, vi_eTyz, vi_eTzz, vi_eTtx, &
             vi_eTty, vi_eTtz, vi_eTtt

  INTEGER*4, dimension(10) :: variable_list, timelevel_list, where_list
  INTEGER*4 :: ierr
  integer :: have_presync

  pointer (pTxx, eTxx)
  pointer (pTxy, eTxy)
  pointer (pTxz, eTxz)
  pointer (pTyy, eTyy)
  pointer (pTyz, eTyz)
  pointer (pTzz, eTzz)
  pointer (pTtx, eTtx)
  pointer (pTty, eTty)
  pointer (pTtz, eTtz)
  pointer (pTtt, eTtt)

  call CCTK_VarIndex(vi_eTxx, "TmunuBase::eTxx")
  call CCTK_VarIndex(vi_eTxy, "TmunuBase::eTxy")
  call CCTK_VarIndex(vi_eTxz, "TmunuBase::eTxz")
  call CCTK_VarIndex(vi_eTyy, "TmunuBase::eTyy")
  call CCTK_VarIndex(vi_eTyz, "TmunuBase::eTyz")
  call CCTK_VarIndex(vi_eTzz, "TmunuBase::eTzz")
  call CCTK_VarIndex(vi_eTtx, "TmunuBase::eTtx")
  call CCTK_VarIndex(vi_eTty, "TmunuBase::eTty")
  call CCTK_VarIndex(vi_eTtz, "TmunuBase::eTtz")
  call CCTK_VarIndex(vi_eTtt, "TmunuBase::eTtt")

  call CCTK_VarDataPtrI(pTxx, cctkGH, 0, vi_eTxx)
  call CCTK_VarDataPtrI(pTxy, cctkGH, 0, vi_eTxy)
  call CCTK_VarDataPtrI(pTxz, cctkGH, 0, vi_eTxz)
  call CCTK_VarDataPtrI(pTyy, cctkGH, 0, vi_eTyy)
  call CCTK_VarDataPtrI(pTyz, cctkGH, 0, vi_eTyz)
  call CCTK_VarDataPtrI(pTzz, cctkGH, 0, vi_eTzz)
  call CCTK_VarDataPtrI(pTtx, cctkGH, 0, vi_eTtx)
  call CCTK_VarDataPtrI(pTty, cctkGH, 0, vi_eTty)
  call CCTK_VarDataPtrI(pTtz, cctkGH, 0, vi_eTtz)
  call CCTK_VarDataPtrI(pTtt, cctkGH, 0, vi_eTtt)

  call CCTK_IsFunctionAliased(have_presync, "Driver_RequireValidData")
  
  if (have_presync .ne. 0) then
    variable_list = (/ vi_eTxx, vi_eTxy, vi_eTxz, vi_eTyy, vi_eTyz, vi_eTzz, &
                     vi_eTtx, vi_eTty, vi_eTtz, vi_eTtt/)
    timelevel_list = 0
    where_list = 7
    ierr = Driver_RequireValidData(cctkGH, variable_list, timelevel_list, 10, &
                                   where_list)
  end if


  Exact_AddToTmunu_all0_idir =                          0
  Exact_AddToTmunu_all0_jdir = 0
  Exact_AddToTmunu_all0_kdir = 0
  Exact_AddToTmunu_all0_imin =                                            1
  Exact_AddToTmunu_all0_jmin = 1
  Exact_AddToTmunu_all0_kmin = 1
  Exact_AddToTmunu_all0_imax =                                            cctk_lsh(1)
  Exact_AddToTmunu_all0_jmax = cctk_lsh(2)
  Exact_AddToTmunu_all0_kmax = cctk_lsh(3)
  Exact_AddToTmunu_all0_iash =                                            cctk_ash(1)
  Exact_AddToTmunu_all0_jash = cctk_ash(2)
  Exact_AddToTmunu_all0_kash = cctk_ash(3)
  Exact_AddToTmunu_all0_istr =    1
  Exact_AddToTmunu3_dummy_imin = Exact_AddToTmunu_all0_imin
  Exact_AddToTmunu3_dummy_imax = Exact_AddToTmunu_all0_imax
  !$omp do collapse(2)
  do k = Exact_AddToTmunu_all0_kmin, Exact_AddToTmunu_all0_kmax
  do j = Exact_AddToTmunu_all0_jmin, Exact_AddToTmunu_all0_jmax
  do                                                                   i = Exact_AddToTmunu_all0_imin - modulo((                   &
  &                                              Exact_AddToTmunu3_dummy_imin+Exact_AddToTmunu_all0_iash*(j+Exact_AddToTmunu_all0_j&
  &ash*(k))), Exact_AddToTmunu_all0_istr), Exact_AddToTmunu_all0_imax, Exact_AddToTmunu_all0_istr
  Exact_AddToTmunu_all1_ni = 0
  Exact_AddToTmunu_all1_nj = 0
  Exact_AddToTmunu_all1_nk = 0
  if (Exact_AddToTmunu_all0_idir < 0)                          Exact_AddToTmunu_all1_ni =                                          &
  &                         i
  if (Exact_AddToTmunu_all0_jdir < 0) Exact_AddToTmunu_all1_nj = j
  if (Exact_AddToTmunu_all0_kdir < 0) Exact_AddToTmunu_all1_nk = k
  if (Exact_AddToTmunu_all0_idir > 0)                          Exact_AddToTmunu_all1_ni = Exact_AddToTmunu_all0_imax+1-            &
  &                                                      i
  if (Exact_AddToTmunu_all0_jdir > 0) Exact_AddToTmunu_all1_nj = Exact_AddToTmunu_all0_jmax+1-j
  if (Exact_AddToTmunu_all0_kdir > 0) Exact_AddToTmunu_all1_nk = Exact_AddToTmunu_all0_kmax+1-k























































































 if     (decoded_exact_model .eq. 1) then

 elseif (decoded_exact_model .eq. 2) then

 elseif (decoded_exact_model .eq. 3) then

 elseif (decoded_exact_model .eq. 4) then

 elseif (decoded_exact_model .eq. 5) then

 elseif (decoded_exact_model .eq. 6) then






 elseif (decoded_exact_model .eq. 10) then

 elseif (decoded_exact_model .eq. 11) then

 elseif (decoded_exact_model .eq. 12) then

 elseif (decoded_exact_model .eq. 13) then

 elseif (decoded_exact_model .eq. 14) then

 elseif (decoded_exact_model .eq. 15) then

 elseif (decoded_exact_model .eq. 16) then








 elseif (decoded_exact_model .eq. 17) then
   razsch2=x(i,j,k)*x(i,j,k)+y(i,j,k)*y(i,j,k)+z(i,j,k)*z(i,j,k)
   coefsch=-Schwarzschild_Lemaitre___Lambda/(8.0D0*3.14159265358979d0)
   pppsch=1.0D0-2.0D0*Schwarzschild_Lemaitre___mass/sqrt(razsch2) &
&               -Schwarzschild_Lemaitre___Lambda*razsch2/3.0D0
   unusch=(1.0D0-pppsch)/pppsch/razsch2

   eTtt(i,j,k) =  eTtt(i,j,k)-coefsch*pppsch
   eTtx(i,j,k) =  eTtx(i,j,k)
   eTty(i,j,k) =  eTty(i,j,k)
   eTtz(i,j,k) =  eTtz(i,j,k)
   eTxx(i,j,k)  = eTxx(i,j,k)+coefsch*(1.0D0+x(i,j,k)*x(i,j,k)*unusch)
   eTyy(i,j,k)  = eTyy(i,j,k)+coefsch*(1.0D0+y(i,j,k)*y(i,j,k)*unusch)
   eTzz(i,j,k)  = eTzz(i,j,k)+coefsch*(1.0D0+z(i,j,k)*z(i,j,k)*unusch)
   eTxy(i,j,k)  = eTxy(i,j,k)+coefsch*x(i,j,k)*y(i,j,k)*unusch
   eTxz(i,j,k)  = eTxz(i,j,k)+coefsch*x(i,j,k)*z(i,j,k)*unusch
   eTyz(i,j,k)  = eTyz(i,j,k)+coefsch*y(i,j,k)*z(i,j,k)*unusch



 elseif (decoded_exact_model .eq. 18) then

 elseif (decoded_exact_model .eq. 19) then

 elseif (decoded_exact_model .eq. 20) then









  elseif (decoded_exact_model .eq. 50) then
    unu1 = sqrt(3.0D0*Lemaitre___Lambda) &
&           * CCTK_time * (Lemaitre___kappa+1.0D0) / (2.0D0)
    raz  = Lemaitre___R0*(cosh(unu1) &
&                         + sqrt(1.0D0+8.0D0*3.14159265358979d0*Lemaitre___epsilon0 &
&                                               /Lemaitre___Lambda) &
&                           *sinh(unu1)) &
&                        **(2.0D0/(3.0D0*Lemaitre___kappa+3.0D0)) 
    raz2 = raz*raz
    treiori = -Lemaitre___Lambda*raz2/8.0D0/3.14159265358979d0 &
&           +Lemaitre___epsilon0*Lemaitre___kappa &
&                              *raz**(-3.0D0*Lemaitre___kappa-1.0D0)

    eTtt(i,j,k) = eTtt(i,j,k) + Lemaitre___Lambda/8.0D0/3.14159265358979d0 &
&              + Lemaitre___epsilon0*raz**(-3.0D0*(Lemaitre___kappa+1.0D0))
    eTxx(i,j,k) = eTxx(i,j,k) + treiori
    eTyy(i,j,k) = eTyy(i,j,k) + treiori
    eTzz(i,j,k) = eTzz(i,j,k) + treiori
    eTxy(i,j,k) = eTxy(i,j,k)
    eTyz(i,j,k) = eTyz(i,j,k)
    eTxz(i,j,k) = eTxz(i,j,k)






































  elseif (decoded_exact_model .eq. 52) then
    eTtt(i,j,k) =  eTtt(i,j,k) + 1.0D0/6.0D0/3.14159265358979d0/(CCTK_time**2)
    eTtx(i,j,k)  = eTtx(i,j,k)
    eTty(i,j,k)  = eTty(i,j,k)
    eTtz(i,j,k)  = eTtz(i,j,k)
    eTxx(i,j,k)  = eTxx(i,j,k)
    eTyy(i,j,k)  = eTyy(i,j,k)
    eTzz(i,j,k)  = eTzz(i,j,k)
    eTxy(i,j,k)  = eTxy(i,j,k)
    eTxz(i,j,k)  = eTxz(i,j,k)
    eTyz(i,j,k)  = eTyz(i,j,k)






  elseif (decoded_exact_model .eq. 53) then
    aaaa = de_Sitter_Lambda___scale/(8.0D0*3.14159265358979d0)
    bbbb = aaaa*exp(2.0D0*sqrt(de_Sitter_Lambda___scale/3.0D0)*CCTK_time)

    eTtt(i,j,k)  = eTtt(i,j,k) + aaaa
    eTtx(i,j,k)  = eTtx(i,j,k)
    eTty(i,j,k)  = eTty(i,j,k)
    eTtz(i,j,k)  = eTtz(i,j,k)
    eTxx(i,j,k)  = eTxx(i,j,k) - bbbb
    eTyy(i,j,k)  = eTyy(i,j,k) - bbbb
    eTzz(i,j,k)  = eTzz(i,j,k) - bbbb
    eTxy(i,j,k)  = eTxy(i,j,k)
    eTxz(i,j,k)  = eTxz(i,j,k)
    eTyz(i,j,k)  = eTyz(i,j,k)







  elseif (decoded_exact_model .eq. 54) then
    aaaa1 = anti_de_Sitter_Lambda___scale/(8.0D0*3.14159265358979d0)
    bbbb1 = aaaa1*exp(2.0D0*sqrt(-anti_de_Sitter_Lambda___scale/3.0D0) &
&                           *x(i,j,k))
  
    eTtt(i,j,k) =  eTtt(i,j,k) + bbbb1
    eTtx(i,j,k)  = eTtx(i,j,k)
    eTty(i,j,k)  = eTty(i,j,k)
    eTtz(i,j,k)  = eTtz(i,j,k)
    eTxx(i,j,k)  = eTxx(i,j,k) - aaaa1
    eTyy(i,j,k)  = eTyy(i,j,k) - bbbb1
    eTzz(i,j,k)  = eTzz(i,j,k) - bbbb1
    eTxy(i,j,k)  = eTxy(i,j,k)
    eTxz(i,j,k)  = eTxz(i,j,k)
    eTyz(i,j,k)  = eTyz(i,j,k)



 elseif (decoded_exact_model .eq. 55) then

 elseif (decoded_exact_model .eq. 56) then







  elseif (decoded_exact_model .eq. 57) then
    bass  = Bertotti___Lambda/(8.0D0*3.14159265358979d0)
    term1 = bass*exp(2.0D0*sqrt(-Bertotti___Lambda)*x(i,j,k))
    term2 = bass*exp(2.0D0*sqrt(-Bertotti___Lambda)*z(i,j,k))

    eTtt(i,j,k) =  eTtt(i,j,k) + term1
    eTtx(i,j,k)  = eTtx(i,j,k)
    eTty(i,j,k)  = eTty(i,j,k)
    eTtz(i,j,k)  = eTtz(i,j,k)
    eTxx(i,j,k)  = eTxx(i,j,k) - bass
    eTyy(i,j,k)  = eTyy(i,j,k) - term2
    eTzz(i,j,k)  = eTzz(i,j,k) - bass
    eTxy(i,j,k)  = eTxy(i,j,k)
    eTxz(i,j,k)  = eTxz(i,j,k)
    eTyz(i,j,k)  = eTyz(i,j,k)






  elseif (decoded_exact_model .eq. 58) then

    kkkk=Kasner_like___q*(2.0D0-3.0D0*Kasner_like___q) &
&                        /(8.0D0*3.14159265358979d0*(CCTK_time**2))

    eTtt(i,j,k)  = eTtt(i,j,k) + kkkk
    eTtx(i,j,k)  = eTtx(i,j,k)
    eTty(i,j,k)  = eTty(i,j,k)
    eTtz(i,j,k)  = eTtz(i,j,k)
    eTxx(i,j,k)  = eTxx(i,j,k) + kkkk*CCTK_time**(2.0D0*Kasner_like___q)
    eTyy(i,j,k)  = eTyy(i,j,k) + kkkk*CCTK_time**(2.0D0*Kasner_like___q)
    eTzz(i,j,k)  = eTzz(i,j,k) + kkkk*CCTK_time**(2.0D0-4.0D0*Kasner_like___q)
    eTxy(i,j,k)  = eTxy(i,j,k)
    eTxz(i,j,k)  = eTxz(i,j,k)
    eTyz(i,j,k)  = eTyz(i,j,k)



 elseif (decoded_exact_model .eq. 59) then







  elseif (decoded_exact_model .eq. 60) then

  kkkk1 = (  Kasner_generalized___p1 - Kasner_generalized___p1**2 &
&           + Kasner_generalized___p2 - Kasner_generalized___p2**2 &
&           - Kasner_generalized___p1*Kasner_generalized___p2 ) &
&          / (8.0D0*3.14159265358979d0*(CCTK_time**2))

  eTtt(i,j,k)  = eTtt(i,j,k) + kkkk1
  eTtx(i,j,k)  = eTtx(i,j,k)
  eTty(i,j,k)  = eTty(i,j,k)
  eTtz(i,j,k)  = eTtz(i,j,k)
  eTxx(i,j,k)  = eTxx(i,j,k)+kkkk1*CCTK_time**(2.0D0*Kasner_generalized___p1)
  eTyy(i,j,k)  = eTyy(i,j,k)+kkkk1*CCTK_time**(2.0D0*Kasner_generalized___p2)
  eTzz(i,j,k)  = eTzz(i,j,k)+kkkk1*CCTK_time**(2.0D0-2.0D0*Kasner_generalized___p1 &
&                                    -2.0D0*Kasner_generalized___p2)
  eTxy(i,j,k)  = eTxy(i,j,k)
  eTxz(i,j,k)  = eTxz(i,j,k)
  eTyz(i,j,k)  = eTyz(i,j,k)


 elseif (decoded_exact_model .eq. 61) then





 elseif (decoded_exact_model .eq. 62) then






 elseif (decoded_exact_model .eq. 80) then

 elseif (decoded_exact_model .eq. 81) then







  elseif (decoded_exact_model .eq. 82) then
    rr  = sqrt(x(i,j,k)*x(i,j,k)+y(i,j,k)*y(i,j,k)+ &
&                z(i,j,k)*z(i,j,k))
    star_m = constant_density_star___mass
    star_r = constant_density_star___radius

    r3 = star_r**3
    if (rr.le.star_r) then
      unu = 3.0D0*sqrt(1.0D0-2.0D0*star_m/star_r)
      doi = sqrt(1.0D0-2.0D0*star_m*rr*rr/r3)
      trei= star_m*(unu-3.0D0*doi)/(2*3.14159265358979d0*(unu-doi)*r3)
      eTtt(i,j,k) = eTtt(i,j,k) + 3.0D0*star_m* &
&        (5.0D0-9.0D0*star_m/star_r - unu*doi &
&        -star_m*rr*rr/r3)/(8.0D0*3.14159265358979d0*r3)
      eTxx(i,j,k) = eTxx(i,j,k) -trei*(1.0D0+2.0D0*star_m*x(i,j,k)*x(i,j,k)/ &
&      (doi*doi*r3))/2.0D0
      eTyy(i,j,k) = eTyy(i,j,k) -trei*(1.0D0+2.0D0*star_m*y(i,j,k)*y(i,j,k)/ &
&      (doi*doi*r3))/2.0D0
      eTzz(i,j,k) = eTzz(i,j,k) -trei*(1.0D0+2.0D0*star_m*z(i,j,k)*z(i,j,k)/ &
&      (doi*doi*r3))/2.0D0
      eTxy(i,j,k) = eTxy(i,j,k) -trei*star_m*x(i,j,k)*y(i,j,k)/(doi*doi*r3)
      eTyz(i,j,k) = eTyz(i,j,k) -trei*star_m*y(i,j,k)*z(i,j,k)/(doi*doi*r3)
      eTxz(i,j,k) = eTxz(i,j,k) -trei*star_m*x(i,j,k)*z(i,j,k)/(doi*doi*r3)
    endif



  else
    call CCTK_Warn(0,429,"tmunu.F90","Exact","Unknown value of Exact::decoded_exact_model")
  endif 


  end do
  end do
  end do

  
  if (have_presync .ne. 0) then
    ierr = Driver_NotifyDataModified(cctkGH, variable_list, timelevel_list, &
                                     10, where_list)
  end if

end subroutine
