### Table of Contents

- Introduction
- Specifying Model Structure
- Heuristic Parameters
- GAMS/ODHCPLEX: General Options
- GAMS/CPLEX: Preprocessing and General Options
- GAMS/CPLEX: Simplex Algorithmic Options
- GAMS/CPLEX: Simplex Limit Options
- GAMS/CPLEX: Simplex Tolerance Options
- GAMS/CPLEX: Barrier Specific Options
- GAMS/CPLEX: Sifting Specific Options
- GAMS/CPLEX: MIP Algorithmic Options
- GAMS/CPLEX: MIP Limit Options
- GAMS/CPLEX: MIP Solution Pool Options
- GAMS/CPLEX: MIP Tolerance Options
- GAMS/CPLEX: Output Options

- Parallel execution using multiple threads
- Determinism
- Detailed Descriptions of ODHCLPEX Options

# Introduction

GAMS/ODHCPLEX is a solver from Optimization Direct Inc. that implements a set of heuristic methods (named ODHeuristics) for finding feasible solutions to Mixed Integer Programming (MIP and MIQCP) models that uses IBM CPLEX as its underlying solver engine. It is designed for large-scale models which a MIP solver would find intractable: either by it being unable to find feasible solutions at all or; more usually, by being unable to find feasible solutions of adequate quality in the time available to its user.

It is intended for users who are familiar with MIP modelling and have some knowledge of using the GAMS/CPLEX solver. GAMS/ODHCPLEX does not demand expert specialism in this field.

ODHCPLEX can be used in two ways: it is implemented as a stand-alone ODHeuristic engine, which can be used on its own (ODHeuristicMethod=STANDALONE); and also within the CPLEX optimizer, within which it can supply and receive solutions from the main CPLEX caller (ODHeuristicMethod=ODH-CPLEX (default)) thereby accelerating optimization compared with GAMS/CPLEX run on its own.

The ODHeuristic engine has a heuristic method for finding an initial feasible solution that it designed to complement, those of CPLEX. Since its main algorithmic procedure works by improving an incumbent feasible solution, getting an initial one is important and may consume a significant part of its total runtime. When used on its own (i.e. ODHeuristicMethod=STANDALONE), users should experiment to discover whether ODHeuristics' or CPLEX's initial feasible solution methods work best, but within ODH-CPLEX (i.e. ODHeuristicMethod=ODH-CPLEX) both methods are run in parallel and the winner is chosen automatically.

ODHeuristics' principal algorithm works by solving a sequence of sub-models. An innovative aspect of this process is its ability to use the model's symbolic structure to achieve the sub-model decomposition. It does this by analyzing the symbolic names that the user gives to the decision variables and careful specification of how this should be done this is worthwhile. ODHCPLEX can work without this analysis, but it usually takes about twice as much runtime.

# Specifying Model Structure

The ODHeuristic method needs to break the model down into sub-models. It can do this in one of three ways:

- Automatically using its decomposition heuristic;
- Using information specified by the user in the IndexKey parameter;
- By simply assigning each variable to a different block (or
*key*); or - By using the dot option notatation with the option .key.

By default, the program will use information specified by the IndexKey parameter if it is set and its automatic decomposition heuristic otherwise. This may be overridden by the Decomposition parameter. If it is set to 0 (zero), option 3 above is selected. If it is set to 1, its automatic decomposition method is used, and if it is set to 2, option 4 above is selected.

Whilst the automatic decomposition method often works well, there may be an advantage to specifying decomposition through the IndexKey parameter. After performing the decomposition in whatever way, the program analyses the decomposition and displays statistics showing the maximum and minimum number of variables in each key or block and showing a percentage score to the decomposition as a whole. A typical display is of the form:

Variables/key 205.58 (+/-304.79), max/min variables/key 933(32) / 60(113). There are 227 keys (4149 keys were dropped) with 46872 values. Decomposition score 13.66%, graph score 2074/3135232.

Other things (such as the distribution of variables in keys and the number of keys) being equal, the smaller the percentage decomposition score, the better the decomposition is and the more effective the program will be.

## Using the IndexKey parameter

