permute order of parameters to put things the user is likely to

want to change closer to the top


git-svn-id: http://svn.einsteintoolkit.org/cactus/EinsteinAnalysis/AHFinderDirect/trunk@973 f88db872-0e4f-0410-b76b-b9085cfa78c5

1 files changed, 299 insertions, 299 deletions

diff --git a/param.ccl b/param.ccl
index 45eb259..bc56167 100644
--- a/param.ccl
+++ b/param.ccl
@@ -114,115 +114,124 @@ boolean print_timing_stats \
 ################################################################################
 
 #
-# ***** parameters for the Jacobian matrix *****
+# ***** parameters for the initial guess for each apparent horizon shape *****
 #
 
-keyword Jacobian_compute_method "how do we compute the Jacobian matrix?"
-{
-# for debugging only"
-"numerical perturbation"    :: "n.b. this is *very* slow"
-
-# use this for normal apparent horizon finding
-"symbolic differentiation with finite diff d/dr" :: \
-  "fast, tricky programming, uses only gij, dx gij, Kij"
-
-# alas, this isn't implemented yet :(
-"symbolic differentiation"  :: \
-  "fast, tricky programming, uses gij, dx gij, dxx gij, Kij, dx Kij"
-} "symbolic differentiation with finite diff d/dr"
-
 #
-# This parameter lists all known methods for storing the Jacobian and
-# solving linear systems with the Jacobian as the LHS matrix.  See
-# "src/include/config.hh" for which of these are actually compiled in at
-# the moment.  N.b. each compiled-in method requires linking with the
-# corresponding linear-solver library; see "src/make.configuration.defn"
-# for details on these libraries.
+# (Note that if at any time we fail to find the (an) apparent horizon,
+# then we reset our trial horizon surface to this initial guess before
+# next attempting to find this horizon.)
 #
-keyword Jacobian_store_solve_method \
-  "how do we store/linear-solve the Jacobian matrix?"
-{
-# good for debugging, but very slow for large  N_zones_per_right_angle
-"dense matrix/LAPACK"	:: \
-  "store as (Fortran) dense matrix, solve with LAPACK routines"
-# use this for normal runs
-"row-oriented sparse matrix/ILUCG" :: \
-  "store as sparse matrix (row-oriented storage format), \
-   solve with ILUCG (incomplete LU decomposition - conjugate gradient) method"
-} "row-oriented sparse matrix/ILUCG"
 
-#
-# This parameter controls two different sorts of one-sided finite
-# differencing:
-# - numerical-perturbation Jacobian computations
-# - the finite differencing part of the "symbolic differentiation
-#   with finite diff d/dr" Jacobian computation
-#
-# Notes on this parameter:
-# - don't set it too small or roundoff errors will become large
-# - don't set it too large or finite differencing errors will become large
-# In practice the default value should be fine
-#
-real Jacobian_perturbation_amplitude \
-  "perturbation amplitude for 1-sided finite differencing for Jacobians"
+# n.b. Schwarzschild/EF is the special case spin=0 of Kerr/Kerr
+keyword initial_guess_method[5] \
+  "method used to set up initial guess for apparent horizon shape"
 {
-(0.0:* :: "any real number > 0"
-} 1.0e-6
+"read from file"	:: "read from input file"
+"Kerr/Kerr"		:: \
+  "set to the (analytical) horizon of Kerr spacetime in Kerr coordinates"
+"Kerr/Kerr-Schild"	:: \
+  "set to the (analytical) horizon of Kerr spacetime in Kerr-Schild coordinates"
+"coordinate sphere"	:: "set to a coordinate sphere"
+"coordinate ellipsoid"	:: "set to a coordinate ellipsoid"
+} "coordinate sphere"
 
