/** destructor of reader to free user data (called when SCIP is exiting) */
static
SCIP_DECL_READERFREE(readerFreeBlk)
{
SCIP_READERDATA* readerdata;
readerdata = SCIPreaderGetData(reader);
assert(readerdata != NULL);
SCIPfreeMemory(scip, &readerdata);
return SCIP_OKAY;
}
/** destructor of reader to free user data (called when SCIP is exiting) */
static
SCIP_DECL_READERFREE(readerFreeCip)
{
SCIP_READERDATA* readerdata;
assert(strcmp(SCIPreaderGetName(reader), READER_NAME) == 0);
readerdata = SCIPreaderGetData(reader);
assert(readerdata != NULL);
SCIPfreeMemory(scip, &readerdata);
return SCIP_OKAY;
}
/** returns the reader object for the given file reader */
scip::ObjReader* SCIPgetObjReader(
SCIP* scip, /**< SCIP data structure */
SCIP_READER* reader /**< file reader */
)
{
SCIP_READERDATA* readerdata;
readerdata = SCIPreaderGetData(reader);
assert(readerdata != NULL);
return readerdata->objreader;
}
/** problem writing method of reader */
static
SCIP_DECL_READERWRITE(readerWritePpm)
{ /*lint --e{715}*/
SCIP_READERDATA* readerdata;
assert(strcmp(SCIPreaderGetName(reader), READER_NAME) == 0);
readerdata = SCIPreaderGetData(reader);
assert(readerdata != NULL);
SCIP_CALL( SCIPwritePpm(scip, file, name, readerdata, transformed, vars, nvars, conss, nconss, result) );
return SCIP_OKAY;
}
/** problem reading method of reader */
static
SCIP_DECL_READERREAD(readerReadObj)
{ /*lint --e{715}*/
SCIP_READERDATA* readerdata;
readerdata = SCIPreaderGetData(reader);
assert(readerdata != NULL);
assert(readerdata->objreader != NULL);
assert(readerdata->objreader->scip_ == scip);
/* call virtual method of reader object */
SCIP_CALL( readerdata->objreader->scip_read(scip, reader, filename, result) );
return SCIP_OKAY;
}
/** returns the reader object of the given name, or 0 if not existing */
scip::ObjReader* SCIPfindObjReader(
SCIP* scip, /**< SCIP data structure */
const char* name /**< name of file reader */
)
{
SCIP_READER* reader;
SCIP_READERDATA* readerdata;
reader = SCIPfindReader(scip, name);
if( reader == NULL )
return 0;
readerdata = SCIPreaderGetData(reader);
assert(readerdata != NULL);
return readerdata->objreader;
}
/** problem writing method of reader */
static
SCIP_DECL_READERWRITE(readerWriteObj)
{ /*lint --e{715}*/
SCIP_READERDATA* readerdata;
readerdata = SCIPreaderGetData(reader);
assert(readerdata != NULL);
assert(readerdata->objreader != NULL);
/* call virtual method of reader object */
SCIP_CALL( readerdata->objreader->scip_write(scip, reader, file, name, probdata, transformed,
objsense, objscale, objoffset,
vars, nvars, nbinvars, nintvars, nimplvars, ncontvars, fixedvars, nfixedvars, startnvars,
conss, nconss, maxnconss, startnconss, genericnames, result) );
return SCIP_OKAY;
}
/** destructor of file reader to free user data (called when SCIP is exiting) */
static
SCIP_DECL_READERFREE(readerFreeObj)
{ /*lint --e{715}*/
SCIP_READERDATA* readerdata;
readerdata = SCIPreaderGetData(reader);
assert(readerdata != NULL);
assert(readerdata->objreader != NULL);
assert(readerdata->objreader->scip_ == scip);
/* call virtual method of reader object */
SCIP_CALL( readerdata->objreader->scip_free(scip, reader) );
/* free reader object */
if( readerdata->deleteobject )
delete readerdata->objreader;
/* free reader data */
delete readerdata;
SCIPreaderSetData(reader, NULL); /*lint !e64*/
return SCIP_OKAY;
}
/** copy method for reader plugins (called when SCIP copies plugins) */
static
SCIP_DECL_READERCOPY(readerCopyObj)
{ /*lint --e{715}*/
SCIP_READERDATA* readerdata;
assert(scip != NULL);
readerdata = SCIPreaderGetData(reader);
assert(readerdata != NULL);
assert(readerdata->objreader != NULL);
assert(readerdata->objreader->scip_ != scip);
if( readerdata->objreader->iscloneable() )
{
scip::ObjReader* newobjreader;
newobjreader = dynamic_cast<scip::ObjReader*> (readerdata->objreader->clone(scip));
/* call include method of reader object */
SCIP_CALL( SCIPincludeObjReader(scip, newobjreader, TRUE) );
}
return SCIP_OKAY;
}
/** reads an BLK file */
static
SCIP_RETCODE readBLKFile(
SCIP* scip, /**< SCIP data structure */
SCIP_READER* reader, /**< reader data structure */
BLKINPUT* blkinput, /**< BLK reading data */
const char* filename /**< name of the input file */
)
{
DEC_DECOMP *decdecomp;
int i;
int nconss;
int nblocksread;
int nvars;
SCIP_READERDATA* readerdata;
SCIP_CONS** conss;
nblocksread = FALSE;
assert(scip != NULL);
assert(reader != NULL);
assert(blkinput != NULL);
if( SCIPgetStage(scip) < SCIP_STAGE_TRANSFORMED )
SCIP_CALL( SCIPtransformProb(scip) );
readerdata = SCIPreaderGetData(reader);
assert(readerdata != NULL);
readerdata->nlinkingcons = SCIPgetNConss(scip);
readerdata->nlinkingvars = 0;
nvars = SCIPgetNVars(scip);
conss = SCIPgetConss(scip);
nconss = SCIPgetNConss(scip);
/* alloc: var -> block mapping */
SCIP_CALL( SCIPallocMemoryArray(scip, &readerdata->varstoblock, nvars) );
for( i = 0; i < nvars; i ++ )
{
readerdata->varstoblock[i] = NOVALUE;
}
/* alloc: linkingvar -> blocks mapping */
SCIP_CALL( SCIPallocMemoryArray(scip, &readerdata->linkingvarsblocks, nvars) );
SCIP_CALL( SCIPallocMemoryArray(scip, &readerdata->nlinkingvarsblocks, nvars) );
BMSclearMemoryArray(readerdata->linkingvarsblocks, nvars);
BMSclearMemoryArray(readerdata->nlinkingvarsblocks, nvars);
/* cons -> block mapping */
SCIP_CALL( SCIPhashmapCreate(&readerdata->constoblock, SCIPblkmem(scip), nconss) );
for( i = 0; i < SCIPgetNConss(scip); i ++ )
{
SCIP_CALL( SCIPhashmapInsert(readerdata->constoblock, conss[i], (void*)(size_t) NOVALUE) );
}
/* open file */
blkinput->file = SCIPfopen(filename, "r");
if( blkinput->file == NULL )
{
SCIPerrorMessage("cannot open file <%s> for reading\n", filename);
SCIPprintSysError(filename);
return SCIP_NOFILE;
}
/* parse the file */
blkinput->section = BLK_START;
while( blkinput->section != BLK_END && !hasError(blkinput) )
{
switch( blkinput->section )
{
case BLK_START:
SCIP_CALL( readStart(scip, blkinput) );
break;
case BLK_PRESOLVED:
SCIP_CALL( readPresolved(scip, blkinput) );
if( blkinput->presolved && SCIPgetStage(scip) < SCIP_STAGE_PRESOLVED )
{
assert(blkinput->haspresolvesection);
/** @bug GCG should be able to presolve the problem first */
SCIPverbMessage(scip, SCIP_VERBLEVEL_MINIMAL, NULL, "decomposition belongs to the presolved problem, please presolve the problem first.\n");
goto TERMINATE;
}
break;
case BLK_NBLOCKS:
SCIP_CALL( readNBlocks(scip, blkinput) );
if( blkinput->haspresolvesection && !blkinput->presolved && SCIPgetStage(scip) >= SCIP_STAGE_PRESOLVED )
{
SCIPverbMessage(scip, SCIP_VERBLEVEL_MINIMAL, NULL, "decomposition belongs to the unpresolved problem, please re-read the problem and read the decomposition without presolving.\n");
goto TERMINATE;
}
if( !blkinput->haspresolvesection )
{
SCIPwarningMessage(scip, "decomposition has no presolve section at beginning. The behaviour is undefined. See the FAQ for further information.\n");
}
break;
case BLK_BLOCK:
if( nblocksread == FALSE )
{
/* alloc n vars per block */
SCIP_CALL( SCIPallocMemoryArray(scip, &readerdata->nblockvars, blkinput->nblocks) );
SCIP_CALL( SCIPallocMemoryArray(scip, &readerdata->nblockcons, blkinput->nblocks) );
SCIP_CALL( SCIPallocMemoryArray(scip, &readerdata->blockcons, blkinput->nblocks) );
for( i = 0; i < blkinput->nblocks; ++i )
{
readerdata->nblockvars[i] = 0;
readerdata->nblockcons[i] = 0;
SCIP_CALL( SCIPallocMemoryArray(scip, &(readerdata->blockcons[i]), nconss) ); /*lint !e866*/
}
nblocksread = TRUE;
}
SCIP_CALL( readBlock(scip, blkinput, readerdata) );
break;
case BLK_MASTERCONSS:
SCIP_CALL( readMasterconss(scip, blkinput, readerdata) );
break;
case BLK_END: /* this is already handled in the while() loop */
default:
SCIPerrorMessage("invalid BLK file section <%d>\n", blkinput->section);
return SCIP_INVALIDDATA;
}
}
SCIP_CALL( DECdecompCreate(scip, &decdecomp) );
/* fill decomp */
SCIP_CALL( fillDecompStruct(scip, blkinput, decdecomp, readerdata) );
/* add decomp to cons_decomp */
SCIP_CALL( SCIPconshdlrDecompAddDecdecomp(scip, decdecomp) );
for( i = 0; i < nvars; ++i )
{
assert(readerdata->linkingvarsblocks[i] != NULL || readerdata->nlinkingvarsblocks[i] == 0);
if( readerdata->nlinkingvarsblocks[i] > 0 )
{
SCIPfreeMemoryArray(scip, &readerdata->linkingvarsblocks[i]);
}
}
TERMINATE:
if( nblocksread )
{
for( i = blkinput->nblocks - 1; i >= 0; --i )
{
SCIPfreeMemoryArray(scip, &(readerdata->blockcons[i]));
}
SCIPfreeMemoryArray(scip, &readerdata->blockcons);
SCIPfreeMemoryArray(scip, &readerdata->nblockcons);
SCIPfreeMemoryArray(scip, &readerdata->nblockvars);
}
SCIPhashmapFree(&readerdata->constoblock);
SCIPfreeMemoryArray(scip, &readerdata->nlinkingvarsblocks);
SCIPfreeMemoryArray(scip, &readerdata->linkingvarsblocks);
SCIPfreeMemoryArray(scip, &readerdata->varstoblock);
/* close file */
SCIPfclose(blkinput->file);
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;
}
