treesak 1.51.2__py3-none-any.whl

TreeSAK/assessOG.py

@@ -0,0 +1,45 @@
+import os
+import glob
+from Bio import SeqIO
+
+
+def sep_path_basename_ext(file_in):
+
+    f_path, f_name = os.path.split(file_in)
+    if f_path == '':
+        f_path = '.'
+    f_base, f_ext = os.path.splitext(f_name)
+
+    return f_name, f_path, f_base, f_ext[1:]
+
+
+def get_gnm_og_cov(og_dir, og_ext, og_cov_txt):
+
+    og_file_re   = '%s/*.%s' % (og_dir, og_ext)
+    og_file_list = glob.glob(og_file_re)
+
+    gnm_to_og_dict = dict()
+    for og_file in og_file_list:
+        _, _, og_id, _ = sep_path_basename_ext(og_file)
+        for each_seq in SeqIO.parse(og_file, 'fasta'):
+            seq_id = each_seq.id
+            gnm_id = '_'.join(seq_id.split('_')[:-1])
+            if gnm_id not in gnm_to_og_dict:
+                gnm_to_og_dict[gnm_id] = set()
+            gnm_to_og_dict[gnm_id].add(og_id)
+
+    og_cov_txt_handle = open(og_cov_txt, 'w')
+    for each_gnm in sorted(list(gnm_to_og_dict.keys())):
+        gnm_og_set = gnm_to_og_dict[each_gnm]
+        og_cov = len(gnm_og_set)*100/len(og_file_list)
+        og_cov = float("{0:.2f}".format(og_cov))
+        og_cov_txt_handle.write('%s\t%s\n' % (each_gnm, og_cov))
+    og_cov_txt_handle.close()
+
+
+og_dir      = '/Users/songweizhi/Desktop/OrthologousGroupsFasta_cov95'
+og_ext      = 'fa'
+og_cov_txt  = '/Users/songweizhi/Desktop/gnm_og_cov.txt'
+
+get_gnm_og_cov(og_dir, og_ext, og_cov_txt)
+

TreeSAK/catfasta2phy.py

