Changeset 1373 for branches


Ignore:
Timestamp:
Dec 6, 2009 4:21:35 PM (9 years ago)
Author:
bjarni
Message:

Renamed parameter constants in CbcParam?, CbcSolver?, and ClpAmplStuff? with same names as CbcOrClpParam? in CLP to make them more readable/search-able

Location:
branches/sandbox/Cbc/src
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • branches/sandbox/Cbc/src/CbcParam.cpp

    r1286 r1373  
    2121//-------------------------------------------------------------------
    2222CbcParam::CbcParam ()
    23         : type_(INVALID),
     23        : type_(CBC_PARAM_NOTUSED_INVALID),
    2424        lowerDoubleValue_(0.0),
    2525        upperDoubleValue_(0.0),
     
    3232        shortHelp_(),
    3333        longHelp_(),
    34         action_(INVALID),
     34        action_(CBC_PARAM_NOTUSED_INVALID),
    3535        currentKeyWord_(-1)
    3636{
     
    285285        double oldValue;
    286286        switch (type_) {
    287         case DUALTOLERANCE:
     287        case CLP_PARAM_DBL_DUALTOLERANCE:
    288288            model->getDblParam(OsiDualTolerance, oldValue);
    289289            model->setDblParam(OsiDualTolerance, value);
    290290            break;
    291         case PRIMALTOLERANCE:
     291        case CLP_PARAM_DBL_PRIMALTOLERANCE:
    292292            model->getDblParam(OsiPrimalTolerance, oldValue);
    293293            model->setDblParam(OsiPrimalTolerance, value);
     
    320320    bool getDblParamRetValue;
    321321    switch (type_) {
    322     case DUALTOLERANCE:
     322    case CLP_PARAM_DBL_DUALTOLERANCE:
    323323        getDblParamRetValue = model->getDblParam(OsiDualTolerance, value);
    324324        assert(getDblParamRetValue);
    325325        break;
    326     case PRIMALTOLERANCE:
     326    case CLP_PARAM_DBL_PRIMALTOLERANCE:
    327327        getDblParamRetValue = model->getDblParam(OsiPrimalTolerance, value);
    328328        assert(getDblParamRetValue);
     
    344344        int oldValue;
    345345        switch (type_) {
    346         case LOGLEVEL:
     346        case CLP_PARAM_INT_LOGLEVEL:
    347347            oldValue = model->messageHandler()->logLevel();
    348348            model->messageHandler()->setLogLevel(value);
     
    362362    int value = 0;
    363363    switch (type_) {
    364     case LOGLEVEL:
     364    case CLP_PARAM_INT_LOGLEVEL:
    365365        //value=model->logLevel();
    366366        break;
     
    381381        double oldValue;
    382382        switch (type_) {
    383         case INFEASIBILITYWEIGHT:
     383        case CBC_PARAM_DBL_INFEASIBILITYWEIGHT:
    384384            oldValue = model.getDblParam(CbcModel::CbcInfeasibilityWeight);
    385385            model.setDblParam(CbcModel::CbcInfeasibilityWeight, value);
    386386            break;
    387         case INTEGERTOLERANCE:
     387        case CBC_PARAM_DBL_INTEGERTOLERANCE:
    388388            oldValue = model.getDblParam(CbcModel::CbcIntegerTolerance);
    389389            model.setDblParam(CbcModel::CbcIntegerTolerance, value);
    390390            break;
    391         case INCREMENT:
     391        case CBC_PARAM_DBL_INCREMENT:
    392392            oldValue = model.getDblParam(CbcModel::CbcCutoffIncrement);
    393393            model.setDblParam(CbcModel::CbcCutoffIncrement, value);
    394         case ALLOWABLEGAP:
     394        case CBC_PARAM_DBL_ALLOWABLEGAP:
    395395            oldValue = model.getDblParam(CbcModel::CbcAllowableGap);
    396396            model.setDblParam(CbcModel::CbcAllowableGap, value);
    397397            break;
    398         case TIMELIMIT: {
     398        case CLP_PARAM_DBL_TIMELIMIT: {
    399399            oldValue = model.getDblParam(CbcModel::CbcMaximumSeconds) ;
    400400            model.setDblParam(CbcModel::CbcMaximumSeconds, value) ;
    401401            break ;
    402402        }
    403         case DUALTOLERANCE:
    404         case PRIMALTOLERANCE:
     403        case CLP_PARAM_DBL_DUALTOLERANCE:
     404        case CLP_PARAM_DBL_PRIMALTOLERANCE:
    405405            setDoubleParameter(model.solver(), value);
    406406            return 0; // to avoid message
     
    419419    double value;
    420420    switch (type_) {
    421     case INFEASIBILITYWEIGHT:
     421    case CBC_PARAM_DBL_INFEASIBILITYWEIGHT:
    422422        value = model.getDblParam(CbcModel::CbcInfeasibilityWeight);
    423423        break;
    424     case INTEGERTOLERANCE:
     424    case CBC_PARAM_DBL_INTEGERTOLERANCE:
    425425        value = model.getDblParam(CbcModel::CbcIntegerTolerance);
    426426        break;
    427     case INCREMENT:
     427    case CBC_PARAM_DBL_INCREMENT:
    428428        value = model.getDblParam(CbcModel::CbcCutoffIncrement);
    429     case ALLOWABLEGAP:
     429    case CBC_PARAM_DBL_ALLOWABLEGAP:
    430430        value = model.getDblParam(CbcModel::CbcAllowableGap);
    431431        break;
    432     case TIMELIMIT: {
     432    case CLP_PARAM_DBL_TIMELIMIT: {
    433433        value = model.getDblParam(CbcModel::CbcMaximumSeconds) ;
    434434        break ;
    435435    }
    436     case DUALTOLERANCE:
    437     case PRIMALTOLERANCE:
     436    case CLP_PARAM_DBL_DUALTOLERANCE:
     437    case CLP_PARAM_DBL_PRIMALTOLERANCE:
    438438        value = doubleParameter(model.solver());
    439439        break;
     
    454454        int oldValue;
    455455        switch (type_) {
    456         case LOGLEVEL:
     456        case CLP_PARAM_INT_LOGLEVEL:
    457457            oldValue = model.messageHandler()->logLevel();
    458458            model.messageHandler()->setLogLevel(value);
    459459            break;
    460         case SOLVERLOGLEVEL:
     460        case CLP_PARAM_INT_SOLVERLOGLEVEL:
    461461            oldValue = model.solver()->messageHandler()->logLevel();
    462462            model.solver()->messageHandler()->setLogLevel(value);
    463463            break;
    464         case MAXNODES:
     464        case CBC_PARAM_INT_MAXNODES:
    465465            oldValue = model.getIntParam(CbcModel::CbcMaxNumNode);
    466466            model.setIntParam(CbcModel::CbcMaxNumNode, value);
    467467            break;
    468         case STRONGBRANCHING:
     468        case CBC_PARAM_INT_STRONGBRANCHING:
    469469            oldValue = model.numberStrong();
    470470            model.setNumberStrong(value);
     
    484484    int value;
    485485    switch (type_) {
    486     case LOGLEVEL:
     486    case CLP_PARAM_INT_LOGLEVEL:
    487487        value = model.messageHandler()->logLevel();
    488488        break;
    489     case SOLVERLOGLEVEL:
     489    case CLP_PARAM_INT_SOLVERLOGLEVEL:
    490490        value = model.solver()->messageHandler()->logLevel();
    491491        break;
    492     case MAXNODES:
     492    case CBC_PARAM_INT_MAXNODES:
    493493        value = model.getIntParam(CbcModel::CbcMaxNumNode);
    494494        break;
    495     case STRONGBRANCHING:
     495    case CBC_PARAM_INT_STRONGBRANCHING:
    496496        value = model.numberStrong();
    497497        break;
  • branches/sandbox/Cbc/src/CbcParam.hpp

    r1286 r1373  
    2424
    2525  This coding scheme is in flux.
    26   NODESTRATEGY, BRANCHSTRATEGY, ADDCUTSSTRATEGY,
    27   CLEARCUTS, OSLSTUFF, CBCSTUFF are not used at present (03.10.24).
     26  CBC_PARAM_STR_NODESTRATEGY,
     27  CBC_PARAM_STR_BRANCHSTRATEGY,
     28  CBC_PARAM_NOTUSED_ADDCUTSSTRATEGY,
     29  CLP_PARAM_ACTION_CLEARCUTS,
     30  CBC_PARAM_NOTUSED_OSLSTUFF,
     31  CBC_PARAM_NOTUSED_CBCSTUFF are not used at present (03.10.24).
    2832*/
    2933
    3034enum CbcParameterType
    3135
    32 { GENERALQUERY = -100, FULLGENERALQUERY,
    33 
    34   PRIMALTOLERANCE = 1, DUALTOLERANCE, CUTOFF, TIMELIMIT,
    35   DUALBOUND, PRIMALWEIGHT,  OBJSCALE, RHSSCALE,
    36 
    37   INFEASIBILITYWEIGHT = 51, INTEGERTOLERANCE, INCREMENT, ALLOWABLEGAP,
    38 
    39   DJFIX = 81, GAPRATIO, TIGHTENFACTOR,
    40 
    41   LOGLEVEL = 101, SOLVERLOGLEVEL, MAXNODES, STRONGBRANCHING,
    42   MAXFACTOR, PERTVALUE, MAXITERATION, PRESOLVEPASS, IDIOT, SPRINT,
    43   OUTPUTFORMAT, SLPVALUE, PRESOLVEOPTIONS, PRINTOPTIONS, SPECIALOPTIONS,
    44 
    45   DIRECTION = 201, DUALPIVOT, SCALING, ERRORSALLOWED, KEEPNAMES, SPARSEFACTOR,
    46   PRIMALPIVOT, PRESOLVE, CRASH, BIASLU, PERTURBATION, MESSAGES, AUTOSCALE,
    47   CHOLESKY, KKT, BARRIERSCALE, GAMMA, CROSSOVER, PFI, ALGORITHM,
    48 
    49   NODESTRATEGY = 251, BRANCHSTRATEGY, ADDCUTSSTRATEGY,
    50   GOMORYCUTS, PROBINGCUTS, KNAPSACKCUTS, ODDHOLECUTS,
    51   ROUNDING, SOLVER, CLIQUECUTS, COSTSTRATEGY, FLOWCUTS, MIXEDCUTS,
    52   TWOMIRCUTS, PREPROCESS,
    53 
    54   DIRECTORY = 301, IMPORT, EXPORT, RESTORE, SAVE, DUALSIMPLEX, PRIMALSIMPLEX,
    55   MAXIMIZE, MINIMIZE, EXIT, STDIN, UNITTEST, NETLIB_DUAL, NETLIB_PRIMAL, SOLUTION,
    56   TIGHTEN, FAKEBOUND, HELP, PLUSMINUS, NETWORK, ALLSLACK, REVERSE, BARRIER, NETLIB_BARRIER,
    57   REALLY_SCALE, BASISIN, BASISOUT, SOLVECONTINUOUS, BAB, MIPLIB, CLEARCUTS, PRINTVERSION,
    58 
    59   OSLSTUFF = 401, CBCSTUFF,
    60 
    61   INVALID = 1000
     36{ CBC_PARAM_GENERALQUERY = -100,
     37  CBC_PARAM_FULLGENERALQUERY,
     38
     39  CLP_PARAM_DBL_PRIMALTOLERANCE = 1,
     40  CLP_PARAM_DBL_DUALTOLERANCE,
     41  CBC_PARAM_DBL_CUTOFF,
     42  CLP_PARAM_DBL_TIMELIMIT,
     43  CLP_PARAM_DBL_DUALBOUND,
     44  CLP_PARAM_DBL_PRIMALWEIGHT, 
     45  CLP_PARAM_DBL_OBJSCALE,
     46  CLP_PARAM_DBL_RHSSCALE,
     47
     48  CBC_PARAM_DBL_INFEASIBILITYWEIGHT = 51,
     49  CBC_PARAM_DBL_INTEGERTOLERANCE,
     50  CBC_PARAM_DBL_INCREMENT,
     51  CBC_PARAM_DBL_ALLOWABLEGAP,
     52
     53  CBC_PARAM_DBL_DJFIX = 81,
     54  CBC_PARAM_DBL_GAPRATIO,
     55  CBC_PARAM_DBL_TIGHTENFACTOR,
     56
     57  CLP_PARAM_INT_LOGLEVEL = 101,
     58  CLP_PARAM_INT_SOLVERLOGLEVEL,
     59  CBC_PARAM_INT_MAXNODES,
     60  CBC_PARAM_INT_STRONGBRANCHING,
     61  CLP_PARAM_INT_MAXFACTOR,
     62  CLP_PARAM_INT_PERTVALUE,
     63  CLP_PARAM_INT_MAXITERATION,
     64  CLP_PARAM_INT_PRESOLVEPASS,
     65  CLP_PARAM_INT_IDIOT,
     66  CLP_PARAM_INT_SPRINT,
     67  CLP_PARAM_INT_OUTPUTFORMAT,
     68  CLP_PARAM_INT_SLPVALUE,
     69  CLP_PARAM_INT_PRESOLVEOPTIONS,
     70  CLP_PARAM_INT_PRINTOPTIONS,
     71  CLP_PARAM_INT_SPECIALOPTIONS,
     72
     73  CLP_PARAM_STR_DIRECTION = 201,
     74  CLP_PARAM_STR_DUALPIVOT,
     75  CLP_PARAM_STR_SCALING,
     76  CLP_PARAM_STR_ERRORSALLOWED,
     77  CLP_PARAM_STR_KEEPNAMES,
     78  CLP_PARAM_STR_SPARSEFACTOR,
     79  CLP_PARAM_STR_PRIMALPIVOT,
     80  CLP_PARAM_STR_PRESOLVE,
     81  CLP_PARAM_STR_CRASH,
     82  CLP_PARAM_STR_BIASLU,
     83  CLP_PARAM_STR_PERTURBATION,
     84  CLP_PARAM_STR_MESSAGES,
     85  CLP_PARAM_STR_AUTOSCALE,
     86  CLP_PARAM_STR_CHOLESKY,
     87  CLP_PARAM_STR_KKT,
     88  CLP_PARAM_STR_BARRIERSCALE,
     89  CLP_PARAM_STR_GAMMA,
     90  CLP_PARAM_STR_CROSSOVER,
     91  CLP_PARAM_STR_PFI,
     92  CLP_PARAM_NOTUSED_ALGORITHM,
     93
     94  CBC_PARAM_STR_NODESTRATEGY = 251,
     95  CBC_PARAM_STR_BRANCHSTRATEGY,
     96  CBC_PARAM_NOTUSED_ADDCUTSSTRATEGY,
     97  CBC_PARAM_STR_GOMORYCUTS,
     98  CBC_PARAM_STR_PROBINGCUTS,
     99  CBC_PARAM_STR_KNAPSACKCUTS,
     100  CBC_PARAM_NOTUSED_ODDHOLECUTS,
     101  CBC_PARAM_STR_ROUNDING,
     102  CBC_PARAM_STR_SOLVER,
     103  CBC_PARAM_STR_CLIQUECUTS,
     104  CBC_PARAM_STR_COSTSTRATEGY,
     105  CBC_PARAM_STR_FLOWCUTS,
     106  CBC_PARAM_STR_MIXEDCUTS,
     107  CBC_PARAM_STR_TWOMIRCUTS,
     108  CBC_PARAM_STR_PREPROCESS,
     109
     110  CLP_PARAM_ACTION_DIRECTORY = 301,
     111  CLP_PARAM_ACTION_IMPORT,
     112  CLP_PARAM_ACTION_EXPORT,
     113  CLP_PARAM_ACTION_RESTORE,
     114  CLP_PARAM_ACTION_SAVE,
     115  CLP_PARAM_ACTION_DUALSIMPLEX,
     116  CLP_PARAM_ACTION_PRIMALSIMPLEX,
     117  CLP_PARAM_ACTION_MAXIMIZE,
     118  CLP_PARAM_ACTION_MINIMIZE,
     119  CLP_PARAM_ACTION_EXIT,
     120  CLP_PARAM_ACTION_STDIN,
     121  CLP_PARAM_ACTION_UNITTEST,
     122  CLP_PARAM_ACTION_NETLIB_DUAL,
     123  CLP_PARAM_ACTION_NETLIB_PRIMAL,
     124  CLP_PARAM_ACTION_SOLUTION,
     125  CLP_PARAM_ACTION_TIGHTEN,
     126  CLP_PARAM_ACTION_FAKEBOUND,
     127  CLP_PARAM_ACTION_HELP,
     128  CLP_PARAM_ACTION_PLUSMINUS,
     129  CLP_PARAM_ACTION_NETWORK,
     130  CLP_PARAM_ACTION_ALLSLACK,
     131  CLP_PARAM_ACTION_REVERSE,
     132  CLP_PARAM_ACTION_BARRIER,
     133  CLP_PARAM_ACTION_NETLIB_BARRIER,
     134  CLP_PARAM_ACTION_REALLY_SCALE,
     135  CLP_PARAM_ACTION_BASISIN,
     136  CLP_PARAM_ACTION_BASISOUT,
     137  CLP_PARAM_ACTION_SOLVECONTINUOUS,
     138  CBC_PARAM_ACTION_BAB,
     139  CBC_PARAM_ACTION_MIPLIB,
     140  CLP_PARAM_ACTION_CLEARCUTS,
     141  CLP_VERSION_NOTUSED_PRINTVERSION,
     142
     143  CBC_PARAM_NOTUSED_OSLSTUFF = 401,
     144  CBC_PARAM_NOTUSED_CBCSTUFF,
     145
     146  CBC_PARAM_NOTUSED_INVALID = 1000
    62147};
    63148
  • branches/sandbox/Cbc/src/CbcSolver.cpp

    r1361 r1373  
    449449        createSolver = 1 ;
    450450    }
    451     parameters_[whichParam(BASISIN, numberParameters_, parameters_)].setStringValue(importBasisFile);
    452     parameters_[whichParam(PRIORITYIN, numberParameters_, parameters_)].setStringValue(importPriorityFile);
    453     parameters_[whichParam(BASISOUT, numberParameters_, parameters_)].setStringValue(exportBasisFile);
    454     parameters_[whichParam(DEBUG, numberParameters_, parameters_)].setStringValue(debugFile);
    455     parameters_[whichParam(PRINTMASK, numberParameters_, parameters_)].setStringValue(printMask);
    456     parameters_[whichParam(DIRECTORY, numberParameters_, parameters_)].setStringValue(directory);
    457     parameters_[whichParam(DIRSAMPLE, numberParameters_, parameters_)].setStringValue(dirSample);
    458     parameters_[whichParam(DIRNETLIB, numberParameters_, parameters_)].setStringValue(dirNetlib);
    459     parameters_[whichParam(DIRMIPLIB, numberParameters_, parameters_)].setStringValue(dirMiplib);
    460     parameters_[whichParam(DUALBOUND, numberParameters_, parameters_)].setDoubleValue(lpSolver->dualBound());
    461     parameters_[whichParam(DUALTOLERANCE, numberParameters_, parameters_)].setDoubleValue(lpSolver->dualTolerance());
    462     parameters_[whichParam(EXPORT, numberParameters_, parameters_)].setStringValue(exportFile);
    463     parameters_[whichParam(IDIOT, numberParameters_, parameters_)].setIntValue(doIdiot);
    464     parameters_[whichParam(IMPORT, numberParameters_, parameters_)].setStringValue(importFile);
    465     parameters_[whichParam(PRESOLVETOLERANCE, numberParameters_, parameters_)].setDoubleValue(1.0e-8);
    466     int iParam = whichParam(SOLVERLOGLEVEL, numberParameters_, parameters_);
     451    parameters_[whichParam(CLP_PARAM_ACTION_BASISIN, numberParameters_, parameters_)].setStringValue(importBasisFile);
     452    parameters_[whichParam(CBC_PARAM_ACTION_PRIORITYIN, numberParameters_, parameters_)].setStringValue(importPriorityFile);
     453    parameters_[whichParam(CLP_PARAM_ACTION_BASISOUT, numberParameters_, parameters_)].setStringValue(exportBasisFile);
     454    parameters_[whichParam(CLP_PARAM_ACTION_DEBUG, numberParameters_, parameters_)].setStringValue(debugFile);
     455    parameters_[whichParam(CLP_PARAM_ACTION_PRINTMASK, numberParameters_, parameters_)].setStringValue(printMask);
     456    parameters_[whichParam(CLP_PARAM_ACTION_DIRECTORY, numberParameters_, parameters_)].setStringValue(directory);
     457    parameters_[whichParam(CLP_PARAM_ACTION_DIRSAMPLE, numberParameters_, parameters_)].setStringValue(dirSample);
     458    parameters_[whichParam(CLP_PARAM_ACTION_DIRNETLIB, numberParameters_, parameters_)].setStringValue(dirNetlib);
     459    parameters_[whichParam(CBC_PARAM_ACTION_DIRMIPLIB, numberParameters_, parameters_)].setStringValue(dirMiplib);
     460    parameters_[whichParam(CLP_PARAM_DBL_DUALBOUND, numberParameters_, parameters_)].setDoubleValue(lpSolver->dualBound());
     461    parameters_[whichParam(CLP_PARAM_DBL_DUALTOLERANCE, numberParameters_, parameters_)].setDoubleValue(lpSolver->dualTolerance());
     462    parameters_[whichParam(CLP_PARAM_ACTION_EXPORT, numberParameters_, parameters_)].setStringValue(exportFile);
     463    parameters_[whichParam(CLP_PARAM_INT_IDIOT, numberParameters_, parameters_)].setIntValue(doIdiot);
     464    parameters_[whichParam(CLP_PARAM_ACTION_IMPORT, numberParameters_, parameters_)].setStringValue(importFile);
     465    parameters_[whichParam(CLP_PARAM_DBL_PRESOLVETOLERANCE, numberParameters_, parameters_)].setDoubleValue(1.0e-8);
     466    int iParam = whichParam(CLP_PARAM_INT_SOLVERLOGLEVEL, numberParameters_, parameters_);
    467467    int value = 1;
    468468    clpSolver->messageHandler()->setLogLevel(1) ;
    469469    lpSolver->setLogLevel(1);
    470470    parameters_[iParam].setIntValue(value);
    471     iParam = whichParam(LOGLEVEL, numberParameters_, parameters_);
     471    iParam = whichParam(CLP_PARAM_INT_LOGLEVEL, numberParameters_, parameters_);
    472472    model_.messageHandler()->setLogLevel(value);
    473473    parameters_[iParam].setIntValue(value);
    474     parameters_[whichParam(MAXFACTOR, numberParameters_, parameters_)].setIntValue(lpSolver->factorizationFrequency());
    475     parameters_[whichParam(MAXITERATION, numberParameters_, parameters_)].setIntValue(lpSolver->maximumIterations());
    476     parameters_[whichParam(OUTPUTFORMAT, numberParameters_, parameters_)].setIntValue(outputFormat);
    477     parameters_[whichParam(PRESOLVEPASS, numberParameters_, parameters_)].setIntValue(preSolve);
    478     parameters_[whichParam(PERTVALUE, numberParameters_, parameters_)].setIntValue(lpSolver->perturbation());
    479     parameters_[whichParam(PRIMALTOLERANCE, numberParameters_, parameters_)].setDoubleValue(lpSolver->primalTolerance());
    480     parameters_[whichParam(PRIMALWEIGHT, numberParameters_, parameters_)].setDoubleValue(lpSolver->infeasibilityCost());
    481     parameters_[whichParam(RESTORE, numberParameters_, parameters_)].setStringValue(restoreFile);
    482     parameters_[whichParam(SAVE, numberParameters_, parameters_)].setStringValue(saveFile);
    483     //parameters_[whichParam(TIMELIMIT,numberParameters_,parameters_)].setDoubleValue(1.0e8);
    484     parameters_[whichParam(TIMELIMIT_BAB, numberParameters_, parameters_)].setDoubleValue(1.0e8);
    485     parameters_[whichParam(SOLUTION, numberParameters_, parameters_)].setStringValue(solutionFile);
    486     parameters_[whichParam(SAVESOL, numberParameters_, parameters_)].setStringValue(solutionSaveFile);
    487     parameters_[whichParam(SPRINT, numberParameters_, parameters_)].setIntValue(doSprint);
    488     parameters_[whichParam(SUBSTITUTION, numberParameters_, parameters_)].setIntValue(substitution);
    489     parameters_[whichParam(DUALIZE, numberParameters_, parameters_)].setIntValue(dualize);
    490     parameters_[whichParam(NUMBERBEFORE, numberParameters_, parameters_)].setIntValue(model_.numberBeforeTrust());
    491     parameters_[whichParam(MAXNODES, numberParameters_, parameters_)].setIntValue(model_.getMaximumNodes());
    492     parameters_[whichParam(STRONGBRANCHING, numberParameters_, parameters_)].setIntValue(model_.numberStrong());
    493     parameters_[whichParam(INFEASIBILITYWEIGHT, numberParameters_, parameters_)].setDoubleValue(model_.getDblParam(CbcModel::CbcInfeasibilityWeight));
    494     parameters_[whichParam(INTEGERTOLERANCE, numberParameters_, parameters_)].setDoubleValue(model_.getDblParam(CbcModel::CbcIntegerTolerance));
    495     parameters_[whichParam(INCREMENT, numberParameters_, parameters_)].setDoubleValue(model_.getDblParam(CbcModel::CbcCutoffIncrement));
    496     parameters_[whichParam(TESTOSI, numberParameters_, parameters_)].setIntValue(testOsiParameters);
    497     parameters_[whichParam(FPUMPTUNE, numberParameters_, parameters_)].setIntValue(1003);
     474    parameters_[whichParam(CLP_PARAM_INT_MAXFACTOR, numberParameters_, parameters_)].setIntValue(lpSolver->factorizationFrequency());
     475    parameters_[whichParam(CLP_PARAM_INT_MAXITERATION, numberParameters_, parameters_)].setIntValue(lpSolver->maximumIterations());
     476    parameters_[whichParam(CLP_PARAM_INT_OUTPUTFORMAT, numberParameters_, parameters_)].setIntValue(outputFormat);
     477    parameters_[whichParam(CLP_PARAM_INT_PRESOLVEPASS, numberParameters_, parameters_)].setIntValue(preSolve);
     478    parameters_[whichParam(CLP_PARAM_INT_PERTVALUE, numberParameters_, parameters_)].setIntValue(lpSolver->perturbation());
     479    parameters_[whichParam(CLP_PARAM_DBL_PRIMALTOLERANCE, numberParameters_, parameters_)].setDoubleValue(lpSolver->primalTolerance());
     480    parameters_[whichParam(CLP_PARAM_DBL_PRIMALWEIGHT, numberParameters_, parameters_)].setDoubleValue(lpSolver->infeasibilityCost());
     481    parameters_[whichParam(CLP_PARAM_ACTION_RESTORE, numberParameters_, parameters_)].setStringValue(restoreFile);
     482    parameters_[whichParam(CLP_PARAM_ACTION_SAVE, numberParameters_, parameters_)].setStringValue(saveFile);
     483    //parameters_[whichParam(CLP_PARAM_DBL_TIMELIMIT,numberParameters_,parameters_)].setDoubleValue(1.0e8);
     484    parameters_[whichParam(CBC_PARAM_DBL_TIMELIMIT_BAB, numberParameters_, parameters_)].setDoubleValue(1.0e8);
     485    parameters_[whichParam(CLP_PARAM_ACTION_SOLUTION, numberParameters_, parameters_)].setStringValue(solutionFile);
     486    parameters_[whichParam(CLP_PARAM_ACTION_SAVESOL, numberParameters_, parameters_)].setStringValue(solutionSaveFile);
     487    parameters_[whichParam(CLP_PARAM_INT_SPRINT, numberParameters_, parameters_)].setIntValue(doSprint);
     488    parameters_[whichParam(CLP_PARAM_INT_SUBSTITUTION, numberParameters_, parameters_)].setIntValue(substitution);
     489    parameters_[whichParam(CLP_PARAM_INT_DUALIZE, numberParameters_, parameters_)].setIntValue(dualize);
     490    parameters_[whichParam(CBC_PARAM_INT_NUMBERBEFORE, numberParameters_, parameters_)].setIntValue(model_.numberBeforeTrust());
     491    parameters_[whichParam(CBC_PARAM_INT_MAXNODES, numberParameters_, parameters_)].setIntValue(model_.getMaximumNodes());
     492    parameters_[whichParam(CBC_PARAM_INT_STRONGBRANCHING, numberParameters_, parameters_)].setIntValue(model_.numberStrong());
     493    parameters_[whichParam(CBC_PARAM_DBL_INFEASIBILITYWEIGHT, numberParameters_, parameters_)].setDoubleValue(model_.getDblParam(CbcModel::CbcInfeasibilityWeight));
     494    parameters_[whichParam(CBC_PARAM_DBL_INTEGERTOLERANCE, numberParameters_, parameters_)].setDoubleValue(model_.getDblParam(CbcModel::CbcIntegerTolerance));
     495    parameters_[whichParam(CBC_PARAM_DBL_INCREMENT, numberParameters_, parameters_)].setDoubleValue(model_.getDblParam(CbcModel::CbcCutoffIncrement));
     496    parameters_[whichParam(CBC_PARAM_INT_TESTOSI, numberParameters_, parameters_)].setIntValue(testOsiParameters);
     497    parameters_[whichParam(CBC_PARAM_INT_FPUMPTUNE, numberParameters_, parameters_)].setIntValue(1003);
    498498    initialPumpTune = 1003;
    499499#ifdef CBC_THREAD
    500     parameters_[whichParam(THREADS, numberParameters_, parameters_)].setIntValue(0);
     500    parameters_[whichParam(CBC_PARAM_INT_THREADS, numberParameters_, parameters_)].setIntValue(0);
    501501#endif
    502502    // Set up likely cut generators and defaults
    503     parameters_[whichParam(PREPROCESS, numberParameters_, parameters_)].setCurrentOption("sos");
    504     parameters_[whichParam(MIPOPTIONS, numberParameters_, parameters_)].setIntValue(1057);
    505     parameters_[whichParam(CUTPASSINTREE, numberParameters_, parameters_)].setIntValue(1);
    506     parameters_[whichParam(MOREMIPOPTIONS, numberParameters_, parameters_)].setIntValue(-1);
    507     parameters_[whichParam(MAXHOTITS, numberParameters_, parameters_)].setIntValue(100);
    508     parameters_[whichParam(CUTSSTRATEGY, numberParameters_, parameters_)].setCurrentOption("on");
    509     parameters_[whichParam(HEURISTICSTRATEGY, numberParameters_, parameters_)].setCurrentOption("on");
    510     parameters_[whichParam(NODESTRATEGY, numberParameters_, parameters_)].setCurrentOption("fewest");
    511     parameters_[whichParam(GOMORYCUTS, numberParameters_, parameters_)].setCurrentOption("ifmove");
    512     parameters_[whichParam(PROBINGCUTS, numberParameters_, parameters_)].setCurrentOption("ifmove");
    513     parameters_[whichParam(KNAPSACKCUTS, numberParameters_, parameters_)].setCurrentOption("ifmove");
     503    parameters_[whichParam(CBC_PARAM_STR_PREPROCESS, numberParameters_, parameters_)].setCurrentOption("sos");
     504    parameters_[whichParam(CBC_PARAM_INT_MIPOPTIONS, numberParameters_, parameters_)].setIntValue(1057);
     505    parameters_[whichParam(CBC_PARAM_INT_CUTPASSINTREE, numberParameters_, parameters_)].setIntValue(1);
     506    parameters_[whichParam(CBC_PARAM_INT_MOREMIPOPTIONS, numberParameters_, parameters_)].setIntValue(-1);
     507    parameters_[whichParam(CBC_PARAM_INT_MAXHOTITS, numberParameters_, parameters_)].setIntValue(100);
     508    parameters_[whichParam(CBC_PARAM_STR_CUTSSTRATEGY, numberParameters_, parameters_)].setCurrentOption("on");
     509    parameters_[whichParam(CBC_PARAM_STR_HEURISTICSTRATEGY, numberParameters_, parameters_)].setCurrentOption("on");
     510    parameters_[whichParam(CBC_PARAM_STR_NODESTRATEGY, numberParameters_, parameters_)].setCurrentOption("fewest");
     511    parameters_[whichParam(CBC_PARAM_STR_GOMORYCUTS, numberParameters_, parameters_)].setCurrentOption("ifmove");
     512    parameters_[whichParam(CBC_PARAM_STR_PROBINGCUTS, numberParameters_, parameters_)].setCurrentOption("ifmove");
     513    parameters_[whichParam(CBC_PARAM_STR_KNAPSACKCUTS, numberParameters_, parameters_)].setCurrentOption("ifmove");
    514514#ifdef ZERO_HALF_CUTS
    515     parameters_[whichParam(ZEROHALFCUTS, numberParameters_, parameters_)].setCurrentOption("off");
    516 #endif
    517     parameters_[whichParam(REDSPLITCUTS, numberParameters_, parameters_)].setCurrentOption("off");
    518     parameters_[whichParam(CLIQUECUTS, numberParameters_, parameters_)].setCurrentOption("ifmove");
    519     parameters_[whichParam(MIXEDCUTS, numberParameters_, parameters_)].setCurrentOption("ifmove");
    520     parameters_[whichParam(FLOWCUTS, numberParameters_, parameters_)].setCurrentOption("ifmove");
    521     parameters_[whichParam(TWOMIRCUTS, numberParameters_, parameters_)].setCurrentOption("root");
    522     parameters_[whichParam(LANDPCUTS, numberParameters_, parameters_)].setCurrentOption("off");
    523     parameters_[whichParam(RESIDCUTS, numberParameters_, parameters_)].setCurrentOption("off");
    524     parameters_[whichParam(ROUNDING, numberParameters_, parameters_)].setCurrentOption("on");
    525     parameters_[whichParam(FPUMP, numberParameters_, parameters_)].setCurrentOption("on");
    526     parameters_[whichParam(GREEDY, numberParameters_, parameters_)].setCurrentOption("on");
    527     parameters_[whichParam(COMBINE, numberParameters_, parameters_)].setCurrentOption("on");
    528     parameters_[whichParam(CROSSOVER2, numberParameters_, parameters_)].setCurrentOption("off");
    529     parameters_[whichParam(PIVOTANDCOMPLEMENT, numberParameters_, parameters_)].setCurrentOption("off");
    530     parameters_[whichParam(PIVOTANDFIX, numberParameters_, parameters_)].setCurrentOption("off");
    531     parameters_[whichParam(RANDROUND, numberParameters_, parameters_)].setCurrentOption("off");
    532     parameters_[whichParam(NAIVE, numberParameters_, parameters_)].setCurrentOption("off");
    533     parameters_[whichParam(RINS, numberParameters_, parameters_)].setCurrentOption("off");
    534     parameters_[whichParam(DINS, numberParameters_, parameters_)].setCurrentOption("off");
    535     parameters_[whichParam(RENS, numberParameters_, parameters_)].setCurrentOption("off");
    536     parameters_[whichParam(LOCALTREE, numberParameters_, parameters_)].setCurrentOption("off");
    537     parameters_[whichParam(COSTSTRATEGY, numberParameters_, parameters_)].setCurrentOption("off");
     515    parameters_[whichParam(CBC_PARAM_STR_ZEROHALFCUTS, numberParameters_, parameters_)].setCurrentOption("off");
     516#endif
     517    parameters_[whichParam(CBC_PARAM_STR_REDSPLITCUTS, numberParameters_, parameters_)].setCurrentOption("off");
     518    parameters_[whichParam(CBC_PARAM_STR_CLIQUECUTS, numberParameters_, parameters_)].setCurrentOption("ifmove");
     519    parameters_[whichParam(CBC_PARAM_STR_MIXEDCUTS, numberParameters_, parameters_)].setCurrentOption("ifmove");
     520    parameters_[whichParam(CBC_PARAM_STR_FLOWCUTS, numberParameters_, parameters_)].setCurrentOption("ifmove");
     521    parameters_[whichParam(CBC_PARAM_STR_TWOMIRCUTS, numberParameters_, parameters_)].setCurrentOption("root");
     522    parameters_[whichParam(CBC_PARAM_STR_LANDPCUTS, numberParameters_, parameters_)].setCurrentOption("off");
     523    parameters_[whichParam(CBC_PARAM_STR_RESIDCUTS, numberParameters_, parameters_)].setCurrentOption("off");
     524    parameters_[whichParam(CBC_PARAM_STR_ROUNDING, numberParameters_, parameters_)].setCurrentOption("on");
     525    parameters_[whichParam(CBC_PARAM_STR_FPUMP, numberParameters_, parameters_)].setCurrentOption("on");
     526    parameters_[whichParam(CBC_PARAM_STR_GREEDY, numberParameters_, parameters_)].setCurrentOption("on");
     527    parameters_[whichParam(CBC_PARAM_STR_COMBINE, numberParameters_, parameters_)].setCurrentOption("on");
     528    parameters_[whichParam(CBC_PARAM_STR_CROSSOVER2, numberParameters_, parameters_)].setCurrentOption("off");
     529    parameters_[whichParam(CBC_PARAM_STR_PIVOTANDCOMPLEMENT, numberParameters_, parameters_)].setCurrentOption("off");
     530    parameters_[whichParam(CBC_PARAM_STR_PIVOTANDFIX, numberParameters_, parameters_)].setCurrentOption("off");
     531    parameters_[whichParam(CBC_PARAM_STR_RANDROUND, numberParameters_, parameters_)].setCurrentOption("off");
     532    parameters_[whichParam(CBC_PARAM_STR_NAIVE, numberParameters_, parameters_)].setCurrentOption("off");
     533    parameters_[whichParam(CBC_PARAM_STR_RINS, numberParameters_, parameters_)].setCurrentOption("off");
     534    parameters_[whichParam(CBC_PARAM_STR_DINS, numberParameters_, parameters_)].setCurrentOption("off");
     535    parameters_[whichParam(CBC_PARAM_STR_RENS, numberParameters_, parameters_)].setCurrentOption("off");
     536    parameters_[whichParam(CBC_PARAM_STR_LOCALTREE, numberParameters_, parameters_)].setCurrentOption("off");
     537    parameters_[whichParam(CBC_PARAM_STR_COSTSTRATEGY, numberParameters_, parameters_)].setCurrentOption("off");
    538538    if (createSolver)
    539539        delete clpSolver;
     
    575575    lpSolver->messageHandler()->setPrefix(false);
    576576
    577     parameters_[whichParam(DUALBOUND, numberParameters_, parameters_)].setDoubleValue(lpSolver->dualBound());
    578     parameters_[whichParam(DUALTOLERANCE, numberParameters_, parameters_)].setDoubleValue(lpSolver->dualTolerance());
     577    parameters_[whichParam(CLP_PARAM_DBL_DUALBOUND, numberParameters_, parameters_)].setDoubleValue(lpSolver->dualBound());
     578    parameters_[whichParam(CLP_PARAM_DBL_DUALTOLERANCE, numberParameters_, parameters_)].setDoubleValue(lpSolver->dualTolerance());
    579579    /*
    580580      Why are we doing this? We read the log level from parameters_, set it into
     
    583583      parameters_!
    584584    */
    585     int iParam = whichParam(SOLVERLOGLEVEL, numberParameters_, parameters_);
     585    int iParam = whichParam(CLP_PARAM_INT_SOLVERLOGLEVEL, numberParameters_, parameters_);
    586586    int value = parameters_[iParam].intValue();
    587587    clpSolver->messageHandler()->setLogLevel(value) ;
    588588    lpSolver->setLogLevel(value);
    589     iParam = whichParam(LOGLEVEL, numberParameters_, parameters_);
     589    iParam = whichParam(CLP_PARAM_INT_LOGLEVEL, numberParameters_, parameters_);
    590590    value = parameters_[iParam].intValue();
    591591    model_.messageHandler()->setLogLevel(value);
    592     parameters_[whichParam(LOGLEVEL, numberParameters_, parameters_)].setIntValue(model_.logLevel());
    593     parameters_[whichParam(SOLVERLOGLEVEL, numberParameters_, parameters_)].setIntValue(lpSolver->logLevel());
    594     parameters_[whichParam(MAXFACTOR, numberParameters_, parameters_)].setIntValue(lpSolver->factorizationFrequency());
    595     parameters_[whichParam(MAXITERATION, numberParameters_, parameters_)].setIntValue(lpSolver->maximumIterations());
    596     parameters_[whichParam(PERTVALUE, numberParameters_, parameters_)].setIntValue(lpSolver->perturbation());
    597     parameters_[whichParam(PRIMALTOLERANCE, numberParameters_, parameters_)].setDoubleValue(lpSolver->primalTolerance());
    598     parameters_[whichParam(PRIMALWEIGHT, numberParameters_, parameters_)].setDoubleValue(lpSolver->infeasibilityCost());
    599     parameters_[whichParam(NUMBERBEFORE, numberParameters_, parameters_)].setIntValue(model_.numberBeforeTrust());
    600     parameters_[whichParam(MAXNODES, numberParameters_, parameters_)].setIntValue(model_.getMaximumNodes());
    601     parameters_[whichParam(STRONGBRANCHING, numberParameters_, parameters_)].setIntValue(model_.numberStrong());
    602     parameters_[whichParam(INFEASIBILITYWEIGHT, numberParameters_, parameters_)].setDoubleValue(model_.getDblParam(CbcModel::CbcInfeasibilityWeight));
    603     parameters_[whichParam(INTEGERTOLERANCE, numberParameters_, parameters_)].setDoubleValue(model_.getDblParam(CbcModel::CbcIntegerTolerance));
    604     parameters_[whichParam(INCREMENT, numberParameters_, parameters_)].setDoubleValue(model_.getDblParam(CbcModel::CbcCutoffIncrement));
     592    parameters_[whichParam(CLP_PARAM_INT_LOGLEVEL, numberParameters_, parameters_)].setIntValue(model_.logLevel());
     593    parameters_[whichParam(CLP_PARAM_INT_SOLVERLOGLEVEL, numberParameters_, parameters_)].setIntValue(lpSolver->logLevel());
     594    parameters_[whichParam(CLP_PARAM_INT_MAXFACTOR, numberParameters_, parameters_)].setIntValue(lpSolver->factorizationFrequency());
     595    parameters_[whichParam(CLP_PARAM_INT_MAXITERATION, numberParameters_, parameters_)].setIntValue(lpSolver->maximumIterations());
     596    parameters_[whichParam(CLP_PARAM_INT_PERTVALUE, numberParameters_, parameters_)].setIntValue(lpSolver->perturbation());
     597    parameters_[whichParam(CLP_PARAM_DBL_PRIMALTOLERANCE, numberParameters_, parameters_)].setDoubleValue(lpSolver->primalTolerance());
     598    parameters_[whichParam(CLP_PARAM_DBL_PRIMALWEIGHT, numberParameters_, parameters_)].setDoubleValue(lpSolver->infeasibilityCost());
     599    parameters_[whichParam(CBC_PARAM_INT_NUMBERBEFORE, numberParameters_, parameters_)].setIntValue(model_.numberBeforeTrust());
     600    parameters_[whichParam(CBC_PARAM_INT_MAXNODES, numberParameters_, parameters_)].setIntValue(model_.getMaximumNodes());
     601    parameters_[whichParam(CBC_PARAM_INT_STRONGBRANCHING, numberParameters_, parameters_)].setIntValue(model_.numberStrong());
     602    parameters_[whichParam(CBC_PARAM_DBL_INFEASIBILITYWEIGHT, numberParameters_, parameters_)].setDoubleValue(model_.getDblParam(CbcModel::CbcInfeasibilityWeight));
     603    parameters_[whichParam(CBC_PARAM_DBL_INTEGERTOLERANCE, numberParameters_, parameters_)].setDoubleValue(model_.getDblParam(CbcModel::CbcIntegerTolerance));
     604    parameters_[whichParam(CBC_PARAM_DBL_INCREMENT, numberParameters_, parameters_)].setDoubleValue(model_.getDblParam(CbcModel::CbcCutoffIncrement));
    605605}
    606606// Add user function
     
    32143214    int doSprint = -1;
    32153215    int testOsiParameters = -1;
    3216     parameters[whichParam(BASISIN, numberParameters, parameters)].setStringValue(importBasisFile);
    3217     parameters[whichParam(PRIORITYIN, numberParameters, parameters)].setStringValue(importPriorityFile);
    3218     parameters[whichParam(BASISOUT, numberParameters, parameters)].setStringValue(exportBasisFile);
    3219     parameters[whichParam(DEBUG, numberParameters, parameters)].setStringValue(debugFile);
    3220     parameters[whichParam(PRINTMASK, numberParameters, parameters)].setStringValue(printMask);
    3221     parameters[whichParam(DIRECTORY, numberParameters, parameters)].setStringValue(directory);
    3222     parameters[whichParam(DIRSAMPLE, numberParameters, parameters)].setStringValue(dirSample);
    3223     parameters[whichParam(DIRNETLIB, numberParameters, parameters)].setStringValue(dirNetlib);
    3224     parameters[whichParam(DIRMIPLIB, numberParameters, parameters)].setStringValue(dirMiplib);
    3225     parameters[whichParam(DUALBOUND, numberParameters, parameters)].setDoubleValue(lpSolver->dualBound());
    3226     parameters[whichParam(DUALTOLERANCE, numberParameters, parameters)].setDoubleValue(lpSolver->dualTolerance());
    3227     parameters[whichParam(EXPORT, numberParameters, parameters)].setStringValue(exportFile);
    3228     parameters[whichParam(IDIOT, numberParameters, parameters)].setIntValue(doIdiot);
    3229     parameters[whichParam(IMPORT, numberParameters, parameters)].setStringValue(importFile);
    3230     parameters[whichParam(PRESOLVETOLERANCE, numberParameters, parameters)].setDoubleValue(1.0e-8);
    3231     int slog = whichParam(SOLVERLOGLEVEL, numberParameters, parameters);
    3232     int log = whichParam(LOGLEVEL, numberParameters, parameters);
     3216    parameters[whichParam(CLP_PARAM_ACTION_BASISIN, numberParameters, parameters)].setStringValue(importBasisFile);
     3217    parameters[whichParam(CBC_PARAM_ACTION_PRIORITYIN, numberParameters, parameters)].setStringValue(importPriorityFile);
     3218    parameters[whichParam(CLP_PARAM_ACTION_BASISOUT, numberParameters, parameters)].setStringValue(exportBasisFile);
     3219    parameters[whichParam(CLP_PARAM_ACTION_DEBUG, numberParameters, parameters)].setStringValue(debugFile);
     3220    parameters[whichParam(CLP_PARAM_ACTION_PRINTMASK, numberParameters, parameters)].setStringValue(printMask);
     3221    parameters[whichParam(CLP_PARAM_ACTION_DIRECTORY, numberParameters, parameters)].setStringValue(directory);
     3222    parameters[whichParam(CLP_PARAM_ACTION_DIRSAMPLE, numberParameters, parameters)].setStringValue(dirSample);
     3223    parameters[whichParam(CLP_PARAM_ACTION_DIRNETLIB, numberParameters, parameters)].setStringValue(dirNetlib);
     3224    parameters[whichParam(CBC_PARAM_ACTION_DIRMIPLIB, numberParameters, parameters)].setStringValue(dirMiplib);
     3225    parameters[whichParam(CLP_PARAM_DBL_DUALBOUND, numberParameters, parameters)].setDoubleValue(lpSolver->dualBound());
     3226    parameters[whichParam(CLP_PARAM_DBL_DUALTOLERANCE, numberParameters, parameters)].setDoubleValue(lpSolver->dualTolerance());
     3227    parameters[whichParam(CLP_PARAM_ACTION_EXPORT, numberParameters, parameters)].setStringValue(exportFile);
     3228    parameters[whichParam(CLP_PARAM_INT_IDIOT, numberParameters, parameters)].setIntValue(doIdiot);
     3229    parameters[whichParam(CLP_PARAM_ACTION_IMPORT, numberParameters, parameters)].setStringValue(importFile);
     3230    parameters[whichParam(CLP_PARAM_DBL_PRESOLVETOLERANCE, numberParameters, parameters)].setDoubleValue(1.0e-8);
     3231    int slog = whichParam(CLP_PARAM_INT_SOLVERLOGLEVEL, numberParameters, parameters);
     3232    int log = whichParam(CLP_PARAM_INT_LOGLEVEL, numberParameters, parameters);
    32333233    parameters[slog].setIntValue(1);
    32343234    clpSolver->messageHandler()->setLogLevel(1) ;
     
    32363236    lpSolver->setLogLevel(1);
    32373237    parameters[log].setIntValue(1);
    3238     parameters[whichParam(MAXFACTOR, numberParameters, parameters)].setIntValue(lpSolver->factorizationFrequency());
    3239     parameters[whichParam(MAXITERATION, numberParameters, parameters)].setIntValue(lpSolver->maximumIterations());
    3240     parameters[whichParam(OUTPUTFORMAT, numberParameters, parameters)].setIntValue(outputFormat);
    3241     parameters[whichParam(PRESOLVEPASS, numberParameters, parameters)].setIntValue(preSolve);
    3242     parameters[whichParam(PERTVALUE, numberParameters, parameters)].setIntValue(lpSolver->perturbation());
    3243     parameters[whichParam(PRIMALTOLERANCE, numberParameters, parameters)].setDoubleValue(lpSolver->primalTolerance());
    3244     parameters[whichParam(PRIMALWEIGHT, numberParameters, parameters)].setDoubleValue(lpSolver->infeasibilityCost());
    3245     parameters[whichParam(RESTORE, numberParameters, parameters)].setStringValue(restoreFile);
    3246     parameters[whichParam(SAVE, numberParameters, parameters)].setStringValue(saveFile);
    3247     //parameters[whichParam(TIMELIMIT,numberParameters,parameters)].setDoubleValue(1.0e8);
    3248     parameters[whichParam(TIMELIMIT_BAB, numberParameters, parameters)].setDoubleValue(1.0e8);
    3249     parameters[whichParam(SOLUTION, numberParameters, parameters)].setStringValue(solutionFile);
    3250     parameters[whichParam(SAVESOL, numberParameters, parameters)].setStringValue(solutionSaveFile);
    3251     parameters[whichParam(SPRINT, numberParameters, parameters)].setIntValue(doSprint);
    3252     parameters[whichParam(SUBSTITUTION, numberParameters, parameters)].setIntValue(substitution);
    3253     parameters[whichParam(DUALIZE, numberParameters, parameters)].setIntValue(dualize);
     3238    parameters[whichParam(CLP_PARAM_INT_MAXFACTOR, numberParameters, parameters)].setIntValue(lpSolver->factorizationFrequency());
     3239    parameters[whichParam(CLP_PARAM_INT_MAXITERATION, numberParameters, parameters)].setIntValue(lpSolver->maximumIterations());
     3240    parameters[whichParam(CLP_PARAM_INT_OUTPUTFORMAT, numberParameters, parameters)].setIntValue(outputFormat);
     3241    parameters[whichParam(CLP_PARAM_INT_PRESOLVEPASS, numberParameters, parameters)].setIntValue(preSolve);
     3242    parameters[whichParam(CLP_PARAM_INT_PERTVALUE, numberParameters, parameters)].setIntValue(lpSolver->perturbation());
     3243    parameters[whichParam(CLP_PARAM_DBL_PRIMALTOLERANCE, numberParameters, parameters)].setDoubleValue(lpSolver->primalTolerance());
     3244    parameters[whichParam(CLP_PARAM_DBL_PRIMALWEIGHT, numberParameters, parameters)].setDoubleValue(lpSolver->infeasibilityCost());
     3245    parameters[whichParam(CLP_PARAM_ACTION_RESTORE, numberParameters, parameters)].setStringValue(restoreFile);
     3246    parameters[whichParam(CLP_PARAM_ACTION_SAVE, numberParameters, parameters)].setStringValue(saveFile);
     3247    //parameters[whichParam(CLP_PARAM_DBL_TIMELIMIT,numberParameters,parameters)].setDoubleValue(1.0e8);
     3248    parameters[whichParam(CBC_PARAM_DBL_TIMELIMIT_BAB, numberParameters, parameters)].setDoubleValue(1.0e8);
     3249    parameters[whichParam(CLP_PARAM_ACTION_SOLUTION, numberParameters, parameters)].setStringValue(solutionFile);
     3250    parameters[whichParam(CLP_PARAM_ACTION_SAVESOL, numberParameters, parameters)].setStringValue(solutionSaveFile);
     3251    parameters[whichParam(CLP_PARAM_INT_SPRINT, numberParameters, parameters)].setIntValue(doSprint);
     3252    parameters[whichParam(CLP_PARAM_INT_SUBSTITUTION, numberParameters, parameters)].setIntValue(substitution);
     3253    parameters[whichParam(CLP_PARAM_INT_DUALIZE, numberParameters, parameters)].setIntValue(dualize);
    32543254    model.setNumberBeforeTrust(10);
    3255     parameters[whichParam(NUMBERBEFORE, numberParameters, parameters)].setIntValue(5);
    3256     parameters[whichParam(MAXNODES, numberParameters, parameters)].setIntValue(model.getMaximumNodes());
     3255    parameters[whichParam(CBC_PARAM_INT_NUMBERBEFORE, numberParameters, parameters)].setIntValue(5);
     3256    parameters[whichParam(CBC_PARAM_INT_MAXNODES, numberParameters, parameters)].setIntValue(model.getMaximumNodes());
    32573257    model.setNumberStrong(5);
    3258     parameters[whichParam(STRONGBRANCHING, numberParameters, parameters)].setIntValue(model.numberStrong());
    3259     parameters[whichParam(INFEASIBILITYWEIGHT, numberParameters, parameters)].setDoubleValue(model.getDblParam(CbcModel::CbcInfeasibilityWeight));
    3260     parameters[whichParam(INTEGERTOLERANCE, numberParameters, parameters)].setDoubleValue(model.getDblParam(CbcModel::CbcIntegerTolerance));
    3261     parameters[whichParam(INCREMENT, numberParameters, parameters)].setDoubleValue(model.getDblParam(CbcModel::CbcCutoffIncrement));
    3262     parameters[whichParam(TESTOSI, numberParameters, parameters)].setIntValue(testOsiParameters);
    3263     parameters[whichParam(FPUMPTUNE, numberParameters, parameters)].setIntValue(1003);
     3258    parameters[whichParam(CBC_PARAM_INT_STRONGBRANCHING, numberParameters, parameters)].setIntValue(model.numberStrong());
     3259    parameters[whichParam(CBC_PARAM_DBL_INFEASIBILITYWEIGHT, numberParameters, parameters)].setDoubleValue(model.getDblParam(CbcModel::CbcInfeasibilityWeight));
     3260    parameters[whichParam(CBC_PARAM_DBL_INTEGERTOLERANCE, numberParameters, parameters)].setDoubleValue(model.getDblParam(CbcModel::CbcIntegerTolerance));
     3261    parameters[whichParam(CBC_PARAM_DBL_INCREMENT, numberParameters, parameters)].setDoubleValue(model.getDblParam(CbcModel::CbcCutoffIncrement));
     3262    parameters[whichParam(CBC_PARAM_INT_TESTOSI, numberParameters, parameters)].setIntValue(testOsiParameters);
     3263    parameters[whichParam(CBC_PARAM_INT_FPUMPTUNE, numberParameters, parameters)].setIntValue(1003);
    32643264    initialPumpTune = 1003;
    32653265#ifdef CBC_THREAD
    3266     parameters[whichParam(THREADS, numberParameters, parameters)].setIntValue(0);
     3266    parameters[whichParam(CBC_PARAM_INT_THREADS, numberParameters, parameters)].setIntValue(0);
    32673267#endif
    32683268    // Set up likely cut generators and defaults
    3269     parameters[whichParam(PREPROCESS, numberParameters, parameters)].setCurrentOption("sos");
    3270     parameters[whichParam(MIPOPTIONS, numberParameters, parameters)].setIntValue(1057);
    3271     parameters[whichParam(CUTPASSINTREE, numberParameters, parameters)].setIntValue(1);
    3272     parameters[whichParam(MOREMIPOPTIONS, numberParameters, parameters)].setIntValue(-1);
    3273     parameters[whichParam(MAXHOTITS, numberParameters, parameters)].setIntValue(100);
    3274     parameters[whichParam(CUTSSTRATEGY, numberParameters, parameters)].setCurrentOption("on");
    3275     parameters[whichParam(HEURISTICSTRATEGY, numberParameters, parameters)].setCurrentOption("on");
    3276     parameters[whichParam(NODESTRATEGY, numberParameters, parameters)].setCurrentOption("fewest");
    3277     parameters[whichParam(GOMORYCUTS, numberParameters, parameters)].setCurrentOption("ifmove");
    3278     parameters[whichParam(PROBINGCUTS, numberParameters, parameters)].setCurrentOption("ifmove");
    3279     parameters[whichParam(KNAPSACKCUTS, numberParameters, parameters)].setCurrentOption("ifmove");
     3269    parameters[whichParam(CBC_PARAM_STR_PREPROCESS, numberParameters, parameters)].setCurrentOption("sos");
     3270    parameters[whichParam(CBC_PARAM_INT_MIPOPTIONS, numberParameters, parameters)].setIntValue(1057);
     3271    parameters[whichParam(CBC_PARAM_INT_CUTPASSINTREE, numberParameters, parameters)].setIntValue(1);
     3272    parameters[whichParam(CBC_PARAM_INT_MOREMIPOPTIONS, numberParameters, parameters)].setIntValue(-1);
     3273    parameters[whichParam(CBC_PARAM_INT_MAXHOTITS, numberParameters, parameters)].setIntValue(100);
     3274    parameters[whichParam(CBC_PARAM_STR_CUTSSTRATEGY, numberParameters, parameters)].setCurrentOption("on");
     3275    parameters[whichParam(CBC_PARAM_STR_HEURISTICSTRATEGY, numberParameters, parameters)].setCurrentOption("on");
     3276    parameters[whichParam(CBC_PARAM_STR_NODESTRATEGY, numberParameters, parameters)].setCurrentOption("fewest");
     3277    parameters[whichParam(CBC_PARAM_STR_GOMORYCUTS, numberParameters, parameters)].setCurrentOption("ifmove");
     3278    parameters[whichParam(CBC_PARAM_STR_PROBINGCUTS, numberParameters, parameters)].setCurrentOption("ifmove");
     3279    parameters[whichParam(CBC_PARAM_STR_KNAPSACKCUTS, numberParameters, parameters)].setCurrentOption("ifmove");
    32803280#ifdef ZERO_HALF_CUTS
    3281     parameters[whichParam(ZEROHALFCUTS, numberParameters, parameters)].setCurrentOption("off");
    3282 #endif
    3283     parameters[whichParam(REDSPLITCUTS, numberParameters, parameters)].setCurrentOption("off");
    3284     parameters[whichParam(CLIQUECUTS, numberParameters, parameters)].setCurrentOption("ifmove");
    3285     parameters[whichParam(MIXEDCUTS, numberParameters, parameters)].setCurrentOption("ifmove");
    3286     parameters[whichParam(FLOWCUTS, numberParameters, parameters)].setCurrentOption("ifmove");
    3287     parameters[whichParam(TWOMIRCUTS, numberParameters, parameters)].setCurrentOption("root");
    3288     parameters[whichParam(LANDPCUTS, numberParameters, parameters)].setCurrentOption("off");
    3289     parameters[whichParam(RESIDCUTS, numberParameters, parameters)].setCurrentOption("off");
    3290     parameters[whichParam(ROUNDING, numberParameters, parameters)].setCurrentOption("on");
    3291     parameters[whichParam(FPUMP, numberParameters, parameters)].setCurrentOption("on");
    3292     parameters[whichParam(GREEDY, numberParameters, parameters)].setCurrentOption("on");
    3293     parameters[whichParam(COMBINE, numberParameters, parameters)].setCurrentOption("on");
    3294     parameters[whichParam(CROSSOVER2, numberParameters, parameters)].setCurrentOption("off");
    3295     parameters[whichParam(PIVOTANDCOMPLEMENT, numberParameters, parameters)].setCurrentOption("off");
    3296     parameters[whichParam(PIVOTANDFIX, numberParameters, parameters)].setCurrentOption("off");
    3297     parameters[whichParam(RANDROUND, numberParameters, parameters)].setCurrentOption("off");
    3298     parameters[whichParam(NAIVE, numberParameters, parameters)].setCurrentOption("off");
    3299     parameters[whichParam(RINS, numberParameters, parameters)].setCurrentOption("off");
    3300     parameters[whichParam(DINS, numberParameters, parameters)].setCurrentOption("off");
    3301     parameters[whichParam(RENS, numberParameters, parameters)].setCurrentOption("off");
    3302     parameters[whichParam(LOCALTREE, numberParameters, parameters)].setCurrentOption("off");
    3303     parameters[whichParam(COSTSTRATEGY, numberParameters, parameters)].setCurrentOption("off");
     3281    parameters[whichParam(CBC_PARAM_STR_ZEROHALFCUTS, numberParameters, parameters)].setCurrentOption("off");
     3282#endif
     3283    parameters[whichParam(CBC_PARAM_STR_REDSPLITCUTS, numberParameters, parameters)].setCurrentOption("off");
     3284    parameters[whichParam(CBC_PARAM_STR_CLIQUECUTS, numberParameters, parameters)].setCurrentOption("ifmove");
     3285    parameters[whichParam(CBC_PARAM_STR_MIXEDCUTS, numberParameters, parameters)].setCurrentOption("ifmove");
     3286    parameters[whichParam(CBC_PARAM_STR_FLOWCUTS, numberParameters, parameters)].setCurrentOption("ifmove");
     3287    parameters[whichParam(CBC_PARAM_STR_TWOMIRCUTS, numberParameters, parameters)].setCurrentOption("root");
     3288    parameters[whichParam(CBC_PARAM_STR_LANDPCUTS, numberParameters, parameters)].setCurrentOption("off");
     3289    parameters[whichParam(CBC_PARAM_STR_RESIDCUTS, numberParameters, parameters)].setCurrentOption("off");
     3290    parameters[whichParam(CBC_PARAM_STR_ROUNDING, numberParameters, parameters)].setCurrentOption("on");
     3291    parameters[whichParam(CBC_PARAM_STR_FPUMP, numberParameters, parameters)].setCurrentOption("on");
     3292    parameters[whichParam(CBC_PARAM_STR_GREEDY, numberParameters, parameters)].setCurrentOption("on");
     3293    parameters[whichParam(CBC_PARAM_STR_COMBINE, numberParameters, parameters)].setCurrentOption("on");
     3294    parameters[whichParam(CBC_PARAM_STR_CROSSOVER2, numberParameters, parameters)].setCurrentOption("off");
     3295    parameters[whichParam(CBC_PARAM_STR_PIVOTANDCOMPLEMENT, numberParameters, parameters)].setCurrentOption("off");
     3296    parameters[whichParam(CBC_PARAM_STR_PIVOTANDFIX, numberParameters, parameters)].setCurrentOption("off");
     3297    parameters[whichParam(CBC_PARAM_STR_RANDROUND, numberParameters, parameters)].setCurrentOption("off");
     3298    parameters[whichParam(CBC_PARAM_STR_NAIVE, numberParameters, parameters)].setCurrentOption("off");
     3299    parameters[whichParam(CBC_PARAM_STR_RINS, numberParameters, parameters)].setCurrentOption("off");
     3300    parameters[whichParam(CBC_PARAM_STR_DINS, numberParameters, parameters)].setCurrentOption("off");
     3301    parameters[whichParam(CBC_PARAM_STR_RENS, numberParameters, parameters)].setCurrentOption("off");
     3302    parameters[whichParam(CBC_PARAM_STR_LOCALTREE, numberParameters, parameters)].setCurrentOption("off");
     3303    parameters[whichParam(CBC_PARAM_STR_COSTSTRATEGY, numberParameters, parameters)].setCurrentOption("off");
    33043304}
    33053305#endif
     
    33253325    //generalMessageHandler->setPrefix(false);
    33263326    bool anyToDo = false;
    3327     int logLevel = parameters_[whichParam(LOGLEVEL, numberParameters_, parameters_)].intValue();
    3328     int useFpump = parameters_[whichParam(FPUMP, numberParameters_, parameters_)].currentOptionAsInteger();
    3329     int useRounding = parameters_[whichParam(ROUNDING, numberParameters_, parameters_)].currentOptionAsInteger();
    3330     int useGreedy = parameters_[whichParam(GREEDY, numberParameters_, parameters_)].currentOptionAsInteger();
    3331     int useCombine = parameters_[whichParam(COMBINE, numberParameters_, parameters_)].currentOptionAsInteger();
    3332     int useCrossover = parameters_[whichParam(CROSSOVER2, numberParameters_, parameters_)].currentOptionAsInteger();
    3333     //int usePivotC = parameters_[whichParam(PIVOTANDCOMPLEMENT, numberParameters_, parameters_)].currentOptionAsInteger();
    3334     int usePivotF = parameters_[whichParam(PIVOTANDFIX, numberParameters_, parameters_)].currentOptionAsInteger();
    3335     int useRand = parameters_[whichParam(RANDROUND, numberParameters_, parameters_)].currentOptionAsInteger();
    3336     int useRINS = parameters_[whichParam(RINS, numberParameters_, parameters_)].currentOptionAsInteger();
    3337     int useRENS = parameters_[whichParam(RENS, numberParameters_, parameters_)].currentOptionAsInteger();
    3338     int useDINS = parameters_[whichParam(DINS, numberParameters_, parameters_)].currentOptionAsInteger();
    3339     int useDIVING2 = parameters_[whichParam(DIVINGS, numberParameters_, parameters_)].currentOptionAsInteger();
    3340     int useNaive = parameters_[whichParam(NAIVE, numberParameters_, parameters_)].currentOptionAsInteger();
     3327    int logLevel = parameters_[whichParam(CLP_PARAM_INT_LOGLEVEL, numberParameters_, parameters_)].intValue();
     3328    int useFpump = parameters_[whichParam(CBC_PARAM_STR_FPUMP, numberParameters_, parameters_)].currentOptionAsInteger();
     3329    int useRounding = parameters_[whichParam(CBC_PARAM_STR_ROUNDING, numberParameters_, parameters_)].currentOptionAsInteger();
     3330    int useGreedy = parameters_[whichParam(CBC_PARAM_STR_GREEDY, numberParameters_, parameters_)].currentOptionAsInteger();
     3331    int useCombine = parameters_[whichParam(CBC_PARAM_STR_COMBINE, numberParameters_, parameters_)].currentOptionAsInteger();
     3332    int useCrossover = parameters_[whichParam(CBC_PARAM_STR_CROSSOVER2, numberParameters_, parameters_)].currentOptionAsInteger();
     3333    //int usePivotC = parameters_[whichParam(CBC_PARAM_STR_PIVOTANDCOMPLEMENT, numberParameters_, parameters_)].currentOptionAsInteger();
     3334    int usePivotF = parameters_[whichParam(CBC_PARAM_STR_PIVOTANDFIX, numberParameters_, parameters_)].currentOptionAsInteger();
     3335    int useRand = parameters_[whichParam(CBC_PARAM_STR_RANDROUND, numberParameters_, parameters_)].currentOptionAsInteger();
     3336    int useRINS = parameters_[whichParam(CBC_PARAM_STR_RINS, numberParameters_, parameters_)].currentOptionAsInteger();
     3337    int useRENS = parameters_[whichParam(CBC_PARAM_STR_RENS, numberParameters_, parameters_)].currentOptionAsInteger();
     3338    int useDINS = parameters_[whichParam(CBC_PARAM_STR_DINS, numberParameters_, parameters_)].currentOptionAsInteger();
     3339    int useDIVING2 = parameters_[whichParam(CBC_PARAM_STR_DIVINGS, numberParameters_, parameters_)].currentOptionAsInteger();
     3340    int useNaive = parameters_[whichParam(CBC_PARAM_STR_NAIVE, numberParameters_, parameters_)].currentOptionAsInteger();
    33413341    int kType = (type < 10) ? type : 1;
    33423342    assert (kType == 1 || kType == 2);
     
    33453345        anyToDo = true;
    33463346        CbcHeuristicFPump heuristic4(*model);
    3347         double dextra3 = parameters_[whichParam(SMALLBAB, numberParameters_, parameters_)].doubleValue();
     3347        double dextra3 = parameters_[whichParam(CBC_PARAM_DBL_SMALLBAB, numberParameters_, parameters_)].doubleValue();
    33483348        heuristic4.setFractionSmall(dextra3);
    3349         double dextra1 = parameters_[whichParam(ARTIFICIALCOST, numberParameters_, parameters_)].doubleValue();
     3349        double dextra1 = parameters_[whichParam(CBC_PARAM_DBL_ARTIFICIALCOST, numberParameters_, parameters_)].doubleValue();
    33503350        if (dextra1)
    33513351            heuristic4.setArtificialCost(dextra1);
    3352         heuristic4.setMaximumPasses(parameters_[whichParam(FPUMPITS, numberParameters_, parameters_)].intValue());
    3353         if (parameters_[whichParam(FPUMPITS, numberParameters_, parameters_)].intValue() == 21)
     3352        heuristic4.setMaximumPasses(parameters_[whichParam(CBC_PARAM_INT_FPUMPITS, numberParameters_, parameters_)].intValue());
     3353        if (parameters_[whichParam(CBC_PARAM_INT_FPUMPITS, numberParameters_, parameters_)].intValue() == 21)
    33543354            heuristic4.setIterationRatio(1.0);
    3355         int pumpTune = parameters_[whichParam(FPUMPTUNE, numberParameters_, parameters_)].intValue();
    3356         int pumpTune2 = parameters_[whichParam(FPUMPTUNE2, numberParameters_, parameters_)].intValue();
     3355        int pumpTune = parameters_[whichParam(CBC_PARAM_INT_FPUMPTUNE, numberParameters_, parameters_)].intValue();
     3356        int pumpTune2 = parameters_[whichParam(CBC_PARAM_INT_FPUMPTUNE2, numberParameters_, parameters_)].intValue();
    33573357        if (pumpTune > 0) {
    33583358            bool printStuff = (pumpTune != initialPumpTune || logLevel > 1 || pumpTune2 > 0)
     
    34053405                model->solver()->getDblParam(OsiDualObjectiveLimit, cutoff);
    34063406                cutoff = CoinMin(cutoff, value + 0.05 * fabs(value) * c);
    3407                 double fakeCutoff = parameters_[whichParam(FAKECUTOFF, numberParameters_, parameters_)].doubleValue();
     3407                double fakeCutoff = parameters_[whichParam(CBC_PARAM_DBL_FAKECUTOFF, numberParameters_, parameters_)].doubleValue();
    34083408                if (fakeCutoff)
    34093409                    cutoff = fakeCutoff;
     
    34623462                //double increment = (0.01*i+0.005)*(fabs(value)+1.0e-12);
    34633463                double increment = 0.0;
    3464                 double fakeIncrement = parameters_[whichParam(FAKEINCREMENT, numberParameters_, parameters_)].doubleValue();
     3464                double fakeIncrement = parameters_[whichParam(CBC_PARAM_DBL_FAKEINCREMENT, numberParameters_, parameters_)].doubleValue();
    34653465                if (fakeIncrement)
    34663466                    increment = fakeIncrement;
     
    35603560    {
    35613561        int useD;
    3562         useD = parameters_[whichParam(DIVINGV, numberParameters_, parameters_)].currentOptionAsInteger();
     3562        useD = parameters_[whichParam(CBC_PARAM_STR_DIVINGV, numberParameters_, parameters_)].currentOptionAsInteger();
    35633563        useDIVING |= 1 * ((useD >= kType) ? 1 : 0);
    3564         useD = parameters_[whichParam(DIVINGG, numberParameters_, parameters_)].currentOptionAsInteger();
     3564        useD = parameters_[whichParam(CBC_PARAM_STR_DIVINGG, numberParameters_, parameters_)].currentOptionAsInteger();
    35653565        useDIVING |= 2 * ((useD >= kType) ? 1 : 0);
    3566         useD = parameters_[whichParam(DIVINGF, numberParameters_, parameters_)].currentOptionAsInteger();
     3566        useD = parameters_[whichParam(CBC_PARAM_STR_DIVINGF, numberParameters_, parameters_)].currentOptionAsInteger();
    35673567        useDIVING |= 4 * ((useD >= kType) ? 1 : 0);
    3568         useD = parameters_[whichParam(DIVINGC, numberParameters_, parameters_)].currentOptionAsInteger();
     3568        useD = parameters_[whichParam(CBC_PARAM_STR_DIVINGC, numberParameters_, parameters_)].currentOptionAsInteger();
    35693569        useDIVING |= 8 * ((useD >= kType) ? 1 : 0);
    3570         useD = parameters_[whichParam(DIVINGL, numberParameters_, parameters_)].currentOptionAsInteger();
     3570        useD = parameters_[whichParam(CBC_PARAM_STR_DIVINGL, numberParameters_, parameters_)].currentOptionAsInteger();
    35713571        useDIVING |= 16 * ((useD >= kType) ? 1 : 0);
    3572         useD = parameters_[whichParam(DIVINGP, numberParameters_, parameters_)].currentOptionAsInteger();
     3572        useD = parameters_[whichParam(CBC_PARAM_STR_DIVINGP, numberParameters_, parameters_)].currentOptionAsInteger();
    35733573        useDIVING |= 32 * ((useD >= kType) ? 1 : 0);
    35743574    }
    35753575    if (useDIVING2 >= kType && useDIVING2 <= kType + 1) {
    3576         int diveOptions = parameters_[whichParam(DIVEOPT, numberParameters_, parameters_)].intValue();
     3576        int diveOptions = parameters_[whichParam(CBC_PARAM_INT_DIVEOPT, numberParameters_, parameters_)].intValue();
    35773577        if (diveOptions < 0 || diveOptions > 10)
    35783578            diveOptions = 2;
     
    36053605
    36063606    if (useDIVING > 0) {
    3607         int diveOptions2 = parameters_[whichParam(DIVEOPT, numberParameters_, parameters_)].intValue();
     3607        int diveOptions2 = parameters_[whichParam(CBC_PARAM_INT_DIVEOPT, numberParameters_, parameters_)].intValue();
    36083608        int diveOptions;
    36093609        if (diveOptions2 > 99) {
     
    37213721        anyToDo = true;
    37223722    }
    3723     int heurSwitches = parameters_[whichParam(HOPTIONS, numberParameters_, parameters_)].intValue() % 100;
     3723    int heurSwitches = parameters_[whichParam(CBC_PARAM_INT_HOPTIONS, numberParameters_, parameters_)].intValue() % 100;
    37243724    if (heurSwitches) {
    37253725        for (int iHeur = 0; iHeur < model->numberHeuristics(); iHeur++) {
     
    37453745        bool cleanModel = !model2.numberIntegers() && !model2.numberObjects();
    37463746        model2.findIntegers(false);
    3747         int heurOptions = (parameters_[whichParam(HOPTIONS, numberParameters_, parameters_)].intValue() / 100) % 100;
     3747        int heurOptions = (parameters_[whichParam(CBC_PARAM_INT_HOPTIONS, numberParameters_, parameters_)].intValue() / 100) % 100;
    37483748        if (heurOptions == 0 || heurOptions == 2) {
    37493749            model2.doHeuristicsAtRoot(1);
     
    40324032        if (originalCoinModel_)
    40334033            complicatedInteger = 1;
    4034         testOsiParameters = intValue(TESTOSI);
     4034        testOsiParameters = intValue(CBC_PARAM_INT_TESTOSI);
    40354035        if (noPrinting_) {
    40364036            model_.messageHandler()->setLogLevel(0);
     
    40534053                            noPrinting_ = false;
    40544054                            info.logLevel = atoi(equals + 1);
    4055                             int log = whichParam(LOGLEVEL, numberParameters_, parameters_);
     4055                            int log = whichParam(CLP_PARAM_INT_LOGLEVEL, numberParameters_, parameters_);
    40564056                            parameters_[log].setIntValue(info.logLevel);
    40574057                            // mark so won't be overWritten
     
    41384138                    // need some relative granularity
    41394139                    si->setDefaultBound(100.0);
    4140                     double dextra3 = parameters_[whichParam(DEXTRA3, numberParameters_, parameters_)].doubleValue();
     4140                    double dextra3 = parameters_[whichParam(CBC_PARAM_DBL_DEXTRA3, numberParameters_, parameters_)].doubleValue();
    41414141                    if (dextra3)
    41424142                        si->setDefaultMeshSize(dextra3);
     
    41454145                    si->setBiLinearPriority(10000);
    41464146                    CoinModel * model2 = reinterpret_cast<CoinModel *> (coinModel);
    4147                     int logLevel = parameters_[whichParam(LOGLEVEL, numberParameters_, parameters_)].intValue();
     4147                    int logLevel = parameters_[whichParam(CLP_PARAM_INT_LOGLEVEL, numberParameters_, parameters_)].intValue();
    41484148                    si->load(*model2, true, logLevel);
    41494149                    // redo
     
    41534153                    clpSolver->messageHandler()->setLogLevel(0) ;
    41544154                    testOsiParameters = 0;
    4155                     parameters_[whichParam(TESTOSI, numberParameters_, parameters_)].setIntValue(0);
     4155                    parameters_[whichParam(CBC_PARAM_INT_TESTOSI, numberParameters_, parameters_)].setIntValue(0);
    41564156                    complicatedInteger = 1;
    41574157                    if (info.cut) {
     
    42844284        std::string solutionFile = "stdout";
    42854285        std::string solutionSaveFile = "solution.file";
    4286         int slog = whichParam(SOLVERLOGLEVEL, numberParameters_, parameters_);
    4287         int log = whichParam(LOGLEVEL, numberParameters_, parameters_);
     4286        int slog = whichParam(CLP_PARAM_INT_SOLVERLOGLEVEL, numberParameters_, parameters_);
     4287        int log = whichParam(CLP_PARAM_INT_LOGLEVEL, numberParameters_, parameters_);
    42884288#ifndef CBC_OTHER_SOLVER
    42894289        double normalIncrement = model_.getCutoffIncrement();;
     
    44114411#endif
    44124412            int iParam;
    4413             iParam = whichParam(DIVEOPT, numberParameters_, parameters_);
     4413            iParam = whichParam(CBC_PARAM_INT_DIVEOPT, numberParameters_, parameters_);
    44144414            parameters_[iParam].setIntValue(3);
    4415             iParam = whichParam(FPUMPITS, numberParameters_, parameters_);
     4415            iParam = whichParam(CBC_PARAM_INT_FPUMPITS, numberParameters_, parameters_);
    44164416            parameters_[iParam].setIntValue(30);
    4417             iParam = whichParam(FPUMPTUNE, numberParameters_, parameters_);
     4417            iParam = whichParam(CBC_PARAM_INT_FPUMPTUNE, numberParameters_, parameters_);
    44184418            parameters_[iParam].setIntValue(1005043);
    44194419            initialPumpTune = 1005043;
    4420             iParam = whichParam(PROCESSTUNE, numberParameters_, parameters_);
     4420            iParam = whichParam(CLP_PARAM_INT_PROCESSTUNE, numberParameters_, parameters_);
    44214421            parameters_[iParam].setIntValue(6);
    44224422            tunePreProcess = 6;
    4423             iParam = whichParam(DIVINGC, numberParameters_, parameters_);
     4423            iParam = whichParam(CBC_PARAM_STR_DIVINGC, numberParameters_, parameters_);
    44244424            parameters_[iParam].setCurrentOption("on");
    4425             iParam = whichParam(RINS, numberParameters_, parameters_);
     4425            iParam = whichParam(CBC_PARAM_STR_RINS, numberParameters_, parameters_);
    44264426            parameters_[iParam].setCurrentOption("on");
    4427             iParam = whichParam(PROBINGCUTS, numberParameters_, parameters_);
     4427            iParam = whichParam(CBC_PARAM_STR_PROBINGCUTS, numberParameters_, parameters_);
    44284428            parameters_[iParam].setCurrentOption("on");
    44294429            probingAction = 1;
     
    45254525                int valid;
    45264526                numberGoodCommands++;
    4527                 if (type == BAB && goodModel) {
     4527                if (type == CBC_PARAM_ACTION_BAB && goodModel) {
    45284528                    // check if any integers
    45294529#ifndef CBC_OTHER_SOLVER
     
    45374537                    if (!lpSolver->integerInformation() && !numberSOS &&
    45384538                            !clpSolver->numberSOS() && !model_.numberObjects() && !clpSolver->numberObjects())
    4539                         type = DUALSIMPLEX;
     4539                        type = CLP_PARAM_ACTION_DUALSIMPLEX;
    45404540#endif
    45414541                }
    4542                 if (type == GENERALQUERY) {
     4542                if (type == CBC_PARAM_GENERALQUERY) {
    45434543                    bool evenHidden = false;
    45444544                    int printLevel =
    4545                         parameters_[whichParam(ALLCOMMANDS,
     4545                        parameters_[whichParam(CLP_PARAM_STR_ALLCOMMANDS,
    45464546                                               numberParameters_, parameters_)].currentOptionAsInteger();
    45474547                    int convertP[] = {2, 1, 0};
     
    46364636                            std::cout << std::endl;
    46374637                    }
    4638                 } else if (type == FULLGENERALQUERY) {
     4638                } else if (type == CBC_PARAM_FULLGENERALQUERY) {
    46394639                    std::cout << "Full list of commands is:" << std::endl;
    46404640                    int maxAcross = 5;
     
    47024702                            }
    47034703                            switch (type) {
    4704                             case DJFIX:
     4704                            case CBC_PARAM_DBL_DJFIX:
    47054705                                djFix = value;
    47064706#ifndef CBC_OTHER_SOLVER
     
    47184718                                    double * dj = lpSolver->dualColumnSolution();
    47194719                                    int numberFixed = 0;
    4720                                     double dextra4 = parameters_[whichParam(DEXTRA4, numberParameters_, parameters_)].doubleValue();
     4720                                    double dextra4 = parameters_[whichParam(CBC_PARAM_DBL_DEXTRA4, numberParameters_, parameters_)].doubleValue();
    47214721                                    if (dextra4)
    47224722                                        printf("Multiple for continuous dj fixing is %g\n", dextra4);
     
    47454745#endif
    47464746                                break;
    4747                             case TIGHTENFACTOR:
     4747                            case CBC_PARAM_DBL_TIGHTENFACTOR:
    47484748                                tightenFactor = value;
    47494749                                if (!complicatedInteger)
     
    47664766                    if (!valid) {
    47674767                        if (type < 151) {
    4768                             if (parameters_[iParam].type() == PRESOLVEPASS)
     4768                            if (parameters_[iParam].type() == CLP_PARAM_INT_PRESOLVEPASS)
    47694769                                preSolve = value;
    4770                             else if (parameters_[iParam].type() == IDIOT)
     4770                            else if (parameters_[iParam].type() == CLP_PARAM_INT_IDIOT)
    47714771                                doIdiot = value;
    4772                             else if (parameters_[iParam].type() == SPRINT)
     4772                            else if (parameters_[iParam].type() == CLP_PARAM_INT_SPRINT)
    47734773                                doSprint = value;
    4774                             else if (parameters_[iParam].type() == OUTPUTFORMAT)
     4774                            else if (parameters_[iParam].type() == CLP_PARAM_INT_OUTPUTFORMAT)
    47754775                                outputFormat = value;
    4776                             else if (parameters_[iParam].type() == SLPVALUE)
     4776                            else if (parameters_[iParam].type() == CLP_PARAM_INT_SLPVALUE)
    47774777                                slpValue = value;
    4778                             else if (parameters_[iParam].type() == CPP)
     4778                            else if (parameters_[iParam].type() == CLP_PARAM_INT_CPP)
    47794779                                cppValue = value;
    4780                             else if (parameters_[iParam].type() == PRESOLVEOPTIONS)
     4780                            else if (parameters_[iParam].type() == CLP_PARAM_INT_PRESOLVEOPTIONS)
    47814781                                presolveOptions = value;
    4782                             else if (parameters_[iParam].type() == PRINTOPTIONS)
     4782                            else if (parameters_[iParam].type() == CLP_PARAM_INT_PRINTOPTIONS)
    47834783                                printOptions = value;
    4784                             else if (parameters_[iParam].type() == SUBSTITUTION)
     4784                            else if (parameters_[iParam].type() == CLP_PARAM_INT_SUBSTITUTION)
    47854785                                substitution = value;
    4786                             else if (parameters_[iParam].type() == DUALIZE)
     4786                            else if (parameters_[iParam].type() == CLP_PARAM_INT_DUALIZE)
    47874787                                dualize = value;
    4788                             else if (parameters_[iParam].type() == PROCESSTUNE)
     4788                            else if (parameters_[iParam].type() == CLP_PARAM_INT_PROCESSTUNE)
    47894789                                tunePreProcess = value;
    4790                             else if (parameters_[iParam].type() == USESOLUTION)
     4790                            else if (parameters_[iParam].type() == CLP_PARAM_INT_USESOLUTION)
    47914791                                useSolution = value;
    4792                             else if (parameters_[iParam].type() == VERBOSE)
     4792                            else if (parameters_[iParam].type() == CLP_PARAM_INT_VERBOSE)
    47934793                                verbose = value;
    47944794                            int returnCode;
     
    48014801                            }
    48024802                        } else {
    4803                             if (parameters_[iParam].type() == CUTPASS)
     4803                            if (parameters_[iParam].type() == CBC_PARAM_INT_CUTPASS)
    48044804                                cutPass = value;
    4805                             else if (parameters_[iParam].type() == CUTPASSINTREE)
     4805                            else if (parameters_[iParam].type() == CBC_PARAM_INT_CUTPASSINTREE)
    48064806                                cutPassInTree = value;
    4807                             else if (parameters_[iParam].type() == STRONGBRANCHING ||
    4808                                      parameters_[iParam].type() == NUMBERBEFORE)
     4807                            else if (parameters_[iParam].type() == CBC_PARAM_INT_STRONGBRANCHING ||
     4808                                     parameters_[iParam].type() == CBC_PARAM_INT_NUMBERBEFORE)
    48094809                                strongChanged = true;
    4810                             else if (parameters_[iParam].type() == FPUMPTUNE ||
    4811                                      parameters_[iParam].type() == FPUMPTUNE2 ||
    4812                                      parameters_[iParam].type() == FPUMPITS)
     4810                            else if (parameters_[iParam].type() == CBC_PARAM_INT_FPUMPTUNE ||
     4811                                     parameters_[iParam].type() == CBC_PARAM_INT_FPUMPTUNE2 ||
     4812                                     parameters_[iParam].type() == CBC_PARAM_INT_FPUMPITS)
    48134813                                pumpChanged = true;
    4814                             else if (parameters_[iParam].type() == EXPERIMENT) {
     4814                            else if (parameters_[iParam].type() == CBC_PARAM_INT_EXPERIMENT) {
    48154815                                if (value >= 1) {
    48164816                                    if (!noPrinting_) {
     
    48254825                                        << CoinMessageEol;
    48264826                                    }
    4827                                     parameters[whichParam(PROBINGCUTS, numberParameters, parameters)].setCurrentOption("forceOnStrong");
     4827                                    parameters[whichParam(CBC_PARAM_STR_PROBINGCUTS, numberParameters, parameters)].setCurrentOption("forceOnStrong");
    48284828                                    probingAction = 8;
    4829                                     parameters_[whichParam(GOMORYCUTS, numberParameters_, parameters_)].setCurrentOption("onGlobal");
     4829                                    parameters_[whichParam(CBC_PARAM_STR_GOMORYCUTS, numberParameters_, parameters_)].setCurrentOption("onGlobal");
    48304830                                    gomoryAction = 5;
    4831                                     parameters_[whichParam(KNAPSACKCUTS, numberParameters_, parameters_)].setCurrentOption("onGlobal");
     4831                                    parameters_[whichParam(CBC_PARAM_STR_KNAPSACKCUTS, numberParameters_, parameters_)].setCurrentOption("onGlobal");
    48324832                                    knapsackAction = 5;
    4833                                     parameters_[whichParam(FACTORIZATION, numberParameters_, parameters_)].setCurrentOption("osl");
     4833                                    parameters_[whichParam(CLP_PARAM_STR_FACTORIZATION, numberParameters_, parameters_)].setCurrentOption("osl");
    48344834                                    lpSolver->factorization()->forceOtherFactorization(3);
    4835                                     parameters_[whichParam(MAXHOTITS, numberParameters_, parameters_)].setIntValue(100);
    4836                                     parameters[whichParam(CUTPASS, numberParameters, parameters)].setIntValue(1000);
     4835                                    parameters_[whichParam(CBC_PARAM_INT_MAXHOTITS, numberParameters_, parameters_)].setIntValue(100);
     4836                                    parameters[whichParam(CBC_PARAM_INT_CUTPASS, numberParameters, parameters)].setIntValue(1000);
    48374837                                    cutPass = 1000;
    4838                                     parameters[whichParam(EXTRA4, numberParameters, parameters)].setIntValue(24003);
    4839                                     parameters[whichParam(RENS, numberParameters, parameters)].setCurrentOption("on");
    4840                                 }
    4841                             } else if (parameters_[iParam].type() == STRATEGY) {
     4838                                    parameters[whichParam(CBC_PARAM_INT_EXTRA4, numberParameters, parameters)].setIntValue(24003);
     4839                                    parameters[whichParam(CBC_PARAM_STR_RENS, numberParameters, parameters)].setCurrentOption("on");
     4840                                }
     4841                            } else if (parameters_[iParam].type() == CBC_PARAM_INT_STRATEGY) {
    48424842                                if (value == 0) {
    48434843                                    gomoryGen.setAwayAtRoot(0.05);
    48444844                                    int iParam;
    4845                                     iParam = whichParam(DIVEOPT, numberParameters_, parameters_);
     4845                                    iParam = whichParam(CBC_PARAM_INT_DIVEOPT, numberParameters_, parameters_);
    48464846                                    parameters_[iParam].setIntValue(-1);
    4847                                     iParam = whichParam(FPUMPITS, numberParameters_, parameters_);
     4847                                    iParam = whichParam(CBC_PARAM_INT_FPUMPITS, numberParameters_, parameters_);
    48484848                                    parameters_[iParam].setIntValue(20);
    4849                                     iParam = whichParam(FPUMPTUNE, numberParameters_, parameters_);
     4849                                    iParam = whichParam(CBC_PARAM_INT_FPUMPTUNE, numberParameters_, parameters_);
    48504850                                    parameters_[iParam].setIntValue(1003);
    48514851                                    initialPumpTune = 1003;
    4852                                     iParam = whichParam(PROCESSTUNE, numberParameters_, parameters_);
     4852                                    iParam = whichParam(CLP_PARAM_INT_PROCESSTUNE, numberParameters_, parameters_);
    48534853                                    parameters_[iParam].setIntValue(-1);
    48544854                                    tunePreProcess = 0;
    4855                                     iParam = whichParam(DIVINGC, numberParameters_, parameters_);
     4855                                    iParam = whichParam(CBC_PARAM_STR_DIVINGC, numberParameters_, parameters_);
    48564856                                    parameters_[iParam].setCurrentOption("off");
    4857                                     iParam = whichParam(RINS, numberParameters_, parameters_);
     4857                                    iParam = whichParam(CBC_PARAM_STR_RINS, numberParameters_, parameters_);
    48584858                                    parameters_[iParam].setCurrentOption("off");
    4859                                     iParam = whichParam(PROBINGCUTS, numberParameters_, parameters_);
     4859                                    iParam = whichParam(CBC_PARAM_STR_PROBINGCUTS, numberParameters_, parameters_);
    48604860                                    parameters_[iParam].setCurrentOption("on");
    48614861                                    probingAction = 1;
     
    49014901                        // for now hard wired
    49024902                        switch (type) {
    4903                         case DIRECTION:
     4903                        case CLP_PARAM_STR_DIRECTION:
    49044904                            if (action == 0)
    49054905                                lpSolver->setOptimizationDirection(1);
     
    49094909                                lpSolver->setOptimizationDirection(0);
    49104910                            break;
    4911                         case DUALPIVOT:
     4911                        case CLP_PARAM_STR_DUALPIVOT:
    49124912                            if (action == 0) {
    49134913                                ClpDualRowSteepest steep(3);
     
    49264926                            }
    49274927                            break;
    4928                         case PRIMALPIVOT:
     4928                        case CLP_PARAM_STR_PRIMALPIVOT:
    49294929                            if (action == 0) {
    49304930                                ClpPrimalColumnSteepest steep(3);
     
    49504950                            }
    49514951                            break;
    4952                         case SCALING:
     4952                        case CLP_PARAM_STR_SCALING:
    49534953                            lpSolver->scaling(action);
    49544954                            solver->setHintParam(OsiDoScale, action != 0, OsiHintTry);
    49554955                            doScaling = action;
    49564956                            break;
    4957                         case AUTOSCALE:
     4957                        case CLP_PARAM_STR_AUTOSCALE:
    49584958                            lpSolver->setAutomaticScaling(action != 0);
    49594959                            break;
    4960                         case SPARSEFACTOR:
     4960                        case CLP_PARAM_STR_SPARSEFACTOR:
    49614961                            lpSolver->setSparseFactorization((1 - action) != 0);
    49624962                            break;
    4963                         case BIASLU:
     4963                        case CLP_PARAM_STR_BIASLU:
    49644964                            lpSolver->factorization()->setBiasLU(action);
    49654965                            break;
    4966                         case PERTURBATION:
     4966                        case CLP_PARAM_STR_PERTURBATION:
    49674967                            if (action == 0)
    49684968                                lpSolver->setPerturbation(50);
     
    49704970                                lpSolver->setPerturbation(100);
    49714971                            break;
    4972                         case ERRORSALLOWED:
     4972                        case CLP_PARAM_STR_ERRORSALLOWED:
    49734973                            allowImportErrors = action;
    49744974                            break;
    4975                         case INTPRINT:
     4975                        case CLP_PARAM_STR_INTPRINT:
    49764976                            printMode = action;
    49774977                            break;
    4978                             //case ALGORITHM:
     4978                            //case CLP_PARAM_NOTUSED_ALGORITHM:
    49794979                            //algorithm  = action;
    49804980                            //defaultSettings=false; // user knows what she is doing
    49814981                            //abort();
    49824982                            //break;
    4983                         case KEEPNAMES:
     4983                        case CLP_PARAM_STR_KEEPNAMES:
    49844984                            keepImportNames = 1 - action;
    49854985                            break;
    4986                         case PRESOLVE:
     4986                        case CLP_PARAM_STR_PRESOLVE:
    49874987                            if (action == 0)
    49884988                                preSolve = 5;
     
    49944994                                preSolveFile = true;
    49954995                            break;
    4996                         case PFI:
     4996                        case CLP_PARAM_STR_PFI:
    49974997                            lpSolver->factorization()->setForrestTomlin(action == 0);
    49984998                            break;
    4999                         case FACTORIZATION:
     4999                        case CLP_PARAM_STR_FACTORIZATION:
    50005000                            lpSolver->factorization()->forceOtherFactorization(action);
    50015001                            break;
    5002                         case CRASH:
     5002                        case CLP_PARAM_STR_CRASH:
    50035003                            doCrash = action;
    50045004                            break;
    5005                         case VECTOR:
     5005                        case CLP_PARAM_STR_VECTOR:
    50065006                            doVector = action;
    50075007                            break;
    5008                         case MESSAGES:
     5008                        case CLP_PARAM_STR_MESSAGES:
    50095009                            lpSolver->messageHandler()->setPrefix(action != 0);
    50105010                            break;
    5011                         case CHOLESKY:
     5011                        case CLP_PARAM_STR_CHOLESKY:
    50125012                            choleskyType = action;
    50135013                            break;
    5014                         case GAMMA:
     5014                        case CLP_PARAM_STR_GAMMA:
    50155015                            gamma = action;
    50165016                            break;
    5017                         case BARRIERSCALE:
     5017                        case CLP_PARAM_STR_BARRIERSCALE:
    50185018                            scaleBarrier = action;
    50195019                            break;
    5020                         case KKT:
     5020                        case CLP_PARAM_STR_KKT:
    50215021                            doKKT = action;
    50225022                            break;
    5023                         case CROSSOVER:
     5023                        case CLP_PARAM_STR_CROSSOVER:
    50245024                            crossover = action;
    50255025                            break;
    5026                         case SOS:
     5026                        case CBC_PARAM_STR_SOS:
    50275027                            doSOS = action;
    50285028                            break;
    5029                         case GOMORYCUTS:
     5029                        case CBC_PARAM_STR_GOMORYCUTS:
    50305030                            defaultSettings = false; // user knows what she is doing
    50315031                            gomoryAction = action;
    50325032                            break;
    5033                         case PROBINGCUTS:
     5033                        case CBC_PARAM_STR_PROBINGCUTS:
    50345034                            defaultSettings = false; // user knows what she is doing
    50355035                            probingAction = action;
    50365036                            break;
    5037                         case KNAPSACKCUTS:
     5037                        case CBC_PARAM_STR_KNAPSACKCUTS:
    50385038                            defaultSettings = false; // user knows what she is doing
    50395039                            knapsackAction = action;
    50405040                            break;
    5041                         case REDSPLITCUTS:
     5041                        case CBC_PARAM_STR_REDSPLITCUTS:
    50425042                            defaultSettings = false; // user knows what she is doing
    50435043                            redsplitAction = action;
    50445044                            break;
    5045                         case CLIQUECUTS:
     5045                        case CBC_PARAM_STR_CLIQUECUTS:
    50465046                            defaultSettings = false; // user knows what she is doing
    50475047                            cliqueAction = action;
    50485048                            break;
    5049                         case FLOWCUTS:
     5049                        case CBC_PARAM_STR_FLOWCUTS:
    50505050                            defaultSettings = false; // user knows what she is doing
    50515051                            flowAction = action;
    50525052                            break;
    5053                         case MIXEDCUTS:
     5053                        case CBC_PARAM_STR_MIXEDCUTS:
    50545054                            defaultSettings = false; // user knows what she is doing
    50555055                            mixedAction = action;
    50565056                            break;
    5057                         case TWOMIRCUTS:
     5057                        case CBC_PARAM_STR_TWOMIRCUTS:
    50585058                            defaultSettings = false; // user knows what she is doing
    50595059                            twomirAction = action;
    50605060                            break;
    5061                         case LANDPCUTS:
     5061                        case CBC_PARAM_STR_LANDPCUTS:
    50625062                            defaultSettings = false; // user knows what she is doing
    50635063                            landpAction = action;
    50645064                            break;
    5065                         case RESIDCUTS:
     5065                        case CBC_PARAM_STR_RESIDCUTS:
    50665066                            defaultSettings = false; // user knows what she is doing
    50675067                            residualCapacityAction = action;
    50685068                            break;
    50695069#ifdef ZERO_HALF_CUTS
    5070                         case ZEROHALFCUTS:
     5070                        case CBC_PARAM_STR_ZEROHALFCUTS:
    50715071                            defaultSettings = false; // user knows what she is doing
    50725072                            zerohalfAction = action;
    50735073                            break;
    50745074#endif
    5075                         case ROUNDING:
     5075                        case CBC_PARAM_STR_ROUNDING:
    50765076                            defaultSettings = false; // user knows what she is doing
    50775077                            break;
    5078                         case FPUMP:
     5078                        case CBC_PARAM_STR_FPUMP:
    50795079                            defaultSettings = false; // user knows what she is doing
    50805080                            break;
    5081                         case RINS:
     5081                        case CBC_PARAM_STR_RINS:
    50825082                            break;
    5083                         case DINS:
     5083                        case CBC_PARAM_STR_DINS:
    50845084                            break;
    5085                         case RENS:
     5085                        case CBC_PARAM_STR_RENS:
    50865086                            break;
    5087                         case CUTSSTRATEGY:
     5087                        case CBC_PARAM_STR_CUTSSTRATEGY:
    50885088                            gomoryAction = action;
    50895089                            probingAction = action;
     
    50975097                            twomirAction = action;
    50985098                            //landpAction = action;
    5099                             parameters_[whichParam(GOMORYCUTS, numberParameters_, parameters_)].setCurrentOption(action);
    5100                             parameters_[whichParam(PROBINGCUTS, numberParameters_, parameters_)].setCurrentOption(action);
    5101                             parameters_[whichParam(KNAPSACKCUTS, numberParameters_, parameters_)].setCurrentOption(action);
    5102                             parameters_[whichParam(CLIQUECUTS, numberParameters_, parameters_)].setCurrentOption(action);
    5103                             parameters_[whichParam(FLOWCUTS, numberParameters_, parameters_)].setCurrentOption(action);
    5104                             parameters_[whichParam(MIXEDCUTS, numberParameters_, parameters_)].setCurrentOption(action);
    5105                             parameters_[whichParam(TWOMIRCUTS, numberParameters_, parameters_)].setCurrentOption(action);
     5099                            parameters_[whichParam(CBC_PARAM_STR_GOMORYCUTS, numberParameters_, parameters_)].setCurrentOption(action);
     5100                            parameters_[whichParam(CBC_PARAM_STR_PROBINGCUTS, numberParameters_, parameters_)].setCurrentOption(action);
     5101                            parameters_[whichParam(CBC_PARAM_STR_KNAPSACKCUTS, numberParameters_, parameters_)].setCurrentOption(action);
     5102                            parameters_[whichParam(CBC_PARAM_STR_CLIQUECUTS, numberParameters_, parameters_)].setCurrentOption(action);
     5103                            parameters_[whichParam(CBC_PARAM_STR_FLOWCUTS, numberParameters_, parameters_)].setCurrentOption(action);
     5104                            parameters_[whichParam(CBC_PARAM_STR_MIXEDCUTS, numberParameters_, parameters_)].setCurrentOption(action);
     5105                            parameters_[whichParam(CBC_PARAM_STR_TWOMIRCUTS, numberParameters_, parameters_)].setCurrentOption(action);
    51065106#ifdef ZERO_HALF_CUTS
    5107                             parameters_[whichParam(ZEROHALFCUTS, numberParameters_, parameters_)].setCurrentOption(action);
     5107                            parameters_[whichParam(CBC_PARAM_STR_ZEROHALFCUTS, numberParameters_, parameters_)].setCurrentOption(action);
    51085108#endif
    51095109                            if (!action) {
    51105110                                redsplitAction = action;
    5111                                 parameters_[whichParam(REDSPLITCUTS, numberParameters_, parameters_)].setCurrentOption(action);
     5111                                parameters_[whichParam(CBC_PARAM_STR_REDSPLITCUTS, numberParameters_, parameters_)].setCurrentOption(action);
    51125112                                landpAction = action;
    5113                                 parameters_[whichParam(LANDPCUTS, numberParameters_, parameters_)].setCurrentOption(action);
     5113                                parameters_[whichParam(CBC_PARAM_STR_LANDPCUTS, numberParameters_, parameters_)].setCurrentOption(action);
    51145114                                residualCapacityAction = action;
    5115                                 parameters_[whichParam(RESIDCUTS, numberParameters_, parameters_)].setCurrentOption(action);
     5115                                parameters_[whichParam(CBC_PARAM_STR_RESIDCUTS, numberParameters_, parameters_)].setCurrentOption(action);
    51165116                            }
    51175117                            break;
    5118                         case HEURISTICSTRATEGY:
    5119                             parameters_[whichParam(ROUNDING, numberParameters_, parameters_)].setCurrentOption(action);
    5120                             parameters_[whichParam(GREEDY, numberParameters_, parameters_)].setCurrentOption(action);
    5121                             parameters_[whichParam(COMBINE, numberParameters_, parameters_)].setCurrentOption(action);
    5122                             //parameters_[whichParam(LOCALTREE,numberParameters_,parameters_)].setCurrentOption(action);
    5123                             parameters_[whichParam(FPUMP, numberParameters_, parameters_)].setCurrentOption(action);
    5124                             parameters_[whichParam(DIVINGC, numberParameters_, parameters_)].setCurrentOption(action);
    5125                             parameters_[whichParam(RINS, numberParameters_, parameters_)].setCurrentOption(action);
     5118                        case CBC_PARAM_STR_HEURISTICSTRATEGY:
     5119                            parameters_[whichParam(CBC_PARAM_STR_ROUNDING, numberParameters_, parameters_)].setCurrentOption(action);
     5120                            parameters_[whichParam(CBC_PARAM_STR_GREEDY, numberParameters_, parameters_)].setCurrentOption(action);
     5121                            parameters_[whichParam(CBC_PARAM_STR_COMBINE, numberParameters_, parameters_)].setCurrentOption(action);
     5122                            //parameters_[whichParam(CBC_PARAM_STR_LOCALTREE,numberParameters_,parameters_)].setCurrentOption(action);
     5123                            parameters_[whichParam(CBC_PARAM_STR_FPUMP, numberParameters_, parameters_)].setCurrentOption(action);
     5124                            parameters_[whichParam(CBC_PARAM_STR_DIVINGC, numberParameters_, parameters_)].setCurrentOption(action);
     5125                            parameters_[whichParam(CBC_PARAM_STR_RINS, numberParameters_, parameters_)].setCurrentOption(action);
    51265126                            break;
    5127                         case GREEDY:
    5128                         case DIVINGS:
    5129                         case DIVINGC:
    5130                         case DIVINGF:
    5131                         case DIVINGG:
    5132                         case DIVINGL:
    5133                         case DIVINGP:
    5134                         case DIVINGV:
    5135                         case COMBINE:
    5136                         case PIVOTANDCOMPLEMENT:
    5137                         case PIVOTANDFIX:
    5138                         case RANDROUND:
    5139                         case LOCALTREE:
    5140                         case NAIVE:
    5141                         case CPX:
     5127                        case CBC_PARAM_STR_GREEDY:
     5128                        case CBC_PARAM_STR_DIVINGS:
     5129                        case CBC_PARAM_STR_DIVINGC:
     5130                        case CBC_PARAM_STR_DIVINGF:
     5131                        case CBC_PARAM_STR_DIVINGG:
     5132                        case CBC_PARAM_STR_DIVINGL:
     5133                        case CBC_PARAM_STR_DIVINGP:
     5134                        case CBC_PARAM_STR_DIVINGV:
     5135                        case CBC_PARAM_STR_COMBINE:
     5136                        case CBC_PARAM_STR_PIVOTANDCOMPLEMENT:
     5137                        case CBC_PARAM_STR_PIVOTANDFIX:
     5138                        case CBC_PARAM_STR_RANDROUND:
     5139                        case CBC_PARAM_STR_LOCALTREE:
     5140                        case CBC_PARAM_STR_NAIVE:
     5141                        case CBC_PARAM_STR_CPX:
    51425142                            defaultSettings = false; // user knows what she is doing
    51435143                            break;
    5144                         case COSTSTRATEGY:
     5144                        case CBC_PARAM_STR_COSTSTRATEGY:
    51455145                            useCosts = action;
    51465146                            break;
    5147                         case NODESTRATEGY:
     5147                        case CBC_PARAM_STR_NODESTRATEGY:
    51485148                            nodeStrategy = action;
    51495149                            break;
    5150                         case PREPROCESS:
     5150                        case CBC_PARAM_STR_PREPROCESS:
    51515151                            preProcess = action;
    51525152                            break;
     
    51585158                } else {
    51595159                    // action
    5160                     if (type == EXIT) {
     5160                    if (type == CLP_PARAM_ACTION_EXIT) {
    51615161#ifdef COIN_HAS_ASL
    51625162                        if (statusUserFunction_[0]) {
     
    51745174                    }
    51755175                    switch (type) {
    5176                     case DUALSIMPLEX:
    5177                     case PRIMALSIMPLEX:
    5178                     case SOLVECONTINUOUS:
    5179                     case BARRIER:
     5176                    case CLP_PARAM_ACTION_DUALSIMPLEX:
     5177                    case CLP_PARAM_ACTION_PRIMALSIMPLEX:
     5178                    case CLP_PARAM_ACTION_SOLVECONTINUOUS:
     5179                    case CLP_PARAM_ACTION_BARRIER:
    51805180                        if (goodModel) {
    51815181                            // Say not in integer
    51825182                            integerStatus = -1;
    51835183                            double objScale =
    5184                                 parameters_[whichParam(OBJSCALE2, numberParameters_, parameters_)].doubleValue();
     5184                                parameters_[whichParam(CLP_PARAM_DBL_OBJSCALE2, numberParameters_, parameters_)].doubleValue();
    51855185                            if (objScale != 1.0) {
    51865186                                int iColumn;
     
    52725272                            }
    52735273                            solveOptions.setPresolveType(presolveType, preSolve);
    5274                             if (type == DUALSIMPLEX || type == SOLVECONTINUOUS) {
     5274                            if (type == CLP_PARAM_ACTION_DUALSIMPLEX ||
     5275                                                                type == CLP_PARAM_ACTION_SOLVECONTINUOUS) {
    52755276                                method = ClpSolve::useDual;
    5276                             } else if (type == PRIMALSIMPLEX) {
     5277                            } else if (type == CLP_PARAM_ACTION_PRIMALSIMPLEX) {
    52775278                                method = ClpSolve::usePrimalorSprint;
    52785279                            } else {
     
    53595360                            } else {
    53605361                                // special solver
    5361                                 int testOsiOptions = parameters_[whichParam(TESTOSI, numberParameters_, parameters_)].intValue();
     5362                                int testOsiOptions = parameters_[whichParam(CBC_PARAM_INT_TESTOSI, numberParameters_, parameters_)].intValue();
    53625363                                double * solution = NULL;
    53635364                                if (testOsiOptions < 10) {
     
    54305431                                if (iStatus == 0) {
    54315432                                    iStatus2 = 0;
    5432                                     if (found.type() == BAB) {
     5433                                    if (found.type() == CBC_PARAM_ACTION_BAB) {
    54335434                                        // set best solution in model as no integers
    54345435                                        model_.setBestSolution(model2->primalColumnSolution(),
     
    55675568                        }
    55685569                        break;
    5569                     case STATISTICS:
     5570                    case CLP_PARAM_ACTION_STATISTICS:
    55705571                        if (goodModel) {
    55715572                            // If presolve on look at presolved
     
    55815582                                    pinfo.statistics();
    55825583                                double presolveTolerance =
    5583                                     parameters_[whichParam(PRESOLVETOLERANCE, numberParameters_, parameters_)].doubleValue();
     5584                                    parameters_[whichParam(CLP_PARAM_DBL_PRESOLVETOLERANCE, numberParameters_, parameters_)].doubleValue();
    55845585                                model2 =
    55855586                                    pinfo.presolvedModel(*lpSolver, presolveTolerance,
     
    56055606                        }
    56065607                        break;
    5607                     case TIGHTEN:
     5608                    case CLP_PARAM_ACTION_TIGHTEN:
    56085609                        if (goodModel) {
    56095610                            int numberInfeasibilities = lpSolver->tightenPrimalBounds();
     
    56165617                        }
    56175618                        break;
    5618                     case PLUSMINUS:
     5619                    case CLP_PARAM_ACTION_PLUSMINUS:
    56195620                        if (goodModel) {
    56205621                            ClpMatrixBase * saveMatrix = lpSolver->clpMatrix();
     
    56395640                        }
    56405641                        break;
    5641                     case OUTDUPROWS:
     5642                    case CLP_PARAM_ACTION_OUTDUPROWS:
    56425643                        dominatedCuts = true;
    56435644#if 0
     
    56605661#endif
    56615662                        break;
    5662                     case NETWORK:
     5663                    case CLP_PARAM_ACTION_NETWORK:
    56635664                        if (goodModel) {
    56645665                            ClpMatrixBase * saveMatrix = lpSolver->clpMatrix();
     
    56835684                        }
    56845685                        break;
    5685                     case DOHEURISTIC:
     5686                    case CBC_PARAM_ACTION_DOHEURISTIC:
    56865687                        if (goodModel) {
    5687                             int vubAction = parameters_[whichParam(VUBTRY, numberParameters_, parameters_)].intValue();
     5688                            int vubAction = parameters_[whichParam(CBC_PARAM_INT_VUBTRY, numberParameters_, parameters_)].intValue();
    56885689                            if (vubAction != -1) {
    56895690                                // look at vubs
    56905691                                // extra1 is number of ints to leave free
    56915692                                // Just ones which affect >= extra3
    5692                                 int extra3 = parameters_[whichParam(EXTRA3, numberParameters_, parameters_)].intValue();
     5693                                int extra3 = parameters_[whichParam(CBC_PARAM_INT_EXTRA3, numberParameters_, parameters_)].intValue();
    56935694                                /* 2 is cost above which to fix if feasible
    56945695                                   3 is fraction of integer variables fixed if relaxing (0.97)
     
    56975698                                double dextra[6];
    56985699                                int extra[5];
    5699                                 extra[1] = parameters_[whichParam(EXTRA1, numberParameters_, parameters_)].intValue();
    5700                                 int exp1 = parameters_[whichParam(EXPERIMENT, numberParameters_,
     5700                                extra[1] = parameters_[whichParam(CBC_PARAM_INT_EXTRA1, numberParameters_, parameters_)].intValue();
     5701                                int exp1 = parameters_[whichParam(CBC_PARAM_INT_EXPERIMENT, numberParameters_,
    57015702                                                                  parameters_)].intValue();
    57025703                                if (exp1 == 2 && extra[1] == -1)
    57035704                                    extra[1] = 999998;
    5704                                 dextra[1] = parameters_[whichParam(FAKEINCREMENT, numberParameters_, parameters_)].doubleValue();
    5705                                 dextra[2] = parameters_[whichParam(FAKECUTOFF, numberParameters_, parameters_)].doubleValue();
    5706                                 dextra[3] = parameters_[whichParam(DEXTRA3, numberParameters_, parameters_)].doubleValue();
    5707                                 dextra[4] = parameters_[whichParam(DEXTRA4, numberParameters_, parameters_)].doubleValue();
    5708                                 dextra[5] = parameters_[whichParam(DEXTRA5, numberParameters_, parameters_)].doubleValue();
     5705                                dextra[1] = parameters_[whichParam(CBC_PARAM_DBL_FAKEINCREMENT, numberParameters_, parameters_)].doubleValue();
     5706                                dextra[2] = parameters_[whichParam(CBC_PARAM_DBL_FAKECUTOFF, numberParameters_, parameters_)].doubleValue();
     5707                                dextra[3] = parameters_[whichParam(CBC_PARAM_DBL_DEXTRA3, numberParameters_, parameters_)].doubleValue();
     5708                                dextra[4] = parameters_[whichParam(CBC_PARAM_DBL_DEXTRA4, numberParameters_, parameters_)].doubleValue();
     5709                                dextra[5] = parameters_[whichParam(CBC_PARAM_DBL_DEXTRA5, numberParameters_, parameters_)].doubleValue();
    57095710                                if (!dextra[3])
    57105711                                    dextra[3] = 0.97;
     
    57775778                        }
    57785779                        break;
    5779                     case MIPLIB:
     5780                    case CBC_PARAM_ACTION_MIPLIB:
    57805781                        // User can set options - main difference is lack of model and CglPreProcess
    57815782                        goodModel = true;
     
    57845785                          Print elapsed time at the end.
    57855786                        */
    5786                     case BAB: // branchAndBound
     5787                    case CBC_PARAM_ACTION_BAB: // branchAndBound
    57875788                        // obsolete case STRENGTHEN:
    57885789                        if (goodModel) {
    5789                             bool miplib = type == MIPLIB;
     5790                            bool miplib = type == CBC_PARAM_ACTION_MIPLIB;
    57905791                            int logLevel = parameters_[slog].intValue();
    57915792                            // Reduce printout
     
    58265827                                    if (obj) {
    58275828                                        preProcess = 0;
    5828                                         int testOsiOptions = parameters_[whichParam(TESTOSI, numberParameters_, parameters_)].intValue();
    5829                                         parameters_[whichParam(TESTOSI, numberParameters_, parameters_)].setIntValue(CoinMax(0, testOsiOptions));
     5829                                        int testOsiOptions = parameters_[whichParam(CBC_PARAM_INT_TESTOSI, numberParameters_, parameters_)].intValue();
     5830                                        parameters_[whichParam(CBC_PARAM_INT_TESTOSI, numberParameters_, parameters_)].setIntValue(CoinMax(0, testOsiOptions));
    58305831                                        // create coin model
    58315832                                        coinModel = lpSolver->createCoinModel();
     
    58415842                                        // need some relative granularity
    58425843                                        si->setDefaultBound(100.0);
    5843                                         double dextra3 = parameters_[whichParam(DEXTRA3, numberParameters_, parameters_)].doubleValue();
     5844                                        double dextra3 = parameters_[whichParam(CBC_PARAM_DBL_DEXTRA3, numberParameters_, parameters_)].doubleValue();
    58445845                                        if (dextra3)
    58455846                                            si->setDefaultMeshSize(dextra3);
     
    59795980                                            cbcModel->initialSolve();
    59805981#ifdef CBC_THREAD
    5981                                             int numberThreads = parameters_[whichParam(THREADS, numberParameters_, parameters_)].intValue();
     5982                                            int numberThreads = parameters_[whichParam(CBC_PARAM_INT_THREADS, numberParameters_, parameters_)].intValue();
    59825983                                            cbcModel->setNumberThreads(numberThreads % 100);
    59835984                                            cbcModel->setThreadMode(CoinMin(numberThreads / 100, 7));
     
    63276328#endif
    63286329                            }
    6329                             if (type == BAB) {
     6330                            if (type == CBC_PARAM_ACTION_BAB) {
    63306331                                double limit;
    63316332                                clpSolver->getDblParam(OsiDualObjectiveLimit, limit);
     
    63346335                                    preProcess = 0;
    63356336                            }
    6336                             if (preProcess && type == BAB) {
     6337                            if (preProcess && type == CBC_PARAM_ACTION_BAB) {
    63376338#ifndef CBC_OTHER_SOLVER
    63386339                                // See if sos from mps file
     
    66546655                                //                         babModel_->getNumCols());
    66556656                            }
    6656                             int testOsiOptions = parameters_[whichParam(TESTOSI, numberParameters_, parameters_)].intValue();
     6657                            int testOsiOptions = parameters_[whichParam(CBC_PARAM_INT_TESTOSI, numberParameters_, parameters_)].intValue();
    66576658                            //#ifdef COIN_HAS_ASL
    66586659#if 1
     
    66606661                            {
    66616662                                OsiSolverLink * solver3 = dynamic_cast<OsiSolverLink *> (babModel_->solver());
    6662                                 int options = parameters_[whichParam(MIPOPTIONS, numberParameters_, parameters_)].intValue() / 10000;
     6663                                int options = parameters_[whichParam(CBC_PARAM_INT_MIPOPTIONS, numberParameters_, parameters_)].intValue() / 10000;
    66636664                                if (solver3 || (options&16) != 0) {
    66646665                                    if (options) {
     
    66776678                                            knapsackRow = new int[numberRows];
    66786679                                            numberKnapsack = 10000;
    6679                                             int extra1 = parameters_[whichParam(EXTRA1, numberParameters_, parameters_)].intValue();
    6680                                             int extra2 = parameters_[whichParam(EXTRA2, numberParameters_, parameters_)].intValue();
     6680                                            int extra1 = parameters_[whichParam(CBC_PARAM_INT_EXTRA1, numberParameters_, parameters_)].intValue();
     6681                                            int extra2 = parameters_[whichParam(CBC_PARAM_INT_EXTRA2, numberParameters_, parameters_)].intValue();
    66816682                                            int logLevel = parameters_[log].intValue();
    66826683                                            OsiSolverInterface * solver = expandKnapsack(saveCoinModel, whichColumn, knapsackStart,
     
    67606761                            doHeuristics(babModel_, (!miplib) ? 1 : 10);
    67616762                            if (!miplib) {
    6762                                 if (parameters_[whichParam(LOCALTREE, numberParameters_, parameters_)].currentOptionAsInteger()) {
     6763                                if (parameters_[whichParam(CBC_PARAM_STR_LOCALTREE, numberParameters_, parameters_)].currentOptionAsInteger()) {
    67636764                                    CbcTreeLocal localTree(babModel_, NULL, 10, 0, 0, 10000, 2000);
    67646765                                    babModel_->passInTreeHandler(localTree);
    67656766                                }
    67666767                            }
    6767                             if (type == MIPLIB) {
     6768                            if (type == CBC_PARAM_ACTION_MIPLIB) {
    67686769                                if (babModel_->numberStrong() == 5 && babModel_->numberBeforeTrust() == 5)
    67696770                                    babModel_->setNumberBeforeTrust(10);
    67706771                            }
    6771                             int experimentFlag = parameters_[whichParam(EXPERIMENT, numberParameters_,
     6772                            int experimentFlag = parameters_[whichParam(CBC_PARAM_INT_EXPERIMENT, numberParameters_,
    67726773                                                             parameters_)].intValue();
    6773                             int strategyFlag = parameters_[whichParam(STRATEGY, numberParameters_,
     6774                            int strategyFlag = parameters_[whichParam(CBC_PARAM_INT_STRATEGY, numberParameters_,
    67746775                                                           parameters_)].intValue();
    67756776                            int bothFlags = CoinMax(CoinMin(experimentFlag, 1), strategyFlag);
     
    68426843                                }
    68436844                                int cutLength =
    6844                                     parameters_[whichParam(CUTLENGTH, numberParameters_, parameters_)].intValue();
     6845                                    parameters_[whichParam(CBC_PARAM_INT_CUTLENGTH, numberParameters_, parameters_)].intValue();
    68456846                                if (cutLength != -1) {
    68466847                                    gomoryGen.setLimitAtRoot(cutLength);
     
    69296930                            int iGenerator;
    69306931                            int cutDepth =
    6931                                 parameters_[whichParam(CUTDEPTH, numberParameters_, parameters_)].intValue();
     6932                                parameters_[whichParam(CBC_PARAM_INT_CUTDEPTH, numberParameters_, parameters_)].intValue();
    69326933                            for (iGenerator = 0; iGenerator < numberGenerators; iGenerator++) {
    69336934                                CbcCutGenerator * generator = babModel_->cutGenerator(iGenerator);
     
    69906991
    69916992                            babModel_->solver()->setIntParam(OsiMaxNumIterationHotStart,
    6992                                                              parameters_[whichParam(MAXHOTITS, numberParameters_, parameters_)].intValue());
     6993                                                             parameters_[whichParam(CBC_PARAM_INT_MAXHOTITS, numberParameters_, parameters_)].intValue());
    69936994#ifndef CBC_OTHER_SOLVER
    69946995                            OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
     
    70667067                            // Turn this off if you get problems
    70677068                            // Used to be automatically set
    7068                             int mipOptions = parameters_[whichParam(MIPOPTIONS, numberParameters_, parameters_)].intValue() % 10000;
     7069                            int mipOptions = parameters_[whichParam(CBC_PARAM_INT_MIPOPTIONS, numberParameters_, parameters_)].intValue() % 10000;
    70697070                            if (mipOptions != (1057)) {
    70707071                                sprintf(generalPrint, "mip options %d", mipOptions);
     
    70817082                            currentBranchModel = babModel_;
    70827083                            //OsiSolverInterface * strengthenedModel=NULL;
    7083                             if (type == BAB || type == MIPLIB) {
     7084                            if (type == CBC_PARAM_ACTION_BAB ||
     7085                                                                type == CBC_PARAM_ACTION_MIPLIB) {
    70847086                                if (strategyFlag == 1) {
    70857087                                    // try reduced model
     
    70917093                                }
    70927094                                {
    7093                                     int depthMiniBab = parameters_[whichParam(DEPTHMINIBAB, numberParameters_, parameters_)].intValue();
     7095                                    int depthMiniBab = parameters_[whichParam(CBC_PARAM_INT_DEPTHMINIBAB, numberParameters_, parameters_)].intValue();
    70947096                                    if (depthMiniBab != -1)
    70957097                                        babModel_->setFastNodeDepth(depthMiniBab);
    70967098                                }
    7097                                 int extra4 = parameters_[whichParam(EXTRA4, numberParameters_, parameters_)].intValue();
     7099                                int extra4 = parameters_[whichParam(CBC_PARAM_INT_EXTRA4, numberParameters_, parameters_)].intValue();
    70987100                                if (extra4 >= 0) {
    70997101                                    int strategy = extra4 % 10;
     
    71047106                                    babModel_->setMoreSpecialOptions(extra4);
    71057107                                }
    7106                                 int moreMipOptions = parameters_[whichParam(MOREMIPOPTIONS, numberParameters_, parameters_)].intValue();
     7108                                int moreMipOptions = parameters_[whichParam(CBC_PARAM_INT_MOREMIPOPTIONS, numberParameters_, parameters_)].intValue();
    71077109                                if (moreMipOptions >= 0) {
    71087110                                    sprintf(generalPrint, "more mip options %d", moreMipOptions);
     
    71387140                            }
    71397141                            {
    7140                                 int extra1 = parameters_[whichParam(EXTRA1, numberParameters_, parameters_)].intValue();
     7142                                int extra1 = parameters_[whichParam(CBC_PARAM_INT_EXTRA1, numberParameters_, parameters_)].intValue();
    71417143                                if (extra1 != -1) {
    71427144                                    if (extra1 < 0) {
     
    71607162                                }
    71617163                            }
    7162                             if (type == BAB) {
     7164                            if (type == CBC_PARAM_ACTION_BAB) {
    71637165#if NEW_STYLE_SOLVER
    71647166                                {
     
    77927794                                            serendipity.setHeuristicName("linked");
    77937795                                            babModel_->addHeuristic(&serendipity);
    7794                                             double dextra3 = parameters_[whichParam(DEXTRA3, numberParameters_, parameters_)].doubleValue();
     7796                                            double dextra3 = parameters_[whichParam(CBC_PARAM_DBL_DEXTRA3, numberParameters_, parameters_)].doubleValue();
    77957797                                            if (dextra3)
    77967798                                                solver3->setMeshSizes(dextra3);
    7797                                             int options = parameters_[whichParam(MIPOPTIONS, numberParameters_, parameters_)].intValue() / 10000;
     7799                                            int options = parameters_[whichParam(CBC_PARAM_INT_MIPOPTIONS, numberParameters_, parameters_)].intValue() / 10000;
    77987800                                            CglStored stored;
    77997801                                            if (options) {
     
    78197821                                                    solver3->sayConvex((options&32) == 0);
    78207822                                                }
    7821                                                 int extra1 = parameters_[whichParam(EXTRA1, numberParameters_, parameters_)].intValue();
     7823                                                int extra1 = parameters_[whichParam(CBC_PARAM_INT_EXTRA1, numberParameters_, parameters_)].intValue();
    78227824                                                if ((options&1) != 0 && extra1 > 0)
    78237825                                                    solver3->setFixedPriority(extra1);
     
    78447846                                        }
    78457847                                        // For temporary testing of heuristics
    7846                                         //int testOsiOptions = parameters_[whichParam(TESTOSI,numberParameters_,parameters_)].intValue();
     7848                                        //int testOsiOptions = parameters_[whichParam(CBC_PARAM_INT_TESTOSI,numberParameters_,parameters_)].intValue();
    78477849                                        if (testOsiOptions >= 10) {
    78487850                                            if (testOsiOptions >= 20)
     
    78517853                                            OsiSolverLink * solver3 = dynamic_cast<OsiSolverLink *> (babModel_->solver());
    78527854                                            assert (solver3) ;
    7853                                             int extra1 = parameters_[whichParam(EXTRA1, numberParameters_, parameters_)].intValue();
     7855                                            int extra1 = parameters_[whichParam(CBC_PARAM_INT_EXTRA1, numberParameters_, parameters_)].intValue();
    78547856                                            solver3->setBiLinearPriority(extra1);
    78557857                                            printf("bilinear priority now %d\n", extra1);
    7856                                             int extra2 = parameters_[whichParam(EXTRA2, numberParameters_, parameters_)].intValue();
     7858                                            int extra2 = parameters_[whichParam(CBC_PARAM_INT_EXTRA2, numberParameters_, parameters_)].intValue();
    78577859                                            double saveDefault = solver3->defaultBound();
    78587860                                            solver3->setDefaultBound(static_cast<double> (extra2));
     
    81118113                                }
    81128114#ifdef CBC_THREAD
    8113                                 int numberThreads = parameters_[whichParam(THREADS, numberParameters_, parameters_)].intValue();
     8115                                int numberThreads = parameters_[whichParam(CBC_PARAM_INT_THREADS, numberParameters_, parameters_)].intValue();
    81148116                                babModel_->setNumberThreads(numberThreads % 100);
    81158117                                babModel_->setThreadMode(numberThreads / 100);
     
    81428144                                    babModel_->setFastNodeDepth(-1);
    81438145                                }
    8144                                 int heurOptions = parameters_[whichParam(HOPTIONS, numberParameters_, parameters_)].intValue();
     8146                                int heurOptions = parameters_[whichParam(CBC_PARAM_INT_HOPTIONS, numberParameters_, parameters_)].intValue();
    81458147                                if (heurOptions > 100)
    81468148                                    babModel_->setSpecialOptions(babModel_->specialOptions() | 8192);
     
    81488150#ifndef CBC_OTHER_SOLVER
    81498151#ifdef CLP_MULTIPLE_FACTORIZATIONS
    8150                                 int denseCode = parameters_[whichParam(DENSE, numberParameters_, parameters_)].intValue();
    8151                                 int smallCode = parameters_[whichParam(SMALLFACT, numberParameters_, parameters_)].intValue();
     8152                                int denseCode = parameters_[whichParam(CBC_PARAM_INT_DENSE, numberParameters_, parameters_)].intValue();
     8153                                int smallCode = parameters_[whichParam(CBC_PARAM_INT_SMALLFACT, numberParameters_, parameters_)].intValue();
    81528154                                if (bothFlags >= 1) {
    81538155                                    if (denseCode < 0)
     
    82298231                                exit(1);
    82308232#endif
    8231                                 int hOp1 = parameters_[whichParam(HOPTIONS, numberParameters_, parameters_)].intValue() / 100000;
     8233                                int hOp1 = parameters_[whichParam(CBC_PARAM_INT_HOPTIONS, numberParameters_, parameters_)].intValue() / 100000;
    82328234                                if (hOp1 % 10) {
    82338235                                    CbcCompareDefault compare;
     
    82398241                                    babModel_->solver()->messageHandler()->setLogLevel(0);
    82408242#endif
    8241                                 if (parameters_[whichParam(CPX, numberParameters_, parameters_)].currentOptionAsInteger()) {
     8243                                if (parameters_[whichParam(CBC_PARAM_STR_CPX, numberParameters_, parameters_)].currentOptionAsInteger()) {
    82428244                                    babModel_->setSpecialOptions(babModel_->specialOptions() | 16384);
    82438245                                    //if (babModel_->fastNodeDepth()==-1)
    82448246                                    babModel_->setFastNodeDepth(-2); // Use Cplex at root
    82458247                                }
    8246                                 int hOp2 = parameters_[whichParam(HOPTIONS, numberParameters_, parameters_)].intValue() / 10000;
     8248                                int hOp2 = parameters_[whichParam(CBC_PARAM_INT_HOPTIONS, numberParameters_, parameters_)].intValue() / 10000;
    82478249                                if (hOp2 % 10) {
    82488250                                    babModel_->setSpecialOptions(babModel_->specialOptions() | 16384);
     
    83518353#endif
    83528354                                checkSOS(babModel_, babModel_->solver());
    8353                             } else if (type == MIPLIB) {
     8355                            } else if (type == CBC_PARAM_ACTION_MIPLIB) {
    83548356                                int typeOfCuts = babModel_->numberCutGenerators() ? 1 : -1;
    83558357                                CbcStrategyDefault strategy(typeOfCuts,
     
    83628364                                babModel_->setStrategy(strategy);
    83638365#ifdef CBC_THREAD
    8364                                 int numberThreads = parameters_[whichParam(THREADS, numberParameters_, parameters_)].intValue();
     8366                                int numberThreads = parameters_[whichParam(CBC_PARAM_INT_THREADS, numberParameters_, parameters_)].intValue();
    83658367                                babModel_->setNumberThreads(numberThreads % 100);
    83668368                                babModel_->setThreadMode(numberThreads / 100);
     
    84108412                                   says -miplib
    84118413                                */
    8412                                 int extra2 = parameters_[whichParam(EXTRA2, numberParameters_, parameters_)].intValue();
     8414                                int extra2 = parameters_[whichParam(CBC_PARAM_INT_EXTRA2, numberParameters_, parameters_)].intValue();
    84138415                                double stuff[11];
    8414                                 stuff[0] = parameters_[whichParam(FAKEINCREMENT, numberParameters_, parameters_)].doubleValue();
    8415                                 stuff[1] = parameters_[whichParam(FAKECUTOFF, numberParameters_, parameters_)].doubleValue();
    8416                                 stuff[2] = parameters_[whichParam(DEXTRA3, numberParameters_, parameters_)].doubleValue();
    8417                                 stuff[3] = parameters_[whichParam(DEXTRA4, numberParameters_, parameters_)].doubleValue();
    8418                                 stuff[4] = parameters_[whichParam(DENSE, numberParameters_, parameters_)].intValue();
    8419                                 stuff[5] = parameters_[whichParam(EXTRA1, numberParameters_, parameters_)].intValue();
    8420                                 stuff[6] = parameters_[whichParam(EXTRA3, numberParameters_, parameters_)].intValue();
    8421                                 stuff[7] = parameters_[whichParam(DEPTHMINIBAB, numberParameters_, parameters_)].intValue();
     8416                                stuff[0] = parameters_[whichParam(CBC_PARAM_DBL_FAKEINCREMENT, numberParameters_, parameters_)].doubleValue();
     8417                                stuff[1] = parameters_[whichParam(CBC_PARAM_DBL_FAKECUTOFF, numberParameters_, parameters_)].doubleValue();
     8418                                stuff[2] = parameters_[whichParam(CBC_PARAM_DBL_DEXTRA3, numberParameters_, parameters_)].doubleValue();
     8419                                stuff[3] = parameters_[whichParam(CBC_PARAM_DBL_DEXTRA4, numberParameters_, parameters_)].doubleValue();
     8420                                stuff[4] = parameters_[whichParam(CBC_PARAM_INT_DENSE, numberParameters_, parameters_)].intValue();
     8421                                stuff[5] = parameters_[whichParam(CBC_PARAM_INT_EXTRA1, numberParameters_, parameters_)].intValue();
     8422                                stuff[6] = parameters_[whichParam(CBC_PARAM_INT_EXTRA3, numberParameters_, parameters_)].intValue();
     8423                                stuff[7] = parameters_[whichParam(CBC_PARAM_INT_DEPTHMINIBAB, numberParameters_, parameters_)].intValue();
    84228424                                stuff[8] = bothFlags;
    84238425                                stuff[9] = doVector;
    8424                                 stuff[10] = parameters_[whichParam(SMALLFACT, numberParameters_, parameters_)].intValue();
     8426                                stuff[10] = parameters_[whichParam(CBC_PARAM_INT_SMALLFACT, numberParameters_, parameters_)].intValue();
    84258427                                if ( dominatedCuts)
    84268428                                    model_.setSpecialOptions(model_.specialOptions() | 64);
    8427                                 if (parameters_[whichParam(CPX, numberParameters_, parameters_)].currentOptionAsInteger()) {
     8429                                if (parameters_[whichParam(CBC_PARAM_STR_CPX, numberParameters_, parameters_)].currentOptionAsInteger()) {
    84288430                                    model_.setSpecialOptions(model_.specialOptions() | 16384);
    84298431                                    //if (model_.fastNodeDepth()==-1)
    84308432                                    model_.setFastNodeDepth(-2); // Use Cplex at root
    84318433                                }
    8432                                 int hOp2 = parameters_[whichParam(HOPTIONS, numberParameters_, parameters_)].intValue() / 10000;
     8434                                int hOp2 = parameters_[whichParam(CBC_PARAM_INT_HOPTIONS, numberParameters_, parameters_)].intValue() / 10000;
    84338435                                if (hOp2 % 10) {
    84348436                                    model_.setSpecialOptions(model_.specialOptions() | 16384);
     
    85518553                                }
    85528554                            }
    8553                             if (babModel_->getMinimizationObjValue() < 1.0e50 && type == BAB) {
     8555                            if (babModel_->getMinimizationObjValue() < 1.0e50 && type == CBC_PARAM_ACTION_BAB) {
    85548556                                // post process
    85558557                                int n;
     
    87878789#endif
    87888790                                checkSOS(babModel_, babModel_->solver());
    8789                             } else if (model_.bestSolution() && type == BAB && model_.getMinimizationObjValue() < 1.0e50 && preProcess) {
     8791                            } else if (model_.bestSolution() && type == CBC_PARAM_ACTION_BAB && model_.getMinimizationObjValue() < 1.0e50 && preProcess) {
    87908792                                sprintf(generalPrint, "Restoring heuristic best solution of %g", model_.getMinimizationObjValue());
    87918793                                generalMessageHandler->message(CLP_GENERAL, generalMessages)
     
    88258827                            }
    88268828#ifndef CBC_OTHER_SOLVER
    8827                             //if (type==STRENGTHEN&&strengthenedModel)
     8829                            //if (type==CBC_PARAM_ACTION_STRENGTHEN&&strengthenedModel)
    88288830                            //clpSolver = dynamic_cast< OsiClpSolverInterface*> (strengthenedModel);
    88298831#ifdef COIN_HAS_ASL
     
    88408842                            }
    88418843#endif
    8842                             if (type == BAB) {
     8844                            if (type == CBC_PARAM_ACTION_BAB) {
    88438845#ifndef CBC_OTHER_SOLVER
    88448846                                //move best solution (should be there -- but ..)
     
    90289030                        }
    90299031                        break ;
    9030                     case IMPORT: {
     9032                    case CLP_PARAM_ACTION_IMPORT: {
    90319033#ifdef COIN_HAS_ASL
    90329034                        if (!statusUserFunction_[0]) {
     
    92099211                    }
    92109212                    break;
    9211                     case MODELIN:
     9213                    case CLP_PARAM_ACTION_MODELIN:
    92129214#ifndef CBC_OTHER_SOLVER
    92139215#ifdef COIN_HAS_LINK
     
    92769278                                // need some relative granularity
    92779279                                si->setDefaultBound(100.0);
    9278                                 double dextra3 = parameters_[whichParam(DEXTRA3, numberParameters_, parameters_)].doubleValue();
     9280                                double dextra3 = parameters_[whichParam(CBC_PARAM_DBL_DEXTRA3, numberParameters_, parameters_)].doubleValue();
    92799281                                if (dextra3)
    92809282                                    si->setDefaultMeshSize(dextra3);
     
    92969298#endif
    92979299                        break;
    9298                     case EXPORT:
     9300                    case CLP_PARAM_ACTION_EXPORT:
    92999301                        if (goodModel) {
    93009302                            // get next field
     
    93669368                                        pinfo.statistics();
    93679369                                    double presolveTolerance =
    9368                                         parameters_[whichParam(PRESOLVETOLERANCE, numberParameters_, parameters_)].doubleValue();
     9370                                        parameters_[whichParam(CLP_PARAM_DBL_PRESOLVETOLERANCE, numberParameters_, parameters_)].doubleValue();
    93699371                                    model2 =
    93709372                                        pinfo.presolvedModel(*lpSolver, presolveTolerance,
     
    94419443                        }
    94429444                        break;
    9443                     case BASISIN:
     9445                    case CLP_PARAM_ACTION_BASISIN:
    94449446                        if (goodModel) {
    94459447                            // get next field
     
    95009502                        }
    95019503                        break;
    9502                     case PRIORITYIN:
     9504                    case CBC_PARAM_ACTION_PRIORITYIN:
    95039505                        if (goodModel) {
    95049506                            // get next field
     
    97999801                        }
    98009802                        break;
    9801                     case DEBUG:
     9803                    case CLP_PARAM_ACTION_DEBUG:
    98029804                        if (goodModel) {
    98039805                            delete [] debugValues;
     
    98769878                        }
    98779879                        break;
    9878                     case PRINTMASK:
     9880                    case CLP_PARAM_ACTION_PRINTMASK:
    98799881                        // get next field
    98809882                    {
     
    98889890                    }
    98899891                    break;
    9890                     case BASISOUT:
     9892                    case CLP_PARAM_ACTION_BASISOUT:
    98919893                        if (goodModel) {
    98929894                            // get next field
     
    99379939                        }
    99389940                        break;
    9939                     case SAVE: {
     9941                    case CLP_PARAM_ACTION_SAVE: {
    99409942                        // get next field
    99419943                        field = CoinReadGetString(argc, argv);
     
    99809982                                ClpPresolve pinfo;
    99819983                                double presolveTolerance =
    9982                                     parameters_[whichParam(PRESOLVETOLERANCE, numberParameters_, parameters_)].doubleValue();
     9984                                    parameters_[whichParam(CLP_PARAM_DBL_PRESOLVETOLERANCE, numberParameters_, parameters_)].doubleValue();
    99839985                                model2 =
    99849986                                    pinfo.presolvedModel(*lpSolver, presolveTolerance,
     
    1001410016                    }
    1001510017                    break;
    10016                     case RESTORE: {
     10018                    case CLP_PARAM_ACTION_RESTORE: {
    1001710019                        // get next field
    1001810020                        field = CoinReadGetString(argc, argv);
     
    1006310065                    }
    1006410066                    break;
    10065                     case MAXIMIZE:
     10067                    case CLP_PARAM_ACTION_MAXIMIZE:
    1006610068                        lpSolver->setOptimizationDirection(-1);
    1006710069                        break;
    10068                     case MINIMIZE:
     10070                    case CLP_PARAM_ACTION_MINIMIZE:
    1006910071                        lpSolver->setOptimizationDirection(1);
    1007010072                        break;
    10071                     case ALLSLACK:
     10073                    case CLP_PARAM_ACTION_ALLSLACK:
    1007210074                        lpSolver->allSlackBasis(true);
    1007310075                        break;
    10074                     case REVERSE:
     10076                    case CLP_PARAM_ACTION_REVERSE:
    1007510077                        if (goodModel) {
    1007610078                            int iColumn;
     
    1009410096                        }
    1009510097                        break;
    10096                     case DIRECTORY: {
     10098                    case CLP_PARAM_ACTION_DIRECTORY: {
    1009710099                        std::string name = CoinReadGetString(argc, argv);
    1009810100                        if (name != "EOL") {
     
    1010910111                    }
    1011010112                    break;
    10111                     case DIRSAMPLE: {
     10113                    case CLP_PARAM_ACTION_DIRSAMPLE: {
    1011210114                        std::string name = CoinReadGetString(argc, argv);
    1011310115                        if (name != "EOL") {
     
    1012410126                    }
    1012510127                    break;
    10126                     case DIRNETLIB: {
     10128                    case CLP_PARAM_ACTION_DIRNETLIB: {
    1012710129                        std::string name = CoinReadGetString(argc, argv);
    1012810130                        if (name != "EOL") {
     
    1013910141                    }
    1014010142                    break;
    10141                     case DIRMIPLIB: {
     10143                    case CBC_PARAM_ACTION_DIRMIPLIB: {
    1014210144                        std::string name = CoinReadGetString(argc, argv);
    1014310145                        if (name != "EOL") {
     
    1015410156                    }
    1015510157                    break;
    10156                     case STDIN:
     10158                    case CLP_PARAM_ACTION_STDIN:
    1015710159                        CbcOrClpRead_mode = -1;
    1015810160                        break;
    10159                     case NETLIB_DUAL:
    10160                     case NETLIB_EITHER:
    10161                     case NETLIB_BARRIER:
    10162                     case NETLIB_PRIMAL:
    10163                     case NETLIB_TUNE: {
     10161                    case CLP_PARAM_ACTION_NETLIB_DUAL:
     10162                    case CLP_PARAM_ACTION_NETLIB_EITHER:
     10163                    case CLP_PARAM_ACTION_NETLIB_BARRIER:
     10164                    case CLP_PARAM_ACTION_NETLIB_PRIMAL:
     10165                    case CLP_PARAM_ACTION_NETLIB_TUNE: {
    1016410166                        printf("unit test is now only from clp - does same thing\n");
    1016510167                        //return(22);
    1016610168                    }
    1016710169                    break;
    10168                     case UNITTEST: {
     10170                    case CLP_PARAM_ACTION_UNITTEST: {
    1016910171                        CbcClpUnitTest(model_, dirSample, -2, NULL);
    1017010172                    }
    1017110173                    break;
    10172                     case FAKEBOUND:
     10174                    case CLP_PARAM_ACTION_FAKEBOUND:
    1017310175                        if (goodModel) {
    1017410176                            // get bound
     
    1020810210                        }
    1020910211                        break;
    10210                     case REALLY_SCALE:
     10212                    case CLP_PARAM_ACTION_REALLY_SCALE:
    1021110213                        if (goodModel) {
    1021210214                            ClpSimplex newModel(*lpSolver,
     
    1021610218                        }
    1021710219                        break;
    10218                     case USERCLP:
     10220                    case CLP_PARAM_ACTION_USERCLP:
    1021910221#ifdef USER_HAS_FAKE_CLP
    1022010222                        // Replace the sample code by whatever you want
     
    1022610228                            double timeToGo = model_.getMaximumSeconds();
    1022710229                            lpSolver->setMaximumSeconds(timeToGo);
    10228                             int extra1 = parameters_[whichParam(EXTRA1, numberParameters_, parameters_)].intValue();
     10230                            int extra1 = parameters_[whichParam(CBC_PARAM_INT_EXTRA1, numberParameters_, parameters_)].intValue();
    1022910231                            fakeMain2(*lpSolver, *clpSolver, extra1);
    1023010232                            lpSolver = clpSolver->getModelPtr();
     
    1025810260#endif
    1025910261                        break;
    10260                     case USERCBC:
     10262                    case CBC_PARAM_ACTION_USERCBC:
    1026110263#ifdef USER_HAS_FAKE_CBC
    1026210264                        // Replace the sample code by whatever you want
     
    1034010342#endif
    1034110343                        break;
    10342                     case HELP:
     10344                    case CLP_PARAM_ACTION_HELP:
    1034310345                        std::cout << "Coin Solver version " << CBCVERSION
    1034410346                                  << ", build " << __DATE__ << std::endl;
     
    1035710359                        );
    1035810360                        break;
    10359                     case CSVSTATISTICS: {
     10361                    case CLP_PARAM_ACTION_CSVSTATISTICS: {
    1036010362                        // get next field
    1036110363                        field = CoinReadGetString(argc, argv);
     
    1043710439                    }
    1043810440                    break;
    10439                     case SOLUTION:
     10441                    case CLP_PARAM_ACTION_SOLUTION:
    1044010442                        if (goodModel) {
    1044110443                            // get next field
     
    1078110783                        }
    1078210784                        break;
    10783                     case SAVESOL:
     10785                    case CLP_PARAM_ACTION_SAVESOL:
    1078410786                        if (goodModel) {
    1078510787                            // get next field
     
    1081510817                        }
    1081610818                        break;
    10817                     case DUMMY:
     10819                    case CLP_PARAM_ACTION_DUMMY:
    1081810820                        break;
    10819                     case ENVIRONMENT:
     10821                    case CLP_PARAM_ACTION_ENVIRONMENT:
    1082010822                        CbcOrClpEnvironmentIndex = 0;
    1082110823                        break;
  • branches/sandbox/Cbc/src/ClpAmplStuff.cpp

    r1361 r1373  
    186186                    printing = true;
    187187                    info_.logLevel = atoi(equals + 1);
    188                     control->setIntValue(LOGLEVEL, info_.logLevel);
     188                    control->setIntValue(CLP_PARAM_INT_LOGLEVEL, info_.logLevel);
    189189                    // mark so won't be overWritten
    190190                    info_.numberRows = -1234567;
     
    237237            // need some relative granularity
    238238            si->setDefaultBound(100.0);
    239             double dextra3 = control->doubleValue(DEXTRA3);
     239            double dextra3 = control->doubleValue(CBC_PARAM_DBL_DEXTRA3);
    240240            if (dextra3)
    241241                si->setDefaultMeshSize(dextra3);
     
    244244            si->setBiLinearPriority(10000);
    245245            CoinModel * model2 = (CoinModel *) coinModel;
    246             int logLevel = control->intValue(LOGLEVEL);
     246            int logLevel = control->intValue(CLP_PARAM_INT_LOGLEVEL);
    247247            si->load(*model2, true, logLevel);
    248248            // redo
     
    250250            lpSolver = solver->getModelPtr();
    251251            solver->messageHandler()->setLogLevel(0) ;
    252             control->setIntValue(TESTOSI, 0);
     252            control->setIntValue(CBC_PARAM_INT_TESTOSI, 0);
    253253            if (info_.cut) {
    254254                printf("Sorry - can't do cuts with LOS as ruins delicate row order\n");
Note: See TracChangeset for help on using the changeset viewer.