def test_longer(self):
ass = Assembly()
ass.coalesce(np.array([[0., 0.], [2., 2.]]))
labels = ass.coalesce(np.array([[1.9, 1.9], [3., 3.], [0.1, 0.1]]))
self.assertTrue(np.array_equal(labels, [1, 2, 0]))
self.assertTrue(
np.array_equal(ass.points, [[0.1, 0.1], [1.9, 1.9], [3., 3.]]))
def test_coalesce(self):
ass = Assembly()
ass.coalesce(np.array([[0., 0.], [2., 2.]]))
ass.coalesce(np.array([[1.9, 1.9], [3, 3], [0.1, 0.1]]))
labels = ass.coalesce(np.array([[2.9, 2.9], [2.1, 2.1]]))
self.assertTrue(np.array_equal(labels, [2, 1]))
self.assertTrue(
np.array_equal(ass.points, [[0.1, 0.1], [2.1, 2.1], [2.9, 2.9]]))
def create_cantilever(l, w):
assem = Assembly(2)
assem.rename_node(0, "gnd")
assem.rename_node(1, "tip")
layer = SOI_berk()
assem.add_model(Anchor(1, 1, layer.p1), ["gnd"])
assem.add_model(Beam2D(l, w, layer.p1), ["gnd", "tip"])
def __init__(self, **kwargs):
"""
Build a new OC instance
"""
frame_size = kwargs.get('frame_size', 100)
self.frame = deque([], frame_size)
del kwargs['frame_size']
self.algo = Batch(MCMC, **kwargs)
self.ass = Assembly()
def genome_assembly(args):
accession, fastq_dir, outdir = args
contig_dir = Path(outdir, 'contig', accession)
assembly = Assembly(accession=accession,
reads_path=fastq_dir,
outdir=outdir)
assembly.denovo()
assembly.move_contig(contig_dir)
shutil.rmtree(fastq_dir)
shutil.rmtree(assembly.outdir)
return accession, contig_dir, outdir
def main(self):
printwithtime("Welcome to the metassembler.")
self.process_arguments()
self.check_input()
self.get_delta()
self.process_delta()
self.contigs_from_fasta()
self.contigs_from_alignments() # TODO: these two methods should be merged?
if self.process_indels_bool: self.process_indels()
self.get_all_neighbors()
if self.perform_assembly_bool:
self.assemble()
else:
for contig in self.contigs.values(): self.assemblies[contig.name] = Assembly([contig])
for assembly in self.assemblies.values():
assembly.get_sequence()
self.cleanup()
self.summary()
self.write_output()
printwithtime("Done.")
# The name of the json file to save the assembly into
PATH_TO = os.path.join(
DATA,
os.path.splitext(os.path.basename(__file__))[0] + ".json")
# Load assembly settings
settings_file = os.path.join(DATA, "settings.json")
with open(settings_file, 'r') as f:
data = json.load(f)
brick = Element.from_data(data['brick'])
halfbrick = Element.from_data(data['halfbrick'])
width, length, height = data['brick_dimensions']
# Create assembly
assembly = Assembly()
# ==============================================================================
# Your code goes here.
# HINT: Use the examples to see how to re-use the brick/halfbrick elements
# defined above, and get a transformed instance of each of them as you
# build up your brick wall.
# Your code comes here
# ==============================================================================
# Transform assembly to correct location and adjust if needed
assembly.transform(Translation([-0.26, -0.34, 0]))
# Save assembly to json
assembly.to_json(PATH_TO, pretty=True)
def assemble(self):
printwithtime("Assembling contigs...")
contigs_copy = self.contigs.copy()
# greedily finds "anchor" contigs (with no neighbors on one side)
for key, contig in self.contigs.items():
if contig.left == [None] or contig.right == [None]:
index = len(self.assemblies)
assembly = Assembly([contig])
assembly.left = contig.left
assembly.right = contig.right
self.assemblies[index] = assembly
del(contigs_copy[key])
print("Assigning %s to assembly %i // %i contigs remaining to assign") % (key, index, len(contigs_copy))
self.contigs = contigs_copy
num_contigs_list = [None, None]
while contigs_copy != {}:
if num_contigs_list[0] == num_contigs_list[1] != None:
break
else:
for index, assembly in self.assemblies.items():
for key, contig in self.contigs.items():
if assembly.assembly[-1] in contig.left:
if len(assembly.right) == 1 and len(contig.left) == 1:
assembly.assembly.append(contig)
assembly.right = contig.right
del(contigs_copy[key])
print("Assigning %s to assembly %i // %i contigs remaining to assign") % (key, index, len(contigs_copy))
elif assembly.assembly[0] in contig.right:
if len(assembly.left) == 1 and len(contig.right) == 1:
assembly.assembly.insert(0, contig)
assembly.left = contig.left
del(contigs_copy[key])
print("Assigning %s to assembly %i // %i contigs remaining to assign") % (key, index, len(contigs_copy))
num_contigs_list[0] = num_contigs_list[1]
num_contigs_list[1] = len(contigs_copy)
# TODO: list value of xrange(100) [1st pass, 2nd pass...]
# TODO: make it more clear when it enters this phase
####### handle any unassigned contigs
if contigs_copy != {}:
printwithtime("Assigning unassignable contigs")
index = int(max(self.assemblies.keys())) # ensures that nothing is being overwritten
# TODO: add a try/except loop that double-checks nothing is being overwritten
for key, contig in self.contigs.items():
index += 1
self.assemblies[index] = Assembly([contig], contig.left, contig.right)
del(contigs_copy[key])
print("Assigning %s to assembly %i // %i contigs remaining to assign") % (key, index, len(contigs_copy))
####### merging assemblies
# TODO: current issue, sometimes combines one assembly into multiple places...
printwithtime("Merging assemblies...")
num_merges = 0
assemblies_copy = self.assemblies.copy()
for asmb1 in assemblies_copy.items():
for asmb2 in assemblies_copy.items():
if asmb1 != asmb2 and asmb1 in self.assemblies.items():
# the and clause helps ensure that assemblies are not merged into
# assemblies that no longer exist
asmb1_index = asmb1[0]
asmb1_asmb = asmb1[1]
asmb2_index = asmb2[0]
asmb2_asmb = asmb2[1]
if (asmb2_asmb.assembly[0] in asmb1_asmb.right and asmb1_asmb.right != [None] and asmb2_asmb.left != [None]) or \
(asmb1_asmb.assembly[-1] in asmb2_asmb.left and asmb2_asmb.left != [None] and asmb1_asmb.right != [None]):
if len(asmb1_asmb.right) == 1 and len(asmb2_asmb.left) == 1:
print("Merging assembly %s into assembly %s") % (asmb2_index, asmb1_index)
# print("Old assemblies: %s and %s") % (asmb1_asmb, asmb2_asmb)
asmb1_asmb.assembly.extend(asmb2_asmb.assembly)
# print("New assembly: %i %s") % (asmb1_index, asmb1_asmb)
asmb1_asmb.right = asmb2_asmb.right
num_merges += 1
try:
del(assemblies_copy[asmb2_index])
del(self.assemblies[asmb2_index])
except:
printwithtime("exception!")
# printwithtime("---")
elif (asmb1_asmb.assembly[0] in asmb2_asmb.right and asmb2_asmb.right != [None] and asmb1_asmb.left != [None]) or \
(asmb2_asmb.assembly[-1] in asmb1_asmb.left and asmb1_asmb.left != [None] and asmb2_asmb.right != [None]):
if len(asmb2_asmb.right) == 1 and len(asmb1_asmb.left) == 1:
print("Merging assembly %s into assembly %s") % (asmb1_index, asmb2_index)
# print("Old assemblies: %s and %s") % (asmb1_asmb, asmb2_asmb)
asmb2_asmb.assembly.extend(asmb1_asmb.assembly)
# print("New assembly: %i %s") % (asmb1_index, asmb2_asmb)
asmb2_asmb.right = asmb1_asmb.right
num_merges += 1
try:
del(assemblies_copy[asmb1_index])
del(self.assemblies[asmb1_index])
except:
printwithtime("exception!")
# printwithtime(asmb1_asmb, asmb1_index, asmb1_asmb.left, asmb1_asmb.right
# printwithtime(asmb2, asmb2_index, asmb2_asmb.left, asmb2_asmb.right
# printwithtime("---"
print("%i merges made.") % (num_merges)
def test_init(self):
ass = Assembly()
labels = ass.coalesce(np.array([[0., 0.], [2., 2.]]))
self.assertTrue(np.array_equal(labels, [0, 1]))
def test_shorter(self):
ass = Assembly()
ass.coalesce(np.array([[0., 0.], [2., 2.]]))
labels = ass.coalesce(np.array([[1.9, 1.9]]))
self.assertTrue(np.array_equal(labels, [1]))
self.assertTrue(np.array_equal(ass.points, [[0., 0.], [1.9, 1.9]]))