@@ -0,0 +1,140 @@
+import os
+import glob
+from Bio import SeqIO
+from Bio import AlignIO
+
+
+def catfasta2phy(msa_dir, msa_ext, concatenated_msa_phy, partition_file):
+
+    concatenated_msa_fasta = '%s.fasta' % concatenated_msa_phy
+    msa_file_re            = '%s/*.%s'  % (msa_dir, msa_ext)
+    msa_file_list          = [os.path.basename(file_name) for file_name in glob.glob(msa_file_re)]
+    msa_file_list_sorted   = sorted(msa_file_list)
+
+    complete_gnm_set = set()
+    for each_msa_file in msa_file_list:
+        pwd_msa = '%s/%s' % (msa_dir, each_msa_file)
+        for each_seq in SeqIO.parse(pwd_msa, 'fasta'):
+            complete_gnm_set.add(each_seq.id)
+
+    complete_gnm_list_sorted = sorted([i for i in complete_gnm_set])
+
+    # initialize concatenated msa dict
+    gnm_to_seq_dict = {i: '' for i in complete_gnm_list_sorted}
+    msa_len_dict = dict()
+    for each_msa_file in msa_file_list_sorted:
+        gene_id = each_msa_file.split('.' + msa_ext)[0]
+
+        # read in msa
+        current_msa_len = 0
+        current_msa_len_set = set()
+        pwd_current_msa = '%s/%s' % (msa_dir, each_msa_file)
+        current_msa_seq_dict = dict()
+        for each_seq in SeqIO.parse(pwd_current_msa, 'fasta'):
+            complete_gnm_set.add(each_seq.id)
+            current_msa_seq_dict[each_seq.id] = str(each_seq.seq)
+            current_msa_len_set.add(len(each_seq.seq))
+            current_msa_len = len(each_seq.seq)
+
+        if len(current_msa_len_set) != 1:
+            print('Sequences with different length were found in %s, program exited!' % each_msa_file)
+            exit()
+
+        msa_len_dict[gene_id] = current_msa_len
+
+        # add sequence to concatenated msa dict
+        for each_gnm in complete_gnm_list_sorted:
+            msa_seq = current_msa_seq_dict.get(each_gnm, current_msa_len*'-')
+            gnm_to_seq_dict[each_gnm] += msa_seq
+
+    # write out concatenated msa
+    concatenated_msa_handle = open(concatenated_msa_fasta, 'w')
+    for each_gnm in complete_gnm_list_sorted:
+        concatenated_msa_handle.write('>%s\n' % each_gnm)
+        concatenated_msa_handle.write('%s\n' % gnm_to_seq_dict[each_gnm])
+    concatenated_msa_handle.close()
+
+    # write out partition file
+    end_pos = 0
+    partition_file_handle = open(partition_file, 'w')
+    for each_m in msa_file_list_sorted:
+        gene_id = each_m.split('.' + msa_ext)[0]
+        current_m_len = msa_len_dict[gene_id]
+        partition_file_handle.write('%s = %s-%s\n' % (each_m, (end_pos + 1), (end_pos + current_m_len)))
+        end_pos += current_m_len
+    partition_file_handle.close()
+
+    # convert msa in fasta to phy
+    AlignIO.convert(concatenated_msa_fasta, 'fasta', concatenated_msa_phy, 'phylip-relaxed')
+
+
+msa_dir                = '/Users/songweizhi/Desktop/s06_identified_marker_aln_trimmed'
+msa_ext                = 'aln'
+concatenated_msa_phy   = '/Users/songweizhi/Desktop/s06_identified_marker_aln_trimmed_concatenated.phy'
+partition_file         = '/Users/songweizhi/Desktop/s06_identified_marker_aln_trimmed_concatenated_partition.txt'
+# catfasta2phy(msa_dir, msa_ext, concatenated_msa_phy, partition_file)
+
+
+
+msa_file = '/Users/songweizhi/Desktop/PA_75_DeltaLL_75_concatenated.phy'
+msa_file_subset = '/Users/songweizhi/Desktop/PA_75_DeltaLL_75_concatenated_subset.phy'
+
+from Bio import AlignIO
+
+def slice_msa_by_col(msa_in, range_str, msa_out):
+    alignment = AlignIO.read(msa_in, 'phylip-relaxed')
+
+    range_l = int(range_str.split('-')[0]) - 1
+    range_r = int(range_str.split('-')[1])
+
+    aln_subset = alignment[:, range_l:range_r]
+    AlignIO.write(aln_subset, msa_out, 'phylip-relaxed')
+
+
+def slice_msa_by_col_manual(msa_in, range_str, msa_out):
+    alignment = AlignIO.read(msa_in, 'phylip-relaxed')
+
+    range_l = int(range_str.split('-')[0]) - 1
+    range_r = int(range_str.split('-')[1])
+    aln_subset = alignment[:, range_l:range_r]
+
+    max_seq_id_len = 0
+    for each_seq in aln_subset:
+        seq_id_len = len(each_seq.id)
+        if seq_id_len > max_seq_id_len:
+            max_seq_id_len = seq_id_len
+    print(max_seq_id_len)
+
+    with open(msa_out, 'w') as msa_out_handle:
+        msa_out_handle.write('%s %s\n' % (len(aln_subset), aln_subset.get_alignment_length()))
+        for each_seq in aln_subset:
+            seq_id = each_seq.id
+            seq_id_with_space = '%s%s' % (seq_id, ' '*(max_seq_id_len + 2 - len(seq_id)))
+            print(seq_id_with_space)
+            msa_out_handle.write('%s%s\n' % (seq_id_with_space, str(each_seq.seq)))
+
+
+#    AlignIO.write(aln_subset, msa_out, 'phylip-relaxed')
+
+
+slice_range = ['1-500', '501-1000', '1001-1500', '1501-2000', '2001-2500', '2501-3000', '3001-3500', '3501-4000', '4001-4500', '4501-4879']
+
+for each_range in slice_range:
+    pwd_msa_op = '/Users/songweizhi/Desktop/%s.phy' % each_range
+    slice_msa_by_col_manual(msa_file, each_range, pwd_msa_op)
+
+
+def fa2phy(fasta_in, phy_out):
+    alignment = AlignIO.read(fasta_in, 'fasta')
+    max_seq_id_len = 0
+    for each_seq in alignment:
+        seq_id_len = len(each_seq.id)
+        if seq_id_len > max_seq_id_len:
+            max_seq_id_len = seq_id_len
+
+    with open(phy_out, 'w') as msa_out_handle:
+        msa_out_handle.write('%s %s\n' % (len(alignment), alignment.get_alignment_length()))
+        for each_seq in alignment:
+            seq_id = each_seq.id
+            seq_id_with_space = '%s%s' % (seq_id, ' ' * (max_seq_id_len + 2 - len(seq_id)))
+            msa_out_handle.write('%s%s\n' % (seq_id_with_space, str(each_seq.seq)))

