def main():
simconfig.branching_factor = 4
simconfig.depth_factor = 4
stats = analysis.BalancedTreeAutomorphismStatistics(simconfig)
g2 = nx.balanced_tree(simconfig.branching_factor, simconfig.depth_factor)
r2 = stats.calculate_graph_symmetries(g2)
log.info("results: %s", r2)
def test_orbit_multiplicites(self):
g = nx.read_adjlist("testdata/asymmetric-tree.adjlist", nodetype=int)
#g = nx.read_dot("testdata/asymmetric-tree.dot")
sym = stats.BalancedTreeAutomorphismStatistics(self.sc)
dg = sym._format_graph_as_nauty(g)
raw = sym._get_raw_nauty_output(dg)
results = sym._parse_nauty_output(raw, g)
obs = len(results['orbitcounts'])
log.info("results: %s", results)
self.assertEqual(obs, 26)
def test_num_orbits(self):
# build a simple example graph
g = nx.petersen_graph()
sym = stats.BalancedTreeAutomorphismStatistics(self.sc)
dg = sym._format_graph_as_nauty(g)
nauty_format = sym._get_raw_nauty_output(dg)
log.info("%s", nauty_format)
o = re.compile('(\d+) orbit;')
m = o.search(nauty_format)
if m:
num_orbits = m.group(1)
#log.debug("num_orbits match: %s", num_orbits)
log.info("orbits in petersen graph: %s", num_orbits)
self.assertEqual(1, int(num_orbits))
else:
self.assertTrue(False)
def get_tree_symmetries_for_traitset(model, simconfig, cultureid, traitset,
culture_count_map):
radii = []
symstats = stats.BalancedTreeAutomorphismStatistics(simconfig)
subgraph_set = model.trait_universe.get_trait_graph_components(traitset)
trait_subgraph = model.trait_universe.get_trait_forest_from_traits(
traitset)
results = symstats.calculate_graph_symmetries(trait_subgraph)
for subgraph in subgraph_set:
radii.append(nx.radius(subgraph))
mean_radii = np.mean(np.asarray(radii))
sd_radii = np.sqrt(np.var(np.asarray(radii)))
degrees = nx.degree(trait_subgraph).values()
mean_degree = np.mean(np.asarray(degrees))
sd_degree = np.sqrt(np.var(np.asarray(degrees)))
mean_orbit_mult = np.mean(np.asarray(results['orbitcounts']))
sd_orbit_mult = np.sqrt(np.var(np.asarray(results['orbitcounts'])))
max_orbit_mult = np.nanmax(np.asarray(results['orbitcounts']))
r = dict(cultureid=str(cultureid),
culture_count=culture_count_map[cultureid],
orbit_multiplicities=results['orbitcounts'],
orbit_number=results['orbits'],
autgroupsize=results['groupsize'],
remaining_density=results['remainingdensity'],
mean_radii=mean_radii,
sd_radii=sd_radii,
mean_degree=mean_degree,
sd_degree=sd_degree,
mean_orbit_multiplicity=mean_orbit_mult,
sd_orbit_multiplicity=sd_orbit_mult,
max_orbit_multiplicity=max_orbit_mult)
#log.debug("groupstats: %s", r)
return r
def test_nauty_format(self):
# build a simple example graph
g = nx.complete_graph(6)
sym = stats.BalancedTreeAutomorphismStatistics(self.sc)
dg = sym._format_graph_as_nauty(g)
log.info(dg)
simconfig.num_trees = n
# hack - nauty takes *forever* to calculate the automorphism group size of a really large group
# so I did it once and we're caching the results. r=6, h=6 is too big, nauty core dumps.
manual = False
if r == 4 and h == 6:
forest_order = 4338.043478424945794
manual = True
elif r == 6 and h == 4:
forest_order = 1704.026063910616259
manual = True
elif r == 6 and h == 6:
forest_order = float("inf")
manual = True
else:
sym = maa.BalancedTreeAutomorphismStatistics(simconfig)
(forest, roots) = utils.generate_forest_balanced_trees(r, h, 1)
log.debug("asking nauty for the aut group size for r=%s, h=%s",
r, h)
res = sym.calculate_graph_symmetries(forest)
forest_order = res["groupsize"]
forest_cache[t] = forest_order
trait_graph_stats_list = row["trait_graph_stats"]
tgs_out = []
for tgs in trait_graph_stats_list:
# first calculate the number of remaining vertices in the forest and store it
o_mult = tgs["orbit_multiplicities"]