Make "Erik" branch the default trunk for AHFinderDirect.

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

1 files changed, 436 insertions, 208 deletions

diff --git a/param.ccl b/param.ccl
index 4f8a33b..487d0ab 100644
--- a/param.ccl
+++ b/param.ccl
@@ -21,19 +21,22 @@ USES KEYWORD rotation_axis
 shares: ADMBase
 USES KEYWORD metric_type
 
+# we need to look at SpaceMask::use_mask in order to find out about the
+# excision region
+shares: SpaceMask
+USES BOOLEAN use_mask
+
 # we need to look at IO::out_dir to set the default for our own
 # output directory parameters
 shares: IO
 USES STRING out_dir
 
-# we need to look at SphericalSurface::nsurfaces to know how many
-# surfaces there are, so that we don't access a non-existing one
+# we want to know how many surfaces there are, so that we don't access
+# a non-existing one
 shares: SphericalSurface
 USES INT nsurfaces
 USES INT maxntheta
 USES INT maxnphi
-USES INT    ntheta
-USES INT    nphi
 
 # all remaining parameters are private to this thorn
 private:
@@ -45,33 +48,79 @@ private:
 #
 
 # set this to (try to) find apparent horizons at every time step
-int find_every "how often should we try to find apparent horizons?"
+int find_every "how often should we try to find apparent horizons?" STEERABLE=recover
 {
 0   :: "don't find AHs at all (this thorn is a no-op)"
 1:* :: "any integer >= 1"
 } 1
 
+# set this to (try to) find individual apparent horizons at every time step
+int find_every_individual[101] "how often should we try to find individual apparent horizons?  (overrides find_every)" STEERABLE=always
+{
+-1  :: "use the value of find_every"
+0   :: "don't find this AH at all"
+1:* :: "any integer >= 1"
+} -1
+
+# set this to (try to) find individual apparent horizons after a time step
+int find_after_individual[101] "when should we start to find individual apparent horizons?" STEERABLE=always
+{
+0:* :: "after this iteration (inclusively)"
+} 0
+
+int dont_find_after_individual[101] "when should we stop finding individual apparent horizons?" STEERABLE=always
+{
+0:* :: "after this iteration (exclusively)"
+-1  :: "do not use this parameter"
+} -1
+
+# set this to (try to) find individual apparent horizons after a certain time
+real find_after_individual_time[101] "when should we start to find individual apparent horizons?" STEERABLE=always
+{
+*:* :: "after this time (inclusively)"
+} 0.0
+
+real dont_find_after_individual_time[101] "when should we stop finding individual apparent horizons?" STEERABLE=always
+{
+*:* :: "after this time (exclusively); ignore this value if it is less than or equal to find_after_individual_time"
+} 0.0
+
+# set this to disable finding individual horizons
+boolean disable_horizon[101] "should this horizon be disabled?" STEERABLE=always
+{
+} "false"
+
 #
 # These parameters control which schedule bin (or even bins, if you
-# want) AHFinderDirect runs in.  Historically, AHFinderDirect has run
-# at CCTK_ANALYSIS.  However, for some purposes it's more convenient
-# to run at CCTK_POSTSTEP and/or CCTK_POSTINITIAL.
+# want) AHFinderDirect runs in.  Historically, Erik's branch of
+# AHFinderDirect has run at CCTK_POSTSTEP.  However, for some purposes
+# it's more convenient to run at CCTK_ANALYSIS and/or CCTK_POSTINITIAL.
+#
+# In general we need to run at CCTK_POST_RECOVER_VARIABLES, since
+# (a) parameters may have been steered at recovery, so we may need
+#     to find a new horizon or horizons, and
+# (b) we need to set the mask again to make sure it's correct
+#     right away (since our next regular horizon-finding may not
+#     be until some time steps later)
+# Therefore the  run_at_CCTK_POST_RECOVER_VARIABLES  parameter should
+# probably be left at its default setting of  true .
 #
 Boolean run_at_CCTK_ANALYSIS "should we run at CCTK_ANALYSIS?"
 {
-} true
+} false
 Boolean run_at_CCTK_POSTSTEP "should we run at CCTK_POSTSTEP?"
 {
-} false
+} true
 Boolean run_at_CCTK_POSTINITIAL "should we run at CCTK_POSTINITIAL?"
 {
 } false
+Boolean run_at_CCTK_POST_RECOVER_VARIABLES				\
+  "should we run at CCTK_POST_RECOVER_VARIABLES?"
+{
+} true
 
