Changed handling of scalars. Scalars are now zero-dimensional arrays.

Changed handling of scalars.  Scalars are now zero-dimensional arrays.
Now handling CCTK_GroupDynamicData correctly.
Now using "include header".
Added results of test case.

darcs-hash:20010709070002-07bb3-ba0f4339acb8652e35a884fbdf7e8482b7236f8e.gz

26 files changed, 914 insertions, 1519 deletions

diff --git a/Carpet/Carpet/interface.ccl b/Carpet/Carpet/interface.ccl
index 6c5c91088..8f9d007e0 100644
--- a/Carpet/Carpet/interface.ccl
+++ b/Carpet/Carpet/interface.ccl
@@ -1,4 +1,7 @@
 # Interface definition for thorn Carpet
-# $Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/interface.ccl,v 1.2 2001/03/05 14:29:38 eschnett Exp $
+# $Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/interface.ccl,v 1.3 2001/07/09 09:00:02 schnetter Exp $
 
 implements: driver
+
+include header: carpet_public.hh in carpet.hh
+include header: carpet_public.h in carpet.h
diff --git a/Carpet/Carpet/src/CarpetStartup.cc b/Carpet/Carpet/src/CarpetStartup.cc
index b82589fe5..dd3a47ff8 100644
--- a/Carpet/Carpet/src/CarpetStartup.cc
+++ b/Carpet/Carpet/src/CarpetStartup.cc
@@ -5,7 +5,7 @@
 
 #include "carpet.hh"
 
-static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/CarpetStartup.cc,v 1.1 2001/07/04 12:29:46 schnetter Exp $";
+static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/CarpetStartup.cc,v 1.2 2001/07/09 09:00:04 schnetter Exp $";
 
 
 
@@ -36,6 +36,7 @@ namespace Carpet {
     CCTK_OverloadnProcs (nProcs);
     CCTK_OverloadArrayGroupSizeB (ArrayGroupSizeB);
     CCTK_OverloadQueryGroupStorageB (QueryGroupStorageB);
+    CCTK_OverloadGroupDynamicData (GroupDynamicData);
     
     return 0;
   }
diff --git a/Carpet/Carpet/src/Checksum.cc b/Carpet/Carpet/src/Checksum.cc
index a24461318..030e699e6 100644
--- a/Carpet/Carpet/src/Checksum.cc
+++ b/Carpet/Carpet/src/Checksum.cc
@@ -8,7 +8,7 @@
 
 #include "carpet.hh"
 
-static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/Checksum.cc,v 1.1 2001/07/04 12:29:46 schnetter Exp $";
+static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/Checksum.cc,v 1.2 2001/07/09 09:00:05 schnetter Exp $";
 
 
 
@@ -39,27 +39,10 @@ namespace Carpet {
 	checksums[n].resize(maxreflevels);
 	checksums[n][reflevel].resize(num_tl);
 	for (int tl=min_tl; tl<=max_tl; ++tl) {
-	  switch (CCTK_GroupTypeFromVarI(n)) {
-	    
-	  case CCTK_SCALAR: {
-	    checksums[n][reflevel][tl].resize(1);
-	    const int c=0;
-	    checksums[n][reflevel][tl][c].valid = false;
-	    break;
-	  }
-	      
-	  case CCTK_ARRAY:
-	  case CCTK_GF: {
-	    checksums[n][reflevel][tl].resize(hh->components(reflevel));
-	    BEGIN_COMPONENT_LOOP(cgh) {
-	      checksums[n][reflevel][tl][component].valid = false;
-	    } END_COMPONENT_LOOP(cgh);
-	    break;
-	  }
-	    
-	  default:
-	    abort();
-	  }
+	  checksums[n][reflevel][tl].resize(hh->components(reflevel));
+	  BEGIN_COMPONENT_LOOP(cgh) {
+	    checksums[n][reflevel][tl][component].valid = false;
+	  } END_COMPONENT_LOOP(cgh);
 	}
       }
     }
@@ -77,45 +60,22 @@ namespace Carpet {
 	  const int max_tl = maxtl(where, num_tl);
 	  
 	  for (int tl=min_tl; tl<=max_tl; ++tl) {
-	    switch (CCTK_GroupTypeFromVarI(n)) {
-	      
-	    case CCTK_SCALAR: {
-	      const int c=0;
-	      int chk = 0;
-	      const void* data = cgh->data[n][tl];
-	      for (int i=0; i<sz/(int)sizeof(chk); ++i) {
-		chk += ((const int*)data)[i];
-	      }
-	      checksums[n][reflevel][tl][c].sum = chk;
-	      checksums[n][reflevel][tl][c].valid = true;
-	      break;
-	    }
-	      
-	    case CCTK_ARRAY:
-	    case CCTK_GF: {
-	      BEGIN_COMPONENT_LOOP(cgh) {
-		if (hh->is_local(reflevel,component)) {
-		  const int gpdim = CCTK_GroupDimI(group);
-		  int np = 1;
-		  for (int d=0; d<gpdim; ++d) {
-		    np *= *CCTK_ArrayGroupSizeI(cgh, d, group);
-		  }
-		  const void* data = cgh->data[n][tl];
-		  int chk = 0;
-		  for (int i=0; i<np*sz/(int)sizeof(chk); ++i) {
-		    chk += ((const int*)data)[i];
-		  }
-		  checksums[n][reflevel][tl][component].sum = chk;
-		  checksums[n][reflevel][tl][component].valid = true;
+	    BEGIN_COMPONENT_LOOP(cgh) {
+	      if (hh->is_local(reflevel,component)) {
+		const int gpdim = arrdata[group].info.dim;
+		int np = 1;
+		for (int d=0; d<gpdim; ++d) {
+		  np *= *CCTK_ArrayGroupSizeI(cgh, d, group);
 		}
-	      } END_COMPONENT_LOOP(cgh);
-	      break;
-	    }
-	      
-	    default:
-	      abort();
-	    }
-	    
+		const void* data = cgh->data[n][tl];
+		int chk = 0;
+		for (int i=0; i<np*sz/(int)sizeof(chk); ++i) {
+		  chk += ((const int*)data)[i];
+		}
+		checksums[n][reflevel][tl][component].sum = chk;
+		checksums[n][reflevel][tl][component].valid = true;
+	      }
+	    } END_COMPONENT_LOOP(cgh);
 	  } // for tl
 	} // for var
       }	// if has storage
