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)