/** adds initial constraint to root node */
SCIP_RETCODE SCIPconsOrigbranchAddRootCons(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_CONSHDLR* conshdlr;
SCIP_CONSHDLRDATA* conshdlrdata;
SCIP_CONS* cons;
assert(scip != NULL);
conshdlr = SCIPfindConshdlr(scip, CONSHDLR_NAME);
if( conshdlr == NULL )
{
SCIPerrorMessage("origbranch constraint handler not found\n");
return SCIP_ERROR;
}
conshdlrdata = SCIPconshdlrGetData(conshdlr);
assert(conshdlrdata != NULL);
if( conshdlrdata->rootcons == NULL )
{
SCIP_CALL( GCGcreateConsOrigbranch(scip, &cons, "root-origbranch", NULL, NULL, NULL, NULL) );
SCIP_CALL( SCIPaddConsNode(scip, SCIPgetRootNode(scip), cons, SCIPgetRootNode(scip)) );
conshdlrdata->rootcons = cons;
}
/* check consistency */
GCGconsOrigbranchCheckConsistency(scip);
return SCIP_OKAY;
}
/** branches on disjunctive constraint */
static
SCIP_RETCODE branchCons(
SCIP* scip, /**< SCIP data structure */
SCIP_CONS* cons, /**< active disjunction constraint */
SCIP_RESULT* result /**< pointer to store the result */
)
{
SCIP_CONSDATA* consdata;
SCIP_CONS** conss;
SCIP_NODE* child;
SCIP_Real estimate;
int nconss;
int i;
assert(result != NULL);
/* cannot branch on modifiable constraint */
if( SCIPconsIsModifiable(cons) )
return SCIP_OKAY;
consdata = SCIPconsGetData(cons);
assert(consdata != NULL);
conss = consdata->conss;
assert(conss != NULL);
nconss = consdata->nconss;
assert(nconss > 0);
estimate = SCIPgetLocalTransEstimate(scip);
/* add all inactive constraints to local subproblem */
for( i = 0; i < nconss; ++i )
{
/* create the branch-and-bound tree child nodes of the current node */
SCIP_CALL( SCIPcreateChild(scip, &child, 0.0, estimate) );
/* add constraints to nodes */
SCIP_CALL( SCIPaddConsNode(scip, child, conss[i], NULL) );
/* remove disjunction constraint, from child node */
SCIP_CALL( SCIPdelConsNode(scip, child, cons) );
}
/* reset constraint age */
SCIP_CALL( SCIPresetConsAge(scip, cons) );
*result = SCIP_BRANCHED;
return SCIP_OKAY;
}
/** branching execution method for fractional LP solutions */
static
SCIP_DECL_BRANCHEXECLP(branchExeclpStp)
{ /*lint --e{715}*/
SCIP_PROBDATA* probdata;
SCIP_CONS* consin;
SCIP_CONS* consout;
SCIP_NODE* vertexin;
SCIP_NODE* vertexout;
SCIP_VAR** edgevars;
SCIP_Real estimatein;
SCIP_Real estimateout;
GRAPH* g;
int e;
int branchvertex;
assert(branchrule != NULL);
assert(strcmp(SCIPbranchruleGetName(branchrule), BRANCHRULE_NAME) == 0);
assert(scip != NULL);
assert(result != NULL);
SCIPdebugMessage("Execlp method of Stp branching\n ");
estimatein = SCIPgetUpperbound(scip);
estimateout = SCIPgetUpperbound(scip);
*result = SCIP_DIDNOTRUN;
/* get problem data */
probdata = SCIPgetProbData(scip);
assert(probdata != NULL);
/* get graph */
g = SCIPprobdataGetGraph(probdata);
assert(g != NULL);
/* get vertex to branch on */
SCIP_CALL( selectBranchingVertex(scip, &branchvertex) );
if( branchvertex == UNKNOWN )
{
SCIPdebugMessage("Branching did not run \n");
return SCIP_OKAY;
}
edgevars = SCIPprobdataGetEdgeVars(scip);
/* create constraints */
SCIP_CALL( SCIPcreateConsLinear(scip, &consin, "consin", 0,
NULL, NULL, 1.0, 1.0,
TRUE, TRUE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE) );
SCIP_CALL( SCIPcreateConsLinear(scip, &consout, "consout", 0,
NULL, NULL, 0.0, 0.0,
TRUE, TRUE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE) );
for( e = g->inpbeg[branchvertex]; e != EAT_LAST; e = g->ieat[e] )
{
SCIP_CALL( SCIPaddCoefLinear(scip, consin, edgevars[e], 1.0) );
SCIP_CALL( SCIPaddCoefLinear(scip, consout, edgevars[e], 1.0) );
SCIP_CALL( SCIPaddCoefLinear(scip, consout, edgevars[flipedge(e)], 1.0) );
}
/* create the child nodes */
SCIP_CALL( SCIPcreateChild(scip, &vertexin, 1.0, estimatein) );
SCIP_CALL( SCIPcreateChild(scip, &vertexout, 1.0, estimateout) );
assert(vertexin != NULL);
assert(vertexout != NULL);
SCIP_CALL( SCIPaddConsNode(scip, vertexin, consin, NULL) );
SCIP_CALL( SCIPaddConsNode(scip, vertexout, consout, NULL) );
/* relase constraints */
SCIP_CALL( SCIPreleaseCons(scip, &consin) );
SCIP_CALL( SCIPreleaseCons(scip, &consout) );
SCIPdebugMessage("Branched on stp vertex %d \n", branchvertex);
*result = SCIP_BRANCHED;
return SCIP_OKAY;
}
