\label{parameter_file}
The parameter file name is passed to \BB\ as the only command line
argument to the master process which is started by the user. Each line
of the parameter file contains either a comment or two words -- a
keyword and a value, separated by white space. If the first word
(sequence of non-white-space characters) on a line is not a keyword,
then the line is considered a comment line. Otherwise the parameter
corresponding to the keyword is set to the listed value. Usually the
keyword is the same as the parameter name in the source code. Here we
list the keywords, the type of value that should be given with the
keywords and the default value. A parameter corresponding to keyword
``K'' in process ``P'' can also be set by using the keyword ``P\_K''.

To make this list shorter, occasionally a comma separated list of parameters
is given if the meanings of those parameters are strongly
connected. For clarity, the constant name is sometimes given instead
of the numerical value for default settings and options. The
corresponding value is given in curly braces for convenience.

\subsection{Global parameters}
\begin{description}

\item[{\tt verbosity} -- integer (0).]
Sets the verbosity of all processes to the given value. In general,
the greater this number the more verbose each process is. Experiment
to find out what this means.

\item[{\tt random\_seed} -- integer (17).]
A random seed.

\item[{\tt granularity} -- double (1e-6).]
should be set to ``the minimum difference between two distinct
objective function values'' less the epsilon tolerance. E.g., if every
variable is integral and the objective coefficients are integral then
for any feasible solution the objective value is integer, so {\tt
granularity} could be correctly set to .99999.

\item[{\tt upper\_bound} -- double (none)].
The value of the best known upper bound.

\end{description}

\subsection{Master Process parameters}
\begin{description}

\item[{\tt M\_verbosity} -- integer (0).]

\item[{\tt M\_random\_seed} -- integer (17).]
A random seed just for the Master Process.

\item[{\tt upper\_bound} -- double (no upper bound).]
This parameter is used if the user wants to artificially impose an
upper bound (for instance if a solution of that value is already
known).

\label{upper_bound_estimate}
\item[{\tt upper\_bound\_estimate} -- double (no estimate).]
This parameter is used if the user wants to provide an estimate of the
optimal value which will help guide the search. This is used in
conjunction with the diving strategy \htmlref{\tt
BEST\_ESTIMATE}{diving_strategy}.

\item[{\tt tm\_exe, dg\_exe} -- strings (``tm'', ``dg'').]
The name of the executable files of the TM and DG processes. Note that
the TM executable name may have extensions that depend on the
configuration of the modules, but the default is always set to the
file name produced by the make file. If you change the name of the
treemanager executable from the default, you must set this parameter
to the new name.

\item[{\tt tm\_debug, dg\_debug} -- boolean (both {\tt FALSE}).]
Whether these processes should be started under a debugger or not (see
\ref{debugging-PVM} for more details on this).

\item[{\tt tm\_machine} -- string (empty string).]
On which processor of the virtual machine the TM should be run. Leaving this
parameter as an empty string means arbitrary selection.

\item[{\tt do\_draw\_graph} -- boolean ({\tt FALSE}).]
Whether to start up the DG process or not (see Section \ref{IGD} for
an introduction to this).

