Python Tree.get_leaf_names方法代码示例

# 需要导入模块: from ete3 import Tree [as 别名]
# 或者: from ete3.Tree import get_leaf_names [as 别名]
    def _parse_tree_tag(self, dir_path):
        self.true_ancestor_names = {}
        with open(os.path.join(dir_path, self.name_tool, "tree_tag.txt")) as f:
            input_tree = Tree(f.readline().strip("\n\t"), 8)
            self.all_species = set(input_tree.get_leaf_names())
            for node in list(input_tree.traverse("preorder"))[1:]:
                if node.name not in self.all_species:
                    if not node.is_leaf():
                        left_split = list(node.children[0].get_leaf_names())
                        left_split.sort()
                        right_split = list(node.children[1].get_leaf_names())
                        right_split.sort()
                        ancestor_split = list(self.all_species.difference(set(left_split).union(set(right_split))))
                        ancestor_split.sort()

                        result = [left_split, right_split, ancestor_split]
                        result = ["".join(str(result[0])),
                                  "".join(str(result[1])),
                                  "".join(str(result[2]))]
                        result.sort()

                        branch = " ".join(result)
                        self.true_ancestor_names[branch] = node.name

# 需要导入模块: from ete3 import Tree [as 别名]
# 或者: from ete3.Tree import get_leaf_names [as 别名]
matrix = {}
def get_dist(a, b):
    if a == b:
        return 0.0
    try:
        return matrix[(a, b)]
    except KeyError:
        return matrix[(b, a)]

for tip_a, tip_b in itertools.permutations(lineages.keys(), 2):
    d = sum([n.dist for n in lineages[tip_a] ^ lineages[tip_b]])
    matrix[(tip_a, tip_b)] = d
    #if len(matrix) % 10000 == 0:
    #    print >>sys.stderr, len(matrix)

leaves = t.get_leaf_names()
print '\t'.join(['#names'] + leaves)
for tip_a in leaves:
    row = [tip_a]
    for tip_b in leaves:
        row.append(get_dist(tip_a, tip_b))
    print '\t'.join(map(str, row))


# test

import random
s = random.sample(matrix.keys(), 1000)
for a,b in s:
    d0 = get_dist(a, b)
    d1 = t.get_distance(a, b)

# 需要导入模块: from ete3 import Tree [as 别名]
# 或者: from ete3.Tree import get_leaf_names [as 别名]

#.........这里部分代码省略.........


    def Brutal(self, reroot = False):
        if reroot:
            self.re_rooting()
        first_node_list = []
        first_node_list.append(self.tree)
        first_childs = self.tree.get_children()
        for child in first_childs:
            first_node_list.append(child)
        num_s = self.comp_num_comb()
        if num_s > self.max_num_search:
            print("Too many search iterations: " + repr(num_s) + ", using H0 instead!!!")
            self.H0(reroot = False)
        else:
            first_setting = species_setting(spe_nodes = first_node_list, root = self.tree, sp_rate = self.fix_spe, fix_sp_rate = self.fix_spe_rate, minbr = self.min_brl)
            self.next(first_setting)


    def search(self, strategy = "H1", reroot = False):
        if strategy == "H1":
            self.H1(reroot)
        elif strategy == "H2":
            self.H2(reroot)
        elif strategy == "H3":
            self.H3(reroot)
        elif strategy == "Brutal":
            self.Brutal(reroot)
        else:
            self.H0(reroot)


    def count_species(self, print_log = True, pv = 0.001):
        lhr = lh_ratio_test(self.null_logl, self.max_logl, 1)
        pvalue = lhr.get_p_value()
        if print_log:
            print("Speciation rate: " + "{0:.3f}".format(self.max_setting.rate2))
            print("Coalesecnt rate: " + "{0:.3f}".format(self.max_setting.rate1))
            print("Null logl: " + "{0:.3f}".format(self.null_logl))
            print("MAX logl: " + "{0:.3f}".format(self.max_logl))
            print("P-value: " + "{0:.3f}".format(pvalue))
            spefit, speaw = self.max_setting.e2.ks_statistic()
            coafit, coaaw = self.max_setting.e1.ks_statistic()
            print("Kolmogorov-Smirnov test for model fitting:")
            print("Speciation: " + "Dtest = {0:.3f}".format(spefit) + " " + speaw)
            print("Coalescent: " + "Dtest = {0:.3f}".format(coafit) + " " + coaaw)
        if pvalue < pv:
            num_sp, self.species_list = self.max_setting.count_species()
            return num_sp
        else:
            self.species_list = []
            self.species_list.append(self.tree.get_leaf_names()) 
            return 1


    def whitening_search(self, strategy = "H1", reroot = False, pv = 0.001):
        self.search(strategy, reroot, pv)
        num_sp, self.species_list = self.max_setting.count_species()
        spekeep = self.max_setting.whiten_species()
        self.tree.prune(spekeep)
        self.max_logl = float("-inf") 
        self.max_setting = None
        self.null_logl = 0.0
        self.null_model()
        self.species_list = None
        self.counter = 0
        self.setting_set = set([])
        self.search(strategy, reroot, pv)


    def print_species(self):
        cnt = 1
        for sp in self.species_list:
            print("Species " + repr(cnt) + ":")
            for leaf in sp:
                print("          " + leaf)
            cnt = cnt + 1


    def output_species(self, taxa_order = []):
        """taxa_order is a list of taxa names, the paritions will be output as the same order"""
        if len(taxa_order) == 0:
            taxa_order = self.tree.get_leaf_names()
        
        num_taxa = 0
        for sp in self.species_list:
            for leaf in sp:
                num_taxa = num_taxa + 1
        if not len(taxa_order) == num_taxa:
            print("error error, taxa_order != num_taxa!")
            return None, None
        else: 
            partion = [-1] * num_taxa
            cnt = 1
            for sp in self.species_list:
                for leaf in sp:
                    idx = taxa_order.index(leaf)
                    partion[idx] = cnt
                cnt = cnt + 1
            return taxa_order, partion