def test_constraints_encoder_any_paired_constraint_exception(self):
monomer_input = ["a:s1", "b:s2"]
constraint_input = ["ANYPAIRED s1"]
tbn_problem = parse_input_lines(monomer_input, constraint_input)
sat_problem = SATProblem()
self.assertRaises(AnyPairedConstraintException,
Encoder.encode_basic_clause, tbn_problem,
sat_problem)
def test_constraints_encoder_monomer_notfree(self):
constraint_input = ["NOTFREE output"]
tbn_problem = parse_input_lines(self.monomer_input, constraint_input)
sat_problem = SATProblem()
Encoder.encode_basic_clause(tbn_problem, sat_problem)
self.assertEqual(len(sat_problem.constraint_clauses), 1)
self.assertEqual(len(sat_problem.constraint_clauses[0]), 8)
def test_constraints_encoder_together_constraint_exception(self):
monomer_input = ["a >mon1", "b >mon2"]
constraint_input = ["TOGETHER mon1 mon2"]
tbn_problem = parse_input_lines(monomer_input, constraint_input)
sat_problem = SATProblem()
self.assertRaises(TogetherConstraintException,
Encoder.encode_basic_clause, tbn_problem,
sat_problem)
def test_constraints_encoder_not_free_constraint_exception(self):
monomer_input = ["a >mon1", "b >mon2"]
constraint_input = ["NOTFREE mon1"]
tbn_problem = parse_input_lines(monomer_input, constraint_input)
sat_problem = SATProblem()
self.assertRaises(NotFreeConstraintException,
Encoder.encode_basic_clause, tbn_problem,
sat_problem)
def test_constraints_encoder_monomer_together(self):
constraint_input = ["TOGETHER output extra"]
tbn_problem = parse_input_lines(self.monomer_input, constraint_input)
sat_problem = SATProblem()
Encoder.encode_basic_clause(tbn_problem, sat_problem)
self.assertEqual(len(sat_problem.constraint_clauses), 1)
self.assertEqual(len(sat_problem.constraint_clauses[0]), 1)
def test_constraints_encoder_bsite_notanypaired(self):
constraint_input = ["NOTANYPAIRED s1"]
tbn_problem = parse_input_lines(self.monomer_input, constraint_input)
sat_problem = SATProblem()
Encoder.encode_basic_clause(tbn_problem, sat_problem)
num_complement = tbn_problem.site_type_to_sitelist_map.get(
"c").get_normal_site_count()
self.assertEqual(len(sat_problem.constraint_clauses), num_complement)
def setUp(self):
# And Gate monomer input
self.monomer_input = [
"a b c d e", "a* b* c* d*", "b* c*:s1 d* e*", "d e f",
"a b >input1", "b c:s2", "c d:s3 >input2", "e f >output",
"e* f* >extra"
]
self.constraint_input = ["FREE output"]
self.tbn_problem = parse_input_lines(self.monomer_input,
self.constraint_input)
def test_basic(self):
tbn_file = open("../input/classic.txt", 'rt')
tbn_problem = parse_input_lines(tbn_file.readlines(), [])
tbn_file.close()
sat_problem = SATProblem()
Encoder.encode_basic_clause(tbn_problem, sat_problem)
while sat_problem.success:
Encoder.increment_min_representatives(tbn_problem, sat_problem)
sat_problem.solve()
self.assertEqual(sat_problem.min_reps, 4)
def test_constraints_encoder_bsite_paired(self):
constraint_input = ["PAIRED s1 s2"]
tbn_problem = parse_input_lines(self.monomer_input, constraint_input)
sat_problem = SATProblem()
Encoder.encode_basic_clause(tbn_problem, sat_problem)
self.assertEqual(len(sat_problem.constraint_clauses), 1)
self.assertEqual(len(sat_problem.constraint_clauses[0]), 1)
pair_id = sat_problem.constraint_clauses[0][0]
pair = sat_problem.id_to_pair.get(pair_id)
self.assertEqual(pair.site1.name, "s1")
self.assertEqual(pair.site2.name, "s2")
def test_one_site(self):
monomer_onesite = ["a", "a*", "a", "a*"]
tbn_problem = parse_input_lines(monomer_onesite, [])
# basic count check
self.assertEqual(tbn_problem.monomer_count, 4)
self.assertEqual(len(tbn_problem.all_monomers), 4)
self.assertEqual(tbn_problem.site_count, 4)
# check a single site problem instance
site_list_a = tbn_problem.site_type_to_sitelist_map.get("a")
site_list_b = tbn_problem.site_type_to_sitelist_map.get("b")
self.assertEqual(len(site_list_a._complementary_sites), 2)
self.assertEqual(site_list_b, None)
def test_basic(self):
monomer_basic = ["a b*", "a* b", "a", "a* b", "b", "b"]
tbn_problem = parse_input_lines(monomer_basic, [])
# basic count check
self.assertEqual(tbn_problem.monomer_count, 6)
self.assertEqual(len(tbn_problem.all_monomers), 6)
self.assertEqual(tbn_problem.site_count, 9)
# check if valid number of non-complements and complements
site_list_a = tbn_problem.site_type_to_sitelist_map.get("a")
site_list_b = tbn_problem.site_type_to_sitelist_map.get("b")
self.assertEqual(len(site_list_a._complementary_sites), 2)
self.assertEqual(len(site_list_b._complementary_sites), 1)
def test_no_b_complement(self):
monomer_tiny = ["a b", "a*"]
tbn_problem = parse_input_lines(monomer_tiny, [])
# basic count check
self.assertEqual(tbn_problem.monomer_count, 2)
self.assertEqual(len(tbn_problem.all_monomers), 2)
self.assertEqual(tbn_problem.site_count, 3)
# check a 0-complement problem
site_list_a = tbn_problem.site_type_to_sitelist_map.get("a")
site_list_b = tbn_problem.site_type_to_sitelist_map.get("b")
self.assertEqual(len(site_list_a._complementary_sites), 1)
self.assertEqual(len(site_list_b._complementary_sites), 0)
def test_comment(self):
monomer_comment_url = "../input/comment.txt"
tbn_file = open(monomer_comment_url, 'rt')
monomer_comment = tbn_file.readlines()
tbn_file.close()
tbn_problem = parse_input_lines(monomer_comment, [])
self.assertEqual(tbn_problem.monomer_count, 4)
self.assertEqual(len(tbn_problem.all_monomers), 4)
self.assertEqual(tbn_problem.site_count, 6)
site_list_c = tbn_problem.site_type_to_sitelist_map.get("c")
self.assertEqual("c" in tbn_problem.site_type_to_sitelist_map.keys(),
False)
def test_and_gate_parsing(self):
monomer_and_gate_url = "../input/and_gate.txt"
tbn_file = open(monomer_and_gate_url, 'rt')
monomer_and_gate = tbn_file.readlines()
tbn_file.close()
tbn_problem = parse_input_lines(monomer_and_gate, [])
self.assertEqual(tbn_problem.monomer_count, 9)
self.assertEqual(len(tbn_problem.all_monomers), 9)
self.assertEqual(tbn_problem.site_count, 26)
site_list_e = tbn_problem.site_type_to_sitelist_map.get("e")
site_list_f = tbn_problem.site_type_to_sitelist_map.get("f")
self.assertEqual(len(site_list_e._complementary_sites), 2)
self.assertEqual(len(site_list_f._complementary_sites), 1)
def test_and_gate_names(self):
monomer_and_gate_url = "../input/and_gate.txt"
tbn_file = open(monomer_and_gate_url, 'rt')
monomer_and_gate = tbn_file.readlines()
tbn_file.close()
tbn_problem = parse_input_lines(monomer_and_gate, [])
# Verify Binding Site Names
self.assertEqual(len(tbn_problem.bindingsite_name_map), 3)
bsite_1 = tbn_problem.bindingsite_name_map.get("s1")
self.assertEqual(bsite_1.name, "s1")
self.assertEqual(bsite_1.type, "c")
self.assertEqual(bsite_1.IsComplement, True)
bsite_2 = tbn_problem.bindingsite_name_map.get("s2")
self.assertEqual(bsite_2.name, "s2")
self.assertEqual(bsite_2.type, "c")
self.assertEqual(bsite_2.IsComplement, False)
bsite_3 = tbn_problem.bindingsite_name_map.get("s3")
self.assertEqual(bsite_3.name, "s3")
self.assertEqual(bsite_3.type, "d")
self.assertEqual(bsite_3.IsComplement, False)
# Verify Monomer Names
input_1 = tbn_problem.monomer_name_map.get("input1")
self.assertEqual(input_1.name, "input1")
self.assertEqual(len(input_1.BindingSites), 2)
input_2 = tbn_problem.monomer_name_map.get("input2")
self.assertEqual(input_2.name, "input2")
self.assertEqual(len(input_2.BindingSites), 2)
output = tbn_problem.monomer_name_map.get("output")
self.assertEqual(output.name, "output")
self.assertEqual(len(output.BindingSites), 2)
def get_stable_config(tbn_lines,
constr_lines,
gen_count,
init_k,
celery_task=None):
# parse the input to encode it into BindingSite/Monomer classes
t0 = time.time()
# Celery Task is flag to indicate if a call is made from library or from a celery broker worker API
if celery_task is not None:
if celery_task.is_aborted():
raise EarlyTerminationException(0, 0)
celery_task.update_state(state="PROGRESS",
meta={
'status': "Progress",
'count': 0,
'k': 0
})
tbn_problem = parse_input_lines(tbn_lines, constr_lines)
tbn_problem.gen_count = gen_count
tbn_problem.init_k = init_k
configs = []
# encode problem to SAT solver compatible problem
sat_problem = SATProblem()
Encoder.encode_basic_clause(tbn_problem, sat_problem)
print()
print("[1] COMPUTING ORIGINAL STABLE CONFIGURATION:")
# Increment solver to minimum polymers before computing
while sat_problem.min_reps < tbn_problem.init_k:
Encoder.increment_min_representatives(tbn_problem, sat_problem)
original_num_reps = 0
# solve the problem (SAT solver)
while sat_problem.success:
if celery_task is not None:
if celery_task.is_aborted():
raise EarlyTerminationException(1, sat_problem.min_reps)
celery_task.update_state(state="PROGRESS",
meta={
'status': "Progress",
'count': 1,
'k': sat_problem.min_reps
})
else:
print("... Checking for k =", sat_problem.min_reps, "polymers")
sat_problem.solve(False)
if (sat_problem.success):
original_num_reps = sat_problem.min_reps
Encoder.increment_min_representatives(tbn_problem, sat_problem)
if original_num_reps > 0:
if celery_task is None:
print("Found an original stable configuration with [",
original_num_reps, "] polymers.\n")
else:
if celery_task is None:
print("Could not find original stable configuration with [",
tbn_problem.init_k, "] polymers.\n")
# Printing execution time
print("\nCompleted in", time.time() - t0, "seconds.\n")
raise MinPolymersExceedEntropyException(tbn_problem.init_k)
# Decode the problem into polymers and print results
polymers = Decoder.decode_boolean_values(tbn_problem, sat_problem)
if celery_task is None:
for index, polymer in enumerate(polymers):
print("\t" + "Polymer number", index + 1)
for monomer in polymer.monomer_list:
print("\t\t" + str(monomer))
print()
# SOLVING WITH CONSTRAINTS
if len(tbn_problem.constraints) != 0:
configs = get_stable_configs_using_constraints(tbn_problem,
sat_problem,
original_num_reps,
celery_task)
# SOLVING WITHOUT CONSTRAINTS
else:
# Add original configuration solution to result list
configs.append(polymers)
# Generate additional unique solutions
if tbn_problem.gen_count > 1:
additional_configs = get_stable_configs_using_constraints(
tbn_problem, sat_problem, original_num_reps, celery_task)
# Add results to existing solution list
configs.extend(additional_configs)
# Printing execution time
if celery_task is None:
print("\nCompleted in", time.time() - t0, "seconds.\n")
return configs, original_num_reps
def setUp(self):
self.monomer_input = ["a b", "a* b*", "a", "b"]
self.tbn_problem = parse_input_lines(self.monomer_input, [])
def test_constraint_monomer_nottogether(self):
constr_input = ["NOTTOGETHER mon1 mon2"]
tbn_problem = parse_input_lines(self.monomer_labeled, constr_input)
constr = tbn_problem.constraints[0]
self.assertEqual(constr.c_type, CONSTR.NOTTOGETHER)
self.assertEqual(len(constr.arguments), 2)
def test_constraint_monomer_notfree(self):
constr_input = ["NOTFREE mon1"]
tbn_problem = parse_input_lines(self.monomer_labeled, constr_input)
constr = tbn_problem.constraints[0]
self.assertEqual(constr.c_type, CONSTR.NOTFREE)
self.assertEqual(len(constr.arguments), 1)
def test_constraint_bsite_notanypaired(self):
constr_input = ["NOTANYPAIRED s1"]
tbn_problem = parse_input_lines(self.monomer_labeled, constr_input)
constr = tbn_problem.constraints[0]
self.assertEqual(constr.c_type, CONSTR.NOTANYPAIRED)
self.assertEqual(len(constr.arguments), 1)
