def test_mini_lambda_table(self): sp = SubstitutionProbability(lambda_table=get_table(), alpha= -5.) o2 = Specie('O', -2) s2 = Specie('S', -2) li1 = Specie('Li', 1) na1 = Specie('Na', 1) self.assertAlmostEqual(sp.prob(s2, o2), 0.124342317272, 5 , "probability isn't correct") self.assertAlmostEqual(sp.pair_corr(li1, na1), 1.65425296864, 5 , "correlation isn't correct") prob = sp.cond_prob_list([o2, li1], [na1, li1]) self.assertAlmostEqual(prob, 0.00102673915742, 5 , "probability isn't correct")
def test_full_lambda_table(self): """ This test tests specific values in the data folder. If the json is updated, these tests will have to be as well """ sp = SubstitutionProbability(alpha= -5.) sp1 = Specie('Fe', 4) sp3 = Specie('Mn', 3) prob1 = sp.prob(sp1, sp3) self.assertAlmostEqual(prob1, 1.69243954552e-05, 5 , "probability isn't correct") sp2 = Specie('Pt', 4) sp4 = Specie('Pd', 4) prob2 = sp.prob(sp2, sp4) self.assertAlmostEqual(prob2, 4.7174906021e-05, 5 , "probability isn't correct") corr = sp.pair_corr(Specie("Cu", 2), Specie("Fe", 2)) self.assertAlmostEqual(corr, 6.82496631637, 5 , "probability isn't correct") prob3 = sp.cond_prob_list([sp1, sp2], [sp3, sp4]) self.assertAlmostEqual(prob3, 0.000300298841302, 6 , "probability isn't correct")
class Substitutor(MSONable): """ This object uses a data mined ionic substitution approach to propose compounds likely to be stable. It relies on an algorithm presented in Hautier, G., Fischer, C., Ehrlacher, V., Jain, A., and Ceder, G. (2011). Data Mined Ionic Substitutions for the Discovery of New Compounds. Inorganic Chemistry, 50(2), 656-663. doi:10.1021/ic102031h """ def __init__(self, threshold=1e-3, symprec=0.1, **kwargs): """ This substitutor uses the substitution probability class to find good substitutions for a given chemistry or structure. Args: threshold: probability threshold for predictions symprec: symmetry precision to determine if two structures are duplicates kwargs: kwargs for the SubstitutionProbability object lambda_table, alpha """ self._kwargs = kwargs self._sp = SubstitutionProbability(**kwargs) self._threshold = threshold self._symprec = symprec def get_allowed_species(self): """ returns the species in the domain of the probability function any other specie will not work """ return self._sp.species def pred_from_structures(self, target_species, structures_list, remove_duplicates=True): """ performs a structure prediction targeting compounds containing the target_species and based on a list of structure (those structures can for instance come from a database like the ICSD). It will return all the structures formed by ionic substitutions with a probability higher than the threshold Args: target_species: a list of species with oxidation states e.g., [Specie('Li',1),Specie('Ni',2), Specie('O',-2)] structures_list: a list of dictionnary of the form {'structure':Structure object ,'id':some id where it comes from} the id can for instance refer to an ICSD id Returns: a list of TransformedStructure objects. """ result = [] transmuter = StandardTransmuter([]) if len(list(set(target_species) & set(self.get_allowed_species()))) \ != len(target_species): raise ValueError("the species in target_species are not allowed" + "for the probability model you are using") for permut in itertools.permutations(target_species): for s in structures_list: #check if: species are in the domain, #and the probability of subst. is above the threshold els = s['structure'].composition.elements if len(els) == len(permut) and \ len(list(set(els) & set(self.get_allowed_species()))) == \ len(els) and self._sp.cond_prob_list(permut, els) > \ self._threshold: clean_subst = {els[i]: permut[i] for i in xrange(0, len(els)) if els[i] != permut[i]} if len(clean_subst) == 0: continue transf = SubstitutionTransformation(clean_subst) if Substitutor._is_charge_balanced( transf.apply_transformation(s['structure'])): ts = TransformedStructure( s['structure'], [transf], history=[s['id']], other_parameters={ 'type': 'structure_prediction', 'proba': self._sp.cond_prob_list(permut, els)} ) result.append(ts) transmuter.append_transformed_structures([ts]) if remove_duplicates: transmuter.apply_filter(RemoveDuplicatesFilter( symprec=self._symprec)) return transmuter.transformed_structures @staticmethod def _is_charge_balanced(struct): """ checks if the structure object is charge balanced """ if sum([s.specie. oxi_state for s in struct.sites]) == 0.0: return True else: return False def pred_from_list(self, species_list): """ There are an exceptionally large number of substitutions to look at (260^n), where n is the number of species in the list. We need a more efficient than brute force way of going through these possibilities. The brute force method would be:: output = [] for p in itertools.product(self._sp.species_list , repeat = len(species_list)): if self._sp.conditional_probability_list(p, species_list) > self._threshold: output.append(dict(zip(species_list,p))) return output Instead of that we do a branch and bound. Args: species_list: list of species in the starting structure Returns: list of dictionaries, each including a substitutions dictionary, and a probability value """ #calculate the highest probabilities to help us stop the recursion max_probabilities = [] for s2 in species_list: max_p = 0 for s1 in self._sp.species: max_p = max([self._sp.cond_prob(s1, s2), max_p]) max_probabilities.append(max_p) output = [] def _recurse(output_prob, output_species): best_case_prob = list(max_probabilities) best_case_prob[:len(output_prob)] = output_prob if reduce(mul, best_case_prob) > self._threshold: if len(output_species) == len(species_list): odict = { 'substitutions': dict(zip(species_list, output_species)), 'probability': reduce(mul, best_case_prob)} output.append(odict) return for sp in self._sp.species: i = len(output_prob) prob = self._sp.cond_prob(sp, species_list[i]) _recurse(output_prob + [prob], output_species + [sp]) _recurse([], []) logging.info('{} substitutions found'.format(len(output))) return output def pred_from_comp(self, composition): """ Similar to pred_from_list except this method returns a list after checking that compositions are charge balanced. """ output = [] predictions = self.pred_from_list(composition.elements) for p in predictions: subs = p['substitutions'] charge = 0 for i_el in composition.elements: f_el = subs[i_el] charge += f_el.oxi_state * composition[i_el] if charge == 0: output.append(p) logging.info('{} charge balanced ' 'compositions found'.format(len(output))) return output @property def to_dict(self): return {"name": self.__class__.__name__, "version": __version__, "kwargs": self._kwargs, "threshold": self._threshold, "@module": self.__class__.__module__, "@class": self.__class__.__name__} @classmethod def from_dict(cls, d): t = d['threshold'] kwargs = d['kwargs'] return cls(threshold=t, **kwargs)