\item[{\tt do\_branch\_and\_cut} -- boolean ({\tt TRUE}).]
Whether to run the branch and cut algorithm or not. (Set this to {\tt
FALSE} to run the user's heuristics only.)

\end{description}

\subsection{Draw Graph parameters}
\begin{description}

\item[{\tt source\_path} -- string (``.'').]
The directory where the DG tcl/tk scripts reside.

\item[{\tt echo\_commands} -- boolean ({\tt FALSE}).]
Whether to echo the tcl/tk commands on the screen or not.

\item[{\tt canvas\_width, canvas\_height} -- integers (1000, 700).]
The default width and height of the drawing canvas in pixels.

\item[{\tt viewable\_width, viewable\_height} -- integers (600, 400).]
The default viewable width and height of the drawing canvas in pixels.

\item[{\tt interactive\_mode} -- integer ({\tt TRUE}).]
Whether it is allowable to change things interactively on the canvas or not.

\item[{\tt node\_radius} -- integer (8).]
The default radius of a displayed graph node.

\item[{\tt disp\_nodelabels, disp\_nodeweights, disp\_edgeweights} -- integers
(all {\tt TRUE}).]
Whether to display node labels, node weights, and edge weights or not.

\item[{\tt nodelabel\_font, nodeweight\_font, edgeweight\_font} -- strings
(all ``-adobe-helvetica-...'').]
The default character font for displaying node labels, node weights and edge
weights. 

\item[{\tt node\_dash, edge\_dash} -- strings (both empty string).]
The dash pattern of the circles drawn around dashed nodes and that of
dashed edges.

\end{description}

\subsection{Tree Manager parameters}
\label{tm_params}
\begin{description}

\item[{\tt TM\_verbosity} -- integer (0).]
The verbosity of the TM process.

\item[{\tt lp\_exe, cg\_exe, cp\_exe} -- strings (``lp'', ``cg'',
``cp'').]
The name of the LP, CG, and CP process binaries. Note: when running in
parallel using PVM, these executables (or links to them) must reside
in the {\tt PVM\_ROOT/bin/PVM\_ARCH/} directory. Also, be sure to note
that the executable names may have extensions that depend on the
configuration of the modules, but the defaults will always be set to
the name that the make file produce.

\item[{\tt lp\_debug, cg\_debug, cp\_debug} -- boolean (all {\tt
FALSE}).]
Whether the processes should be started under a debugger or not.

\item[{\tt max\_active\_nodes} -- integer (1).]
The maximum number of active search tree nodes---equal to the number of
LP and CG tandems to be started up.

\item[{\tt max\_cp\_num} -- integer (0).]
The maximum number of cut pools to be used.

\item[{\tt lp\_mach\_num, cg\_mach\_num, cp\_mach\_num} -- integers
(all 0).]
The number of processors in the virtual machine to run LP (CG, CP)
processes. If this value is 0 then the processes will be assigned to
processors in round-robin order. Otherwise the next {\tt xx\_mach\_num} lines
describe the processors where the LP (CG, CP) processes must run. The
keyword -- value pairs on these lines must be {\bf TM\_xx\_machine} and the
name or IP address of a processor (the processor names need not be distinct).
In this case the actual processes are assigned in a round robin fashion to the
processors on this list.\\
\\
This feature is useful if a specific software package is needed for
some process, but that software is not licensed for every node of the
virtual machine or if a certain process must run on a certain type of
machine due to resource requirements.

\item[{\tt use\_cg} -- boolean ({\tt FALSE}).]
Whether to use a cut generator or not. 

\item[{\tt TM\_random\_seed} -- integer (17).]
The random seed used in the TM.

\item[{\tt unconditional\_dive\_frac} -- double (0.1).]
The fraction of the nodes on which \BB\ randomly dives
unconditionally into one of the children.

\label{diving_strategy}
\item[{\tt diving\_strategy} -- integer ({\tt BEST\_ESTIMATE}\{0\}).]
The strategy employed when deciding whether to dive or not. \\
\\
The {\tt BEST\_ESTIMATE}\{0\} strategy continues to dive until the
lower bound in the child to be dived into exceeds the parameter
\htmlref{\tt upper\_bound\_estimate}{upper_bound_estimate}, which is 
given by the user. \\
\\
The {\tt COMP\_BEST\_K}\{1\} strategy computes the average lower bound
on the best \htmlref{\tt diving\_k}{diving} search tree nodes and
decides to dive if
the lower bound of the child to be dived into does not exceed this
average by more than the fraction \htmlref{\tt
diving\_threshold}{diving}.\\
\\
The {\tt COMP\_BEST\_K\_GAP}\{2\} strategy takes the size of the gap
into account when deciding whether to dive. After the average lower
bound of the best \htmlref{\tt diving\_k}{diving} nodes is computed, 
the gap between
this average lower bound and the current upper bound is computed.
Diving only occurs if the difference between the computed average
lower bound and the lower bound of the child to be dived into is at
most the fraction \htmlref{\tt diving\_threshold}{diving} of the gap.\\
\\
Note that fractional diving settings can override these strategies.
See \htmlref{below}{fractional_diving}.

\label{diving}
\item[{\tt diving\_k, diving\_threshold} -- integer, double (1, 0.0).]
See above.

\label{fractional_diving}
\item[{\tt fractional\_diving\_ratio, fractional\_diving\_num} --
integer (0.02, 0).]

Diving occurs automatically if the number of fractional variables in
the child to be dived into is less than {\tt fractional\_diving\_num}
or the fraction of total variables that are fractional is less than {\tt
fractional\_diving\_ratio}. This overrides the other diving rules.
Note that in order for this option to work, the code must be compiled
with {\tt FRACTIONAL\_BRANCHING} defined. This is the default. See the
Makefile for more details.

\item[{\tt node\_selection\_rule} -- integer ({\tt LOWEST\_LP\_FIRST}\{0\}).]
The rule for selecting the next search tree node to be processed. This rule
selects the one with lowest lower bound. Other possible values are: {\tt
HIGHEST\_LP\_FIRST}\{1\}, {\tt BREADTH\_FIRST\_SEARCH}\{2\} and {\tt
DEPTH\_FIRST\_SEARCH}\{3\}.

\item[{\tt load\_balance\_level}] -- integer (-1).]
A naive attempt at load balancing on problems where significant time
is spent in the root node, contributing to a lack of parallel
speed-up. Only a prescribed number of iterations ({\tt
load\_balance\_iter}) are performed in the root node (and in each
subsequent node on
a level less than or equal to {\tt load\_balance\_level}) before
branching is forced in order to provide additional subproblems for the
idle processors to work on. This doesn't work well in general.