-# if AHFinderDirect::method = "test Jacobian", should we test all
-# known methods for computing the Jacobian, or just the numerical perturbation
-# method (the latter may be useful of some other methods are broken)
-boolean test_all_Jacobian_compute_methods \
-  "should we test all Jacobian computation methods, or just NP?"
+# parameters for initial_guess_method = "Kerr/Kerr"
+real initial_guess__Kerr_Kerr__x_posn[5] "x coordinate of Kerr BH"
 {
-} "true"
-
-################################################################################
-
-#
-# ***** parameters for the Newton's-method solution of Theta(h) = 0 *****
-#
+*:* :: "any real number"
+} 0.0
+real initial_guess__Kerr_Kerr__y_posn[5] "y coordinate of Kerr BH"
+{
+*:* :: "any real number"
+} 0.0
+real initial_guess__Kerr_Kerr__z_posn[5] "z coordinate of Kerr BH"
+{
+*:* :: "any real number"
+} 0.0
+real initial_guess__Kerr_Kerr__mass[5] "mass of Kerr BH"
+{
+(0.0:*		:: "BH mass = any real number > 0"
+} 1.0
+# n.b. my convention is that a=J/m^2 is dimensionless,
+#      while MTW take a=J/m=m * (my a)
+real initial_guess__Kerr_Kerr__spin[5] "dimensionless spin a=J/m^2 of Kerr BH"
+{
+(-1.0:1.0)	:: \
+  "dimensionless BH spin = J/m^2 = any real number with absolute value < 1"
+} 0.6
 
-#
-# The first time we (try to) find a given horizon, our initial guess
-# is likely to be rather inaccurate, so we may need a larger number of
-# iterations.  But if we've found this horizon before, then we have its
-# previous position as an initial guess, so (assuming that we've been
-# scheduled at each time step) we shouldn't need as many iterations.
-#
-int max_Newton_iterations__initial \
-  "maximum number of Newton iterations before giving up \
-   when initially finding a given horizon"
+# parameters for initial_guess_method = "Kerr/Kerr-Schild"
+real initial_guess__Kerr_KerrSchild__x_posn[5] "x coordinate of Kerr BH"
 {
-(0:* :: "any positive integer"
-} 20
-int max_Newton_iterations__subsequent \
-  "maximum number of Newton iterations before giving up \
-   when re-finding a given horizon after finding it before"
+*:* :: "any real number"
+} 0.0
+real initial_guess__Kerr_KerrSchild__y_posn[5] "y coordinate of Kerr BH"
 {
-(0:* :: "any positive integer"
-} 10
+*:* :: "any real number"
+} 0.0
+real initial_guess__Kerr_KerrSchild__z_posn[5] "z coordinate of Kerr BH"
+{
+*:* :: "any real number"
+} 0.0
+real initial_guess__Kerr_KerrSchild__mass[5] "mass of Kerr BH"
+{
+(0.0:*		:: "BH mass = any real number > 0"
+} 1.0
+# n.b. my convention is that a=J/m^2 is dimensionless,
+#      while MTW take a=J/m=m * (my a)
+real initial_guess__Kerr_KerrSchild__spin[5] "dimensionless spin a=J/m^2 of Kerr BH"
+{
+(-1.0:1.0)	:: \
+  "dimensionless BH spin = J/m^2 = any real number with absolute value < 1"
+} 0.6
 
-#
-# To avoid the Newton iteration diverging if there is no horizon present
-# or if the initial guess is bad, we limit the distance the horizon may
-# move in any single Newton iteration (i.e. the infinity-norm of Delta_h)
-# to <= this fraction of the mean horizon radius
-#
-real max_allowable_Delta_h_over_h \
-  "don't let horizon move > this fraction of mean radius in a Newton iteration"
+# parameters for initial_guess_method = "sphere"
+real initial_guess__coord_sphere__x_center[5] "x coordinate of sphere center"
 {
-(0.0:* :: "any positive real number"
-} 0.1
+*:* :: "any real number"
+} 0.0
+real initial_guess__coord_sphere__y_center[5] "y coordinate of sphere center"
+{
+*:* :: "any real number"
+} 0.0
+real initial_guess__coord_sphere__z_center[5] "z coordinate of sphere center"
+{
+*:* :: "any real number"
+} 0.0
+real initial_guess__coord_sphere__radius[5] "radius of sphere"
+{
+(0.0:* :: "any real number > 0.0"
+} 2.0
 
-#
-# convergence tolerance for the Newton iteration
-#
-real Theta_norm_for_convergence \
-  "we declare the horizon to be found if ||Theta||_infinity <= this"
+# parameters for initial_guess_method = "ellipsoid"
+real initial_guess__coord_ellipsoid__x_center[5] \
+  "x coordinate of ellipsoid center"
 {
-(0.0:* :: "any positive real number"
-} 1.0e-8
+*:* :: "any real number"
+} 0.0
+real initial_guess__coord_ellipsoid__y_center[5] \
+  "y coordinate of ellipsoid center"
+{
+*:* :: "any real number"
+} 0.0
+real initial_guess__coord_ellipsoid__z_center[5] \
+  "z coordinate of ellipsoid center"
+{
+*:* :: "any real number"
+} 0.0
+real initial_guess__coord_ellipsoid__x_radius[5] "x radius of ellipsoid"
+{
+(0.0:* :: "any real number > 0.0"
+} 2.0
+real initial_guess__coord_ellipsoid__y_radius[5] "y radius of ellipsoid"
+{
+(0.0:* :: "any real number > 0.0"
+} 2.0
+real initial_guess__coord_ellipsoid__z_radius[5] "z radius of ellipsoid"
+{
+(0.0:* :: "any real number > 0.0"
+} 2.0
 
 ################################################################################
 
@@ -382,6 +391,127 @@ string Jacobian_base_file_name "base file name for Jacobian output file(s)"
 ################################################################################
 
 #
+# ***** parameters controlling how we handle errors/warnings *****
+#
+
+#
+# We currently "handle" the following errors/warnings by CCTK_VWarn();
+# these parameters give the warning levels (in the sense of the -W flag
+# to Cactus, and the first argument to CCTK_VWarn()) for various conditions:
+#
+
+# point outside (or too close to boundary of) Cactus grid,
+# i.e. geometry interpolator returns CCTK_ERROR_INTERP_POINT_OUTSIDE
+# ... warning level if error occurs on first Newton iteration,
+#     i.e. when evaluating expansion/Jacobian for initial guess
+# ... this may mean that  driver::ghost_size  is too small, especially
+#     if any horizon crosses a symmetry boundary
+#     ==> visible message by default
+int warn_level__point_outside__initial \
+  "warning level for point outside (or too close to boundary of) Cactus grid \
+   (error occurs on first Newton iteration)"
+{
+-1:* :: "any valid Cactus warning level"
+} 1
+# ... warning level if error occurs on a subsequent Newton iteration
+# ... this probably "just" means there's no horizon in the grid
+#     ==> no visible message by default
+int warn_level__point_outside__subsequent \
+  "warning level for point outside (or too close to boundary of) Cactus grid \
+   (error occurs on subsequent Newton iteration)"
+{
+-1:* :: "any valid Cactus warning level"
+} 2
+
+# the Cactus configure process didn't find a finite() function,
+# so we're skipping the "check that the geometry is finite" tests
+# even though the user set  check_that_geometry_is_finite = "true"
+int warn_level__skipping_finite_check \
+  "warning level if the user sets  check_that_geometry_is_finite \
+   but the Cactus configure process doesn't find a  finite()  function \
+   so we have to skip the finite-geometry check"
+{
+-1:* :: "any valid Cactus warning level"
+} 3
+
+# infinity and/or NaN in interpolated {g_ij, partial_k g_ij, K_ij}
+int warn_level__nonfinite_geometry \
+  "warning level if we find infinity and/or NaN in the interpolated geometry \
+   values {g_ij, partial_k g_ij, K_ij}"
+{
+-1:* :: "any valid Cactus warning level"
+} 1
+
+# interpolated g_{ij} isn't positive definite
+# (usually this means we're too close to a singularity)
+# ... warning level if error occurs on first Newton iteration,
+#     i.e. when evaluating expansion/Jacobian for initial guess
+int warn_level__gij_not_positive_definite__initial \
+  "warning level if the interpolated g_{ij} isn't positive definite \
+   (usually this means we're too close to a singularity) \
+   (error occurs on first Newton iteration)"
+{
+-1:* :: "any valid Cactus warning level"
+} 2
+# ... warning level if error occurs on a subsequent Newton iteration
+int warn_level__gij_not_positive_definite__subsequent \
+  "warning level if the interpolated g_{ij} isn't positive definite \
+   (usually this means we're too close to a singularity) \
+   (error occurs on subsequent Newton iteration)"
+{
+-1:* :: "any valid Cactus warning level"
+} 2
+
+################################################################################
+
+#
+# ***** parameters for the Newton's-method solution of Theta(h) = 0 *****
+#
+
+#
+# The first time we (try to) find a given horizon, our initial guess
+# is likely to be rather inaccurate, so we may need a larger number of
+# iterations.  But if we've found this horizon before, then we have its
+# previous position as an initial guess, so (assuming that we've been
+# scheduled at each time step) we shouldn't need as many iterations.
+#
+int max_Newton_iterations__initial \
+  "maximum number of Newton iterations before giving up \
+   when initially finding a given horizon"
+{
+(0:* :: "any positive integer"
+} 20
+int max_Newton_iterations__subsequent \
+  "maximum number of Newton iterations before giving up \
+   when re-finding a given horizon after finding it before"
+{
+(0:* :: "any positive integer"
+} 10
+
+#
+# To avoid the Newton iteration diverging if there is no horizon present
+# or if the initial guess is bad, we limit the distance the horizon may
+# move in any single Newton iteration (i.e. the infinity-norm of Delta_h)
+# to <= this fraction of the mean horizon radius
+#
+real max_allowable_Delta_h_over_h \
+  "don't let horizon move > this fraction of mean radius in a Newton iteration"
+{
+(0.0:* :: "any positive real number"
+} 0.1
+
+#
+# convergence tolerance for the Newton iteration
+#
+real Theta_norm_for_convergence \
+  "we declare the horizon to be found if ||Theta||_infinity <= this"
+{
+(0.0:* :: "any positive real number"
+} 1.0e-8
+
+################################################################################
+
+#
 # ***** parameters to define the patch system(s) *****
 #
 
@@ -510,30 +640,68 @@ int patch_overlap_width \
 ################################################################################
 
 #
-# ***** parameters for computing surface integrals over the horizon *****
+# ***** parameters for the Jacobian matrix *****
 #
 
+keyword Jacobian_compute_method "how do we compute the Jacobian matrix?"
+{
+# for debugging only"
+"numerical perturbation"    :: "n.b. this is *very* slow"
+
+# use this for normal apparent horizon finding
+"symbolic differentiation with finite diff d/dr" :: \
+  "fast, tricky programming, uses only gij, dx gij, Kij"
+
+# alas, this isn't implemented yet :(
+"symbolic differentiation"  :: \
+  "fast, tricky programming, uses gij, dx gij, dxx gij, Kij, dx Kij"
+} "symbolic differentiation with finite diff d/dr"
+
 #
-# In the descriptions, N is the number of grid zones in a patch
-# in either the rho or the sigma direction, i.e. it's 45 or 90 degrees
-# divided by delta_drho_dsigma.
+# This parameter lists all known methods for storing the Jacobian and
+# solving linear systems with the Jacobian as the LHS matrix.  See
+# "src/include/config.hh" for which of these are actually compiled in at
+# the moment.  N.b. each compiled-in method requires linking with the
+# corresponding linear-solver library; see "src/make.configuration.defn"
+# for details on these libraries.
 #
-keyword integral_method "how do we compute integrals over the horizon?"
+keyword Jacobian_store_solve_method \
+  "how do we store/linear-solve the Jacobian matrix?"
 {
-"trapezoid"		:: "alternate name for trapezoid rule"
-"trapezoid rule"	:: "trapezoid rule (2nd order for smooth functions)"
-"Simpson"		:: "alternate name for Simpson's rule"
-"Simpson's rule"	:: \
-  "Simpson's rule (4th order for smooth fns, requires N to be even)"
-"Simpson (variant)"	:: "alternate name for Simpson's rule variant"
-"Simpson's rule (variant)":: \
-  "Simpson's rule variant (4th order for smooth fns, requires N >= 7)"
+# good for debugging, but very slow for large  N_zones_per_right_angle
+"dense matrix/LAPACK"	:: \
+  "store as (Fortran) dense matrix, solve with LAPACK routines"
+# use this for normal runs
+"row-oriented sparse matrix/ILUCG" :: \
+  "store as sparse matrix (row-oriented storage format), \
+   solve with ILUCG (incomplete LU decomposition - conjugate gradient) method"
+} "row-oriented sparse matrix/ILUCG"
 
-# choose this for normal use (assuming FINITE_DIFF_ORDER is set to 4
-# in "src/include/config.hh")
-"automatic choice"	:: \
-  "choose Simpson's rule or variant if applicable, otherwise trapezoid rule"
-} "automatic choice"
+#
+# This parameter controls two different sorts of one-sided finite
+# differencing:
+# - numerical-perturbation Jacobian computations
+# - the finite differencing part of the "symbolic differentiation
+#   with finite diff d/dr" Jacobian computation
+#
+# Notes on this parameter:
+# - don't set it too small or roundoff errors will become large
+# - don't set it too large or finite differencing errors will become large
+# In practice the default value should be fine
+#
+real Jacobian_perturbation_amplitude \
+  "perturbation amplitude for 1-sided finite differencing for Jacobians"
+{
+(0.0:* :: "any real number > 0"
+} 1.0e-6
+
+# if AHFinderDirect::method = "test Jacobian", should we test all
+# known methods for computing the Jacobian, or just the numerical perturbation
+# method (the latter may be useful of some other methods are broken)
+boolean test_all_Jacobian_compute_methods \
+  "should we test all Jacobian computation methods, or just NP?"
+{
+} "true"
 
 ################################################################################
 
@@ -673,7 +841,7 @@ boolean check_that_geometry_is_finite \
 ################################################################################
 
 #
-# ***** parameters for the interpatch interpolator *****
+# ***** parameters for the interpatch interpolation *****
 #
 
 #
@@ -701,198 +869,30 @@ string interpatch_interpolator_pars \
 ################################################################################
 
 #
-# ***** parameters for the initial guess for the apparent horizon shape *****
-#
-
-#
-# (Note that if at any time we fail to find the (an) apparent horizon,
-# then we reset our trial horizon surface to this initial guess before
-# next attempting to find this horizon.)
-#
-
-# n.b. Schwarzschild/EF is the special case spin=0 of Kerr/Kerr
-keyword initial_guess_method[5] \
-  "method used to set up initial guess for apparent horizon shape"
-{
-"read from file"	:: "read from input file"
-"Kerr/Kerr"		:: \
-  "set to the (analytical) horizon of Kerr spacetime in Kerr coordinates"
-"Kerr/Kerr-Schild"	:: \
-  "set to the (analytical) horizon of Kerr spacetime in Kerr-Schild coordinates"
-"coordinate sphere"	:: "set to a coordinate sphere"
-"coordinate ellipsoid"	:: "set to a coordinate ellipsoid"
-} "coordinate sphere"
-
-# parameters for initial_guess_method = "Kerr/Kerr"
-real initial_guess__Kerr_Kerr__x_posn[5] "x coordinate of Kerr BH"
-{
-*:* :: "any real number"
-} 0.0
-real initial_guess__Kerr_Kerr__y_posn[5] "y coordinate of Kerr BH"
-{
-*:* :: "any real number"
-} 0.0
-real initial_guess__Kerr_Kerr__z_posn[5] "z coordinate of Kerr BH"
-{
-*:* :: "any real number"
-} 0.0
-real initial_guess__Kerr_Kerr__mass[5] "mass of Kerr BH"
-{
-(0.0:*		:: "BH mass = any real number > 0"
-} 1.0
-# n.b. my convention is that a=J/m^2 is dimensionless,
-#      while MTW take a=J/m=m * (my a)
-real initial_guess__Kerr_Kerr__spin[5] "dimensionless spin a=J/m^2 of Kerr BH"
-{
-(-1.0:1.0)	:: \
-  "dimensionless BH spin = J/m^2 = any real number with absolute value < 1"
-} 0.6
-
-# parameters for initial_guess_method = "Kerr/Kerr-Schild"
-real initial_guess__Kerr_KerrSchild__x_posn[5] "x coordinate of Kerr BH"
-{
-*:* :: "any real number"
-} 0.0
-real initial_guess__Kerr_KerrSchild__y_posn[5] "y coordinate of Kerr BH"
-{
-*:* :: "any real number"
-} 0.0
-real initial_guess__Kerr_KerrSchild__z_posn[5] "z coordinate of Kerr BH"
-{
-*:* :: "any real number"
-} 0.0
-real initial_guess__Kerr_KerrSchild__mass[5] "mass of Kerr BH"
-{
-(0.0:*		:: "BH mass = any real number > 0"
-} 1.0
-# n.b. my convention is that a=J/m^2 is dimensionless,
-#      while MTW take a=J/m=m * (my a)
-real initial_guess__Kerr_KerrSchild__spin[5] "dimensionless spin a=J/m^2 of Kerr BH"
-{
-(-1.0:1.0)	:: \
-  "dimensionless BH spin = J/m^2 = any real number with absolute value < 1"
-} 0.6
-
-# parameters for initial_guess_method = "sphere"
-real initial_guess__coord_sphere__x_center[5] "x coordinate of sphere center"
-{
-*:* :: "any real number"
-} 0.0
-real initial_guess__coord_sphere__y_center[5] "y coordinate of sphere center"
-{
-*:* :: "any real number"
-} 0.0
-real initial_guess__coord_sphere__z_center[5] "z coordinate of sphere center"
-{
-*:* :: "any real number"
-} 0.0
-real initial_guess__coord_sphere__radius[5] "radius of sphere"
-{
-(0.0:* :: "any real number > 0.0"
-} 2.0
-
-# parameters for initial_guess_method = "ellipsoid"
-real initial_guess__coord_ellipsoid__x_center[5] \
-  "x coordinate of ellipsoid center"
-{
-*:* :: "any real number"
-} 0.0
-real initial_guess__coord_ellipsoid__y_center[5] \
-  "y coordinate of ellipsoid center"
-{
-*:* :: "any real number"
-} 0.0
-real initial_guess__coord_ellipsoid__z_center[5] \
-  "z coordinate of ellipsoid center"
-{
-*:* :: "any real number"
-} 0.0
-real initial_guess__coord_ellipsoid__x_radius[5] "x radius of ellipsoid"
-{
-(0.0:* :: "any real number > 0.0"
-} 2.0
-real initial_guess__coord_ellipsoid__y_radius[5] "y radius of ellipsoid"
-{
-(0.0:* :: "any real number > 0.0"
-} 2.0
-real initial_guess__coord_ellipsoid__z_radius[5] "z radius of ellipsoid"
-{
-(0.0:* :: "any real number > 0.0"
-} 2.0
-
-################################################################################
-
-#
-# ***** parameters controlling how we handle errors/warnings *****
+# ***** parameters for computing line/surface integrals over the horizon *****
 #
 
 #
-# We currently "handle" the following errors/warnings by CCTK_VWarn();
-# these parameters give the warning levels (in the sense of the -W flag
-# to Cactus, and the first argument to CCTK_VWarn()) for various conditions:
+# In the descriptions, N is the number of grid zones in a patch
+# in either the rho or the sigma direction, i.e. it's 45 or 90 degrees
+# divided by delta_drho_dsigma.
 #
-
-# point outside (or too close to boundary of) Cactus grid,
-# i.e. geometry interpolator returns CCTK_ERROR_INTERP_POINT_OUTSIDE
-# ... warning level if error occurs on first Newton iteration,
-#     i.e. when evaluating expansion/Jacobian for initial guess
-# ... this may mean that  driver::ghost_size  is too small, especially
-#     if any horizon crosses a symmetry boundary
-#     ==> visible message by default
-int warn_level__point_outside__initial \
-  "warning level for point outside (or too close to boundary of) Cactus grid \
-   (error occurs on first Newton iteration)"
-{
--1:* :: "any valid Cactus warning level"
-} 1
-# ... warning level if error occurs on a subsequent Newton iteration
-# ... this probably "just" means there's no horizon in the grid
-#     ==> no visible message by default
-int warn_level__point_outside__subsequent \
-  "warning level for point outside (or too close to boundary of) Cactus grid \
-   (error occurs on subsequent Newton iteration)"
-{
--1:* :: "any valid Cactus warning level"
-} 2
-
-# the Cactus configure process didn't find a finite() function,
-# so we're skipping the "check that the geometry is finite" tests
-# even though the user set  check_that_geometry_is_finite = "true"
-int warn_level__skipping_finite_check \
-  "warning level if the user sets  check_that_geometry_is_finite \
-   but the Cactus configure process doesn't find a  finite()  function \
-   so we have to skip the finite-geometry check"
-{
--1:* :: "any valid Cactus warning level"
-} 3
-
-# infinity and/or NaN in interpolated {g_ij, partial_k g_ij, K_ij}
-int warn_level__nonfinite_geometry \
-  "warning level if we find infinity and/or NaN in the interpolated geometry \
-   values {g_ij, partial_k g_ij, K_ij}"
+keyword integral_method "how do we compute integrals over the horizon?"
 {
--1:* :: "any valid Cactus warning level"
-} 1
+"trapezoid"		:: "alternate name for trapezoid rule"
+"trapezoid rule"	:: "trapezoid rule (2nd order for smooth functions)"
+"Simpson"		:: "alternate name for Simpson's rule"
+"Simpson's rule"	:: \
+  "Simpson's rule (4th order for smooth fns, requires N to be even)"
+"Simpson (variant)"	:: "alternate name for Simpson's rule variant"
+"Simpson's rule (variant)":: \
+  "Simpson's rule variant (4th order for smooth fns, requires N >= 7)"
 
-# interpolated g_{ij} isn't positive definite
-# (usually this means we're too close to a singularity)
-# ... warning level if error occurs on first Newton iteration,
-#     i.e. when evaluating expansion/Jacobian for initial guess
-int warn_level__gij_not_positive_definite__initial \
-  "warning level if the interpolated g_{ij} isn't positive definite \
-   (usually this means we're too close to a singularity) \
-   (error occurs on first Newton iteration)"
-{
--1:* :: "any valid Cactus warning level"
-} 2
-# ... warning level if error occurs on a subsequent Newton iteration
-int warn_level__gij_not_positive_definite__subsequent \
-  "warning level if the interpolated g_{ij} isn't positive definite \
-   (usually this means we're too close to a singularity) \
-   (error occurs on subsequent Newton iteration)"
-{
--1:* :: "any valid Cactus warning level"
-} 2
+# choose this for normal use (assuming FINITE_DIFF_ORDER is set to 4
+# in "src/include/config.hh")
+"automatic choice"	:: \
+  "choose Simpson's rule or variant if applicable, otherwise trapezoid rule"
+} "automatic choice"
 
 ################################################################################