-#
-# unless you're trying to debug AHFinderDirect, you should leave
-# this parameter at its default value
-#
-keyword method "what should this thorn do for each apparent horizon?"
+keyword method "what should this thorn do for each apparent horizon?" \
+  STEERABLE=recover
 {
 # these options are mostly for testing/debugging
 # ... in a multiprocessor Cactus run, the horizons are done sequentually
@@ -99,10 +148,11 @@ keyword method "what should this thorn do for each apparent horizon?"
 #
 # To change the N_horizons limit, just change the upper limit for
 # N_horizons itself, change all the [N_horizons+1] array sizes in this
-# paramter file, and recompile your configuration.  No changes are
-# needed to the source code.
+# paramter file, change the upper limit for which_horizon_to_announce_centroid,
+# and recompile your configuration.  No changes are needed to the source code.
 #
-int N_horizons "number of apparent horizons to search for"
+int N_horizons "number of apparent horizons to search for" \
+  STEERABLE=recover
 {
 0     :: "turn this thorn into a fancy no-op :)"
 1:100 :: "search for this many apparent horizons"
@@ -116,64 +166,38 @@ int N_horizons "number of apparent horizons to search for"
 # keep the horizon centroid at a constant coordinate position.
 #
 int which_horizon_to_announce_centroid \
-  "for which horizon should we announce the centroid?"
+  "for which horizon should we announce the centroid?" \
+  STEERABLE=recover
 {
 0     :: "don't announce any centroid(s)"
 1:100 :: "announce this horizon's centroid each time we find it"
 } 0
 
 #
-# This parameter controls whether/how we should store our horizon
-# information into the SphericalSurface variables.
-#
-# If this parameter is set to any value >= 0, that value must be
-# in the range  0 <= value < SphericalSurface::nsurfaces .  We check
-# this at run-time...
+# This parameter controls whether and (if) into which surface the horizon
+# information will be stored.
 #
 int which_surface_to_store_info[101] \
-  "into which SphericalSurface surface should we store our horizon information?"
+  "into which surface should we store the info?" \
+  STEERABLE=recover
 {
--1  :: "don't store this horizon's information"
-0:* :: "store this horizon's information into the specified SphericalSurface surface"
+-1  :: "don't store info"
+0:* :: "store info into the corresponding surface"
 } -1
 
 #
-# When finding multiple horizons in a multiprocessor run, this thorn
-# will find different horizons in parallel on different processors.
-# As a performance optimization, this thorn normally only broadcasts
-# each horizon's shape from the processor that finds it, to all processors,
-# if it thinks that information will be needed, i.e. if either or both
-# of the following conditions hold:
-# * we're setting an excision mask
-# * we're storing horizon information in the SphericalSurface variables
-#   for at least one horizon
-#
-# If another thorn calls the  HorizonRadiusInDirection()  aliased function
-# for a horizon which was found on some other processor, this broadcast is
-# also needed to get the right answer (in a multiprocessor run), but this
-# thorn doesn't know this.  The following parameter should be used in this
-# case to force the broadcast to be made.
-#
-Boolean always_broadcast_horizon_shape \
-  "should we always broadcast each horizon shape from the processor \
-   that finds it, to all processors, even if there's no apparent need \
-   for this information on other processors?"
-{
-} false
-
-#
 # This parameter controls how verbose this thorn is in printing
 # informational (non-error) messages describing what it's doing.
 #
 keyword verbose_level \
-  "controls which (how many) messages to print describing AH finding"
+  "controls which (how many) messages to print describing AH finding" \
+  STEERABLE=recover
 {
-"no output"            :: "don't print anything"
-
-# 1 line each time step giving which horizons were found
+# 1 line each time step giving number of horizons found and their masses
+# ... this doesn't work yet :(
 "physics highlights"   :: "just a few physics messages"
 
-# 2 lines for each horizon giving position/mass/area, + a summary line or two
+# 1 line for each horizon giving position/mass/area, + a summary line or two
 "physics details"      :: "more detailed physics messages"
 
 # 1 line giving Theta(h) norms at each Newton iteration
@@ -190,20 +214,136 @@ keyword verbose_level \
 } "physics details"
 
 # n.b. printing timing stats is independent of  verbose_level
-Boolean print_timing_stats \
-  "should we print timing stats for the whole apparent-horizon-finding process?"
-{
-} false
+boolean print_timing_stats \
+  "should we print timing stats for the whole apparent-horizon-finding process?" \
+  STEERABLE=recover
+{
+} "false"
+
+# Do we want the gradients of the surface expansion?
+# (Increases run time)
+boolean want_expansion_gradients "should we print the gradients of the expansions?" \
+  STEERABLE=recover
+{
+} "false"
+
+# By default, we find apparent horizons or CE surfaces.
+# This parameter allows the equation to be change so that other surfaces
+# are found instead.
+keyword surface_definition[101] "search for what kind of surface?" STEERABLE=recover
+{
+"expansion"         :: "Theta_(l) (apparent horizons etc.)"
+"inner expansion"   :: "Theta_(n) (expansion of ingoing null normal)"
+"mean curvature"    :: "for CMC surfaces"
+"expansion product" :: "Theta_(l) Theta_(n) (product of the expansions)"
+} "expansion"
+
+# By default, we find surfaces as defined above.
+# This parameter allows the definition to be modified.
+keyword surface_modification[101] "how to modify the surface definition" STEERABLE=recover
+{
+"none"         :: "no modification"
+"radius"       :: "multiply with the coordinate radius"
+"radius^2"     :: "multiply with the square of the coordinate radius"
+"mean radius"  :: "multiply with the mean coordinate radius"
+"areal radius" :: "multiply with the areal radius (does not converge nicely, because the Jacobian is only approximate)"
+} "none"
+
+# By default, we find apparent horizons by looking for a specified expansion.
+# This parameter allows looking for a specified areal radius etc. instead.
+keyword surface_selection[101] "search for a surface with this areal radius" STEERABLE=recover
+{
+"definition"                             :: "look for a surface as defined by 'surface_definition'"
+"mean coordinate radius"                 :: "look for a surface with a certain mean coordinate radius (not covariant, but fast)"
+"areal radius"                           :: "look for a surface with a certain areal radius"
+"expansion times mean coordinate radius" :: "look for a surface with a certain product of expansion and mean coordiante radius"
+"expansion times areal radius"           :: "look for a surface with a certain product of expansion and areal radius"
+} "definition"
 
 # By default, we find apparent horizons by solving the equation
 #  Theta(h) = 0
 # This parameter allows the RHS to be set to any specified constant,
 # to find a surface of constant expansion.
-real surface_expansion[101] "search for a surface with this (constant) expansion"
+real desired_value[101] "search for a surface with this (constant) value" STEERABLE=recover
 {
 *:* :: "any real number"
 } 0.0
 
+
+
+# By default, we just find apparent horizons.  This parameter uses
+# pretracking to search for outermost apparent horizons instead.
+boolean use_pretracking[101] "search for an outermost apparent horizon" STEERABLE=recover
+{
+} "no"
+
+int pretracking_max_iterations[101] "maximum number of pretracking iterations" STEERABLE=recover
+{
+  0:* :: ""
+} 100
+
+real pretracking_value[101] "initial pretracking value" STEERABLE=recover
+{
+  *:* :: ""
+} 1.0
+
+real pretracking_minimum_value[101] "minimum pretracking value" STEERABLE=recover
+{
+  *:* :: ""
+} 0.0
+
+real pretracking_maximum_value[101] "maximum pretracking value (should be near the outer boundary)" STEERABLE=recover
+{
+  *:* :: ""
+} 10.0
+
+real pretracking_delta[101] "step size for value" STEERABLE=recover
+{
+  (0.0:* :: ""
+} 1.0
+
+real pretracking_minimum_delta[101] "minimum step size for value" STEERABLE=recover
+{
+  (0.0:* :: ""
+} 1.0e-4
+
+real pretracking_maximum_delta[101] "maximum step size for value" STEERABLE=recover
+{
+  (0.0:* :: ""
+} 1.0
+
+# Horizons can depend on other (usually pretracked) horizons
+int depends_on[101] "the other horizon that this horizon depends on" STEERABLE=recover
+{
+  0     :: "the horizon is independent"
+  1:100 :: "horizon index"
+} 0
+
+real desired_value_factor[101] "factor between this horizon's and the other horizon's desired value, applied before the offset" STEERABLE=recover
+{
+  *:* :: ""
+} 1.0
+
+real desired_value_offset[101] "difference between this horizon's and the other horizon's desired value, applied after the factor" STEERABLE=recover
+{
+  *:* :: ""
+} 0.0
+
+
+
+# By default, we keep the surface from the last time (if so desired).
+# We can also modify it before each finding to try make it find inner
+# or outer horizons.
+real shiftout_factor[101] "enlarge the surface initial guess before finding" STEERABLE=recover
+{
+  (0:* :: "choose 1 for doing nothing, larger for enlarging, smaller for shrinking"
+} 1.0
+
+real smoothing_factor[101] "smoothen (remove higher multipole moments) the surface initial guess before finding" STEERABLE=recover
+{
+  *:* :: "choose 0 for no smoothing, 1 for complete smoothing, larger for over-smoothing, negative for roughening"
+} 0.0
+
 ################################################################################
 
 #
@@ -217,7 +357,8 @@ real surface_expansion[101] "search for a surface with this (constant) expansion
 #
 
 keyword initial_guess_method[101] \
-  "method used to set up initial guess for apparent horizon shape"
+  "method used to set up initial guess for apparent horizon shape" \
+  STEERABLE=recover
 {
 "read from named file"	:: "read from explicitly-named input file"
 "read from h file"	:: \
@@ -231,106 +372,115 @@ keyword initial_guess_method[101] \
 "coordinate ellipsoid"	:: "set to a coordinate ellipsoid"
 } "coordinate sphere"
 
+# if a horizon could not be found, do we want to reset the horizon shape,
+# or do we want to continue with the last shape?
+boolean reset_horizon_after_not_finding[101] \
+  "reset the horizon shape to the initial data if a horizon was not found" \
+  STEERABLE=recover
+{
+} "yes"
+
 # parameters for initial_guess_method = "read from named file"
 string initial_guess__read_from_named_file__file_name[101] \
-  "file name to read initial guess from"
+  "file name to read initial guess from" \
+  STEERABLE=recover
 {
 ".+" :: "file name to read initial guess from"
 } "h.gp"
 
 # parameters for initial_guess_method = "Kerr/Kerr"
-real initial_guess__Kerr_Kerr__x_posn[101] "x coordinate of Kerr BH"
+real initial_guess__Kerr_Kerr__x_posn[101] "x coordinate of Kerr BH" STEERABLE=recover
 {
 *:* :: "any real number"
 } 0.0
-real initial_guess__Kerr_Kerr__y_posn[101] "y coordinate of Kerr BH"
+real initial_guess__Kerr_Kerr__y_posn[101] "y coordinate of Kerr BH" STEERABLE=recover
 {
 *:* :: "any real number"
 } 0.0
-real initial_guess__Kerr_Kerr__z_posn[101] "z coordinate of Kerr BH"
+real initial_guess__Kerr_Kerr__z_posn[101] "z coordinate of Kerr BH" STEERABLE=recover
 {
 *:* :: "any real number"
 } 0.0
-real initial_guess__Kerr_Kerr__mass[101] "mass of Kerr BH"
+real initial_guess__Kerr_Kerr__mass[101] "mass of Kerr BH" STEERABLE=recover
 {
 (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[101] "dimensionless spin a=J/m^2 of Kerr BH"
+real initial_guess__Kerr_Kerr__spin[101] "dimensionless spin a=J/m^2 of Kerr BH" STEERABLE=recover
 {
 (-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[101] "x coordinate of Kerr BH"
+real initial_guess__Kerr_KerrSchild__x_posn[101] "x coordinate of Kerr BH" STEERABLE=recover
 {
 *:* :: "any real number"
 } 0.0
-real initial_guess__Kerr_KerrSchild__y_posn[101] "y coordinate of Kerr BH"
+real initial_guess__Kerr_KerrSchild__y_posn[101] "y coordinate of Kerr BH" STEERABLE=recover
 {
 *:* :: "any real number"
 } 0.0
-real initial_guess__Kerr_KerrSchild__z_posn[101] "z coordinate of Kerr BH"
+real initial_guess__Kerr_KerrSchild__z_posn[101] "z coordinate of Kerr BH" STEERABLE=recover
 {
 *:* :: "any real number"
 } 0.0
-real initial_guess__Kerr_KerrSchild__mass[101] "mass of Kerr BH"
+real initial_guess__Kerr_KerrSchild__mass[101] "mass of Kerr BH" STEERABLE=recover
 {
 (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[101] "dimensionless spin a=J/m^2 of Kerr BH"
+real initial_guess__Kerr_KerrSchild__spin[101] "dimensionless spin a=J/m^2 of Kerr BH" STEERABLE=recover
 {
 (-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[101] "x coordinate of sphere center"
+real initial_guess__coord_sphere__x_center[101] "x coordinate of sphere center" STEERABLE=recover
 {
 *:* :: "any real number"
 } 0.0
-real initial_guess__coord_sphere__y_center[101] "y coordinate of sphere center"
+real initial_guess__coord_sphere__y_center[101] "y coordinate of sphere center" STEERABLE=recover
 {
 *:* :: "any real number"
 } 0.0
-real initial_guess__coord_sphere__z_center[101] "z coordinate of sphere center"
+real initial_guess__coord_sphere__z_center[101] "z coordinate of sphere center" STEERABLE=recover
 {
 *:* :: "any real number"
 } 0.0
-real initial_guess__coord_sphere__radius[101] "radius of sphere"
+real initial_guess__coord_sphere__radius[101] "radius of sphere" STEERABLE=recover
 {
 (0.0:* :: "any real number > 0.0"
 } 2.0
 
 # parameters for initial_guess_method = "ellipsoid"
 real initial_guess__coord_ellipsoid__x_center[101] \
-  "x coordinate of ellipsoid center"
+  "x coordinate of ellipsoid center" STEERABLE=recover
 {
 *:* :: "any real number"
 } 0.0
 real initial_guess__coord_ellipsoid__y_center[101] \
-  "y coordinate of ellipsoid center"
+  "y coordinate of ellipsoid center" STEERABLE=recover
 {
 *:* :: "any real number"
 } 0.0
 real initial_guess__coord_ellipsoid__z_center[101] \
-  "z coordinate of ellipsoid center"
+  "z coordinate of ellipsoid center" STEERABLE=recover
 {
 *:* :: "any real number"
 } 0.0
-real initial_guess__coord_ellipsoid__x_radius[101] "x radius of ellipsoid"
+real initial_guess__coord_ellipsoid__x_radius[101] "x radius of ellipsoid" STEERABLE=recover
 {
 (0.0:* :: "any real number > 0.0"
 } 2.0
-real initial_guess__coord_ellipsoid__y_radius[101] "y radius of ellipsoid"
+real initial_guess__coord_ellipsoid__y_radius[101] "y radius of ellipsoid" STEERABLE=recover
 {
 (0.0:* :: "any real number > 0.0"
 } 2.0
-real initial_guess__coord_ellipsoid__z_radius[101] "z radius of ellipsoid"
+real initial_guess__coord_ellipsoid__z_radius[101] "z radius of ellipsoid" STEERABLE=recover
 {
 (0.0:* :: "any real number > 0.0"
 } 2.0
@@ -356,10 +506,11 @@ real initial_guess__coord_ellipsoid__z_radius[101] "z radius of ellipsoid"
 # - each line contains various tab-separated fields, as described by
 #   the header comment
 #
-Boolean output_BH_diagnostics \
-  "should we output BH diagnostics to a data file for each AH found?"
+boolean output_BH_diagnostics \
+  "should we output BH diagnostics to a data file for each AH found?" \
+  STEERABLE=always
 {
-} true
+} "true"
 
 #
 # These file names are actually just "base" file names, with the full
@@ -373,19 +524,20 @@ Boolean output_BH_diagnostics \
 # - the third %s is the file name extension as set by the
 #   BH_diagnostics_file_name_extension  parameter
 #
-string BH_diagnostics_directory "directory for BH diagnostics output file(s)"
+string BH_diagnostics_directory "directory for BH diagnostics output file(s)" \
+  STEERABLE=always
 {
 ".+" :: "any nonempty string"
 "^$" :: "an empty string to default to IO::out_dir"
 } ""
 string BH_diagnostics_base_file_name \
-  "base file name for BH diagnostics output file(s)"
+  "base file name for BH diagnostics output file(s)" STEERABLE=always
 {
 ".+" :: "any nonempty string"
 } "BH_diagnostics"
 
 string BH_diagnostics_file_name_extension \
-  "extension for BH diagnostics data files"
+  "extension for BH diagnostics data files" STEERABLE=always
 {
 ".+" :: "any nonempty string"
 } "gp"
@@ -404,7 +556,8 @@ string BH_diagnostics_file_name_extension \
 # of one-file-per-horizon-per-time-step apparent-horizon-shape output
 # files
 int output_h_every \
-  "how often (in Cactus time steps) should we output h (0 to disable)?"
+  "how often (in Cactus time steps) should we output h (0 to disable)?" \
+  STEERABLE=always
 {
 0   :: "don't output h at all"
 1:* :: "any integer >= 1"
@@ -413,38 +566,48 @@ int output_h_every \
 # setting this > 0 is probably only of interest if the Newton iteration
 # fails to converge, or if you're debugging AHFinderDirect internals
 int output_Theta_every \
-  "how often (in Cactus time steps) should we output the Theta(h) functions?"
+  "how often (in Cactus time steps) should we output the Theta(h) functions?" \
+  STEERABLE=always
 {
 0   :: "don't output Theta(h) at all"
 1:* :: "any integer >= 1"
 } 0
 
-keyword horizon_file_format \
-  "what file format should we use for h and Theta(h) data files?"
+int output_mean_curvature_every \
+  "how often (in Cactus time steps) should we output the mean_curvature(h) functions?" \
+  STEERABLE=always
+{
+0   :: "don't output mean_curvature(h) at all"
+1:* :: "any integer >= 1"
+} 0
+
+boolean output_ASCII_files "output h and Theta(h) as ASCII files" STEERABLE=always
+{
+} "yes"
+
+boolean output_HDF5_files "output h and Theta(h) as HDF5 files" STEERABLE=always
 {
-"ASCII (gnuplot)"	:: "simple ASCII format, directly readable by gnuplot"
-"HDF5"			:: "HDF5 surface format (alas not implemented yet)"
-} "ASCII (gnuplot)"
+} "no"
 
 # n.b. this refers to the patch system (angular) interpatch ghost zones,
 #      *not* the Cactus interprocessor ghost zones
-Boolean output_ghost_zones_for_h \
+boolean output_ghost_zones_for_h \
   "should we include the patch system (angular) interpatch ghost zones \
-   in h data files?"
+   in h data files?" STEERABLE=always
 {
-} false
+} "false"
 
 # n.b. making this "gnuplot" probably isn't a good idea,
 #      since it could create confusion with gnuplot command files
 string ASCII_gnuplot_file_name_extension \
-  "extension for ASCII (gnuplot) data files"
+  "extension for ASCII (gnuplot) data files" STEERABLE=always
 {
 ".+" :: "any nonempty string"
 } "gp"
-string HDF5_file_name_extension "extension for HDF5 data files"
+string HDF5_file_name_extension "extension for HDF5 data files" STEERABLE=always
 {
 ".+" :: "any nonempty string"
-} "hdf5"
+} "h5"
 
 #
 # These file names are actually just "base" file names, with the full
@@ -461,29 +624,45 @@ string HDF5_file_name_extension "extension for HDF5 data files"
 #   {ASCII,HDF5}_data_file_name_extension
 #
 string h_directory \
-  "directory for horizon shape and other similar output (or input) file(s)"
+  "directory for horizon shape and other similar output (or input) file(s)" \
+   STEERABLE=always
 {
 ".+" :: "any nonempty string"
 "^$" :: "an empty string to default to IO::out_dir"
 } ""
 
 string h_base_file_name \
-  "base file name for horizon shape h input/output file(s)"
+  "base file name for horizon shape h input/output file(s)" \
+  STEERABLE=always
 {
 ".+" :: "any nonempty string"
 } "h"
 
-string Theta_base_file_name "base file name for Theta(h) output file(s)"
+string Theta_base_file_name "base file name for Theta(h) output file(s)" \
+  STEERABLE=always
 {
 ".+" :: "any nonempty string"
 } "Theta"
 
+string mean_curvature_base_file_name "base file name for mean_curvature(h) output file(s)" \
+  STEERABLE=always
+{
+".+" :: "any nonempty string"
+} "mean_curvature"
+
 string Delta_h_base_file_name \
-  "base file name for horizon-shape-update Delta_h output file(s)"
+  "base file name for horizon-shape-update Delta_h output file(s)" \
+  STEERABLE=always
 {
 ".+" :: "any nonempty string"
 } "Delta_h"
 
+int h_min_digits \
+  "minimum number of digits for the iteration number in the file name" STEERABLE=always
+{
+0:* :: ""
+} 0
+
 #
 # Thomas Radke has written a set of OpenDX macros to read AHFinderDirect
 # ASCII (gnuplot) format files.  These macros require a "control file"
@@ -498,13 +677,13 @@ string Delta_h_base_file_name \
 # - the %d is the apparent horizon number
 # - the third %s is the file name extension OpenDX_control_file_name_extension
 #
-Boolean output_OpenDX_control_files \
+boolean output_OpenDX_control_files \
   "should we output OpenDX control files to allow reading of AHFinderDirect \
-   'ASCII (gnuplot)' format data files?"
+   'ASCII (gnuplot)' format data files?" STEERABLE=always
 {
-} true
+} "true"
 string OpenDX_control_file_name_extension \
-  "file name extension for OpenDX control files"
+  "file name extension for OpenDX control files" STEERABLE=always
 {
 ".+" :: "any nonempty string"
 } "dx"
@@ -516,20 +695,23 @@ string OpenDX_control_file_name_extension \
 #
 
 # this is mainly useful for debugging purposes
-Boolean output_initial_guess \
-  "should we output the initial guess back to the h data file?"
+boolean output_initial_guess \
+  "should we output the initial guess back to the h data file?" \
+  STEERABLE=always
 {
-} false
+} "false"
 
 # for debugging convergence failures, we can optionally output
 # h, Theta, and delta_h at each Newton iteration
 # (the file names are the usual ones with ".it%d" appended)
-Boolean debugging_output_at_each_Newton_iteration \
-  "should we output {h, Theta, delta_h} at each Newton iteration?"
+boolean debugging_output_at_each_Newton_iteration \
+  "should we output {h, Theta, delta_h} at each Newton iteration?" \
+  STEERABLE=recover
 {
-} false
+} "false"
 
-string Jacobian_base_file_name "base file name for Jacobian output file(s)"
+string Jacobian_base_file_name "base file name for Jacobian output file(s)" \
+  STEERABLE=always
 {
 ".+" :: "any valid file name"
 } "Jacobian.dat"
@@ -541,15 +723,17 @@ string Jacobian_base_file_name "base file name for Jacobian output file(s)"
 # ***** based on each apparent horizon shape *****
 #
 
-Boolean set_mask_for_all_horizons \
-  "should we set a mask grid function (or functions) for all horizons?"
+boolean set_mask_for_all_horizons \
+  "should we set a mask grid function (or functions) for all horizons?" \
+  STEERABLE=recover
 {
-} false
+} "false"
 
-Boolean set_mask_for_individual_horizon[101] \
-  "should we set a mask grid function (or functions) for *this* horizon?"
+boolean set_mask_for_individual_horizon[101] \
+  "should we set a mask grid function (or functions) for *this* horizon?" \
+  STEERABLE=recover
 {
-} false
+} "false"
 
 #
 # If we set a mask, we do so based on partitioning the Cactus grid into
@@ -570,23 +754,22 @@ Boolean set_mask_for_individual_horizon[101] \
 # the geometric mean of the base grid's x, y, and z Cactus grid spacings)
 # (The "base grid" part here only matters if you're doing mesh refinement.)
 #
-real mask_radius_multiplier						\
-  "radius multiplier to define the 'inside' mask region"		\
-  STEERABLE=ALWAYS
+real mask_radius_multiplier \
+  "radius multiplier to define the 'inside' mask region" \
+  STEERABLE=recover
 {
-(0:*) ::								\
+(0:*) :: \
   "any positive real number; typically this will be slightly less than 1.0"
 } 0.8
-real mask_radius_offset							\
-  "radius offset (in Cactus grid spacings)				\
-   to define the 'inside' mask region"					\
-  STEERABLE=ALWAYS
+real mask_radius_offset \
+  "radius offset (in Cactus base grid spacings) to define the 'inside' mask region" \
+  STEERABLE=recover
 {
 *:* :: "any real number; typically this will be negative"
 } -5.0
-real mask_buffer_thickness						\
-  "thickness (in Cactus grid spacings) of the 'buffer' mask region"	\
-  STEERABLE=ALWAYS
+real mask_buffer_thickness \
+  "thickness (in Cactus base grid spacings) of the 'buffer' mask region" \
+  STEERABLE=recover
 {
 *:* :: "any real number; typically this will be positive"
 } 5.0
@@ -600,11 +783,11 @@ real mask_buffer_thickness						\
 #    values independently at each time step, so all three regions can grow
 #    or shrink depending on the horizon positions/shapes.
 #
-Boolean mask_is_noshrink						\
-  "should we prevent the inside & buffer regions from ever shrinking?"	\
-  STEERABLE=ALWAYS
+boolean mask_is_noshrink \
+  "should we prevent the inside & buffer regions from ever shrinking?" \
+  STEERABLE=recover
 {
-} true
+} "true"
 
 #
 # If we're using mesh refinement (eg Carpet) it's possible to find a
@@ -628,9 +811,9 @@ Boolean mask_is_noshrink						\
 # the default setting for this parameter is effectively -infinity, to
 # excise any horizon.
 #
-real min_horizon_radius_points_for_mask					\
-  "only set mask if min r_inner >= this number of local grid spacings"	\
-  STEERABLE=ALWAYS
+real min_horizon_radius_points_for_mask \
+  "only set mask if min r_inner >= this number of local grid spacings" \
+  STEERABLE=recover
 {
 *:* :: "any real number"
 } -1.0e10
@@ -651,39 +834,35 @@ real min_horizon_radius_points_for_mask					\
 #	does horizon finding.]
 # You can choose to set either (or even both!) of these.
 #
-Boolean set_old_style_mask						\
-  "if we're setting a mask,						\
-   should we set an old-style (CCTK_REAL) mask gridfn?"			\
-  STEERABLE = ALWAYS
+boolean set_old_style_mask \
+  "if we're setting a mask, should we set an old-style (CCTK_REAL) mask gridfn?" STEERABLE=recover
 {
-} true
-Boolean set_new_style_mask						\
-  "if we're setting a mask,						\
-   should we set an new-style (CCTK_INT) mask gridfn?"			\
-  STEERABLE = ALWAYS
+} "true"
+boolean set_new_style_mask \
+  "if we're setting a mask, should we set an new-style (CCTK_INT) mask gridfn?" STEERABLE=recover
 {
-} false
+} "false"
 
 #
 # mask info for  mask_type = "old-style (CCTK_REAL)"
 # defaults match CactusEinstein/AHFinder
 #
-string old_style_mask_gridfn_name "name of the old-style mask grid function"
+string old_style_mask_gridfn_name "name of the old-style mask grid function" STEERABLE=recover
 {
 ".+" :: "any valid Cactus grid function name"
 } "SpaceMask::emask"
 real old_style_mask_inside_value \
-  "set the old-style mask to this value in the 'inside' region"
+  "set the old-style mask to this value in the 'inside' region" STEERABLE=recover
 {
 *:* :: "any real number"
 } 0.0
 real old_style_mask_buffer_value \
-  "set the old-style mask to this value in the 'buffer' region"
+  "set the old-style mask to this value in the 'buffer' region" STEERABLE=recover
 {
 *:* :: "any real number"
 } 0.5
 real old_style_mask_outside_value \
-  "set the old-style mask to this value in the 'outside' region"
+  "set the old-style mask to this value in the 'outside' region" STEERABLE=recover
 {
 *:* :: "any real number"
 } 1.0
@@ -691,30 +870,30 @@ real old_style_mask_outside_value \
 #
 # mask info for  mask_type = "new-style (CCTK_INT)"
 #
-string new_style_mask_gridfn_name "name of the new-style mask grid function"
+string new_style_mask_gridfn_name "name of the new-style mask grid function" STEERABLE=recover
 {
 ".+" :: "any valid Cactus grid function name"
 } "SpaceMask::space_mask"
 string new_style_mask_bitfield_name \
-  "name of the new-style mask bit field ('type') as registered with SpaceMask"
+  "name of the new-style mask bit field ('type') as registered with SpaceMask" STEERABLE=recover
 {
 ".+" :: "any valid bit field ('type') name registered with the SpaceMask thorn"
 } "mask"
 string new_style_mask_inside_value \
   "set the specified bit field of the new-style mask to this named state \
-   at grid points in the 'inside' region"
+   at grid points in the 'inside' region" STEERABLE=recover
 {
 ".+" :: "any state name registered with the SpaceMask thorn"
 } "inside"
 string new_style_mask_buffer_value \
   "set the specified bit field of the new-style mask to this named state \
-   at grid points in the 'buffer' region"
+   at grid points in the 'buffer' region" STEERABLE=recover
 {
 ".+" :: "any state name registered with the SpaceMask thorn"
 } "buffer"
 string new_style_mask_outside_value \
   "set the specified bit field of the new-style mask to this named state \
-   at grid points in the 'outside' region"
+   at grid points in the 'outside' region" STEERABLE=recover
 {
 ".+" :: "any state name registered with the SpaceMask thorn"
 } "outside"
@@ -740,7 +919,7 @@ string new_style_mask_outside_value \
 #     ==> 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)"
+   (error occurs on first Newton iteration)" STEERABLE=recover
 {
 -1:* :: "any valid Cactus warning level"
 } 1
@@ -749,18 +928,18 @@ int warn_level__point_outside__initial \
 #     ==> 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)"
+   (error occurs on subsequent Newton iteration)" STEERABLE=recover
 {
 -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
+# 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"
+   so we have to skip the finite-geometry check" STEERABLE=recover
 {
 -1:* :: "any valid Cactus warning level"
 } 3
@@ -768,7 +947,7 @@ int warn_level__skipping_finite_check \
 # 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}"
+   values {g_ij, partial_k g_ij, K_ij}" STEERABLE=recover
 {
 -1:* :: "any valid Cactus warning level"
 } 1
@@ -780,7 +959,7 @@ int warn_level__nonfinite_geometry \
 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)"
+   (error occurs on first Newton iteration)" STEERABLE=recover
 {
 -1:* :: "any valid Cactus warning level"
 } 2
@@ -788,7 +967,7 @@ int warn_level__gij_not_positive_definite__initial \
 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)"
+   (error occurs on subsequent Newton iteration)" STEERABLE=recover
 {
 -1:* :: "any valid Cactus warning level"
 } 2
@@ -808,13 +987,13 @@ int warn_level__gij_not_positive_definite__subsequent \
 #
 int max_Newton_iterations__initial \
   "maximum number of Newton iterations before giving up \
-   when initially finding a given horizon"
+   when initially finding a given horizon" STEERABLE=recover
 {
 (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"
+   when re-finding a given horizon after finding it before" STEERABLE=recover
 {
 (0:* :: "any positive integer"
 } 10
@@ -826,7 +1005,7 @@ int max_Newton_iterations__subsequent \
 # 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"
+  "don't let horizon move > this fraction of mean radius in a Newton iteration" STEERABLE=recover
 {
 (0.0:* :: "any positive real number"
 } 0.1
@@ -843,7 +1022,7 @@ real max_allowable_Delta_h_over_h \
 #
 real max_allowable_horizon_radius[101] \
   "max mean-coordinate-radius allowed for any trial surface \
-   before we give up and say we can't find this horizon"
+   before we give up and say we can't find this horizon" STEERABLE=recover
 {
 (0.0:* :: "any positive real number"
 } 1.0e10
@@ -852,7 +1031,7 @@ real max_allowable_horizon_radius[101] \
 # convergence tolerance for the Newton iteration
 #
 real Theta_norm_for_convergence \
-  "we declare the horizon to be found if ||Theta||_infinity <= this"
+  "we declare the horizon to be found if ||Theta||_infinity <= this" STEERABLE=recover
 {
 (0.0:* :: "any positive real number"
 } 1.0e-8
@@ -864,11 +1043,36 @@ real Theta_norm_for_convergence \
 #
 real max_allowable_Theta \
   "max ||Theta||_infinity allowed for any trial surface \
-   before we give up and say we can't find this horizon"
+   before we give up and say we can't find this horizon" STEERABLE=recover
 {
 (0.0:* :: "any positive real number"
 } 1.0e10
 
+#
+# To detect some divergence cases faster, we also do not allow the Theta
+# norm to grow for more than a certain number of iterations.
+#
+int max_allowable_Theta_growth_iterations \
+  "max number of consecutive iterations during which ||Theta||_infinity \
+   is allowed to grow before we give up and say we can't find this horizon" STEERABLE=recover
+{
+0   :: "infinitly many"
+1:* :: "that many"
+} 0
+
+#
+# To detect some divergence cases faster, we also do not allow the Theta
+# norm to oscillate without shrinking for more than a certain number of
+# iterations.
+#
+int max_allowable_Theta_nonshrink_iterations \
+  "max number of consecutive iterations during which ||Theta||_infinity \
+   is allowed to oscillate without shrinking before we give up and say \
+   we can't find this horizon" STEERABLE=recover
+{
+0   :: "infinitly many"
+1:* :: "that many"
+} 0
 
 ################################################################################
 
@@ -895,19 +1099,31 @@ real max_allowable_Theta \
 # of the horizon radius is no problem, and even 1/2 the horizon radius
 # only slows the convergence by an extra iteration or two.
 #
-real origin_x[101] "global x coordinate of patch system origin"
+real origin_x[101] "global x coordinate of patch system origin" STEERABLE=recover
 {
 *:* :: "any real number"
 } 0.0
-real origin_y[101] "global y coordinate of patch system origin"
+real origin_y[101] "global y coordinate of patch system origin" STEERABLE=recover
 {
 *:* :: "any real number"
 } 0.0
-real origin_z[101] "global z coordinate of patch system origin"
+real origin_z[101] "global z coordinate of patch system origin" STEERABLE=recover
 {
 *:* :: "any real number"
 } 0.0
 
+boolean move_origins "move the origins with the horizons" STEERABLE=recover
+{
+} "no"
+
+boolean reshape_while_moving "reshape the horizons when moving them" STEERABLE=recover
+{
+} "no"
+
+boolean predict_origin_movement "predict origin movement when moving the origins" STEERABLE=recover
+{
+} "no"
+
 #
 # The "(rotating)" patch system types are ok for evaluating Theta(h),
 # but alas they don't work yet for apparent horizon finding
@@ -966,11 +1182,21 @@ keyword patch_system_type[101] "what type of patch system should we use?"
 # ... 3rd power of this parameter
 #     if Jacobian_store_solve_method = "row-oriented sparse matrix/ILUCG"
 #
+#int N_zones_per_right_angle[101] "sets angular resolution of patch systems" ACCUMULATOR-BASE max_N_zones_per_right_angle
 int N_zones_per_right_angle[101] "sets angular resolution of patch systems"
 {
 1:* :: "any integer >= 1; must be even for patch systems other than full-sphere"
 } 18
 
+# Default parameter values do not trigger accumulator expressions.
+# Therefore the default values here must be large enough for the default
+# horizon shape.
+#int max_N_zones_per_right_angle "the maximum of all N_zones_per_right_angle -- calculated automatically; do not set this parameter directly" ACCUMULATOR=((x>y)*x+!(x>y)*y)
+int max_N_zones_per_right_angle "the maximum of all N_zones_per_right_angle"
+{
+1:* :: "must be at least the maximum of all N_zones_per_right_angle"
+} 18
+
 #
 # This parameter sets the width of the interpatch ghost zones in the
 # patch system.  Note that this thorn uses the terminology "ghost zone"
@@ -1005,7 +1231,7 @@ int patch_overlap_width \
 # ***** parameters for the Jacobian matrix *****
 #
 
-keyword Jacobian_compute_method "how do we compute the Jacobian matrix?"
+keyword Jacobian_compute_method "how do we compute the Jacobian matrix?" STEERABLE=recover
 {
 # for debugging only"
 "numerical perturbation"    :: "n.b. this is *very* slow"
@@ -1030,7 +1256,7 @@ keyword Jacobian_compute_method "how do we compute the Jacobian matrix?"
 # for details on these libraries.
 #
 keyword Jacobian_store_solve_method \
-  "how do we store/linear-solve the Jacobian matrix?"
+  "how do we store/linear-solve the Jacobian matrix?" STEERABLE=recover
 {
 # good for debugging, but very slow for large  N_zones_per_right_angle
 "dense matrix/LAPACK"	:: \
@@ -1051,7 +1277,7 @@ keyword Jacobian_store_solve_method \
 
 # extra parameters for
 #   Jacobian_store_solve_method == "row-oriented sparse matrix/ILUCG"
-real ILUCG__error_tolerance "error tolerance for conjugate gradient iteration"
+real ILUCG__error_tolerance "error tolerance for conjugate gradient iteration" STEERABLE=recover
 {
 (*:0.0)	:: \
   "negative ==> scale the absolute value by the floating point roundoff \
@@ -1060,18 +1286,18 @@ real ILUCG__error_tolerance "error tolerance for conjugate gradient iteration"
 (0.0:*)	:: \
   "positive ==> error tolerance"
 } 1.0e-10
-Boolean ILUCG__limit_CG_iterations \
-  "should we limit the maximum number of conjugate gradient iterations allowed?"
+boolean ILUCG__limit_CG_iterations \
+  "should we limit the maximum number of conjugate gradient iterations allowed?" STEERABLE=recover
 {
-false	:: "no limit on CG iterations"
-true	:: "limit to Neqns CG iterations"
-} true
+"false"	:: "no limit on CG iterations"
+"true"	:: "limit to Neqns CG iterations"
+} "true"
 
 # extra parameters for
 #   Jacobian_store_solve_method == "row-oriented sparse matrix/UMFPACK"
 int UMFPACK__N_II_iterations \
   "number of iterative-improvement iterations to do inside UMFPACK \
-   after the sparse LU decompose/solve, each time we solve a linear system"
+   after the sparse LU decompose/solve, each time we solve a linear system" STEERABLE=recover
 {
 -1	:: "use the UMFPACK default"
 0	:: "don't do iterative improvement"
@@ -1094,7 +1320,7 @@ int UMFPACK__N_II_iterations \
 # In practice the default value should be fine
 #
 real Jacobian_perturbation_amplitude \
-  "perturbation amplitude for 1-sided finite differencing for Jacobians"
+  "perturbation amplitude for 1-sided finite differencing for Jacobians" STEERABLE=recover
 {
 (0.0:* :: "any real number > 0"
 } 1.0e-6
@@ -1102,10 +1328,10 @@ real Jacobian_perturbation_amplitude \
 # 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?"
+boolean test_all_Jacobian_compute_methods \
+  "should we test all Jacobian computation methods, or just NP?" STEERABLE=recover
 {
-} true
+} "true"
 
 ################################################################################
 
@@ -1135,13 +1361,13 @@ Boolean test_all_Jacobian_compute_methods \
 #
 
 string coordinate_system_name \
-  "name under which the coordinate system is registered in Cactus"
+  "name under which the coordinate system is registered in Cactus" STEERABLE=recover
 {
 ".+" :: "any nonempty string"
 } "cart3d"
 
 string geometry_interpolator_name \
-  "name under which the geometry interpolation operator is registered in Cactus"
+  "name under which the geometry interpolation operator is registered in Cactus" STEERABLE=recover
 {
 ".+" :: "any nonempty string"
 } "Hermite polynomial interpolation"
@@ -1151,7 +1377,7 @@ string geometry_interpolator_name \
 # which requires driver::ghost_size >= 2.
 #
 string geometry_interpolator_pars \
-  "parameters for the geometry interpolator"
+  "parameters for the geometry interpolator" STEERABLE=recover
 {
 ".*" :: \
   "any string acceptable to Util_TableSetFromString() and to the interpolator"
@@ -1166,11 +1392,11 @@ string geometry_interpolator_pars \
 # from the Cactus grid, we can instead hardwire it to an Eddington-Finkelstein
 # slice of Schwarzschild spacetime
 #
-Boolean hardwire_Schwarzschild_EF_geometry \
+boolean hardwire_Schwarzschild_EF_geometry \
   "should we hard-wire the geometry to Schwarzschild/EF instead of \
    interpolating from the Cactus grid?"
 {
-} false
+} "false"
 
 real geometry__Schwarzschild_EF__mass "mass of Schwarzschild BH"
 {
@@ -1227,14 +1453,16 @@ real geometry__Schwarzschild_EF__Delta_xyz \
 # useful in catching assorted wierdness, so it's probably worth leaving
 # them enabled unless you're trying to squeeze every last nanosecond...
 #
-Boolean check_that_h_is_finite \
-  "should we check that horizon shape function h is finite?"
+boolean check_that_h_is_finite \
+  "should we check that horizon shape function h is finite?" \
+  STEERABLE=recover
 {
-} true
-Boolean check_that_geometry_is_finite \
-  "should we check the interpolated geometry variables are finite?"
+} "true"
+boolean check_that_geometry_is_finite \
+  "should we check the interpolated geometry variables are finite?" \
+  STEERABLE=recover
 {
-} true
+} "true"
 
 ################################################################################
 
@@ -1253,13 +1481,13 @@ Boolean check_that_geometry_is_finite \
 #
 
 string interpatch_interpolator_name \
-  "name under which the interpatch interpolation operator is registered in Cactus"
+  "name under which the interpatch interpolation operator is registered in Cactus" STEERABLE=recover
 {
 ".+" :: "any string (in practice it should be nonempty)"
 } "Lagrange polynomial interpolation"
 
 string interpatch_interpolator_pars \
-  "parameters for the interpatch interpolator"
+  "parameters for the interpatch interpolator" STEERABLE=recover
 {
 ".*" :: \
   "any string acceptable to Util_TableSetFromString() and to the interpolator"
@@ -1281,14 +1509,14 @@ string interpatch_interpolator_pars \
 #
 
 string surface_interpolator_name \
-  "name under which the surface interpolation operator is registered in Cactus"
+  "name under which the surface interpolation operator is registered in Cactus" STEERABLE=recover
 {
 "^$" :: "the empty string if this interpolator isn't going to be used"
 ".+" :: "any string (in practice it should be nonempty)"
 } "Lagrange polynomial interpolation"
 
 string surface_interpolator_pars \
-  "parameters for the surface interpolator"
+  "parameters for the surface interpolator" STEERABLE=recover
 {
 ".*" :: \
   "any string acceptable to Util_TableSetFromString() and to the interpolator"
@@ -1307,7 +1535,7 @@ string surface_interpolator_pars \
 # in either the rho or the sigma direction, i.e. it's 45 or 90 degrees
 # divided by delta_drho_dsigma.
 #
-keyword integral_method "how do we compute integrals over the horizon?"
+keyword integral_method "how do we compute integrals over the horizon?" STEERABLE=recover
 {
 "trapezoid"		:: "alternate name for trapezoid rule"
 "trapezoid rule"	:: "trapezoid rule (2nd order for smooth functions)"
@@ -1357,10 +1585,10 @@ keyword integral_method "how do we compute integrals over the horizon?"
 ### true ==> gives a more thorough test of the Jacobian,
 ###          but makes the test run much slower
 ### false ==> gives a slightly less thorough test, but runs faster
-##Boolean NP_Jacobian__perturb_all_y_patch_points \
+##boolean NP_Jacobian__perturb_all_y_patch_points \
 ##  "should we perturb at *all* points in the y patch, or just those with the \
 ##   iperp which is (supposedly) involved in the interpatch interpolation?"
 ##{
-##} true
+##} "true"
 ##
 ##################################################################################