@@ -152,53 +112,27 @@ namespace Carpet {
 	    
 	    bool unexpected_change = false;
 	    
-	    switch (CCTK_GroupTypeFromVarI(n)) {
-	      
-	    case CCTK_SCALAR: {
-	      assert ((int)checksums[n][reflevel][tl].size()==1);
-	      const int c=0;
-	      if (checksums[n][reflevel][tl][c].valid) {
-		int chk = 0;
-		const void* data = cgh->data[n][tl];
-		for (int i=0; i<sz/(int)sizeof(chk); ++i) {
-		  chk += ((const int*)data)[i];
-		}
-		unexpected_change
-		  = (unexpected_change
-		     || chk != checksums[n][reflevel][tl][c].sum);
-	      }
-	      break;
-	    }
-	      
-	    case CCTK_ARRAY:
-	    case CCTK_GF: {
-	      assert ((int)checksums[n][reflevel][tl].size()
-		      == hh->components(reflevel));
-	      BEGIN_COMPONENT_LOOP(cgh) {
-		if (checksums[n][reflevel][tl][component].valid) {
-		  if (hh->is_local(reflevel,component)) {
-		    const int gpdim = CCTK_GroupDimI(group);
-		    int np = 1;
-		    for (int d=0; d<gpdim; ++d) {
-		      np *= *CCTK_ArrayGroupSizeI(cgh, d, group);
-		    }
-		    const void* data = cgh->data[n][tl];
-		    int chk = 0;
-		    for (int i=0; i<np*sz/(int)sizeof(chk); ++i) {
-		      chk += ((const int*)data)[i];
-		    }
-		    unexpected_change
-		      = (unexpected_change
-			 || chk != checksums[n][reflevel][tl][component].sum);
+	    assert ((int)checksums[n][reflevel][tl].size()
+		    == hh->components(reflevel));
+	    BEGIN_COMPONENT_LOOP(cgh) {
+	      if (checksums[n][reflevel][tl][component].valid) {
+		if (hh->is_local(reflevel,component)) {
+		  const int gpdim = arrdata[group].info.dim;
+		  int np = 1;
+		  for (int d=0; d<gpdim; ++d) {
+		    np *= *CCTK_ArrayGroupSizeI(cgh, d, group);
 		  }
+		  const void* data = cgh->data[n][tl];
+		  int chk = 0;
+		  for (int i=0; i<np*sz/(int)sizeof(chk); ++i) {
+		    chk += ((const int*)data)[i];
+		  }
+		  unexpected_change
+		    = (unexpected_change
+		       || chk != checksums[n][reflevel][tl][component].sum);
 		}
-	      } END_COMPONENT_LOOP(cgh);
-	      break;
-	    }
-	      
-	    default:
-	      abort();
-	    }
+	      }
+	    } END_COMPONENT_LOOP(cgh);
 	    
 	    if (unexpected_change) {
 	      char* fullname = CCTK_FullName(n);
diff --git a/Carpet/Carpet/src/Comm.cc b/Carpet/Carpet/src/Comm.cc
index d5410d9e7..12484068e 100644
--- a/Carpet/Carpet/src/Comm.cc
+++ b/Carpet/Carpet/src/Comm.cc
@@ -9,7 +9,7 @@
 
 #include "carpet.hh"
 
-static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/Comm.cc,v 1.1 2001/07/04 12:29:46 schnetter Exp $";
+static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/Comm.cc,v 1.2 2001/07/09 09:00:07 schnetter Exp $";
 
 
 
@@ -43,46 +43,18 @@ namespace Carpet {
     assert (num_tl>0);
     const int tl = 0;
     
-    switch (CCTK_GroupTypeI(group)) {
-      
-    case CCTK_SCALAR:
-      // TODO: Check whether the local values are consistent
-      break;
-      
-    case CCTK_ARRAY:
-      assert (group<(int)arrdata.size());
-      for (int var=0; var<(int)arrdata[group].data.size(); ++var) {
-	if (num_tl>1 && reflevel>0) {
-	  for (int c=0; c<arrdata[group].hh->components(reflevel); ++c) {
-	    arrdata[group].data[var]->ref_bnd_prolongate
-	      (tl, reflevel, c, mglevel,
-	       prolongation_order_space, prolongation_order_time);
-	  }
-	}
+    assert (group<(int)arrdata.size());
+    for (int var=0; var<(int)arrdata[group].data.size(); ++var) {
+      if (num_tl>1 && reflevel>0) {
 	for (int c=0; c<arrdata[group].hh->components(reflevel); ++c) {
-	  arrdata[group].data[var]->sync (tl, reflevel, c, mglevel);
+	  arrdata[group].data[var]->ref_bnd_prolongate
+	    (tl, reflevel, c, mglevel,
+	     prolongation_order_space, prolongation_order_time);
 	}
       }
-      break;
-      
-    case CCTK_GF:
-      assert (group<(int)gfdata.size());
-      for (int var=0; var<(int)gfdata[group].data.size(); ++var) {
-	if (num_tl>1 && reflevel>0) {
-	  for (int c=0; c<hh->components(reflevel); ++c) {
-	    gfdata[group].data[var]->ref_bnd_prolongate
-	      (tl, reflevel, c, mglevel,
-	       prolongation_order_space, prolongation_order_time);
-	  }
-	}
-	for (int c=0; c<hh->components(reflevel); ++c) {
-	  gfdata[group].data[var]->sync (tl, reflevel, c, mglevel);
-	}
+      for (int c=0; c<arrdata[group].hh->components(reflevel); ++c) {
+	arrdata[group].data[var]->sync (tl, reflevel, c, mglevel);
       }
-      break;
-      
-    default:
-      abort();
     }
     
     return 0;
diff --git a/Carpet/Carpet/src/Cycle.cc b/Carpet/Carpet/src/Cycle.cc
index d0c841cae..3bf771939 100644
--- a/Carpet/Carpet/src/Cycle.cc
+++ b/Carpet/Carpet/src/Cycle.cc
@@ -8,7 +8,7 @@
 
 #include "carpet.hh"
 
-static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/Cycle.cc,v 1.1 2001/07/04 12:29:46 schnetter Exp $";
+static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/Cycle.cc,v 1.2 2001/07/09 09:00:08 schnetter Exp $";
 
 
 
@@ -25,41 +25,13 @@ namespace Carpet {
     for (int group=0; group<CCTK_NumGroups(); ++group) {
       if (CCTK_QueryGroupStorageI(cgh, group)) {
 	for (int var=0; var<CCTK_NumVarsInGroupI(group); ++var) {
-	  const int n = CCTK_FirstVarIndexI(group) + var;
-	  switch (CCTK_GroupTypeFromVarI(n)) {
-	  case CCTK_SCALAR: {
-	    assert (group<(int)scdata.size());
-	    assert (var<(int)scdata[group].data.size());
-	    const int num_tl = CCTK_NumTimeLevelsFromVarI(n);
-	    assert (num_tl>0);
-	    void* tmpdata = scdata[group].data[var][reflevel][0];
-	    for (int tl=1; tl<num_tl; ++tl) {
-	      scdata[group].data[var][reflevel][tl]
-		= scdata[group].data[var][reflevel][tl-1];
-	    }
-	    scdata[group].data[var][reflevel][0] = tmpdata;
-	    tmpdata = 0;
-	    break;
-	  }
-	  case CCTK_ARRAY: {
-	    assert (group<(int)arrdata.size());
-	    assert (var<(int)arrdata[group].data.size());
-	    for (int c=0; c<arrdata[group].hh->components(reflevel); ++c) {
-	      arrdata[group].data[var]->cycle (reflevel, c, mglevel);
-	    }
-	    break;
-	  }
-	  case CCTK_GF: {
-	    assert (group<(int)gfdata.size());
-	    assert (var<(int)gfdata[group].data.size());
-	    for (int c=0; c<hh->components(reflevel); ++c) {
-	      gfdata[group].data[var]->cycle (reflevel, c, mglevel);
-	    }
-	    break;
-	  }
-	  default:
-	    abort();
+	  
+	  assert (group<(int)arrdata.size());
+	  assert (var<(int)arrdata[group].data.size());
+	  for (int c=0; c<arrdata[group].hh->components(reflevel); ++c) {
+	    arrdata[group].data[var]->cycle (reflevel, c, mglevel);
 	  }
+	  
 	}
       }
     }
diff --git a/Carpet/Carpet/src/Evolve.cc b/Carpet/Carpet/src/Evolve.cc
index a9e464c44..2dde2757a 100644
--- a/Carpet/Carpet/src/Evolve.cc
+++ b/Carpet/Carpet/src/Evolve.cc
@@ -8,7 +8,7 @@
 
 #include "carpet.hh"
 
-static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/Evolve.cc,v 1.1 2001/07/04 12:29:46 schnetter Exp $";
+static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/Evolve.cc,v 1.2 2001/07/09 09:00:08 schnetter Exp $";
 
 
 
@@ -46,6 +46,7 @@ namespace Carpet {
 	  
 	  // Advance level times
 	  tt->advance_time (reflevel, mglevel);
+	  tt0->advance_time (reflevel, mglevel);
 	  for (int group=0; group<CCTK_NumGroups(); ++group) {
 	    switch (CCTK_GroupTypeI(group)) {
 	    case CCTK_SCALAR:
diff --git a/Carpet/Carpet/src/Poison.cc b/Carpet/Carpet/src/Poison.cc
index 4b0194bf3..d57cbf2de 100644
--- a/Carpet/Carpet/src/Poison.cc
+++ b/Carpet/Carpet/src/Poison.cc
@@ -7,7 +7,7 @@
 
 #include "carpet.hh"
 
-static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/Poison.cc,v 1.1 2001/07/04 12:29:47 schnetter Exp $";
+static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/Poison.cc,v 1.2 2001/07/09 09:00:09 schnetter Exp $";
 
 
 
@@ -62,30 +62,16 @@ namespace Carpet {
       
       for (int tl=min_tl; tl<=max_tl; ++tl) {
 	
-	switch (CCTK_GroupTypeFromVarI(n)) {
-	case CCTK_SCALAR: {
-	  assert (group<(int)scdata.size());
-	  assert (var<(int)scdata[group].data.size());
-	  memset (cgh->data[n][tl], poison_value, sz);
-	  break;
-	}
-	case CCTK_ARRAY:
-	case CCTK_GF: {
-	  BEGIN_COMPONENT_LOOP(cgh) {
-	    if (hh->is_local(reflevel,component)) {
-	      int np = 1;
-	      const int gpdim = CCTK_GroupDimI(group);
-	      for (int d=0; d<gpdim; ++d) {
-		np *= *CCTK_ArrayGroupSizeI(cgh, d, group);
-	      }
-	      memset (cgh->data[n][tl], poison_value, np*sz);
+	BEGIN_COMPONENT_LOOP(cgh) {
+	  if (hh->is_local(reflevel,component)) {
+	    int np = 1;
+	    const int gpdim = arrdata[group].info.dim;
+	    for (int d=0; d<gpdim; ++d) {
+	      np *= *CCTK_ArrayGroupSizeI(cgh, d, group);
 	    }
-	  } END_COMPONENT_LOOP(cgh);
-	  break;
-	}
-	default:
-	  abort();
-	}
+	    memset (cgh->data[n][tl], poison_value, np*sz);
+	  }
+	} END_COMPONENT_LOOP(cgh);
 	
       } // for tl
       
@@ -115,91 +101,56 @@ namespace Carpet {
 	  
 	  for (int tl=min_tl; tl<=max_tl; ++tl) {
 	    
-	    switch (CCTK_GroupTypeFromVarI(n)) {
-	      
-	    case CCTK_SCALAR: {
-	      bool poisoned=false;
-	      switch (CCTK_VarTypeI(n)) {
-#define TYPECASE(N,T)						\
-	      case N: {						\
-		T worm;						\
-		memset (&worm, poison_value, sizeof(worm));	\
-		poisoned = *(const T*)cgh->data[n][tl] == worm;	\
-		break;						\
-	      }
-#include "typecase"
-#undef TYPECASE
-	      default:
-		UnsupportedVarType(n);
-	      }
-	      if (poisoned) {
-		char* fullname = CCTK_FullName(n);
-		CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING,
-			    "The variable \"%s\" contains poison in timelevel %d",
-			    fullname, tl);
-		free (fullname);
-	      }
-	      break;
-	    }
-	      
-	    case CCTK_ARRAY:
-	    case CCTK_GF: {
-	      BEGIN_COMPONENT_LOOP(cgh) {
-		if (hh->is_local(reflevel,component)) {
-		  vect<int,dim> size(1);
-		  const int gpdim = CCTK_GroupDimI(group);
-		  for (int d=0; d<gpdim; ++d) {
-		    size[d] = *CCTK_ArrayGroupSizeI(cgh, d, group);
-		  }
-		  const int tp = CCTK_VarTypeI(n);
-		  const void* const data = cgh->data[n][tl];
-		  int numpoison=0;
-		  for (int k=0; k<size[2]; ++k) {
-		    for (int j=0; j<size[1]; ++j) {
-		      for (int i=0; i<size[0]; ++i) {
-			const int idx = CCTK_GFINDEX3D(cgh,i,j,k);
-			bool poisoned=false;
-			switch (tp) {
+	    BEGIN_COMPONENT_LOOP(cgh) {
+	      if (hh->is_local(reflevel,component)) {
+		vect<int,dim> size(1);
+		const int gpdim = arrdata[group].info.dim;
+		for (int d=0; d<gpdim; ++d) {
+		  size[d] = *CCTK_ArrayGroupSizeI(cgh, d, group);
+		}
+		const int tp = CCTK_VarTypeI(n);
+		const void* const data = cgh->data[n][tl];
+		int numpoison=0;
+		for (int k=0; k<size[2]; ++k) {
+		  for (int j=0; j<size[1]; ++j) {
+		    for (int i=0; i<size[0]; ++i) {
+		      const int idx = CCTK_GFINDEX3D(cgh,i,j,k);
+		      bool poisoned=false;
+		      switch (tp) {
 #define TYPECASE(N,T)							\
-			case N: {					\
-			  T worm;					\
-			  memset (&worm, poison_value, sizeof(worm));	\
-			  poisoned = ((const T*)data)[idx] == worm;	\
-			  break;					\
-			}
+		      case N: {						\
+			T worm;						\
+			memset (&worm, poison_value, sizeof(worm));	\
+			poisoned = ((const T*)data)[idx] == worm;	\
+			break;						\
+		      }
 #include "typecase"
 #undef TYPECASE
-			default:
-			  UnsupportedVarType(n);
+		      default:
+			UnsupportedVarType(n);
+		      }
+		      if (poisoned) {
+			++numpoison;
+			if (numpoison<=10) {
+			  char* fullname = CCTK_FullName(n);
+			  CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING,
+				      "The variable \"%s\" contains poison at [%d,%d,%d] in timelevel %d",
+				      fullname, i,j,k, tl);
+			  free (fullname);
 			}
-			if (poisoned) {
-			  ++numpoison;
-			  if (numpoison<=10) {
-			    char* fullname = CCTK_FullName(n);
-			    CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING,
-					"The variable \"%s\" contains poison at [%d,%d,%d] in timelevel %d",
-					fullname, i,j,k, tl);
-			    free (fullname);
-			  }
-			} // if poisoned
-		      } // for i
-		    } // for j
-		  } // for k
-		  if (numpoison>10) {
-		    char* fullname = CCTK_FullName(n);
-		    CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING,
-				"The variable \"%s\" contains poison at %d locations in timelevel %d; not all locations were printed.",
-				fullname, numpoison, tl);
-		    free (fullname);
-		  }
-		} // if is local
-	      } END_COMPONENT_LOOP(cgh);
-	      break;
-	    }
-	      
-	    default:
-	      abort();
-	    }
+		      } // if poisoned
+		    } // for i
+		  } // for j
+		} // for k
+		if (numpoison>10) {
+		  char* fullname = CCTK_FullName(n);
+		  CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING,
+			      "The variable \"%s\" contains poison at %d locations in timelevel %d; not all locations were printed.",
+			      fullname, numpoison, tl);
+		  free (fullname);
+		}
+	      } // if is local
+	    } END_COMPONENT_LOOP(cgh);
 	    
 	  } // for tl
 	  
diff --git a/Carpet/Carpet/src/Recompose.cc b/Carpet/Carpet/src/Recompose.cc
index e1c9afba8..1e250df40 100644
--- a/Carpet/Carpet/src/Recompose.cc
+++ b/Carpet/Carpet/src/Recompose.cc
@@ -12,7 +12,7 @@
 
 #include "carpet.hh"
 
-static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/Recompose.cc,v 1.1 2001/07/04 12:29:47 schnetter Exp $";
+static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/Recompose.cc,v 1.2 2001/07/09 09:00:09 schnetter Exp $";
 
 
 
@@ -34,6 +34,7 @@ namespace Carpet {
     Checkpoint ("%*sRecompose", 2*reflevel, "");
     
     Recompose_gh (cgh, hh);
+    Recompose_gh (cgh, hh0);
     
     for (int group=0; group<CCTK_NumGroups(); ++group) {
       switch (CCTK_GroupTypeI(group)) {
diff --git a/Carpet/Carpet/src/Restrict.cc b/Carpet/Carpet/src/Restrict.cc
index c935b9336..7c4ef7467 100644
--- a/Carpet/Carpet/src/Restrict.cc
+++ b/Carpet/Carpet/src/Restrict.cc
@@ -8,7 +8,7 @@
 
 #include "carpet.hh"
 
-static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/Restrict.cc,v 1.1 2001/07/04 12:29:47 schnetter Exp $";
+static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/Restrict.cc,v 1.2 2001/07/09 09:00:10 schnetter Exp $";
 
 
 
@@ -33,37 +33,14 @@ namespace Carpet {
 	
 	const int tl = 0;
 	
-	switch (CCTK_GroupTypeI(group)) {
-	  
-	case CCTK_SCALAR:
-	  break;
-	  
-	case CCTK_ARRAY:
-	  for (int var=0; var<(int)arrdata[group].data.size(); ++var) {
-	    for (int c=0; c<hh->components(reflevel); ++c) {
-	      arrdata[group].data[var]->ref_restrict
-		(tl, reflevel, c, mglevel);
-	    }
-	    for (int c=0; c<arrdata[group].hh->components(reflevel); ++c) {
-	      arrdata[group].data[var]->sync (tl, reflevel, c, mglevel);
-	    }
+	for (int var=0; var<(int)arrdata[group].data.size(); ++var) {
+	  for (int c=0; c<hh->components(reflevel); ++c) {
+	    arrdata[group].data[var]->ref_restrict
+	      (tl, reflevel, c, mglevel);
 	  }
-	  break;
-	  
-	case CCTK_GF:
-	  for (int var=0; var<(int)gfdata[group].data.size(); ++var) {
-	    for (int c=0; c<hh->components(reflevel); ++c) {
-	      gfdata[group].data[var]->ref_restrict
-		(tl, reflevel, c, mglevel);
-	    }
-	    for (int c=0; c<hh->components(reflevel); ++c) {
-	      gfdata[group].data[var]->sync (tl, reflevel, c, mglevel);
-	    }
+	  for (int c=0; c<arrdata[group].hh->components(reflevel); ++c) {
+	    arrdata[group].data[var]->sync (tl, reflevel, c, mglevel);
 	  }
-	  break;
-	  
-	default:
-	  abort();
 	}
 	
       }	// if group has storage
diff --git a/Carpet/Carpet/src/SetupGH.cc b/Carpet/Carpet/src/SetupGH.cc
index c7837edc9..0f59d3fa0 100644
--- a/Carpet/Carpet/src/SetupGH.cc
+++ b/Carpet/Carpet/src/SetupGH.cc
@@ -10,7 +10,7 @@
 
 #include "carpet.hh"
 
-static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/SetupGH.cc,v 1.1 2001/07/04 12:29:47 schnetter Exp $";
+static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/SetupGH.cc,v 1.2 2001/07/09 09:00:10 schnetter Exp $";
 
 
 
@@ -85,10 +85,24 @@ namespace Carpet {
       }
     }
     
+    // Allocate grid hierarchy for scalars
+    const vect<int,dim> lb0(0);
+    const vect<int,dim> ub0(0);
+    const bbox<int,dim> baseext0(lb0, ub0, str);
+    hh0 = new gh<dim>(refinement_factor, vertex_centered,
+		      multigrid_factor, vertex_centered,
+		      baseext0);
+    
+    // Allocate time hierarchy for scalars
+    tt0 = new th(hh0, maxreflevelfact);
+    
+    // Allocate data hierarchy for scalars
+    const vect<int,dim> lghosts0(0);
+    const vect<int,dim> ughosts0(0);
+    dd0 = new dh<dim>(*hh0, lghosts0, ughosts0, prolongation_order_space);
+    
     // Allocate space for groups
-    scdata.resize(CCTK_NumGroups());
     arrdata.resize(CCTK_NumGroups());
-    gfdata.resize(CCTK_NumGroups());
     
     // Allocate space for variables in group (but don't enable storage
     // yet)
@@ -97,17 +111,10 @@ namespace Carpet {
       switch (CCTK_GroupTypeI(group)) {
 	
       case CCTK_SCALAR: {
-	scdata[group].data.resize(CCTK_NumVarsInGroupI(group));
-	for (int var=0; var<(int)scdata[group].data.size(); ++var) {
-	  const int n = (CCTK_FirstVarIndexI(group) + var);
-	  scdata[group].data[var].resize(maxreflevels);
-	  for (int rl=0; rl<maxreflevels; ++rl) {
-	    scdata[group].data[var][rl].resize(CCTK_NumTimeLevelsFromVarI(n));
-	    for (int tl=0; tl<(int)scdata[group].data[var].size(); ++tl) {
-	      scdata[group].data[var][rl][tl] = 0;
-	    }
-	  }
-	}
+	arrdata[group].info.dim = 0;
+	arrdata[group].hh = hh0;
+	arrdata[group].tt = tt0;
+	arrdata[group].dd = dd0;
 	break;
       }
 	
@@ -116,6 +123,7 @@ namespace Carpet {
 	CCTK_GroupData (group, &gp);
 	
 	assert (gp.dim>=1 || gp.dim<=dim);
+	arrdata[group].info.dim = gp.dim;
 	
 	switch (gp.disttype) {
 	case CCTK_DISTRIB_CONSTANT:
@@ -148,7 +156,7 @@ namespace Carpet {
 					multigrid_factor, vertex_centered,
 					arrext);
 	
-	arrdata[group].tt = new th (arrdata[group].hh, maxreflevelfact);
+	arrdata[group].tt = new th(arrdata[group].hh, maxreflevelfact);
 	
 	vect<int,dim> alghosts(0), aughosts(0);
 	for (int d=0; d<gp.dim; ++d) {
@@ -173,33 +181,44 @@ namespace Carpet {
 			prolongation_order_space, min_nghosts);
 	  }
 	}
-	
-	arrdata[group].data.resize(CCTK_NumVarsInGroupI(group));
-	for (int var=0; var<(int)scdata[group].data.size(); ++var) {
-	  arrdata[group].data[var] = 0;
-	}
 	break;
       }
 	
       case CCTK_GF: {
 	assert (CCTK_GroupDimI(group) == dim);
-	
-	gfdata[group].data.resize(CCTK_NumVarsInGroupI(group));
-	for (int var=0; var<(int)scdata[group].data.size(); ++var) {
-	  gfdata[group].data[var] = 0;
-	}
+	arrdata[group].info.dim = dim;
+	arrdata[group].hh = hh;
+	arrdata[group].tt = tt;
+	arrdata[group].dd = dd;
 	break;
       }
 	
       default:
 	abort();
       }
+      
+      arrdata[group].info.gsh         = (int*)malloc(  dim * sizeof(int));
+      arrdata[group].info.lsh         = (int*)malloc(  dim * sizeof(int));
+      arrdata[group].info.lbnd        = (int*)malloc(  dim * sizeof(int));
+      arrdata[group].info.ubnd        = (int*)malloc(  dim * sizeof(int));
+      arrdata[group].info.bbox        = (int*)malloc(2*dim * sizeof(int));
+      arrdata[group].info.nghostzones = (int*)malloc(  dim * sizeof(int));
+      
+      arrdata[group].data.resize(CCTK_NumVarsInGroupI(group));
+      for (int var=0; var<(int)arrdata[group].data.size(); ++var) {
+	arrdata[group].data[var] = 0;
+      }
     }
     
     // Initialise cgh
     for (int d=0; d<dim; ++d) {
       cgh->cctk_nghostzones[d] = dd->lghosts[d];
     }
+    for (int group=0; group<CCTK_NumGroups(); ++group) {
+      for (int d=0; d<dim; ++d) {
+	cgh->cctk_nghostzones[d] = arrdata[group].dd->lghosts[d];
+      }
+    }
     
     // Initialise current position
     reflevel  = 0;
diff --git a/Carpet/Carpet/src/Storage.cc b/Carpet/Carpet/src/Storage.cc
index a741ff5e7..ae54bf0b0 100644
--- a/Carpet/Carpet/src/Storage.cc
+++ b/Carpet/Carpet/src/Storage.cc
@@ -8,7 +8,7 @@
 
 #include "carpet.hh"
 
-static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/Storage.cc,v 1.1 2001/07/04 12:29:47 schnetter Exp $";
+static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/Storage.cc,v 1.2 2001/07/09 09:00:11 schnetter Exp $";
 
 
 
@@ -41,8 +41,8 @@ namespace Carpet {
     // There is a difference between the Cactus time levels and the
     // Carpet time levels.  If there are n time levels, then the
     // Cactus time levels are numbered 0 ... n-1, with the current
-    // time level being n-1.  In Carpet, the time levels are numbered
-    // -(n-1) ... 0, where the current time level is always 0.
+    // time level being 0.  In Carpet, the time levels are numbered
+    // -(n-1) ... 0, where the current time level is also 0.
     const int n0 = CCTK_FirstVarIndexI(group);
     assert (n0>=0);
     const int num_tl = CCTK_NumTimeLevelsFromVarI(n0);
@@ -50,74 +50,23 @@ namespace Carpet {
     const int tmin = 1 - num_tl;
     const int tmax = 0;
     
-    switch (CCTK_GroupTypeI(group)) {
-      
-    case CCTK_SCALAR:
-      assert (scdata[group].data.size()==0
-	      || scdata[group].data[0].size()==0
-	      || scdata[group].data[0][0].size()==0
-	      || scdata[group].data[0][0][0] == 0);
-      for (int var=0; var<(int)scdata[group].data.size(); ++var) {
-	for (int rl=0; rl<(int)scdata[group].data[var].size(); ++rl) {
-	  for (int tl=0; tl<(int)scdata[group].data[var][rl].size(); ++tl) {
-	    const int n = n0 + var;
-	    switch (CCTK_VarTypeI(n)) {
-#define TYPECASE(N,T)					\
-	    case N:					\
-	      scdata[group].data[var][rl][tl] = new T;	\
-	      break;
-#include "typecase"
-#undef TYPECASE
-	    default:
-	      UnsupportedVarType(n);
-	    } // switch
-	  } // for
-	} // for
-      }	// for
-      break;
-      
-    case CCTK_ARRAY:
-      assert (arrdata[group].data.size()==0
-	      || arrdata[group].data[0] == 0);
-      for (int var=0; var<(int)arrdata[group].data.size(); ++var) {
-	const int n = n0 + var;
-	switch (CCTK_VarTypeI(n)) {
+    assert (arrdata[group].data.size()==0
+	    || arrdata[group].data[0] == 0);
+    for (int var=0; var<(int)arrdata[group].data.size(); ++var) {
+      const int n = n0 + var;
+      switch (CCTK_VarTypeI(n)) {
 #define TYPECASE(N,T)							\
-	case N:								\
-	  arrdata[group].data[var] = new gf<T,dim>			\
-	    (CCTK_VarName(n), *arrdata[group].tt, *arrdata[group].dd,	\
-	     tmin, tmax);						\
-	  break;
-#include "typecase"
-#undef TYPECASE
-	default:
-	  UnsupportedVarType(n);
-	} // switch
-      }	// for
-      break;
-      
-    case CCTK_GF:
-      assert (gfdata[group].data.size()==0
-	      || gfdata[group].data[0] == 0);
-      for (int var=0; var<(int)gfdata[group].data.size(); ++var) {
-	const int n = n0 + var;
-	switch (CCTK_VarTypeI(n)) {
-#define TYPECASE(N,T)						\
-	case N:							\
-	  gfdata[group].data[var] = new gf<T,dim>		\
-	    (CCTK_VarName(n), *tt, *(dh<dim>*)dd, tmin, tmax);	\
-	  break;
+      case N:								\
+	arrdata[group].data[var] = new gf<T,dim>			\
+	  (CCTK_VarName(n), *arrdata[group].tt, *arrdata[group].dd,	\
+	   tmin, tmax);							\
+	break;
 #include "typecase"
 #undef TYPECASE
-	default:
-	  UnsupportedVarType(n);
-	} // switch
-      }	// for
-      break;
-      
-    default:
-      abort();
-    }
+      default:
+	UnsupportedVarType(n);
+      } // switch
+    } // for
     
     // Reinitialise Cactus variables
     set_component (cgh, component);
@@ -147,82 +96,22 @@ namespace Carpet {
     
     const int n0 = CCTK_FirstVarIndexI(group);
     
-    switch (CCTK_GroupTypeI(group)) {
-      
-    case CCTK_SCALAR:
-      if (scdata[group].data.size()==0
-	  || scdata[group].data[0].size()==0
-	  || scdata[group].data[0][0].size()==0
-	  || scdata[group].data[0][0][0] == 0) {
-	// group already has no storage
-	break;
-      }
-      for (int var=0; var<(int)scdata[group].data.size(); ++var) {
-	const int n = n0 + var;
-	for (int rl=0; rl<(int)scdata[group].data[var].size(); ++rl) {
-	  for (int tl=0; tl<(int)scdata[group].data[var][rl].size(); ++tl) {
-	    switch (CCTK_VarTypeI(n)) {
-#define TYPECASE(N,T)						\
-	    case N:						\
-	      delete (T*)scdata[group].data[var][rl][tl];	\
-	      break;
-#include "typecase"
-#undef TYPECASE
-	    default:
-	      UnsupportedVarType(n);
-	    }
-	    scdata[group].data[var][rl][tl] = 0;
-	  }
-	}
-      }
-      break;
-      
-    case CCTK_ARRAY:
-      if (arrdata[group].data.size()==0 || arrdata[group].data[0] == 0) {
-	// group already has no storage
-	break;
-      }
-      for (int var=0; var<(int)arrdata[group].data.size(); ++var) {
-	const int n = CCTK_FirstVarIndexI(group) + var;
-	switch (CCTK_VarTypeI(n)) {
+    assert (arrdata[group].data.size());
+    assert (arrdata[group].data[0]);
+    for (int var=0; var<(int)arrdata[group].data.size(); ++var) {
+      const int n = n0 + var;
+      switch (CCTK_VarTypeI(n)) {
 #define TYPECASE(N,T)					\
-	case N:						\
-	  delete (gf<T,dim>*)arrdata[group].data[var];	\
-	  break;
-#include "typecase"
-#undef TYPECASE
-	default:
-	  UnsupportedVarType(n);
-	} // switch
-	arrdata[group].data[var] = 0;
-      }	// for
-      break;
-      
-    case CCTK_GF:
-      if (gfdata[group].data.size()==0
-	  || gfdata[group].data[0] == 0) {
-	// group already has no storage
+      case N:						\
+	delete (gf<T,dim>*)arrdata[group].data[var];	\
 	break;
-      }
-      for (int var=0; var<(int)gfdata[group].data.size(); ++var) {
-	const int n = CCTK_FirstVarIndexI(group) + var;
-	switch (CCTK_VarTypeI(n)) {
-#define TYPECASE(N,T)					\
-	case N:						\
-	  delete (gf<T,dim>*)gfdata[group].data[var];	\
-	  break;
 #include "typecase"
 #undef TYPECASE
-	default:
-	  UnsupportedVarType(n);
-	} // switch
-	gfdata[group].data[var] = 0;
-      }	// for
-      break;
-      
-    default:
-      abort();
-    }
+      default:
+	UnsupportedVarType(n);
+      } // switch
+      arrdata[group].data[var] = 0;
+    } // for
     
     // Reinitialise Cactus variables
     set_component (cgh, component);
@@ -244,32 +133,55 @@ namespace Carpet {
     assert (n>=0 && n<CCTK_NumVars());
     const int var = 0;
     
-    switch (CCTK_GroupTypeFromVarI(n)) {
-      
-    case CCTK_SCALAR: {
-      assert (group<(int)scdata.size());
-      assert (var<(int)scdata[group].data.size());
-      assert (reflevel<(int)scdata[group].data[var].size());
-      const int tl=0;
-      assert (tl<(int)scdata[group].data[var][reflevel].size());
-      return scdata[group].data[var][reflevel][tl] != 0;
+    assert (group<(int)arrdata.size());
+    assert (var<(int)arrdata[group].data.size());
+    return arrdata[group].data[var] != 0;
+  }
+  
+  
+  
+  const int* ArrayGroupSizeB (cGH* cgh, int dir, int group,
+			      const char* groupname)
+  {
+    static const int zero = 0;
+    
+    if (component == -1) {
+      // global routine
+      return &zero;
     }
+    
+    if (groupname) {
+      group = CCTK_GroupIndex(groupname);
+    }
+    assert (group>=0 && group<CCTK_NumGroups());
+    
+    const int gpdim = arrdata[group].info.dim;
+    
+    assert (dir>=0 && dir<gpdim);
+    
+    if (CCTK_QueryGroupStorageI(cgh, group)) {
+      
+      const int var = CCTK_FirstVarIndexI(group);
+      assert (var>=0 && var<CCTK_NumVars());
       
-    case CCTK_ARRAY: {
       assert (group<(int)arrdata.size());
-      assert (var<(int)arrdata[group].data.size());
-      return arrdata[group].data[var] != 0;
-    }
+      return &arrdata[group].info.lsh[dir];
       
-    case CCTK_GF: {
-      assert (group<(int)gfdata.size());
-      assert (var<(int)gfdata[group].data.size());
-      return gfdata[group].data[var] != 0;
-    }
+    } else {
+      
+      // no storage
+      return &zero;
       
-    default:
-      abort();
     }
   }
   
+  
+  
+  int GroupDynamicData (cGH* cgh, int group, cGroupDynamicData* data)
+  {
+    assert (group>=0 && group<CCTK_NumGroups());
+    *data = arrdata[group].info;
+    return 0;
+  }
+  
 } // namespace Carpet
diff --git a/Carpet/Carpet/src/carpet.h b/Carpet/Carpet/src/carpet.h
deleted file mode 100644
index 336d843f1..000000000
--- a/Carpet/Carpet/src/carpet.h
+++ /dev/null
@@ -1,8 +0,0 @@
-// $Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/Attic/carpet.h,v 1.2 2001/03/05 14:30:03 eschnett Exp $
-
-#include <mpi.h>
-
-#include "cctk.h"
-
-int CarpetStartup (void);
-MPI_Comm CarpetMPICommunicator (void);
diff --git a/Carpet/Carpet/src/carpet.hh b/Carpet/Carpet/src/carpet.hh
index f3005fb49..c8a55c201 100644
--- a/Carpet/Carpet/src/carpet.hh
+++ b/Carpet/Carpet/src/carpet.hh
@@ -1,198 +1,9 @@
-// $Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/carpet.hh,v 1.11 2001/07/04 12:29:48 schnetter Exp $
+// $Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/carpet.hh,v 1.12 2001/07/09 09:00:13 schnetter Exp $
 
-// It is assumed that the number of components of all arrays is equal
-// to the number of components of the grid functions, and that their
-// distribution onto the processors is the same, and that all
-// processors own the same number of components.
-
-// TODO: treat scalars as arrays with a dimension of zero
-
-#include <vector>
-
-#include "cctk.h"
-#include "cctk_Schedule.h"
-
-#include "Carpet/CarpetLib/src/dh.hh"
-#include "Carpet/CarpetLib/src/ggf.hh"
-#include "Carpet/CarpetLib/src/gh.hh"
-#include "Carpet/CarpetLib/src/th.hh"
+#include "carpet_public.hh"
 
 namespace Carpet {
   
-  
-  
-  const int dim = 3;
-  
-  
-  
-  // Handle from CCTK_RegisterGHExtension
-  extern int GHExtension;
-  
-  // Maximum number of refinement levels
-  extern int maxreflevels;
-  
-  // Refinement factor on finest grid
-  extern int maxreflevelfact;
-  
-  // Current iteration per refinement level
-  extern vector<int> iteration;
-  
-  // Current position on the grid hierarchy
-  extern int reflevel;
-  extern int mglevel;
-  extern int component;
-  
-  // Current refinement factor
-  extern int reflevelfact;
-  
-  // Time step on base grid
-  extern CCTK_REAL base_delta_time;
-  
-  
-  
-  // Data for scalars
-  struct scdesc {
-    vector<vector<vector<void*> > > data; // [var][rl][tl]
-  };
-  extern vector<scdesc> scdata;	// group
-  
-  // Data for arrays
-  struct arrdesc {
-    gh<dim>* hh;
-    th* tt;
-    dh<dim>* dd;
-    vector<generic_gf<dim>* > data; // [var]
-    int size[dim];
-  };
-  extern vector<arrdesc> arrdata; // [group]
-  
-  // Data for grid functions
-  
-  // The grid hierarchy
-  extern gh<dim>* hh;
-  extern th* tt;
-  extern dh<dim>* dd;
-  extern int gfsize[dim];
-  
-  struct gfdesc {
-    vector<generic_gf<dim>*> data; // [var]
-  };
-  extern vector<gfdesc> gfdata;	// [group]
-  
-  // Checksums
-  struct ckdesc {
-    bool valid;
-    int sum;
-  };
-  extern vector<vector<vector<vector<ckdesc> > > > checksums; // [n][rl][tl][c]
-  
-  
-  
-  // Scheduled functions
-  extern "C" {
-    int CarpetStartup();
-  }
-  
-  // Registered functions
-  void* SetupGH (tFleshConfig* fc, int convLevel, cGH* cgh);
-  
-  int Initialise (tFleshConfig* config);
-  int Evolve (tFleshConfig* config);
-  int Shutdown (tFleshConfig* config);
-  int CallFunction (void* function, cFunctionData* attribute, void* data);
-  
-  int SyncGroup (cGH* cgh, const char* groupname);
-  int EnableGroupStorage (cGH* cgh, const char* groupname);
-  int DisableGroupStorage (cGH* cgh, const char* groupname); 
-  int EnableGroupComm (cGH* cgh, const char* groupname);
-  int DisableGroupComm (cGH* cgh, const char* groupname);
-  int Barrier (cGH* cgh);
-  int Exit (cGH* cgh, int retval);
-  int Abort (cGH* cgh, int retval);
-  int MyProc (cGH* cgh);
-  int nProcs (cGH* cgh);
-  const int* ArrayGroupSizeB (cGH* cgh, int dir, int group,
-			      const char* groupname);
-  int QueryGroupStorageB (cGH* cgh, int group, const char* groupname);
-  
-  
-  
-  // Helper functions
-  void set_reflevel (cGH* cgh, int rl);
-  void set_mglevel (cGH* cgh, int ml);
-  void set_component (cGH* cgh, int c);
-  
-  
-  
-  // Refinement level iterator
-  
-#define BEGIN_REFLEVEL_LOOP(cgh)		\
-  do {						\
-    int _rl;					\
-    assert (reflevel==0);			\
-    for (;;) {					\
-      {
-#define END_REFLEVEL_LOOP(cgh)			\
-      }						\
-      if (reflevel==maxreflevels-1) break;	\
-      set_reflevel ((cgh), reflevel+1);		\
-    }						\
-    set_reflevel ((cgh), 0);			\
-    assert (reflevel==0);			\
-    _rl = 0;					\
-  } while (0)
-  
-  
-  
-  // Reverse refinement level iterator
-  
-#define BEGIN_REVERSE_REFLEVEL_LOOP(cgh)	\
-  do {						\
-    int _rrl;					\
-    assert (reflevel==0);			\
-    set_reflevel ((cgh), maxreflevels-1);	\
-    for (;;) {					\
-      {
-#define END_REVERSE_REFLEVEL_LOOP(cgh)		\
-      }						\
-      if (reflevel==0) break;			\
-      set_reflevel ((cgh), reflevel-1);		\
-    }						\
-    assert (reflevel==0);			\
-    _rrl = 0;					\
-  } while (0)
-  
-  
-  
-  // Component iterator
-  
-#define BEGIN_COMPONENT_LOOP(cgh)		\
-  do {						\
-    int _cl;					\
-    assert (component==-1);			\
-    set_component ((cgh), 0);			\
-    for (;;) {					\
-      {
-#define END_COMPONENT_LOOP(cgh)				\
-      }							\
-      if (component==hh->components(reflevel)-1) break;	\
-      set_component ((cgh), component+1);		\
-    }							\
-    set_component ((cgh), -1);				\
-    assert (component==-1);				\
-    _cl = 0;						\
-  } while (0)
-  
-  
-  
-  extern "C" {
-    MPI_Comm CarpetMPICommunicator();
-  }
-  
-  
-  
-  // These are private; don't use these from the outside
-  
   void Recompose (cGH* cgh);
   void CycleTimeLevels (cGH* cgh);
   void Restrict (cGH* cgh);
diff --git a/Carpet/Carpet/src/carpet_public.h b/Carpet/Carpet/src/carpet_public.h
index 87c9130bc..168ef725b 100644
--- a/Carpet/Carpet/src/carpet_public.h
+++ b/Carpet/Carpet/src/carpet_public.h
@@ -1,113 +1,11 @@
-/* $Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/carpet_public.h,v 1.15 2004/06/16 16:36:02 schnetter Exp $ */
-
-#ifndef CARPET_PUBLIC_H
-#define CARPET_PUBLIC_H
+/* $Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/carpet_public.h,v 1.1 2001/07/09 09:00:13 schnetter Exp $ */
 
 #include <mpi.h>
 
 #include "cctk.h"
 
+/* Scheduled functions */
+int CarpetStartup (void);
 
-
-/* Tell thorns that the Carpet routines exist */
-#define HAVE_CARPET
-
-
-
-#ifdef __cplusplus
-namespace Carpet {
-  extern "C" {
-#endif
-    
-    /* Carpet's GH extension */
-    struct CarpetGH {
-      
-#if 0
-      /* Maximum number of refinement levels */
-      int maxreflevels;
-      
-      /* Refinement levels */
-      int reflevels;
-      
-      /* Refinement factor */
-      int reffact;
-      
-      /* Refinement factor on finest possible grid */
-      int maxreflevelfact;
-      
-      /* Base multigrid level */
-      int basemglevel;
-      
-      /* Multigrid levels */
-      int mglevels;
-      
-      /* Multigrid factor */
-      int mgfact;
-      
-      /* Multigrid factor on coarsest grid */
-      int maxmglevelfact;
-#endif
-      
-      /* Maps */
-      int maps;
-      
-      
-      
-#if 0
-      /* Current position on the grid hierarchy */
-      int reflevel;
-      int mglevel;
-#endif
-      int map;
-#if 0
-      int component;
-      
-      /* Current refinement factor */
-      int reflevelfact;
-      
-      /* Current multigrid factor */
-      int mglevelfact;
-#endif
-      
-    };
-    
-    struct CarpetGH const * GetCarpetGH (const cGH * const cgh);
-    
-    
-    
-    /* Prolongation management */
-    CCTK_INT CarpetEnableProlongating (const CCTK_INT flag);
-    
-    
-    
-    /* Call a schedule group */
-    int CallScheduleGroup (cGH * const cgh, const char * const group);
-    
-    /* Call a local function */
-    int CallLocalFunction (cGH * const cgh,
-                           void (* const function) (cGH * const cgh));
-    int CallSinglemapFunction (cGH * const cgh,
-                               void (* const function) (cGH * const cgh));
-    int CallLevelFunction (cGH * const cgh,
-                           void (* const function) (cGH * const cgh));
-    int CallGlobalFunction (cGH * const cgh,
-                            void (* const function) (cGH * const cgh));
-    int CallMetaFunction (cGH * const cgh,
-                          void (* const function) (cGH * const cgh));
-    
-    
-    
-    /* Helper functions */
-    MPI_Comm CarpetMPIComm (void);
-    MPI_Datatype CarpetMPIDatatype (int vartype);
-    MPI_Datatype CarpetSimpleMPIDatatype (int vartype);
-    int CarpetSimpleMPIDatatypeLength (int vartype);
-    
-    
-    
-#ifdef __cplusplus
-  } /* extern "C" */
-} /* namespace Carpet */
-#endif
-
-#endif /* !defined(CARPET_PUBLIC_H) */
+/* Helper functions */
+MPI_Comm CarpetMPICommunicator (void);
diff --git a/Carpet/Carpet/src/carpet_public.hh b/Carpet/Carpet/src/carpet_public.hh
index fbe9d8c0f..5c12b3ce3 100644
--- a/Carpet/Carpet/src/carpet_public.hh
+++ b/Carpet/Carpet/src/carpet_public.hh
@@ -1,15 +1,182 @@
-// $Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/carpet_public.hh,v 1.40 2004/01/25 14:57:27 schnetter Exp $
+// $Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/carpet_public.hh,v 1.1 2001/07/09 09:00:14 schnetter Exp $
 
-#ifndef CARPET_PUBLIC_HH
-#define CARPET_PUBLIC_HH
+// It is assumed that the number of components of all arrays is equal
+// to the number of components of the grid functions, and that their
+// distribution onto the processors is the same, and that all
+// processors own the same number of components.
 
-// Stuff with C linkage
-#include "carpet_public.h"
+#include <vector>
+
+#include "cctk.h"
+#include "cctk_Schedule.h"
 
-// Other declarations
-#include "defines.hh"
-#include "functions.hh"
-#include "modes.hh"
-#include "variables.hh"
+#include "Carpet/CarpetLib/src/dh.hh"
+#include "Carpet/CarpetLib/src/ggf.hh"
+#include "Carpet/CarpetLib/src/gh.hh"
+#include "Carpet/CarpetLib/src/th.hh"
 
-#endif // !defined(CARPET_PUBLIC_HH)
+namespace Carpet {
+  
+  
+  
+  const int dim = 3;
+  
+  
+  
+  // Handle from CCTK_RegisterGHExtension
+  extern int GHExtension;
+  
+  // Maximum number of refinement levels
+  extern int maxreflevels;
+  
+  // Refinement factor on finest grid
+  extern int maxreflevelfact;
+  
+  // Current iteration per refinement level
+  extern vector<int> iteration;
+  
+  // Current position on the grid hierarchy
+  extern int reflevel;
+  extern int mglevel;
+  extern int component;
+  
+  // Current refinement factor
+  extern int reflevelfact;
+  
+  // Time step on base grid
+  extern CCTK_REAL base_delta_time;
+  
+  
+  
+  // Data for grid functions
+  
+  // The grid hierarchy
+  extern gh<dim>* hh;
+  extern th* tt;
+  extern dh<dim>* dd;
+  
+  // Data for scalars
+  extern gh<dim>* hh0;
+  extern th* tt0;
+  extern dh<dim>* dd0;
+  
+  // Data for everything
+  struct arrdesc {
+    // points to hh etc. for GF, and to hh0 etc. for SCALAR
+    // is unique for ARRAY
+    cGroupDynamicData info;
+    gh<dim>* hh;
+    th* tt;
+    dh<dim>* dd;
+    vector<generic_gf<dim>* > data; // [var]
+  };
+  extern vector<arrdesc> arrdata; // [group]
+  
+  
+  
+  // Checksums
+  struct ckdesc {
+    bool valid;
+    int sum;
+  };
+  extern vector<vector<vector<vector<ckdesc> > > > checksums; // [n][rl][tl][c]
+  
+  
+  
+  // Stuff with C linkage
+  extern "C" {
+#include "carpet_public.h"
+  }
+  
+  // Registered functions
+  void* SetupGH (tFleshConfig* fc, int convLevel, cGH* cgh);
+  
+  int Initialise (tFleshConfig* config);
+  int Evolve (tFleshConfig* config);
+  int Shutdown (tFleshConfig* config);
+  int CallFunction (void* function, cFunctionData* attribute, void* data);
+  
+  int SyncGroup (cGH* cgh, const char* groupname);
+  int EnableGroupStorage (cGH* cgh, const char* groupname);
+  int DisableGroupStorage (cGH* cgh, const char* groupname); 
+  int EnableGroupComm (cGH* cgh, const char* groupname);
+  int DisableGroupComm (cGH* cgh, const char* groupname);
+  int Barrier (cGH* cgh);
+  int Exit (cGH* cgh, int retval);
+  int Abort (cGH* cgh, int retval);
+  int MyProc (cGH* cgh);
+  int nProcs (cGH* cgh);
+  const int* ArrayGroupSizeB (cGH* cgh, int dir, int group,
+			      const char* groupname);
+  int QueryGroupStorageB (cGH* cgh, int group, const char* groupname);
+  int GroupDynamicData (cGH* cgh, int group, cGroupDynamicData* data);
+  
+  
+  
+  // Helper functions
+  void set_reflevel (cGH* cgh, int rl);
+  void set_mglevel (cGH* cgh, int ml);
+  void set_component (cGH* cgh, int c);
+  
+  
+  
+  // Refinement level iterator
+  
+#define BEGIN_REFLEVEL_LOOP(cgh)		\
+  do {						\
+    int _rl;					\
+    assert (reflevel==0);			\
+    for (;;) {					\
+      {
+#define END_REFLEVEL_LOOP(cgh)			\
+      }						\
+      if (reflevel==maxreflevels-1) break;	\
+      set_reflevel ((cgh), reflevel+1);		\
+    }						\
+    set_reflevel ((cgh), 0);			\
+    assert (reflevel==0);			\
+    _rl = 0;					\
+  } while (0)
+  
+  
+  
+  // Reverse refinement level iterator
+  
+#define BEGIN_REVERSE_REFLEVEL_LOOP(cgh)	\
+  do {						\
+    int _rrl;					\
+    assert (reflevel==0);			\
+    set_reflevel ((cgh), maxreflevels-1);	\
+    for (;;) {					\
+      {
+#define END_REVERSE_REFLEVEL_LOOP(cgh)		\
+      }						\
+      if (reflevel==0) break;			\
+      set_reflevel ((cgh), reflevel-1);		\
+    }						\
+    assert (reflevel==0);			\
+    _rrl = 0;					\
+  } while (0)
+  
+  
+  
+  // Component iterator
+  
+#define BEGIN_COMPONENT_LOOP(cgh)		\
+  do {						\
+    int _cl;					\
+    assert (component==-1);			\
+    set_component ((cgh), 0);			\
+    for (;;) {					\
+      {
+#define END_COMPONENT_LOOP(cgh)				\
+      }							\
+      if (component==hh->components(reflevel)-1) break;	\
+      set_component ((cgh), component+1);		\
+    }							\
+    set_component ((cgh), -1);				\
+    assert (component==-1);				\
+    _cl = 0;						\
+  } while (0)
+  
+} // namespace Carpet
diff --git a/Carpet/Carpet/src/helpers.cc b/Carpet/Carpet/src/helpers.cc
index c7af53a78..924a42d14 100644
--- a/Carpet/Carpet/src/helpers.cc
+++ b/Carpet/Carpet/src/helpers.cc
@@ -1,4 +1,5 @@
 #include <assert.h>
+#include <stdarg.h>
 #include <stdlib.h>
 
 #include <mpi.h>
@@ -10,7 +11,7 @@
 
 #include "carpet.hh"
 
-static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/helpers.cc,v 1.1 2001/07/04 12:29:48 schnetter Exp $";
+static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/helpers.cc,v 1.2 2001/07/09 09:00:15 schnetter Exp $";
 
 
 
@@ -59,58 +60,6 @@ namespace Carpet {
   
   
   
-  const int* ArrayGroupSizeB (cGH* cgh, int dir, int group,
-			      const char* groupname)
-  {
-    static const int zero = 0, one = 1;
-    
-    if (component == -1) {
-      // global routine
-      return &zero;
-    }
-    
-    if (groupname) {
-      group = CCTK_GroupIndex(groupname);
-    }
-    assert (group>=0 && group<CCTK_NumGroups());
-    
-    const int gpdim = CCTK_GroupDimI(group);
-    
-    assert (dir>=0 && dir<gpdim);
-    
-    if (CCTK_QueryGroupStorageI(cgh, group)) {
-      
-      const int var = CCTK_FirstVarIndexI(group);
-      assert (var>=0 && var<CCTK_NumVars());
-      
-      switch (CCTK_GroupTypeFromVarI(var)) {
-	
-      case CCTK_SCALAR:
-	assert (group<(int)scdata.size());
-	return &one;
-	
-      case CCTK_ARRAY:
-	assert (group<(int)arrdata.size());
-	return &arrdata[group].size[dir];
-	
-      case CCTK_GF:
-	assert (group<(int)gfdata.size());
-	return &gfsize[dir];
-	
-      default:
-	abort();
-      }
-      
-    } else {
-      
-      // no storage
-      return &zero;
-      
-    }
-  }
-  
-  
-  
   MPI_Comm CarpetMPICommunicator ()
   {
     return dist::comm;
@@ -207,6 +156,16 @@ namespace Carpet {
 	    + dd->lghosts + dd->ughosts)[d] - 1) * reflevelfact + 1;
       cgh->cctk_levfac[d] = reflevelfact;
     }
+    for (int group=0; group<CCTK_NumGroups(); ++group) {
+      const bbox<int,dim>& base = arrdata[group].hh->baseextent;
+      for (int d=0; d<dim; ++d) {
+	((int*)arrdata[group].info.gsh)[d]
+	  = (((base.shape() / base.stride()
+	       + arrdata[group].dd->lghosts + arrdata[group].dd->ughosts)[d]
+	      - 1)
+	     * reflevelfact + 1);
+      }
+    }
   }
   
   
@@ -240,25 +199,13 @@ namespace Carpet {
 	  cgh->cctk_lssh[CCTK_LSSH_IDX(stg,d)] = 0xdeadbeef;
 	}
       }
-      
-      // Set local grid function and array sizes
-      for (int d=0; d<dim; ++d) {
-	gfsize[d] = 0xdeadbeef;
-      }
       for (int group=0; group<CCTK_NumGroups(); ++group) {
-	const int n0 = CCTK_FirstVarIndexI(group);
-	switch (CCTK_GroupTypeFromVarI(n0)) {
-	case CCTK_SCALAR:
-	  break;
-	case CCTK_ARRAY:
-	  for (int d=0; d<dim; ++d) {
-	    arrdata[group].size[d] = 0xdeadbeef;
-	  }
-	  break;
-	case CCTK_GF:
-	  break;
-	default:
-	  abort();
+	for (int d=0; d<dim; ++d) {
+	  ((int*)arrdata[group].info.lsh)[d]      = 0xdeadbeef;
+	  ((int*)arrdata[group].info.bbox)[2*d  ] = 0xdeadbeef;
+	  ((int*)arrdata[group].info.bbox)[2*d+1] = 0xdeadbeef;
+	  ((int*)arrdata[group].info.lbnd)[d]     = 0xdeadbeef;
+	  ((int*)arrdata[group].info.ubnd)[d]     = 0xdeadbeef;
 	}
       }
       
@@ -271,36 +218,8 @@ namespace Carpet {
 	  const int var   = n - CCTK_FirstVarIndexI(group);
 	  assert (var>=0);
 	  
-	  if (CCTK_QueryGroupStorageI(cgh, group)) {
-	    // Group has storage
-	    
-	    switch (CCTK_GroupTypeFromVarI(n)) {
-	      
-	    case CCTK_SCALAR:
-	      // Scalar variables can be accessed
-	      assert (group<(int)scdata.size());
-	      assert (var<(int)scdata[group].data.size());
-	      assert (reflevel<(int)scdata[group].data[var].size());
-	      assert (tl<(int)scdata[group].data[var][reflevel].size());
-	      cgh->data[n][tl] = scdata[group].data[var][reflevel][tl];
-	      break;
-	      
-	    case CCTK_ARRAY:
-	    case CCTK_GF:
-	      // Arrays and grid functions cannot be accessed
-	      cgh->data[n][tl] = 0;
-	      break;
-	      
-	    default:
-	      abort();
-	    }
-	    
-	  } else {
-	    // Group has no storage
-	    
-	    cgh->data[n][tl] = 0;
-	    
-	  }
+	  // Scalars, arrays, and grid functions cannot be accessed
+	  cgh->data[n][tl] = 0;
 	  
 	} // for tl
       }	// for n
@@ -335,34 +254,36 @@ namespace Carpet {
 	  cgh->cctk_lssh[CCTK_LSSH_IDX(stg,d)] = cgh->cctk_lsh[d];
 	}
       }
-      
-      // Set local grid function and array sizes
-      const bbox<int,dim> ext =
-	dd->boxes[reflevel][component][mglevel].exterior;
-      for (int d=0; d<dim; ++d) {
-	gfsize[d] = ext.shape()[d] / ext.stride()[d];
-      }
-      
       for (int group=0; group<CCTK_NumGroups(); ++group) {
-	const int n0 = CCTK_FirstVarIndexI(group);
-	switch (CCTK_GroupTypeFromVarI(n0)) {
-	case CCTK_SCALAR:
-	  break;
-	case CCTK_ARRAY: {
-	  assert (reflevel < (int)arrdata[group].dd->boxes.size());
-	  assert (component < (int)arrdata[group].dd->boxes[reflevel].size());
-	  assert (mglevel
-		  < (int)arrdata[group].dd->boxes[reflevel][component].size());
-	  const bbox<int,dim> ext =
-	    arrdata[group].dd->boxes[reflevel][component][mglevel].exterior;
-	  for (int d=0; d<dim; ++d) {
-	    arrdata[group].size[d] = ext.shape()[d] / ext.stride()[d];
-	  }
-	}
-	case CCTK_GF:
-	  break;
-	default:
-	  abort();
+	for (int d=0; d<dim; ++d) {
+	  const bbox<int,dim>& ext
+	    = arrdata[group].dd->boxes[reflevel][component][mglevel].exterior;
+	  ((int*)arrdata[group].info.lsh)[d]
+	    = (ext.shape() / ext.stride())[d];
+	  ((int*)arrdata[group].info.lbnd)[d]
+	    = (ext.lower() / ext.stride())[d];
+	  ((int*)arrdata[group].info.ubnd)[d]
+	    = (ext.upper() / ext.stride())[d];
+	  assert (arrdata[group].info.lsh[d]>=0
+		  && arrdata[group].info.lsh[d]<=arrdata[group].info.gsh[d]);
+	  assert (arrdata[group].info.lbnd[d]>=0
+		  && arrdata[group].info.ubnd[d]<arrdata[group].info.gsh[d]);
+	  assert (arrdata[group].info.lbnd[d]<=arrdata[group].info.ubnd[d]+1);
+	  // No outer boundaries on the finer grids
+	  ((int*)arrdata[group].info.bbox)[2*d  ]
+	    = reflevel==0 && arrdata[group].info.lbnd[d] == 0;
+	  ((int*)arrdata[group].info.bbox)[2*d+1]
+	    = (reflevel==0
+	       && arrdata[group].info.ubnd[d] == arrdata[group].info.gsh[d]-1);
+#if 0
+	  // Do allow outer boundaries on the finer grids (but this is
+	  // generally inconsistent -- c. f. periodicity)
+	  const bbox<int,dim>& base = arrdata[group].hh->baseextent;
+	  ((int*)arrdata[group].info.bbox)[2*d  ]
+	    = (ext.lower() < base.lower())[d];
+	  ((int*)arrdata[group].info.bbox)[2*d+1]
+	    = (ext.upper() > base.upper())[d];
+#endif
 	}
       }
       
@@ -381,37 +302,12 @@ namespace Carpet {
 	  if (CCTK_QueryGroupStorageI(cgh, group)) {
 	    // Group has storage
 	    
-	    switch (CCTK_GroupTypeFromVarI(n)) {
-	      
-	    case CCTK_SCALAR:
-	      assert (group<(int)scdata.size());
-	      assert (var<(int)scdata[group].data.size());
-	      assert (reflevel<(int)scdata[group].data[var].size());
-	      assert (tl<(int)scdata[group].data[var][reflevel].size());
-	      cgh->data[n][tl] = scdata[group].data[var][reflevel][tl];
-	      break;
-	      
-	    case CCTK_ARRAY:
-	      assert (group<(int)arrdata.size());
-	      assert (var<(int)arrdata[group].data.size());
-	      cgh->data[n][tl]
-		= ((*arrdata[group].data[var])
-		   (-tl, reflevel, component, mglevel)->storage());
-	      break;
-	      
-	    case CCTK_GF:
-	      assert (group<(int)gfdata.size());
-	      assert (var<(int)gfdata[group].data.size());
-	      cgh->data[n][tl]
-		= ((*gfdata[group].data[var])
-		   (-tl, reflevel, component, mglevel)->storage());
-	      break;
-	      
-	    default:
-	      abort();
-	    }
-	    if (CCTK_GroupTypeFromVarI(n)==CCTK_SCALAR
-		|| hh->is_local(reflevel,component)) {
+	    assert (group<(int)arrdata.size());
+	    assert (var<(int)arrdata[group].data.size());
+	    cgh->data[n][tl]
+	      = ((*arrdata[group].data[var])
+		 (-tl, reflevel, component, mglevel)->storage());
+	    if (hh->is_local(reflevel,component)) {
 	      assert (cgh->data[n][tl]);
 	    } else {
 	      assert (! cgh->data[n][tl]);
diff --git a/Carpet/Carpet/src/variables.cc b/Carpet/Carpet/src/variables.cc
index f884950f1..91ee10bb6 100644
--- a/Carpet/Carpet/src/variables.cc
+++ b/Carpet/Carpet/src/variables.cc
@@ -5,7 +5,7 @@
 
 #include "carpet.hh"
 
-static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/variables.cc,v 1.1 2001/07/04 12:29:48 schnetter Exp $";
+static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/Carpet/Carpet/src/variables.cc,v 1.2 2001/07/09 09:00:15 schnetter Exp $";
 
 
 
@@ -40,21 +40,20 @@ namespace Carpet {
   
   
   
-  // Data for scalars
-  vector<scdesc> scdata;	// [group]
-  
-  // Data for arrays
-  // TODO: have replicated arrays
-  vector<arrdesc> arrdata;	// [group]
+  // Data for grid functions
   
   // The grid hierarchy
   gh<dim>* hh;
   th* tt;
   dh<dim>* dd;
-  int gfsize[dim];
   
-  // Data for grid functions
-  vector<gfdesc> gfdata;	// [group]
+  // Data for scalars
+  gh<dim>* hh0;
+  th* tt0;
+  dh<dim>* dd0;
+
+    // Data for everything
+  vector<arrdesc> arrdata;	// [group]
   
   // Checksums
   vector<vector<vector<vector<ckdesc> > > > checksums; // [n][rl][tl][c]
diff --git a/Carpet/CarpetIOASCII/interface.ccl b/Carpet/CarpetIOASCII/interface.ccl
index b199f1942..59a56d523 100644
--- a/Carpet/CarpetIOASCII/interface.ccl
+++ b/Carpet/CarpetIOASCII/interface.ccl
@@ -1,4 +1,6 @@
 # Interface definition for thorn CarpetIOASCII
-# $Header: /home/eschnett/C/carpet/Carpet/Carpet/CarpetIOASCII/interface.ccl,v 1.2 2001/03/05 14:30:22 eschnett Exp $
+# $Header: /home/eschnett/C/carpet/Carpet/Carpet/CarpetIOASCII/interface.ccl,v 1.3 2001/07/09 09:00:17 schnetter Exp $
 
 implements: IOASCII
+
+uses include header: carpet.hh
diff --git a/Carpet/CarpetIOASCII/src/ioascii.cc b/Carpet/CarpetIOASCII/src/ioascii.cc
index f6a5a049e..4f8df4840 100644
--- a/Carpet/CarpetIOASCII/src/ioascii.cc
+++ b/Carpet/CarpetIOASCII/src/ioascii.cc
@@ -20,11 +20,11 @@
 #include "Carpet/CarpetLib/src/gf.hh"
 #include "Carpet/CarpetLib/src/ggf.hh"
 
-#include "Carpet/Carpet/src/carpet.hh"
+#include "carpet.hh"
 
 #include "ioascii.hh"
 
-static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/Carpet/CarpetIOASCII/src/ioascii.cc,v 1.15 2001/07/04 13:55:23 schnetter Exp $";
+static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/Carpet/CarpetIOASCII/src/ioascii.cc,v 1.16 2001/07/09 09:00:19 schnetter Exp $";
 
 
 
@@ -129,71 +129,154 @@ int CarpetIOASCII<outdim>
   const int n = CCTK_VarIndex(varname);
   assert (n>=0 && n<CCTK_NumVars());
   const int group = CCTK_GroupIndexFromVarI (n);
-  assert (group>=0 && group<(int)Carpet::gfdata.size());
+  assert (group>=0 && group<(int)Carpet::arrdata.size());
   const int n0 = CCTK_FirstVarIndexI(group);
   assert (n0>=0 && n0<CCTK_NumVars());
   const int var = n - n0;
   assert (var>=0 && var<CCTK_NumVars());
   const int tl = 0;
   
-  switch (CCTK_GroupTypeI(group)) {
-    
-  case CCTK_SCALAR: {
-    // Don't output scalars
-    CCTK_VWarn (2, __LINE__, __FILE__, CCTK_THORNSTRING,
-		"Cannout output variable \"%s\" because it is a scalar",
+  // Check for storage
+  if (! CCTK_QueryGroupStorageI(cgh, group)) {
+    CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING,
+		"Cannot output variable \"%s\" because it has no storage",
 		varname);
     return 0;
   }
+  
+  // Create the output directory
+  const char* myoutdir = GetStringParameter("outdir%dD", outdir);
+  if (CCTK_MyProc(cgh)==0) {
+    CCTK_CreateDirectory (0755, myoutdir);
+  }
+  
+  // Loop over all direction combinations
+  vect<int,outdim> dirs;
+  for (int d=0; d<outdim; ++d) dirs[d] = 0;
+  
+  bool done;
+  do {
     
-  case CCTK_ARRAY:
-  case CCTK_GF: {
-    
-    // Check for storage
-    if (! CCTK_QueryGroupStorageI(cgh, group)) {
-      CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING,
-		  "Cannot output variable \"%s\" because it has no storage",
-		  varname);
-      return 0;
-    }
-    
-    // Create the output directory
-    const char* myoutdir = GetStringParameter("outdir%dD", outdir);
-    if (CCTK_MyProc(cgh)==0) {
-      CCTK_CreateDirectory (0755, myoutdir);
+    // Output each combination only once
+    bool ascending = true;
+    for (int d1=0; d1<outdim; ++d1) {
+      for (int d2=d1+1; d2<outdim; ++d2) {
+	ascending = ascending && dirs[d1] < dirs[d2];
+      }
     }
     
-    // Loop over all direction combinations
-    vect<int,outdim> dirs;
-    for (int d=0; d<outdim; ++d) dirs[d] = 0;
-    
-    bool done;
-    do {
+    // Skip output if the dimensions are not ascending
+    if (ascending) {
       
-      // Output each combination only once
-      bool ascending = true;
-      for (int d1=0; d1<outdim; ++d1) {
-	for (int d2=d1+1; d2<outdim; ++d2) {
-	  ascending = ascending && dirs[d1] < dirs[d2];
+      // If this output is desired at all
+      bool desired;
+      switch (outdim) {
+      case 1:
+	switch (dirs[0]) {
+	case 0:
+	  desired = out1D_x;
+	  break;
+	case 1:
+	  desired = out1D_y;
+	  break;
+	case 2:
+	  desired = out1D_z;
+	  break;
+	default:
+	  abort();
+	}
+	break;
+      case 2:
+	if (dirs[0]==0 && dirs[1]==1) {
+	  desired = out2D_xy;
+	} else if (dirs[0]==0 && dirs[1]==2) {
+	  desired = out2D_xz;
+	} else if (dirs[0]==1 && dirs[1]==2) {
+	  desired = out2D_yz;
+	} else {
+	  abort();
 	}
+	break;
+      case 3:
+	// Output is always desired (if switched on)
+	desired = true;
+	break;
+      default:
+	abort();
       }
       
-      // Skip output if the dimensions are not ascending
-      if (ascending) {
+      // Skip output if not desired
+      if (desired) {
+	
+	// Invent a file name
+	char* const filename
+	  = (char*)alloca(strlen(myoutdir)+strlen(alias)+100);
+	sprintf (filename, "%s/%s.", myoutdir, alias);
+	for (int d=0; d<outdim; ++d) {
+	  assert (dirs[d]>=0 && dirs[d]<3);
+	  const char* const coords = "xyz";
+	  sprintf (filename, "%s%c", filename, coords[dirs[d]]);
+	}
+	const char* const suffixes = "lpv";
+	sprintf (filename, "%s%c", filename, suffixes[outdim-1]);
+	
+	// If this is the first time, then write a nice header on
+	// the root processor
+	if (do_truncate[n]) {
+	  if (CCTK_MyProc(cgh)==0) {
+	    struct stat fileinfo;
+	    if (! IOUtil_RestartFromRecovery(cgh)
+		|| stat(filename, &fileinfo)!=0) {
+	      ofstream file(filename, ios::out | ios::trunc);
+	      assert (file.good());
+	      file << "# " << varname;
+	      for (int d=0; d<outdim; ++d) {
+		file << " " << "xyz"[dirs[d]];
+	      }
+	      file << " (" << alias << ")" << endl;
+	      file << "#" << endl;
+	      file.close();
+	      assert (file.good());
+	    }
+	  }
+	}
+	
+	assert (outdim <= CCTK_GroupDimI(group));
 	
-	// If this output is desired at all
-	bool desired;
+	// Find the output offset
+	vect<int,dim> offset(0);
 	switch (outdim) {
 	case 1:
 	  switch (dirs[0]) {
 	  case 0:
-	    desired = out1D_x;
+	    offset[1] = GetGridOffset (cgh, 2,
+				       "out%dD_xline_yi", "out_xline_yi",
+				       "out%dD_xline_y",  "out_xline_y",
+				       out_xline_y);
+	    offset[2] = GetGridOffset (cgh, 3,
+				       "out%dD_xline_zi", "out_xline_zi",
+				       "out%dD_xline_z",  "out_xline_z",
+				       out_xline_z);
 	    break;
 	  case 1:
-	    desired = out1D_y;
+	    offset[0] = GetGridOffset (cgh, 1,
+				       "out%dD_yline_xi", "out_yline_xi",
+				       "out%dD_yline_x",  "out_yline_x",
+				       out_yline_x);
+	    offset[2] = GetGridOffset (cgh, 3,
+				       "out%dD_yline_zi", "out_yline_zi",
+				       "out%dD_yline_z",  "out_yline_z",
+				       out_yline_z);
 	    break;
 	  case 2:
-	    desired = out1D_z;
+	    offset[0] = GetGridOffset (cgh, 1,
+				       "out%dD_zline_xi", "out_zline_xi",
+				       "out%dD_zline_x",  "out_zline_x",
+				       out_zline_x);
+	    offset[1] = GetGridOffset (cgh, 2,
+				       "out%dD_zline_yi", "out_zline_yi",
+				       "out%dD_zline_y",  "out_zline_y",
+				       out_zline_y);
 	    break;
 	  default:
 	    abort();
@@ -201,194 +284,78 @@ int CarpetIOASCII<outdim>
 	  break;
 	case 2:
 	  if (dirs[0]==0 && dirs[1]==1) {
-	    desired = out2D_xy;
+	    offset[2] = GetGridOffset
+	      (cgh, 3,
+	       "out%dD_xyplane_zi", "out_xyplane_zi",
+	       "out%dD_xyplane_z",  "out_xyplane_z",
+	       out_xyplane_z);
 	  } else if (dirs[0]==0 && dirs[1]==2) {
-	    desired = out2D_xz;
+	    offset[1] = GetGridOffset
+	      (cgh, 2,
+	       "out%dD_xzplane_yi", "out_xzplane_yi",
+	       "out%dD_xzplane_y",  "out_xzplane_y",
+	       out_xzplane_y);
 	  } else if (dirs[0]==1 && dirs[1]==2) {
-	    desired = out2D_yz;
+	    offset[0] = GetGridOffset
+	      (cgh, 1,
+	       "out%dD_yzplane_xi", "out_yzplane_xi",
+	       "out%dD_yzplane_x",  "out_yzplane_x",
+	       out_yzplane_x);
 	  } else {
 	    abort();
 	  }
 	  break;
 	case 3:
-	  // Output is always desired (if switched on)
-	  desired = true;
+	  // The offset doesn't matter in this case
 	  break;
 	default:
 	  abort();
 	}
 	
-	// Skip output if not desired
-	if (desired) {
+	// Traverse all components on this refinement and multigrid
+	// level
+	BEGIN_COMPONENT_LOOP(cgh) {
 	  
-	  // Invent a file name
-	  char* const filename
-	    = (char*)alloca(strlen(myoutdir)+strlen(alias)+100);
-	  sprintf (filename, "%s/%s.", myoutdir, alias);
-	  for (int d=0; d<outdim; ++d) {
-	    assert (dirs[d]>=0 && dirs[d]<3);
-	    const char* const coords = "xyz";
-	    sprintf (filename, "%s%c", filename, coords[dirs[d]]);
-	  }
-	  const char* const suffixes = "lpv";
-	  sprintf (filename, "%s%c", filename, suffixes[outdim-1]);
+	  generic_gf<dim>* ff = 0;
 	  
-	  // If this is the first time, then write a nice header on
-	  // the root processor
-	  if (do_truncate[n]) {
-	    if (CCTK_MyProc(cgh)==0) {
-	      struct stat fileinfo;
-	      if (! IOUtil_RestartFromRecovery(cgh)
-		  || stat(filename, &fileinfo)!=0) {
-		ofstream file(filename, ios::out | ios::trunc);
-		assert (file.good());
-		file << "# " << varname;
-		for (int d=0; d<outdim; ++d) {
-		  file << " " << "xyz"[dirs[d]];
-		}
-		file << " (" << alias << ")" << endl;
-		file << "#" << endl;
-		file.close();
-		assert (file.good());
-	      }
-	    }
-	  }
-	  
-	  assert (outdim <= CCTK_GroupDimI(group));
-	  
-	  // Find the output offset
-	  vect<int,dim> offset(0);
-	  switch (outdim) {
-	  case 1:
-	    switch (dirs[0]) {
-	    case 0:
-	      offset[1] = GetGridOffset (cgh, 2,
-					 "out%dD_xline_yi", "out_xline_yi",
-					 "out%dD_xline_y",  "out_xline_y",
-					 out_xline_y);
-	      offset[2] = GetGridOffset (cgh, 3,
-					 "out%dD_xline_zi", "out_xline_zi",
-					 "out%dD_xline_z",  "out_xline_z",
-					 out_xline_z);
-	      break;
-	    case 1:
-	      offset[0] = GetGridOffset (cgh, 1,
-					 "out%dD_yline_xi", "out_yline_xi",
-					 "out%dD_yline_x",  "out_yline_x",
-					 out_yline_x);
-	      offset[2] = GetGridOffset (cgh, 3,
-					 "out%dD_yline_zi", "out_yline_zi",
-					 "out%dD_yline_z",  "out_yline_z",
-					 out_yline_z);
-	      break;
-	    case 2:
-	      offset[0] = GetGridOffset (cgh, 1,
-					 "out%dD_zline_xi", "out_zline_xi",
-					 "out%dD_zline_x",  "out_zline_x",
-					 out_zline_x);
-	      offset[1] = GetGridOffset (cgh, 2,
-					 "out%dD_zline_yi", "out_zline_yi",
-					 "out%dD_zline_y",  "out_zline_y",
-					 out_zline_y);
-	      break;
-	    default:
-	      abort();
-	    }
-	    break;
-	  case 2:
-	    if (dirs[0]==0 && dirs[1]==1) {
-	      offset[2] = GetGridOffset
-		(cgh, 3,
-		 "out%dD_xyplane_zi", "out_xyplane_zi",
-		 "out%dD_xyplane_z",  "out_xyplane_z",
-		 out_xyplane_z);
-	    } else if (dirs[0]==0 && dirs[1]==2) {
-	      offset[1] = GetGridOffset
-		(cgh, 2,
-		 "out%dD_xzplane_yi", "out_xzplane_yi",
-		 "out%dD_xzplane_y",  "out_xzplane_y",
-		 out_xzplane_y);
-	    } else if (dirs[0]==1 && dirs[1]==2) {
-	      offset[0] = GetGridOffset
-		(cgh, 1,
-		 "out%dD_yzplane_xi", "out_yzplane_xi",
-		 "out%dD_yzplane_x",  "out_yzplane_x",
-		 out_yzplane_x);
-	    } else {
-	      abort();
-	    }
-	    break;
-	  case 3:
-	    // The offset doesn't matter in this case
-	    break;
-	  default:
-	    abort();
-	  }
+	  assert (var < (int)arrdata[group].data.size());
+	  ff = (generic_gf<dim>*)arrdata[group].data[var];
 	  
-	  // Traverse all components on this refinement and multigrid
-	  // level
-	  BEGIN_COMPONENT_LOOP(cgh) {
-	    
-	    generic_gf<dim>* ff = 0;
-	    
-	    switch (CCTK_GroupTypeI(group)) {
-	      
-	    case CCTK_ARRAY:
-	      assert (var < (int)arrdata[group].data.size());
-	      ff = (generic_gf<dim>*)arrdata[group].data[var];
-	      break;
-	      
-	    case CCTK_GF:
-	      assert (var < (int)gfdata[group].data.size());
-	      ff = (generic_gf<dim>*)gfdata[group].data[var];
-	      break;
-	      
-	    default:
-	      abort();
-	    }
-	    
-	    const generic_data<dim>* const data
-	      = (*ff) (tl, reflevel, component, mglevel);
-	    const bbox<int,dim> ext = data->extent();
-	    const vect<int,dim> offset1 = offset * ext.stride();
-	    
-	    data->write_ascii (filename, cgh->cctk_iteration, offset1, dirs,
-			       tl, reflevel, component, mglevel);
-	    
-	  } END_COMPONENT_LOOP(cgh);
+	  const generic_data<dim>* const data
+	    = (*ff) (tl, reflevel, component, mglevel);
+	  const bbox<int,dim> ext = data->extent();
+	  const vect<int,dim> offset1 = offset * ext.stride();
 	  
-	  // Append EOL after every complete set of components
-	  if (CCTK_MyProc(cgh)==0) {
-	    ofstream file(filename, ios::app);
-	    assert (file.good());
-	    file << endl;
-	    file.close();
-	    assert (file.good());
-	  }
+	  data->write_ascii (filename, cgh->cctk_iteration, offset1, dirs,
+			     tl, reflevel, component, mglevel);
 	  
-	} // if (desired)
+	} END_COMPONENT_LOOP(cgh);
 	
-      } // if (ascending)
-      
-      // Next direction combination
-      done = true;
-      for (int d=0; d<outdim; ++d) {
-	++dirs[d];
-	if (dirs[d]<CCTK_GroupDimI(group)) {
-	  done = false;
-	  break;
+	// Append EOL after every complete set of components
+	if (CCTK_MyProc(cgh)==0) {
+	  ofstream file(filename, ios::app);
+	  assert (file.good());
+	  file << endl;
+	  file.close();
+	  assert (file.good());
 	}
-	dirs[d] = 0;
-      }
+	
+      } // if (desired)
       
-    } while (! done);		// all directions
+    } // if (ascending)
     
-    break;
-  }
+      // Next direction combination
+    done = true;
+    for (int d=0; d<outdim; ++d) {
+      ++dirs[d];
+      if (dirs[d]<CCTK_GroupDimI(group)) {
+	done = false;
+	break;
+      }
+      dirs[d] = 0;
+    }
     
-  default:
-    abort();
-  }
+  } while (! done);		// all directions
   
   // Don't truncate again
   do_truncate[n] = false;
diff --git a/Carpet/CarpetSlab/src/carpetslab.cc b/Carpet/CarpetSlab/src/carpetslab.cc
index 0bc745d3b..4da5a813f 100644
--- a/Carpet/CarpetSlab/src/carpetslab.cc
+++ b/Carpet/CarpetSlab/src/carpetslab.cc
@@ -1,4 +1,4 @@
-// $Header: /home/eschnett/C/carpet/Carpet/Carpet/CarpetSlab/src/Attic/carpetslab.cc,v 1.10 2001/07/04 12:29:52 schnetter Exp $
+// $Header: /home/eschnett/C/carpet/Carpet/Carpet/CarpetSlab/src/Attic/carpetslab.cc,v 1.11 2001/07/09 09:00:24 schnetter Exp $
 
 #include <alloca.h>
 #include <assert.h>
@@ -18,7 +18,7 @@
 
 #include "carpetslab.hh"
 
-static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/Carpet/CarpetSlab/src/Attic/carpetslab.cc,v 1.10 2001/07/04 12:29:52 schnetter Exp $";
+static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/Carpet/CarpetSlab/src/Attic/carpetslab.cc,v 1.11 2001/07/09 09:00:24 schnetter Exp $";
 
 
 
@@ -108,28 +108,13 @@ namespace CarpetSlab {
     const gh<dim>* myhh;
     const dh<dim>* mydd;
     const generic_gf<dim>* myff;
-    switch (gp.grouptype) {
-    case CCTK_SCALAR:
-      abort();
-    case CCTK_ARRAY:
-      assert (group < (int)arrdata.size());
-      myhh = arrdata[group].hh;
-      mydd = arrdata[group].dd;
-      assert (var < (int)arrdata[group].data.size());
-      myff = arrdata[group].data[var];
-      break;
-    case CCTK_GF:
-      myhh = hh;
-      mydd = Carpet::dd;	// dd is int dd above for old C++ compilers
-      assert (group < (int)gfdata.size());
-      assert (var < (int)gfdata[group].data.size());
-      myff = gfdata[group].data[var];
-      break;
-    default:
-      abort();
-    }
+    assert (group < (int)arrdata.size());
+    myhh = arrdata[group].hh;
     assert (myhh);
+    mydd = arrdata[group].dd;
     assert (mydd);
+    assert (var < (int)arrdata[group].data.size());
+    myff = arrdata[group].data[var];
     assert (myff);
     
     // Detemine collecting processor
diff --git a/Carpet/CarpetTest/interface.ccl b/Carpet/CarpetTest/interface.ccl
index eb5323639..55cd937c5 100644
--- a/Carpet/CarpetTest/interface.ccl
+++ b/Carpet/CarpetTest/interface.ccl
@@ -1,5 +1,5 @@
 # Interface definition for thorn CarpetTest
-# $Header: /home/eschnett/C/carpet/Carpet/Carpet/CarpetTest/interface.ccl,v 1.1 2001/07/04 12:29:53 schnetter Exp $
+# $Header: /home/eschnett/C/carpet/Carpet/Carpet/CarpetTest/interface.ccl,v 1.2 2001/07/09 09:00:26 schnetter Exp $
 
 implements: CarpetTest
 
@@ -22,3 +22,8 @@ CCTK_REAL arrg1 type=ARRAY dim=1 size=i8
 {
   arr1
 } "1D array"
+
+CCTK_REAL scg type=SCALAR
+{
+  sc
+} "scalar"
diff --git a/Carpet/CarpetTest/src/carpettest_check_arguments.F77 b/Carpet/CarpetTest/src/carpettest_check_arguments.F77
index d24f2a391..9a3a08351 100644
--- a/Carpet/CarpetTest/src/carpettest_check_arguments.F77
+++ b/Carpet/CarpetTest/src/carpettest_check_arguments.F77
@@ -1,4 +1,5 @@
-c     $Header: /home/eschnett/C/carpet/Carpet/Carpet/CarpetTest/src/carpettest_check_arguments.F77,v 1.2 2001/07/04 13:55:25 schnetter Exp $
+c     -*-Fortran-*-
+c     $Header: /home/eschnett/C/carpet/Carpet/Carpet/CarpetTest/src/carpettest_check_arguments.F77,v 1.3 2001/07/09 09:00:27 schnetter Exp $
 
 #include "cctk.h"
 #include "cctk_Arguments.h"
@@ -13,6 +14,7 @@ c     $Header: /home/eschnett/C/carpet/Carpet/Carpet/CarpetTest/src/carpettest_c
       print *, "arrg3 ", arrg30, arrg31, arrg32
       print *, "arrg2 ", arrg20, arrg21
       print *, "arrg1 ", arrg10
+      print *, "scg"
       print *
       do k=1,gfg2
          do j=1,gfg1
@@ -36,4 +38,5 @@ c     $Header: /home/eschnett/C/carpet/Carpet/Carpet/CarpetTest/src/carpettest_c
       do i=1,arrg10
          arr1(i) = i
       end do
+      sc = 42
       end
diff --git a/Carpet/CarpetTest/src/carpettest_check_sizes.c b/Carpet/CarpetTest/src/carpettest_check_sizes.c
index 79ca08929..c4e17baf7 100644
--- a/Carpet/CarpetTest/src/carpettest_check_sizes.c
+++ b/Carpet/CarpetTest/src/carpettest_check_sizes.c
@@ -1,4 +1,4 @@
-/* $Header: /home/eschnett/C/carpet/Carpet/Carpet/CarpetTest/src/carpettest_check_sizes.c,v 1.1 2001/07/04 12:29:54 schnetter Exp $ */
+/* $Header: /home/eschnett/C/carpet/Carpet/Carpet/CarpetTest/src/carpettest_check_sizes.c,v 1.2 2001/07/09 09:00:27 schnetter Exp $ */
 
 #include <assert.h>
 #include <stdio.h>
@@ -10,125 +10,98 @@
 
 void carpettest_check_sizes (CCTK_ARGUMENTS);
 
+static void print_scalar (const char *name, int sc);
+static void print_scalar_descr (const char *name, int sc, const char *descr);
+static void print_array (const char *name, int dim, const int *arr);
+
+static const char *grouptype_string (int grouptype);
+static const char *disttype_string (int disttype);
+
 
 
 void carpettest_check_sizes (CCTK_ARGUMENTS)
 {
   DECLARE_CCTK_ARGUMENTS
   DECLARE_CCTK_PARAMETERS
-  char msg[1000];
   int group;
-  int var;
   int dim;
-  CCTK_INT **sizes, **ghostsizes;
-  int d;
-  int gsh[3], lsh[3], lbnd[3], ubnd[3];
-  const int *cip;
-  int size[3];
+  cGroup data;
+  cGroupDynamicData dyndata;
   
-  sprintf (msg, "gsh: %d %d %d\n", cctk_gsh[0], cctk_gsh[1], cctk_gsh[2]);
-  printf (msg);
-  sprintf (msg, "lsh: %d %d %d\n", cctk_lsh[0], cctk_lsh[1], cctk_lsh[2]);
-  printf (msg);
-  sprintf (msg, "lbnd: %d %d %d\n", cctk_lbnd[0], cctk_lbnd[1], cctk_lbnd[2]);
-  printf (msg);
-  sprintf (msg, "ubnd: %d %d %d\n", cctk_ubnd[0], cctk_ubnd[1], cctk_ubnd[2]);
-  printf (msg);
+  dim = cctk_dim;
+  print_scalar ("cctk_dim", cctk_dim);
+  print_array ("cctk_gsh", dim, cctk_gsh);
+  print_array ("cctk_lsh", dim, cctk_lsh);
+  print_array ("cctk_lbnd", dim, cctk_lbnd);
+  print_array ("cctk_ubnd", dim, cctk_ubnd);
+  print_array ("cctk_bbox", 2*dim, cctk_bbox);
+  print_array ("cctk_nghostzones", dim, cctk_nghostzones);
   printf ("\n");
   
-#if 0
   for (group=0; group<CCTK_NumGroups(); ++group) {
-    var = CCTK_FirstVarIndexI(group);
-    sprintf (msg, "group: %d %s\n", group, CCTK_GroupNameFromVarI(var));
-    printf (msg);
-    
-    dim = CCTK_GroupDimI(group);
-    sprintf (msg, "dim: %d\n", CCTK_GroupDimI(group));
-    printf (msg);
-    
-    sizes = CCTK_GroupSizesI(group);
-    sprintf (msg, "sizes:");
-    if (sizes) {
-      for (d=0; d<dim; ++d) {
-	sprintf (msg, "%s %d", msg, (*sizes)[d]);
-      }
-    } else {
-      sprintf (msg, "%s (no sizes)", msg);
-    }
-    sprintf (msg, "%s\n", msg);
-    printf (msg);
+    CCTK_GroupData (group, &data);
+    CCTK_GroupDynamicData (cctkGH, group, &dyndata);
     
-    ghostsizes = CCTK_GroupGhostsizesI(group);
-    sprintf (msg, "ghostsizes:");
-    if (ghostsizes) {
-      for (d=0; d<dim; ++d) {
-	sprintf (msg, "%s %d", msg, (*ghostsizes)[d]);
-      }
-    } else {
-      sprintf (msg, "%s (no ghostsizes)", msg);
-    }
-    sprintf (msg, "%s\n", msg);
-    printf (msg);
-    
-    CCTK_GroupgshGI (cctkGH, dim, gsh, group);
-    sprintf (msg, "gsh:");
-    for (d=0; d<dim; ++d) {
-      sprintf (msg, "%s %d", msg, gsh[d]);
-    }
-    sprintf (msg, "%s\n", msg);
-    printf (msg);
-    
-    CCTK_GrouplshGI (cctkGH, dim, lsh, group);
-    sprintf (msg, "lsh:");
-    for (d=0; d<dim; ++d) {
-      sprintf (msg, "%s %d", msg, lsh[d]);
-    }
-    sprintf (msg, "%s\n", msg);
-    printf (msg);
-    
-    CCTK_GrouplbndGI (cctkGH, dim, lbnd, group);
-    sprintf (msg, "lbnd:");
-    for (d=0; d<dim; ++d) {
-      sprintf (msg, "%s %d", msg, lbnd[d]);
-    }
-    sprintf (msg, "%s\n", msg);
-    printf (msg);
-    
-    CCTK_GroupubndGI (cctkGH, dim, ubnd, group);
-    sprintf (msg, "ubnd:");
-    for (d=0; d<dim; ++d) {
-      sprintf (msg, "%s %d", msg, ubnd[d]);
-    }
-    sprintf (msg, "%s\n", msg);
-    printf (msg);
+    print_scalar_descr ("group", group, CCTK_GroupName(group));
     
+    dim = data.dim;
+    print_scalar ("dim", data.dim);
+    print_scalar_descr ("grouptype", data.grouptype, grouptype_string(data.grouptype));
+    print_scalar_descr ("vartype", data.vartype, CCTK_VarTypeName(data.vartype));
+    print_scalar_descr ("disttype", data.disttype, disttype_string(data.disttype));
+    print_scalar ("stagtype", data.stagtype);
+    print_scalar ("numvars", data.numvars);
+    print_scalar ("numtimelevels", data.numtimelevels);
+    print_array ("gsh", dim, dyndata.gsh);
+    print_array ("lsh", dim, dyndata.lsh);
+    print_array ("lbnd", dim, dyndata.lbnd);
+    print_array ("ubnd", dim, dyndata.ubnd);
+    print_array ("bbox", 2*dim, dyndata.bbox);
+    print_array ("nghostzones", dim, dyndata.nghostzones);
     printf ("\n");
   }
-#endif
   
-  for (group=0; group<CCTK_NumGroups(); ++group) {
-    var = CCTK_FirstVarIndexI(group);
-    sprintf (msg, "group: %d %s\n", group, CCTK_GroupNameFromVarI(var));
-    printf (msg);
-    
-    dim = CCTK_GroupDimI(group);
-    sprintf (msg, "dim: %d\n", CCTK_GroupDimI(group));
-    printf (msg);
-    
-    for (d=0; d<dim; ++d) {
-      cip = CCTK_ArrayGroupSizeI(cctkGH, d, group);
-      assert (cip);
-      size[d] = *cip;
-    }
-    
-    sprintf (msg, "size:");
-    for (d=0; d<dim; ++d) {
-      sprintf (msg, "%s %d", msg, size[d]);
-    }
-    sprintf (msg, "%s\n", msg);
-    printf (msg);
-    
-    printf ("\n");
+}
+
+
+
+static void print_scalar (const char *name, int sc)
+{
+  printf ("%-15s: %3d\n", name, sc);
+}
+
+static void print_scalar_descr (const char *name, int sc, const char *descr)
+{
+  printf ("%-15s: %3d   %s\n", name, sc, descr);
+}
+
+static void print_array (const char *name, int dim, const int *arr)
+{
+  int d;
+  printf ("%-15s:", name);
+  for (d=0; d<dim; ++d) {
+    printf (" %3d", arr[d]);
   }
-  
+  printf ("\n");
+}
+ 
+ 
+
+static const char *grouptype_string (int grouptype)
+{
+  switch (grouptype) {
+  case CCTK_SCALAR: return "CCTK_SCALAR";
+  case CCTK_GF:     return "CCTK_GF";
+  case CCTK_ARRAY:  return "CCTK_ARRAY";
+  }
+  return "[illegal group type]";
+}
+
+static const char *disttype_string (int disttype)
+{
+  switch (disttype) {
+  case CCTK_DISTRIB_CONSTANT: return "CCTK_DISTRIB_CONSTANT";
+  case CCTK_DISTRIB_DEFAULT:  return "CCTK_DISTRIB_DEFAULT";
+  }
+  return "[illegal distribution type]";
 }
diff --git a/Carpet/CarpetTest/test/arraysizes.par b/Carpet/CarpetTest/test/arraysizes.par
index 416bc883c..769cbb5c9 100644
--- a/Carpet/CarpetTest/test/arraysizes.par
+++ b/Carpet/CarpetTest/test/arraysizes.par
@@ -1,4 +1,4 @@
-# $Header: /home/eschnett/C/carpet/Carpet/Carpet/CarpetTest/test/arraysizes.par,v 1.2 2001/07/04 13:55:25 schnetter Exp $
+# $Header: /home/eschnett/C/carpet/Carpet/Carpet/CarpetTest/test/arraysizes.par,v 1.3 2001/07/09 09:00:29 schnetter Exp $
 
 !DESC "Check array sizes"
 
@@ -23,6 +23,6 @@ IOASCII::out2D_xyplane_zi	= 0
 IOASCII::out2D_xzplane_yi	= 0
 IOASCII::out2D_yzplane_xi	= 0
 
-IOASCII::out1D_vars	= "CarpetTest::gfg CarpetTest::arrg3 CarpetTest::arrg2 CarpetTest::arrg1"
-IOASCII::out2D_vars	= "CarpetTest::gfg CarpetTest::arrg3 CarpetTest::arrg2 CarpetTest::arrg1"
-IOASCII::out3D_vars	= "CarpetTest::gfg CarpetTest::arrg3 CarpetTest::arrg2 CarpetTest::arrg1"
+IOASCII::out1D_vars	= "CarpetTest::gfg CarpetTest::arrg3 CarpetTest::arrg2 CarpetTest::arrg1 CarpetTest::scg"
+IOASCII::out2D_vars	= "CarpetTest::gfg CarpetTest::arrg3 CarpetTest::arrg2 CarpetTest::arrg1 CarpetTest::scg"
+IOASCII::out3D_vars	= "CarpetTest::gfg CarpetTest::arrg3 CarpetTest::arrg2 CarpetTest::arrg1 CarpetTest::scg"
diff --git a/CarpetAttic/CarpetIOFlexIO/interface.ccl b/CarpetAttic/CarpetIOFlexIO/interface.ccl
index f10a470cb..4b51ccd97 100644
--- a/CarpetAttic/CarpetIOFlexIO/interface.ccl
+++ b/CarpetAttic/CarpetIOFlexIO/interface.ccl
@@ -1,4 +1,6 @@
 # Interface definition for thorn CarpetIOFlexIO
-# $Header: /home/eschnett/C/carpet/Carpet/CarpetAttic/CarpetIOFlexIO/interface.ccl,v 1.1 2001/03/15 23:28:45 eschnett Exp $
+# $Header: /home/eschnett/C/carpet/Carpet/CarpetAttic/CarpetIOFlexIO/interface.ccl,v 1.2 2001/07/09 09:00:21 schnetter Exp $
 
 implements: IOFlexIO
+
+uses include header: carpet.hh
diff --git a/CarpetAttic/CarpetIOFlexIO/src/ioflexio.cc b/CarpetAttic/CarpetIOFlexIO/src/ioflexio.cc
index 0c87f5701..bbf8235d4 100644
--- a/CarpetAttic/CarpetIOFlexIO/src/ioflexio.cc
+++ b/CarpetAttic/CarpetIOFlexIO/src/ioflexio.cc
@@ -28,11 +28,11 @@
 #include "Carpet/CarpetLib/src/ggf.hh"
 #include "Carpet/CarpetLib/src/vect.hh"
 
-#include "Carpet/Carpet/src/carpet.hh"
+#include "carpet.hh"
 
 #include "ioflexio.hh"
 
-static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/CarpetAttic/CarpetIOFlexIO/src/ioflexio.cc,v 1.10 2001/07/04 12:29:50 schnetter Exp $";
+static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/CarpetAttic/CarpetIOFlexIO/src/ioflexio.cc,v 1.11 2001/07/09 09:00:22 schnetter Exp $";
 
 
 
@@ -118,206 +118,171 @@ namespace CarpetIOFlexIO {
     const int n = CCTK_VarIndex(varname);
     assert (n>=0 && n<CCTK_NumVars());
     const int group = CCTK_GroupIndexFromVarI (n);
-    assert (group>=0 && group<(int)Carpet::gfdata.size());
+    assert (group>=0 && group<(int)Carpet::arrdata.size());
     const int n0 = CCTK_FirstVarIndexI(group);
     assert (n0>=0 && n0<CCTK_NumVars());
     const int var = n - n0;
     assert (var>=0 && var<CCTK_NumVars());
     const int tl = 0;
     
-    switch (CCTK_GroupTypeI(group)) {
-      
-    case CCTK_SCALAR: {
-      // Don't output scalars
-      CCTK_VWarn (2, __LINE__, __FILE__, CCTK_THORNSTRING,
-		  "Cannout output variable \"%s\" because it is a scalar",
+    // Check for storage
+    if (! CCTK_QueryGroupStorageI(cgh, group)) {
+      CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING,
+		  "Cannot output variable \"%s\" because it has no storage",
 		  varname);
       return 0;
     }
     
-    case CCTK_ARRAY:
-    case CCTK_GF: {
-      
-      // Check for storage
-      if (! CCTK_QueryGroupStorageI(cgh, group)) {
-	CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING,
-		    "Cannot output variable \"%s\" because it has no storage",
-		    varname);
-	return 0;
-      }
+    // Create the output directory
+    const char* myoutdir = GetStringParameter("outdir3D", outdir);
+    if (CCTK_MyProc(cgh)==0) {
+      CCTK_CreateDirectory (0755, myoutdir);
+    }
+    
+    // Invent a file name
+    const char* extension = 0;
+    if (CCTK_Equals(out3D_format, "IEEE")) {
+      extension = ".raw";
+#ifdef HDF5
+    } else if (CCTK_Equals(out3D_format, "HDF4")) {
+      extension = ".hdf";
+    } else if (CCTK_Equals(out3D_format, "HDF5")) {
+      extension = ".h5";
+#endif
+    } else {
+      abort();
+    }
+    extension = GetStringParameter ("out3D_extension", extension);
+    
+    char* const filename = (char*)alloca(strlen(myoutdir)
+					 +strlen(alias)
+					 +strlen(extension)+100);
+    sprintf (filename, "%s/%s%s", myoutdir, alias, extension);
+    
+    IObase* writer = 0;
+    AMRwriter* amrwriter = 0;
+    
+    // Write the file only on the root processor
+    if (CCTK_MyProc(cgh)==0) {
       
-      // Create the output directory
-      const char* myoutdir = GetStringParameter("outdir3D", outdir);
-      if (CCTK_MyProc(cgh)==0) {
-	CCTK_CreateDirectory (0755, myoutdir);
+      // If this is the first time, then create and truncate the file
+      if (do_truncate[n]) {
+	struct stat fileinfo;
+	if (! IOUtil_RestartFromRecovery(cgh)
+	    || stat(filename, &fileinfo)!=0) {
+	  writer = 0;
+	  if (CCTK_Equals(out3D_format, "IEEE")) {
+	    writer = new IEEEIO(filename, IObase::Create);
+#ifdef HDF5
+	  } else if (CCTK_Equals(out3D_format, "HDF4")) {
+	    writer = new HDFIO(filename, IObase::Create);
+	  } else if (CCTK_Equals(out3D_format, "HDF5")) {
+	    writer = new H5IO(filename, IObase::Create);
+#endif
+	  } else {
+	    abort();
+	  }
+	  delete writer;
+	  writer = 0;
+	}
       }
       
-      // Invent a file name
-      const char* extension = 0;
+      // Open the file 
       if (CCTK_Equals(out3D_format, "IEEE")) {
-	extension = ".raw";
+	writer = new IEEEIO(filename, IObase::Append);
 #ifdef HDF5
       } else if (CCTK_Equals(out3D_format, "HDF4")) {
-	extension = ".hdf";
+	writer = new HDFIO(filename, IObase::Append);
       } else if (CCTK_Equals(out3D_format, "HDF5")) {
-	extension = ".h5";
+	writer = new H5IO(filename, IObase::Append);
 #endif
       } else {
 	abort();
       }
-      extension = GetStringParameter ("out3D_extension", extension);
+      assert (writer->isValid());
+      amrwriter = new AMRwriter(*writer);
       
-      char* const filename = (char*)alloca(strlen(myoutdir)
-					   +strlen(alias)
-					   +strlen(extension)+100);
-      sprintf (filename, "%s/%s%s", myoutdir, alias, extension);
+      // Set datatype
+      assert (CCTK_VarTypeI(n) == CCTK_VARIABLE_REAL8
+	      || (sizeof(CCTK_REAL) == sizeof(CCTK_REAL8)
+		  && CCTK_VarTypeI(n) == CCTK_VARIABLE_REAL));
+      // TODO: Set datatype correctly
+      amrwriter->setType (IObase::Float64);
       
-      IObase* writer = 0;
-      AMRwriter* amrwriter = 0;
+      const int gpdim = CCTK_GroupDimI(group);
       
-      // Write the file only on the root processor
-      if (CCTK_MyProc(cgh)==0) {
-	
-	// If this is the first time, then create and truncate the
-	// file
-	if (do_truncate[n]) {
-	  struct stat fileinfo;
-	  if (! IOUtil_RestartFromRecovery(cgh)
-	      || stat(filename, &fileinfo)!=0) {
-	    writer = 0;
-	    if (CCTK_Equals(out3D_format, "IEEE")) {
-	      writer = new IEEEIO(filename, IObase::Create);
-#ifdef HDF5
-	    } else if (CCTK_Equals(out3D_format, "HDF4")) {
-	      writer = new HDFIO(filename, IObase::Create);
-	    } else if (CCTK_Equals(out3D_format, "HDF5")) {
-	      writer = new H5IO(filename, IObase::Create);
-#endif
-	    } else {
-	      abort();
-	    }
-	    delete writer;
-	    writer = 0;
-	  }
-	}
-	
-	// Open the file 
-	if (CCTK_Equals(out3D_format, "IEEE")) {
-	  writer = new IEEEIO(filename, IObase::Append);
-#ifdef HDF5
-	} else if (CCTK_Equals(out3D_format, "HDF4")) {
-	  writer = new HDFIO(filename, IObase::Append);
-	} else if (CCTK_Equals(out3D_format, "HDF5")) {
-	  writer = new H5IO(filename, IObase::Append);
-#endif
-	} else {
-	  abort();
-	}
-	assert (writer->isValid());
-	amrwriter = new AMRwriter(*writer);
-	
-	// Set datatype
-	assert (CCTK_VarTypeI(n) == CCTK_VARIABLE_REAL8
-		|| (sizeof(CCTK_REAL) == sizeof(CCTK_REAL8)
-		    && CCTK_VarTypeI(n) == CCTK_VARIABLE_REAL));
-	// TODO: Set datatype correctly
-	amrwriter->setType (IObase::Float64);
-	
-	const int gpdim = CCTK_GroupDimI(group);
-	
-	// Set coordinate information
-	CCTK_REAL lower[dim], upper[dim];
-	double origin[dim], delta[dim], timestep;
-	for (int d=0; d<dim; ++d) {
-	  const int ierr = CCTK_CoordRange
-	    (cgh, &lower[d], &upper[d], d+1, 0, "cart3d");
-	  assert (ierr==0);
-	  origin[d] = lower[d];
-	  delta[d] = cgh->cctk_delta_space[d];
-	}
-	timestep = base_delta_time;
-	amrwriter->setTopLevelParameters
-	  (gpdim, origin, delta, timestep, maxreflevels);
-	
-	// Set refinement information
-	int interlevel_timerefinement;
-	int interlevel_spacerefinement[dim];
-	int initial_gridplacementrefinement[dim];
-	interlevel_timerefinement = hh->reffact;
-	for (int d=0; d<dim; ++d) {
-	  interlevel_spacerefinement[d] = hh->reffact;
- 	  initial_gridplacementrefinement[d] = 1;
-	}
-	amrwriter->setRefinement
-	  (interlevel_timerefinement, interlevel_spacerefinement,
-	   initial_gridplacementrefinement);
-	
-	// Set level
-	amrwriter->setLevel (reflevel);
-	
-	// Set current time
-	amrwriter->setTime (cgh->cctk_iteration);
+      // Set coordinate information
+      CCTK_REAL lower[dim], upper[dim];
+      double origin[dim], delta[dim], timestep;
+      for (int d=0; d<dim; ++d) {
+	const int ierr = CCTK_CoordRange
+	  (cgh, &lower[d], &upper[d], d+1, 0, "cart3d");
+	assert (ierr==0);
+	origin[d] = lower[d];
+	delta[d] = cgh->cctk_delta_space[d];
       }
+      timestep = base_delta_time;
+      amrwriter->setTopLevelParameters
+	(gpdim, origin, delta, timestep, maxreflevels);
       
-      // Traverse all components on this refinement and multigrid
-      // level
-      BEGIN_COMPONENT_LOOP(cgh) {
-	
-	const generic_gf<dim>* ff = 0;
-	
-	switch (CCTK_GroupTypeI(group)) {
-	  
-	case CCTK_ARRAY:
-	  assert (var < (int)arrdata[group].data.size());
-	  ff = (generic_gf<dim>*)arrdata[group].data[var];
-	  break;
-	  
-	case CCTK_GF:
-	  assert (var < (int)gfdata[group].data.size());
-	  ff = (generic_gf<dim>*)gfdata[group].data[var];
-	  break;
-	  
-	default:
-	  abort();
-	}
-	
-	const generic_data<dim>* const data
-	  = (*ff) (tl, reflevel, component, mglevel);
-	
-	/* Make temporary copy on processor 0 */
-	const bbox<int,dim> ext = data->extent();
-	generic_data<dim>* const tmp = data->make_typed ();
-	tmp->allocate (ext, 0);
-	tmp->copy_from (data, ext);
-	
-	/* Write data */
-	if (CCTK_MyProc(cgh)==0) {
-	  int origin[dim], dims[dim];
-	  for (int d=0; d<dim; ++d) {
-	    origin[d] = (ext.lower() / ext.stride())[d];
-	    dims[d]   = (ext.shape() / ext.stride())[d];
-	  }
-	  amrwriter->write (origin, dims, (void*)tmp->storage());
-	}
-	
-	/* Delete temporary copy */
-	delete tmp;
-	
-      } END_COMPONENT_LOOP(cgh);
+      // Set refinement information
+      int interlevel_timerefinement;
+      int interlevel_spacerefinement[dim];
+      int initial_gridplacementrefinement[dim];
+      interlevel_timerefinement = hh->reffact;
+      for (int d=0; d<dim; ++d) {
+	interlevel_spacerefinement[d] = hh->reffact;
+	initial_gridplacementrefinement[d] = 1;
+      }
+      amrwriter->setRefinement
+	(interlevel_timerefinement, interlevel_spacerefinement,
+	 initial_gridplacementrefinement);
       
-      // Close the file
+      // Set level
+      amrwriter->setLevel (reflevel);
+      
+      // Set current time
+      amrwriter->setTime (cgh->cctk_iteration);
+    }
+    
+    // Traverse all components on this refinement and multigrid level
+    BEGIN_COMPONENT_LOOP(cgh) {
+      
+      const generic_gf<dim>* ff = 0;
+      
+      assert (var < (int)arrdata[group].data.size());
+      ff = (generic_gf<dim>*)arrdata[group].data[var];
+      
+      const generic_data<dim>* const data
+	= (*ff) (tl, reflevel, component, mglevel);
+      
+      // Make temporary copy on processor 0
+      const bbox<int,dim> ext = data->extent();
+      generic_data<dim>* const tmp = data->make_typed ();
+      tmp->allocate (ext, 0);
+      tmp->copy_from (data, ext);
+      
+      // Write data
       if (CCTK_MyProc(cgh)==0) {
-	delete amrwriter;
-	amrwriter = 0;
-	delete writer;
-	writer = 0;
+	int origin[dim], dims[dim];
+	for (int d=0; d<dim; ++d) {
+	  origin[d] = (ext.lower() / ext.stride())[d];
+	  dims[d]   = (ext.shape() / ext.stride())[d];
+	}
+	amrwriter->write (origin, dims, (void*)tmp->storage());
       }
       
-      break;
-    } // ARRAY or GROUP
+      // Delete temporary copy
+      delete tmp;
       
-    default:
-      abort();
+    } END_COMPONENT_LOOP(cgh);
+    
+    // Close the file
+    if (CCTK_MyProc(cgh)==0) {
+      delete amrwriter;
+      amrwriter = 0;
+      delete writer;
+      writer = 0;
     }
     
     // Don't truncate again
@@ -406,7 +371,7 @@ namespace CarpetIOFlexIO {
     const int n = CCTK_VarIndex(varname);
     assert (n>=0 && n<CCTK_NumVars());
     const int group = CCTK_GroupIndexFromVarI (n);
-    assert (group>=0 && group<(int)Carpet::gfdata.size());
+    assert (group>=0 && group<(int)Carpet::arrdata.size());
     const int n0 = CCTK_FirstVarIndexI(group);
     assert (n0>=0 && n0<CCTK_NumVars());
     const int var = n - n0;
@@ -550,26 +515,13 @@ namespace CarpetIOFlexIO {
 	  
 	  generic_gf<dim>* ff = 0;
 	  
-	  switch (CCTK_GroupTypeI(group)) {
-	    
-	  case CCTK_ARRAY:
-	    assert (var < (int)arrdata[group].data.size());
-	    ff = (generic_gf<dim>*)arrdata[group].data[var];
-	    break;
-	    
-	  case CCTK_GF:
-	    assert (var < (int)gfdata[group].data.size());
-	    ff = (generic_gf<dim>*)gfdata[group].data[var];
-	    break;
-	    
-	  default:
-	    abort();
-	  }
+	  assert (var < (int)arrdata[group].data.size());
+	  ff = (generic_gf<dim>*)arrdata[group].data[var];
 	  
 	  generic_data<dim>* const data
 	    = (*ff) (tl, reflevel, component, mglevel);
 	  
-	  /* Create temporary data storage on processor 0 */
+	  // Create temporary data storage on processor 0
 	  const vect<int,dim> str = vect<int,dim>(reflevelfact);
 	  const vect<int,dim> lb = vect<int,dim>(amr_origin) * str;
 	  const vect<int,dim> ub
@@ -583,10 +535,10 @@ namespace CarpetIOFlexIO {
 	    tmp->allocate (ext, 0, 0);
 	  }
 	  
-	  /* Copy into grid function */
+	  // Copy into grid function
 	  data->copy_from (tmp, ext);
 	  
-	  /* Delete temporary copy */
+	  // Delete temporary copy
 	  delete tmp;
 	  
 	} END_COMPONENT_LOOP(cgh);