def test_nbors():
box = [[5.493642, 0, 0], [0, 5.493642, 0], [0, 0, 5.493642]]
elements = ["Si", "Si", "Si", "Si", "Si", "Si", "Si", "Si"]
coords = [
[0, 0, 0],
[0.25, 0.25, 0.25],
[0.000000, 0.500000, 0.500000],
[0.250000, 0.750000, 0.750000],
[0.500000, 0.000000, 0.500000],
[0.750000, 0.250000, 0.750000],
[0.500000, 0.500000, 0.000000],
[0.750000, 0.750000, 0.250000],
]
coords = np.array(coords)
# box = [[2.715, 2.715, 0], [0, 2.715, 2.715], [2.715, 0, 2.715]]
# coords = [[0, 0, 0], [0.25, 0.25, 0.25]]
# elements = ["Si", "Si"]
Si = Atoms(lattice_mat=box, coords=coords, elements=elements)
nb = NeighborsAnalysis(Si).get_all_distributions
tmp = round((nb["rdf"][-3]), 2)
assert (tmp) == (4.08)
def from_atoms(
atoms=None,
get_prim=False,
zero_diag=False,
node_atomwise_angle_dist=False,
node_atomwise_rdf=False,
features="basic",
enforce_c_size=10.0,
max_n=100,
max_cut=5.0,
verbose=False,
make_colormap=True,
):
"""
Get Networkx graph. Requires Networkx installation.
Args:
atoms: jarvis.core.Atoms object.
rcut: cut-off after which distance will be set to zero
in the adjacency matrix.
features: Node features.
'atomic_number': graph with atomic numbers only.
'cfid': 438 chemical descriptors from CFID.
'basic':10 features
'atomic_fraction': graph with atomic fractions
in 103 elements.
array: array with CFID chemical descriptor names.
See: jarvis/core/specie.py
enforce_c_size: minimum size of the simulation cell in Angst.
"""
if get_prim:
atoms = atoms.get_primitive_atoms
dim = get_supercell_dims(atoms=atoms, enforce_c_size=enforce_c_size)
atoms = atoms.make_supercell(dim)
adj = np.array(atoms.raw_distance_matrix.copy())
# zero out edges with bond length greater than threshold
adj[adj >= max_cut] = 0
if zero_diag:
np.fill_diagonal(adj, 0.0)
nodes = np.arange(atoms.num_atoms)
if features == "atomic_number":
node_attributes = np.array(
[[np.array(Specie(i).Z)] for i in atoms.elements],
dtype="float",
)
if features == "atomic_fraction":
node_attributes = []
fracs = atoms.composition.atomic_fraction_array
for i in fracs:
node_attributes.append(np.array([float(i)]))
node_attributes = np.array(node_attributes)
elif features == "basic":
feats = [
"Z",
"coulmn",
"row",
"X",
"atom_rad",
"nsvalence",
"npvalence",
"ndvalence",
"nfvalence",
"first_ion_en",
"elec_aff",
]
node_attributes = []
for i in atoms.elements:
tmp = []
for j in feats:
tmp.append(Specie(i).element_property(j))
node_attributes.append(tmp)
node_attributes = np.array(node_attributes, dtype="float")
elif features == "cfid":
node_attributes = np.array(
[np.array(Specie(i).get_descrp_arr) for i in atoms.elements],
dtype="float",
)
elif isinstance(features, list):
node_attributes = []
for i in atoms.elements:
tmp = []
for j in features:
tmp.append(Specie(i).element_property(j))
node_attributes.append(tmp)
node_attributes = np.array(node_attributes, dtype="float")
else:
print("Please check the input options.")
if node_atomwise_rdf or node_atomwise_angle_dist:
nbr = NeighborsAnalysis(atoms,
max_n=max_n,
verbose=verbose,
max_cut=max_cut)
if node_atomwise_rdf:
node_attributes = np.concatenate(
(node_attributes, nbr.atomwise_radial_dist()), axis=1)
node_attributes = np.array(node_attributes, dtype="float")
if node_atomwise_angle_dist:
node_attributes = np.concatenate(
(node_attributes, nbr.atomwise_angle_dist()), axis=1)
node_attributes = np.array(node_attributes, dtype="float")
# construct edge list
uv = []
edge_features = []
for ii, i in enumerate(atoms.elements):
for jj, j in enumerate(atoms.elements):
bondlength = adj[ii, jj]
if bondlength > 0:
uv.append((ii, jj))
edge_features.append(bondlength)
edge_attributes = edge_features
if make_colormap:
sps = atoms.uniq_species
color_dict = random_colors(number_of_colors=len(sps))
new_colors = {}
for i, j in color_dict.items():
new_colors[sps[i]] = j
color_map = []
for ii, i in enumerate(atoms.elements):
color_map.append(new_colors[i])
return Graph(
nodes=nodes,
edges=uv,
node_attributes=np.array(node_attributes),
edge_attributes=np.array(edge_attributes),
color_map=color_map,
)
def get_comp_descp(
self,
jcell=True,
jmean_chem=True,
jmean_chg=True,
jrdf=False,
jrdf_adf=True,
print_names=False,
):
"""
Get chemo-structural CFID decriptors.
Args:
struct: Structure object
jcell: whether to use cell-size descriptors
jmean_chem: whether to use average chemical descriptors
jmean_chg: whether to use average charge distribution descriptors
jmean_rdf: whether to use radial distribution descriptors
jrdf_adf: whether to use radial and angle distribution descriptors
print_names: whether to print names of descriptors
Returns:
cat: catenated final descriptors
"""
cat = []
s = self._atoms
cell = []
mean_chem = []
rdf = []
nn = []
mean_chg = []
adfa = []
adfb = []
ddf = []
if jmean_chem:
el_dict = s.composition._content
# print (el_dict,type(el_dict))
arr = []
for k, v in el_dict.items():
des = Specie(k).get_descrp_arr
arr.append(des)
mean_chem = np.mean(np.array(arr), axis=0)
# print ('mean_chem',len(mean_chem))
if jcell:
v_pa = round(float(s.volume) / float(s.num_atoms), 5)
logv_pa = round(log(v_pa), 5)
pf = s.packing_fraction
density = round(s.density, 5)
cell = np.array([v_pa, logv_pa, pf, density])
# print ('jcell',len(cell))
if jrdf:
Nbrs = NeighborsAnalysis(s)
_, distrdf, nn = Nbrs.get_rdf()
rdf = np.array(distrdf)
print("rdf", len(rdf))
if jrdf_adf:
try:
adfa = np.zeros(179)
adfb = np.zeros(179)
ddf = np.zeros(179)
rdf = np.zeros(100)
nn = np.zeros(100)
distributions = NeighborsAnalysis(s).get_all_distributions
rdf = distributions["rdf"]
nn = distributions["nn"]
adfa = distributions["adfa"]
adfb = distributions["adfb"]
ddf = distributions["ddf"]
except Exception:
pass
adfa = np.array(adfa)
adfb = np.array(adfb)
rdf = np.array(rdf)
ddf = np.array(ddf)
nn = np.array(nn)
# print ('adfa',len(adfa))
# print ('ddf',len(ddf))
# print ('adfb',len(adfb))
# print ('rdf',len(rdf))
# print ('nn',len(nn))
if jmean_chg:
chgarr = []
el_dict = s.composition._content
for k, v in el_dict.items():
chg = Specie(k).get_chgdescrp_arr
chgarr.append(chg)
mean_chg = np.mean(chgarr, axis=0)
# print ('mean_chg',len(mean_chg))
if print_names:
nmes = []
chem_nm = get_descrp_arr_name()
for d, nm in zip(
[mean_chem, cell, mean_chg, rdf,
adfa, adfb, ddf, nn],
["mean_chem", "cell", "mean_chg",
"rdf", "adfa", "adfb", "ddf", "nn"],
):
if len(d) != 0:
for ff, dd in enumerate(d):
cat.append(dd)
if nm == "mean_chem":
tag = chem_nm[ff]
else:
tag = str(nm) + str("_") + str(ff)
nmes.append(str(tag))
cat = np.array(cat).astype(float)
# print (nmes,len(nmes))
return nmes
else:
for d, nm in zip(
[mean_chem, cell, mean_chg, rdf,
adfa, adfb, ddf, nn],
["mean_chem", "cell", "mean_chg",
"rdf", "adfa", "adfb", "ddf", "nn"],
):
if len(d) != 0:
# if d != []:
for ff, dd in enumerate(d):
cat.append(dd)
cat = np.array(cat).astype(float)
return cat
def test_nbors():
box = [[5.493642, 0, 0], [0, 5.493642, 0], [0, 0, 5.493642]]
elements = ["Si", "Si", "Si", "Si", "Si", "Si", "Si", "Si"]
coords = [
[0, 0, 0],
[0.25, 0.25, 0.25],
[0.000000, 0.500000, 0.500000],
[0.250000, 0.750000, 0.750000],
[0.500000, 0.000000, 0.500000],
[0.750000, 0.250000, 0.750000],
[0.500000, 0.500000, 0.000000],
[0.750000, 0.750000, 0.250000],
]
coords = np.array(coords)
# box = [[2.715, 2.715, 0], [0, 2.715, 2.715], [2.715, 0, 2.715]]
# coords = [[0, 0, 0], [0.25, 0.25, 0.25]]
# elements = ["Si", "Si"]
Si = Atoms(lattice_mat=box, coords=coords, elements=elements)
nbr = NeighborsAnalysis(Si)
nb = nbr.get_all_distributions
tmp = round((nb["rdf"][-3]), 2)
assert (tmp) == (4.08)
nbr.get_rdf(plot=True)
# nbr.ang_dist(nbor_info=info,plot=True)
nbr.ang_dist_first(plot=True)
nbr.ang_dist_second(plot=True)
nbr.get_ddf(plot=True)
angs = nbr.atomwise_angle_dist()
ardf = nbr.atomwise_radial_dist()
cmd = "rm *.png"
os.system(cmd)