\item[{\tt load\_balance\_iter}] -- integer (-1).]
Works in tandem with the {\tt load\_balance\_level} to attempt some
simple load balancing. See the above description.

\item[{\tt keep\_description\_of\_pruned} -- integer ({\tt DISCARD}\{0\}).]
Whether to keep the description of pruned search tree nodes or not.
The reasons to do this are (1) if the user wants to write out a proof
of optimality using the logging function, (2) for debugging, or (3) to
get a visual picture of the tree using the software VBCTOOL.
Otherwise, keeping the pruned nodes around just takes up memory. 

There are three options if it is desired to keep some description of
the pruned nodes around. First, their full description can be written
out to disk and freed from memory ({\tt KEEP\_ON\_DISK\_FULL}\{1\}). There
is not really too much you can do with this kind of file, but
theoretically, it contains a full record of the solution process and
could be used to provide a certificate of optimality (if we were using
exact arithmetic) using an independent verifier. In this case, the
line following {\tt keep\_description\_of\_pruned} should be a line
containing the keyword {\tt pruned\_node\_file\_name} with its
corresponding value being the name of a file to which a description of
the pruned nodes can be written. The file does not need to exist and
will be over-written if it does exist.

If you have the software VBCTOOL (see Section \ref{output}), then
you can alternatively just write out the information VBCTOOL needs to
display the tree ({\tt KEEP\_ON\_DISK\_VBC\_TOOL}\{2\}). 

Finally, the user can set the value to of this parameter to {\tt
KEEP\_IN\_MEMORY}\{2\}, in which case all pruned nodes will be kept in
memory and written out to the regular log file if that option is
chosen. This is really only useful for debugging. Otherwise, pruned
nodes should be flushed.

