/** frees message handler */
static
SCIP_RETCODE messagehdlrFree(
SCIP_MESSAGEHDLR** messagehdlr /**< pointer to the message handler */
)
{
assert(messagehdlr != NULL);
if( *messagehdlr != NULL )
{
/* flush message buffers */
messagePrintWarning(*messagehdlr, NULL);
messagePrintDialog(*messagehdlr, NULL, NULL);
messagePrintInfo(*messagehdlr, NULL, NULL);
if( (*messagehdlr)->messagehdlrfree != NULL )
{
/* call destructor method of message handler to free the message handler data */
SCIP_CALL( (*messagehdlr)->messagehdlrfree(*messagehdlr) );
}
/* close the log file if one exists */
if( (*messagehdlr)->logfile != NULL )
{
fclose((*messagehdlr)->logfile);
}
/* free buffer arrays */
BMSfreeMemoryArrayNull(&(*messagehdlr)->warningbuffer);
BMSfreeMemoryArrayNull(&(*messagehdlr)->dialogbuffer);
BMSfreeMemoryArrayNull(&(*messagehdlr)->infobuffer);
BMSfreeMemory(messagehdlr);
}
return SCIP_OKAY;
}
/** frees all debugging solution data*/
SCIP_RETCODE SCIPdebugFreeDebugData(
SCIP_SET* set /**< global SCIP settings */
)
{
int s;
assert(set != NULL);
/* check if we are in the original problem and not in a sub MIP */
if( !isSolutionInMip(set) )
return SCIP_OKAY;
for( s = nsolvals - 1; s >= 0; --s )
BMSfreeMemoryArrayNull(&solnames[s]);
BMSfreeMemoryArrayNull(&solnames);
BMSfreeMemoryArrayNull(&solvals);
nsolvals = 0;
debugsolval = 0.0;
mainscipset = NULL;
solisachieved = FALSE;
if( solinnode != NULL)
SCIPhashmapFree(&solinnode);
return SCIP_OKAY;
}
/** calls destructor and frees memory of primal heuristic */
SCIP_RETCODE SCIPheurFree(
SCIP_HEUR** heur, /**< pointer to primal heuristic data structure */
SCIP_SET* set /**< global SCIP settings */
)
{
int d;
assert(heur != NULL);
assert(*heur != NULL);
assert(!(*heur)->initialized);
assert(set != NULL);
assert((*heur)->divesets != NULL || (*heur)->ndivesets == 0);
/* call destructor of primal heuristic */
if( (*heur)->heurfree != NULL )
{
SCIP_CALL( (*heur)->heurfree(set->scip, *heur) );
}
for( d = 0; d < (*heur)->ndivesets; ++d )
{
assert((*heur)->divesets[d] != NULL);
divesetFree(&((*heur)->divesets[d]));
}
BMSfreeMemoryArrayNull(&(*heur)->divesets);
SCIPclockFree(&(*heur)->heurclock);
SCIPclockFree(&(*heur)->setuptime);
BMSfreeMemoryArray(&(*heur)->name);
BMSfreeMemoryArray(&(*heur)->desc);
BMSfreeMemory(heur);
return SCIP_OKAY;
}
/** frees separation storage */
SCIP_RETCODE SCIPsepastoreFree(
SCIP_SEPASTORE** sepastore /**< pointer to store separation storage */
)
{
assert(sepastore != NULL);
assert(*sepastore != NULL);
assert((*sepastore)->ncuts == 0);
BMSfreeMemoryArrayNull(&(*sepastore)->cuts);
BMSfreeMemoryArrayNull(&(*sepastore)->efficacies);
BMSfreeMemoryArrayNull(&(*sepastore)->objparallelisms);
BMSfreeMemoryArrayNull(&(*sepastore)->orthogonalities);
BMSfreeMemoryArrayNull(&(*sepastore)->scores);
BMSfreeMemory(sepastore);
return SCIP_OKAY;
}
/** frees memory buffer */
void SCIPbufferFree(
SCIP_BUFFER** buffer /**< pointer to memory buffer storage */
)
{
int i;
assert(buffer != NULL);
for( i = 0; i < (*buffer)->ndata; ++i )
{
assert(!(*buffer)->used[i]);
BMSfreeMemoryArrayNull(&(*buffer)->data[i]);
}
BMSfreeMemoryArrayNull(&(*buffer)->data);
BMSfreeMemoryArrayNull(&(*buffer)->size);
BMSfreeMemoryArrayNull(&(*buffer)->used);
BMSfreeMemory(buffer);
}
/** frees pricing storage */
SCIP_RETCODE SCIPpricestoreFree(
SCIP_PRICESTORE** pricestore /**< pointer to store pricing storage */
)
{
assert(pricestore != NULL);
assert(*pricestore != NULL);
assert((*pricestore)->nvars == 0);
assert((*pricestore)->nbdviolvars == 0);
SCIPclockFree(&(*pricestore)->probpricingtime);
BMSfreeMemoryArrayNull(&(*pricestore)->vars);
BMSfreeMemoryArrayNull(&(*pricestore)->scores);
BMSfreeMemoryArrayNull(&(*pricestore)->bdviolvars);
BMSfreeMemoryArrayNull(&(*pricestore)->bdviolvarslb);
BMSfreeMemoryArrayNull(&(*pricestore)->bdviolvarsub);
BMSfreeMemory(pricestore);
return SCIP_OKAY;
}
/** clears the separation storage without adding the cuts to the LP */
SCIP_RETCODE SCIPsepastoreClearCuts(
SCIP_SEPASTORE* sepastore, /**< separation storage */
BMS_BLKMEM* blkmem, /**< block memory */
SCIP_SET* set, /**< global SCIP settings */
SCIP_EVENTQUEUE* eventqueue, /**< event queue */
SCIP_EVENTFILTER* eventfilter, /**< event filter for global events */
SCIP_LP* lp /**< LP data */
)
{
int c;
assert(sepastore != NULL);
SCIPdebugMessage("clearing %d cuts\n", sepastore->nforcedcuts + sepastore->ncuts);
/* release cuts */
for( c = 0; c < sepastore->ncuts; ++c )
{
/* check, if the row deletions from separation storage events are tracked
* if so, issue ROWDELETEDSEPA event
*/
if( eventfilter->len > 0 && (eventfilter->eventmask & SCIP_EVENTTYPE_ROWDELETEDSEPA) != 0 )
{
SCIP_EVENT* event;
SCIP_CALL( SCIPeventCreateRowDeletedSepa(&event, blkmem, sepastore->cuts[c]) );
SCIP_CALL( SCIPeventqueueAdd(eventqueue, blkmem, set, NULL, NULL, NULL, eventfilter, &event) );
}
SCIP_CALL( SCIProwRelease(&sepastore->cuts[c], blkmem, set, lp) );
}
/* reset counters */
sepastore->ncuts = 0;
sepastore->nforcedcuts = 0;
sepastore->ncutsfoundround = 0;
/* if we have just finished the initial LP construction, free the (potentially large) cuts array */
if( sepastore->initiallp )
{
BMSfreeMemoryArrayNull(&sepastore->cuts);
sepastore->cutssize = 0;
}
return SCIP_OKAY;
}