/** execution method of event handler */
static
SCIP_DECL_EVENTEXEC(eventhdlrExecObj)
{ /*lint --e{715}*/
SCIP_EVENTHDLRDATA* eventhdlrdata;
eventhdlrdata = SCIPeventhdlrGetData(eventhdlr);
assert(eventhdlrdata != NULL);
assert(eventhdlrdata->objeventhdlr != NULL);
/* call virtual method of eventhdlr object */
SCIP_CALL( eventhdlrdata->objeventhdlr->scip_exec(scip, eventhdlr, event, eventdata) );
return SCIP_OKAY;
}
/** solving process initialization method of event handler (called when branch and bound process is about to begin) */
static
SCIP_DECL_EVENTINITSOL(eventhdlrInitsolObj)
{ /*lint --e{715}*/
SCIP_EVENTHDLRDATA* eventhdlrdata;
eventhdlrdata = SCIPeventhdlrGetData(eventhdlr);
assert(eventhdlrdata != NULL);
assert(eventhdlrdata->objeventhdlr != NULL);
/* call virtual method of eventhdlr object */
SCIP_CALL( eventhdlrdata->objeventhdlr->scip_initsol(scip, eventhdlr) );
return SCIP_OKAY;
}
/** destructor of event handler to free user data (called when SCIP is exiting) */
static
SCIP_DECL_EVENTFREE(eventFreeSofttimelimit)
{ /*lint --e{715}*/
SCIP_EVENTHDLRDATA* eventhdlrdata;
assert(scip != NULL);
assert(eventhdlr != NULL);
assert(strcmp(SCIPeventhdlrGetName(eventhdlr), EVENTHDLR_NAME) == 0);
eventhdlrdata = SCIPeventhdlrGetData(eventhdlr);
assert(eventhdlrdata != NULL);
SCIPfreeMemory(scip, &eventhdlrdata);
SCIPeventhdlrSetData(eventhdlr, NULL);
return SCIP_OKAY;
}
/** destructor of event handler to free user data (called when SCIP is exiting) */
static
SCIP_DECL_EVENTFREE(eventFreeBoundwriting)
{ /*lint --e{715}*/
SCIP_EVENTHDLRDATA* eventhdlrdata;
assert(scip != NULL);
assert(eventhdlr != NULL);
eventhdlrdata = SCIPeventhdlrGetData(eventhdlr);
assert(eventhdlrdata != NULL);
assert(!eventhdlrdata->isopen);
assert(eventhdlrdata->file == NULL);
SCIPfreeMemory(scip, &eventhdlrdata);
return SCIP_OKAY;
}
/** returns the eventhdlr object of the given name, or 0 if not existing */
scip::ObjEventhdlr* SCIPfindObjEventhdlr(
SCIP* scip, /**< SCIP data structure */
const char* name /**< name of event handler */
)
{
SCIP_EVENTHDLR* eventhdlr;
SCIP_EVENTHDLRDATA* eventhdlrdata;
eventhdlr = SCIPfindEventhdlr(scip, name);
if( eventhdlr == NULL )
return 0;
eventhdlrdata = SCIPeventhdlrGetData(eventhdlr);
assert(eventhdlrdata != NULL);
return eventhdlrdata->objeventhdlr;
}
/** initialization method of event handler (called after problem was transformed) */
static
SCIP_DECL_EVENTINIT(eventInitBoundwriting)
{ /*lint --e{715}*/
SCIP_EVENTHDLRDATA* eventhdlrdata;
assert(scip != NULL);
assert(eventhdlr != NULL);
assert(strcmp(SCIPeventhdlrGetName(eventhdlr), EVENTHDLR_NAME) == 0);
/* notify SCIP that your event handler wants to react on the event type best solution found */
SCIP_CALL( SCIPcatchEvent(scip, SCIP_EVENTTYPE_NODESOLVED, eventhdlr, NULL, NULL) );
eventhdlrdata = SCIPeventhdlrGetData(eventhdlr);
assert(eventhdlrdata != NULL);
eventhdlrdata->lastpb = SCIPinfinity(scip) * (SCIPgetObjsense(scip) == SCIP_OBJSENSE_MINIMIZE ? 1.0 : -1.0);
return SCIP_OKAY;
}
/** execution method of objective change event handler */
static
SCIP_DECL_EVENTEXEC(eventExecIntobj)
{ /*lint --e{715}*/
SCIP_EVENTHDLRDATA* eventhdlrdata;
SCIP_SEPADATA* sepadata;
SCIP_VAR* var;
SCIP_Real objdelta;
eventhdlrdata = SCIPeventhdlrGetData(eventhdlr);
sepadata = (SCIP_SEPADATA*)eventhdlrdata;
assert(sepadata != NULL);
/* we don't have anything to do, if the objective value inequality doesn't yet exist */
if( sepadata->objrow == NULL )
return SCIP_OKAY;
var = SCIPeventGetVar(event);
switch( SCIPeventGetType(event) )
{
case SCIP_EVENTTYPE_VARADDED:
SCIPdebugMessage("variable <%s> with obj=%g was added to the problem\n", SCIPvarGetName(var), SCIPvarGetObj(var));
objdelta = SCIPvarGetObj(var);
if( !SCIPisZero(scip, objdelta) )
{
SCIP_CALL( SCIPaddVarToRow(scip, sepadata->objrow, var, SCIPvarGetObj(var)) );
}
break;
case SCIP_EVENTTYPE_OBJCHANGED:
SCIPdebugMessage("variable <%s> changed objective value from %g to %g\n",
SCIPvarGetName(var), SCIPeventGetOldobj(event), SCIPeventGetNewobj(event));
objdelta = SCIPeventGetNewobj(event) - SCIPeventGetOldobj(event);
SCIP_CALL( SCIPaddVarToRow(scip, sepadata->objrow, var, objdelta) );
break;
default:
SCIPerrorMessage("invalid event type %x\n", SCIPeventGetType(event));
return SCIP_INVALIDDATA;
}
return SCIP_OKAY;
}
/** event execution method of distribution branching which handles bound change events of variables */
static
SCIP_DECL_EVENTEXEC(eventExecDistribution)
{
SCIP_HEURDATA* heurdata;
SCIP_EVENTHDLRDATA* eventhdlrdata;
SCIP_VAR* var;
assert(eventhdlr != NULL);
eventhdlrdata = SCIPeventhdlrGetData(eventhdlr);
assert(eventhdlrdata != NULL);
heurdata = eventhdlrdata->heurdata;
var = SCIPeventGetVar(event);
/* add the variable to the queue of unprocessed variables; method itself ensures that every variable is added at most once */
heurdataAddBoundChangeVar(scip, heurdata, var);
return SCIP_OKAY;
}
/** initialization method of event handler (called after problem was transformed) */
static
SCIP_DECL_EVENTINIT(eventInitSofttimelimit)
{ /*lint --e{715}*/
SCIP_EVENTHDLRDATA* eventhdlrdata;
assert(scip != NULL);
assert(eventhdlr != NULL);
assert(strcmp(SCIPeventhdlrGetName(eventhdlr), EVENTHDLR_NAME) == 0);
eventhdlrdata = SCIPeventhdlrGetData(eventhdlr);
assert(eventhdlrdata != NULL);
if( eventhdlrdata->filterpos < 0 && !SCIPisNegative(scip, eventhdlrdata->softtimelimit) )
{
/* notify SCIP that your event handler wants to react on the event type best solution found */
SCIP_CALL( SCIPcatchEvent(scip, SCIP_EVENTTYPE_BESTSOLFOUND, eventhdlr, NULL, &eventhdlrdata->filterpos) );
}
return SCIP_OKAY;
}
/** deinitialization method of event handler (called before transformed problem is freed) */
static
SCIP_DECL_EVENTEXIT(eventExitSofttimelimit)
{ /*lint --e{715}*/
SCIP_EVENTHDLRDATA* eventhdlrdata;
assert(scip != NULL);
assert(eventhdlr != NULL);
assert(strcmp(SCIPeventhdlrGetName(eventhdlr), EVENTHDLR_NAME) == 0);
eventhdlrdata = SCIPeventhdlrGetData(eventhdlr);
assert(eventhdlrdata != NULL);
/* notify SCIP that your event handler wants to drop the event type best solution found */
if( eventhdlrdata->filterpos >= 0 )
{
SCIP_CALL( SCIPdropEvent(scip, SCIP_EVENTTYPE_BESTSOLFOUND, eventhdlr, NULL, eventhdlrdata->filterpos) );
eventhdlrdata->filterpos = -1;
}
return SCIP_OKAY;
}
/** destructor of event handler to free user data (called when SCIP is exiting) */
static
SCIP_DECL_EVENTFREE(eventhdlrFreeObj)
{ /*lint --e{715}*/
SCIP_EVENTHDLRDATA* eventhdlrdata;
eventhdlrdata = SCIPeventhdlrGetData(eventhdlr);
assert(eventhdlrdata != NULL);
assert(eventhdlrdata->objeventhdlr != NULL);
assert(eventhdlrdata->objeventhdlr->scip_ == scip);
/* call virtual method of eventhdlr object */
SCIP_CALL( eventhdlrdata->objeventhdlr->scip_free(scip, eventhdlr) );
/* free eventhdlr object */
if( eventhdlrdata->deleteobject )
delete eventhdlrdata->objeventhdlr;
/* free eventhdlr data */
delete eventhdlrdata;
SCIPeventhdlrSetData(eventhdlr, NULL); /*lint !e64*/
return SCIP_OKAY;
}
/** copy method for event handler plugins (called when SCIP copies plugins) */
static
SCIP_DECL_EVENTCOPY(eventhdlrCopyObj)
{ /*lint --e{715}*/
SCIP_EVENTHDLRDATA* eventhdlrdata;
assert(scip != NULL);
eventhdlrdata = SCIPeventhdlrGetData(eventhdlr);
assert(eventhdlrdata != NULL);
assert(eventhdlrdata->objeventhdlr != NULL);
assert(eventhdlrdata->objeventhdlr->scip_ != scip);
if( eventhdlrdata->objeventhdlr->iscloneable() )
{
scip::ObjEventhdlr* newobjeventhdlr;
newobjeventhdlr = dynamic_cast<scip::ObjEventhdlr*> (eventhdlrdata->objeventhdlr->clone(scip));
/* call include method of event handler object */
SCIP_CALL( SCIPincludeObjEventhdlr(scip, newobjeventhdlr, TRUE) );
}
return SCIP_OKAY;
}
/** destructor of event handler to free user data (called when SCIP is exiting) */
static
SCIP_DECL_EVENTFREE(eventhdlrFreeJava)
{ /*lint --e{715}*/
SCIP_EVENTHDLRDATA* eventhdlrdata;
JNIEnv* env;
jobject jobj;
jlong jscip;
jlong jeventhdlr;
eventhdlrdata = SCIPeventhdlrGetData(eventhdlr);
assert(eventhdlrdata != NULL);
assert(eventhdlrdata->javaeventhdlr != NULL);
assert(eventhdlrdata->scip_free != NULL);
jscip = (jlong) (size_t) scip;
jeventhdlr = (jlong) (size_t) eventhdlr;
env = eventhdlrdata->env;
jobj = eventhdlrdata->jobj;
/* call virtual method of eventhdlr object */
JNISCIP_CALL( (*env)->CallIntMethod(env, jobj, eventhdlrdata->scip_free, jscip, jeventhdlr) );
/* free eventhdlr object
*
* ??????????????????????????
*/
// if( eventhdlrdata->deleteobject )
// delete eventhdlrdata->objeventhdlr;
/* free eventhdlr data */
SCIPfreeMemory(scip, &eventhdlrdata)
SCIPeventhdlrSetData(eventhdlr, NULL); /*lint !e64*/
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;
}