\item[{\tt logging} -- integer ({\tt NO\_LOGGING}\{0\}).]
Whether or not to write out the state of the search tree and all other
necessary data to disk periodically in order to allow a warm start in
the case of a system crash or to allow periodic viewing with VBCTOOL.

If the value of this parameter is set to {\tt FULL\_LOGGING}\{1\},
then all information needed to warm start the calculation will written
out periodically. The next two lines of the parameter file following
should contain the keywords {\tt tree\_log\_file\_name} and {\tt
cut\_log\_file\_name} along with corresponding file names as values.
These will be the files used to record the search tree and related
data and the list of cuts needed to reconstruct the tree.

If the value of the parameter is set to {\tt VBC\_TOOL}\{2\}, then
only the information VBCTOOL needs to display the tree will be
logged. This is not really a very useful option since a ``live'' picture
of the tree can be obtained using the {\tt vbc\_emulation} parameter
described below (see Section \ref{output} for more on this).

\item[{\tt logging\_interval} -- integer (1800).]
Interval (in seconds) between writing out the above log files.

\item[{\tt warm\_start} -- boolean (0).]
Used to allow the tree manager to make a warm start by reading in
previously written log files. If this option is set, then the two line
following must start with the keywords {\tt
warm\_start\_tree\_file\_name} and {\tt warm\_start\_cut\_file\_name}
and include the appropriate file names as the corresponding values.

\item[{\tt vbc\_emulation}] -- integer ({\tt
NO\_VBC\_EMULATION}\{0\}).]
Determines whether or not to employ the VBCTOOL emulation mode. If
one of these modes is chosen, then the tree will be displayed in
``real time'' using the VBCTOOL Software. When using the option {\tt
VBC\_EMULATION\_LIVE}\{2\} and piping the output directly to VBCTOOL, the
tree will be displayed as it is constructed, with color coding
indicating the status of each node. With {\tt
VBC\_EMULATION\_FILE}\{1\} selected, a log file will be produced which
can later be read into VBCTOOL to produce an emulation of the
solution process at any desired speed. If {\tt VBC\_EMULATION\_FILE}
is selected, the the following line should contain the keyword {\tt
vbc\_emulation\_file\_name} along with the corresponding file name
for a value.

\item[{\tt price\_in\_root} -- boolean ({\tt FALSE}).]
Whether to price out variables in the root node before the second
phase starts (called {\em repricing the root}). 

\item[{\tt trim\_search\_tree} -- boolean ({\tt FALSE}).]
Whether to trim the search tree before the second phase starts or not. Useful
only if there are two phases. (It is very useful then.)

\item[{\tt colgen\_in\_first\_phase, colgen\_in\_second\_phase} --
integers (both 4).] These parameters determine if and when to do
column generation in the first and second phase of the algorithm. The
value of each parameter is obtained by setting the last four bits.
The last two bits refer to what to do when attempting to prune a node.
If neither of the last two bits are set, then we don't do
anything---we just prune it. If only the last bit is set, then we
simply save the node for the second phase without doing any column
generation (yet). If only the second to last bit is set, then we do
column generation immediately and resolve if any new columns are
found. The next two higher bits determine whether or not to do column
generation before branching. If only the third lowest bit is set, then no
column generation occurs before branching. If only the fourth lowest bit is
set, then column generation is attempted before branching. The default
is not to generate columns before branching or fathoming, which
corresponds to only the third lowest bit being set, resulting in a
default value of 4.

\item[{\tt time\_limit} -- integer (0).]
Number of seconds of wall-clock time allowed for solution. When this
time limit is reached, the solution process will stop and the best
solution found to that point, along with other relevant data, will be
output. A time limit of zero means there is no limit.

\end{description}

\subsection{LP parameters}

\begin{description}

\item[{\tt LP\_verbosity} -- integer (0).]
Verbosity level of the LP process.

