bool MSConnectivityScore::check_assignment(NNGraph &G, unsigned int node_handle,
Assignment const &assignment,
EdgeSet &picked) const {
MSConnectivityRestraint::ExperimentalTree::Node const *node =
tree_.get_node(node_handle);
MSConnectivityRestraint::ExperimentalTree::Node::Label const &lb =
node->get_label();
Vector<Tuples> new_tuples;
Ints empty_vector;
for (unsigned int i = 0; i < lb.size(); ++i) {
int prot_count = lb[i].second;
unsigned int id = lb[i].first;
while (new_tuples.size() < id)
new_tuples.push_back(Tuples(empty_vector, 0));
if (prot_count > 0) {
if (!assignment[id].empty()) {
Ints const &configuration = assignment[id].get_tuple();
if (prot_count > int(configuration.size())) {
IMP_THROW("Experimental tree is inconsistent",
IMP::ValueException);
}
new_tuples.push_back(Tuples(configuration, prot_count));
} else {
IMP_THROW("Experimental tree is inconsistent",
IMP::ValueException);
}
} else
new_tuples.push_back(Tuples(empty_vector, 0));
}
while (new_tuples.size() <
restraint_.particle_matrix_.get_number_of_classes())
new_tuples.push_back(Tuples(empty_vector, 0));
Assignment new_assignment(new_tuples);
if (new_assignment.empty()) return false;
do {
NNGraph ng = build_subgraph_from_assignment(G, new_assignment);
if (is_connected(ng)) {
EdgeSet n_picked;
bool good = true;
for (unsigned int i = 0; i < node->get_number_of_children(); ++i) {
unsigned int child_handle = node->get_child(i);
if (!check_assignment(ng, child_handle, new_assignment, n_picked)) {
good = false;
break;
}
}
if (good) {
add_edges_to_set(ng, n_picked);
picked.insert(n_picked.begin(), n_picked.end());
return true;
}
}
} while (new_assignment.next());
return false;
}
static
void process_clause(Mclause c, Mstate state)
{
if (c->subsumed)
return;
else if (c->u.active == 0) {
if (flag(Opt->trace))
printf("\t\t\t\t\t** BACKUP **\n");
state->ok = FALSE;
return;
}
else if (c->u.active != 1)
return; /* nonunit, so do nothing */
else {
/* OK, we have a nonsubsumed unit. */
Term lit, beta;
BOOL negated, eq;
int id;
int i = 0;
while (FALSE_TERM(LIT(c,i)))
i++;
lit = LIT(c,i);
negated = NEGATED(lit);
eq = EQ_TERM(lit);
#if 0
printf("process_clause 1: ");
p_matom(lit);
#endif
if (!eq && eterm(lit, &id))
beta = Domain[negated ? 0 : 1]; /* P(1,2,3) or ~P(1,2,3) */
else if (eq && eterm(ARG(lit,0),&id) && VARIABLE(ARG(lit,1)))
beta = ARG(lit,1); /* f(1,2)=3 or f(1,2)!=3 */
else if (eq && eterm(ARG(lit,1),&id) && VARIABLE(ARG(lit,0)))
beta = ARG(lit,0); /* 3=f(1,2) or 3!=f(1,2) */
else {
if (flag(Opt->negprop))
/* If it is an nterm, index and insert into job list. */
nterm_check_and_process(lit, state);
return; /* We cannot do anything else with the unit. */
}
if (eq && negated)
new_elimination(id, beta, state); /* f(1,2) != 3 */
else
new_assignment(id, beta, state); /* f(1,2) = 3, P(0), ~P(0) */
}
} /* process_clause */
void new_elimination(int id, Term beta, Mstate state)
{
if (Cells[id].value == beta) {
if (flag(Opt->trace)) {
printf("\t\t\t\t\t");
fwrite_term(stdout, Cells[id].eterm);
printf(" != %d BACKUP!\n", VARNUM(beta));
}
state->ok = FALSE; /* contradiction: cell already has that value! */
return;
}
else if (Cells[id].value != NULL)
return; /* ok: cell already has a (different) value */
else if (Cells[id].possible[VARNUM(beta)] == NULL)
return; /* ok: already crossed off */
else {
/* New unit f(1,2) != 3. Cross it off and push for negprop. */
Term value;
Mstats.cross_offs++;
state->stack=update_and_push((void **) &(Cells[id].possible[VARNUM(beta)]),
NULL, state->stack);
if (flag(Opt->trace)) {
printf("\t\t\t\t\t");
fwrite_term(stdout, Cells[id].eterm);
printf(" != %d\n", VARNUM(beta));
}
if (flag(Opt->negprop))
job_prepend(state, ELIMINATION, id, NULL, beta, -1);
value = pvalues_check(Cells[id].possible, Domain_size);
if (value == NULL)
return; /* ok: nothing more to do */
else {
Mstats.rules_from_neg++;
new_assignment(id, value, state);
}
}
} /* new_elimination */
