def compute_simultaneous_packing_efficiency(self, comp):
"""Compute the packing efficiency of the system when the neighbor
shell of each atom has the same composition as the alloy. When this
criterion is satisfied, it is possible for every atom in this system
to be simultaneously as efficiently-packed as possible.
Args:
comp (Composition): Composition to be assessed
Returns
(float) Average APE of all atoms
(float) Average deviation of the APE of each atom from ideal (0)
"""
# Compute the average atomic radius of the system
elements, fractions = zip(*comp.element_composition.items())
radii = self._data_source.get_elemental_properties(elements,
'MiracleRadius')
mean_radius = PropertyStats.mean(radii, fractions)
# Compute the APE for each cluster
best_ape = [
self.find_ideal_cluster_size(r / mean_radius)[1] for r in radii
]
# Return the averages
return PropertyStats.mean(best_ape, fractions), PropertyStats.mean(np.abs(best_ape), fractions)
def compute_delta(self, comp):
"""Compute Yang's delta parameter
:math:`\sqrt{\sum^n_{i=1} c_i \left( 1 - \\frac{r_i}{\\bar{r}} \\right)^2 }`
where :math:`c_i` and :math:`r_i` are the fraction and radius of
element :math:`i`, and :math:`\\bar{r}` is the fraction-weighted
average of the radii. We use the radii compiled by
.. Miracle et al. `https://www.tandfonline.com/doi/ref/10.1179/095066010X12646898728200?scroll=top`.
Args:
comp (Composition) - Composition to assess
Returns:
(float) delta
"""
elements, fractions = zip(*comp.element_composition.items())
# Get the radii of elements
radii = self.elem_data.get_elemental_properties(
elements, "MiracleRadius")
mean_r = PropertyStats.mean(radii, fractions)
# Compute the mean (1 - r/\\bar{r})^2
r_dev = np.power(1.0 - np.divide(radii, mean_r), 2)
return np.sqrt(PropertyStats.mean(r_dev, fractions))
def test_geom_std_dev(self):
# This is right. Yes, a list without variation has a geom_std_dev of 1
self.assertAlmostEqual(1, PropertyStats.geom_std_dev([1, 1, 1]))
# Harder case
self.assertAlmostEqual(1.166860716,
PropertyStats.geom_std_dev([0.5, 1.5, 1]))
self.assertAlmostEqual(
1.352205875,
PropertyStats.geom_std_dev([0.5, 1.5, 1], weights=[2, 1, 0]))
def test_geom_std_dev(self):
# This is right. Yes, a list without variation has a geom_std_dev of 1
self.assertAlmostEqual(1, PropertyStats.geom_std_dev([1, 1, 1]))
# Harder case
self.assertAlmostEqual(1.166860716,
PropertyStats.geom_std_dev([0.5, 1.5, 1]))
self.assertAlmostEqual(1.352205875,
PropertyStats.geom_std_dev([0.5, 1.5, 1],
weights=[2, 1, 0]))
def featurize(self, n_w):
"""
Get Voronoi fingerprints of site with given index in input structure.
Args:
struct (Structure): Pymatgen Structure object.
idx (int): index of target site in structure.
Returns:
(list of floats): Voronoi fingerprints.
-Voronoi indices
-i-fold symmetry indices
-weighted i-fold symmetry indices (if use_symm_weights = True)
-Voronoi volume
-Voronoi volume statistics
-Voronoi area
-Voronoi area statistics
-Voronoi dist statistics
"""
# Prepare storage for the Voronoi indices
voro_idx_list = np.zeros(8, int)
voro_idx_weights = np.zeros(8)
vol_list = []
area_list = []
dist_list = []
# Get statistics
for nn in n_w:
if nn['poly_info']['n_verts'] <= 10:
# If a facet has more than 10 edges, it's skipped here.
voro_idx_list[nn['poly_info']['n_verts'] - 3] += 1
vol_list.append(nn['poly_info']['volume'])
area_list.append(nn['poly_info']['area'])
dist_list.append(nn['poly_info']['face_dist'] * 2)
if self.use_symm_weights:
voro_idx_weights[nn['poly_info']['n_verts'] - 3] += \
nn['poly_info'][self.symm_weights]
symm_idx_list = voro_idx_list / sum(voro_idx_list)
if self.use_symm_weights:
symm_wt_list = voro_idx_weights / sum(voro_idx_weights)
voro_fps = list(np.concatenate((voro_idx_list, symm_idx_list,
symm_wt_list), axis=0))
else:
voro_fps = list(np.concatenate((voro_idx_list,
symm_idx_list), axis=0))
voro_fps.append(sum(vol_list))
voro_fps.append(sum(area_list))
voro_fps += [PropertyStats().calc_stat(vol_list, stat_vol)
for stat_vol in self.stats_vol]
voro_fps += [PropertyStats().calc_stat(area_list, stat_area)
for stat_area in self.stats_area]
voro_fps += [PropertyStats().calc_stat(dist_list, stat_dist)
for stat_dist in self.stats_dist]
return voro_fps
def test_holder_mean(self):
self._run_test("holder_mean::0", 1, 1, np.product(self.sample_2), 0)
self._run_test("holder_mean::1", 1, 1, 2. / 3, 5. / 7)
self._run_test("holder_mean::2", 1, 1, sqrt(5. / 6), 0.88640526)
# can't use run_test since it uses a sample with zero, which is not
# allowed for Holder mean with -1
self.assertAlmostEqual(PropertyStats.holder_mean(
[1, 1, 2], power=-1), 1.2, places=3)
self.assertAlmostEqual(PropertyStats.holder_mean(
[1, 2], [2, 1], power=-1), 1.2, places=3)
def featurize(self, struct, idx):
"""
Get interstice distribution fingerprints of site with given index in
input structure.
Args:
struct (Structure): Pymatgen Structure object.
idx (int): index of target site in structure.
Returns:
interstice_fps ([float]): Interstice distribution fingerprints.
"""
interstice_fps = list()
# Get the nearest neighbors using Voronoi tessellation
n_w = VoronoiNN(cutoff=self.cutoff).get_voronoi_polyhedra(
struct, idx).values()
nn_coords = np.array([nn['site'].coords for nn in n_w])
# Get center atom's radius and its nearest neighbors' radii
center_r = MagpieData().get_elemental_properties(
[struct[idx].specie], self.radius_type)[0] / 100
nn_els = [nn['site'].specie for nn in n_w]
nn_rs = np.array(MagpieData().get_elemental_properties(
nn_els, self.radius_type)) / 100
# Get indices of atoms forming the simplices of convex hull
convex_hull_simplices = ConvexHull(nn_coords).simplices
if 'dist' in self.interstice_types:
nn_dists = [nn['face_dist'] * 2 for nn in n_w]
interstice_dist_list = IntersticeDistribution.\
analyze_dist_interstices(center_r, nn_rs, nn_dists)
interstice_fps += [PropertyStats().calc_stat(
interstice_dist_list, stat) for stat in self.stats]
if 'area' in self.interstice_types:
interstice_area_list = IntersticeDistribution.\
analyze_area_interstice(nn_coords, nn_rs, convex_hull_simplices)
interstice_fps += [PropertyStats().calc_stat(
interstice_area_list, stat) for stat in self.stats]
if 'vol' in self.interstice_types:
interstice_vol_list = IntersticeDistribution.\
analyze_vol_interstice(struct[idx].coords, nn_coords,
center_r, nn_rs, convex_hull_simplices)
interstice_fps += [PropertyStats().calc_stat(
interstice_vol_list, stat) for stat in self.stats]
return interstice_fps
def featurize(self, s):
# Get each feature for each site
vals = [[] for t in self._site_labels]
for i, site in enumerate(s.sites):
if (self.min_oxi is None or site.specie.oxi_state >= self.min_oxi) \
and (
self.max_oxi is None or site.specie.oxi_state >= self.max_oxi):
opvalstmp = self.site_featurizer.featurize(s, i)
for j, opval in enumerate(opvalstmp):
if opval is None:
vals[j].append(0.0)
else:
vals[j].append(opval)
# If the user does not request statistics, return the site features now
if self.stats is None:
return vals
# Compute the requested statistics
stats = []
for op in vals:
for stat in self.stats:
stats.append(PropertyStats().calc_stat(op, stat))
# If desired, compute covariances
if self.covariance:
if len(s) == 1:
stats.extend([0] * int(len(vals) * (len(vals) - 1) / 2))
else:
covar = np.cov(vals)
tri_ind = np.triu_indices(len(vals), 1)
stats.extend(covar[tri_ind].tolist())
return stats
def test_holder_mean(self):
self._run_test("holder_mean::0", 1, 1, np.product(self.sample_2), 0)
self._run_test("holder_mean::1", 1, 1, 2. / 3, 5. / 7)
self._run_test("holder_mean::2", 1, 1, sqrt(5. / 6), 0.88640526)
# can't use run_test since it uses a sample with zero, which is not
# allowed for Holder mean with -1
self.assertAlmostEqual(PropertyStats.holder_mean([1, 1, 2], power=-1),
1.2,
places=3)
self.assertAlmostEqual(PropertyStats.holder_mean([1, 2], [2, 1],
power=-1),
1.2,
places=3)
def __init__(self):
self.data_source = MagpieData()
#The labels for statistics on element properties
self._element_property_feature_labels = [
"mean AtomicWeight",
"mean Column",
"mean Row",
"range Number",
"mean Number",
"range AtomicRadius",
"mean AtomicRadius",
"range Electronegativity",
"mean Electronegativity"
]
# Initialize stats computer
self.pstats = PropertyStats()
def __init__(self, data_source, features, stats):
if data_source == "pymatgen":
self.data_source = PymatgenData()
elif data_source == "magpie":
self.data_source = MagpieData()
elif data_source == "deml":
self.data_source = DemlData()
elif data_source == "matscholar_el":
self.data_source = MatscholarElementData()
elif data_source == "megnet_el":
self.data_source = MEGNetElementData()
else:
self.data_source = data_source
self.features = features
self.stats = stats
# Initialize stats computer
self.pstats = PropertyStats()
def featurize(self, comp):
# Check if oxidation states are present
if not has_oxidation_states(comp):
raise ValueError('Oxidation states have not been determined')
# Get the oxidation states and their proportions
oxid_states, fractions = zip(*[(s.oxi_state, f) for s, f in comp.items()])
# Compute statistics
return [PropertyStats.calc_stat(oxid_states, s, fractions) for s in self.stats]
def featurize(self, strc):
# Compute the Voronoi tessellation of each site
voro = VoronoiNN(extra_nn_info=True, weight=self.weight)
nns = get_all_nearest_neighbors(voro, strc)
# Compute the mean bond length of each atom, and the mean
# variation within each cell
mean_bond_lengths = np.zeros((len(strc), ))
bond_length_var = np.zeros_like(mean_bond_lengths)
for i, nn in enumerate(nns):
weights = [n['weight'] for n in nn]
lengths = [n['poly_info']['face_dist'] * 2 for n in nn]
mean_bond_lengths[i] = PropertyStats.mean(lengths, weights)
# Compute the mean absolute deviation of the bond lengths
bond_length_var[i] = PropertyStats.avg_dev(lengths, weights) / \
mean_bond_lengths[i]
# Normalize the bond lengths by the average of the whole structure
# This is done to make the attributes length-scale-invariant
mean_bond_lengths /= mean_bond_lengths.mean()
# Compute statistics related to bond lengths
features = [
PropertyStats.avg_dev(mean_bond_lengths),
mean_bond_lengths.max(),
mean_bond_lengths.min()
]
features += [
PropertyStats.calc_stat(bond_length_var, stat)
for stat in self.stats
]
# Compute the variance in volume
cell_volumes = [
sum(x['poly_info']['volume'] for x in nn) for nn in nns
]
features.append(
PropertyStats.avg_dev(cell_volumes) / np.mean(cell_volumes))
return features
def featurize(self, comp):
"""
Args:
comp: Pymatgen Composition object
Returns:
en_diff_stats (list of floats): Property stats of electronegativity difference
"""
# Check if oxidation states have been determined
if not has_oxidation_states(comp):
raise ValueError('Oxidation states have not yet been determined')
if not is_ionic(comp):
raise ValueError('Composition is not ionic')
# Determine the average anion EN
anions, anion_fractions = zip(*[(s, x) for s, x in comp.items() if s.oxi_state < 0])
# If there are no anions, raise an Exception
if len(anions) == 0:
raise Exception('Features not applicable: Compound contains no anions')
anion_en = [s.element.X for s in anions]
mean_anion_en = PropertyStats.mean(anion_en, anion_fractions)
# Determine the EN difference for each cation
cations, cation_fractions = zip(*[(s, x) for s, x in comp.items() if s.oxi_state > 0])
# If there are no cations, raise an Exception
# It is possible to construct a non-charge-balanced Composition,
# so we have to check for both the presence of anions and cations
if len(cations) == 0:
raise Exception('Features not applicable: Compound contains no cations')
en_difference = [mean_anion_en - s.element.X for s in cations]
# Compute the statistics
return [
PropertyStats.calc_stat(en_difference, stat, cation_fractions) for stat in self.stats
]
def _run_test(self, statistic, sample_1, sample_1_weighted, sample_2,
sample_2_weighted):
""" Run a test for a certain statistic against the two sample datasets
Args:
statistic: name of statistic
sample_1: float, expected value for statistic of sample 1 without weights
sample_1_weighted: float, expected value for statistic of sample 1 with weights
sample_2: float, expected value for statistic of sample 2 without weights
sample_2_weighted: float, expected value for statistic of sample 2 with weights
"""
self.assertAlmostEqual(sample_1, PropertyStats.calc_stat(self.sample_1,
statistic))
self.assertAlmostEqual(sample_1_weighted,
PropertyStats.calc_stat(self.sample_1, statistic,
self.sample_1_weights))
self.assertAlmostEqual(sample_2, PropertyStats.calc_stat(self.sample_2,
statistic))
self.assertAlmostEqual(sample_2_weighted,
PropertyStats.calc_stat(self.sample_2, statistic,
self.sample_2_weights))
def _run_test(self, statistic, sample_1, sample_1_weighted, sample_2,
sample_2_weighted):
""" Run a test for a certain statistic against the two sample datasets
:param statistic: name of statistic
:param sample_1: float, expected value for statistic of sample 1 without weights
:param sample_1_weighted: float, expected value for statistic of sample 1 with weights
:param sample_2: float, expected value for statistic of sample 2 without weights
:param sample_2_weighted: float, expected value for statistic of sample 2 with weights
"""
self.assertAlmostEqual(
sample_1, PropertyStats.calc_stat(self.sample_1, statistic))
self.assertAlmostEqual(
sample_1_weighted,
PropertyStats.calc_stat(self.sample_1, statistic,
self.sample_1_weights))
self.assertAlmostEqual(
sample_2, PropertyStats.calc_stat(self.sample_2, statistic))
self.assertAlmostEqual(
sample_2_weighted,
PropertyStats.calc_stat(self.sample_2, statistic,
self.sample_2_weights))
def featurize(self, comp):
# Check if oxidation states are present
if not has_oxidation_states(comp):
raise ValueError('Oxidation states have not been determined')
if not is_ionic(comp):
raise ValueError('Composition is not ionic')
# Prepare to store the attributes
all_attributes = []
# Initialize stats computer
pstats = PropertyStats()
# Get the cation species and fractions
cations, fractions = zip(*[(s, f) for s, f in comp.items() if s.oxi_state > 0])
for attr in self.features:
elem_data = [self.data_source.get_charge_dependent_property_from_specie(c, attr)
for c in cations]
for stat in self.stats:
all_attributes.append(pstats.calc_stat(elem_data, stat, fractions))
return all_attributes
def compute_omega(self, comp):
"""Compute Yang's mixing thermodynamics descriptor
:math:`\\frac{T_m \Delta S_{mix}}{ | \Delta H_{mix} | }`
Where :math:`T_m` is average melting temperature,
:math:`\Delta S_{mix}` is the ideal mixing entropy,
and :math:`\Delta H_{mix}` is the average mixing enthalpies
of all pairs of elements in the alloy
Args:
comp (Composition) - Composition to featurizer
Returns:
(float) Omega
"""
# Special case: Elemental compound (entropy == 0 -> Omega == 1)
if len(comp) == 1:
return 0
# Get the element names and fractions
elements, fractions = zip(
*comp.element_composition.fractional_composition.items())
# Get the mean melting temperature
mean_Tm = PropertyStats.mean(
self.elem_data.get_elemental_properties(elements, "MeltingT"),
fractions)
# Get the mixing entropy
entropy = np.dot(fractions, np.log(fractions)) * 8.314 / 1000
# Get the mixing enthalpy
enthalpy = 0
for i, (e1, f1) in enumerate(zip(elements, fractions)):
for e2, f2 in zip(elements[:i], fractions):
enthalpy += f1 * f2 * self.dhf_mix.get_mixing_enthalpy(e1, e2)
enthalpy *= 4
# Make sure the enthalpy is nonzero
# The limit as dH->0 of omega is +\inf. A very small positive dH will approximate
# this limit without causing issues with infinite features
enthalpy = max(1e-6, abs(enthalpy))
return abs(mean_Tm * entropy / enthalpy)
class ElementProperty(BaseFeaturizer):
"""
Class to calculate elemental property attributes.
To initialize quickly, use the from_preset() method.
Features: Based on the statistics of the data_source chosen, computed
by element stoichiometry. The format generally is:
"{data source} {statistic} {property}"
For example:
"PymetgenData range X" # Range of electronegativity from Pymatgen data
For a list of all statistics, see the PropertyStats documentation; for a
list of all attributes available for a given data_source, see the
documentation for the data sources (e.g., PymatgenData, MagpieData,
MatscholarElementData, etc.).
Args:
data_source (AbstractData or str): source from which to retrieve
element property data (or use str for preset: "pymatgen",
"magpie", or "deml")
features (list of strings): List of elemental properties to use
(these must be supported by data_source)
stats (list of strings): a list of weighted statistics to compute to for each
property (see PropertyStats for available stats)
"""
def __init__(self, data_source, features, stats):
if data_source == "pymatgen":
self.data_source = PymatgenData()
elif data_source == "magpie":
self.data_source = MagpieData()
elif data_source == "deml":
self.data_source = DemlData()
elif data_source == "matscholar_el":
self.data_source = MatscholarElementData()
elif data_source == "megnet_el":
self.data_source = MEGNetElementData()
else:
self.data_source = data_source
self.features = features
self.stats = stats
# Initialize stats computer
self.pstats = PropertyStats()
@classmethod
def from_preset(cls, preset_name):
"""
Return ElementProperty from a preset string
Args:
preset_name: (str) can be one of "magpie", "deml", "matminer",
"matscholar_el", or "megnet_el".
Returns:
ElementProperty based on the preset name.
"""
if preset_name == "magpie":
data_source = "magpie"
features = [
"Number", "MendeleevNumber", "AtomicWeight", "MeltingT",
"Column", "Row", "CovalentRadius", "Electronegativity",
"NsValence", "NpValence", "NdValence", "NfValence", "NValence",
"NsUnfilled", "NpUnfilled", "NdUnfilled", "NfUnfilled",
"NUnfilled", "GSvolume_pa", "GSbandgap", "GSmagmom",
"SpaceGroupNumber"
]
stats = ["minimum", "maximum", "range", "mean", "avg_dev", "mode"]
elif preset_name == "deml":
data_source = "deml"
stats = ["minimum", "maximum", "range", "mean", "std_dev"]
features = [
"atom_num", "atom_mass", "row_num", "col_num", "atom_radius",
"molar_vol", "heat_fusion", "melting_point", "boiling_point",
"heat_cap", "first_ioniz", "electronegativity", "electric_pol",
"GGAU_Etot", "mus_fere", "FERE correction"
]
elif preset_name == "matminer":
data_source = "pymatgen"
stats = ["minimum", "maximum", "range", "mean", "std_dev"]
features = [
"X", "row", "group", "block", "atomic_mass", "atomic_radius",
"mendeleev_no", "electrical_resistivity", "velocity_of_sound",
"thermal_conductivity", "melting_point", "bulk_modulus",
"coefficient_of_linear_thermal_expansion"
]
elif preset_name == "matscholar_el":
data_source = "matscholar_el"
stats = ["minimum", "maximum", "range", "mean", "std_dev"]
features = MatscholarElementData().prop_names
elif preset_name == "megnet_el":
data_source = "megnet_el"
stats = ["minimum", "maximum", "range", "mean", "std_dev"]
features = MEGNetElementData().prop_names
else:
raise ValueError("Invalid preset_name specified!")
return cls(data_source, features, stats)
def featurize(self, comp):
"""
Get elemental property attributes
Args:
comp: Pymatgen composition object
Returns:
all_attributes: Specified property statistics of features
"""
all_attributes = []
# Get the element names and fractions
elements, fractions = zip(*comp.element_composition.items())
for attr in self.features:
elem_data = [
self.data_source.get_elemental_property(e, attr)
for e in elements
]
for stat in self.stats:
all_attributes.append(
self.pstats.calc_stat(elem_data, stat, fractions))
return all_attributes
def feature_labels(self):
labels = []
for attr in self.features:
src = self.data_source.__class__.__name__
for stat in self.stats:
labels.append(f"{src} {stat} {attr}")
return labels
def citations(self):
if self.data_source.__class__.__name__ == "MagpieData":
citation = [
"@article{ward_agrawal_choudary_wolverton_2016, title={A general-purpose "
"machine learning framework for predicting properties of inorganic materials}, "
"volume={2}, DOI={10.1038/npjcompumats.2017.28}, number={1}, journal={npj "
"Computational Materials}, author={Ward, Logan and Agrawal, Ankit and Choudhary, "
"Alok and Wolverton, Christopher}, year={2016}}"
]
elif self.data_source.__class__.__name__ == "DemlData":
citation = [
"@article{deml_ohayre_wolverton_stevanovic_2016, title={Predicting density "
"functional theory total energies and enthalpies of formation of metal-nonmetal "
"compounds by linear regression}, volume={47}, DOI={10.1002/chin.201644254}, "
"number={44}, journal={ChemInform}, author={Deml, Ann M. and Ohayre, Ryan and "
"Wolverton, Chris and Stevanovic, Vladan}, year={2016}}"
]
elif self.data_source.__class__.__name__ == "PymatgenData":
citation = [
"@article{Ong2013, author = {Ong, Shyue Ping and Richards, William Davidson and Jain, Anubhav and Hautier, "
"Geoffroy and Kocher, Michael and Cholia, Shreyas and Gunter, Dan and Chevrier, Vincent L. and Persson, "
"Kristin A. and Ceder, Gerbrand}, doi = {10.1016/j.commatsci.2012.10.028}, issn = {09270256}, "
"journal = {Computational Materials Science}, month = {feb}, pages = {314--319}, "
"publisher = {Elsevier B.V.}, title = {{Python Materials Genomics (pymatgen): A robust, open-source python "
"library for materials analysis}}, url = {http://linkinghub.elsevier.com/retrieve/pii/S0927025612006295}, "
"volume = {68}, year = {2013} } "
]
elif self.data_source.__class__.__name__ == "MEGNetElementData":
# TODO: Cite MEGNet publication (not preprint) once released!
citation = [
"@ARTICLE{2018arXiv181205055C,"
"author = {{Chen}, Chi and {Ye}, Weike and {Zuo}, Yunxing and {Zheng}, Chen and {Ong}, Shyue Ping},"
"title = '{Graph Networks as a Universal Machine Learning Framework for Molecules and Crystals}',"
"journal = {arXiv e-prints},"
"keywords = {Condensed Matter - Materials Science, Physics - Computational Physics},"
"year = '2018',"
"month = 'Dec',"
"eid = {arXiv:1812.05055},"
"pages = {arXiv:1812.05055},"
"archivePrefix = {arXiv},"
"eprint = {1812.05055},"
"primaryClass = {cond-mat.mtrl-sci},"
"adsurl = {https://ui.adsabs.harvard.edu/\#abs/2018arXiv181205055C},"
"adsnote = {Provided by the SAO/NASA Astrophysics Data System}}"
]
else:
citation = []
return citation
def implementors(self):
return ["Jiming Chen", "Logan Ward", "Anubhav Jain", "Alex Dunn"]
def test_mode(self):
self._run_test("mode", 1, 1, 0, 0.5)
# Additional tests
self.assertAlmostEqual(0, PropertyStats.mode([0, 1, 2], [1, 1, 1]))
def test_mode(self):
self._run_test("mode", 1, 1, 0, 0.5)
# Additional tests
self.assertAlmostEqual(0, PropertyStats.mode([0, 1, 2], [1, 1, 1]))
class Meredig(BaseFeaturizer):
"""
Class to calculate features as defined in Meredig et. al.
Features:
Atomic fraction of each of the first 103 elements, in order of atomic number.
17 statistics of elemental properties;
Mean atomic weight of constituent elements
Mean periodic table row and column number
Mean and range of atomic number
Mean and range of atomic radius
Mean and range of electronegativity
Mean number of valence electrons in each orbital
Fraction of total valence electrons in each orbital
"""
def __init__(self):
self.data_source = MagpieData()
#The labels for statistics on element properties
self._element_property_feature_labels = [
"mean AtomicWeight",
"mean Column",
"mean Row",
"range Number",
"mean Number",
"range AtomicRadius",
"mean AtomicRadius",
"range Electronegativity",
"mean Electronegativity"
]
# Initialize stats computer
self.pstats = PropertyStats()
def featurize(self, comp):
"""
Get elemental property attributes
Args:
comp: Pymatgen composition object
Returns:
all_attributes: Specified property statistics of features
"""
# First 103 features are element fractions, we can get these from the ElementFraction featurizer
element_fraction_features = ElementFraction().featurize(comp)
# Next 9 features are statistics on elemental properties
elements, fractions = zip(*comp.element_composition.items())
element_property_features = [0] * len(self._element_property_feature_labels)
for i,feat in enumerate(self._element_property_feature_labels):
stat = feat.split(" ")[0]
attr = " ".join(feat.split(" ")[1:])
elem_data = [self.data_source.get_elemental_property(e, attr) for e in elements]
element_property_features[i] = self.pstats.calc_stat(elem_data, stat, fractions)
# Final 8 features are statistics on valence orbitals, available from the ValenceOrbital featurizer
valence_orbital_features = ValenceOrbital(orbitals=("s", "p", "d", "f"), props=("avg", "frac")).featurize(comp)
return element_fraction_features+element_property_features+valence_orbital_features
def feature_labels(self):
# Since we have more features than just element fractions, append 'fraction' to element symbols for clarity
element_fraction_features = [e + " fraction" for e in ElementFraction().feature_labels()]
valence_orbital_features = ValenceOrbital().feature_labels()
return element_fraction_features+self._element_property_feature_labels+valence_orbital_features
def citations(self):
citation = [
"@article{meredig_agrawal_kirklin_saal_doak_thompson_zhang_choudhary_wolverton_2014, title={Combinatorial "
"screening for new materials in unconstrained composition space with machine learning}, "
"volume={89}, DOI={10.1103/PhysRevB.89.094104}, number={1}, journal={Physical "
"Review B}, author={B. Meredig, A. Agrawal, S. Kirklin, J. E. Saal, J. W. Doak, A. Thompson, "
"K. Zhang, A. Choudhary, and C. Wolverton}, year={2014}}"]
return citation
def implementors(self):
return ["Amalie Trewartha"]