\item[{\tt set\_obj\_upper\_lim} -- boolean ({\tt FALSE}).]
Whether to stop solving the LP relaxation when it's optimal value is
provably higher than the global upper bound. There are some advantages
to continuing the solution process anyway. For instance, this results
in the highest possible lower bound. On the other hand, if the matrix
is full, this node will be pruned anyway and the rest of the
computation is pointless. This option should be set at {\tt FALSE} for
column generation since the LP dual values may not be reliable otherwise.

\item[{\tt try\_to\_recover\_from\_error} -- boolean ({\tt TRUE}).]
Indicates what should be done in case the LP solver is unable to solve
a particular LP relaxation because of numerical problems. It is
possible to recover from this situation but further results may be
suspect. On the other hand, the entire solution process can be
abandoned.

\item[{\tt problem\_type} -- integer ({\tt ZERO\_ONE\_PROBLEM}\{0\}).]
The type of problem being solved. Other values are {\tt
INTEGER\_PROBLEM}\{1\} or {\tt MIXED\_INTEGER\_PROBLEM}\{2\}.
(Caution: The mixed-integer option is not well tested.)

\item[{\tt cut\_pool\_check\_frequency} -- integer (10).]
The number of iterations between sending LP solutions to the cut pool
to find violated cuts. It is not advisable to check the cut pool too
frequently as the cut pool process can get bogged down and the LP
solution generally do not change that drastically from one iteration
to the next anyway.

\item[{\tt not\_fixed\_storage\_size} -- integer (2048).]
The {\em not fixed list} is a partial list of indices of variables not
in the matrix that have not been fixed by reduced cost. Keeping this
list allows \BB\ to avoid repricing variables (an expensive operation)
that are not in the matrix because they have already been permanently
fixed. When this array reaches its maximum size, no more variable
indices can be stored. It is therefore advisable to keep the maximum
size of this array as large as possible, given memory limitations.

\item[{\tt max\_non\_dual\_feas\_to\_add\_min,
max\_non\_dual\_feas\_to\_add\_max,
max\_non\_dual\_feas\_to\_add\_frac} --] integer, integer, double (20,
200, .05).
These three parameters determine the maximum number of
non-dual-feasible columns that can be added in any one iteration
after pricing. This maximum is set to the indicated
fraction of the current number of active columns unless this numbers
exceeds the given maximum or is less than the given minimum, in which
case, it is set to the max or min, respectively.

\item[{\tt max\_not\_fixable\_to\_add\_min,
max\_not\_fixable\_to\_add\_max,
max\_not\_fixable\_to\_add\_frac} --] integer, integer, double (100,
500, .1).
As above, these three parameters determine the maximum number of new
columns to be added to the problem because they cannot be priced out.
These variables are only added when trying to restore infeasibility
and usually, this does not require many variables anyway.

\item[{\tt mat\_col\_compress\_num, mat\_col\_compress\_ratio} -- integer,
double (50, .05).]
Determines when the matrix should be physically compressed. This only
happens when the number of columns is high enough to make it
``worthwhile.'' The matrix is physically compressed when the number of
deleted columns exceeds either an absolute number {\em and} a specified
fraction of the current number of active columns.

\item[{\tt mat\_row\_compress\_num, mat\_row\_compress\_ratio} -- integer,
double (20, .05).]
Same as above except for rows.

\item[{\tt tailoff\_gap\_backsteps, tailoff\_gap\_frac} -- integer, double
(2, .99).]
Determines when tailoff is detected in the LP process.
Tailoff is reported if the average ratio of the current gap to the
previous iteration's gap over the last {\tt tailoff\_gap\_backsteps}
iterations wasn't at least {\tt tailoff\_gap\_frac}.

\item[{\tt tailoff\_obj\_backsteps, tailoff\_obj\_frac} -- integer, double
(2, .99).]
Same as above, only the ratio is taken with respect to the change in
objective function values instead of the change in the gap.

\item[{\tt ineff\_cnt\_to\_delete} -- integer (0).]
Determines after how many iterations of being deemed ineffective a
constraint is removed from the current relaxation.

