***********************************************************
                       Commandfile
***********************************************************
In the description of the
commands we differentiate between computational levels and problem
periods. A problem period is a timestage in the model. A
computational level is one or more problem periods aggregated to a
deterministic equivalent lp.

Here is a short description of the commands in the file:

corefile <filename>
   gives the name of the core file

timefile <filename>
   gives the name of the time file

stochfile <filename>
   gives the name of the stoch file

allfiles <filename>
   gives the name of all the files.
   the three files are given as filename.cor,
   filename.tim and filename.sto

common
   use a common lp structure for the last level problems.
   this will reduce the required amount of memory,
   and possibly make the solution faster.

common before cut
   use a common lp structure for all subproblems before the cutlevel
   this will reduce the required amount of memory.

periods per level [<computational level>] <periods>
   if two integers are given, 
   the first designates the computational level, and the second the number of
   problem stages to be aggregated into this level.
   If one integer is given, this is the default number of 
   periods for all computational levels.

last level periods <periods>
   Gives the number of periods for the last computational level.
   This will override other specifications.

cut level <integer>
   This gives the cut level for the algorithm.
   If this is set, the algorithm will alternate between solving
   problems before the cut-level, and after the cut-level. Memory may be saved by 
   completely solving everyting below the cut-level to generate a cut at the cut-level.
   After this is done, cuts and bases after the cut-level may be
   discarded, only to be regenerated whenever needed.

print progress
   Print lower and upper bound each time the root problem is resolved.

children per theta [<level>] <no children>
   If two integers are given, this gives the number of child nodes per
   cut-bunch for a certain level.
   if only the number of children is given, this is the default for all nodes.

thetas to rows [<level>] <fraction>
   This command gives a maximal ratio of child 
   bunches to rows in the computational level.
   The idea is to limit the number of cuts compared 
   to the rows of the problem.
   This command and children per theta are mutually exclusive.
   WARNING, this command is almost untested, use at your own risk.

print deteq size
   print the deterministic equivalent size of the problem

print memory
   print the maximum resident set size of the process. This
   command needs the getrusage function to work properly 
   (it does not work properly on solaris)

print solution [print_period]
   print the solution for the problem
   if print_period is given , the solution up to and including 
   the problem period print_period is printed.

print time
   Turn on printing of solution time.
   Given is user and system time for readin of problem, 
   solution and cleanup (printout and deallocation).

shared after cut
   The problems after the cut level use common data structures for the LPs.

store cuts
   store cuts after the cut-level, making it unnessecary to regenerate them.

store basis
   store an optimal basis for each node after the cut.

compress basis
   works like store basis, but compresses the basis to save memory
   Memory required is one byte per 4 columns or rows for 
   cplex (only avaiable for cplex)

silent
   nothing is printed

keep after cut
   keep the solution variables in memory after the cut. Normally primal and dual 
   variable values are purged between iterations.

bounce [times]
   bounce at the cut level, not going into the leafs until everything
   before the cut is completely solved If a number of times is given, 
   this is me maximum number of times the solver will bounce. A lower 
   number of bounces will be performed if the difference between the lower and upper
   bound becomes small enough.

bounce leaf [times]
   bonce down into the leafs a specified number of times
   if times is 1, a maximum of two passes is made (1 bounce)

no down
   do not change direction in the tree if an infeasible sub-problem is
   found.

debug save problem
   save the problem to an smps file. 
   This function may be used to catch read errors.

classic
   This will do the classical breadth first search of the 
   scenario-tree, instead of depth first search. This option 
   will turn off bounce and cut. 

no copy
   The default behaviour of the solver is to copy the basis of a 
   solved to its neighbour, if it is the first iteration and 
   they do not share an LP-struct. The option no copy prevents this.

end data
   Must be the last row in the file, Terminates input.

rows starting with # are treated as comments.