TreeSAK/cogTree.py

@@ -0,0 +1,185 @@
+import os
+import glob
+import argparse
+from Bio import SeqIO
+import multiprocessing as mp
+
+
+cogTree_usage = '''
+================================ cogTree example commands ================================
+
+TreeSAK cogTree -i combined.faa -cog arCOG_wd -o op_dir -bmge -t 12 -f -fun arCOG_id.txt
+TreeSAK cogTree -i combined.faa -cog arCOG_wd -o op_dir -bmge -t 12 -f -fun arCOG00724
+TreeSAK cogTree -i combined.faa -cog arCOG_wd -o op_dir -bmge -t 12 -f -fun arCOG00724,arCOG02271 
+
+==========================================================================================
+'''
+
+
+def select_seq(seq_file, seq_id_set, output_file):
+    output_file_handle = open(output_file, 'w')
+    for seq_record in SeqIO.parse(seq_file, 'fasta'):
+        seq_id = seq_record.id
+        if seq_id in seq_id_set:
+            SeqIO.write(seq_record, output_file_handle, 'fasta-2line')
+    output_file_handle.close()
+
+
+def cogTree(args):
+
+    combined_faa            = args['i']
+    cog_annotation_wd       = args['cog']
+    interested_fun_txt      = args['fun']
+    op_dir                  = args['o']
+    trim_with_bmge          = args['bmge']
+    trim_model              = args['bmge_m']
+    entropy_score_cutoff    = args['bmge_esc']
+    iqtree_model            = args['iqtree_m']
+    force_overwrite         = args['f']
+    num_of_threads          = args['t']
+
+    # specify path to BMGE.jar
+    current_file_path = '/'.join(os.path.realpath(__file__).split('/')[:-1])
+    pwd_bmge_jar = '%s/BMGE.jar' % current_file_path
+
+    interested_fun_set = set()
+    if os.path.isfile(interested_fun_txt) is False:
+        if ',' in interested_fun_txt:
+            interested_fun_set = interested_fun_txt.split(',')
+        else:
+            interested_fun_set.add(interested_fun_txt)
+    else:
+        for each_fun in open(interested_fun_txt):
+            interested_fun_set.add(each_fun.strip().split()[0])
+
+    ################################################################################
+
+    faa_dir                 = '%s/dir_1_faa'                % op_dir
+    aln_dir                 = '%s/dir_2_msa'                % op_dir
+    trimmed_aln_dir         = '%s/dir_3_trimmed_msa'        % op_dir
+    tree_dir                = '%s/dir_4_tree'               % op_dir
+    cmd_1_mafft_txt         = '%s/cmd_1_mafft.txt'          % op_dir
+    cmd_2_trim_txt          = '%s/cmd_2_trim.txt'           % op_dir
+    cmd_3_tree_txt          = '%s/cmd_3_tree.txt'           % op_dir
+
+    ################################################################################
+
+    # create output folder
+    if os.path.isdir(op_dir) is True:
+        if force_overwrite is True:
+            os.system('rm -r %s' % op_dir)
+        else:
+            print('%s exist, program exited!' % op_dir)
+            exit()
+
+    os.mkdir(op_dir)
+    os.mkdir(faa_dir)
+    os.mkdir(aln_dir)
+    os.mkdir(trimmed_aln_dir)
+    os.mkdir(tree_dir)
+
+    ################################################################################
+
+    fun_to_gene_dict = dict()
+    if cog_annotation_wd is not None:
+
+        print('Reading in COG annotation results')
+        file_re = '%s/*COG_wd/*_query_to_cog.txt' % (cog_annotation_wd)
+        file_list = glob.glob(file_re)
+        if len(file_list) == 0:
+            print('COG annotation file not detected, program exited!')
+            exit()
+
+        for each_file in file_list:
+            line_index = 0
+            for each_line in open(each_file):
+                if line_index > 0:
+                    each_line_split = each_line.strip().split('\t')
+                    if len(each_line_split) == 4:
+                        gene_id = each_line_split[0]
+                        cog_id = each_line_split[1]
+                        if cog_id in interested_fun_set:
+                            if cog_id not in fun_to_gene_dict:
+                                fun_to_gene_dict[cog_id] = set()
+                            fun_to_gene_dict[cog_id].add(gene_id)
+                line_index += 1
+
+    cmd_list_mafft = []
+    cmd_list_trim  = []
+    cmd_list_tree  = []
+    cmd_1_mafft_txt_handle = open(cmd_1_mafft_txt, 'w')
+    cmd_2_trim_txt_handle = open(cmd_2_trim_txt, 'w')
+    cmd_3_tree_txt_handle = open(cmd_3_tree_txt, 'w')
+    for each_fun in sorted(fun_to_gene_dict):
+
+        # define file name
+        fun_faa                     = '%s/%s.faa'           % (faa_dir, each_fun)
+        current_gene_tree_dir       = '%s/%s'               % (tree_dir, each_fun)
+        fun_aln                     = '%s/%s.aln'           % (aln_dir, each_fun)
+        fun_aln_trimmed             = '%s/%s_trimal.aln'    % (trimmed_aln_dir, each_fun)
+        if trim_with_bmge is True:
+            fun_aln_trimmed         = '%s/%s_bmge.aln'      % (trimmed_aln_dir, each_fun)
+
+        # extract sequences
+        current_fun_gene_set = fun_to_gene_dict[each_fun]
+        select_seq(combined_faa, current_fun_gene_set, fun_faa)
+
+        os.system('mkdir %s' % current_gene_tree_dir)
+
+        # prepare commands
+        mafft_cmd      = 'mafft-einsi --thread %s --quiet %s > %s'      % (1, fun_faa, fun_aln)
+        trim_cmd       = 'trimal -in %s -out %s -automated1'            % (fun_aln, fun_aln_trimmed)
+        if trim_with_bmge is True:
+            trim_cmd   = 'java -jar %s -i %s -m %s -t AA -h %s -of %s'  % (pwd_bmge_jar, fun_aln, trim_model, entropy_score_cutoff, fun_aln_trimmed)
+        infer_tree_cmd = 'iqtree2 -s %s --seqtype AA -m %s -B 1000 --wbtl --bnni --prefix %s/%s -T %s --quiet' % (fun_aln_trimmed, iqtree_model, current_gene_tree_dir, each_fun, num_of_threads)
+
+        # add commands to list
+        cmd_list_mafft.append(mafft_cmd)
+        cmd_list_trim.append(trim_cmd)
+        cmd_list_tree.append(infer_tree_cmd)
+
+        # write out commands
+        cmd_1_mafft_txt_handle.write(mafft_cmd + '\n')
+        cmd_2_trim_txt_handle.write(trim_cmd + '\n')
+        cmd_3_tree_txt_handle.write(infer_tree_cmd + '\n')
+
+    cmd_1_mafft_txt_handle.close()
+    cmd_2_trim_txt_handle.close()
+    cmd_3_tree_txt_handle.close()
+
+    # run mafft commands
+    print('Running mafft with %s cores for %s commands' % (num_of_threads, len(cmd_list_mafft)))
+    pool = mp.Pool(processes=num_of_threads)
+    pool.map(os.system, cmd_list_mafft)
+    pool.close()
+    pool.join()
+
+    # run trim commands
+    print('Trimming with %s cores for %s commands' % (num_of_threads, len(cmd_list_trim)))
+    pool = mp.Pool(processes=num_of_threads)
+    pool.map(os.system, cmd_list_trim)
+    pool.close()
+    pool.join()
+
+    # run iqtree commands
+    print('Running iqtree with %s cores' % num_of_threads)
+    for each_iqtree_cmd in sorted(cmd_list_tree):
+        print(each_iqtree_cmd)
+        os.system(each_iqtree_cmd)
+
+
+if __name__ == '__main__':
+
+    cogTree_parser = argparse.ArgumentParser()
+    cogTree_parser.add_argument('-i',         required=True,                          help='orthologous gene sequence')
+    cogTree_parser.add_argument('-fun',       required=True,                          help='interested functions')
+    cogTree_parser.add_argument('-cog',       required=False, default=None,           help='COG annotation results')
+    cogTree_parser.add_argument('-o',         required=True,                          help='output directory')
+    cogTree_parser.add_argument('-bmge',      required=False, action="store_true",    help='trim with BMGE, default is trimal')
+    cogTree_parser.add_argument('-bmge_m',    required=False, default='BLOSUM30',     help='trim model, default: BLOSUM30')
+    cogTree_parser.add_argument('-bmge_esc',  required=False, default='0.55',         help='entropy score cutoff, default: 0.55')
+    cogTree_parser.add_argument('-iqtree_m',  required=False, default='LG+G+I',       help='iqtree_model, default: LG+G+I')
+    cogTree_parser.add_argument('-f',         required=False, action="store_true",    help='force overwrite')
+    cogTree_parser.add_argument('-t',         required=False, type=int, default=1,    help='num of threads, default: 1')
+    args = vars(cogTree_parser.parse_args())
+    cogTree(args)