\item[{\tt eff\_cnt\_before\_cutpool} -- integer (3).]
Determines after how many iterations of being deemed effective each
cut will be sent to the global pool.

\item[{\tt ineffective\_constraints} -- integer
({\tt BASIC\_SLACKS\_ARE\_INEFFECTIVE}\{2\}).]
Determines under what condition a constraint is deemed ineffective in
the current relaxation. Other possible values are {\tt
NO\_CONSTRAINT\_IS\_INEFFECTIVE}\{0\},  {\tt
NONZERO\_SLACKS\_ARE\_INEFFECTIVE}\{1\}, and \\
{\tt ZERO\_DUAL\_VALUES\_ARE\_INEFFECTIVE}\{3\}.

\item[{\tt base\_constraints\_always\_effective} -- boolean ({\tt TRUE}).]
Determines whether the base constraints can ever be removed from the
relaxation. In some case, removing the base constraints from the
problem can be disastrous depending on the assumptions made by the cut
generator.

\item[{\tt branch\_on\_cuts} -- boolean ({\tt FALSE}).]
This informs the framework whether the user plans on branching on cuts
or not. If so, there is additional bookkeeping to be done, such as
maintaining a pool of slack cuts to be used for branching. Therefore,
the user should not set this flag unless he actually plans on using
this feature.

\item[{\tt discard\_slack\_cuts} -- integer ({\tt
DISCARD\_SLACKS\_BEFORE\_NEW\_ITERATION}\{0\}).]
Determines when the pool of slack cuts is discarded. The other option
is {\tt DISCARD\_SLACKS\_WHEN\_STARTING\_NEW\_NODE}\{1\}.


\item[{\tt first\_lp\_first\_cut\_time\_out,
first\_lp\_all\_cuts\_time\_out,
later\_lp\_first\_cut\_time\_out},] {\tt later\_lp\_all\_cuts\_time\_out} --
double (0, 0, 5, 1).
The next group of parameters determines when the LP should give up
waiting for cuts from the cut generator and start to solve the
relaxation in its current form or possibly branch if necessary. There
are two factors that contribute to determining this timeout. First
is whether this is the first LP in the search node of whether it is a
later LP. Second is whether any cuts have been added already in this
iteration. The four timeout parameters correspond to the four possible
combinations of these two variables.

\item[{\tt no\_cut\_timeout} -- ]
This keyword does not have an associated value. If this keyword
appears on a line by itself or with a value, this tells the framework
not to time out while waiting for cuts. This is useful for debugging
since it enables runs with a single LP process to be duplicated.

\item[{\tt all\_cut\_timeout} -- double (no default).]
This keyword tells the framework to set all of the above timeout
parameters to the value indicated.

\item[{\tt max\_cut\_num\_per\_iter} -- integer (20).]
The maximum number of cuts that can be added to the LP in an
iteration. The remaining cuts stay in the local pool to be added in
subsequent iterations, if they are strong enough.

\item[{\tt do\_reduced\_cost\_fixing} -- boolean ({\tt FALSE}).]
Whether or not to attempt to fix variables by reduced cost. This
option is highly recommended

\item[{\tt gap\_as\_ub\_frac, gap\_as\_last\_gap\_frac} -- double (.1, .7).]
Determines when reduced cost fixing should be attempted. It is only
done when the gap is within the fraction {\tt gap\_as\_ub\_frac} of the upper
bound or when the gap has decreased by the fraction 
{\tt gap\_as\_last\_gap\_frac} since the last time variables were fixed.

\item[{\tt do\_logical\_fixing} -- boolean ({\tt FALSE}).]
Determines whether the user's logical fixing routine should be used.