The program needs to associate sets of variables with distinct values of a single index. The user can specify this association with a pattern to which some or all of the variables conform. The pattern is in standard C scanf format (see, for example, Kernighan and Ritchie's 2nd edition of The C Programming Language, section B1.3 *Formatted Input*). Currently allowable index values must be non-negative integers, so the pattern must include *d*. For example, if we have variables `x`

whose first index names starts with a number of letters then an underscore followed by a numeric index value (like `x(firstone_1)`

, `x(another_1)`

, `x(firstone_2)`

, `x(another_2)`

, ..) the pattern

x(%*[a-z]_%d)

associates those variables whose name ends in `_1`

with index value 1, those whose name ends in `_2`

with index value 2 and so on. The pattern is called an *index key* referred to by the program as the option parameter IndexKey, for example

IndexKey=%*[xy](t_%d)

It may, however, be desirable to consider variables whose names are, say, `x(t_2)`

and `y(t_2)`

, to belong to different index values, i.e. to belong to different groups. One way of doing this is to identify them with separate index keys. These can be supplied to IndexKey as two fields separated by a semi-colon, for example

IndexKey=x(t_%d);y(t_%d)

Up to 10 fields can be specified in this way.

On the other hand, it may be desirable to consider such variables as having the same index key and their nomenclature may not permit their identification by a single key field. For example, suppose there are variables `john(t_1)`

, `john(t_2)`

,.., `jane(t_1)`

, `jane(t_2)`

,.. and `johnny(t_1)`

, `johnny(t_2)`

,.. and we want to associate `john(t_x)`

and `jane(t_x)`

as belonging to key value *x*, but want to ignore `johnny(t_x)`

.

Two key fields can be used to do this by

INDEXKEY=john(t_%d);jane(t_%d)

By default `john(t_2)`

and `jane(t_2)`

would not share the same index value, but if the option parameter KeyType, is set to 1, the heuristic will group them together so as to share the same index.

If IndexKey is not specified, the program uses a default decomposition.

The program divides the model up into parts associated with different values of the IndexKey (if specified), using an integer interval divisor. Initially this is a number not less than 2 and it is increased as the search progresses. When no improved solution is found after a number, MaxRepeat, of attempts with the maximum interval divisor, MaxInterDiv, the program terminates. Default values are provided for MaxRepeat and MaxInterDiv, so these do not have to be specified by the user.

# Heuristic Parameters

There are a number of other parameters which control the behaviour of the heuristic program. These may be left at their default values or specified on the GAMS/ODHCPLEX option file. In addition, many GAMS/CPLEX options can be supplied in the GAMS/ODHCPLEX option file to tweak the CPLEX behavior, see tables below. Note however that - although they can be technically set - these GAMS/CPLEX options may not have any influence on a GAMS/ODHCPLEX solve. For detailed descriptions of the GAMS/CPLEX options, see Detailed Descriptions of CPLEX Options.

Parameter names and their meanings are summarized in the table below.

## GAMS/ODHCPLEX: General Options

Option | Description | Default |
---|---|---|

cpxpresolve | Applies CPLEX presolve to full model | `0` |

decompdensity | Matrix density above which automatic decomposition assigns each variable to a separate key | `0.3` |

decomposition | Model decomposition method. | `-1` |

deterministic | Specifies whether the solution improvement heuristic is run in deterministic or opportunistic (i.e. non-deterministic) mode | `1` |

divisor | Initial divisor for sub models | `automatic` |

dynamicsearch | Search strategy for CPLEX caller and sub-model solves | `-1` |

extracplexlog | Write addition CPLEX output to log | `0` |

feastol | Feasibility tolerance | `1e-6` |

firstfeas | Use first feasible heuristic for finding an initial feasible solution | `-1` |

firstfeascontinue | Whether first feasible heuristic continues when it achieves feasibility | `0` |

firstfeaseffort | Effort limit on first feasible heuristic | `-500` |

firstfeasshift | First feasible heuristic variable shifting in found solutions | `1` |

globalbounds | Use of global bounds from CPLEX caller | `2` |

indexkey | Pattern used to match variable names for grouping into sub-models discussed above | |

integeronly | Variables to include in INDEXKEY | `-1` |

integertol | Integrality tolerance for variable values | `1e-5` |

interdiv | Initial divisor value | `4` |

.key | Variable block or key number | `0` |

keytype | Treatment of multiple INDEXKEYs | `0` |

maxbacktrack | The maximum number of backtracks permitted in sub-model solves | `-1` |

maxbound | The largest(smallest) non infinite bound value ODH will accept for upper(lower) bounds | `1e+9` |

maxinfrepeat | Maximum divisor value when solution is infeasible | `0` |

maxinterdiv | Maximum divisor value | `0` |

maxrepeat | Maximum number of sub-model repeat solves for each divisor value | `0` |

newcallback | CPLEX call-back type used | `1` |

objtarget | Target objective value | `0` |

odheuristicmethod | ODHeuristic method section | `ODH-CPLEX` |

odhfeasopt | Optimization method for sub-models in phaseI | `0` |

odhpresolve | Indicator for the ODHeuristics engine using a separate presolve within ODH-CPLEX | `1` |

odhthreads | The number of heuristic threads used by ODH-CPLEX or STANDALONE | `-1` |

odhtimelimit | Elapsed time limit in seconds | `GAMS ResLim` |

penalty | The objective function coefficient value for penalties | `-1` |

penperturb | Perturbation tolerance for penalties coefficients | `0` |

phase12 | Specifies whether to use a phaseI/phaseII method to remove infeasibilities | `1` |

processorlock | Thread allocation | `0` |

quickfirstsolve | Accelerate initial CPLEX solve | `0` |

recurse | Recurse using heuristic to solve sub-models when a feasible solution has been obtained | `0` |

recursedecomp | Recursed model decomposition method | `0` |

recurseiterlim | Recursed heuristic iteration limit for sub-solves | `40` |

recurselog | Write thread log files for recursed sub-solves | `0` |

recurseminiterlim | Recursed heuristic minimum iterations before a solution is found in sub-solves | `0` |

recursesoliterlim | Recursed heuristic sub-solves quit after these iterations if a solution is found | `maxint` |

rejectinfsol | Reject infeasible solutions to sub-models | `2` |

relaxsos2 | Treatment of SOS2 members | `1` |

seed | Initial random number seed | `1234` |

strategy | ODH-Cplex Strategy | `1` |

subnodelimit | Node limit for submodel searches | `-1` |

suborder | Use of priority order in sub-solves | `1` |

subpresolve | Use of CPLEX presolve in sub-solves | `1` |

sub_cpx_threads | Threads availble for the solves within ODHeuristic | `1` |

syncfreq | Thread synchronization frequency in deterministic parallel mode | `1` |

threadlog | Write thread log files | `0` |

threadzerosync | Which CPLEX threads to use for synchronization | `0` |

variableclean | Clean variable values from sub-models | `0` |

zerotol | Zero tolerance for variable values | `1e-9` |

## GAMS/CPLEX: Preprocessing and General Options

Option | Description | Default |
---|---|---|

advind | advanced basis use | `1` |

aggfill | aggregator fill parameter | `10` |

aggind | aggregator on/off | `-1` |

calcqcpduals | calculate the dual values of a quadratically constrained problem | `1` |

clocktype | clock type for computation time | `2` |

coeredind | coefficient reduction on/off | `-1` |

cpumask | switch and mask to bind threads to processors (Linux only) | `auto` |

cutoff | GMO cutoff | `0.0` |

datacheck | controls data consistency checking and modeling assistance | `0` |

depind | dependency checker on/off | `-1` |

dettilim | deterministic time limit | `1.0e+75` |

domlim | domain violation number | `0` |

eprelax | relaxation for feasOpt | `1.0e-06` |

feasoptmode | mode of FeasOpt | `0` |

fixoptfile | name of option file which is read just before solving the fixed problem | |

folding | LP folding will be attempted during the preprocessing phase | `-1` |

freegamsmodel | preserves memory by dumping the GAMS model instance representation temporarily to disk | `0` |

indicoptstrict | abort in case of an error in indicator constraint in solver option file | `1` |

lpmethod | algorithm to be used for LP problems | `0` |

memoryemphasis | reduces use of memory | `0` |

multobjdisplay | level of display during multiobjective optimization | `1` |

names | load GAMS names into Cplex | `1` |

numericalemphasis | emphasizes precision in numerically unstable or difficult problems | `0` |

optimalitytarget | type of optimality that Cplex targets | `0` |

parallelmode | parallel optimization mode | `0` |

paramdisplay | display the nondefault parameters before optimization | `1` |

predual | give dual problem to the optimizer | `0` |

preind | turn presolver on/off | `1` |

prelinear | linear reduction indicator | `1` |

prepass | number of presolve applications to perform | `-1` |

prereform | set presolve reformulations | `3` |

printoptions | list values of all options to GAMS listing file | `0` |

qextractalg | quadratic extraction algorithm in GAMS interface | `0` |

qpmethod | algorithm to be used for QP problems | `0` |

qtolin | linearization of the quadratic terms in the objective function of a QP or MIQP model | `-1` |

randomseed | sets the random seed differently for diversity of solutions | `202009243` |

record | Records invocations of Callable Library routines | `0` |

reduce | primal and dual reduction type | `3` |

relaxfixedinfeas | accept small infeasibilties in the solve of the fixed problem | `0` |

relaxpreind | presolve for initial relaxation on/off | `-1` |

rerun | rerun problem if presolve infeasible or unbounded | `yes` |

scaind | matrix scaling on/off | `0` |

solutiontype | type of solution (basic or non basic) for an LP or QP | `0` |

threads | global default thread count | `0` |

tilim | overrides the GAMS ResLim option | `1.0e+75` |

tryint | GMO tryint | `0.0` |

tuningdettilim | tuning deterministic time limit per model or suite | `1.0e+75` |

tuningdisplay | level of information reported by the tuning tool | `1` |

tuningmeasure | measure for evaluating progress for a suite of models | `1` |

tuningrepeat | number of times tuning is to be repeated on perturbed versions | `1` |

tuningtilim | tuning time limit per model or suite | `1.0e+75` |

usebasis | GMO usebasis | `0` |

warninglimit | determines how many times warnings of a specific type (datacheck=2) will be displayed | `10` |

workdir | directory for working files | `.` |

workmem | memory available for working storage | `2048.0` |

## GAMS/CPLEX: Simplex Algorithmic Options

Option | Description | Default |
---|---|---|

conflictalg | algorithm CPLEX uses in the conflict refiner to discover a minimal set of conflicting constraints in an infeasible model | `0` |

conflictdisplay | decides how much information CPLEX reports when the conflict refiner is working | `1` |

craind | crash strategy (used to obtain starting basis) | `1` |

dpriind | dual simplex pricing | `0` |

dynamicrows | switch for dynamic management of rows | `-1` |

epper | perturbation constant | `1.0e-06` |

netfind | attempt network extraction | `2` |

netppriind | network simplex pricing | `0` |

perind | force initial perturbation | `0` |

perlim | number of stalled iterations before perturbation | `0` |

ppriind | primal simplex pricing | `0` |

pricelim | pricing candidate list | `0` |

reinv | refactorization frequency | `0` |

sifting | switch for sifting from simplex optimization | `1` |

## GAMS/CPLEX: Simplex Limit Options

Option | Description | Default |
---|---|---|

itlim | iteration limit | `2147483647` |

netitlim | iteration limit for network simplex | `2147483647` |

objllim | objective function lower limit | `-1.0e+75` |

objulim | objective function upper limit | `1.0e+75` |

singlim | limit on singularity repairs | `10` |

## GAMS/CPLEX: Simplex Tolerance Options

Option | Description | Default |
---|---|---|

epmrk | Markowitz pivot tolerance | `0.01` |

epopt | optimality tolerance | `1.0e-06` |

eprhs | feasibility tolerance | `1.0e-06` |

netepopt | optimality tolerance for the network simplex method | `1.0e-06` |

neteprhs | feasibility tolerance for the network simplex method | `1.0e-06` |

## GAMS/CPLEX: Barrier Specific Options

Option | Description | Default |
---|---|---|

baralg | algorithm selection | `0` |

barcolnz | dense column handling | `0` |

barcrossalg | barrier crossover method | `0` |

barepcomp | convergence tolerance | `1.0e-08` |

bargrowth | unbounded face detection | `1.0e+12` |

baritlim | iteration limit | `2147483647` |

barmaxcor | maximum correction limit | `-1` |

barobjrng | maximum objective function | `1.0e+20` |

barorder | row ordering algorithm selection | `0` |

barqcpepcomp | convergence tolerance for the barrier optimizer for QCPs | `1.0e-07` |

barstartalg | barrier starting point algorithm | `1` |

## GAMS/CPLEX: Sifting Specific Options

Option | Description | Default |
---|---|---|

siftalg | sifting subproblem algorithm | `0` |

siftitlim | limit on sifting iterations | `2147483647` |

## GAMS/CPLEX: MIP Algorithmic Options

Option | Description | Default |
---|---|---|

bbinterval | best bound interval | `7` |

bendersstrategy | Benders decomposition algorithm as a strategy | `0` |

bndstrenind | bound strengthening | `-1` |

bqpcuts | boolean quadric polytope cuts for nonconvex QP or MIQP solved to global optimality | `0` |

brdir | set branching direction | `0` |

bttol | backtracking limit | `1.0` |

cliques | clique cut generation | `0` |

covers | cover cut generation | `0` |

cutlo | lower cutoff for tree search | `-1.0e+75` |

cuts | default cut generation | `0` |

cutsfactor | cut limit | `-1.0` |

cutup | upper cutoff for tree search | `1.0e+75` |

disjcuts | disjunctive cuts generation | `0` |

divetype | MIP dive strategy | `0` |

eachcutlim | sets a limit for each type of cut | `2100000000` |

flowcovers | flow cover cut generation | `0` |

flowpaths | flow path cut generation | `0` |

fpheur | feasibility pump heuristic | `0` |

fraccuts | Gomory fractional cut generation | `0` |

gubcovers | GUB cover cut generation | `0` |

heurfreq | heuristic frequency | `0` |

heuristiceffort | the effort that CPLEX spends on heuristics during a MIP solve | `1.0` |

implbd | implied bound cut generation | `0` |

.lazy | Lazy constraints activation | `0` |

lazyconstraints | Indicator to use lazy constraints | `0` |

lbheur | local branching heuristic | `0` |

liftprojcuts | lift-and-project cuts | `0` |

localimplied | generation of locally valid implied bound cuts | `0` |

mcfcuts | multi-commodity flow cut generation | `0` |

mipemphasis | MIP solution tactics | `0` |

mipkappastats | MIP kappa computation | `0` |

mipordind | priority list on/off | `1` |

mipordtype | priority order generation | `0` |

mipsearch | search strategy for mixed integer programs | `0` |

mipstart | use mip starting values | `0` |

miqcpstrat | MIQCP relaxation choice | `0` |

mircuts | mixed integer rounding cut generation | `0` |

multimipstart | use multiple mipstarts provided via gdx files | |

nodecuts | decide whether or not cutting planes are separated at the nodes of the branch-and-bound tree | `0` |

nodefileind | node storage file indicator | `1` |

nodesel | node selection strategy | `1` |

preslvnd | node presolve selector | `0` |

probe | perform probing before solving a MIP | `0` |

qpmakepsdind | adjust MIQP formulation to make the quadratic matrix positive-semi-definite | `1` |

repeatpresolve | reapply presolve at root after preprocessing | `-1` |

rinsheur | relaxation induced neighborhood search frequency | `0` |

rltcuts | Reformulation Linearization Technique (RLT) cuts | `0` |

solvefinal | switch to solve the problem with fixed discrete variables | `1` |

sos1reform | automatic logarithmic reformulation of special ordered sets of type 1 (SOS1) | `0` |

sos2reform | automatic logarithmic reformulation of special ordered sets of type 2 (SOS2) | `0` |

startalg | MIP starting algorithm | `0` |

strongcandlim | size of the candidates list for strong branching | `10` |

strongitlim | limit on iterations per branch for strong branching | `0` |

subalg | algorithm for subproblems | `0` |

submipnodelim | limit on number of nodes in an RINS subMIP | `500` |

submipscale | scale the problem matrix when CPLEX solves a subMIP during MIP optimization | `0` |

submipstartalg | starting algorithm for a subMIP of a MIP | `0` |

submipsubalg | algorithm for subproblems of a subMIP of a MIP | `0` |

symmetry | symmetry breaking cuts | `-1` |

varsel | variable selection strategy at each node | `0` |

workeralgorithm | set method for optimizing benders subproblems | `0` |

zerohalfcuts | zero-half cuts | `0` |

## GAMS/CPLEX: MIP Limit Options

Option | Description | Default |
---|---|---|

aggcutlim | aggregation limit for cut generation | `3` |

auxrootthreads | number of threads for auxiliary tasks at the root node | `0` |

cutpass | maximum number of cutting plane passes | `0` |

fraccand | candidate limit for generating Gomory fractional cuts | `200` |

fracpass | maximum number of passes for generating Gomory fractional cuts | `0` |

intsollim | maximum number of integer solutions | `2147483647` |

nodelim | maximum number of nodes to solve | `2147483647` |

polishafterdettime | deterministic time before starting to polish a feasible solution | `1.0e+75` |

polishafterepagap | absolute MIP gap before starting to polish a feasible solution | `0.0` |

polishafterepgap | relative MIP gap before starting to polish a solution | `0.0` |

polishafterintsol | MIP integer solutions to find before starting to polish a feasible solution | `2147483647` |

polishafternode | nodes to process before starting to polish a feasible solution | `2147483647` |

polishaftertime | time before starting to polish a feasible solution | `1.0e+75` |

probedettime | deterministic time spent probing | `1.0e+75` |

probetime | time spent probing | `1.0e+75` |

repairtries | try to repair infeasible MIP start | `0` |

trelim | maximum space in memory for tree | `1.0e+75` |

## GAMS/CPLEX: MIP Solution Pool Options

Option | Description | Default |
---|---|---|

.divflt | solution pool range filter coefficients | `0` |

divfltlo | lower bound on diversity | `mindouble` |

divfltup | upper bound on diversity | `maxdouble` |

populatelim | limit of solutions generated for the solution pool by populate method | `20` |

readflt | reads Cplex solution pool filter file | |

solnpool | solution pool file name | |

solnpoolagap | absolute tolerance for the solutions in the solution pool | `1.0e+75` |

solnpoolcapacity | limits of solutions kept in the solution pool | `2100000000` |

solnpoolgap | relative tolerance for the solutions in the solution pool | `1.0e+75` |

solnpoolintensity | solution pool intensity for ability to produce multiple solutions | `0` |

solnpoolmerge | solution pool file name for merged solutions | |

solnpoolnumsym | maximum number of variable symbols when writing merged solutions | `10` |

solnpoolprefix | file name prefix for GDX solution files | `soln` |

solnpoolreplace | strategy for replacing a solution in the solution pool | `0` |

## GAMS/CPLEX: MIP Tolerance Options

Option | Description | Default |
---|---|---|

bendersfeascuttol | Tolerance for whether a feasibility cut has been violated in Benders decomposition | `1.0e-06` |

bendersoptcuttol | Tolerance for optimality cuts in Benders decomposition | `1.0e-06` |

epagap | absolute stopping tolerance | `1.0e-06` |

epgap | relative stopping tolerance | `1.0e-04` |

epint | integrality tolerance | `1.0e-05` |

eplin | degree of tolerance used in linearization | `0.001` |

objdif | overrides GAMS Cheat parameter | `0.0` |

relobjdif | relative cheat parameter | `0.0` |

## GAMS/CPLEX: Output Options

Option | Description | Default |
---|---|---|

bardisplay | progress display level | `1` |

clonelog | enable clone logs | `0` |

mipdisplay | progress display level | `2` |

mipinterval | progress display interval | `0` |

mpslongnum | MPS file format precision of numeric output | `1` |

netdisplay | network display level | `2` |

quality | write solution quality statistics | `0` |

siftdisplay | sifting display level | `1` |

simdisplay | simplex display level | `1` |

writeannotation | produce a Cplex annotation file | |

writebas | produce a Cplex basis file | |

writeflt | produce a Cplex solution pool filter file | |

writelp | produce a Cplex LP file | |

writemps | produce a Cplex MPS file | |

writemst | produce a Cplex mst file | |

writeord | produce a Cplex ord file | |

writeparam | produce a Cplex parameter file with all active options | |

writepre | produce a Cplex LP/MPS/SAV file of the presolved problem | |

writeprob | produce a Cplex problem file and inferrs the type from the extension | |

writesav | produce a Cplex binary problem file |

# Parallel execution using multiple threads

Both ODHeuristicMethods `STANDALONE`

and `ODH-CPLEX`

can use multiple simultaneous threads. `ODH-CPLEX`

must use separate threads for the main CPLEX solve and for the ODHeuristics engine. The `STANDALONE`

just uses the ODHeuristics engine which may use multiple simultaneous threads. Thus the processing capability of multi-core hardware can be exploited effectively.

GAMS/ODHCPLEX will ignore the GAMS threads parameter and use its own default. The default ODHeuristic method (i.e. `ODH-CPLEX`

) requires multiple threads to works and with the GAMS threads default of 1 this will not work.

Whilst there are good defaults for allocating available threads, it may be worthwhile to give some attention to the allocation of threads between the main CPLEX solver and the ODHeuristics engine for ODH-CPLEX and STANDALONE.

If the option ODHThreads is set to *n*, *n* threads are allocated in total, otherwise the total number of threads allocated for both ODH-CPLEX and STANDALONE is set to the number of physical processors available on the computer. If the ODHThreads option is set to a number greater than the number of available processors, multiple threads will have to share the same processor, which may severely degrade performance.

In general, the more threads allocated to the main CPLEX solver, the faster it will run, and similarly, the more allocated to the ODHeuristics engine, the faster it will run. The best balance depends on the model being solved and whether it is intended to run to optimality or to an optimality gap of (say) 0.05 or 0.1. If the GAMS/Cplex Threads is not set, ODH-CPLEX defaults to allocating a quarter of the threads to the ODHeuristics engine and the remainder to the main CPLEX solve. Otherwise it allocates the specified number of threads to the main CPLEX solver and the remainder to the ODHeuristics engine.

Within the ODHeuristics engine, the principal heuristic algorithm can run in parallel on multiple threads. Each algorithmic thread uses CPLEX to solve sub-models and each such instance of CPLEX can itself run on multiple threads. So some attention needs to be given to the allocation of threads between them. If SUB_CPX_THREADS is not set, the CPLEX solver will use one thread for each available logical processor to solve the sub-models. This means that only one thread will be available for the solution improvement heuristic. If the option SUB_CPX_THREADS is set, then by default the heuristic engine sets its number of algorithmic threads to

number_of_available_processors / SUB_CPX_THREADS

where number_of_available_processors is: the number of logical processors for STANDALONE; and for ODH-CPLEX it is this number less those allocated to the main CPLEX solver.

Many Intel and compatible processors support hyperthreading (where this is enabled on the computer and operating system) and if so there will be two logical processors for every physical core. Using them can severely degrade performance, so if they are enabled it is often a good idea to set ODHThreads to the number of physical processors. Note that on machines with a large number of processors (cores), the principal bottleneck for large scale optimization is usually memory access. In practice it is often better to use only about half of the available cores on (say) a 24 core Intel Xeon system. This is model dependent and some experimentation is worthwhile.

Although the operating system's scheduler usually allocates threads to logical processors so that they run on separate physical cores where possible, it will have more threads to manage than those of the heuristic or CPLEX and so will change this allocation as the heuristic and CPLEX run so as to balance its workload effectively. There is a performance penalty to doing this from the perspective of the heuristic run time. For the ODHeuristics STANDALONE, this can be avoided by locking the heuristic threads to specific processors by setting the heuristic option parameter ProcessorLock to 1. It is not supported for ODH-CPLEX. Under Windows, beware that the threads need to be locked at an above normal priority so this may have a negative impact on other programs concurrently running on the machine.

# Determinism

Many users require that repeated runs of their applications under the same conditions give the same results, albeit in slightly variable times. The heuristic runs in this way by default. However, there is a performance penalty that has to be paid for synchronizing the threads. On average, performance can be considerably improved performance at the expense of non-repeatable execution by setting the heuristic option parameter Deterministic to 0. This is often preferred by users with particularly large and difficult models.

# Detailed Descriptions of ODHCLPEX Options

**advind** *(integer)*: advanced basis use ↵

Default:

`1`

**aggcutlim** *(integer)*: aggregation limit for cut generation ↵

Default:

`3`

**aggfill** *(integer)*: aggregator fill parameter ↵

Default:

`10`

**aggind** *(integer)*: aggregator on/off ↵

Default:

`-1`

**auxrootthreads** *(integer)*: number of threads for auxiliary tasks at the root node ↵

Default:

`0`

**baralg** *(integer)*: algorithm selection ↵

Default:

`0`

**barcolnz** *(integer)*: dense column handling ↵

Default:

`0`

**barcrossalg** *(integer)*: barrier crossover method ↵

Default:

`0`

**bardisplay** *(integer)*: progress display level ↵

Default:

`1`

**barepcomp** *(real)*: convergence tolerance ↵

Default:

`1.0e-08`

**bargrowth** *(real)*: unbounded face detection ↵

Default:

`1.0e+12`

**baritlim** *(integer)*: iteration limit ↵

Default:

`2147483647`

**barmaxcor** *(integer)*: maximum correction limit ↵

Default:

`-1`

**barobjrng** *(real)*: maximum objective function ↵

Default:

`1.0e+20`

**barorder** *(integer)*: row ordering algorithm selection ↵

Default:

`0`

**barqcpepcomp** *(real)*: convergence tolerance for the barrier optimizer for QCPs ↵

Default:

`1.0e-07`

**barstartalg** *(integer)*: barrier starting point algorithm ↵

Default:

`1`

**bbinterval** *(integer)*: best bound interval ↵

Default:

`7`

**bendersfeascuttol** *(real)*: Tolerance for whether a feasibility cut has been violated in Benders decomposition ↵

Default:

`1.0e-06`

**bendersoptcuttol** *(real)*: Tolerance for optimality cuts in Benders decomposition ↵

Default:

`1.0e-06`

**bendersstrategy** *(integer)*: Benders decomposition algorithm as a strategy ↵

Default:

`0`

**bndstrenind** *(integer)*: bound strengthening ↵

Default:

`-1`

**bqpcuts** *(integer)*: boolean quadric polytope cuts for nonconvex QP or MIQP solved to global optimality ↵

Default:

`0`

**brdir** *(integer)*: set branching direction ↵

Default:

`0`

**bttol** *(real)*: backtracking limit ↵

Default:

`1.0`

**calcqcpduals** *(integer)*: calculate the dual values of a quadratically constrained problem ↵

Default:

`1`

**cliques** *(integer)*: clique cut generation ↵

Default:

`0`

**clocktype** *(integer)*: clock type for computation time ↵

Default:

`2`

**clonelog** *(integer)*: enable clone logs ↵

Default:

`0`

**coeredind** *(integer)*: coefficient reduction on/off ↵

Default:

`-1`

**conflictalg** *(integer)*: algorithm CPLEX uses in the conflict refiner to discover a minimal set of conflicting constraints in an infeasible model ↵

Default:

`0`

**conflictdisplay** *(integer)*: decides how much information CPLEX reports when the conflict refiner is working ↵

Default:

`1`

**covers** *(integer)*: cover cut generation ↵

Default:

`0`

**cpumask** *(string)*: switch and mask to bind threads to processors (Linux only) ↵

Default:

`auto`

**cpxpresolve** *(integer)*: Applies CPLEX presolve to full model ↵

Default:

`0`

value meaning `-1`

Do not apply `0`

Automatically determined `1`

Always applied

**craind** *(integer)*: crash strategy (used to obtain starting basis) ↵

Default:

`1`

**cutlo** *(real)*: lower cutoff for tree search ↵

Default:

`-1.0e+75`

**cutoff** *(real)*: GMO cutoff ↵

Default:

`0.0`

**cutpass** *(integer)*: maximum number of cutting plane passes ↵

Default:

`0`

**cuts** *(string)*: default cut generation ↵

Default:

`0`

**cutsfactor** *(real)*: cut limit ↵

Default:

`-1.0`

**cutup** *(real)*: upper cutoff for tree search ↵

Default:

`1.0e+75`

**datacheck** *(integer)*: controls data consistency checking and modeling assistance ↵

Default:

`0`

**decompdensity** *(real)*: Matrix density above which automatic decomposition assigns each variable to a separate key ↵

Default:

`0.3`

**decomposition** *(integer)*: Model decomposition method. ↵

Default:

`-1`

value meaning `-1`

Automatically determined `0`

Assign each variable to a separate key `1`

Use automatic decomosition method `2`

Use decomposition based on dot option .key

**depind** *(integer)*: dependency checker on/off ↵

Default:

`-1`

**deterministic** *(boolean)*: Specifies whether the solution improvement heuristic is run in deterministic or opportunistic (i.e. non-deterministic) mode ↵

Default:

`1`

value meaning `0`

Opportunistic `1`

Deterministic

**dettilim** *(real)*: deterministic time limit ↵

Default:

`1.0e+75`

**disjcuts** *(integer)*: disjunctive cuts generation ↵

Default:

`0`

**divetype** *(integer)*: MIP dive strategy ↵

Default:

`0`

**.divflt** *(real)*: solution pool range filter coefficients ↵

Default:

`0`

**divfltlo** *(real)*: lower bound on diversity ↵

Default:

`mindouble`

**divfltup** *(real)*: upper bound on diversity ↵

Default:

`maxdouble`

**divisor** *(integer)*: Initial divisor for sub models ↵

Initial sub model size is model_size times 1 over Divisor. Ignored if InterDiv is set.

Default:

`automatic`

**domlim** *(integer)*: domain violation number ↵

Default:

`0`

**dpriind** *(integer)*: dual simplex pricing ↵

Default:

`0`

**dynamicrows** *(integer)*: switch for dynamic management of rows ↵

Default:

`-1`

**dynamicsearch** *(integer)*: Search strategy for CPLEX caller and sub-model solves ↵

Default:

`-1`

value meaning `-1`

Automatically determined `0`

Use traditional branch & cut `1`

Use dynamic search

**eachcutlim** *(integer)*: sets a limit for each type of cut ↵

Default:

`2100000000`

**epagap** *(real)*: absolute stopping tolerance ↵

Synonym: optca

Default:

`1.0e-06`

**epgap** *(real)*: relative stopping tolerance ↵

Synonym: optcr

Default:

`1.0e-04`

**epint** *(real)*: integrality tolerance ↵

Default:

`1.0e-05`

**eplin** *(real)*: degree of tolerance used in linearization ↵

Default:

`0.001`

**epmrk** *(real)*: Markowitz pivot tolerance ↵

Default:

`0.01`

**epopt** *(real)*: optimality tolerance ↵

Default:

`1.0e-06`

**epper** *(real)*: perturbation constant ↵

Default:

`1.0e-06`

**eprelax** *(real)*: relaxation for feasOpt ↵

Default:

`1.0e-06`

**eprhs** *(real)*: feasibility tolerance ↵

Default:

`1.0e-06`

**extracplexlog** *(boolean)*: Write addition CPLEX output to log ↵

Default:

`0`

value meaning `0`

Do not write extra CPLEX informtion `1`

Write extra CPLEX information

**feasoptmode** *(integer)*: mode of FeasOpt ↵

Default:

`0`

**feastol** *(real)*: Feasibility tolerance ↵

Range: [

`1e-9`

,`0.1`

]Default:

`1e-6`

**firstfeas** *(integer)*: Use first feasible heuristic for finding an initial feasible solution ↵

The default for ODH-CPLEX is 1 while for the heuristic engine the default is -1.

Default:

`-1`

value meaning `-1`

Do not use `0`

Use if no solution found during initial presolve `1`

Always use

**firstfeascontinue** *(boolean)*: Whether first feasible heuristic continues when it achieves feasibility ↵

Default:

`0`

value meaning `0`

Do not continue `1`

Continue

**firstfeaseffort** *(integer)*: Effort limit on first feasible heuristic ↵

If the option value is positive the exact value is used as the level of effort. If the value is negative no more than the absolute value of the option is used as the level of effort. The larger the effort level, the more effort is expended before giving up.

Default:

`-500`

**firstfeasshift** *(integer)*: First feasible heuristic variable shifting in found solutions ↵

Default:

`1`

value meaning `0`

Do not shift `1`

Moderate shifting `2`

Aggressive shifting

**fixoptfile** *(string)*: name of option file which is read just before solving the fixed problem ↵

**flowcovers** *(integer)*: flow cover cut generation ↵

Default:

`0`

**flowpaths** *(integer)*: flow path cut generation ↵

Default:

`0`

**folding** *(integer)*: LP folding will be attempted during the preprocessing phase ↵

Default:

`-1`

**fpheur** *(integer)*: feasibility pump heuristic ↵

Default:

`0`

**fraccand** *(integer)*: candidate limit for generating Gomory fractional cuts ↵

Default:

`200`

**fraccuts** *(integer)*: Gomory fractional cut generation ↵

Default:

`0`

**fracpass** *(integer)*: maximum number of passes for generating Gomory fractional cuts ↵

Default:

`0`

**freegamsmodel** *(boolean)*: preserves memory by dumping the GAMS model instance representation temporarily to disk ↵

Default:

`0`

**globalbounds** *(integer)*: Use of global bounds from CPLEX caller ↵

Default:

`2`

value meaning `0`

Never use `2`

Always use `1-4`

Intensity of use

**gubcovers** *(integer)*: GUB cover cut generation ↵

Default:

`0`

**heurfreq** *(integer)*: heuristic frequency ↵

Default:

`0`

**heuristiceffort** *(real)*: the effort that CPLEX spends on heuristics during a MIP solve ↵

Default:

`1.0`

**implbd** *(integer)*: implied bound cut generation ↵

Default:

`0`

**indexkey** *(string)*: Pattern used to match variable names for grouping into sub-models discussed above ↵

**indicoptstrict** *(boolean)*: abort in case of an error in indicator constraint in solver option file ↵

Default:

`1`

**integeronly** *(integer)*: Variables to include in INDEXKEY ↵

Default:

`-1`

value meaning `-1`

Automatically determined `0`

All variables `1`

Only non-continuous variables

**integertol** *(real)*: Integrality tolerance for variable values ↵

Default:

`1e-5`

**interdiv** *(integer)*: Initial divisor value ↵

Default:

`4`

**intsollim** *(integer)*: maximum number of integer solutions ↵

Default:

`2147483647`

**itlim** *(integer)*: iteration limit ↵

Synonym: iterlim

Default:

`2147483647`

**.key** *(integer)*: Variable block or key number ↵

Default:

`0`

**keytype** *(boolean)*: Treatment of multiple INDEXKEYs ↵

Default:

`0`

value meaning `0`

Considered separately e.g. INDEXKEY=x_d;y_d means x_2 and y_2 belong to separate groups `1`

Considered together e.g. INDEXKEY=x_d;y_d means x_2 and y_2 belong to the same group

**.lazy** *(boolean)*: Lazy constraints activation ↵

Default:

`0`

**lazyconstraints** *(boolean)*: Indicator to use lazy constraints ↵

Default:

`0`

**lbheur** *(boolean)*: local branching heuristic ↵

Default:

`0`

**liftprojcuts** *(integer)*: lift-and-project cuts ↵

Default:

`0`

**localimplied** *(integer)*: generation of locally valid implied bound cuts ↵

Default:

`0`

**lpmethod** *(integer)*: algorithm to be used for LP problems ↵

Default:

`0`

**maxbacktrack** *(integer)*: The maximum number of backtracks permitted in sub-model solves ↵

Default:

`-1`

value meaning `-1`

Automatically determined `0`

Infinite `>0`

Use this value if a better solution is available

**maxbound** *(real)*: The largest(smallest) non infinite bound value ODH will accept for upper(lower) bounds ↵

If this value is positive, bounds exceeding MAXBOUND are reduced to MAXBOUND; if this value is negative, bounds exceeding -MAXBOUND are ignored.

Default:

`1e+9`

**maxinfrepeat** *(integer)*: Maximum divisor value when solution is infeasible ↵

Default:

`0`

value meaning `0`

Automatically determined `>0`

Use this value

**maxinterdiv** *(integer)*: Maximum divisor value ↵

Default:

`0`

**maxrepeat** *(integer)*: Maximum number of sub-model repeat solves for each divisor value ↵

Default:

`0`

value meaning `0`

Automatically determined `>0`

Use this value

**mcfcuts** *(integer)*: multi-commodity flow cut generation ↵

Default:

`0`

**memoryemphasis** *(boolean)*: reduces use of memory ↵

Default:

`0`

**mipdisplay** *(integer)*: progress display level ↵

Default:

`2`

**mipemphasis** *(integer)*: MIP solution tactics ↵

Default:

`0`

**mipinterval** *(integer)*: progress display interval ↵

Default:

`0`

**mipkappastats** *(integer)*: MIP kappa computation ↵

Default:

`0`

**mipordind** *(boolean)*: priority list on/off ↵

Synonym: prioropt

Default:

`1`

**mipordtype** *(integer)*: priority order generation ↵

Default:

`0`

**mipsearch** *(integer)*: search strategy for mixed integer programs ↵

Default:

`0`

**mipstart** *(integer)*: use mip starting values ↵

Default:

`0`

**miqcpstrat** *(integer)*: MIQCP relaxation choice ↵

Default:

`0`

**mircuts** *(integer)*: mixed integer rounding cut generation ↵

Default:

`0`

**mpslongnum** *(boolean)*: MPS file format precision of numeric output ↵

Default:

`1`

**multimipstart** *(string)*: use multiple mipstarts provided via gdx files ↵

**multobjdisplay** *(integer)*: level of display during multiobjective optimization ↵

Default:

`1`

**names** *(boolean)*: load GAMS names into Cplex ↵

Default:

`1`

**netdisplay** *(integer)*: network display level ↵

Default:

`2`

**netepopt** *(real)*: optimality tolerance for the network simplex method ↵

Default:

`1.0e-06`

**neteprhs** *(real)*: feasibility tolerance for the network simplex method ↵

Default:

`1.0e-06`

**netfind** *(integer)*: attempt network extraction ↵

Default:

`2`

**netitlim** *(integer)*: iteration limit for network simplex ↵

Default:

`2147483647`

**netppriind** *(integer)*: network simplex pricing ↵

Default:

`0`

**newcallback** *(integer)*: CPLEX call-back type used ↵

Default:

`1`

value meaning `0`

Use legacy call-backs `1`

Use new call-backs for main CPLEX solve `2`

Use new call-backs for sub-model solves `3`

Use new call-backs for main CPLEX solve and sub-model solves

**nodecuts** *(integer)*: decide whether or not cutting planes are separated at the nodes of the branch-and-bound tree ↵

Default:

`0`

**nodefileind** *(integer)*: node storage file indicator ↵

Default:

`1`

**nodelim** *(integer)*: maximum number of nodes to solve ↵

Synonym: nodlim

Default:

`2147483647`

**nodesel** *(integer)*: node selection strategy ↵

Default:

`1`

**numericalemphasis** *(boolean)*: emphasizes precision in numerically unstable or difficult problems ↵

Default:

`0`

**objdif** *(real)*: overrides GAMS Cheat parameter ↵

Synonym: cheat

Default:

`0.0`

**objllim** *(real)*: objective function lower limit ↵

Default:

`-1.0e+75`

**objtarget** *(real)*: Target objective value ↵

ODHeuristics terminates when this value is reached. Defaults to -infinity for minimization or +infinity for maximization models.

Default:

`0`

**objulim** *(real)*: objective function upper limit ↵

Default:

`1.0e+75`

**odheuristicmethod** *(string)*: ODHeuristic method section ↵

Default:

`ODH-CPLEX`

value meaning `ODH-CPLEX`

ODHeuristic within the CPLEX optimizer `STANDALONE`

Stand-alone ODHeuristic engine

**odhfeasopt** *(boolean)*: Optimization method for sub-models in phaseI ↵

Default:

`0`

**odhpresolve** *(integer)*: Indicator for the ODHeuristics engine using a separate presolve within ODH-CPLEX ↵

Default:

`1`

value meaning `1`

One-step presolve `2`

Two-step presolve

**odhthreads** *(integer)*: The number of heuristic threads used by ODH-CPLEX or STANDALONE ↵

Default:

`-1`

value meaning `-1`

Automatically determined `0`

Run in serial mode `>0`

Use the specified number of threads

**odhtimelimit** *(real)*: Elapsed time limit in seconds ↵

Synonym: reslim

Default:

`GAMS ResLim`

**optimalitytarget** *(integer)*: type of optimality that Cplex targets ↵

Default:

`0`

**parallelmode** *(integer)*: parallel optimization mode ↵

Default:

`0`

**paramdisplay** *(boolean)*: display the nondefault parameters before optimization ↵

Default:

`1`

**penalty** *(real)*: The objective function coefficient value for penalties ↵

The objective function coefficient value for the penalties introduced to deal with infeasibilities in the solution improvement heuristic. It is set by default when required and if not specified.

Default:

`-1`

**penperturb** *(real)*: Perturbation tolerance for penalties coefficients ↵

Default:

`0`

**perind** *(boolean)*: force initial perturbation ↵

Default:

`0`

**perlim** *(integer)*: number of stalled iterations before perturbation ↵

Default:

`0`

**phase12** *(boolean)*: Specifies whether to use a phaseI/phaseII method to remove infeasibilities ↵

Default:

`1`

value meaning `0`

Use composite objective method `1`

Use phaseI/phaseII method

**polishafterdettime** *(real)*: deterministic time before starting to polish a feasible solution ↵

Default:

`1.0e+75`

**polishafterepagap** *(real)*: absolute MIP gap before starting to polish a feasible solution ↵

Default:

`0.0`

**polishafterepgap** *(real)*: relative MIP gap before starting to polish a solution ↵

Default:

`0.0`

**polishafterintsol** *(integer)*: MIP integer solutions to find before starting to polish a feasible solution ↵

Default:

`2147483647`

**polishafternode** *(integer)*: nodes to process before starting to polish a feasible solution ↵

Default:

`2147483647`

**polishaftertime** *(real)*: time before starting to polish a feasible solution ↵

Default:

`1.0e+75`

**populatelim** *(integer)*: limit of solutions generated for the solution pool by populate method ↵

Default:

`20`

**ppriind** *(integer)*: primal simplex pricing ↵

Default:

`0`

**predual** *(integer)*: give dual problem to the optimizer ↵

Default:

`0`

**preind** *(boolean)*: turn presolver on/off ↵

Default:

`1`

**prelinear** *(boolean)*: linear reduction indicator ↵

Default:

`1`

**prepass** *(integer)*: number of presolve applications to perform ↵

Default:

`-1`

**prereform** *(integer)*: set presolve reformulations ↵

Default:

`3`

**preslvnd** *(integer)*: node presolve selector ↵

Default:

`0`

**pricelim** *(integer)*: pricing candidate list ↵

Default:

`0`

**printoptions** *(boolean)*: list values of all options to GAMS listing file ↵

Default:

`0`

**probe** *(integer)*: perform probing before solving a MIP ↵

Default:

`0`

**probedettime** *(real)*: deterministic time spent probing ↵

Default:

`1.0e+75`

**probetime** *(real)*: time spent probing ↵

Default:

`1.0e+75`

**processorlock** *(boolean)*: Thread allocation ↵

Default:

`0`

value meaning `0`

Do not lock threads to processors `1`

Lock threads to processors

**qextractalg** *(integer)*: quadratic extraction algorithm in GAMS interface ↵

Default:

`0`

**qpmakepsdind** *(boolean)*: adjust MIQP formulation to make the quadratic matrix positive-semi-definite ↵

Default:

`1`

**qpmethod** *(integer)*: algorithm to be used for QP problems ↵

Default:

`0`

**qtolin** *(integer)*: linearization of the quadratic terms in the objective function of a QP or MIQP model ↵

Default:

`-1`

**quality** *(boolean)*: write solution quality statistics ↵

Default:

`0`

**quickfirstsolve** *(boolean)*: Accelerate initial CPLEX solve ↵

Default:

`0`

value meaning `0`

Do not unless presolve applied to full model `1`

Use existing presolved model

**randomseed** *(integer)*: sets the random seed differently for diversity of solutions ↵

Default:

`202009243`

**readflt** *(string)*: reads Cplex solution pool filter file ↵

**record** *(boolean)*: Records invocations of Callable Library routines ↵

Default:

`0`

**recurse** *(integer)*: Recurse using heuristic to solve sub-models when a feasible solution has been obtained ↵

Default:

`0`

value meaning `0`

Do not recurse `1`

Recurse thread 0 only `2`

Recurse odd numbered threads `3`

Recurse all threads `<0`

Recurse when working with an infeasible solution. values are negated (e.g. -3 = recursion of all threads)

**recursedecomp** *(integer)*: Recursed model decomposition method ↵

Default:

`0`

value meaning `-1`

Use initial model decomposition `0`

Assign each variable to a separate key `1`

Use automatic decomposition method

**recurseiterlim** *(integer)*: Recursed heuristic iteration limit for sub-solves ↵

Default:

`40`

**recurselog** *(boolean)*: Write thread log files for recursed sub-solves ↵

Default:

`0`

**recurseminiterlim** *(integer)*: Recursed heuristic minimum iterations before a solution is found in sub-solves ↵

Default:

`0`

**recursesoliterlim** *(integer)*: Recursed heuristic sub-solves quit after these iterations if a solution is found ↵

Default:

`maxint`

**reduce** *(integer)*: primal and dual reduction type ↵

Default:

`3`

**reinv** *(integer)*: refactorization frequency ↵

Default:

`0`

**rejectinfsol** *(integer)*: Reject infeasible solutions to sub-models ↵

Default:

`2`

value meaning `0`

Do not check feasibility or reject `1`

Check feasibility and warn if infeasible, but accept `2`

Check feasibility and reject if infeasible

**relaxfixedinfeas** *(boolean)*: accept small infeasibilties in the solve of the fixed problem ↵

Default:

`0`

**relaxpreind** *(integer)*: presolve for initial relaxation on/off ↵

Default:

`-1`

**relaxsos2** *(integer)*: Treatment of SOS2 members ↵

Default:

`1`

value meaning `0`

Aggressive use in reducing sub-model size `1`

Moderate use in reducing sub-model size `2`

Ignored in sub-model creation

**relobjdif** *(real)*: relative cheat parameter ↵

Default:

`0.0`

**repairtries** *(integer)*: try to repair infeasible MIP start ↵

Default:

`0`

**repeatpresolve** *(integer)*: reapply presolve at root after preprocessing ↵

Default:

`-1`

**rerun** *(string)*: rerun problem if presolve infeasible or unbounded ↵

Default:

`yes`

**rinsheur** *(integer)*: relaxation induced neighborhood search frequency ↵

Default:

`0`

**rltcuts** *(integer)*: Reformulation Linearization Technique (RLT) cuts ↵

Default:

`0`

**scaind** *(integer)*: matrix scaling on/off ↵

Default:

`0`

**seed** *(integer)*: Initial random number seed ↵

Default:

`1234`

**siftalg** *(integer)*: sifting subproblem algorithm ↵

Default:

`0`

**siftdisplay** *(integer)*: sifting display level ↵

Default:

`1`

**sifting** *(boolean)*: switch for sifting from simplex optimization ↵

Default:

`1`

**siftitlim** *(integer)*: limit on sifting iterations ↵

Default:

`2147483647`

**simdisplay** *(integer)*: simplex display level ↵

Default:

`1`

**singlim** *(integer)*: limit on singularity repairs ↵

Default:

`10`

**solnpool** *(string)*: solution pool file name ↵

**solnpoolagap** *(real)*: absolute tolerance for the solutions in the solution pool ↵

Default:

`1.0e+75`

**solnpoolcapacity** *(integer)*: limits of solutions kept in the solution pool ↵

Default:

`2100000000`

**solnpoolgap** *(real)*: relative tolerance for the solutions in the solution pool ↵

Default:

`1.0e+75`

**solnpoolintensity** *(integer)*: solution pool intensity for ability to produce multiple solutions ↵

Default:

`0`

**solnpoolmerge** *(string)*: solution pool file name for merged solutions ↵

**solnpoolnumsym** *(integer)*: maximum number of variable symbols when writing merged solutions ↵

Default:

`10`

**solnpoolprefix** *(string)*: file name prefix for GDX solution files ↵

Default:

`soln`

**solnpoolreplace** *(integer)*: strategy for replacing a solution in the solution pool ↵

Default:

`0`

**solutiontype** *(integer)*: type of solution (basic or non basic) for an LP or QP ↵

Default:

`0`

**solvefinal** *(boolean)*: switch to solve the problem with fixed discrete variables ↵

Default:

`1`

**sos1reform** *(integer)*: automatic logarithmic reformulation of special ordered sets of type 1 (SOS1) ↵

Default:

`0`

**sos2reform** *(integer)*: automatic logarithmic reformulation of special ordered sets of type 2 (SOS2) ↵

Default:

`0`

**startalg** *(integer)*: MIP starting algorithm ↵

Default:

`0`

**strategy** *(integer)*: ODH-Cplex Strategy ↵

The aggressive setting attempt to make more progress with each sub-model solve at the cost of more expensive sub solves. Amongst other changes, it sets InterDiv, MaxInterDiv and MaxRepeat if they are not explicitly set by the user.

Default:

`1`

value meaning `0`

Conservative `1`

Normal `2`

Aggressiv

**strongcandlim** *(integer)*: size of the candidates list for strong branching ↵

Default:

`10`

**strongitlim** *(integer)*: limit on iterations per branch for strong branching ↵

Default:

`0`

**subalg** *(integer)*: algorithm for subproblems ↵

Default:

`0`

**submipnodelim** *(integer)*: limit on number of nodes in an RINS subMIP ↵

Default:

`500`

**submipscale** *(integer)*: scale the problem matrix when CPLEX solves a subMIP during MIP optimization ↵

Default:

`0`

**submipstartalg** *(integer)*: starting algorithm for a subMIP of a MIP ↵

Default:

`0`

**submipsubalg** *(integer)*: algorithm for subproblems of a subMIP of a MIP ↵

Default:

`0`

**subnodelimit** *(integer)*: Node limit for submodel searches ↵

Default:

`-1`

value meaning `-1`

Automatically determined `>0`

Set node limit to this value

**suborder** *(integer)*: Use of priority order in sub-solves ↵

Default:

`1`

value meaning `0`

Do not use any supplied priority order information in sub-solves `1`

Use any supplied priority order information in sub-solves

**subpresolve** *(integer)*: Use of CPLEX presolve in sub-solves ↵

Default:

`1`

value meaning `1`

Use normal presolve `2`

Use two-step presolve

**sub_cpx_threads** *(integer)*: Threads availble for the solves within ODHeuristic ↵

Default:

`1`

**symmetry** *(integer)*: symmetry breaking cuts ↵

Default:

`-1`

**syncfreq** *(integer)*: Thread synchronization frequency in deterministic parallel mode ↵

Default:

`1`

value meaning `0`

Low frequency `1`

High frequency

**threadlog** *(boolean)*: Write thread log files ↵

Default:

`0`

**threads** *(integer)*: global default thread count ↵

Synonym: gthreads

Default:

`0`

**threadzerosync** *(integer)*: Which CPLEX threads to use for synchronization ↵

Default:

`0`

value meaning `0`

Synchronize with multiple CPLEX threads `1`

Only synchronize with CPLEX thread 0

**tilim** *(real)*: overrides the GAMS ResLim option ↵

Default:

`1.0e+75`

**trelim** *(real)*: maximum space in memory for tree ↵

Default:

`1.0e+75`

**tryint** *(real)*: GMO tryint ↵

Default:

`0.0`

**tuningdettilim** *(real)*: tuning deterministic time limit per model or suite ↵

Default:

`1.0e+75`

**tuningdisplay** *(integer)*: level of information reported by the tuning tool ↵

Default:

`1`

**tuningmeasure** *(integer)*: measure for evaluating progress for a suite of models ↵

Default:

`1`

**tuningrepeat** *(integer)*: number of times tuning is to be repeated on perturbed versions ↵

Default:

`1`

**tuningtilim** *(real)*: tuning time limit per model or suite ↵

Default:

`1.0e+75`

**usebasis** *(boolean)*: GMO usebasis ↵

Default:

`0`

**variableclean** *(integer)*: Clean variable values from sub-models ↵

Default:

`0`

value meaning `0`

No cleaning `1`

Quick cleaning and allow feasible uncleaned solutions if unable to clean `2`

Quick cleaning and disallow uncleaned solutions `3`

Thorough cleaning

**varsel** *(integer)*: variable selection strategy at each node ↵

Default:

`0`

**warninglimit** *(integer)*: determines how many times warnings of a specific type (datacheck=2) will be displayed ↵

Default:

`10`

**workdir** *(string)*: directory for working files ↵

Default:

`.`

**workeralgorithm** *(integer)*: set method for optimizing benders subproblems ↵

Default:

`0`

**workmem** *(real)*: memory available for working storage ↵

Default:

`2048.0`

**writeannotation** *(string)*: produce a Cplex annotation file ↵

**writebas** *(string)*: produce a Cplex basis file ↵

**writeflt** *(string)*: produce a Cplex solution pool filter file ↵

**writelp** *(string)*: produce a Cplex LP file ↵

**writemps** *(string)*: produce a Cplex MPS file ↵

**writemst** *(string)*: produce a Cplex mst file ↵

**writeord** *(string)*: produce a Cplex ord file ↵

**writeparam** *(string)*: produce a Cplex parameter file with all active options ↵

**writepre** *(string)*: produce a Cplex LP/MPS/SAV file of the presolved problem ↵

**writeprob** *(string)*: produce a Cplex problem file and inferrs the type from the extension ↵

**writesav** *(string)*: produce a Cplex binary problem file ↵

**zerohalfcuts** *(integer)*: zero-half cuts ↵

Default:

`0`

**zerotol** *(real)*: Zero tolerance for variable values ↵

Default:

`1e-9`