TreeSAK/compare_trees.R

@@ -0,0 +1,30 @@
+
+# check.packages function: install and load multiple R packages.
+# Check to see if packages are installed. Install them if they are not, then load them into the R session.
+check.packages <- function(pkg){
+    new.pkg <- pkg[!(pkg %in% installed.packages()[, "Package"])]
+    if (length(new.pkg))
+        install.packages(new.pkg, dependencies = TRUE)
+    sapply(pkg, require, character.only = 1)}
+
+# install packages if not installed
+packages<-c("optparse", "ape", "vegan")
+invisible(suppressMessages(check.packages(packages)))
+
+option_list = list(
+  make_option(c("-a", "--treeo"),  type="character", default=NULL, help="the first tree"),
+  make_option(c("-b", "--treet"),  type="character", default=NULL, help="the second tree"));
+
+opt_parser = OptionParser(option_list=option_list);
+opt = parse_args(opt_parser);
+
+TREE1 = read.tree(opt$treeo)
+TREE2 = read.tree(opt$treet)
+
+D1 = cophenetic(TREE1)
+D1 = D1[order(row.names(D1)),order(row.names(D1))]
+D2 = cophenetic(TREE2)
+D2 = D2[order(row.names(D2)),order(row.names(D2))]
+
+mantel(xdis = D1, ydis = D2, permutations = 999)
+