\item[{\tt fixed\_to\_ub\_before\_logical\_fixing,
fixed\_to\_ub\_frac\_before\_logical\_fixing}] -- {\bf integer, double
(1, .01)}.
Determines when logical fixing should be attempted. It will be called
only when a certain absolute number {\em and} a certain number of variables
have been fixed to their upper bounds by reduced cost. This is because
it is typically only after fixing variables to their upper bound that
other variables can be logically fixed.

\label{strong_branching}
\item[{\tt max\_presolve\_iter} -- integer (10).]
Number of simplex iterations to be performed in the pre-solve for
strong branching.

\item[{\tt strong\_branching\_cand\_num\_max,
strong\_branching\_cand\_num\_min, strong\_branching\_red\_ratio}] --
{\bf integer (25, 5, 1)}.
These three parameters together determine the number of strong
branching candidates to be used by default. In the root node,
{\tt strong\_branching\_cand\_num\_max} candidates are used. On each
succeeding level, this number is reduced by the number {\tt
strong\_branching\_red\_ratio} multiplied by the square of the level.
This continues until the number of candidates is reduced to {\tt
strong\_branching\_cand\_num\_min} and then that number of candidates
is used in all lower levels of the tree.

\item[{\tt is\_feasible\_default} -- integer ({\tt TEST\_INTEGRALITY}\{1\}).]
Determines the default test to be used to determine feasibility. This
parameter is provided so that the user can change the default behavior
without recompiling. The only other option is {\tt TEST\_ZERO\_ONE}\{0\}.

\item[{\tt send\_feasible\_solution\_default} -- integer 
({\tt SEND\_NONZEROS}\{0\}).]
Determines the form in which to send the feasible solution. This
parameter is provided so that the user can change the default behavior
without recompiling. This is currently the only option.

\item[{\tt send\_lp\_solution\_default} -- integer ({\tt SEND\_NONZEROS}\{0\}).]
Determines the default form in which to send the LP solution to the
cut generator and cut pool. This
parameter is provided so that the user can change the default behavior
without recompiling. The other option is {\tt SEND\_FRACTIONS}\{1\}.

\item[{\tt display\_solution\_default} -- integer ({\tt DISP\_NOTHING}\{0\}).]
Determines how to display the current LP solution if desired.
See the description of \htmlref{\tt user\_display\_solution()}
{user_display_solution} for other
possible values. This parameter is provided so that
the user can change the default behavior without recompiling.

\item[{\tt shall\_we\_branch\_default} -- integer 
({\tt USER\_\_BRANCH\_IF\_MUST}\{2\}).]
Determines the default branching behavior. Other values are {\tt
USER\_\_DO\_NOT\_BRANCH}\{0\} (not recommended as a default), {\tt
USER\_\_DO\_BRANCH}\{1\} (also not recommended as a default), and {\tt
USER\_\_BRANCH\_IF\_TAILOFF}\{3\}. This
parameter is provided so that the user can change the default behavior
without recompiling.

\item[{\tt select\_candidates\_default} -- integer ({\tt
USER\_\_CLOSE\_TO\_HALF\_AND\_EXPENSIVE}\{11\}).]
Determines the default rule for selecting strong branching candidates.
Other values are {\tt USER\_\_CLOSE\_TO\_HALF}\{10\} and 
{\tt USER\_\_CLOSE\_TO\_ONE\_AND\_CHEAP}\{12\}. This
parameter is provided so that the user can change the default behavior
without recompiling.

\item[{\tt compare\_candidates\_default} -- integer 
({\tt LOWEST\_LOW\_OBJ}\{1\}).]
Determines the default rule for comparing candidates. See the
description of \htmlref{\tt user\_compare\_candidates()}
{user_compare_candidates} for other values. This
parameter is provided so that the user can change the default behavior
without recompiling.

\item[{\tt select\_child\_default} -- integer 
({\tt PREFER\_LOWER\_OBJ\_VALUE}\{0\}).]
Determines the default rule for selecting the child to be processed
next. For other possible values, see the description \htmlref{\tt
user\_select\_child()}{user_select_child}. This
parameter is provided so that the user can change the default behavior
without recompiling.

