def check_split_counting(
self,
tree_filename,
test_as_rooted,
parser_rooting_interpretation,
test_ignore_tree_weights=False,
dp_ignore_tree_weights=False,
):
tree_filepath = pathmap.tree_source_path(tree_filename)
ps = paup.PaupService()
paup_sd = ps.get_split_distribution_from_files(
tree_filepaths=[tree_filepath],
is_rooted=test_as_rooted,
use_tree_weights=not test_ignore_tree_weights,
burnin=0,
taxa_definition_filepath=tree_filepath)
taxon_namespace = paup_sd.taxon_namespace
dp_sd = dendropy.SplitDistribution(taxon_namespace=taxon_namespace)
dp_sd.ignore_edge_lengths = True
dp_sd.ignore_node_ages = True
dp_sd.ignore_tree_weights = dp_ignore_tree_weights
taxa_mask = taxon_namespace.all_taxa_bitmask()
taxon_namespace.is_mutable = False
trees = dendropy.TreeList.get_from_path(
tree_filepath,
"nexus",
rooting=parser_rooting_interpretation,
taxon_namespace=taxon_namespace)
for tree in trees:
self.assertIs(tree.taxon_namespace, taxon_namespace)
self.assertIs(tree.taxon_namespace, dp_sd.taxon_namespace)
dp_sd.count_splits_on_tree(tree, is_bipartitions_updated=False)
self.assertEqual(dp_sd.total_trees_counted,
paup_sd.total_trees_counted)
taxa_mask = taxon_namespace.all_taxa_bitmask()
for split in dp_sd.split_counts:
if not dendropy.Bipartition.is_trivial_bitmask(
split, taxa_mask):
# if split not in paup_sd.split_counts:
# print("{}: {}".format(split, split in paup_sd.split_counts))
# s2 = taxon_namespace.normalize_bitmask(split)
# print("{}: {}".format(s2, s2 in paup_sd.split_counts))
# s3 = ~split & taxon_namespace.all_taxa_bitmask()
# print("{}: {}".format(s3, s3 in paup_sd.split_counts))
self.assertIn(split, paup_sd.split_counts,
"split not found")
self.assertEqual(dp_sd.split_counts[split],
paup_sd.split_counts[split],
"incorrect split frequency")
del paup_sd.split_counts[split]
remaining_splits = list(paup_sd.split_counts.keys())
for split in remaining_splits:
if dendropy.Bipartition.is_trivial_bitmask(split, taxa_mask):
del paup_sd.split_counts[split]
self.assertEqual(len(paup_sd.split_counts), 0)
def check_splits_counting(
self,
tree_filename,
taxa_definition_filepath,
splits_filename,
paup_as_rooted,
paup_use_tree_weights,
paup_burnin,
expected_taxon_labels,
expected_is_rooted,
expected_num_trees,
):
tree_filepath = pathmap.tree_source_path(tree_filename)
paup_service = paup.PaupService()
result = paup_service.count_splits_from_files(
tree_filepaths=[tree_filepath],
taxa_definition_filepath=taxa_definition_filepath,
is_rooted=paup_as_rooted,
use_tree_weights=paup_use_tree_weights,
burnin=paup_burnin,
)
num_trees = result["num_trees"]
bipartition_counts = result["bipartition_counts"]
bipartition_freqs = result["bipartition_freqs"]
taxon_namespace = result["taxon_namespace"]
is_rooted = result["is_rooted"]
# check taxon namespace
self.assertEqual(len(taxon_namespace), len(expected_taxon_labels))
for taxon, expected_label in zip(taxon_namespace,
expected_taxon_labels):
self.assertEqual(taxon.label, expected_label)
# check general tree state
self.assertEqual(num_trees, expected_num_trees)
self.assertIs(is_rooted, expected_is_rooted)
splits_ref = paupsplitsreference.get_splits_reference(
splits_filename=splits_filename,
key_column_index=0,
)
self.assertEqual(len(splits_ref), len(bipartition_counts))
self.assertEqual(len(splits_ref), len(bipartition_freqs))
if is_rooted:
splits_ref_bitmasks = set([
splits_ref[x]["unnormalized_split_bitmask"]
for x in splits_ref
])
else:
splits_ref_bitmasks = set([
splits_ref[x]["normalized_split_bitmask"]
for x in splits_ref
])
counts_keys = set(bipartition_counts.keys())
freqs_keys = set(bipartition_freqs.keys())
self.assertEqual(len(counts_keys), len(splits_ref_bitmasks))
self.assertEqual(
counts_keys, splits_ref_bitmasks,
"\n {}\n\n {}\n\n".format(sorted(counts_keys),
sorted(splits_ref_bitmasks)))
for split_str_rep in splits_ref:
ref = splits_ref[split_str_rep]
self.assertEqual(split_str_rep, ref["bipartition_string"])
self.assertEqual(
paup.PaupService.bipartition_groups_to_split_bitmask(
split_str_rep, normalized=False),
ref["unnormalized_split_bitmask"])
self.assertEqual(
paup.PaupService.bipartition_groups_to_split_bitmask(
split_str_rep, normalized=True),
ref["normalized_split_bitmask"])
split_bitmask = paup.PaupService.bipartition_groups_to_split_bitmask(
split_str_rep, normalized=not is_rooted)
self.assertEqual(bipartition_counts[split_bitmask],
ref["count"])
# self.assertAlmostEqual(bipartition_freqs[split_bitmask], ref["frequency"])
self.assertAlmostEqual(bipartition_freqs[split_bitmask],
ref["frequency"],
2) # PAUP* 4.10b: no very precise
def setUp(self):
self.ps = paup.PaupService()