/** constraint display method of constraint handler */
static
SCIP_DECL_CONSPRINT(consPrintConjunction)
{ /*lint --e{715}*/
SCIP_CONSDATA* consdata;
int i;
assert( scip != NULL );
assert( conshdlr != NULL );
assert( cons != NULL );
consdata = SCIPconsGetData(cons);
assert(consdata != NULL);
SCIPinfoMessage(scip, file, "conjunction(");
for( i = 0; i < consdata->nconss; ++i )
{
if( i > 0 )
SCIPinfoMessage(scip, file, ", ");
SCIP_CALL( SCIPprintCons(scip, consdata->conss[i], file) );
}
SCIPinfoMessage(scip, file, ")");
return SCIP_OKAY;
}
/** output method of display column to output file stream 'file' */
static
SCIP_DECL_DISPOUTPUT(SCIPdispOutputGap)
{ /*lint --e{715}*/
SCIP_Real gap;
assert(disp != NULL);
assert(strcmp(SCIPdispGetName(disp), DISP_NAME_GAP) == 0);
assert(scip != NULL);
gap = SCIPgetGap(scip);
if( SCIPisInfinity(scip, gap) )
SCIPinfoMessage(scip, file, " Inf ");
else if( gap >= 100.00 )
SCIPinfoMessage(scip, file, " Large ");
else
SCIPinfoMessage(scip, file, "%7.2f%%", 100.0*gap);
if( SCIPgetNNodesLeft(scip) > 0
|| SCIPisZero(scip, gap) )
{
SCIP_CALL( SCIPsetIntParam(scip, "display/verblevel", 0) );
}
return SCIP_OKAY;
}
/** output method of display column to output file stream 'file' */
static
SCIP_DECL_DISPOUTPUT(SCIPdispOutputSolfound)
{ /*lint --e{715}*/
SCIP* origprob;
SCIP_SOL* sol;
SCIP_DISPDATA* dispdata;
/* get original problem */
origprob = GCGpricerGetOrigprob(scip);
assert(origprob != NULL);
assert(disp != NULL);
assert(strcmp(SCIPdispGetName(disp), DISP_NAME_SOLFOUND) == 0);
assert(scip != NULL);
sol = SCIPgetBestSol(scip);
if( sol == NULL )
SCIPdispSetData(disp, NULL);
dispdata = SCIPdispGetData(disp);
if( sol != (SCIP_SOL*)dispdata )
{
SCIPinfoMessage(scip, file, "%c%c",
GCGrelaxGetProbingheur(origprob) == NULL ? '*' : SCIPheurGetDispchar(GCGrelaxGetProbingheur(origprob)),
SCIPgetSolHeur(scip, sol) == NULL ? '*' : SCIPheurGetDispchar(SCIPgetSolHeur(scip, sol)));
SCIPdispSetData(disp, (SCIP_DISPDATA*)sol);
}
else
SCIPinfoMessage(scip, file, " ");
return SCIP_OKAY;
}
/** create linear ordering problem instance */
SCIP_RETCODE LOPcreateProb(
SCIP* scip, /**< SCIP data structure */
const char* filename /**< name of file to read */
)
{
SCIP_PROBDATA* probdata = NULL;
char probname[SCIP_MAXSTRLEN];
/* allocate memory */
SCIP_CALL( SCIPallocMemory(scip, &probdata) );
/* take filename as problem name */
SCIP_CALL( getProblemName(filename, probname, SCIP_MAXSTRLEN) );
SCIPinfoMessage(scip, NULL, "File name:\t\t%s\n", filename);
SCIPinfoMessage(scip, NULL, "Problem name:\t\t%s\n", probname);
/* read file */
SCIP_CALL( LOPreadFile(scip, filename, probdata) );
probdata->vars = NULL;
SCIP_CALL( SCIPcreateProb(scip, probname, probdelorigLOP, NULL, NULL,
NULL, NULL, probcopyLOP, probdata) );
return SCIP_OKAY;
}
/** prints vardata to file stream */
void SCIPvardataPrint(
SCIP* scip, /**< SCIP data structure */
SCIP_VARDATA* vardata, /**< variable data */
FILE* file /**< the text file to store the information into */
)
{
SCIP_PROBDATA* probdata;
int* ids;
int i;
probdata = SCIPgetProbData(scip);
assert(probdata != NULL);
ids = SCIPprobdataGetIds(probdata);
assert(ids != NULL);
SCIPinfoMessage(scip, file, "consids = {");
for( i = 0; i < vardata->nconsids; ++i )
{
SCIPinfoMessage(scip, file, "%d->%d", ids[vardata->consids[i]], vardata->consids[i]);
if( i < vardata->nconsids - 1 )
SCIPinfoMessage(scip, file, ",");
}
SCIPinfoMessage(scip, file, "}\n");
}
/** prints vardata to file stream */
void SCIPvardataPrint(
SCIP* scip, /**< SCIP data structure */
SCIP_VARDATA* vardata, /**< variable data */
FILE* file /**< the text file to store the information into */
)
{
int i;
SCIPinfoMessage(scip, file, "consids = {");
for( i = 0; i < vardata->nconsids; ++i )
{
SCIPinfoMessage(scip, file, "%d", vardata->consids[i]);
if( i < vardata->nconsids - 1 )
SCIPinfoMessage(scip, file, ",");
}
SCIPinfoMessage(scip, file, "}\n");
SCIPinfoMessage(scip, file, "oriFlowVars = {");
for(i = 0; i < vardata->nOriFlowVars; i++)
{
SCIPinfoMessage(scip, file, "%d", vardata->oriFlowVars[i]);
if(i < vardata->nOriFlowVars)
SCIPinfoMessage(scip, file, ",");
}
SCIPinfoMessage(scip, file, "}\n");
}
/** output method of display column to output file stream 'file' */
static
SCIP_DECL_DISPOUTPUT(SCIPdispOutputNsols)
{ /*lint --e{715}*/
SCIPinfoMessage(scip, file, "%5"SCIP_LONGINT_FORMAT, SCIPgetNSolsFound(GCGpricerGetOrigprob(scip)));
return SCIP_OKAY;
}
/** execution method of event handler */
static
SCIP_DECL_EVENTEXEC(eventExecSofttimelimit)
{ /*lint --e{715}*/
SCIP_EVENTHDLRDATA* eventhdlrdata;
assert(eventhdlr != NULL);
assert(strcmp(SCIPeventhdlrGetName(eventhdlr), EVENTHDLR_NAME) == 0);
assert(event != NULL);
assert(scip != NULL);
assert(SCIPeventGetType(event) == SCIP_EVENTTYPE_BESTSOLFOUND);
eventhdlrdata = SCIPeventhdlrGetData(eventhdlr);
assert(eventhdlrdata != NULL);
SCIPdebugMessage("exec method of event handler for soft time limit\n");
SCIP_CALL( SCIPsetRealParam(scip, "limits/time", eventhdlrdata->softtimelimit) );
/* notify SCIP that your event handler wants to drop the event type best solution found */
SCIP_CALL( SCIPdropEvent(scip, SCIP_EVENTTYPE_BESTSOLFOUND, eventhdlr, NULL, eventhdlrdata->filterpos) );
eventhdlrdata->filterpos = -1;
/* print best solution value */
SCIPinfoMessage(scip, NULL, "changed time limit to %.1f after first solution was found\n",
eventhdlrdata->softtimelimit);
return SCIP_OKAY;
}
/** read in parameter file */
static
SCIP_RETCODE readParams(
SCIP* scip, /**< SCIP data structure */
const char* filename /**< parameter file name */
)
{
if( SCIPfileExists(filename) )
{
SCIPinfoMessage(scip, NULL, "reading user parameter file <%s>\n", filename);
SCIP_CALL( SCIPreadParams(scip, filename) );
}
else
SCIPinfoMessage(scip, NULL, "user parameter file <%s> not found - using default parameters\n", filename);
return SCIP_OKAY;
}
/** output method of display column to output file stream 'file' */
static
SCIP_DECL_DISPOUTPUT(SCIPdispOutputLpavgiters)
{ /*lint --e{715}*/
assert(disp != NULL);
assert(strcmp(SCIPdispGetName(disp), DISP_NAME_LPAVGITERS) == 0);
assert(scip != NULL);
if( SCIPgetNNodes(scip) < 2 )
SCIPinfoMessage(scip, file, " - ");
else
SCIPinfoMessage(scip, file, "%6.1f ",
(SCIPgetNLPIterations(scip) - SCIPgetNRootLPIterations(scip))
/ (SCIP_Real)(SCIPgetNNodes(scip) - 1) );
return SCIP_OKAY;
}
/** output method of display column to output file stream 'file' */
static
SCIP_DECL_DISPOUTPUT(SCIPdispOutputCutoffbound)
{ /*lint --e{715}*/
SCIP_Real cutoffbound;
assert(disp != NULL);
assert(strcmp(SCIPdispGetName(disp), DISP_NAME_CUTOFFBOUND) == 0);
assert(scip != NULL);
cutoffbound = SCIPgetCutoffbound(GCGpricerGetOrigprob(scip));
if( SCIPisInfinity(scip, REALABS(cutoffbound)) )
SCIPinfoMessage(scip, file, " -- ");
else
SCIPinfoMessage(scip, file, "%13.6e ", SCIPretransformObj(GCGpricerGetOrigprob(scip), cutoffbound));
return SCIP_OKAY;
}
/** output method of display column to output file stream 'file' */
static
SCIP_DECL_DISPOUTPUT(SCIPdispOutputAvgdualbound)
{ /*lint --e{715}*/
SCIP_Real avgdualbound;
assert(disp != NULL);
assert(strcmp(SCIPdispGetName(disp), DISP_NAME_AVGDUALBOUND) == 0);
assert(scip != NULL);
avgdualbound = SCIPgetAvgDualbound(GCGpricerGetOrigprob(scip));
if( SCIPisInfinity(scip, REALABS(avgdualbound)) )
SCIPinfoMessage(scip, file, " -- ");
else
SCIPinfoMessage(scip, file, "%13.6e ", avgdualbound);
return SCIP_OKAY;
}
/** output method of display column to output file stream 'file' */
static
SCIP_DECL_DISPOUTPUT(SCIPdispOutputEstimate)
{ /*lint --e{715}*/
SCIP_Real estimate;
assert(disp != NULL);
assert(strcmp(SCIPdispGetName(disp), DISP_NAME_ESTIMATE) == 0);
assert(scip != NULL);
estimate = SCIPgetLocalOrigEstimate(GCGpricerGetOrigprob(scip));
if( SCIPisInfinity(scip, REALABS(estimate)) )
SCIPinfoMessage(scip, file, " -- ");
else
SCIPinfoMessage(scip, file, "%13.6e ", estimate);
return SCIP_OKAY;
}
/** output method of display column to output file stream 'file' */
static
SCIP_DECL_DISPOUTPUT(SCIPdispOutputLpobj)
{ /*lint --e{715}*/
SCIP_Real lpobj;
assert(disp != NULL);
assert(strcmp(SCIPdispGetName(disp), DISP_NAME_LPOBJ) == 0);
assert(scip != NULL);
lpobj = SCIPgetLPObjval(scip);
if( SCIPisInfinity(scip, REALABS(lpobj)) )
SCIPinfoMessage(scip, file, " -- ");
else
SCIPinfoMessage(scip, file, "%13.6e ", lpobj);
return SCIP_OKAY;
}
/** output method of display column to output file stream 'file' */
static
SCIP_DECL_DISPOUTPUT(SCIPdispOutputPrimalbound)
{ /*lint --e{715}*/
SCIP_Real primalbound;
assert(disp != NULL);
assert(strcmp(SCIPdispGetName(disp), DISP_NAME_PRIMALBOUND) == 0);
assert(scip != NULL);
primalbound = SCIPgetPrimalbound(scip);
if( SCIPisInfinity(scip, REALABS(primalbound)) )
SCIPinfoMessage(scip, file, " -- ");
else
SCIPinfoMessage(scip, file, "%13.6e%c", SCIPretransformObj(GCGpricerGetOrigprob(scip), primalbound),
SCIPisPrimalboundSol(scip) ? ' ' : '*');
return SCIP_OKAY;
}
/** output method of display column to output file stream 'file' */
static
SCIP_DECL_DISPOUTPUT(SCIPdispOutputNfrac)
{ /*lint --e{715}*/
assert(disp != NULL);
assert(strcmp(SCIPdispGetName(disp), DISP_NAME_NFRAC) == 0);
assert(scip != NULL);
if( SCIPhasCurrentNodeLP(scip) && SCIPgetLPSolstat(scip) == SCIP_LPSOLSTAT_OPTIMAL )
SCIPdispInt(SCIPgetMessagehdlr(scip), file, SCIPgetNLPBranchCands(scip), DISP_WIDT_NFRAC);
else
SCIPinfoMessage(scip, file, " - ");
return SCIP_OKAY;
}
/** ends the given line with '\\0' and prints it to the given file stream */
static
void endLine(
SCIP* scip, /**< SCIP data structure */
FILE* file, /**< output file (or NULL for standard output) */
SCIP_READERDATA* readerdata, /**< information for reader */
char* linebuffer, /**< line */
int* linecnt /**< number of characters in line */
)
{
assert( scip != NULL );
assert( linebuffer != NULL );
assert( linecnt != NULL );
if( (*linecnt) > 0 )
{
linebuffer[(*linecnt)] = '\0';
if(readerdata->rgb_ascii)
SCIPinfoMessage(scip, file, "%s", linebuffer);
else
SCIPinfoMessage(scip, file, "%s\n", linebuffer);
clearLine(linebuffer, linecnt);
}
}
/** display constraints */
static
void consdataPrint(
SCIP* scip, /**< SCIP data structure */
SCIP_CONSDATA* consdata, /**< constraint data */
FILE* file /**< file stream */
)
{
SCIP_PROBDATA* probdata;
int* ids;
probdata = SCIPgetProbData(scip);
assert(probdata != NULL);
ids = SCIPprobdataGetIds(probdata);
assert(ids != NULL);
SCIPinfoMessage(scip, file, "%s(%d,%d) at node %d\n",
consdata->type == SAME ? "same" : "diff",
ids[consdata->itemid1], ids[consdata->itemid2], SCIPnodeGetNumber(consdata->node) );
}
/** checks all constraints in conjunction constraints for feasibility */
static
SCIP_RETCODE checkAllConss(
SCIP* scip, /**< SCIP data structure */
SCIP_CONS** conss, /**< active conjunction constraints */
int nconss, /**< number of active conjunction constraints */
SCIP_SOL* sol, /**< solution to check */
SCIP_Bool checkintegrality, /**< has integrality to be checked? */
SCIP_Bool checklprows, /**< have current LP rows to be checked? */
SCIP_Bool printreason, /**< should the reason for the violation be printed? */
SCIP_RESULT* result /**< pointer to store the result */
)
{
SCIP_CONSDATA* consdata;
int c;
int i;
assert(result != NULL);
for( c = 0; c < nconss && *result == SCIP_FEASIBLE; ++c )
{
consdata = SCIPconsGetData(conss[c]);
assert(consdata != NULL);
/* check all constraints */
for( i = 0; i < consdata->nconss && *result == SCIP_FEASIBLE; ++i )
{
SCIP_CALL( SCIPcheckCons(scip, consdata->conss[i], sol, checkintegrality, checklprows, printreason, result) );
assert(*result == SCIP_FEASIBLE || *result == SCIP_INFEASIBLE);
}
if( printreason && *result == SCIP_INFEASIBLE )
{
SCIPinfoMessage(scip, NULL, "conjunction constraint %s is violated, at least the sub-constraint %s is violated by this given solution\n", SCIPconsGetName(conss[c]), SCIPconsGetName(consdata->conss[i-1]));
SCIPdebug( SCIP_CALL( SCIPprintCons(scip, conss[c], NULL) ) );
}
}
return SCIP_OKAY;
}
/** execution method of event handler */
static
SCIP_DECL_EVENTEXEC(eventExecBestsol)
{ /*lint --e{715}*/
SCIP_SOL* bestsol;
SCIP_Real solvalue;
assert(eventhdlr != NULL);
assert(strcmp(SCIPeventhdlrGetName(eventhdlr), EVENTHDLR_NAME) == 0);
assert(event != NULL);
assert(scip != NULL);
assert(SCIPeventGetType(event) == SCIP_EVENTTYPE_BESTSOLFOUND);
SCIPdebugMessage("exec method of event handler for best solution found\n");
bestsol = SCIPgetBestSol(scip);
assert(bestsol != NULL);
solvalue = SCIPgetSolOrigObj(scip, bestsol);
/* print best solution value */
SCIPinfoMessage(scip, NULL, "found new best solution with solution value <%g> in SCIP <%s>\n",
solvalue, SCIPgetProbName(scip) );
return SCIP_OKAY;
}
/** problem writing method of reader */
static
SCIP_DECL_READERWRITE(readerWriteCip)
{ /*lint --e{715}*/
SCIP_HASHTABLE* varhash = NULL;
SCIP_READERDATA* readerdata;
int i;
assert(reader != NULL);
assert(strcmp(SCIPreaderGetName(reader), READER_NAME) == 0);
SCIPinfoMessage(scip, file, "STATISTICS\n");
SCIPinfoMessage(scip, file, " Problem name : %s\n", name);
SCIPinfoMessage(scip, file, " Variables : %d (%d binary, %d integer, %d implicit integer, %d continuous)\n",
nvars, nbinvars, nintvars, nimplvars, ncontvars);
SCIPinfoMessage(scip, file, " Constraints : %d initial, %d maximal\n", startnconss, maxnconss);
SCIPinfoMessage(scip, file, "OBJECTIVE\n");
SCIPinfoMessage(scip, file, " Sense : %s\n", objsense == SCIP_OBJSENSE_MINIMIZE ? "minimize" : "maximize");
if( !SCIPisZero(scip, objoffset) )
SCIPinfoMessage(scip, file, " Offset : %+.15g\n", objoffset);
if( !SCIPisEQ(scip, objscale, 1.0) )
SCIPinfoMessage(scip, file, " Scale : %.15g\n", objscale);
if ( nfixedvars > 0 )
{
/* set up hash table for variables that have been written property (used for writing out fixed vars in the right order) */
SCIP_CALL( SCIPhashtableCreate(&varhash, SCIPblkmem(scip), SCIPcalcHashtableSize(10 * (nvars + nfixedvars)), hashGetKeyVar, hashKeyEqVar, hashKeyValVar, NULL) );
}
if ( nvars + nfixedvars > 0 )
{
SCIPinfoMessage(scip, file, "VARIABLES\n");
}
if( nvars > 0 )
{
for( i = 0; i < nvars; ++i )
{
SCIP_VAR* var;
var = vars[i];
assert( var != NULL );
SCIP_CALL( SCIPprintVar(scip, var, file) );
if ( varhash != NULL )
{
/* add free variable to hashtable */
if ( ! SCIPhashtableExists(varhash, (void*) var) )
{
SCIP_CALL( SCIPhashtableInsert(varhash, (void*) var) );
}
}
}
}
readerdata = SCIPreaderGetData(reader);
assert(readerdata != NULL);
if( readerdata->writefixedvars && nfixedvars > 0 )
{
int nwritten = 0;
SCIPinfoMessage(scip, file, "FIXED\n");
/* loop through variables until each has been written after the variables that it depends on have been written; this
* requires several runs over the variables, but the depth (= number of loops) is usually small. */
while ( nwritten < nfixedvars )
{
SCIPdebugMessage("written %d of %d fixed variables.\n", nwritten, nfixedvars);
for (i = 0; i < nfixedvars; ++i)
{
SCIP_VAR* var;
SCIP_VAR* tmpvar;
var = fixedvars[i];
assert( var != NULL );
/* skip variables already written */
if ( SCIPhashtableExists(varhash, (void*) var) )
continue;
switch ( SCIPvarGetStatus(var) )
{
case SCIP_VARSTATUS_FIXED:
/* fixed variables can simply be output and added to the hashtable */
SCIP_CALL( SCIPprintVar(scip, var, file) );
assert( ! SCIPhashtableExists(varhash, (void*) var) );
SCIP_CALL( SCIPhashtableInsert(varhash, (void*) var) );
++nwritten;
break;
case SCIP_VARSTATUS_NEGATED:
tmpvar = SCIPvarGetNegationVar(var);
assert( tmpvar != NULL );
assert( var == SCIPvarGetNegatedVar(tmpvar) );
/* if the negated variable has been written, we can write the current variable */
if ( SCIPhashtableExists(varhash, (void*) tmpvar) )
{
SCIP_CALL( SCIPprintVar(scip, var, file) );
assert( ! SCIPhashtableExists(varhash, (void*) var) );
SCIP_CALL( SCIPhashtableInsert(varhash, (void*) var) );
++nwritten;
}
break;
case SCIP_VARSTATUS_AGGREGATED:
tmpvar = SCIPvarGetAggrVar(var);
assert( tmpvar != NULL );
/* if the aggregating variable has been written, we can write the current variable */
if ( SCIPhashtableExists(varhash, (void*) tmpvar) )
{
SCIP_CALL( SCIPprintVar(scip, var, file) );
assert( ! SCIPhashtableExists(varhash, (void*) var) );
SCIP_CALL( SCIPhashtableInsert(varhash, (void*) var) );
++nwritten;
}
break;
case SCIP_VARSTATUS_MULTAGGR:
{
SCIP_VAR** aggrvars;
int naggrvars;
int j;
/* get the active representation */
SCIP_CALL( SCIPflattenVarAggregationGraph(scip, var) );
naggrvars = SCIPvarGetMultaggrNVars(var);
aggrvars = SCIPvarGetMultaggrVars(var);
assert(aggrvars != NULL || naggrvars == 0);
for (j = 0; j < naggrvars; ++j)
{
if( !SCIPhashtableExists(varhash, (void*) aggrvars[j]) ) /*lint !e613*/
break;
}
/* if all multi-aggregating variables have been written, we can write the current variable */
if ( j >= naggrvars )
{
SCIP_CALL( SCIPprintVar(scip, var, file) );
assert( ! SCIPhashtableExists(varhash, (void*) var) );
SCIP_CALL( SCIPhashtableInsert(varhash, (void*) var) );
++nwritten;
}
break;
}
case SCIP_VARSTATUS_ORIGINAL:
case SCIP_VARSTATUS_LOOSE:
case SCIP_VARSTATUS_COLUMN:
SCIPerrorMessage("Only fixed variables are allowed to be present in fixedvars list.\n");
SCIPABORT();
return SCIP_ERROR; /*lint !e527*/
}
}
}
}
if( nconss > 0 )
{
SCIPinfoMessage(scip, file, "CONSTRAINTS\n");
for( i = 0; i < nconss; ++i )
{
SCIP_CALL( SCIPprintCons(scip, conss[i], file) );
SCIPinfoMessage(scip, file, ";\n");
}
}
SCIPinfoMessage(scip, file, "END\n");
*result = SCIP_SUCCESS;
if( nfixedvars > 0 )
SCIPhashtableFree(&varhash);
else
assert(varhash == NULL);
return SCIP_OKAY;
}
static
SCIP_RETCODE fromCommandLine(
SCIP* scip, /**< SCIP data structure */
const char* filename /**< input file name */
)
{
SCIP_RETCODE retcode;
/********************
* Problem Creation *
********************/
/** @note The message handler should be only fed line by line such the message has the chance to add string in front
* of each message
*/
SCIPinfoMessage(scip, NULL, "\n");
SCIPinfoMessage(scip, NULL, "read problem <%s>\n", filename);
SCIPinfoMessage(scip, NULL, "============\n");
SCIPinfoMessage(scip, NULL, "\n");
retcode = SCIPreadProb(scip, filename, NULL);
switch( retcode )
{
case SCIP_NOFILE:
SCIPinfoMessage(scip, NULL, "file <%s> not found\n", filename);
return SCIP_OKAY;
case SCIP_PLUGINNOTFOUND:
SCIPinfoMessage(scip, NULL, "no reader for input file <%s> available\n", filename);
return SCIP_OKAY;
case SCIP_READERROR:
SCIPinfoMessage(scip, NULL, "error reading file <%s>\n", filename);
return SCIP_OKAY;
default:
SCIP_CALL( retcode );
} /*lint !e788*/
/*******************
* Problem Solving *
*******************/
/* solve problem */
SCIPinfoMessage(scip, NULL, "\nsolve problem\n");
SCIPinfoMessage(scip, NULL, "=============\n\n");
SCIP_CALL( SCIPsolve(scip) );
SCIPinfoMessage(scip, NULL, "\nprimal solution:\n");
SCIPinfoMessage(scip, NULL, "================\n\n");
SCIP_CALL( SCIPprintBestSol(scip, NULL, FALSE) );
/**************
* Statistics *
**************/
SCIPinfoMessage(scip, NULL, "\nStatistics\n");
SCIPinfoMessage(scip, NULL, "==========\n\n");
SCIP_CALL( SCIPprintStatistics(scip, NULL) );
return SCIP_OKAY;
}
/** read weight matrix from file (in LOLIB format)
*
* Format:
* comment line
* # of elements
* weight matrix (doubles)
*/
static
SCIP_RETCODE LOPreadFile(
SCIP* scip, /**< SCIP data structure */
const char* filename, /**< name of file to read */
SCIP_PROBDATA* probdata /**< problem data to be filled */
)
{
int i, j;
FILE *file;
int status;
int n;
SCIP_Real** W;
char s[SCIP_MAXSTRLEN];
/* open file */
file = fopen(filename, "r");
if ( file == NULL )
{
SCIPerrorMessage("Could not open file <%s>.\n", filename);
return SCIP_NOFILE;
}
/* skip one line */
if ( fgets(s, SCIP_MAXSTRLEN, file) == NULL )
{
SCIPerrorMessage("Error reading file <%s>.\n", filename);
return SCIP_READERROR;
}
/* read number of elements */
status = fscanf(file, "%d", &n);
if ( ! status )
{
SCIPerrorMessage("Reading failed.\n");
return SCIP_READERROR;
}
assert( 0 < n );
SCIPinfoMessage(scip, NULL, "Number of elements:\t%d\n\n", n);
probdata->n = n;
/* set up matrix */
SCIP_CALL( SCIPallocMemoryArray(scip, &W, n) );
for (i = 0; i < n; ++i)
SCIP_CALL( SCIPallocMemoryArray(scip, &(W[i]), n) ); /*lint !e866*/
probdata->W = W;
/* read matrix */
for (i = 0; i < n; ++i)
{
for (j = 0; j < n; ++j)
{
SCIP_Real val;
status = fscanf(file, "%lf", &val);
if ( ! status )
{
SCIPerrorMessage("Reading failed.\n");
return SCIP_READERROR;
}
W[i][j] = val;
}
}
fclose( file );
return SCIP_OKAY;
}
/** runs GCG from the command line */
static
SCIP_RETCODE fromCommandLine(
SCIP* scip, /**< SCIP data structure */
const char* filename, /**< input file name */
const char* decname /**< decomposition file name (or NULL) */
)
{
SCIP_RESULT result = SCIP_DIDNOTRUN;
/********************
* Problem Creation *
********************/
SCIPinfoMessage(scip, NULL, "\nread problem <%s>\n", filename);
SCIPinfoMessage(scip, NULL, "============\n\n");
SCIP_CALL( SCIPreadProb(scip, filename, NULL) );
SCIP_CALL( SCIPtransformProb(scip) );
if( decname != NULL )
{
SCIPinfoMessage(scip, NULL, "\nread decomposition <%s>\n", decname);
SCIPinfoMessage(scip, NULL, "==================\n\n");
SCIP_CALL( SCIPreadProb(scip, decname, NULL) );
SCIP_CALL( SCIPsetIntParam(scip, "presolving/maxrounds", 0) );
}
else
{
SCIP_CALL( SCIPpresolve(scip) );
SCIP_CALL( DECdetectStructure(scip, &result) );
}
/*******************
* Problem Solving *
*******************/
if( decname == NULL && result != SCIP_SUCCESS )
{
SCIPinfoMessage(scip, NULL, "No decomposition exists or could be detected. You need to specify one.\n");
return SCIP_OKAY;
}
/* solve problem */
SCIPinfoMessage(scip, NULL, "\nsolve problem\n");
SCIPinfoMessage(scip, NULL, "=============\n\n");
SCIP_CALL( SCIPsolve(scip) );
SCIPinfoMessage(scip, NULL, "\nprimal solution:\n");
SCIPinfoMessage(scip, NULL, "================\n\n");
SCIP_CALL( SCIPprintBestSol(scip, NULL, FALSE) );
/**************
* Statistics *
**************/
SCIPinfoMessage(scip, NULL, "\nStatistics\n");
SCIPinfoMessage(scip, NULL, "==========\n\n");
SCIP_CALL( SCIPprintStatistics(scip, NULL) );
return SCIP_OKAY;
}
/** prints the given variable: name, type (original, master or pricing) block number,
* and the list of all variables related to the given variable
*/
void GCGrelaxPrintVar(
SCIP* scip, /**< SCIP data structure */
FILE* file, /**< File to write information to, or NULL for stdout */
SCIP_VAR* var /**< variable that should be printed */
)
{
int i;
int blocknr;
assert(GCGvarIsOriginal(var) || GCGvarIsMaster(var) || GCGvarIsPricing(var));
blocknr = GCGvarGetBlock(var);
if( GCGvarIsOriginal(var) )
{
SCIP_VAR** mastervars;
SCIP_Real* mastervals;
int nmastervars;
if( GCGvarIsLinking(var) )
{
SCIP_VAR** pricingvars;
int nblocks;
int j;
pricingvars = GCGlinkingVarGetPricingVars(var);
nblocks = GCGlinkingVarGetNBlocks(var);
SCIPinfoMessage(scip, file, "Variable %s (linking): %d block%s (", SCIPvarGetName(var), nblocks, nblocks == 1 ? "":"s" );
/*lint --e{440}*/
for( i = 0, j = 0; j < nblocks; ++i )
{
if( pricingvars[i] != NULL )
{
SCIPinfoMessage(scip, file, "%d ", i);
++j;
}
}
SCIPinfoMessage(scip, file, ")\n");
}
else
{
SCIPinfoMessage(scip, file, "Variable %s (original): block %d\n", SCIPvarGetName(var), blocknr);
}
mastervars = GCGoriginalVarGetMastervars(var);
mastervals = GCGoriginalVarGetMastervals(var);
nmastervars = GCGoriginalVarGetNMastervars(var);
SCIPinfoMessage(scip, file, "mastervars:");
for( i = 0; i < nmastervars-1; i++ )
{
SCIPinfoMessage(scip, file, "%s (%g), ", SCIPvarGetName(mastervars[i]), mastervals[i]);
}
SCIPinfoMessage(scip, file, "%s (%g)\n", SCIPvarGetName(mastervars[nmastervars-1]), mastervals[nmastervars-1]);
}
else if( GCGvarIsPricing(var) )
{
SCIP_VAR** origvars;
int norigvars;
origvars = GCGpricingVarGetOrigvars(var);
norigvars = GCGpricingVarGetNOrigvars(var);
SCIPinfoMessage(scip, file, "Variable %s (pricing): block %d\n", SCIPvarGetName(var), blocknr);
SCIPinfoMessage(scip, file, "origvars:");
for( i = 0; i < norigvars-1; i++ )
{
SCIPinfoMessage(scip, file, "%s, ", SCIPvarGetName(origvars[i]));
}
SCIPinfoMessage(scip, file, "%s\n", SCIPvarGetName(origvars[norigvars-1]));
}
else if( GCGvarIsMaster(var) )
{
SCIP_VAR** origvars;
int norigvars;
SCIP_Real* origvals;
origvars = GCGmasterVarGetOrigvars(var);
norigvars = GCGmasterVarGetNOrigvars(var);
origvals = GCGmasterVarGetOrigvals(var);
SCIPinfoMessage(scip, file, "Variable %s (master): block %d\n", SCIPvarGetName(var), blocknr);
SCIPinfoMessage(scip, file, "origvars:");
for( i = 0; i < norigvars-1; i++ )
{
SCIPinfoMessage(scip, file, "%s (%g), ", SCIPvarGetName(origvars[i]), origvals[i]);
}
SCIPinfoMessage(scip, file, "%s (%g)\n", SCIPvarGetName(origvars[norigvars-1]), origvals[norigvars-1]);
}
}
int GamsScip::callSolver()
{
assert(gmo != NULL);
assert(gev != NULL);
assert(scip != NULL);
/* set interface type so we see =B= and =X= equations */
gmoInterfaceSet(gmo, gmoIFace_Raw);
if( gmoGetEquTypeCnt(gmo, gmoequ_C) || gmoGetEquTypeCnt(gmo, gmoequ_B) || gmoGetEquTypeCnt(gmo, gmoequ_X) )
{
gevLogStat(gev, "ERROR: Conic and logic constraints and external functions not supported by SCIP interface.\n");
gmoSolveStatSet(gmo, gmoSolveStat_Capability);
gmoModelStatSet(gmo, gmoModelStat_NoSolutionReturned);
return 1;
}
// set number of threads for linear algebra routines used in Ipopt
setNumThreads(gev, gevThreads(gev));
// update error printing callback in SCIP to use current gev
SCIPmessageSetErrorPrinting(printErrorGev, (void*)gev);
SCIP_RETCODE scipret;
// let GMO reader setup SCIP parameters and read options file
// do this here already so we know how to assemble dialog
scipret = SCIPreadParamsReaderGmo(scip);
if( scipret != SCIP_OKAY )
{
char buffer[256];
sprintf(buffer, "Error %d in call of SCIP function\n", scipret);
gevLogStatPChar(gev, buffer);
gmoSolveStatSet(gmo, gmoSolveStat_SystemErr);
gmoModelStatSet(gmo, gmoModelStat_ErrorNoSolution);
return 1;
}
SCIPinfoMessage(scip, NULL, "non-default parameter settings:\n");
SCIPwriteParams(scip, NULL, FALSE, TRUE);
char* interactive = NULL;
SCIP_CALL_ABORT( SCIPgetStringParam(scip, "gams/interactive", &interactive) );
assert(interactive != NULL);
#ifdef GAMS_BUILD
if( interactive[0] != '\0' && !palLicenseIsAcademic(pal) )
{
gevLogStat(gev, "SCIP interactive shell not available in demo mode.\n");
interactive[0] = '\0';
}
#endif
SCIP_Bool printstat;
SCIP_CALL_ABORT( SCIPgetBoolParam(scip, "display/statistics", &printstat) );
char* attrfile = NULL;
#if 0
SCIP_CALL( SCIPgetStringParam(scip, "constraints/attrfile", &attrfile) );
#endif
// setup commands to be executed by SCIP
SCIP_CALL_ABORT( SCIPaddDialogInputLine(scip, "readgams") ); // setup model
if( attrfile != NULL && *attrfile != '\0' )
{
char buffer[SCIP_MAXSTRLEN + 10];
size_t len;
len = strlen(attrfile);
if( len >= 3 && strcmp(&attrfile[len-3], ".ca") == 0 )
(void) SCIPsnprintf(buffer, sizeof(buffer), "read %g", attrfile);
else
(void) SCIPsnprintf(buffer, sizeof(buffer), "read %g ca", attrfile);
SCIP_CALL_ABORT( SCIPaddDialogInputLine(scip, buffer) ); // process constraints attribute file
}
if( interactive[0] == '\0' )
{
SCIP_CALL_ABORT( SCIPaddDialogInputLine(scip, "optimize") ); // solve model
if( printstat )
{
SCIP_CALL_ABORT( SCIPaddDialogInputLine(scip, "disp statistics") ); // display solution statistics
}
SCIP_CALL_ABORT( SCIPaddDialogInputLine(scip, "write gamssol") ); // pass solution to GMO
SCIP_CALL_ABORT( SCIPaddDialogInputLine(scip, "quit") ); // quit shell
}
else
{
// pass user commands to shell
SCIP_CALL_ABORT( SCIPaddDialogInputLine(scip, interactive) );
}
// run SCIP
scipret = SCIPstartInteraction(scip);
// evaluate SCIP return code
switch( scipret )
{
case SCIP_OKAY:
break;
case SCIP_READERROR:
/* if it's readerror, then we guess that it comes from encountering an unsupported gams instruction in the gmo readers makeExprtree method
* we still return with zero then
*/
gmoModelStatSet(gmo, gmoModelStat_NoSolutionReturned);
gmoSolveStatSet(gmo, gmoSolveStat_Capability);
break;
case SCIP_LPERROR:
case SCIP_MAXDEPTHLEVEL:
/* if SCIP failed due to internal error (forced LP solve failed, max depth level reached), also return zero */
gmoModelStatSet(gmo, gmoModelStat_ErrorNoSolution);
gmoSolveStatSet(gmo, gmoSolveStat_SolverErr);
break;
case SCIP_NOMEMORY:
/* there is no extra solver status for running out of memory, but memory is a resource, so return this */
gmoModelStatSet(gmo, gmoModelStat_ErrorNoSolution);
gmoSolveStatSet(gmo, gmoSolveStat_Resource);
break;
default:
{
char buffer[256];
sprintf(buffer, "Error %d in call of SCIP function\n", scipret);
gevLogStatPChar(gev, buffer);
gmoModelStatSet(gmo, gmoModelStat_ErrorNoSolution);
gmoSolveStatSet(gmo, gmoSolveStat_SystemErr);
return 1;
}
}
return 0;
}
/** evaluates command line parameters and runs GCG appropriately in the given SCIP instance */
static
SCIP_RETCODE SCIPprocessGCGShellArguments(
SCIP* scip, /**< SCIP data structure */
int argc, /**< number of shell parameters */
char** argv, /**< array with shell parameters */
const char* defaultsetname /**< name of default settings file */
)
{ /*lint --e{850}*/
char* probname = NULL;
char* decname = NULL;
char* settingsname = NULL;
char* mastersetname = NULL;
char* logname = NULL;
SCIP_Bool quiet;
SCIP_Bool paramerror;
SCIP_Bool interactive;
int i;
/********************
* Parse parameters *
********************/
quiet = FALSE;
paramerror = FALSE;
interactive = FALSE;
for( i = 1; i < argc; ++i )
{
if( strcmp(argv[i], "-l") == 0 )
{
i++;
if( i < argc )
logname = argv[i];
else
{
SCIPinfoMessage(scip, NULL, "missing log filename after parameter '-l'\n");
paramerror = TRUE;
}
}
else if( strcmp(argv[i], "-q") == 0 )
quiet = TRUE;
else if( strcmp(argv[i], "-s") == 0 )
{
i++;
if( i < argc )
settingsname = argv[i];
else
{
SCIPinfoMessage(scip, NULL, "missing settings filename after parameter '-s'\n");
paramerror = TRUE;
}
}
else if( strcmp(argv[i], "-m") == 0 )
{
i++;
if( i < argc )
mastersetname = argv[i];
else
{
SCIPinfoMessage(scip, NULL, "missing master settings filename after parameter '-m'\n");
paramerror = TRUE;
}
}
else if( strcmp(argv[i], "-f") == 0 )
{
i++;
if( i < argc )
probname = argv[i];
else
{
SCIPinfoMessage(scip, NULL, "missing problem filename after parameter '-f'\n");
paramerror = TRUE;
}
}
else if( strcmp(argv[i], "-d") == 0 )
{
i++;
if( i < argc )
decname = argv[i];
else
{
SCIPinfoMessage(scip, NULL, "missing decomposition filename after parameter '-d'\n");
paramerror = TRUE;
}
}
else if( strcmp(argv[i], "-c") == 0 )
{
i++;
if( i < argc )
{
SCIP_CALL( SCIPaddDialogInputLine(scip, argv[i]) );
interactive = TRUE;
}
else
{
SCIPinfoMessage(scip, NULL, "missing command line after parameter '-c'\n");
paramerror = TRUE;
}
}
else if( strcmp(argv[i], "-b") == 0 )
{
i++;
if( i < argc )
{
SCIP_FILE* file;
file = SCIPfopen(argv[i], "r");
if( file == NULL )
{
SCIPinfoMessage(scip, NULL, "cannot read command batch file <%s>\n", argv[i]);
SCIPprintSysError(argv[i]);
paramerror = TRUE;
}
else
{
while( !SCIPfeof(file) )
{
char buffer[SCIP_MAXSTRLEN];
(void)SCIPfgets(buffer, sizeof(buffer), file);
if( buffer[0] != '\0' )
{
SCIP_CALL( SCIPaddDialogInputLine(scip, buffer) );
}
}
SCIPfclose(file);
interactive = TRUE;
}
}
else
{
SCIPinfoMessage(scip, NULL, "missing command batch filename after parameter '-b'\n");
paramerror = TRUE;
}
}
else
{
SCIPinfoMessage(scip, NULL, "invalid parameter <%s>\n", argv[i]);
paramerror = TRUE;
}
}
if( interactive && probname != NULL )
{
SCIPinfoMessage(scip, NULL, "cannot mix batch mode '-c' and '-b' with file mode '-f'\n");
paramerror = TRUE;
}
if( probname == NULL && decname != NULL )
{
SCIPinfoMessage(scip, NULL, "cannot read decomposition file without given problem\n");
paramerror = TRUE;
}
if( !paramerror )
{
/***********************************
* create log file message handler *
***********************************/
if( quiet )
{
SCIPsetMessagehdlrQuiet(scip, quiet);
}
if( logname != NULL )
{
SCIPsetMessagehdlrLogfile(scip, logname);
}
/***********************************
* Version and library information *
***********************************/
SCIPprintVersion(scip, NULL);
SCIPinfoMessage(scip, NULL, "\n");
SCIPprintExternalCodes(scip, NULL);
SCIPinfoMessage(scip, NULL, "\n");
/*****************
* Load settings *
*****************/
if( settingsname != NULL )
{
SCIP_CALL( readParams(scip, settingsname) );
}
else if( defaultsetname != NULL )
{
SCIP_CALL( readParams(scip, defaultsetname) );
}
if( mastersetname != NULL )
{
SCIP_CALL( readParams(GCGrelaxGetMasterprob(scip), mastersetname) );
}
/**************
* Start SCIP *
**************/
if( probname != NULL )
{
SCIP_CALL( fromCommandLine(scip, probname, decname) );
}
else
{
SCIPinfoMessage(scip, NULL, "\n");
SCIP_CALL( SCIPstartInteraction(scip) );
}
}
else
{
SCIPinfoMessage(scip, NULL, "\nsyntax: %s [-l <logfile>] [-q] [-s <settings>] [-f <problem>] [-m <mastersettings>] [-d <decomposition>] [-b <batchfile>] [-c \"command\"]\n"
" -l <logfile> : copy output into log file\n"
" -q : suppress screen messages\n"
" -s <settings> : load parameter settings (.set) file\n"
" -m <mastersettings> : load master parameter settings (.set) file\n"
" -f <problem> : load and solve problem file\n"
" -d <decomposition> : load decomposition file\n"
" -b <batchfile> : load and execute dialog command batch file (can be used multiple times)\n"
" -c \"command\" : execute single line of dialog commands (can be used multiple times)\n\n",
argv[0]);
}
return SCIP_OKAY;
}
/** execution method of event handler */
static
SCIP_DECL_EVENTEXEC(eventExecBoundwriting)
{ /*lint --e{715}*/
SCIP_EVENTHDLRDATA* eventhdlrdata;
assert(scip != NULL);
assert(eventhdlr != NULL);
assert(strcmp(SCIPeventhdlrGetName(eventhdlr), EVENTHDLR_NAME) == 0);
assert(event != NULL);
assert(((SCIPeventGetType(event) & SCIP_EVENTTYPE_NODESOLVED) == SCIP_EVENTTYPE_NODEFEASIBLE) || ((SCIPeventGetType(event) & SCIP_EVENTTYPE_NODESOLVED) == SCIP_EVENTTYPE_NODEINFEASIBLE) || ((SCIPeventGetType(event) & SCIP_EVENTTYPE_NODESOLVED) == SCIP_EVENTTYPE_NODEBRANCHED));
SCIPdebugMessage("exec method of event handler for writing primal- and dualbounds\n");
eventhdlrdata = SCIPeventhdlrGetData(eventhdlr);
assert(eventhdlrdata != NULL);
#ifdef ONEFILE
/* check if we need to open the file */
if( strlen(eventhdlrdata->filename) > 0 && !eventhdlrdata->isopen )
{
assert(eventhdlrdata->file == NULL);
assert(eventhdlrdata->oldfilename[0] == '\0');
eventhdlrdata->file = fopen(eventhdlrdata->filename, "w");
(void)strncpy(eventhdlrdata->oldfilename, eventhdlrdata->filename, SCIP_MAXSTRLEN);
if( eventhdlrdata->file == NULL )
{
SCIPerrorMessage("cannot create file <%s> for writing\n", eventhdlrdata->filename);
SCIPprintSysError(eventhdlrdata->filename);
return SCIP_FILECREATEERROR;
}
eventhdlrdata->isopen = TRUE;
#ifdef LONGSTATS
SCIPinfoMessage(scip, eventhdlrdata->file, "Problem: %s (%d Original Constraints, %d Original Variables)\n", SCIPgetProbName(scip), SCIPgetNOrigConss(scip), SCIPgetNOrigVars(scip) );
SCIPinfoMessage(scip, eventhdlrdata->file, "\t (%d Presolved Constraints, %d Presolved Variables, (%d binary, %d integer, %d implicit integer, %d continuous))\n", SCIPgetNConss(scip), SCIPgetNVars(scip), SCIPgetNBinVars(scip), SCIPgetNIntVars(scip), SCIPgetNImplVars(scip), SCIPgetNContVars(scip));
SCIPinfoMessage(scip, eventhdlrdata->file, "\n");
#endif
}
#endif
/* call writing only at right moment */
if( eventhdlrdata->freq == 0 || (SCIPgetNNodes(scip) % eventhdlrdata->freq) != 0 )
return SCIP_OKAY;
#ifndef ONEFILE
if( strlen(eventhdlrdata->filename) > 0 )
{
char name[SCIP_MAXSTRLEN];
char number[SCIP_MAXSTRLEN];
char* pch;
int n;
assert(eventhdlrdata->file == NULL);
assert(!eventhdlrdata->isopen);
if( eventhdlrdata->oldfilename[0] == '\0' )
(void)strncpy(eventhdlrdata->oldfilename, eventhdlrdata->filename, SCIP_MAXSTRLEN);
/* find last '.' to append filenumber */
pch=strrchr(eventhdlrdata->filename,'.');
assert(eventhdlrdata->filenumber > 0);
n=sprintf(number, "%"SCIP_LONGINT_FORMAT"", eventhdlrdata->filenumber * eventhdlrdata->freq);
assert(n > 0);
assert(n < SCIP_MAXSTRLEN);
/* if no point is found, extend directly */
if( pch == NULL )
{
(void)strncpy(name, eventhdlrdata->filename, (unsigned int)(SCIP_MAXSTRLEN - n));
strncat(name, number, (unsigned int)n);
}
else
{
int len;
if( (pch-(eventhdlrdata->filename)) > (SCIP_MAXSTRLEN - n) ) /*lint !e776*/
len = SCIP_MAXSTRLEN - n;
else
len = (int) (pch-(eventhdlrdata->filename));
(void)strncpy(name, eventhdlrdata->filename, (unsigned int)len);
name[len] = '\0';
strncat(name, number, (unsigned int)n);
assert(len+n < SCIP_MAXSTRLEN);
name[len+n] = '\0';
if( len + n + strlen(&(eventhdlrdata->filename[len])) < SCIP_MAXSTRLEN ) /*lint !e776*/
{
strncat(name, &(eventhdlrdata->filename[len]), strlen(&(eventhdlrdata->filename[len])));
name[strlen(eventhdlrdata->filename)+n] = '\0';
}
}
eventhdlrdata->file = fopen(name, "w");
if( eventhdlrdata->file == NULL )
{
SCIPerrorMessage("cannot create file <%s> for writing\n", eventhdlrdata->filename);
SCIPprintSysError(eventhdlrdata->filename);
return SCIP_FILECREATEERROR;
}
eventhdlrdata->isopen = TRUE;
#ifdef LONGSTATS
SCIPinfoMessage(scip, eventhdlrdata->file, "Problem: %s (%d Original Constraints, %d Original Variables)\n", SCIPgetProbName(scip), SCIPgetNOrigConss(scip), SCIPgetNOrigVars(scip) );
SCIPinfoMessage(scip, eventhdlrdata->file, "\t (%d Active Constraints, %d Active Variables, (%d binary, %d integer, %d implicit integer, %d continuous))\n", SCIPgetNConss(scip), SCIPgetNVars(scip), SCIPgetNBinVars(scip), SCIPgetNIntVars(scip), SCIPgetNImplVars(scip), SCIPgetNContVars(scip));
SCIPinfoMessage(scip, eventhdlrdata->file, "\n");
#endif
}
#endif
#ifndef NDEBUG
/* check the filename did not change during the solving */
if( strlen(eventhdlrdata->filename) > 0 && eventhdlrdata->isopen )
{
char tmp[SCIP_MAXSTRLEN];
(void)strncpy(tmp, eventhdlrdata->filename, SCIP_MAXSTRLEN);
/* the name should stay the same */
assert(strcmp(tmp, eventhdlrdata->oldfilename) == 0);
}
#endif
#ifdef FOCUSNODE
/* call writing method */
SCIP_CALL( writeBoundsFocusNode(scip, eventhdlrdata) );
#else
/* call writing method */
SCIP_CALL( writeBounds(scip, eventhdlrdata->file, eventhdlrdata->writesubmipdualbound) );
#endif
#ifndef ONEFILE
if( strlen(eventhdlrdata->filename) > 0 )
{
assert(eventhdlrdata->isopen);
(void) fclose(eventhdlrdata->file);
eventhdlrdata->isopen = FALSE;
eventhdlrdata->file = NULL;
++(eventhdlrdata->filenumber);
}
#endif
return SCIP_OKAY;
}
/** call writing method */
static
SCIP_RETCODE writeBounds(
SCIP* scip, /**< SCIP data structure */
FILE* file, /**< file to write to or NULL */
SCIP_Bool writesubmipdualbound/**< write dualbounds of submip roots for all open nodes */
)
{
SCIP_NODE** opennodes;
int nopennodes;
int n;
int v;
assert(scip != NULL);
nopennodes = -1;
#ifdef LONGSTATS
SCIPinfoMessage(scip, file, "Status after %"SCIP_LONGINT_FORMAT" processed nodes (%d open)\n", SCIPgetNNodes(scip), SCIPgetNNodesLeft(scip));
SCIPinfoMessage(scip, file, "Primalbound: %g\n", SCIPgetPrimalbound(scip));
SCIPinfoMessage(scip, file, "Dualbound: %g\n", SCIPgetDualbound(scip));
#else
SCIPinfoMessage(scip, file, "PB %g\n", SCIPgetPrimalbound(scip));
#endif
/* get all open nodes and therefor print all dualbounds */
for( v = 2; v >= 0; --v )
{
SCIP_NODE* node;
switch( v )
{
case 2:
SCIP_CALL( SCIPgetChildren(scip, &opennodes, &nopennodes) );
break;
case 1:
SCIP_CALL( SCIPgetSiblings(scip, &opennodes, &nopennodes) );
break;
case 0:
SCIP_CALL( SCIPgetLeaves(scip, &opennodes, &nopennodes) );
break;
default:
assert(0);
break;
}
assert(nopennodes >= 0);
/* print all node information */
for( n = nopennodes - 1; n >= 0 && !SCIPisStopped(scip); --n )
{
node = opennodes[n];
if( writesubmipdualbound )
{
SCIP* subscip;
SCIP_Bool valid;
SCIP_HASHMAP* varmap; /* mapping of SCIP variables to sub-SCIP variables */
SCIP_VAR** vars; /* original problem's variables */
int nvars;
SCIP_Real submipdb;
SCIP_Bool cutoff;
SCIP_CALL( SCIPcreate(&subscip) );
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, NULL, NULL, NULL, NULL) );
/* create the variable mapping hash map */
SCIP_CALL( SCIPhashmapCreate(&varmap, SCIPblkmem(subscip), SCIPcalcHashtableSize(5 * nvars)) );
submipdb = SCIP_INVALID;
valid = FALSE;
cutoff = FALSE;
SCIP_CALL( SCIPcopy(scip, subscip, varmap, NULL, "__boundwriting", TRUE, FALSE, TRUE, &valid) );
if( valid )
{
SCIP_VAR** branchvars;
SCIP_Real* branchbounds;
SCIP_BOUNDTYPE* boundtypes;
int nbranchvars;
int size;
size = SCIPnodeGetDepth(node);
/* allocate memory for all branching decisions */
SCIP_CALL( SCIPallocBufferArray(scip, &branchvars, size) );
SCIP_CALL( SCIPallocBufferArray(scip, &branchbounds, size) );
SCIP_CALL( SCIPallocBufferArray(scip, &boundtypes, size) );
/* we assume that we only have one branching decision at each node */
SCIPnodeGetAncestorBranchings( node, branchvars, branchbounds, boundtypes, &nbranchvars, size );
/* check if did not have enough memory */
if( nbranchvars > size )
{
size = nbranchvars;
SCIP_CALL( SCIPallocBufferArray(scip, &branchvars, size) );
SCIP_CALL( SCIPallocBufferArray(scip, &branchbounds, size) );
SCIP_CALL( SCIPallocBufferArray(scip, &boundtypes, size) );
/* now getting all information */
SCIPnodeGetAncestorBranchings( node, branchvars, branchbounds, boundtypes, &nbranchvars, size );
}
/* apply all changes to the submip */
SCIP_CALL( applyDomainChanges(subscip, branchvars, branchbounds, boundtypes, nbranchvars, varmap) );
/* free memory for all branching decisions */
SCIPfreeBufferArray(scip, &boundtypes);
SCIPfreeBufferArray(scip, &branchbounds);
SCIPfreeBufferArray(scip, &branchvars);
/* do not abort subproblem on CTRL-C */
SCIP_CALL( SCIPsetBoolParam(subscip, "misc/catchctrlc", FALSE) );
/* disable output to console */
SCIP_CALL( SCIPsetIntParam(subscip, "display/verblevel", 0) );
/* solve only root node */
SCIP_CALL( SCIPsetLongintParam(subscip, "limits/nodes", 1LL) );
/* set cutoffbound as objective limit for subscip */
SCIP_CALL( SCIPsetObjlimit(subscip, SCIPgetCutoffbound(scip)) );
SCIP_CALL( SCIPsolve(subscip) );
cutoff = (SCIPgetStatus(subscip) == SCIP_STATUS_INFEASIBLE);
submipdb = SCIPgetDualbound(subscip) * SCIPgetTransObjscale(scip) + SCIPgetTransObjoffset(scip);
}
#ifdef LONGSTATS
SCIPinfoMessage(scip, file, "Node %"SCIP_LONGINT_FORMAT" (depth %d): dualbound: %g, nodesubmiprootdualbound: %g %s\n", SCIPnodeGetNumber(node), SCIPnodeGetDepth(node), SCIPgetNodeDualbound(scip, node), submipdb, cutoff ? "(cutoff)" : "");
#else
SCIPinfoMessage(scip, file, "%"SCIP_LONGINT_FORMAT" %d %g %g %s\n", SCIPnodeGetNumber(node), SCIPnodeGetDepth(node), SCIPgetNodeDualbound(scip, node), submipdb, cutoff ? "(cutoff)" : "");
#endif
/* free hash map */
SCIPhashmapFree(&varmap);
SCIP_CALL( SCIPfree(&subscip) );
}
else
{
#ifdef LONGSTATS
SCIPinfoMessage(scip, file, "Node %"SCIP_LONGINT_FORMAT" (depth %d): dualbound: %g\n", SCIPnodeGetNumber(node), SCIPnodeGetDepth(node), SCIPgetNodeDualbound(scip, node));
#else
SCIPinfoMessage(scip, file, "%"SCIP_LONGINT_FORMAT" %d %g\n", SCIPnodeGetNumber(node), SCIPnodeGetDepth(node), SCIPgetNodeDualbound(scip, node));
#endif
}
}
}
#ifdef LONGSTATS
SCIPinfoMessage(scip, file, "\n");
#endif
return SCIP_OKAY;
}
/** call writing method */
static
SCIP_RETCODE writeBoundsFocusNode(
SCIP* scip, /**< SCIP data structure */
SCIP_EVENTHDLRDATA* eventhdlrdata /**< event handler data */
)
{
FILE* file;
SCIP_Bool writesubmipdualbound;
SCIP_NODE* node;
assert(scip != NULL);
assert(eventhdlrdata != NULL);
file = eventhdlrdata->file;
writesubmipdualbound = eventhdlrdata->writesubmipdualbound;
node = SCIPgetCurrentNode(scip);
/* do not process probing nodes */
if( SCIPnodeGetType(node) == SCIP_NODETYPE_PROBINGNODE )
return SCIP_OKAY;
/* do not process cutoff nodes */
if( SCIPisInfinity(scip, SCIPgetNodeDualbound(scip, node)) )
return SCIP_OKAY;
if( !SCIPisEQ(scip, eventhdlrdata->lastpb, SCIPgetPrimalbound(scip)) )
{
#ifdef LONGSTATS
SCIPinfoMessage(scip, file, "Status after %"SCIP_LONGINT_FORMAT" processed nodes (%d open)\n", SCIPgetNNodes(scip), SCIPgetNNodesLeft(scip));
SCIPinfoMessage(scip, file, "Primalbound: %g\n", SCIPgetPrimalbound(scip));
SCIPinfoMessage(scip, file, "Dualbound: %g\n", SCIPgetDualbound(scip));
#else
SCIPinfoMessage(scip, file, "PB %g\n", SCIPgetPrimalbound(scip));
#endif
eventhdlrdata->lastpb = SCIPgetPrimalbound(scip);
}
if( writesubmipdualbound )
{
SCIP* subscip;
SCIP_Bool valid;
SCIP_Real submipdb;
SCIP_Bool cutoff;
SCIP_CALL( SCIPcreate(&subscip) );
submipdb = SCIP_INVALID;
valid = FALSE;
cutoff = FALSE;
SCIP_CALL( SCIPcopy(scip, subscip, NULL, NULL, "__boundwriting", FALSE, FALSE, TRUE, &valid) );
if( valid )
{
/* do not abort subproblem on CTRL-C */
SCIP_CALL( SCIPsetBoolParam(subscip, "misc/catchctrlc", FALSE) );
/* disable output to console */
SCIP_CALL( SCIPsetIntParam(subscip, "display/verblevel", 0) );
/* solve only root node */
SCIP_CALL( SCIPsetLongintParam(subscip, "limits/nodes", 1LL) );
#if 0
/* disable heuristics in subscip */
SCIP_CALL( SCIPsetHeuristics(subscip, SCIP_PARAMSETTING_OFF, TRUE) );
#endif
/* set cutoffbound as objective limit for subscip */
SCIP_CALL( SCIPsetObjlimit(subscip, SCIPgetCutoffbound(scip)) );
SCIP_CALL( SCIPsolve(subscip) );
cutoff = (SCIPgetStatus(subscip) == SCIP_STATUS_INFEASIBLE);
submipdb = SCIPgetDualbound(subscip) * SCIPgetTransObjscale(scip) + SCIPgetTransObjoffset(scip);
}
#ifdef LONGSTATS
SCIPinfoMessage(scip, file, "Node %"SCIP_LONGINT_FORMAT" (depth %d): dualbound: %g, nodesubmiprootdualbound: %g %s\n", SCIPnodeGetNumber(node), SCIPnodeGetDepth(node), SCIPgetNodeDualbound(scip, node), submipdb, cutoff ? "(cutoff)" : "");
#else
SCIPinfoMessage(scip, file, "%"SCIP_LONGINT_FORMAT" %d %g %g %s\n", SCIPnodeGetNumber(node), SCIPnodeGetDepth(node), SCIPgetNodeDualbound(scip, node), submipdb, cutoff ? "(cutoff)" : "");
#endif
SCIP_CALL( SCIPfree(&subscip) );
}
else
{
#ifdef LONGSTATS
SCIPinfoMessage(scip, file, "Node %"SCIP_LONGINT_FORMAT" (depth %d): dualbound: %g\n", SCIPnodeGetNumber(node), SCIPnodeGetDepth(node), SCIPgetNodeDualbound(scip, node));
#else
SCIPinfoMessage(scip, file, "%"SCIP_LONGINT_FORMAT" %d %g\n", SCIPnodeGetNumber(node), SCIPnodeGetDepth(node), SCIPgetNodeDualbound(scip, node));
#endif
}
#ifdef LONGSTATS
SCIPinfoMessage(scip, file, "\n");
#endif
return SCIP_OKAY;
}