\end{description}

\subsection{Cut Generator Parameters}

\begin{description}

\item[{\tt CG\_verbosity} -- integer (0).]
Verbosity level for the cut generator process.

\end{description}

\subsection{Cut Pool Parameters}
\label{cut_pool_params}
\begin{description}

\item[{\tt CP\_verbosity} -- integer (0).]
Verbosity of the cut pool process.

\item[{\tt cp\_logging} -- boolean (0).]
Determines whether the logging option is enabled. In this case, the
entire contents of the cut pool are written out periodically to disk
(at the same interval as the tree manager log files are written). If
this option is set, then the line following must start with the
keyword {\tt cp\_log\_file\_name} and include the appropriate
file name as the value.

\item[{\tt cp\_warm\_start} -- boolean (0).]
Used to allow the cut pool to make a warm start by reading in a
previously written log file. If
this option is set, then the line following must start with the
keyword {\tt cp\_warm\_start\_file\_name} and include the appropriate
file name as the value.

\item[{\tt block\_size} -- integer (5000).]
Indicates the size of the blocks to allocate when more space is needed
in the cut list.

\item[{\tt max\_size} -- integer (2000000).]
Indicates the maximum size of the cut pool in bytes. This is the total
memory taken up by the cut list, including all data structures and the
array of pointers itself.

\item[{\tt max\_number\_of\_cuts} -- integer (10000).]
Indicates the maximum number of cuts allowed to be stored. When this
max is reached, cuts are forceably purged, starting with duplicates
and then those indicated by the parameter \htmlref{delete\_which}
{delete_which} (see below), until the list is below the allowable size.

\item[{\tt min\_to\_delete} -- integer (1000).]
Indicates the number of cuts required to be deleted when the pool reaches
it's maximum size.

\item[{\tt touches\_until\_deletion} -- integer (10).]
When using the number of touches a cut has as a measure of its
quality, this parameter indicates the number of touches a cut can have
before being deleted from the pool. The number of touches is the
number of times in a row that a cut has been checked without being
found to be violated. It is a measure of a cut's relevance or
effectiveness.

\label{delete_which}
\item[{\tt delete\_which} -- integer 
({\tt DELETE\_BY\_TOUCHES}\{2\}).] Indicates which cuts to delete when
purging the pool. {\tt DELETE\_BY\_TOUCHES} indicates that cuts whose
number of touches is above the threshold (see {\tt
touches\_until\_deletion} above) should be purged if the pool gets too
large. {\tt DELETE\_BY\_QUALITY}\{1\} indicates that a user-defined
measure of quality should be used (see the function \hyperref{\tt
user\_check\_cuts()} {{\tt user\_check\_cuts} in Section}{} 
{user_check_cuts}).

\item[{\tt check\_which} -- integer ({\tt CHECK\_ALL\_CUTS}\{0\}).]
Indicates which cuts should be checked for violation. The choices are
to check all cuts ({\tt CHECK\_ALL\_CUTS}\{0\}); only those that have
number of touches below the threshold ({\tt CHECK\_TOUCHES}\{2\}); only
those that were generated at a level higher in the tree than the
current one ({\tt CHECK\_LEVEL}\{1\}); or both ({\tt
CHECK\_LEVEL\_AND\_TOUCHES}\{3\}). Note that with {\tt
CHECK\_ALL\_CUTS} set, SYMPHONY will still only check the first
\htmlref{\tt cuts\_to\_check}{cuts_to_check} cuts in the list ordered
by quality (see the function \htmlref{user\_check\_cut}{user_check_cuts}).

\label{cuts_to_check}
\item[{\tt cuts\_to\_check} -- integer (1000).]
Indicates how many cuts in the pool to actually check. The list is
ordered by quality and the first {\tt cuts\_to\_check} cuts are
checked for violation.

\end{description}