From 9716af1598ddfd2ab8ee7198b35cca1df312c4fd Mon Sep 17 00:00:00 2001 From: svnadmin Date: Thu, 26 Jun 2008 13:51:26 +0000 Subject: 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 --- param.ccl | 644 ++++++++++++++++++++++++++++++++++++++++++-------------------- 1 file changed, 436 insertions(+), 208 deletions(-) (limited to 'param.ccl') 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" ## ################################################################################## -- cgit v1.2.3