******************************************************************************
*                    SYMPHONY CNRP Application                               * 
******************************************************************************

The SYMPHONY CNRP application is a solver for Capacitated Node
Routing Problems as described in the following technical report:

T.K.R., M.J. Saltzman, and M.M. Wiecek, An Improved Algorithm for Biobjective
Integer Programming and Its Application to Network Routing Problems, Lehigh
University Industrial and Systems Engineering Technical Report 04T-004,
available for download from

http://www.lehigh.edu/~tkr2/research/papers/BICRIT.pdf.

The CNRP application takes advantage of SYMPHONY's ability to solve bicriteria
optimization problems and can analyze the tradeoff between fixed and variable
cost in a class of network routing applications that include variants of the
Traveling Salesman Problem, Vehicle Routing Problem, Capacitated Minimum
Spanning Tree Problem, and Cable Trench Problem.

******************************************************************************
*                              INSTALLATION                                  *
******************************************************************************

Please see the INSTALL file for a guide to compile SYMPHONY CNRP application.

*******************************************************************************
*                      USING THE SOLVER                                       *
*******************************************************************************

This file briefly introduces the use of the SYMPHONY CNRP solver. To use the
CNRP solver, type the executable name followed by one or more of the
command-line switches. There are two required switches. You must specify the
location of the data file by using "-F 'filename'" (type this after executable
name) and you must specify the type of the problem by "-R". Below is a list 
of other parameters that can be set on the command line. This list can also
be obtained by typing the executable name followed by "-H".  Notice that all 
application-specific parameters are denoted by a capital letter.

        -H: help
        -E: use sparse edge set
        -D level: verbosity level for displaying LP solutions
        -R type: specify problem type
        -S file: load sparse graph from 'file'
        -F file: problem data is in 'file'
        -B i: which candidates to check in strong branching
        -V i: how to construct the base set of variables
        -K k: use 'k' closest edges to build sparse graph
        -N n: use 'n' routes
        -M  : use min cut subroutine
        -C c: use capacity 'c'
        -X t: toggles generation of X cuts
        -Y t: toggles generation of capacity cuts
        -Z t: toggles generation of tight capacity cuts
        -G t: set tau to 't'

There are a number of other (for now) undocumented parameters that can be used
to fine-tune the performance of the solver. These must be set in a parameter
file. The SYMPHONY User's Manual explains the use of the parameter file.

Some of SYMPHONY's native parameters can also be set on the command
line. Below is a list of these parameters. This list can also be obtained by
typing the executable name with no command-line arguments. Note that all
SYMPHONY parameters are denoted by a lowercase letter. Note that there are
dozens of other parameters that can be set with the use of a parameter
file. These parameters are listed in the SYMPHONY User's Manual.

        -h: help
        -a: no cut timeout
        -d: enable graph drawing
        -g: use cut generator
        -r: do repricing in root
        -t: trim the tree
        -b: don't perform branch and cut
        -u ub: use upper bound 'ub'
        -p procs: allow 'procs' active nodes
        -n i: use node selection rule 'i'
        -v i: set verbosity to level 'i'
        -s cands: use 'cands' candidates for strong branching
        -c i: use rule 'i' to compare candidates
        -k i: use rule 'i' to select child
        -m n: allow a max of 'n' cuts to enter per iteration
        -l n: allow a max of 'n' cut pools
        -i n: allow a max of 'n' iterations in presolve
        -f file: read parameters from parameter file 'file'

AUTHORS

The SYMPHONY CNRP application was developed by Ted Ralphs
(ted@lehigh.edu).

BUG REPORTS

Please submit bug reports at https://projects.coin-or.org/SYMPHONY