TreeSAK/compare_trees.py

@@ -0,0 +1,255 @@
+import os
+import glob
+import argparse
+from ete3 import Tree
+import multiprocessing as mp
+
+
+compare_trees_usage = '''
+======================== compare_trees example command ========================
+
+TreeSAK compare_trees -t1 tree_1.newick -t2 tree_2.newick -o op_dir
+TreeSAK compare_trees -t1 tree_dir -t2 tree_dir -tx newick -dm -t 12 -o op_dir
+
+===============================================================================
+'''
+
+
+def sep_path_basename_ext(file_in):
+
+    # separate path and file name
+    file_path, file_name = os.path.split(file_in)
+    if file_path == '':
+        file_path = '.'
+
+    # separate file basename and extension
+    file_basename, file_extension = os.path.splitext(file_name)
+
+    return file_path, file_basename, file_extension
+
+
+def check_numeric(str_in):
+    is_numeric = True
+    try:
+        x = float(str_in)
+    except ValueError:
+        is_numeric = False
+
+    return is_numeric
+
+
+def parse_mantel_stats(mantel_stats_txt):
+
+    mantel_similarity = 'na'
+    for each_line in open(mantel_stats_txt):
+        if 'Mantel statistic r: ' in each_line:
+            mantel_similarity = each_line.strip().split('Mantel statistic r: ')[1]
+    return mantel_similarity
+
+
+def get_matrix(query_tree_list, subject_tree_list, mantel_stats_dir, write_out_dm, output_matrix, output_matrix_distance):
+
+    header_line_str = '\t' + '\t'.join(subject_tree_list) + '\n'
+
+    output_matrix_handle = open(output_matrix, 'w')
+    output_matrix_handle.write(header_line_str)
+    distance_lol = []
+    for each_qt in query_tree_list:
+
+        current_qt_mantel_stats_value_list = [each_qt]
+        for each_st in subject_tree_list:
+
+            qt_vs_st_mantel_stats = '%s/%s_vs_%s_mantel_stats.txt' % (mantel_stats_dir, each_qt, each_st)
+            st_vs_qt_mantel_stats = '%s/%s_vs_%s_mantel_stats.txt' % (mantel_stats_dir, each_st, each_qt)
+
+            tree_similarity = 'na'
+            if os.path.isfile(qt_vs_st_mantel_stats) is True:
+                tree_similarity = parse_mantel_stats(qt_vs_st_mantel_stats)
+            if os.path.isfile(st_vs_qt_mantel_stats) is True:
+                tree_similarity = parse_mantel_stats(st_vs_qt_mantel_stats)
+
+            current_qt_mantel_stats_value_list.append(tree_similarity)
+
+        current_qt_mantel_stats_value_list_distance = [each_qt]
+        for each_value in current_qt_mantel_stats_value_list[1:]:
+            if check_numeric(each_value) is True:
+                in_distance = 1 - float(each_value)
+                in_distance = float("{0:.4f}".format(in_distance))
+                if in_distance == 0:
+                    in_distance = '0'
+                current_qt_mantel_stats_value_list_distance.append(str(in_distance))
+            else:
+                current_qt_mantel_stats_value_list_distance.append('na')
+
+        distance_lol.append(current_qt_mantel_stats_value_list_distance)
+        current_qt_mantel_stats_value_str = '\t'.join(current_qt_mantel_stats_value_list)
+        output_matrix_handle.write(current_qt_mantel_stats_value_str + '\n')
+    output_matrix_handle.close()
+
+    # write out distance matrix
+    if write_out_dm is True:
+        output_matrix_distance_handle = open(output_matrix_distance, 'w')
+        output_matrix_distance_handle.write(header_line_str)
+        for each_list in distance_lol:
+            output_matrix_distance_handle.write('\t'.join(each_list) + '\n')
+        output_matrix_distance_handle.close()
+
+
+def compare_trees_worker(arg_list):
+
+    compare_trees_R = arg_list[0]
+    tree_file_1     = arg_list[1]
+    tree_file_2     = arg_list[2]
+    tmp_dir         = arg_list[3]
+    keep_tmp_file   = arg_list[4]
+
+    tree1_path, tree1_basename, tree1_extension = sep_path_basename_ext(tree_file_1)
+    tree2_path, tree2_basename, tree2_extension = sep_path_basename_ext(tree_file_2)
+
+    op_stats = '%s/%s_vs_%s_mantel_stats.txt' % (tmp_dir, tree1_basename, tree2_basename)
+
+    t1 = Tree(tree_file_1, format=1)
+    t2 = Tree(tree_file_2, format=1)
+
+    tree1_leaf_list = []
+    for leaf1 in t1:
+        tree1_leaf_list.append(leaf1.name)
+
+    tree2_leaf_list = []
+    for leaf2 in t2:
+        tree2_leaf_list.append(leaf2.name)
+
+    shared_leaves = set(tree1_leaf_list).intersection(tree2_leaf_list)
+    if len(shared_leaves) == 0:
+        print('No leaves shared between %s and %s, calculation skipped!' % (tree1_basename, tree2_basename))
+        #exit()
+
+    elif len(tree1_leaf_list) == len(tree2_leaf_list) == len(shared_leaves):
+        compare_trees_cmd = 'Rscript %s -a %s -b %s > %s' % (compare_trees_R, tree_file_1, tree_file_2, op_stats)
+        os.system(compare_trees_cmd)
+
+    elif (len(shared_leaves) != len(tree1_leaf_list)) or (len(shared_leaves) != len(tree2_leaf_list)):
+        print('Performing Mantel test based on %s leaves shared by %s (%s) and %s (%s)' % (len(shared_leaves), tree1_basename, len(tree1_leaf_list), tree2_basename, len(tree2_leaf_list)))
+
+        # write out shared leaves
+        shared_leaves_txt = '%s/%s_vs_%s_shared_leaves.txt' % (tmp_dir, tree1_basename, tree2_basename)
+        shared_leaves_txt_handle = open(shared_leaves_txt, 'w')
+        for each_shared_leaf in shared_leaves:
+            shared_leaves_txt_handle.write(each_shared_leaf + '\n')
+        shared_leaves_txt_handle.close()
+
+        # subset_tree
+        t1_subset     = '%s/%s_vs_%s_%s_subset%s'                           % (tmp_dir, tree1_basename, tree2_basename, tree1_basename, tree1_extension)
+        t2_subset     = '%s/%s_vs_%s_%s_subset%s'                           % (tmp_dir, tree1_basename, tree2_basename, tree2_basename, tree2_extension)
+        subset_cmd_t1 = 'BioSAK subset_tree -tree %s -taxon %s -out %s -q'  % (tree_file_1, shared_leaves_txt, t1_subset)
+        subset_cmd_t2 = 'BioSAK subset_tree -tree %s -taxon %s -out %s -q'  % (tree_file_2, shared_leaves_txt, t2_subset)
+        os.system(subset_cmd_t1)
+        os.system(subset_cmd_t2)
+
+        compare_trees_cmd = 'Rscript %s -a %s -b %s > %s' % (compare_trees_R, t1_subset, t2_subset, op_stats)
+        os.system(compare_trees_cmd)
+
+        if keep_tmp_file is False:
+            os.system('rm %s' % shared_leaves_txt)
+            os.system('rm %s' % t1_subset)
+            os.system('rm %s' % t2_subset)
+
+
+def compare_trees(args):
+
+    op_dir              = args['o']
+    tree_file_1         = args['t1']
+    tree_file_2         = args['t2']
+    tree_file_ext       = args['tx']
+    export_dm           = args['dm']
+    num_threads         = args['t']
+    keep_tmp            = args['tmp']
+    force_create_op_dir = args['f']
+
+    current_file_path   = '/'.join(os.path.realpath(__file__).split('/')[:-1])
+    compare_trees_R     = '%s/compare_trees.R'  % current_file_path
+    tmp_dir             = '%s/tmp'              % op_dir
+
+    query_tree_list = []
+    if os.path.isfile(tree_file_1):
+        query_tree_list = [tree_file_1]
+    elif os.path.isdir(tree_file_1):
+        query_tree_re = '%s/*.%s' % (tree_file_1, tree_file_ext)
+        query_tree_list = glob.glob(query_tree_re)
+
+    subject_tree_list = []
+    if os.path.isfile(tree_file_2):
+        subject_tree_list = [tree_file_2]
+    elif os.path.isdir(tree_file_2):
+        subject_tree_re = '%s/*.%s' % (tree_file_2, tree_file_ext)
+        subject_tree_list = glob.glob(subject_tree_re)
+
+    # prepare arg list for compare_trees_worker
+    to_be_calculated_set = set()
+    list_for_compare_trees_worker = []
+    for each_query_tree in query_tree_list:
+        for each_subject_tree in subject_tree_list:
+
+            tree_1_vs_2 = '%s_vs_%s' % (each_query_tree, each_subject_tree)
+            tree_2_vs_1 = '%s_vs_%s' % (each_subject_tree, each_query_tree)
+
+            if tree_1_vs_2 not in to_be_calculated_set:
+                list_for_compare_trees_worker.append([compare_trees_R, each_query_tree, each_subject_tree, tmp_dir, keep_tmp])
+                to_be_calculated_set.add(tree_1_vs_2)
+                to_be_calculated_set.add(tree_2_vs_1)
+
+    print('Total pairs of trees to compare: %s' % len(list_for_compare_trees_worker))
+
+    # create op_dir
+    if os.path.isdir(op_dir) is True:
+        if force_create_op_dir is True:
+            os.system('rm -r %s' % op_dir)
+        else:
+            print('Output folder detected, program exited!')
+            exit()
+    os.system('mkdir %s' % op_dir)
+    os.system('mkdir %s' % tmp_dir)
+
+    # compare trees with multiprocessing
+    pool = mp.Pool(processes=num_threads)
+    pool.map(compare_trees_worker, list_for_compare_trees_worker)
+    pool.close()
+    pool.join()
+
+    # get matrix
+    output_matrix_similarity = '%s/Matrix_similarity.txt' % op_dir
+    output_matrix_distance   = '%s/Matrix_distance.txt'   % op_dir
+    query_tree_list_basename = []
+    for each_q_tree in query_tree_list:
+        q_tree_path, q_tree_basename, q_tree_ext = sep_path_basename_ext(each_q_tree)
+        query_tree_list_basename.append(q_tree_basename)
+
+    subject_tree_list_basename = []
+    for each_s_tree in subject_tree_list:
+        s_tree_path, s_tree_basename, s_tree_ext = sep_path_basename_ext(each_s_tree)
+        subject_tree_list_basename.append(s_tree_basename)
+
+    get_matrix(sorted(query_tree_list_basename), sorted(subject_tree_list_basename), tmp_dir, export_dm, output_matrix_similarity, output_matrix_distance)
+
+    # final report
+    if export_dm is True:
+        print('Data matrix exported to: %s and %s' % (output_matrix_similarity, output_matrix_distance))
+    else:
+        print('Data matrix exported to: %s' % output_matrix_similarity)
+
+    print('Done!')
+
+
+if __name__ == '__main__':
+
+    compare_trees_parser = argparse.ArgumentParser(usage=compare_trees_usage)
+    compare_trees_parser.add_argument('-o',   required=True,                       help='output directory')
+    compare_trees_parser.add_argument('-t1',  required=True,                       help='tree (folder) 1')
+    compare_trees_parser.add_argument('-t2',  required=True,                       help='tree (folder) 2')
+    compare_trees_parser.add_argument('-tx',  required=False, default='newick',    help='extention of tree files, default: newick')
+    compare_trees_parser.add_argument('-dm',  required=False, action="store_true", help='export distance-alike matrix, obtained by subtract the similarity value from 1')
+    compare_trees_parser.add_argument('-t',   required=False, type=int, default=1, help='number of threads')
+    compare_trees_parser.add_argument('-tmp', required=False, action="store_true", help='keep tmp files')
+    compare_trees_parser.add_argument('-f',   required=False, action="store_true", help='force overwrite')
+    args = vars(compare_trees_parser.parse_args())
+    compare_trees(args)