def test_weightkey():
g1 = nx.DiGraph()
g2 = nx.DiGraph()
g1.add_edge('A','B', weight=1)
g2.add_edge('C','D', weight=0)
assert_true( nx.is_isomorphic(g1, g2) )
em = iso.numerical_edge_match('nonexistent attribute', 1)
assert_true( nx.is_isomorphic(g1, g2, edge_match=em) )
em = iso.numerical_edge_match('weight', 1)
assert_false( nx.is_isomorphic(g1, g2, edge_match=em) )
g2 = nx.DiGraph()
g2.add_edge('C','D')
assert_true( nx.is_isomorphic(g1, g2, edge_match=em) )
def build(self):
g1 = self.g1
g2 = self.g2
# We will assume integer weights only.
g1.add_edge('A', 'B', color='green', weight=0, size=.5)
g1.add_edge('A', 'B', color='red', weight=1, size=.35)
g1.add_edge('A', 'B', color='red', weight=2, size=.65)
g2.add_edge('C', 'D', color='green', weight=1, size=.5)
g2.add_edge('C', 'D', color='red', weight=0, size=.45)
g2.add_edge('C', 'D', color='red', weight=2, size=.65)
if g1.is_multigraph():
self.em = iso.numerical_multiedge_match('weight', 1)
self.emc = iso.categorical_multiedge_match('color', '')
self.emcm = iso.categorical_multiedge_match(['color', 'weight'], ['', 1])
self.emg1 = iso.generic_multiedge_match('color', 'red', eq)
self.emg2 = iso.generic_multiedge_match(['color', 'weight', 'size'], ['red', 1, .5], [eq, eq, iso.matchhelpers.close])
else:
self.em = iso.numerical_edge_match('weight', 1)
self.emc = iso.categorical_edge_match('color', '')
self.emcm = iso.categorical_edge_match(['color', 'weight'], ['', 1])
self.emg1 = iso.generic_multiedge_match('color', 'red', eq)
self.emg2 = iso.generic_edge_match(['color', 'weight', 'size'], ['red', 1, .5], [eq, eq, iso.matchhelpers.close])
def test_graphml(self):
output = convert(
'graph', self.test_input['distances'], {'format': 'graphml'})
expected_edges = set(self.test_input['distances']['data'].edges(
data='distance'))
actual_edges = set()
self.assertIsInstance(output['data'], (str, unicode))
tree = etree.fromstring(output['data'])
self.assertEqual(len(tree), 2)
self.assertEqual(tree[0].tag, self.GRAPHML_NS + 'key')
self.assertEqual(tree[1].tag, self.GRAPHML_NS + 'graph')
for edge in tree[1].findall(self.GRAPHML_NS + 'edge'):
edge = (edge.attrib['source'],
edge.attrib['target'],
int(edge.find(self.GRAPHML_NS + 'data').text))
self.assertNotIn(edge, actual_edges)
actual_edges.add(edge)
self.assertEqual(expected_edges, actual_edges)
output = convert(
'graph', output, {'format': 'networkx'})
self.assertTrue(
is_isomorphic(output['data'],
self.test_input['distances']['data'],
edge_match=numerical_edge_match('distance', 1)))
def get_frequency(G_q, train_g_path):
"""
# Projecting a Query Graph to BoFG histogram
"""
train_lst = fn.get_file_list(train_g_path, ".g")
freq_lst = []
for g_tr in train_lst:
G_tr = nx.read_gpickle(train_g_path + g_tr)
# Count the frequency of each G_tr in G_q
# Check that Node labels of G_tr belongs to that of G_q
with open(train_g_path + g_tr[:-2] + ".nodelabel", "r") as nl:
G_tr_nlabels = json.load(nl)
G_q_nlabels = [int(n_tup[1]["label"]) for n_tup in G_q.nodes(data=True)]
if fn.is_subset(G_tr_nlabels, G_q_nlabels):
# print G_tr_nlabels, G_tr.edges(data=True)
nm = iso.numerical_node_match("label", 1)
em = iso.numerical_edge_match("weight", 0)
GM = iso.GraphMatcher(G_q, G_tr, node_match=nm, edge_match=em)
frequency = len(list(GM.subgraph_isomorphisms_iter()))
if frequency > 0:
BoFG_ID = int(g_tr[-5:-2])
freq_lst.append((BoFG_ID, frequency))
return freq_lst
def check_isomorphism(json_1, json_2):
g1 = json.loads(json_1)
g2 = json.loads(json_2)
try:
nodes_1 = [(i['id'], {'type': i['type']}) for i in g1['nodes']]
edges_1 = [(i['from'],i['to'], {'type': i['type']}) for i in g1['edges']]
nodes_2 = [(i['id'], {'type': i['type']}) for i in g2['nodes']]
edges_2 = [(i['from'],i['to'], {'type': i['type']}) for i in g2['edges']]
except KeyError:
return g1 == g2 # if graph isomorphism check is not possible, fall back to simple json-level equality check
graph_1 = nx.Graph()
graph_1.add_nodes_from(nodes_1)
graph_1.add_edges_from(edges_1)
graph_2 = nx.Graph()
graph_2.add_nodes_from(nodes_2)
graph_2.add_edges_from(edges_2)
nm = iso.numerical_node_match('type',-1)
em = iso.numerical_edge_match('type',-1)
return nx.is_isomorphic(graph_1, graph_2, node_match=nm, edge_match=em)
def _get_subgraph_N_X_N(self, graph1, graph2, name1, name2):
ret = {
'subgraph_N_0_N' : 0
}
# TODO: not worth counting all of them
# ret = {
# 'subgraph_N_0_N' : 0,
# 'subgraph_N_1_N' : 0,
# 'subgraph_N_2_N' : 0
# }
subgraphs1 = self._get_subgraphs(graph1, name1, 2)
subgraphs2 = self._get_subgraphs(graph2, name2, 2)
for r in itertools.product(subgraphs1, subgraphs2):
GM = nx.algorithms.isomorphism.GraphMatcher(r[0], r[1],
node_match=iso.categorical_node_match(['str_name'], ['name']),
edge_match=iso.numerical_edge_match(['color'], [-1]))
if GM.is_isomorphic():
for u, v, d in r[0].edges(data=True):
if d['color'] == 0:
ret['subgraph_N_0_N'] += 1
# print u + " " + v + " 0"
# TODO: appears to be unuseful
# elif d['color'] == 1:
# ret['subgraph_N_1_N'] += 1
# # print u + " " + v + " 1"
# elif d['color'] == 2:
# ret['subgraph_N_2_N'] += 1
# # print u + " " + v + " 2"
return ret
def build(self):
self.nm = iso.categorical_node_match('color', '')
self.em = iso.numerical_edge_match('weight', 1)
self.g1.add_node('A', color='red')
self.g2.add_node('C', color='blue')
self.g1.add_edge('A', 'B', weight=1)
self.g2.add_edge('C', 'D', weight=1)
def __eq__(
self, other
): # two rules are equal if the LHSs match and RHSs are isomorphic
g1 = nx.convert_node_labels_to_integers(self.graph)
g2 = nx.convert_node_labels_to_integers(other.graph)
# and nx.fast_could_be_isomorphic(g1, g2) \
return self.lhs == other.lhs \
and nx.is_isomorphic(g1, g2, edge_match=iso.numerical_edge_match('weight', 1.0),
node_match=iso.categorical_node_match('label', ''))
def build(self):
self.nm = iso.categorical_node_match('color', '')
self.em = iso.numerical_edge_match('weight', 1)
self.g1.add_node('A', color='red')
self.g2.add_node('C', color='blue')
self.g1.add_edge('A','B', weight=1)
self.g2.add_edge('C','D', weight=1)
def __fit_graph(self, model):
if self.get_bin_step() != 0:
gm = iso.GraphMatcher(self._PharmacophoreBase__g,
model,
node_match=self.__nm,
edge_match=self.__em)
else:
gm = iso.GraphMatcher(self._PharmacophoreBase__g,
model,
node_match=self.__nm,
edge_match=iso.numerical_edge_match(
'dist', 0, atol=0.75))
return gm
def test_find_edges_in_file_different_weight(self):
with mock.patch('graph.open') as m:
with mock.patch("sample.count_import") as s:
s.return_value = 2
m.return_value = io.StringIO("import sample \n from agh")
gg = networkx.DiGraph()
g.find_edges_in_file("node.py", gg, "/")
em = iso.numerical_edge_match('weight', 1)
# equality of graph
self.assertFalse(
networkx.is_isomorphic(gg,
self.get_expected_graph(),
edge_match=em))
def test_back_and_forth(self):
ncsv, ecsv = self.tmp_root + "test_node_csv", self.tmp_root + "test_edges_csv"
parser.networkx_to_csv(self.G, ncsv, ecsv)
H = parser.csv_to_networkx(ncsv, ecsv)
print(self.G.nodes())
print(H.nodes())
print(self.G.edges(), H.edges())
#Test isomorphism
em = iso.numerical_edge_match('weight', 1)
self.assertTrue(nx.is_isomorphic(self.G, H, edge_match=em))
def test_cmdline_back_and_forth(self):
pickle.dump(self.G, open("test_out.nx", 'wb'))
su.check_call([
"lntk-nx_to_csv", "test_out.nx", "test_nodes_csv", "test_edges_csv"
])
su.check_call([
"lntk-csv_to_nx", "test_nodes_csv", "test_edges_csv", "test_out.nx"
])
H = pickle.load(open("test_out.nx", 'rb'))
em = iso.numerical_edge_match('weight', 1)
self.assertTrue(nx.is_isomorphic(self.G, H, edge_match=em))
def _get_subgraph_3_nodes(self, graph1, graph2, name1, name2):
ret = {'subgraph_3N': 0}
subgraphs1 = self._get_subgraphs(graph1, name1, 3)
subgraphs2 = self._get_subgraphs(graph2, name2, 3)
for r in itertools.product(subgraphs1, subgraphs2):
GM = nx.algorithms.isomorphism.GraphMatcher(
r[0],
r[1],
node_match=iso.categorical_node_match(['str_name'], ['name']),
edge_match=iso.numerical_edge_match(['color'], [-1]))
if GM.is_isomorphic():
ret['subgraph_3N'] += 1
return ret
def _get_subgraph_3_nodes(self, graph1, graph2, name1, name2):
ret = {
'subgraph_3N' : 0
}
subgraphs1 = self._get_subgraphs(graph1, name1, 3)
subgraphs2 = self._get_subgraphs(graph2, name2, 3)
for r in itertools.product(subgraphs1, subgraphs2):
GM = nx.algorithms.isomorphism.GraphMatcher(r[0], r[1],
node_match=iso.categorical_node_match(['str_name'], ['name']),
edge_match=iso.numerical_edge_match(['color'], [-1]))
if GM.is_isomorphic():
ret['subgraph_3N'] += 1
return ret
def test_simple():
# 16 simple tests
w = 'weight'
edges = [(0, 0, 1), (0, 0, 1.5), (0, 1, 2), (1, 0, 3)]
for g1 in [
nx.Graph(),
nx.DiGraph(),
nx.MultiGraph(),
nx.MultiDiGraph(),
]:
g1.add_weighted_edges_from(edges)
g2 = g1.subgraph(g1.nodes())
if g1.is_multigraph():
em = iso.numerical_multiedge_match('weight', 1)
else:
em = iso.numerical_edge_match('weight', 1)
assert_true(nx.is_isomorphic(g1, g2, edge_match=em))
for mod1, mod2 in [(False, True), (True, False), (True, True)]:
# mod1 tests a regular edge
# mod2 tests a selfloop
if g2.is_multigraph():
if mod1:
data1 = {0: {'weight': 10}}
if mod2:
data2 = {0: {'weight': 1}, 1: {'weight': 2.5}}
else:
if mod1:
data1 = {'weight': 10}
if mod2:
data2 = {'weight': 2.5}
g2 = g1.subgraph(g1.nodes()).copy()
if mod1:
if not g1.is_directed():
g2._adj[1][0] = data1
g2._adj[0][1] = data1
else:
g2._succ[1][0] = data1
g2._pred[0][1] = data1
if mod2:
if not g1.is_directed():
g2._adj[0][0] = data2
else:
g2._succ[0][0] = data2
g2._pred[0][0] = data2
assert_false(nx.is_isomorphic(g1, g2, edge_match=em))
def test_simple():
# 16 simple tests
w = 'weight'
edges = [(0, 0, 1), (0, 0, 1.5), (0, 1, 2), (1, 0, 3)]
for g1 in [nx.Graph(),
nx.DiGraph(),
nx.MultiGraph(),
nx.MultiDiGraph(),
]:
g1.add_weighted_edges_from(edges)
g2 = g1.subgraph(g1.nodes())
if g1.is_multigraph():
em = iso.numerical_multiedge_match('weight', 1)
else:
em = iso.numerical_edge_match('weight', 1)
assert_true( nx.is_isomorphic(g1, g2, edge_match=em) )
for mod1, mod2 in [(False, True), (True, False), (True, True)]:
# mod1 tests a regular edge
# mod2 tests a selfloop
if g2.is_multigraph():
if mod1:
data1 = {0: {'weight': 10}}
if mod2:
data2 = {0: {'weight': 1}, 1: {'weight': 2.5}}
else:
if mod1:
data1 = {'weight': 10}
if mod2:
data2 = {'weight': 2.5}
g2 = g1.subgraph(g1.nodes()).copy()
if mod1:
if not g1.is_directed():
g2._adj[1][0] = data1
g2._adj[0][1] = data1
else:
g2._succ[1][0] = data1
g2._pred[0][1] = data1
if mod2:
if not g1.is_directed():
g2._adj[0][0] = data2
else:
g2._succ[0][0] = data2
g2._pred[0][0] = data2
assert_false(nx.is_isomorphic(g1, g2, edge_match=em))
def create_fvl(glist, flist):
fva = np.zeros((len(glist), len(flist)))
i = 0
nm = iso.categorical_node_match('elem', 'C')
em = iso.numerical_edge_match('weight', 1)
for mol in glist:
# print(i)
j = 0
for feature in flist:
GM = iso.GraphMatcher(mol, feature, node_match=nm, edge_match=em)
if GM.subgraph_is_isomorphic():
fva[i][j] = 1
j += 1
i += 1
return fva
def _get_subgraph_N(self, graph1, graph2, name1, name2):
ret = 0
subgraphs1 = self._get_subgraphs(graph1, name1, 1)
subgraphs2 = self._get_subgraphs(graph2, name2, 1)
for r in itertools.product(subgraphs1, subgraphs2):
GM = nx.algorithms.isomorphism.GraphMatcher(r[0], r[1],
node_match=iso.categorical_node_match(['str_name'], ['name']),
edge_match=iso.numerical_edge_match(['color'], [-1]))
if GM.is_isomorphic():
is_upper = False
for n, d in r[0].nodes_iter(data=True):
if d['str_name'].isupper():
is_upper = True
if not is_upper:
ret = 1
return {'subgraph_N' : ret}
def _matcher_factory(self, graph_component, value_type):
factory_dict = dict(node=dict(), edge=dict())
# TODO Is this dangerous?
numerical_default = 0.
categorical_default = None
factory_dict['node']['categorical'] = iso.categorical_node_match(
self.label, categorical_default)
factory_dict['node']['numerical'] = iso.numerical_node_match(
self.label, numerical_default)
factory_dict['edge']['categorical'] = iso.categorical_edge_match(
self.label, categorical_default)
factory_dict['edge']['numerical'] = iso.numerical_edge_match(
self.label, numerical_default)
return factory_dict[graph_component][value_type]
def categorize_functional_groups(self, groups):
"""
Determine classes of functional groups present in a set.
:param groups: Set of functional groups.
:return: dict containing representations of the groups, the indices of
where the group occurs in the MoleculeGraph, and how many of each
type of group there is.
"""
categories = {}
em = iso.numerical_edge_match("weight", 1)
nm = iso.categorical_node_match("specie", "C")
for group in groups:
atoms = [self.molecule[a] for a in group]
species = [a.specie for a in atoms]
coords = [a.coords for a in atoms]
adaptor = BabelMolAdaptor(Molecule(species, coords))
# Use Canonical SMILES to ensure uniqueness
smiles = adaptor.pybel_mol.write("can").strip()
if smiles in categories:
this_subgraph = self.molgraph.graph.subgraph(
list(group)).to_undirected()
for other in categories[smiles]["groups"]:
other_subgraph = self.molgraph.graph.subgraph(
list(other)).to_undirected()
if not nx.is_isomorphic(this_subgraph,
other_subgraph,
edge_match=em,
node_match=nm):
break
if group not in categories[smiles]["groups"]:
categories[smiles]["groups"].append(group)
categories[smiles]["count"] += 1
else:
categories[smiles] = {"groups": [group], "count": 1}
return categories
def _get_subgraph_N(self, graph1, graph2, name1, name2):
ret = 0
subgraphs1 = self._get_subgraphs(graph1, name1, 1)
subgraphs2 = self._get_subgraphs(graph2, name2, 1)
for r in itertools.product(subgraphs1, subgraphs2):
GM = nx.algorithms.isomorphism.GraphMatcher(
r[0],
r[1],
node_match=iso.categorical_node_match(['str_name'], ['name']),
edge_match=iso.numerical_edge_match(['color'], [-1]))
if GM.is_isomorphic():
is_upper = False
for n, d in r[0].nodes_iter(data=True):
if d['str_name'].isupper():
is_upper = True
if not is_upper:
ret = 1
return {'subgraph_N': ret}
def categorize_functional_groups(self, groups):
"""
Determine classes of functional groups present in a set.
:param groups: Set of functional groups.
:return: dict containing representations of the groups, the indices of
where the group occurs in the MoleculeGraph, and how many of each
type of group there is.
"""
categories = {}
em = iso.numerical_edge_match("weight", 1)
nm = iso.categorical_node_match("specie", "C")
for group in groups:
atoms = [self.molecule[a] for a in group]
species = [a.specie for a in atoms]
coords = [a.coords for a in atoms]
adaptor = BabelMolAdaptor(Molecule(species, coords))
# Use Canonical SMILES to ensure uniqueness
smiles = adaptor.pybel_mol.write("can").strip()
if smiles in categories:
this_subgraph = self.molgraph.graph.subgraph(list(group)).to_undirected()
for other in categories[smiles]["groups"]:
other_subgraph = self.molgraph.graph.subgraph(list(other)).to_undirected()
if not nx.is_isomorphic(this_subgraph, other_subgraph,
edge_match=em, node_match=nm):
break
if group not in categories[smiles]["groups"]:
categories[smiles]["groups"].append(group)
categories[smiles]["count"] += 1
else:
categories[smiles] = {"groups": [group],
"count": 1}
return categories
def _printmoleculename(self):
mname = []
d = defaultdict(list)
em = iso.numerical_edge_match(['atom', 'level'], ["None", 1])
with WriteBuffer(open(self.moleculefilename, 'w'),
sep='\n') as fm, open(self.moleculetemp2filename,
'rb') as ft:
for line in itertools.zip_longest(*[ft] * 3):
atoms, bonds = self._getatomsandbonds(line)
molecule = self._molecule(self, atoms, bonds)
for isomer in d[str(molecule)]:
if isomer.isomorphic(molecule, em):
molecule.smiles = isomer.smiles
break
else:
d[str(molecule)].append(molecule)
mname.append(molecule.smiles)
fm.append(
listtostirng((molecule.smiles, atoms, bonds),
sep=(' ', ';', ',')))
self.mname = np.array(mname)
def reactant_indices(R1, R2, P, broken_bond):
"""Match the indices of a pair of reactants from a
product and broken bond.
Parameters
----------
R1 : networkx MultiGraph
Graph representing reactant 1
R2 : networkx MultiGraph
Graph representing reactant 2
P : networkx MultiGraph
Graph representing the product
broken_bond : list (2,)
Indices representing the edge of the product
to be removed.
Returns
-------
pindex: ndarrays (n,)
Indices of the product graph sorted by the order of
the reactants indices.
"""
GM = nx.algorithms.isomorphism.GraphMatcher
em = iso.numerical_edge_match('bonds', 1)
nm = iso.numerical_node_match('number', 1)
Pgraph = P.copy()
u, v = broken_bond
Pgraph.graph.remove_edge(u, v)
Rgraph = R1 + R2
gm = GM(Pgraph.graph, Rgraph.graph, edge_match=em, node_match=nm)
gm.is_isomorphic()
pindex = np.empty(len(Pgraph), dtype=int)
for k, v in gm.mapping.items():
pindex[k] = v
return pindex
def _handlespecies(self, name):
showname = {}
if self.species == {}:
species_out = dict([(x, {}) for x in (name if len(
name) <= self.maxspecies else name[0:self.maxspecies])])
else:
species_out = {}
b = True
for spec in self.species.items():
specname, value = spec
if "structure" in value:
atoms, bonds = value["structure"]
G1 = self._convertstructure(atoms, bonds)
if b:
structures = self._readstrcture()
em = iso.numerical_edge_match(
['atom', 'level'], ["None", 1])
b = False
i = 1
while (specname+"_"+str(i) if i > 1 else specname) in structures:
G2 = self._convertstructure(structures[(
specname+"_"+str(i) if i > 1 else specname)][0], structures[(specname+"_"+str(i) if i > 1 else specname)][1])
if nx.is_isomorphic(G1, G2, em):
if i > 1:
specname += "_"+str(i)
break
i += 1
species_out[specname] = {}
if "showname" in value:
showname[specname] = value["showname"]
if self.showid:
if species_out:
self._logging()
self._logging("Species are:")
for n, (specname, value) in enumerate(species_out.items(), start=1):
showname[specname] = str(n)
print(n, specname)
return species_out, showname
def _get_subgraph_N_X_N(self, graph1, graph2, name1, name2):
ret = {'subgraph_N_0_N': 0, 'subgraph_N_1_N': 0, 'subgraph_N_2_N': 0}
subgraphs1 = self._get_subgraphs(graph1, name1, 2)
subgraphs2 = self._get_subgraphs(graph2, name2, 2)
for r in itertools.product(subgraphs1, subgraphs2):
GM = nx.algorithms.isomorphism.GraphMatcher(
r[0],
r[1],
node_match=iso.categorical_node_match(['str_name'], ['name']),
edge_match=iso.numerical_edge_match(['color'], [-1]))
if GM.is_isomorphic():
for u, v, d in r[0].edges(data=True):
if d['color'] == 0:
ret['subgraph_N_0_N'] += 1
# print u + " " + v + " 0"
elif d['color'] == 1:
ret['subgraph_N_1_N'] += 1
# print u + " " + v + " 1"
elif d['color'] == 2:
ret['subgraph_N_2_N'] += 1
# print u + " " + v + " 2"
return ret
def _printmoleculename(self):
mname = []
d = {}
em = iso.numerical_edge_match(['atom', 'level'], ["None", 1])
with open(self.moleculefilename, 'w') as fm, open(self.moleculetemp2filename, 'rb') as ft, open(self.moleculestructurefilename, 'w') as fs:
for line in ft:
s = self._decompress(line).split()
atoms = np.array([int(x) for x in s[0].split(",")])
bonds = np.array([tuple(int(y) for y in x.split(","))
for x in s[1].split(";")] if len(s) == 3 else [])
typenumber = np.zeros(len(self.atomname), dtype=np.int)
atomtypes = []
for atomnumber in atoms:
typenumber[self._atomtype[atomnumber-1]-1] += 1
atomtypes.append(
(atomnumber, self._atomtype[atomnumber-1]))
G = self._makemoleculegraph(atomtypes, bonds)
name = "".join([self.atomname[i]+(str(typenumber[i] if typenumber[i] > 1 else ""))
if typenumber[i] > 0 else "" for i in range(0, len(self.atomname))])
if name in d:
for j in range(len(d[name])):
if nx.is_isomorphic(G, d[name][j], em):
if j > 0:
name += "_"+str(j+1)
break
else:
d[name].append(G)
name += "_"+str(len(d[name]))
print(self._getstructure(name, atoms, bonds), file=fs)
else:
d[name] = [G]
print(self._getstructure(name, atoms, bonds), file=fs)
mname.append(name)
print(name, ",".join([str(x) for x in atoms]), ";".join(
[",".join([str(y) for y in x]) for x in bonds]), file=fm)
self._mname = mname
def __setstate__(self, state):
self.__dict__.update(state)
self.__nm = iso.categorical_node_match('label', '_')
self.__em = iso.numerical_edge_match('dist', 0)
def __init__(self, bin_step=1, cached=False):
super().__init__(bin_step, cached)
self.__nm = iso.categorical_node_match('label', '_')
self.__em = iso.numerical_edge_match('dist', 0)
G_q.add_edge( v1, v2, weight=order_dist )
"""
# Projecting a Query Graph to BoFG histogram
"""
train_path = 'train/model_1/graph/'
train_lst = fn.get_file_list( train_path, '.g' )
for g_tr in train_lst:
G_tr = nx.read_gpickle( train_path + g_tr )
# Count the frequency of each G_tr in G_q
# Check that Node labels of G_tr belongs to that of G_q
with open( train_path + g_tr[:-2] + '.nodelabel', 'r') as nl:
G_tr_nlabels = json.load( nl )
G_q_nlabels = [ int(n_tup[1]['label']) for n_tup in G_q.nodes(data=True)]
if fn.is_subset( G_tr_nlabels, G_q_nlabels ):
# print G_tr_nlabels, G_tr.edges(data=True)
nm = iso.numerical_node_match('label', 1)
em = iso.numerical_edge_match('weight', 0)
GM = iso.GraphMatcher( G_q, G_tr, node_match=nm, edge_match=em )
#==============================================================================
# for subgraph in GM.subgraph_isomorphisms_iter():
# print subgraph
#==============================================================================
if len(list(GM.subgraph_isomorphisms_iter())) > 0:
BoFG_ID = int( g_tr[-5:-2] )
def __eq__(self, other):
return nx.is_isomorphic(self._Graph,
other._Graph,
edge_match=numerical_edge_match("weight", 1))
def main():
""" Main func inicial"""
numberOfCircuits = 100 # numero de arquivos rcirucit0,rcircuit1 ...
maxElements = 200 # numero maximo de elementos dentro de cada circuito
maxCM = 0
criarCircuitos = 0
if criarCircuitos == 1:
os.chdir(
'C:\\Users\\evand\\Documents\\teste pfc\\netlists\\script\\teste_CM0\\experimento'
+ str(numberOfCircuits) + '_' + str(maxElements) + '_' +
str(maxCM))
os.system('create_netlists.py --file ' + str(numberOfCircuits) +
' --max_elements ' + str(maxElements) + ' --max_CM ' +
str(maxCM))
#caminho dos circuitos
os.chdir('C:\\Users\\evand\\Documents\\teste pfc')
pathC = 'C:/Users/evand/Documents/teste pfc/netlists/script/teste_CM0/experimento' + str(
numberOfCircuits) + '_' + str(maxElements) + '_' + str(
maxCM) + '/circuits/'
#arquivo de simplificações de circuito
list_simpl = []
for i in range(1, 5):
list_simpl.append('netlists/archSimpl/simplifica' + str(i) + '.sp')
list_arq = []
for i in range(1, 6):
list_arq.append('netlists/script/experimento1_evandro/CM_circuits/cm' +
str(i) + '.sp')
# ['netlists/script/CM_circuits/cm0.sp','netlists/script/CM_circuits/cm1.sp','netlists/script/CM_circuits/cm2.sp',
# 'netlists/script/CM_circuits/cm3.sp','netlists/script/CM_circuits/cm4.sp','netlists/script/CM_circuits/cm5.sp',
# 'netlists/script/CM_circuits/cm6.sp','netlists/script/CM_circuits/cm7.sp','netlists/script/CM_circuits/cm8.sp',
# 'netlists/script/CM_circuits/cm9.sp','netlists/script/CM_circuits/cm10.sp','netlists/script/CM_circuits/cm10.sp']
#
#carrega arquiteturas para simplificação de circuitos (associação de resistores e capacitores)
archSimpl_list = []
for arq in list_simpl:
archSimpl_list = read_arch(arq, archSimpl_list)
#carrega arquiteturas espelhos de corrente
arch_list = []
for arq in list_arq:
arch_list = read_arch(arq, arch_list)
#carrega circuito
listaMatchCircs = []
listaMatchCircsReal = []
tableOfResults = []
totalArchitectures = 0
numberOfCorrectsArch = np.zeros(numberOfCircuits)
contadorArchCM = 0
#T_netlist,C_netlist,R_netlist = read_netlist(open('netlists/script/circuits/rcircuit0teste2.sp').readlines())
#T_netlist,C_netlist,R_netlist = read_netlist(open('netlists/script/teste/simplifica/rcircuit0.sp').readlines())
for circ in range(0, 130):
T_netlist, C_netlist, R_netlist = read_netlist(
open(pathC + 'rcircuit' + str(circ) + '.sp').readlines())
arch_in_circ = read_log(
open(pathC + 'rcircuit' + str(circ) + '.log').readlines())
#cria grafo do circuito sem peso
#graph = create_graph(T_netlist,R_netlist,C_netlist, False)
#cria grafo do circuito com pesos
graph = create_graph(T_netlist, R_netlist, C_netlist, True, False)
#nx.draw(graph, with_labels=True, node_size=10, font_size = 6,figsize=(400,400))
#nx.draw_spectral(graph, with_labels=True, node_size=10, font_size = 6)
#nx.draw_spring(graph, with_labels=True, node_size=10, font_size = 8)
#nx.draw_circular(graph, with_labels=True)
#realiza passagens pelo circuitos para identificar e realizar possíveis simplificações
sair = 0
nCS = 0 #numero de Capacitores em série
nCP = 0 #numero de Capacitores em paralelo
nRS = 0 #numero de Resistores em série
nRP = 0 #numero de Resistores em paralelo
while sair == 0:
sair = 1 # se ele fizer qualquer simplificação ele muda este flag para 0 e verifica novamente
cont_archSimpl = -1
for arch in archSimpl_list:
cont_archSimpl = cont_archSimpl + 1
graph_arch = create_graph(arch[0], arch[2], arch[1], True,
False)
em = iso.numerical_edge_match(
['weight', 'weight', 'weight', 'weight', 'weight'],
[1, 2, 3, 4, 5])
nm = iso.categorical_node_match(['type', 'type'], ['C', 'R'])
GM = iso.GraphMatcher(graph,
graph_arch,
edge_match=em,
node_match=nm)
II = GM.subgraph_is_isomorphic()
print('simplificação: ', cont_archSimpl + 1,
II) #+1 porque as arquiteturas começam em 1 e não zero
# if II: #apenas para visualização
# if plotar == 1:
# for subgraph in GM.subgraph_isomorphisms_iter():
# print(subgraph)
# plot_graph(graph.subgraph(subgraph.keys()))
lista_subgraph = []
for subgraph in GM.subgraph_isomorphisms_iter():
lista_subgraph.append(subgraph)
#verifica condições extras para simplificação
# - capacitores e resistores em série não podem ter mais que duas arestas no nó central entre eles
if list_espec_simpl[
cont_archSimpl] == 'CS': #para capacitores em série
for subgraph in lista_subgraph:
#busca estrutura no grafo do circuito
NA = list(subgraph.keys())[list(
subgraph.values()).index('NA')]
NB = list(subgraph.keys())[list(
subgraph.values()).index('NB')]
NC = list(subgraph.keys())[list(
subgraph.values()).index('NC')]
NE1 = list(subgraph.keys())[list(
subgraph.values()).index(
'C1')] #nó elemento (pode ser C ou R)
NE2 = list(subgraph.keys())[list(
subgraph.values()).index(
'C2')] #nó elemento (pode ser C ou R)
#verifica número de conexões no nó central dos capcitores e se o nó existe (se já não foi simplificado)
if (graph.has_node(NE1)) and (
graph.has_node(NE2)
): # existem os nós (não foram simplificados ainda)
if (len(graph.edges(NB)) == 2): #pode simplificar
nCS = nCS + 1
graph = simplificar(graph, NA, NB, NC, NE1,
NE2, 'CS')
sair = 0
#else:
#graph.nodes[NB]['valsub']='NNV' # indica se o nó é valido para comparação de isomorphismo (NNV = nó Não valido para subgrafo - tem mais de duas conexções no nó intermediário)
if list_espec_simpl[
cont_archSimpl] == 'RS': #para resistores em série
for subgraph in lista_subgraph:
#busca estrutura no grafo do circuito
NA = list(subgraph.keys())[list(
subgraph.values()).index('NA')]
NB = list(subgraph.keys())[list(
subgraph.values()).index('NB')]
NC = list(subgraph.keys())[list(
subgraph.values()).index('NC')]
NE1 = list(subgraph.keys())[list(
subgraph.values()).index(
'R1')] #nó elemento (pode ser C ou R)
NE2 = list(subgraph.keys())[list(
subgraph.values()).index(
'R2')] #nó elemento (pode ser C ou R)
#verifica número de conexões no nó central dos resistores e se o nó existe (se já não foi simplificado)
if (len(graph.edges(NB))
== 2) and (graph.has_node(NE1)) and (
graph.has_node(NE2)): #pode simplificar
nRS = nRS + 1
graph = simplificar(graph, NA, NB, NC, NE1, NE2,
'RS')
sair = 0
if list_espec_simpl[
cont_archSimpl] == 'CP': #para capacitores em paralelo
#cont = 0
for subgraph in lista_subgraph:
# AUX DEBUG #######################
#if cont == 1:
# print('break ',cont)
# break
#print('cont ',cont)
#cont = cont + 1
#print(list(subgraph.keys())[list(subgraph.values()).index('C1')], list(subgraph.keys())[list(subgraph.values()).index('C2')], '\n')
#############################
#busca estrutura no grafo do circuito
NA = list(subgraph.keys())[list(
subgraph.values()).index('NA')]
NB = list(subgraph.keys())[list(
subgraph.values()).index('NB')]
NC = 'none'
NE1 = list(subgraph.keys())[list(
subgraph.values()).index(
'C1')] #nó elemento (pode ser C ou R)
NE2 = list(subgraph.keys())[list(
subgraph.values()).index(
'C2')] #nó elemento (pode ser C ou R)
#verifica se o nó existe (se já não foi simplificado)
if (graph.has_node(NE1)) and (
graph.has_node(NE2)): #pode simplificar
nCP = nCP + 1
graph = simplificar(graph, NA, NB, NC, NE1, NE2,
'CP')
sair = 0
if list_espec_simpl[
cont_archSimpl] == 'RP': #para resistores em paralelo
for subgraph in lista_subgraph:
#busca estrutura no grafo do circuito
NA = list(subgraph.keys())[list(
subgraph.values()).index('NA')]
NB = list(subgraph.keys())[list(
subgraph.values()).index('NB')]
NC = 'none'
NE1 = list(subgraph.keys())[list(
subgraph.values()).index(
'R1')] #nó elemento (pode ser C ou R)
NE2 = list(subgraph.keys())[list(
subgraph.values()).index(
'R2')] #nó elemento (pode ser C ou R)
#verifica se o nó existe (se já não foi simplificado)
if (graph.has_node(NE1)) and (
graph.has_node(NE2)): #pode simplificar
nRP = nRP + 1
graph = simplificar(graph, NA, NB, NC, NE1, NE2,
'RP')
sair = 0
#cria grafo das arquiteturas
cont_arch = -1
listaMatch = []
for arch in arch_list:
cont_arch = cont_arch + 1
#sem peso
#graph_arch = create_graph(arch[0],arch[2],arch[1], False)
#COm peso
graph_arch = create_graph(arch[0], arch[2], arch[1], True, False)
#para encontrar isomorfismo em grafo sem peso
#GM = iso.GraphMatcher(graph,graph_arch)
#em = iso.numerical_multiedge_match(['weight','weight','weight'], [1,2,3])
em = iso.numerical_edge_match(
['weight', 'weight', 'weight', 'weight', 'weight'],
[1, 2, 3, 4, 5])
#em = iso.numerical_edge_match('weight', 2)
GM = iso.GraphMatcher(graph, graph_arch, edge_match=em)
II = GM.subgraph_is_isomorphic()
#print(GM.is_isomorphic())
print('match arquiteturas: ', cont_arch + 1,
II) #+1 porque as arquiteturas começam em 1 e não zero
#para teste
if II:
listaMatch.append(str(cont_arch + 1))
contadorArchCM += 1
for subgraph in GM.subgraph_isomorphisms_iter():
print(subgraph)
plot_graph(graph.subgraph(subgraph.keys()))
# resultados acurácia
print('nCS,nCP,nRS,nRP', nCS, nCP, nRS, nRP)
listaMatchCircs.append(listaMatch)
listaMatchCircsReal.append(arch_in_circ)
#print('######### 3/4 3=tipoDaArquiteturaDoEspelhoDeCorrente / 4=asVezesQueEssarArquiteturaSeRepetiu')
arch_in_circ_ordenadoSemRepeticao = list(
dict.fromkeys(sorted(arch_in_circ)))
arch_in_circ_contadorDeRepeticao = dict(
(i, arch_in_circ.count(i)) for i in sorted(arch_in_circ))
print(
f'tipo : numeroDeRepetiçoes = {arch_in_circ_contadorDeRepeticao}')
# print('listaMatch: ',listaMatch,type(listaMatch))
# print('arch_in_circ: ',arch_in_circ,type(arch_in_circ))
# numberOfCorrectsArch[circ] = list((Counter(listaMatch) & Counter(arch_in_circ)).elements())
# acuraciaDoCircuito = numberOfCorrectsArch[circ]/len(arch_in_circ)
a = set(listaMatch)
b = set(arch_in_circ)
numberOfCorrectsArch[circ] = len(a.intersection(b))
totalArchitectures = totalArchitectures + len(b)
if (len(b) == 0):
b = set([0])
acuraciaDoCircuito = len(a.intersection(b)) / len(b)
x = '{} & {} & {} & {} & {} & {} & {} & {}\\'.format(
circ + 1, maxElements, arch_in_circ_contadorDeRepeticao, nRP, nRS,
nCP, nCS, contadorArchCM, "{:.2f}".format(acuraciaDoCircuito))
tableOfResults.append(x)
print(x)
print('___________________________________')
tableOfResults = np.array(tableOfResults)
tableOfResults = tableOfResults[:, np.newaxis]
print(tableOfResults)
print('Acuracia total = ' +
str(sum(numberOfCorrectsArch) / totalArchitectures))
def main():
""" Main func """
#caminho dos circuitos
pathC = 'netlists/script/experimento1/circuits/'
#arquivo de simplificações de circuito
list_simpl = []
for i in range(1,5):
list_simpl.append('netlists/archSimpl/simplifica' + str(i) + '.sp')
#list_simpl. é uma variavel que recebe o caminho com as simplificações
list_arq = []
for i in range(1,6):
list_arq.append('netlists/script/experimento1/CM_circuits/cm' + str(i) + '.sp')
# ['netlists/script/CM_circuits/cm0.sp','netlists/script/CM_circuits/cm1.sp','netlists/script/CM_circuits/cm2.sp',
# 'netlists/script/CM_circuits/cm3.sp','netlists/script/CM_circuits/cm4.sp','netlists/script/CM_circuits/cm5.sp',
# 'netlists/script/CM_circuits/cm6.sp','netlists/script/CM_circuits/cm7.sp','netlists/script/CM_circuits/cm8.sp',
# 'netlists/script/CM_circuits/cm9.sp','netlists/script/CM_circuits/cm10.sp','netlists/script/CM_circuits/cm10.sp']
#
#########################################################################
#carrega arquiteturas para simplificação de circuitos (associação de resistores e capacitores)
archSimpl_list = []
for arq in list_simpl:
archSimpl_list = read_arch(arq,archSimpl_list)
# archSimpl_list recebe as arquiteturas dentro do caminho especificado(list_simpl), exemplo
# para a primeira posição deste vetor
# C1 (NA NB) C=1.0E-7
# C2 (NA NB) C=1.0E-7
#########################################################################
# carrega arquiteturas espelhos de corrente # que sao os cm1,cm2,...
arch_list = []
for arq in list_arq:
arch_list = read_arch(arq,arch_list) # read_netlist está dentro da função read_arch
#exemplo da primeira posição do vetor:
# T73 ( net23 net23 0 0) nfet L=9.64E-6 W=1.12E-6
# T74 ( net1 net23 0 0) nfet L=9.64E-6 W=1.12E-6
# R75 ( net1 net22) R=4.0E3
#########################################################################
#carrega circuito
listaMatchCircs = []
listaMatchCircsReal = []
contador = 0
tot = 5# total
acc = np.zeros(5)
#T_netlist,C_netlist,R_netlist = read_netlist(open('netlists/script/circuits/rcircuit0teste2.sp').readlines())
#T_netlist,C_netlist,R_netlist = read_netlist(open('netlists/script/teste/simplifica/rcircuit0.sp').readlines())
for circ in range(2,3):
T_netlist,C_netlist,R_netlist = read_netlist(open(pathC + 'rcircuit' + str(circ) + '.sp').readlines())
arch_in_circ = read_log(open(pathC + 'rcircuit' + str(circ) + '.log').readlines())
#cria grafo do circuito sem peso
#graph = create_graph(T_netlist,R_netlist,C_netlist, False)
#Cria grafo do circuito com pesos
graph = create_graph(T_netlist,R_netlist,C_netlist,True,False)
nx.draw(graph, with_labels=True, node_size=10, font_size = 6,figsize=(400,400))
nx.draw_spectral(graph, with_labels=True, node_size=10, font_size = 6)
nx.draw_spring(graph, with_labels=True, node_size=10, font_size = 8)
nx.draw_circular(graph, with_labels=True)
# #realiza passagens pelo circuitos para identificar e realizar possíveis simplificações
sair = 0
nCS = 0 #numero de Capacitores em série
nCP = 0 #numero de Capacitores em paralelo
nRS = 0 #numero de Resistores em série
nRP = 0 #numero de Resistores em paralelo
######################################## SIMPLIFICAÇÃO ##########################################
#################################################################################################
while sair == 0:
sair = 1 # se ele fizer qualquer simplificação ele muda este flag para 0 e verifica novamente
cont_archSimpl = -1
for arch in archSimpl_list:
cont_archSimpl=cont_archSimpl +1
#cria um grafo da arquitetura que se quer simplificar para comparar por ismorfismo
graph_arch = create_graph(arch[0],arch[2],arch[1],True,False)
# em <- funcao customizada de edge_match
em = iso.numerical_edge_match(['weight','weight','weight','weight','weight'], [1,2,3,4,5])
# nm <- funcao customizada de node match
nm = iso.categorical_node_match(['type', 'type'], ['C','R'])
GM = iso.GraphMatcher(graph,graph_arch,edge_match=em,node_match=nm)
II = GM.subgraph_is_isomorphic() # retorna TRUE or FALSE
print('simplificacao: ',cont_archSimpl+1,II) #+1 porque as arquiteturas começam em 1 e não zero
if II: #apenas para visualização
#if plotar == 1:
for subgraph in GM.subgraph_isomorphisms_iter():
print(subgraph)
plot_graph(graph.subgraph(subgraph.keys()))
lista_subgraph = []
for subgraph in GM.subgraph_isomorphisms_iter():
lista_subgraph.append(subgraph)
#verifica condições extras para simplificação
# - capacitores e resistores em série não podem ter mais que duas arestas no nó central entre eles
if list_espec_simpl[cont_archSimpl] == 'CS': #para capacitores em série
for subgraph in lista_subgraph:
#busca estrutura no grafo do circuito
NA = list(subgraph.keys())[list(subgraph.values()).index('NA')]
NB = list(subgraph.keys())[list(subgraph.values()).index('NB')]
NC = list(subgraph.keys())[list(subgraph.values()).index('NC')]
NE1 = list(subgraph.keys())[list(subgraph.values()).index('C1')] #nó elemento (pode ser C ou R)
NE2 = list(subgraph.keys())[list(subgraph.values()).index('C2')] #nó elemento (pode ser C ou R)
#verifica número de conexões no nó central dos capcitores e se o nó existe (se já não foi simplificado)
if (graph.has_node(NE1)) and (graph.has_node(NE2)): # existem os nós (não foram simplificados ainda)
if (len(graph.edges(NB))== 2): #pode simplificar
nCS = nCS + 1
graph = simplificar(graph,NA,NB,NC,NE1,NE2,'CS') # função de simplificação
sair = 0
#else:
#graph.node[NB]['valsub']='NNV' # indica se o nó é valido para comparação de isomorphismo (NNV = nó Não valido para subgrafo - tem mais de duas conexções no nó intermediário)
if list_espec_simpl[cont_archSimpl] == 'RS': #para resistores em série
for subgraph in lista_subgraph:
#busca estrutura no grafo do circuito
NA = list(subgraph.keys())[list(subgraph.values()).index('NA')]
NB = list(subgraph.keys())[list(subgraph.values()).index('NB')]
NC = list(subgraph.keys())[list(subgraph.values()).index('NC')]
NE1 = list(subgraph.keys())[list(subgraph.values()).index('R1')] #nó elemento (pode ser C ou R)
NE2 = list(subgraph.keys())[list(subgraph.values()).index('R2')] #nó elemento (pode ser C ou R)
#verifica número de conexões no nó central dos resistores e se o nó existe (se já não foi simplificado)
if (len(graph.edges(NB))== 2) and (graph.has_node(NE1)) and (graph.has_node(NE2)): #pode simplificar
nRS = nRS + 1
graph = simplificar(graph,NA,NB,NC,NE1,NE2,'RS')
sair = 0
if list_espec_simpl[cont_archSimpl] == 'CP': #para capacitores em paralelo
#cont = 0
for subgraph in lista_subgraph:
# AUX DEBUG #######################
#if cont == 1:
# print('break ',cont)
# break
#print('cont ',cont)
#cont = cont + 1
#print(list(subgraph.keys())[list(subgraph.values()).index('C1')], list(subgraph.keys())[list(subgraph.values()).index('C2')], '\n')
#############################
#busca estrutura no grafo do circuito
NA = list(subgraph.keys())[list(subgraph.values()).index('NA')]
NB = list(subgraph.keys())[list(subgraph.values()).index('NB')]
NC = 'none'
NE1 = list(subgraph.keys())[list(subgraph.values()).index('C1')] #nó elemento (pode ser C ou R)
NE2 = list(subgraph.keys())[list(subgraph.values()).index('C2')] #nó elemento (pode ser C ou R)
#verifica se o nó existe (se já não foi simplificado)
if (graph.has_node(NE1)) and (graph.has_node(NE2)): #pode simplificar
nCP = nCP + 1
graph = simplificar(graph,NA,NB,NC,NE1,NE2,'CP')
sair = 0
if list_espec_simpl[cont_archSimpl] == 'RP': #para resistores em paralelo
for subgraph in lista_subgraph:
#busca estrutura no grafo do circuito
NA = list(subgraph.keys())[list(subgraph.values()).index('NA')]
NB = list(subgraph.keys())[list(subgraph.values()).index('NB')]
NC = 'none'
NE1 = list(subgraph.keys())[list(subgraph.values()).index('R1')] #nó elemento (pode ser C ou R)
NE2 = list(subgraph.keys())[list(subgraph.values()).index('R2')] #nó elemento (pode ser C ou R)
#verifica se o nó existe (se já não foi simplificado)
if (graph.has_node(NE1)) and (graph.has_node(NE2)): #pode simplificar
nRP = nRP + 1
graph = simplificar(graph,NA,NB,NC,NE1,NE2,'RP')
sair = 0
###########################################################################################################
###########################################################################################################
#cria grafo das arquiteturas
cont_arch = -1
listaMatch =[]
for arch in arch_list:
cont_arch=cont_arch +1
#sem peso
#graph_arch = create_graph(arch[0],arch[2],arch[1], False)
#COm peso
graph_arch = create_graph(arch[0],arch[2],arch[1],True,False)
#para encontrar isomorfismo em grafo sem peso
#GM = iso.GraphMatcher(graph,graph_arch)
#em = iso.numerical_multiedge_match(['weight','weight','weight'], [1,2,3])
em = iso.numerical_edge_match(['weight','weight','weight','weight','weight'], [1,2,3,4,5])
#em = iso.numerical_edge_match('weight', 2)
GM = iso.GraphMatcher(graph,graph_arch,edge_match=em)
II = GM.subgraph_is_isomorphic()
#print(GM.is_isomorphic())
print('espelho de corrente: ',cont_arch+1,II) #+1 porque as arquiteturas começam em 1 e não zero
#para teste
if II:
listaMatch.append(str(cont_arch+1))
for subgraph in GM.subgraph_isomorphisms_iter():
print(subgraph)
plot_graph(graph.subgraph(subgraph.keys()))
# resultados acurácia
print('nCS,nCP,nRS,nRP', nCS,nCP,nRS,nRP)
listaMatchCircs.append(listaMatch)
listaMatchCircsReal.append(arch_in_circ)
a=set(listaMatch)
b=set(arch_in_circ)
contador = contador+1
print('contador =', contador)
acc[circ] = len(a.intersection(b))
tot = tot + len(b)
print(' ___________________________________________________________' )
print(' ___________________________________________________________' )
print('Acurácia = ' + str(sum(acc)/tot))
def __init__(self,
pos: np.ndarray,
sitetypes: List[str],
env2config: List[int],
permutations: List[List[int]],
cutoff: float = 6.00,
Grtol: float = 0.0,
Gatol: float = 0.01,
rtol: float = 0.01,
atol: float = 0.0,
tol: float = 0.01,
grtol: float = 1e-3):
"""
Initialize site environment
This class contains local site environment information. This is used
to find neighbor list in the datum.
Parameters
----------
pos : np.ndarray
n x 3 list or numpy array of (non-scaled) positions. n is the
number of atom.
sitetypes : List[str]
n list of string. String must be S or A followed by a
number. S indicates a spectator sites and A indicates a active
sites.
env2config: List[int]
A particular permutation of the neighbors around an active
site. These indexes will be used for lattice transformation.
permutations : List[List[int]]
p x n list of list of integer. p is the permutation
index and n is the number of sites.
cutoff : float
cutoff used for pooling neighbors.
Grtol : float (default 0.0)
relative tolerance in distance for forming an edge in graph
Gatol : float (default 0.01)
absolute tolerance in distance for forming an edge in graph
rtol : float (default 0.01)
relative tolerance in rmsd in distance for graph matching
atol : float (default 0.0)
absolute tolerance in rmsd in distance for graph matching
tol : float (default 0.01)
maximum tolerance of position RMSD to decide whether two
environment are the same
grtol : float (default 0.01)
tolerance for deciding symmetric nodes
"""
try:
import networkx.algorithms.isomorphism as iso
except:
raise ImportError("This class requires networkx to be installed.")
self.pos = pos
self.sitetypes = sitetypes
self.activesiteidx = [i for i, s in enumerate(self.sitetypes) if 'A' in s]
self.formula: DefaultDict[str, int] = defaultdict(int)
for s in sitetypes:
self.formula[s] += 1
self.permutations = permutations
self.env2config = env2config
self.cutoff = cutoff
# Set up site environment matcher
self.tol = tol
# Graphical option
self.Grtol = Grtol
self.Gatol = Gatol
# tolerance for grouping nodes
self.grtol = grtol
# determine minimum distance between sitetypes.
# This is used to determine the existence of an edge
dists = squareform(pdist(pos))
mindists = defaultdict(list)
for i, row in enumerate(dists):
row_dists = defaultdict(list)
for j in range(0, len(sitetypes)):
if i == j:
continue
# Sort by bond
row_dists[frozenset((sitetypes[i], sitetypes[j]))].append(dists[i, j])
for pair in row_dists:
mindists[pair].append(np.min(row_dists[pair]))
# You want to maximize this in order to make sure every node gets an edge
self.mindists = {}
for pair in mindists:
self.mindists[pair] = np.max(mindists[pair])
# construct graph
self.G = self._construct_graph(pos, sitetypes)
# matcher options
self._nm = iso.categorical_node_match('n', '')
self._em = iso.numerical_edge_match('d', 0, rtol, 0)
def subgraph_isomorphism(graph, sub):
nm = iso.numerical_node_match('label', -1)
em = iso.numerical_edge_match('label', -1)
matcher = iso.DiGraphMatcher(graph, sub, node_match=nm, edge_match=em)
return matcher.subgraph_is_isomorphic()
def graph_isomorphism(graph1, graph2):
nm = iso.numerical_node_match('label', -1)
em = iso.numerical_edge_match('label', -1)
matcher = iso.DiGraphMatcher(graph1, graph2, node_match=nm, edge_match=em)
return matcher.is_isomorphic()
import networkx as nx
from networkx import Graph, MultiGraph
from ase import Atoms, Atom
from ase.constraints import FixConstraint, FixBondLengths
from ase.data import chemical_symbols
import networkx.algorithms.isomorphism as iso
import numpy as np
import copy
import warnings
try:
from builtins import super
except (ImportError):
from __builtin__ import super
sym = np.array(chemical_symbols)
em = iso.numerical_edge_match('bonds', 1)
nm = iso.numerical_node_match('number', 1)
class Gratoms(Atoms):
"""Graph based atoms object.
An Integrated class for an ASE atoms object with a corresponding
Networkx Graph.
"""
def __init__(self,
symbols=None,
positions=None,
numbers=None,
tags=None,
momenta=None,
def _is_isomorphic_graphs(self):
nm = iso.categorical_node_match('label', '')
em = iso.numerical_edge_match('weight', 1)
return nx.is_isomorphic(self.graph1, self.graph2,
node_match=nm, edge_match=em)
def __init__(self,pos,sitetypes,env2config,permutations,cutoff,\
Grtol=0.0,Gatol=0.01,rtol = 0.01,atol=0.0, tol=0.01,grtol=0.01):
""" Initialize site environment
This class contains local site enrivonment information. This is used
to find neighborlist in the datum (see GetMapping).
Parameters
----------
pos : n x 3 list or numpy array of (non-scaled) positions. n is the
number of atom.
sitetypes : n list of string. String must be S or A followed by a
number. S indicates a spectator sites and A indicates a active
sites.
permutations : p x n list of list of integer. p is the permutation
index and n is the number of sites.
cutoff : float. cutoff used for pooling neighbors. for aesthetics only
Grtol : relative tolerance in distance for forming an edge in graph
Gatol : absolute tolerance in distance for forming an edge in graph
rtol : relative tolerance in rmsd in distance for graph matching
atol : absolute tolerance in rmsd in distance for graph matching
tol : maximum tolerance of position RMSD to decide whether two
environment are the same
grtol : tolerance for deciding symmetric nodes
"""
self.pos = pos
self.sitetypes = sitetypes
self.activesiteidx = [
i for i, s in enumerate(self.sitetypes) if 'A' in s
]
self.formula = defaultdict(int)
for s in sitetypes:
self.formula[s] += 1
self.permutations = permutations
self.env2config = env2config
self.cutoff = cutoff
# Set up site environment matcher
self.tol = tol
# Graphical option
self.Grtol = Grtol
self.Gatol = Gatol
#tolerance for grouping nodes
self.grtol = 1e-3
# determine minimum distance between sitetypes.
# This is used to determine the existence of an edge
dists = squareform(pdist(pos))
mindists = defaultdict(list)
for i, row in enumerate(dists):
row_dists = defaultdict(list)
for j in range(0, len(sitetypes)):
if i == j:
continue
# Sort by bond
row_dists[frozenset(
(sitetypes[i], sitetypes[j]))].append(dists[i, j])
for pair in row_dists:
mindists[pair].append(np.min(row_dists[pair]))
# You want to maximize this in order to make sure every node gets an edge
self.mindists = {}
for pair in mindists:
self.mindists[pair] = np.max(mindists[pair])
# construct graph
self.G = self._ConstructGraph(pos, sitetypes)
# matcher options
self._nm = iso.categorical_node_match('n', '')
self._em = iso.numerical_edge_match('d', 0, rtol, 0)
pred_node = dagList[pred_dag_id]
pred_node_name = pred_node[0].name + '_' + str(
pred_dag_id)
if pred_dag_id in group: # if in the group, connect them
G.add_weighted_edges_from([(name, pred_node_name,
new_qarg)])
else: # if not in the group connect it to a dumb_node
G.add_nodes_from([dumb_node], fill='dumb')
G.add_weighted_edges_from([(dumb_node, name,
new_qarg)])
dumb_node = chr(ord(dumb_node) - 1)
index += 1
i += 1
# compare with known structures in table_list
em = iso.numerical_edge_match('weight', 1)
nm = iso.categorical_node_match('fill', 'dumb')
index = 0
found = False
while index < len(dist_table):
H = dist_table[index]
if nx.is_isomorphic(G, H, node_match=nm, edge_match=em):
dist_table_dict[index] = dist_table_dict[index] + 1
found = True
break
index += 1
if not found: # add a new structure
dist_table.append(G)
pos = len(dist_table) - 1
dist_table_dict[pos] = 1
def main():
# create a rosnode
rospy.init_node("agent_test", log_level=rospy.DEBUG)
# create an agent with the intent to control right arm
test_agent = agent.Agent('right') # pylint: disable=C0103
test_agent.subscribe()
# B
# _ BB
# BB
# B Actual Pyramid
"""
green_1x4 = kb.Block(length=4, width=1, color="green")
green_1x4_final_position = Point(x=0.735, y=-0.287, z=0.0)
blue_1x2 = kb.Block(length=2, width=1, color="blue")
blue_1x2_final_position = Point(x=0.738, y=-0.240, z=0.0)
green_1x4_pnp = generate_pick_and_place(
green_1x4, green_1x4_final_position, 0, 0)
blue_1x2_pnp = generate_pick_and_place(
blue_1x2, blue_1x2_final_position, 0, 1)
fake_action_list = green_1x4_pnp + blue_1x2_pnp + [None]
green_1x4_desired = Pose2D(x=0.729, y=-0.273, theta=0.0)
blue_1x2_desired = Pose2D(x=0.723, y=-0.321, theta=math.pi/2)
green_1x4_block = kb.Block(length=4, width=1, color="green",
pose=green_1x4_desired)
blue_1x2_block = kb.Block(
length=2, width=1, color="blue", pose=blue_1x2_desired)
"""
# BBB
# B
# B
# B
# B
# BBB Barbell
green_1x2 = kb.Block(length=2, width=1, color="green")
green_1x2_final_position = Point(x=0.554, y=-0.239, z=0.0)
blue_1x4 = kb.Block(length=4, width=1, color="blue")
blue_1x4_final_position = Point(x=.637, y=-0.242, z=0.0)
red_1x2 = kb.Block(length=2, width=1, color="red")
red_1x2_final_position = Point(x=0.728, y=-0.247, z=0.0)
green_1x2_pnp = generate_pick_and_place(green_1x2,
green_1x2_final_position, 0, 1)
blue_1x4_pnp = generate_pick_and_place(blue_1x4, blue_1x4_final_position,
0, 0)
red_1x2_pnp = generate_pick_and_place(red_1x2, red_1x2_final_position, 0,
1)
fake_action_list = green_1x2_pnp + red_1x2_pnp + blue_1x4_pnp
green_1x2_desired = Pose2D(x=0.807, y=-0.245, theta=math.pi / 2)
blue_1x4_desired = Pose2D(x=0.729, y=-0.241, theta=0)
red_1x2_desired = Pose2D(x=0.653, y=-0.232, theta=math.pi / 2)
green_1x2_block = kb.Block(length=4,
width=1,
color="green",
pose=green_1x2_desired)
blue_1x4_block = kb.Block(length=4,
width=1,
color="blue",
pose=blue_1x4_desired)
red_1x2_block = kb.Block(length=2,
width=1,
color="red",
pose=red_1x2_desired)
expectation = kb.EnvState()
expectation.add_block(green_1x2_block)
expectation.add_block(blue_1x4_block)
expectation.add_block(red_1x2_block)
errortolerancexy = 0.010
errortolerancetheta = 0.087
node_condition1 = iso.categorical_node_match(['length', 'width'], [1, 1])
node_condition2 = iso.numerical_edge_match(['pose_x', 'pose_y'], [0, 0],
rtol=errortolerancexy)
node_condition3 = iso.numerical_edge_match(['pose_theta'], [0],
rtol=errortolerancetheta)
i = 0
none_count = 0
while (True):
action_dict = fake_action_list[i]
if (action_dict is None):
none_count += 1
else:
rospy.loginfo("Executing action: %s", action_dict['desc'])
action = action_dict['action']
constraints = action_dict['constraints']
test_agent.executor(action, constraints)
rospy.sleep(0.1)
i += 1
if (none_count == 1):
rospy.loginfo("Finished block PNP!")
rospy.loginfo("Adding new block to WS EnvState")
if (none_count == 2):
rospy.loginfo("Task complete")
break
expectation.print_graph()
test_agent.get_ws().print_graph()
result1 = nx.is_isomorphic(expectation.ws_state,
test_agent.get_ws().ws_state,
node_match=node_condition1)
result2 = nx.is_isomorphic(expectation.ws_state,
test_agent.get_ws().ws_state,
node_match=node_condition2)
result3 = nx.is_isomorphic(expectation.ws_state,
test_agent.get_ws().ws_state,
node_match=node_condition3)
result = result1 and result2 and result3
print("Result 1: ", result1, " and Result 2: ", result2, " Result 3: ",
result3, " and sum ", result)
