def read_input_tree_file(self, outfname):
if self.args.debug:
print ' reading trees from %s' % self.args.input_simulation_treefname
utils.simplerun('cp %s %s' %
(self.args.input_simulation_treefname, outfname),
debug=False)
ages, treestrs = [], []
with open(outfname) as treefile:
for line in treefile:
tstr = line.strip()
if tstr == '': # skip empty lines
continue
dtree = treeutils.get_dendro_tree(
treestr=tstr, suppress_internal_node_taxa=True)
if dtree.seed_node.edge_length is None: # make sure root edge length is set (otherwise bppseqgen barfs)
dtree.seed_node.edge_length = 0.
old_new_label_pairs = [
(l.taxon.label, 't%d' % (i + 1))
for i, l in enumerate(dtree.leaf_node_iter())
]
treeutils.translate_labels(
dtree, old_new_label_pairs
) # rename the leaves to t1, t2, etc. (it would be nice to not have to do this, but a bunch of stuff in recombinator uses this to check that e.g. bppseqgen didn't screw up the ordering)
age = self.choose_full_sequence_branch_length()
if self.args.debug > 1: # it's easier to keep this debug line separate up here than make a tmp variable to keep track of the old height
print ' input tree %d (rescaled depth %.3f --> %.3f):' % (
len(ages), treeutils.get_mean_leaf_height(tree=dtree),
age)
treeutils.rescale_tree(
age, dtree=dtree
) # I think this gets rescaled again for each event, so we could probably in principle avoid this rescaling, but if the input depth is greater than one stuff starts breaking, so may as well do it now
ages.append(age)
treestrs.append(dtree.as_string(schema='newick').strip())
if self.args.debug > 1:
print utils.pad_lines(treeutils.get_ascii_tree(dtree))
if any(a > 1. for a in ages):
raise Exception(
'tree depths must be less than 1., but trees read from %s don\'t satisfy this: %s'
% (self.args.input_simulation_treefname, ages))
if len(ages) != self.args.n_trees:
print ' resetting --n-trees from %d to %d to match trees read from %s' % (
self.args.n_trees, len(ages),
self.args.input_simulation_treefname)
self.args.n_trees = len(ages)
return ages, treestrs
def generate_trees(self, seed, outfname, workdir):
if self.args.input_simulation_treefname is None: # default: generate our own trees
ages, treestrs = self.run_treesim(seed, outfname, workdir)
else: # read trees from a file that pass set on the command line
ages, treestrs = self.read_input_tree_file(outfname)
os.remove(
outfname
) # remove it here, just to make clear that we *re*write it in self.post_process_trees() so that recombinator can later read it
if self.args.debug:
mean_leaf_height_list = [
treeutils.get_mean_leaf_height(treestr=tstr)
for tstr in treestrs
]
n_leaf_list = [
treeutils.get_n_leaves(
treeutils.get_dendro_tree(
treestr=tstr, suppress_internal_node_taxa=True))
for tstr in treestrs
]
print ' mean over %d trees: depth %.5f leaves %.2f' % (
len(mean_leaf_height_list), numpy.mean(mean_leaf_height_list),
numpy.mean(n_leaf_list))
# Each tree is written with branch length the mean branch length over the whole sequence, so we need to add the length for each region afterward,
# so each line looks e.g. like (t2:0.003751736951,t1:0.003751736951):0.001248262937;v:0.98,d:1.8,j:0.87
# add the region-specific branch info as an extra string tacked onto the right of the newick tree (so the output file isn't newick any more, sigh)
length_list = [
'%s:%f' % (region, self.branch_lengths[region]['mean'] /
self.branch_lengths['all']['mean'])
for region in utils.regions
]
for itree in range(len(ages)):
if treestrs[itree].count(';') != 1 or treestrs[itree][-1] != ';':
raise Exception('malformatted newick string:\n %s' %
treestrs[itree])
treestrs[itree] = treestrs[itree].replace(
';', ';%s' % ','.join(length_list))
# then write the modified lines for recombinator to read
with open(outfname, 'w') as treefile:
for tstr in treestrs:
treefile.write('%s\n' % tstr)
def generate_trees(self, seed, outfname, workdir):
if self.args.input_simulation_treefname is None: # default: generate our own trees
ages, treestrs = self.run_treesim(seed, outfname, workdir)
else: # read trees from a file that pass set on the command line
ages, treestrs = self.read_input_tree_file(outfname)
os.remove(
outfname
) # remove it here, just to make clear that we *re*write it in self.post_process_trees() so that recombinator can later read it
if self.args.debug or utils.getsuffix(outfname) == '.nwk':
dtreelist = [
treeutils.get_dendro_tree(treestr=tstr,
suppress_internal_node_taxa=True)
for tstr in treestrs
]
mean_leaf_height_list = [
treeutils.get_mean_leaf_height(tree=dt) for dt in dtreelist
]
n_leaf_list = [treeutils.get_n_leaves(dt) for dt in dtreelist]
print ' mean over %d trees: depth %.5f leaves %.2f' % (
len(mean_leaf_height_list), numpy.mean(mean_leaf_height_list),
numpy.mean(n_leaf_list))
# each tree is written with branch length the mean branch length over the whole sequence (which is different for each tree), but recombinator also needs the relative length for each region (which is the same, it's an average over the whole repertoire)
with open(outfname, 'w') as yfile:
if utils.getsuffix(outfname) == '.yaml':
yamlfo = {
'branch-length-ratios': {
r: self.branch_lengths[r]['mean'] /
self.branch_lengths['all']['mean']
for r in utils.regions
},
'trees': treestrs
}
json.dump(yamlfo, yfile)
elif utils.getsuffix(outfname) == '.nwk':
print ' writing trees to %s' % outfname
for treestr in treestrs:
yfile.write(treestr + '\n')
else:
assert False
def add_mutants(self, reco_event, irandom):
if self.args.mutation_multiplier is not None and self.args.mutation_multiplier == 0.: # some of the stuff below fails if mut mult is actually 0.
reco_event.final_seqs.append(reco_event.recombined_seq) # set final sequnce in reco_event
reco_event.indelfos = [indelutils.get_empty_indel() for _ in range(len(reco_event.final_seqs))]
return
# When generating trees, each tree's number of leaves and total depth are chosen from the specified distributions (a.t.m., by default n-leaves is from a geometric/zipf, and depth is from data)
# This chosen depth corresponds to the sequence-wide mutation frequency.
# In order to account for varying mutation rates in v, d, and j we simulate these regions separately, by appropriately rescaling the tree for each region.
# i.e.: here we get the sequence-wide mute freq from the tree, and rescale it by the repertoire-wide ratios from data (which are stored in the tree file).
# looks like e.g.: (t2:0.003751736951,t1:0.003751736951):0.001248262937;v:0.98,d:1.8,j:0.87, where the newick trees has branch lengths corresponding to the whole sequence (i.e. the weighted mean of v, d, and j)
# NOTE a.t.m (and probably permanently) the mean branch lengths for each region are the same for all the trees in the file, I just don't have a better place to put them while I'm passing from TreeGenerator to here than at the end of each line in the file
treefostr = self.treeinfo[random.randint(0, len(self.treeinfo)-1)] # per-region mutation info is tacked on after the tree... sigh. kind of hackey but works ok.
assert treefostr.count(';') == 1
isplit = treefostr.find(';') + 1
chosen_tree = treefostr[:isplit] # includes semi-colon
reco_event.set_tree(chosen_tree) # leaf names are still just like t<n>
mutefo = [rstr for rstr in treefostr[isplit:].split(',')]
mean_total_height = treeutils.get_mean_leaf_height(treestr=chosen_tree)
regional_heights = {} # per-region height, including <self.args.mutation_multiplier>
for tmpstr in mutefo:
region, ratio = tmpstr.split(':')
assert region in utils.regions
ratio = float(ratio)
if self.args.mutation_multiplier is not None: # multiply the branch lengths by some factor
ratio *= self.args.mutation_multiplier
regional_heights[region] = mean_total_height * ratio
scaled_trees = {r : treeutils.rescale_tree(regional_heights[r], treestr=chosen_tree) for r in utils.regions}
if self.args.debug:
print ' chose tree with total height %f' % treeutils.get_mean_leaf_height(treestr=chosen_tree)
print ' regional trees rescaled to heights: %s' % (' '.join(['%s %.3f (expected %.3f)' % (region, treeutils.get_mean_leaf_height(treestr=scaled_trees[region]), regional_heights[region]) for region in utils.regions]))
n_leaves = treeutils.get_n_leaves(treeutils.get_dendro_tree(treestr=chosen_tree, schema='newick'))
cmdfos = []
regional_naive_seqs = {} # only used for tree checking
for region in utils.regions:
simstr = reco_event.eroded_seqs[region]
if region == 'd':
simstr = reco_event.insertions['vd'] + simstr + reco_event.insertions['dj']
cmdfos.append(self.prepare_bppseqgen(simstr, scaled_trees[region], n_leaves, reco_event.genes[region], reco_event, seed=irandom))
regional_naive_seqs[region] = simstr
utils.run_cmds([cfo for cfo in cmdfos if cfo is not None], sleep=False) # shenanigan is to handle zero-length regional seqs
mseqs = {}
for ireg in range(len(utils.regions)): # NOTE kind of sketchy just using index in <utils.regions> (although it just depends on the loop immediately above a.t.m.)
if cmdfos[ireg] is None:
mseqs[utils.regions[ireg]] = ['' for _ in range(n_leaves)] # return an empty string for each leaf node
else:
tmp_names, tmp_seqs = self.read_bppseqgen_output(cmdfos[ireg], n_leaves)
if reco_event.leaf_names is None:
reco_event.leaf_names = tmp_names
assert reco_event.leaf_names == tmp_names # enforce different regions having same name + ordering (although this is already enforced when reading bppseqgen output)
mseqs[utils.regions[ireg]] = tmp_seqs
assert len(reco_event.final_seqs) == 0
for iseq in range(n_leaves):
seq = mseqs['v'][iseq] + mseqs['d'][iseq] + mseqs['j'][iseq]
seq = reco_event.revert_conserved_codons(seq, debug=self.args.debug) # if mutation screwed up the conserved codons, just switch 'em back to what they were to start with
reco_event.final_seqs.append(seq) # set final sequnce in reco_event
reco_event.final_codon_positions.append(copy.deepcopy(reco_event.post_erosion_codon_positions)) # separate codon positions for each sequence, because of shm indels
self.add_shm_indels(reco_event)
reco_event.setline(irandom) # set the line here because we use it when checking tree simulation, and want to make sure the uids are always set at the same point in the workflow
# self.check_tree_simulation(mean_total_height, regional_heights, chosen_tree, scaled_trees, regional_naive_seqs, mseqs, reco_event)
# self.print_validation_values()
if self.args.debug:
print ' tree passed to bppseqgen:'
print treeutils.get_ascii_tree(dendro_tree=reco_event.tree, extra_str=' ')
utils.print_reco_event(reco_event.line, extra_str=' ')
def prepare_bppseqgen(self, seq, chosen_tree, n_leaf_nodes, gene, reco_event, seed):
""" write input files and get command line options necessary to run bppseqgen on <seq> (which is a part of the full query sequence) """
if len(seq) == 0:
return None
# write the tree to a tmp file
workdir = self.workdir + '/' + utils.get_region(gene)
os.makedirs(workdir)
treefname = workdir + '/tree.tre'
reco_seq_fname = workdir + '/start-seq.txt'
leaf_seq_fname = workdir + '/leaf-seqs.fa'
# add dummy leaf that we'll subsequently ignore (such are the vagaries of bppseqgen)
chosen_tree = '(%s,%s:%.15f):0.0;' % (chosen_tree.rstrip(';'), dummy_name_so_bppseqgen_doesnt_break, treeutils.get_mean_leaf_height(treestr=chosen_tree))
with open(treefname, 'w') as treefile:
treefile.write(chosen_tree)
self.write_mute_freqs(gene, seq, reco_event, reco_seq_fname)
env = os.environ.copy()
env['LD_LIBRARY_PATH'] = env.get('LD_LIBRARY_PATH', '') + ':' + self.args.partis_dir + '/packages/bpp/lib'
# build up the command line
# docs: http://biopp.univ-montp2.fr/apidoc/bpp-phyl/html/classbpp_1_1GTR.html that page is too darn hard to google
bpp_binary = self.args.partis_dir + '/packages/bpp/bin/bppseqgen'
if not os.path.exists(bpp_binary):
raise Exception('bpp not found in %s' % os.path.dirname(bpp_binary))
command = bpp_binary # NOTE should I use the "equilibrium frequencies" option?
command += ' alphabet=DNA'
command += ' --seed=' + str(seed)
command += ' input.infos=' + reco_seq_fname # input file (specifies initial "state" for each position, and possibly also the mutation rate at that position)
command += ' input.infos.states=state' # column name in input file BEWARE bio++ undocumented defaults (i.e. look in the source code)
command += ' input.tree.file=' + treefname
command += ' input.tree.format=Newick'
command += ' output.sequence.file=' + leaf_seq_fname
command += ' output.sequence.format=Fasta'
if self.args.mutate_from_scratch:
command += ' model=JC69'
command += ' input.infos.rates=none' # BEWARE bio++ undocumented defaults (i.e. look in the source code)
if self.args.flat_mute_freq:
command += ' rate_distribution=Constant'
else:
command += ' rate_distribution=Gamma(n=4,alpha=' + self.mute_models[utils.get_region(gene)]['gamma']['alpha']+ ')'
else:
command += ' input.infos.rates=rate' # column name in input file
pvpairs = [p + '=' + v for p, v in self.mute_models[utils.get_region(gene)]['gtr'].items()]
command += ' model=GTR(' + ','.join(pvpairs) + ')'
return {'cmd_str' : command, 'outfname' : leaf_seq_fname, 'workdir' : workdir, 'other-files' : [reco_seq_fname, treefname], 'env' : env}
