def read_treemix_file2(filename_treeout, filename_vertices, filename_edges, outgroup=None): if filename_treeout.endswith('.gz'): filename_treeout = unzip(filename_treeout) if filename_vertices.endswith('.gz'): filename_vertices = unzip(filename_vertices) if filename_edges.endswith('.gz'): filename_edges = unzip(filename_edges) with open(filename_treeout, 'r') as f: newick_tree = f.readline().rstrip() admixtures = parse_admixtures2(map(str.rstrip, f.readlines())) vertice_dictionary = read_vertices(filename_vertices) print vertice_dictionary edges = get_edge_lengths2(filename_edges) #print newick_tree tree = make_Rtree(edges, vertice_dictionary, admixtures) print pretty_string(tree) #tree=remove_children(tree) if outgroup is not None: tree = rearrange_root(tree, outgroup) print 'after rearrangement' print pretty_string(tree) return tree
def make_Rtree(edges, vertice_dictionary, admixtures): root_name = get_root(vertice_dictionary).name all_nodes = construct_pointers(edges) all_nodes, vertice_dictionary, edges = prune_tree_structure( all_nodes, vertice_dictionary, edges) print_all_nodes(all_nodes) leaf_nodes = get_leaf_nodes(all_nodes) rTree_structure = tree_structure_to_Rtree_structure( leaf_nodes, edges, root_name) #print pretty_string(rTree_structure) print 'Before inserting admixture proportions:', pretty_string( rTree_structure) tree = adjust_admixture_proportions(rTree_structure, vertice_dictionary, admixtures) print 'After admixture proportions, before double node pruning', pretty_string( tree) #tree=prune_double_nodes(tree) print 'After pruning, before renaming tree leaves', pretty_string(tree) tree = remap_leaves(tree, vertice_dictionary) print 'After remapping tree leaves', pretty_string(tree) return tree
def __call__(self, tree, **not_needed): #print tree #print not_needed #print tree Rtree = identifier_to_tree_clean( tree, leaves=generate_predefined_list_string(deepcopy(self.nodes))) #print pretty_string(Rtree) if self.subnodes: #DETTE TAGER IKKE ORDENTLIG HOJDE FOR KOVARIANSMATRICERNE SOM BLIVER FORKERTE try: Rtree = get_subtree(Rtree, self.subnodes) except AssertionError: print pretty_string(Rtree) from tree_plotting import plot_as_directed_graph plot_as_directed_graph(Rtree) print 'input_tree', tree print 'nodes', self.nodes print 'subnodes', self.subnodes assert False if self.remove_sadtrees and (not admixes_are_sadmixes(Rtree)): print 'returned true because adtrees are not sad' return {'Rtree': Rtree}, True return {'Rtree': Rtree}, False
#print 'resimulated', old_length, 'to', new_length, 'on branch', str((key,branch)), 'and change in lattitude at', delta_L, 'backward', backward return tree, 1.0, backward if __name__=='__main__': test_tree={ 's3': ['x', None, None, 0.3, None, None, None], 's2': ['a', None, None, 0.05, None, None, None], 's1': ['d', None, None, 0.1, None, None, None], 's4': ['b', None, None, 0.3, None, None, None], 'a': ['b', 'c', 0.5, 0.2, 0.1, 's2', None], 'c': ['x', 'd', 0.5, 0.083428092356333014, 0.1, 'a', None], 'b': ['f', None, None, 0.05, None, 's4', 'a'], 'd': ['r', None, None, 0.05, None, 's1', 'c'], 'f': ['r', None, None, 0.02, None, 'b', 'x'], 'x': ['f', None, None, 0.066571907643666994, None, 's3', 'c']} from Rcatalogue_of_trees import tree_good t=tree_good print pretty_string(t) letters=['n'+str(i) for i in xrange(100000)] for i in xrange(100): t,f,b= make_sliding_regraft(t, new_node=letters[i] , resimulate_moved_branch_length=True) print 'forward', f print 'backward',b print 'tree' print pretty_string(t)
filename_vertices, filename_edges, outgroup='out', snodes=['s' + str(i) for i in range(1, 11)], prefix='sletmig' + os.sep, return_format='outgroup_rooted') #tree=read_treemix_file2('../../../../Dropbox/Bioinformatik/AdmixtureBayes/treemix_example3/new_one2.treeout', # '../../../../Dropbox/Bioinformatik/AdmixtureBayes/treemix_example3/new_one2.vertices', # '../../../../Dropbox/Bioinformatik/AdmixtureBayes/treemix_example3/new_one2.edges', outgroup='out') import tree_plotting tree_plotting.plot_as_directed_graph(tree) from tree_warner import check check(tree) print pretty_string(tree) import numpy as np print pretty_string(tree) from Rtree_to_covariance_matrix import make_covariance from reduce_covariance import reduce_covariance, Areduce cov = make_covariance(tree, node_keys=['out'] + ['s' + str(i) for i in range(1, 10)]) print cov cov2 = np.loadtxt( '../../../../Dropbox/Bioinformatik/AdmixtureBayes/treemix_example3/anew.txt' ) np.set_printoptions(precision=6, linewidth=200, suppress=True) print cov - cov2 print reduce_covariance(cov - cov2, 0) print Areduce(cov - cov2)
def addadmix(tree, new_node_names=None, pks={}, fixed_sink_source=None, new_branch_length=None, new_to_root_length=None, check_opposite=False, preserve_root_distance=True): ''' This proposal adds an admixture to the tree. There are a lot of free parameters but only 5 are in play here: c1: the branch length of the source population c2: the branch length of the population genes are migrating into. u1: the position of the admixture source on the source population branch u2: the position of the admixture destination on the sink population branch w: the admixture proportion. The connecting function, h, (see Green & Hastie 2009) is h(c1,c2,u1,u2,w)=(c1*u1, c1*(1-u1), c2*u2, c2*(1-u2), 0.5*w) ''' possible_nodes = _get_possible_starters(tree) no_admixtures = get_number_of_admixes(tree) new_tree = deepcopy(tree) #print possible_nodes sink_key, sink_branch = possible_nodes[choice(len(possible_nodes), 1)[0]] if fixed_sink_source is not None: sink_key, sink_branch, source_key, source_branch = fixed_sink_source children, other = get_all_branch_descendants_and_rest( tree, sink_key, sink_branch) candidates = other + [('r', 0)] ch = choice(len(candidates), 1)[0] if fixed_sink_source is None: source_key, source_branch = candidates[ch] pks['sink_key'] = sink_key pks['source_key'] = source_key pks['source_branch'] = source_branch pks['sink_branch'] = sink_branch #print 'children', children #print 'candidates', candidates #print 'sink', (sink_key, sink_branch) #print 'source', (source_key,source_branch) #print 'new_tree',new_tree if fixed_sink_source is not None: new_tree, forward_density, backward_density, multip = insert_admix( new_tree, source_key, source_branch, sink_key, sink_branch, pks=pks, new_branch_length=new_branch_length, new_to_root_length=new_to_root_length, preserve_root_distance=preserve_root_distance) elif new_node_names is None: new_tree, forward_density, backward_density, multip = insert_admix( new_tree, source_key, source_branch, sink_key, sink_branch, pks=pks, preserve_root_distance=preserve_root_distance) else: new_tree, forward_density, backward_density, multip = insert_admix( new_tree, source_key, source_branch, sink_key, sink_branch, pks=pks, source_name=new_node_names[0], sink_name=new_node_names[1], preserve_root_distance=preserve_root_distance) choices_forward = float(len(possible_nodes) * len(candidates)) * 2 choices_backward = float(len(_get_removable_admixture_branches(new_tree))) pks['forward_density'] = forward_density pks['backward_density'] = backward_density pks['forward_choices'] = choices_forward pks['backward_choices'] = choices_backward if check_opposite: pks2 = {} t, f, b = deladmix(new_tree, pks=pks2, fixed_remove=(pks['sink_new_name'], pks['sink_new_branch']), check_opposite=False, preserve_root_distance=preserve_root_distance) if (float_equal(forward_density, pks2['backward_density']) and choices_forward == pks2['backward_choices'] and float_equal(backward_density, pks2['forward_density']) and choices_backward == pks2['forward_choices']): print 'test passed' else: print 'TEST FAILED' print forward_density, "==", pks2[ 'backward_density'], ":", forward_density == pks2[ 'backward_density'] print backward_density, "==", pks2[ 'forward_density'], ":", backward_density == pks2[ 'forward_density'] print choices_forward, "==", pks2[ 'backward_choices'], ":", choices_forward == pks2[ 'backward_choices'] print choices_backward, "==", pks2[ 'forward_choices'], ":", choices_backward == pks2[ 'forward_choices'] print pretty_string(tree) print pretty_string(new_tree) print pretty_string(t) for key, val in pks.items(): print key, ': ', val print "-----------" for key, val in pks2.items(): print key, ': ', val assert False return new_tree, forward_density / choices_forward, backward_density / choices_backward * multip
def deladmix(tree, pks={}, fixed_remove=None, check_opposite=False, preserve_root_distance=True): ''' Reversible Jump MCMC transition which removes a random admixture branch. This is the reverse of the other proposal in this file. ''' #making copy that we can erase branches from. cop = deepcopy(tree) candidates = _get_removable_admixture_branches(cop) #print candidates if len(candidates) == 0: return tree, 1, 1 if fixed_remove is None: remove_key, remove_branch = candidates[choice(len(candidates), 1)[0]] else: remove_key, remove_branch = fixed_remove pks['remove_key'] = remove_key pks['remove_branch'] = remove_branch #get_keys_and_branches_from_children() #print 'remove', (remove_key, remove_branch) new_tree, (t1, t2, t3, t4, t5), alpha = remove_admix2(cop, remove_key, remove_branch, pks=pks) #pks['sink_key']=sink_key #pks['sink_branch']=sink_branch #pks['removed_alpha']=alpha pks['t1'] = t1 pks['t2'] = t2 pks['t3'] = t3 pks['t4'] = t4 pks['t5'] = t5 if preserve_root_distance: #print t1 multip = (alpha**2 + (1.0 - alpha)**2) old_length = t2 + multip * t1 t1 = old_length - t2 #print old_length, t1,t2 child_key, child_branch = get_keys_and_branches_from_children( tree, remove_key)[0] update_branch_length(new_tree, child_key, child_branch, old_length) else: multip = 1.0 backward_density = get_backward_remove_density(t1, t2, t3, t4, t5, alpha) forward_density = 1.0 forward_choices = float(len(candidates)) backward_choices = float( get_possible_admixture_adds(new_tree, pks['orphanota_key'], pks['orphanota_branch'])) * 2 pks['forward_choices'] = forward_choices pks['backward_choices'] = backward_choices pks['forward_density'] = forward_density pks['backward_density'] = backward_density if check_opposite: pks2 = {} if t4 is None: new_to_root_length = t3 else: new_to_root_length = None t, f, b = addadmix(new_tree, pks=pks2, fixed_sink_source=(pks['orphanota_key'], pks['orphanota_branch'], pks['sorphanota_key'], pks['sorphanota_branch']), new_branch_length=t5, new_to_root_length=new_to_root_length, check_opposite=False, preserve_root_distance=preserve_root_distance) if (float_equal(forward_density, pks2['backward_density']) and forward_choices == pks2['backward_choices'] and float_equal(backward_density, pks2['forward_density']) and backward_choices == pks2['forward_choices']): print 'test passed' else: print 'TEST FAILED' print forward_density, "==", pks2[ 'backward_density'], ":", forward_density == pks2[ 'backward_density'] print backward_density, "==", pks2[ 'forward_density'], ":", backward_density == pks2[ 'forward_density'] print forward_choices, "==", pks2[ 'backward_choices'], ":", forward_choices == pks2[ 'backward_choices'] print backward_choices, "==", pks2[ 'forward_choices'], ":", backward_choices == pks2[ 'forward_choices'] print pretty_string(tree) print pretty_string(new_tree) print pretty_string(t) for key, val in pks.items(): print key, ': ', val print "----------------" for key, val in pks2.items(): print key, ': ', val assert False return new_tree, forward_density / forward_choices, backward_density / backward_choices * multip
class rescale_constrained_class(object): new_nodes = 0 proposal_name = 'rescale_constrained' adaption = True input = 'both' require_admixture = 0 reverse_require_admixture = 0 admixture_change = 0 reverse = 'rescale_constrained' def __init__(self, **kwargs): self.kwargs = kwargs def __call__(self, *args, **kwargs): kwargs.update(self.kwargs) #print kwargs return rescale(*args, **kwargs) if __name__ == '__main__': from tree_plotting import plot_graph from Rcatalogue_of_trees import tree_on_the_border2_with_children from Rtree_operations import pretty_string (new_tree, new_add), _, _ = rescale( (tree_on_the_border2_with_children, 0.1)) print 'old_tree', pretty_string(tree_on_the_border2_with_children) print 'new_tree', pretty_string(new_tree)
def identifier_to_tree(identifier, leaves=None, inner_nodes=None, branch_lengths=None, admixture_proportions=None): ''' Transforms an identifier of the form qwert-uio-asdfg-jk into a dictionary tree using the generators of leaves, inner_nodes, branch_lengths and admixture_proportions. ''' levels=identifier.split('-') n_leaves=len(levels[0].split('.')) #initiate leaves if leaves is None: leaf_values=sorted(get_trivial_nodes(n_leaves)) else: leaf_values=[leaves() for _ in range(n_leaves)] tree={leaf:[None]*5 for leaf in leaf_values} trace_lineages=[(leaf,0) for leaf in leaf_values] #initiate generators if inner_nodes is None: inner_nodes=generate_numbered_nodes('n') if branch_lengths is None: def f(): return 1.0 branch_lengths= f if admixture_proportions is None: def g(): return 0.4 admixture_proportions=g for level in levels: identifier_lineages=level.split('.') assert len(trace_lineages)==len(identifier_lineages), 'the number of traced lineages did not match the number of lineages in the identifier '+\ '\n\n'+'trace_lineages:'+'\n'+str(trace_lineages)+\ '\n\n'+'identifier_lineages:'+'\n'+str(identifier_lineages) parent_index={} indexes_to_be_removed=[] for n,identifier_lineage in enumerate(identifier_lineages): if identifier_lineage=='c': ##there is a coalecence for the n'th lineage, and it should be replaced by a new lineage new_key=inner_nodes() old_key,old_branch=trace_lineages[n] new_branch_length=branch_lengths() tree=update_parent_and_branch_length(tree, old_key, old_branch, new_key, new_branch_length) tree[new_key]=[None]*5 parent_index[n]=new_key trace_lineages[n]=(new_key,0) elif identifier_lineage=='w': pass elif identifier_lineage=='a': new_key=inner_nodes(admixture=True) old_key,old_branch=trace_lineages[n] new_branch_length=branch_lengths() tree=update_parent_and_branch_length(tree, old_key, old_branch, new_key, new_branch_length) new_admixture_proportion=admixture_proportions() tree[new_key]=[None,None,new_admixture_proportion,None,None] trace_lineages[n]=(new_key,0) trace_lineages.append((new_key,1)) else: ##there is a coalescence but this lineage disappears try: new_key=parent_index[int(identifier_lineage)] except KeyError as e: print e print 'new_key', new_key print 'parent_index', parent_index print 'identifier_lineage', identifier_lineage print pretty_string(insert_children_in_tree(tree)) old_key,old_branch=trace_lineages[n] new_branch_length=branch_lengths() tree=update_parent_and_branch_length(tree, old_key, old_branch, new_key, new_branch_length) indexes_to_be_removed.append(n) ##remove lineages trace_lineages=[trace_lineage for n,trace_lineage in enumerate(trace_lineages) if n not in indexes_to_be_removed] root_key=new_key del tree[root_key] tree=rename_root(tree, new_key) return insert_children_in_tree(tree)
's4':['n4',None,None,1.3,None,None,None], 'n4':['r',None,None,0.3,None,'n3','s4'], 's5':['r',None,None,1.2,None,None,None]} print unique_identifier_and_branch_lengths(tree1) from tree_warner import check from tree_plotting import pretty_string tree='c.c.w.w.a.0.1.w.w-w.a.w.c.3.w.w.w-c.w.w.0.w.w.c.9-c.w.w.w.w.0-c.w.0.w.w-c.w.0.w-c.0.w-c.0;0.012-0.038-0.05-0.062-0.029-0.068-0.068-0.097-0.005-0.048-0.083-0.024-0.123-0.057-0.024-0.047-0.058-0.144-0.079-0.04-0.035-0.032;0.086-0.219' tree2='c.c.w.w.a.0.1.w.w-w.a.w.c.3.w.w.w-c.w.w.0.w.w.c.6-c.w.w.w.w.0-c.w.0.w.w-c.w.0.w-c.0.w-c.0;0.012-0.038-0.05-0.062-0.029-0.068-0.068-0.097-0.005-0.048-0.083-0.024-0.123-0.057-0.024-0.047-0.058-0.144-0.079-0.04-0.035-0.032;0.586-0.219' tree3={'136': ['32', None, None, 0.000485164, None, 's8', 's6'], '172': ['16', None, None, 0.00101341, None, '244', '32'], '233': ['r', None, None, 0.000104723, None, 's7', None], 's9': ['32', None, None, 0.00224709, None, None, None], 's8': ['136', None, None, 0.00318685, None, None, None], 's3': ['244', None, None, 0.00230204, None, None, None], 's2': ['104', None, None, 0.00224093, None, None, None], 's1': ['103pruned', None, None, 0, None, None, None], 's7': ['233', None, None, 0.0, None, None, None], 's6': ['136', None, None, 0.0015962, None, None, None], 's5': ['52', None, None, 0.000780002, None, None, None], 's4': ['76', None, None, 0.0025597, None, None, None], '0': ['16', None, None, 0.000394219, None, 's10', '2'], '2': ['0', None, None, 0.000262294, None, 'out', '76'], '103pruned': ['104', '244', 0.875419, 0.00235895, 0, 's1', None], 'out': ['2', None, None, 0.00158848, None, None, None], 's10': ['0', None, None, 1.76418e-05, None, None, None], '244': ['172', None, None, 0.000340227, None, 's3', '103pruned'], '104': ['76', None, None, 0.000879448, None, 's2', '103pruned'], '76': ['2', None, None, 0.000144781, None, '104', 's4'], '32': ['172', None, None, 0.00148711, None, '136', 's9'], '16': ['52', None, None, 0.0041016, None, '172', '0'], '52': ['r', None, None, 0.000104723, None, '16', 's5']} tree4={'136': ['32', None, None, 0.000485164, None, 's8', 's6'], '172': ['16', None, None, 0.00101341, None, '244', '32'], '233': ['r', None, None, 0.000104723, None, 's7', None], 's9': ['32', None, None, 0.00224709, None, None, None], 's8': ['136', None, None, 0.00318685, None, None, None], 's3': ['244', None, None, 0.00230204, None, None, None], 's2': ['104', None, None, 0.00224093, None, None, None], 's1': ['103pruned', None, None, 0, None, None, None], 's7': ['233', None, None, 0.0, None, None, None], 's6': ['136', None, None, 0.0015962, None, None, None], 's5': ['52', None, None, 0.000780002, None, None, None], 's4': ['76', None, None, 0.0025597, None, None, None], '0': ['16', None, None, 0.000394219, None, 's10', '2'], '2': ['0', None, None, 0.000262294, None, 'out', '76'], '103pruned': ['104', '244', 0.875419, 0.00235895, 0, 's1', None], 'out': ['2', None, None, 0.00158848, None, None, None], 's10': ['0', None, None, 1.76418e-05, None, None, None], '244': ['172', None, None, 0.000340227, None, 's3', '103pruned'], '104': ['76', None, None, 0.000879448, None, 's2', '103pruned'], '76': ['2', None, None, 0.000144781, None, '104', 's4'], '32': ['172', None, None, 0.00148711, None, '136', 's9'], '16': ['52', None, None, 0.0041016, None, '172', '0'], '52': ['r', None, None, 0.000104723, None, '16', 's5']} ft=identifier_to_tree_clean(tree2) ft=tree3 print check(ft) print pretty_string(ft) print unique_identifier_and_branch_lengths(ft) print tree_to_0ntree(ft) print tree_to_mode_ntree(ft) print tree_to_random_ntree(ft) print majority_tree(ft) from sys import exit exit() from Rcatalogue_of_trees import * from Rtree_operations import create_burled_leaved_tree print generation_counts(tree_good) print get_timing(tree_good) ad= unique_identifier_and_branch_lengths(tree_good)
def get_all_pairs(nodes): all_nodes={} count=0 for node_index in range(len(nodes)): for node_index2 in range(node_index, len(nodes)): node1=nodes[node_index] node2=nodes[node_index2] all_nodes[(node1, node2)]=count count+=1 return all_nodes if __name__=='__main__': from Rcatalogue_of_trees import * from Rtree_operations import pretty_string, create_trivial_tree, get_specific_branch_lengths, update_specific_branch_lengths print pretty_string(tree_good) coef, ni, bi= make_coefficient_matrix(tree_good) nodes_determined = [None]*len(ni) branches_determined=[None]*len(bi) for n,i in ni.items(): nodes_determined[i]=n for b,i in bi.items(): branches_determined[i]=b branch_lengths=get_specific_branch_lengths(tree_good, branches_determined) from numpy import array print coef print coef.dot(array(branch_lengths)) from Rtree_to_covariance_matrix import make_covariance from numpy.random import normal
's10': ['n13', None, None, 0.017452689, None, None, None], 'a1': ['a4', 'n12', 0.32, 0.008438453, 0.006708239, 's1', None], 'a2': ['n5', 'n6', 0.135, 0.12066482, 0.001733599, 's5', None], 'a4': ['a7', 'n9', 0.599, 0.035053964, 0.041518206, 'a1', None], 'a7': ['n10', 'n11', 0.401, 0.029920208, 0.009904888, 'a4', None], 'n8': ['n10', None, None, 0.009578977, None, 's3', 'n5'], 'n9': ['n12', None, None, 0.033982401, None, 's7', 'a4'], 'n3': ['r', None, None, 0.069890962, None, 's9', 's6'], 'n5': ['n8', None, None, 0.008113672, None, 's4', 'a2'], 'n6': ['n15', None, None, 0.002455554, None, 's8', 'a2'] } #print plot_as_directed_graph(tree) sub_tree = get_subtree(tree, ['s1', 's2', 's3']) #print plot_as_directed_graph(sub_tree) print pretty_string(sub_tree) #plots=get_unique_plottable_tree(sub_tree) #print 'gotten unique_plottable' #print plots stree_difficult = 'a.w.w.c.c.w.c.4.3.6-c.w.0.w.c.w.w.4-c.w.w.w.w.0-c.w.w.w.0-c.0.w.w-c.0.w-c.0;0.014843959-0.003602704-0.002128203-0.027030132-0.008484730-0.067616899-0.021207056-0.027455759-0.011647297-0.009065170-0.053386961-0.001718477-0.009310923-0.010471979-0.036314546-0.004808845-0.055956235-0.004694887-0.003482668-0.039323330-0.014821628;1.000' from tree_statistics import (identifier_to_tree_clean, generate_predefined_list_string, identifier_file_to_tree_clean, unique_identifier_and_branch_lengths) from Rtree_to_covariance_matrix import make_covariance nodes = sorted(['s' + str(i + 1) for i in range(10)]) tree_difficult = identifier_to_tree_clean( stree_difficult, leaves=generate_predefined_list_string(deepcopy(nodes))) cov1 = make_covariance(tree_difficult)
def get_true_posterior(wishart_file='tmp_covariance_and_multiplier.txt', true_tree_file='tmp_scaled_true_tree.txt', p=0.5, use_skewed_distr=False, wishart_df_file='tmp_wishart_DF.txt', outgroup='out'): true_tree, nodes = read_tree_file(true_tree_file) set_printoptions(precision=2) multiplier = 8.57292960745 print make_covariance(scale_tree_copy(true_tree, multiplier), node_keys=nodes) print reduce_covariance( make_covariance(scale_tree_copy(true_tree, multiplier), node_keys=nodes), len(nodes) - 1) print true_tree print nodes print outgroup print pretty_string(true_tree) x = get_pruned_tree_and_add(true_tree, outgroup) print pretty_string(x[0]) print x[1] print nodes nodes.remove(outgroup) covariance, multiplier = read_wishart_file(wishart_file, nodes) print 'multiplier', multiplier #multiplier=1.0 print covariance #print make_covariance(scale_tree_copy(x[0], multiplier)) t_covariance, t_multiplier = rescale_empirical_covariance( make_covariance(x[0]) + x[1]) print t_covariance print t_covariance - covariance print(t_covariance) / covariance print(t_covariance / t_multiplier) - covariance / multiplier print(t_covariance / t_multiplier) / (covariance / multiplier) avg_scale = mean((make_covariance(scale_tree_copy(x[0], 1.0)) + x[1]) * multiplier / covariance) avg_root = get_average_distance_to_root(x[0]) max_root = get_max_distance_to_root(x[0]) min_root = get_min_distance_to_root(x[0]) wishart_df = read_wishart_df_file(wishart_df_file) posterior = posterior_class(covariance, M=wishart_df, p=p, use_skewed_distr=use_skewed_distr, multiplier=multiplier, nodes=nodes) pks = {} a = posterior(x, pks) print a prior_val = pks['prior'] lik_vals = [ posterior.get_likelihood_from_matrix(t_covariance * c) for c in linspace(0.1, 2.5, 1500) ] print lik_vals n = sorted([(v, e) for e, v in enumerate(lik_vals)])[-1][1] print n, linspace(0.1, 2.5, 1500)[n] print lik_vals[n] print linspace(0.1, 2.5, 1500)[n] * t_covariance print covariance print t_covariance print posterior.get_likelihood_from_matrix(t_covariance) print sum((covariance - t_covariance)**2) print sum((covariance - t_covariance * linspace(0.1, 2.5, 1500)[n])**2) t_cov2 = deepcopy(t_covariance) t_cov2[3, 5] = t_cov2[5, 3] = 1.6 t_cov2[1, 2] = t_cov2[2, 1] = 2.45 print t_cov2 print posterior.get_likelihood_from_matrix(t_cov2) print posterior.get_likelihood_from_matrix(covariance) print posterior.get_likelihood_from_matrix( covariance * (wishart_df / (wishart_df - covariance.shape[0] - 1))) return prior_val + max(lik_vals)
#print reduce_covariance(identity(10), 5) #print file_to_emp_cov('out_stem.cov',4) from sys import exit exit() from generate_prior_trees import generate_phylogeny from Rcatalogue_of_trees import * from Rtree_operations import create_trivial_tree, scale_tree tree2=scale_tree(generate_phylogeny(5,1),0.05) print pretty_string(tree2) print pretty_string(identifier_to_tree_clean(unique_identifier_and_branch_lengths(tree2))) print supplementary_text_ms_string() tree_good=generate_phylogeny(7) a=tree_to_ms_command(tree_good, 50,20) #print call_ms_string(a, 'supp.txt') b=time_adjusted_tree_to_ms_command(tree_good,50,20) #print call_ms_string(b, 'supp2.txt') #print call_ms_string(tree_to_ms_command(tree2, 50,20), 'tmp.txt') #cov= ms_to_treemix2('supp.txt', 20, 20,400) #cov= ms_to_treemix2('tmp.txt', 50, 5,20) #cov2=calculate_covariance_matrix('tmp.txt', 50, 5,20) #print cov #print cov2 #print make_covariance(tree2) #print reduce_covariance(cov, 0)