def run_Cogent_on_input():
"""
The main reconstruction function.
Homopolymers and repeated nodes in path must be resolved first.
(however, it's possible the graph contains cycles not manifested in path,
this is a bug that will result in failure to *explain* the sequences later,
right now I catch the bug by using the sequence pth itself but this should be fixed eventually)
Graph reduction is iteratively done until cannot be further reduced
Two points of failure:
(1) graph is not reduced to small enough, too many paths, mem explosion
cur soln: fall back to using own paths
(2) cycle in graph
cur soln: fall back to using own paths (still wrong)
"""
time1 = time.time()
# first trim in.fa away all lower case
f = open('in.trimmed.fa', 'w')
for r in SeqIO.parse(open('in.fa'),'fasta'):
f.write(">{0}\n{1}\n".format(r.id, trim_ends(str(r.seq))))
f.close()
seqweights = {}
# read in the weights for each sequence
with open('in.weights') as f:
for line in f:
seqid, weight = line.strip().split('\t')
seqweights[seqid] = int(weight)
adjusted_kmer = splice_cycle.precycle_kmer_adjustment(cc_settings.KMER_SIZE)
if adjusted_kmer != cc_settings.KMER_SIZE:
log.info("Adjusting k-mer size to: {0}".format(adjusted_kmer))
cc_settings.KMER_SIZE = adjusted_kmer
# setting up the DiGraph
G = nx.DiGraph()
node_d = {None: -1} # this is just used to initialize the graph, delete it later
path_d = {}
reader = SeqIO.parse(open('in.trimmed.fa'),'fasta')
seqrecs = []
for r in reader:
sp.add_seq_to_graph(G, node_d, path_d, str(r.seq), r.id, seqweights[r.id])
seqrecs.append(r)
del node_d[None]
mermap = dict((v,k) for k,v in node_d.iteritems())
# resolve all homopolymers
homo_nodes = filter(lambda n: G.has_edge(n, n), G.nodes_iter())
for n in homo_nodes:
sp.untangle_homopolymer_helper(G, path_d, mermap, seqweights, n)
splice_cycle.detect_and_replace_cycle(G, path_d, seqweights, mermap, max(G.nodes()), cc_settings.KMER_SIZE)
visited = {}
sp.reachability(G, mermap, visited, path_d)
# cycle detection and abort if detected
# (this should not happen with splice_cycle.detect_and_replace_cycle run)
for k,v in path_d.iteritems():
for x in v:
if v.count(x) > 1:
log.info("CYCLE detected through path analysis! Raise CycleDetectedException!")
os.system("touch CYCLE_DETECTED")
raise CycleDetectedException
if cc_settings.NX_CYCLE_DETECTION:
log.info("Doing nx.cycle_detection....")
iter = nx.simple_cycles(G)
for _it in iter:
print >> sys.stderr, "CYCLE detected through simple_cycles! Raise CycleDetectedException!"
os.system("touch CYCLE_DETECTED")
raise CycleDetectedException
nx.write_graphml(G, 'in.0.graphml')
log.info("Initial Graph Size: {0} nodes, {1} edges".format(G.number_of_nodes(), G.number_of_edges()))
## sanity check: confirm that all sequences can be reconstructed via the collapsed graph
## also check that all nodes are visited
#for n in G.nodes_iter(): assert n in visited
#for k,v in path_d.iteritems():
# s = sp.stitch_string_from_path(v, mermap)
# s2 = seqdict[k].seq.tostring().upper()
# assert s.find(s2) >= 0
while True:
cur_num_nodes = G.number_of_nodes()
sp.find_source_bubbles(G, path_d, mermap)
sp.reachability(G, mermap, {}, path_d)
sp.find_bubbles(G, path_d, mermap)
sp.reachability(G, mermap, {}, path_d)
sp.contract_sinks(G, path_d, mermap)
sp.find_dangling_sinks(G, path_d, mermap)
sp.reachability(G, mermap, {}, path_d)
#assert sanity_check_path_all_valid(path_d, G)
if G.number_of_nodes() == cur_num_nodes:
break
nx.write_graphml(G, 'in.1.graphml')
log.info("Post-Reduction Graph Size: {0} nodes, {1} edges".format(G.number_of_nodes(), G.number_of_edges()))
time2 = time.time()
keys = path_d.keys()
keys.sort()
good_for, paths = find_minimal_path_needed_to_explain_pathd(G, path_d, keys)
solve_with_lp_and_reduce(good_for, paths, mermap)
time3 = time.time()
run_gmap()
post_gmap_processing(seqrecs=seqrecs)
time4 = time.time()
log.info("[RUNTIME] for graph construction and reduction: {0}".format(time2-time1))
log.info("[RUNTIME] for path finding and LP solving: {0}".format(time3-time2))
log.info("[RUNTIME] for GMAP and post-processing: {0}".format(time4-time3))
log.info("[RUNTIME] Total time in run_Cogent: {0}".format(time4-time1))
def run_Cogent_on_input():
"""
The main reconstruction function.
Homopolymers and repeated nodes in path must be resolved first.
(however, it's possible the graph contains cycles not manifested in path,
this is a bug that will result in failure to *explain* the sequences later,
right now I catch the bug by using the sequence pth itself but this should be fixed eventually)
Graph reduction is iteratively done until cannot be further reduced
Two points of failure:
(1) graph is not reduced to small enough, too many paths, mem explosion
cur soln: fall back to using own paths
(2) cycle in graph
cur soln: fall back to using own paths (still wrong)
"""
time1 = time.time()
# first trim in.fa away all lower case
f = open("in.trimmed.fa", "w")
for r in SeqIO.parse(open("in.fa"), "fasta"):
f.write(">{0}\n{1}\n".format(r.id, trim_ends(str(r.seq))))
f.close()
seqweights = {}
# read in the weights for each sequence
with open("in.weights") as f:
for line in f:
seqid, weight = line.strip().split("\t")
seqweights[seqid] = int(weight)
adjusted_kmer = splice_cycle.precycle_kmer_adjustment(cc_settings.KMER_SIZE)
if adjusted_kmer != cc_settings.KMER_SIZE:
log.info("Adjusting k-mer size to: {0}".format(adjusted_kmer))
cc_settings.KMER_SIZE = adjusted_kmer
# setting up the DiGraph
G = nx.DiGraph()
node_d = {None: -1} # this is just used to initialize the graph, delete it later
path_d = {}
reader = SeqIO.parse(open("in.trimmed.fa"), "fasta")
seqrecs = []
for r in reader:
sp.add_seq_to_graph(G, node_d, path_d, str(r.seq), r.id, seqweights[r.id])
seqrecs.append(r)
del node_d[None]
mermap = dict((v, k) for k, v in node_d.iteritems())
# resolve all homopolymers
homo_nodes = filter(lambda n: G.has_edge(n, n), G.nodes_iter())
for n in homo_nodes:
sp.untangle_homopolymer_helper(G, path_d, mermap, seqweights, n)
splice_cycle.detect_and_replace_cycle(G, path_d, seqweights, mermap, max(G.nodes()), cc_settings.KMER_SIZE)
visited = {}
sp.reachability(G, mermap, visited, path_d)
# cycle detection and abort if detected
# (this should not happen with splice_cycle.detect_and_replace_cycle run)
for k, v in path_d.iteritems():
for x in v:
if v.count(x) > 1:
log.info("CYCLE detected through path analysis! Raise CycleDetectedException!")
os.system("touch CYCLE_DETECTED")
raise CycleDetectedException
if cc_settings.NX_CYCLE_DETECTION:
log.info("Doing nx.cycle_detection....")
iter = nx.simple_cycles(G)
for _it in iter:
print >>sys.stderr, "CYCLE detected through simple_cycles! Raise CycleDetectedException!"
os.system("touch CYCLE_DETECTED")
raise CycleDetectedException
nx.write_graphml(G, "in.0.graphml")
log.info("Initial Graph Size: {0} nodes, {1} edges".format(G.number_of_nodes(), G.number_of_edges()))
## sanity check: confirm that all sequences can be reconstructed via the collapsed graph
## also check that all nodes are visited
# for n in G.nodes_iter(): assert n in visited
# for k,v in path_d.iteritems():
# s = sp.stitch_string_from_path(v, mermap)
# s2 = seqdict[k].seq.tostring().upper()
# assert s.find(s2) >= 0
while True:
cur_num_nodes = G.number_of_nodes()
sp.find_source_bubbles(G, path_d, mermap)
sp.reachability(G, mermap, {}, path_d)
sp.find_bubbles(G, path_d, mermap)
sp.reachability(G, mermap, {}, path_d)
sp.contract_sinks(G, path_d, mermap)
sp.find_dangling_sinks(G, path_d, mermap)
sp.reachability(G, mermap, {}, path_d)
# assert sanity_check_path_all_valid(path_d, G)
if G.number_of_nodes() == cur_num_nodes:
break
nx.write_graphml(G, "in.1.graphml")
log.info("Post-Reduction Graph Size: {0} nodes, {1} edges".format(G.number_of_nodes(), G.number_of_edges()))
time2 = time.time()
keys = path_d.keys()
keys.sort()
good_for, paths = find_minimal_path_needed_to_explain_pathd(G, path_d, keys)
solve_with_lp_and_reduce(good_for, paths, mermap)
time3 = time.time()
run_gmap()
post_gmap_processing(seqrecs=seqrecs)
time4 = time.time()
log.info("[RUNTIME] for graph construction and reduction: {0}".format(time2 - time1))
log.info("[RUNTIME] for path finding and LP solving: {0}".format(time3 - time2))
log.info("[RUNTIME] for GMAP and post-processing: {0}".format(time4 - time3))
log.info("[RUNTIME] Total time in run_Cogent: {0}".format(time4 - time1))