# matminer.featurizers.structure package

## Subpackages

- matminer.featurizers.structure.tests package
  - Submodules
  - matminer.featurizers.structure.tests.base module
  - matminer.featurizers.structure.tests.test_bonding module
  - matminer.featurizers.structure.tests.test_composite module
  - matminer.featurizers.structure.tests.test_matrix module
  - matminer.featurizers.structure.tests.test_misc module
  - matminer.featurizers.structure.tests.test_order module
  - matminer.featurizers.structure.tests.test_rdf module
  - matminer.featurizers.structure.tests.test_sites module
  - matminer.featurizers.structure.tests.test_symmetry module
  - Module contents

## Submodules

## matminer.featurizers.structure.bonding module

Structure featurizers based on bonding.

class `matminer.featurizers.structure.bonding.``BagofBonds`(coulomb_matrix=SineCoulombMatrix(flatten=False), token=' - ')

  Bases: `matminer.featurizers.base.BaseFeaturizer`

  Compute a Bag of Bonds vector, as first described by Hansen et al. (2015).

  The Bag of Bonds approach is based creating an even-length vector from a Coulomb matrix output. Practically, it represents the Coloumbic interactions between each possible set of sites in a structure as a vector.

  BagofBonds must be fit to an iterable of structures using the “fit” method before featurization can occur. This is because the bags and the maximum lengths of each bag must be set prior to featurization. We recommend fitting and featurizing on the same data to maintain consistency between generated feature sets. This can be done using the fit_transform method (for lists of structures) or the fit_featurize_dataframe method (for dataframes).

  BagofBonds is based on a method by Hansen et. al “Machine Learning Predictions of Molecular Properties: Accurate Many-Body Potentials and Nonlocality in Chemical Space” (2015).

  Args:
    coulomb_matrix (BaseFeaturizer): A featurizer object containing a

      “featurize” method which returns a matrix of size nsites x nsites. Good choices are CoulombMatrix() or SineCoulombMatrix(), with the flatten=False parameter set.

    token (str): The string used to separate species in a bond, including

      spaces. The token must contain at least one space and cannot have alphabetic characters in it, and should be padded by spaces. For example, for the bond Cs+ - Cl-, the token is ‘ - ‘. This determines how bonds are represented in the dataframe.

  `__init__`(coulomb_matrix=SineCoulombMatrix(flatten=False), token=' - ')

    Initialize self. See help(type(self)) for accurate signature.

  `bag`(s, return_baglens=False)

    Convert a structure into a bag of bonds, where each bag has no padded zeros. using this function will give the ‘raw’ bags, which when concatenated, will have different lengths.

    Args:
      s (Structure): A pymatgen Structure or IStructure object. May also

        work with a

      return_baglens (bool): If True, returns the bag of bonds with as

        a dictionary with the number of bonds as values in place of the vectors of coulomb matrix vals. If False, calculates Coulomb matrix values and returns ‘raw’ bags.

    Returns:
      (dict) A bag of bonds, where the keys are sorted tuples of pymatgen

        Site objects representing bonds or sites, and the values are the Coulomb matrix values for that bag.

  `citations`()

    Citation(s) and reference(s) for this feature.

    Returns:
      (list) each element should be a string citation,

        ideally in BibTeX format.

  `feature_labels`()

    Generate attribute names.

    Returns:

      ([str]) attribute labels.

  `featurize`(s)

    Featurizes a structure according to the bag of bonds method. Specifically, each structure is first bagged by flattening the Coulomb matrix for the structure. Then, it is zero-padded according to the maximum number of bonds in each bag, for the set of bags that BagofBonds was fit with.

    Args:

      s (Structure): A pymatgen structure object

    Returns:

      (list): The Bag of Bonds vector for the input structure

  `fit`(X, y=None)

    Define the bags using a list of structures.

    Both the names of the bags (e.g., Cs-Cl) and the maximum lengths of the bags are set with fit.

    Args:
      X (Series/list): An iterable of pymatgen Structure

        objects which will be used to determine the allowed bond types and bag lengths.

      y : unused (added for consistency with overridden method signature)

    Returns:

      self

  `implementors`()

    List of implementors of the feature.

    Returns:
      (list) each element should either be a string with author name (e.g.,

        “Anubhav Jain”) or a dictionary with required key “name” and other keys like “email” or “institution” (e.g., {“name”: “Anubhav Jain”, “email”: “ajain@lbl.gov”, “institution”: “LBNL”}).

class `matminer.featurizers.structure.bonding.``BondFractions`(nn=<pymatgen.analysis.local_env.CrystalNN object>, bbv=0, no_oxi=False, approx_bonds=False, token=' - ', allowed_bonds=None)

  Bases: `matminer.featurizers.base.BaseFeaturizer`

  Compute the fraction of each bond in a structure, based on NearestNeighbors.

  For example, in a structure with 2 Li-O bonds and 3 Li-P bonds:

  Li-0: 0.4 Li-P: 0.6

  Features:

  BondFractions must be fit with iterable of structures before featurization in order to define the allowed bond types (features). To do this, pass a list of allowed_bonds. Otherwise, fit based on a list of structures. If allowed_bonds is defined and BondFractions is also fit, the intersection of the two lists of possible bonds is used.

  For dataframes containing structures of various compositions, a unified dataframe is returned which has the collection of all possible bond types gathered from all structures as columns. To approximate bonds based on chemical rules (ie, for a structure which you’d like to featurize but has bonds not in the allowed set), use approx_bonds = True.

  BondFractions is based on the “sum over bonds” in the Bag of Bonds approach, based on a method by Hansen et. al “Machine Learning Predictions of Molecular Properties: Accurate Many-Body Potentials and Nonlocality in Chemical Space” (2015).

  Args:
    nn (NearestNeighbors): A Pymatgen nearest neighbors derived object. For

      example, pymatgen.analysis.local_env.VoronoiNN().

    bbv (float): The ‘bad bond values’, values substituted for

      structure-bond combinations which can not physically exist, but exist in the unified dataframe. For example, if a dataframe contains structures of BaLiP and BaTiO3, determines the value to place in the Li-P column for the BaTiO3 row; by default, is 0.

    no_oxi (bool): If True, the featurizer will be agnostic to oxidation

      states, which prevents oxidation states from differentiating bonds. For example, if True, Ca - O is identical to Ca2+ - O2-, Ca3+ - O-, etc., and all of them will be included in Ca - O column.

    approx_bonds (bool): If True, approximates the fractions of bonds not

      in allowed_bonds (forbidden bonds) with similar allowed bonds. Chemical rules are used to determine which bonds are most ‘similar’; particularly, the Euclidean distance between the 2-tuples of the bonds in Mendeleev no. space is minimized for the approximate bond chosen.

    token (str): The string used to separate species in a bond, including

      spaces. The token must contain at least one space and cannot have alphabetic characters in it, and should be padded by spaces. For example, for the bond Cs+ - Cl-, the token is ‘ - ‘. This determines how bonds are represented in the dataframe.

    allowed_bonds ([str]): A listlike object containing bond types as

      strings. For example, Cs - Cl, or Li+ - O2-. Ions and elements will still have distinct bonds if (1) the bonds list originally contained them and (2) no_oxi is False. These must match the token specified.

  `__init__`(nn=<pymatgen.analysis.local_env.CrystalNN object>, bbv=0, no_oxi=False, approx_bonds=False, token=' - ', allowed_bonds=None)

    Initialize self. See help(type(self)) for accurate signature.

  `citations`()

    Citation(s) and reference(s) for this feature.

    Returns:
      (list) each element should be a string citation,

        ideally in BibTeX format.

  `enumerate_all_bonds`(structures)

    Identify all the unique, possible bonds types of all structures present, and create the ‘unified’ bonds list.

    Args:

      structures (list/ndarray): List of pymatgen Structures

    Returns:

      A tuple of unique, possible bond types for an entire list of structures. This tuple is used to form the unified feature labels.

  `enumerate_bonds`(s)

    Lists out all the bond possibilities in a single structure.

    Args:

      s (Structure): A pymatgen structure

    Returns:

      A list of bond types in ‘Li-O’ form, where the order of the elements in each bond type is alphabetic.

  `feature_labels`()

    Returns the list of allowed bonds. Throws an error if the featurizer has not been fit.

  `featurize`(s)

    Quantify the fractions of each bond type in a structure.

    For collections of structures, bonds types which are not found in a particular structure (e.g., Li-P in BaTiO3) are represented as NaN.

    Args:

      s (Structure): A pymatgen Structure object

    Returns:
      (list) The feature list of bond fractions, in the order of the

        alphabetized corresponding bond names.

  `fit`(X, y=None)

    Define the bond types allowed to be returned during each featurization. Bonds found during featurization which are not allowed will be omitted from the returned dataframe or matrix.

    Fit BondFractions by either passing an iterable of structures to training_data or by defining the bonds explicitly with allowed_bonds in __init__.

    Args:
      X (Series/list): An iterable of pymatgen Structure

        objects which will be used to determine the allowed bond types.

      y : unused (added for consistency with overridden method signature)

    Returns:

      self

  static `from_preset`(preset, **kwargs)

    Use one of the standard instances of a given NearNeighbor class. Pass args to __init__, such as allowed_bonds, using this method as well.

    Args:

      preset (str): preset type (“CrystalNN”, “VoronoiNN”, “JmolNN”, “MiniumDistanceNN”, “MinimumOKeeffeNN”, or “MinimumVIRENN”).

    Returns:

      CoordinationNumber from a preset.

  `implementors`()

    List of implementors of the feature.

    Returns:
      (list) each element should either be a string with author name (e.g.,

        “Anubhav Jain”) or a dictionary with required key “name” and other keys like “email” or “institution” (e.g., {“name”: “Anubhav Jain”, “email”: “ajain@lbl.gov”, “institution”: “LBNL”}).

class `matminer.featurizers.structure.bonding.``GlobalInstabilityIndex`(r_cut=4.0, disordered_pymatgen=False)

  Bases: `matminer.featurizers.base.BaseFeaturizer`

  The global instability index of a structure.

  The default is to use IUCr 2016 bond valence parameters for computing bond valence sums. If the structure has disordered site occupancies or non-integer valences on sites, pymatgen’s bond valence sum method can be used instead.

  Note that pymatgen’s bond valence sum method is prone to error unless the correct scale factor is supplied. A scale factor based on testing with perovskites is used here. TODO: Use scipy to optimize scale factor for minimizing GII

  Based on the following publication:

  ‘Structural characterization of R2BaCuO5 (R = Y, Lu, Yb, Tm, Er, Ho,

    Dy, Gd, Eu and Sm) oxides by X-ray and neutron diffraction’, A.Salinas-Sanchez, J.L.Garcia-Muñoz, J.Rodriguez-Carvajal, R.Saez-Puche, and J.L.Martinez, Journal of Solid State Chemistry, 100, 201-211 (1992), https://doi.org/10.1016/0022-4596(92)90094-C

  Args:

    r_cut: Float, how far to search for neighbors when computing bond valences disordered_pymatgen: Boolean, whether to fall back on pymatgen’s bond

    > valence sum method for disordered structures

  Features:
    The global instability index is the square root of the sum of squared

      differences of the bond valence sums from the formal valences averaged over all atoms in the unit cell.

  `__init__`(r_cut=4.0, disordered_pymatgen=False)

    Initialize self. See help(type(self)) for accurate signature.

  `calc_bv_sum`(site_val, site_el, neighbor_list)

    Computes bond valence sum for site. Args:

    > site_val (Integer): valence of site site_el (String): element name neighbor_list (List): List of neighboring sites and their distances

  `calc_gii_iucr`(s)

    Computes global instability index using tabulated bv params.

    Args:

      s: Pymatgen Structure object

    Returns:

      gii: Float, the global instability index

  `calc_gii_pymatgen`(struct, scale_factor=0.965)

    Calculates global instability index using Pymatgen’s bond valence sum Args:

    > struct: Pymatgen Structure object scale_factor: Float, tunable scale factor for bond valence

    Returns:

      gii: Float, global instability index

  `citations`()

    Citation(s) and reference(s) for this feature.

    Returns:
      (list) each element should be a string citation,

        ideally in BibTeX format.

  static `compute_bv`(params, dist)

    Compute bond valence from parameters. Args:

    > params: Dataframe with Ro and B parameters dist: Float, distance to neighboring atom

    Returns:

      bv: Float, bond valence

  `feature_labels`()

    Generate attribute names.

    Returns:

      ([str]) attribute labels.

  `featurize`(struct)

    Get global instability index.

    Args:

      struct: Pymatgen Structure object

    Returns:

      [gii]: Length 1 list with float value

  `get_bv_params`(cation, anion, cat_val, an_val)

    Lookup bond valence parameters from IUPAC table. Args:

    > cation: String, cation element anion: String, anion element cat_val: Integer, cation formal valence an_val: Integer, anion formal valence

    Returns:

      bond_val_list: dataframe of bond valence parameters

  `get_equiv_sites`(s, site)

    Find identical sites from analyzing space group symmetry.

  `implementors`()

    List of implementors of the feature.

    Returns:
      (list) each element should either be a string with author name (e.g.,

        “Anubhav Jain”) or a dictionary with required key “name” and other keys like “email” or “institution” (e.g., {“name”: “Anubhav Jain”, “email”: “ajain@lbl.gov”, “institution”: “LBNL”}).

  `precheck`(struct)

    Bond valence methods require atom pairs with oxidation states.

    Additionally, check if at least the first and last site’s species have a entry in the bond valence parameters.

    Args:

      struct: Pymatgen Structure

class `matminer.featurizers.structure.bonding.``MinimumRelativeDistances`(cutoff=10.0, flatten=True, include_distances=True, include_species=True)

  Bases: `matminer.featurizers.base.BaseFeaturizer`

  Determines the relative distance of each site to its closest neighbor.

  We use the relative distance, f_ij = r_ij / (r^atom_i + r^atom_j), as a measure rather than the absolute distances, r_ij, to account for the fact that different atoms/species have different sizes. The function uses the valence-ionic radius estimator implemented in Pymatgen.

  The features can be flattened so a uniform-length vector is returned for each material, regardless of the number of sites in each structure. Returning flat output REQUIRES fitting (using self.fit(…)). If fit, structures having fewer sites than the max sites among the fitting structures are extended with NaNs; structures with more sites are truncated. To return non-flat (i.e., requiring further processing) features so that no features are NaN and no distances are truncated, use flatten=False.

  Features:

    If using flatten=True: site #{number} min. rel. dist. (float): The minimum relative distance of

    > site {number}

    site #{number} specie (str): The string representing the specie at site

      {number}

    site #{number} neighbor specie(s) (str, tuple(str)): The neighbor specie

      used to determine the minimum relative distance with respect to site {number}. If multiple neighbor sites have equivalent minimum relative distances,all these sites are listed in a tuple.

    If using flatten=False: minimum relative distance of each site ([float]): List of the minimum

    > relative distance for each site. Structures with different numbers of sites will return a different length vector.

  Args:
    cutoff (float): (absolute) distance up to which tentative closest

      neighbors (on the basis of relative distances) are to be determined.

    flatten (bool): If True, returns a uniform length feature vector for

      each structure regardless of the number of sites in the structure. If True, you must call .fit() before featurizing.

    include_distances (bool): Include the numerical minimum relative

      distance in the returned features. Only used if flatten=True.

    include_species (bool): Include the species for each site and the

      species of the neighbor (as determined by minimum rel. distance). Only used as flatten=True.

  `__init__`(cutoff=10.0, flatten=True, include_distances=True, include_species=True)

    Initialize self. See help(type(self)) for accurate signature.

  `citations`()

    Citation(s) and reference(s) for this feature.

    Returns:
      (list) each element should be a string citation,

        ideally in BibTeX format.

  `feature_labels`()

    Generate attribute names.

    Returns:

      ([str]) attribute labels.

  `featurize`(s)

    Get minimum relative distances of all sites of the input structure.

    Args:

      s: Pymatgen Structure object.

    Returns:
      dists_relative_min: (list of floats) list of all minimum relative

        distances (i.e., for all sites).

  `fit`(X, y=None)

    Fit the MRD featurizer to a list of structures. Args:

    > X ([Structure]): A list of pymatgen structures. y : unused (added for consistency with overridden method signature)

    Returns:

      self

  `implementors`()

    List of implementors of the feature.

    Returns:
      (list) each element should either be a string with author name (e.g.,

        “Anubhav Jain”) or a dictionary with required key “name” and other keys like “email” or “institution” (e.g., {“name”: “Anubhav Jain”, “email”: “ajain@lbl.gov”, “institution”: “LBNL”}).

class `matminer.featurizers.structure.bonding.``StructuralHeterogeneity`(weight='area', stats='minimum', 'maximum', 'range', 'mean', 'avg_dev')

  Bases: `matminer.featurizers.base.BaseFeaturizer`

  Variance in the bond lengths and atomic volumes in a structure

  These features are based on several statistics derived from the Voronoi tessellation of a structure. The first set of features relate to the variance in the average bond length across all atoms in the structure. The second relate to the variance of bond lengths between each neighbor of each atom. The final feature is the variance in Voronoi cell sizes across the structure.

  We define the ‘average bond length’ of a site as the weighted average of the bond lengths for all neighbors. By default, the weight is the area of the face between the sites.

  The ‘neighbor distance variation’ is defined as the weighted mean absolute deviation in both length for all neighbors of a particular site. As before, the weight is according to face area by default. For this statistic, we divide the mean absolute deviation by the mean neighbor distance for that site.

  Features:
    mean absolute deviation in relative bond length - Mean absolute deviation

      in the average bond lengths for all sites, divided by the mean average bond length

    max relative bond length - Maximum average bond length, divided by the

      mean average bond length

    min relative bond length - Minimum average bond length, divided by the

      mean average bond length

    [stat] neighbor distance variation - Statistic (e.g., mean) of the

      neighbor distance variation

    mean absolute deviation in relative cell size - Mean absolute deviation

      in the Voronoi cell volume across all sites in the structure. Divided by the mean Voronoi cell volume.

  References:

    Ward et al. _PRB_ 2017

  `__init__`(weight='area', stats='minimum', 'maximum', 'range', 'mean', 'avg_dev')

    Initialize self. See help(type(self)) for accurate signature.

  `citations`()

    Citation(s) and reference(s) for this feature.

    Returns:
      (list) each element should be a string citation,

        ideally in BibTeX format.

  `feature_labels`()

    Generate attribute names.

    Returns:

      ([str]) attribute labels.

  `featurize`(strc)

    Main featurizer function, which has to be implemented in any derived featurizer subclass.

    Args:

      x: input data to featurize (type depends on featurizer).

    Returns:

      (list) one or more features.

  `implementors`()

    List of implementors of the feature.

    Returns:
      (list) each element should either be a string with author name (e.g.,

        “Anubhav Jain”) or a dictionary with required key “name” and other keys like “email” or “institution” (e.g., {“name”: “Anubhav Jain”, “email”: “ajain@lbl.gov”, “institution”: “LBNL”}).

## matminer.featurizers.structure.composite module

Structure featurizers producing more than one kind of structue feature data.

class `matminer.featurizers.structure.composite.``JarvisCFID`(use_cell=True, use_chem=True, use_chg=True, use_rdf=True, use_adf=True, use_ddf=True, use_nn=True)

  Bases: `matminer.featurizers.base.BaseFeaturizer`

  Classical Force-Field Inspired Descriptors (CFID) from Jarvis-ML.

  Chemo-structural descriptors from five different sub-methods,cincluding pairwise radial, nearest neighbor, bond-angle, dihedral-angle and core-charge distributions. With all descriptors enabled, there are 1,557 features per structure.

  Adapted from the nist/jarvis package hosted at: https://github.com/usnistgov/jarvis

  Find details at: https://journals.aps.org/prmaterials/abstract/10.1103/

    PhysRevMaterials.2.083801

  Args/Features:
    use_cell (bool): Use structure cell descriptors (4 features, based

      on DensityFeatures and log volume per atom).

    use_chem (bool): Use chemical composition descriptors (438 features) use_chg (bool): Use core charge descriptors (378 features) use_adf (bool): Use angular distribution function (179 features x 2, one

    > set of features for each cutoff).

    use_rdf (bool): Use radial distribution function (100 features) use_ddf (bool): Use dihedral angle distribution function (179 features) use_nn (bool): Use nearest neighbors (100 descriptors)

  `__init__`(use_cell=True, use_chem=True, use_chg=True, use_rdf=True, use_adf=True, use_ddf=True, use_nn=True)

    Initialize self. See help(type(self)) for accurate signature.

  `citations`()

    Citation(s) and reference(s) for this feature.

    Returns:
      (list) each element should be a string citation,

        ideally in BibTeX format.

  `feature_labels`()

    Generate attribute names.

    Returns:

      ([str]) attribute labels.

  `featurize`(s)

    Get chemo-structural CFID decriptors

    Args:

      s: Structure object

    Returns:

      (np.ndarray) Final descriptors

  `get_chem`(element)

    Get chemical descriptors for an element

    Args:

      element: element name

    Returns:

      arr: descriptor array value

  `get_chg`(element)

    Get charge descriptors for an element

    Args:

      element: element name

    Returns:

      arr: descriptor array values

  `get_distributions`(structure, c_size=10.0, max_cut=5.0)

    Get radial and angular distribution functions

    Args:

      structure: Structure object c_size: max. cell size max_cut: max. bond cut-off for angular distribution

    Retruns:

      adfa, adfb, ddf, rdf, bondo Angular distribution upto first cut-off Angular distribution upto second cut-off Dihedral angle distribution upto first cut-off Radial distribution funcion Bond order distribution

  `implementors`()

    List of implementors of the feature.

    Returns:
      (list) each element should either be a string with author name (e.g.,

        “Anubhav Jain”) or a dictionary with required key “name” and other keys like “email” or “institution” (e.g., {“name”: “Anubhav Jain”, “email”: “ajain@lbl.gov”, “institution”: “LBNL”}).

## matminer.featurizers.structure.matrix module

Structure featurizers generating a matrix for each structure.

Most matrix structure featurizers contain the ability to flatten matrices to be dataframe-friendly.

class `matminer.featurizers.structure.matrix.``CoulombMatrix`(diag_elems=True, flatten=True)

  Bases: `matminer.featurizers.base.BaseFeaturizer`

  The Coulomb matrix, a representation of nuclear coulombic interaction.

  Generate the Coulomb matrix, M, of the input structure (or molecule). The Coulomb matrix was put forward by Rupp et al. (Phys. Rev. Lett. 108, 058301, 2012) and is defined by off-diagonal elements M_ij = Z_i*Z_j/|R_i-R_j| and diagonal elements 0.5*Z_i^2.4, where Z_i and R_i denote the nuclear charge and the position of atom i, respectively.

  Coulomb Matrix features are flattened (for ML-readiness) by default. Use fit before featurizing to use flattened features. To return the matrix form, set flatten=False.

  Args:
    diag_elems (bool): flag indication whether (True, default) to use

      the original definition of the diagonal elements; if set to False, the diagonal elements are set to 0

    flatten (bool): If True, returns a flattened vector based on eigenvalues

      of the matrix form. Otherwise, returns a matrix object (single feature), which will likely need to be processed further.

  `__init__`(diag_elems=True, flatten=True)

    Initialize self. See help(type(self)) for accurate signature.

  `citations`()

    Citation(s) and reference(s) for this feature.

    Returns:
      (list) each element should be a string citation,

        ideally in BibTeX format.

  `feature_labels`()

    Generate attribute names.

    Returns:

      ([str]) attribute labels.

  `featurize`(s)

    Get Coulomb matrix of input structure.

    Args:

      s: input Structure (or Molecule) object.

    Returns:

      m: (Nsites x Nsites matrix) Coulomb matrix.

  `fit`(X, y=None)

    Fit the Coulomb Matrix to a list of structures.

    Args:

      X ([Structure]): A list of pymatgen structures. y : unused (added for consistency with overridden method signature)

    Returns:

      self

  `implementors`()

    List of implementors of the feature.

    Returns:
      (list) each element should either be a string with author name (e.g.,

        “Anubhav Jain”) or a dictionary with required key “name” and other keys like “email” or “institution” (e.g., {“name”: “Anubhav Jain”, “email”: “ajain@lbl.gov”, “institution”: “LBNL”}).

class `matminer.featurizers.structure.matrix.``OrbitalFieldMatrix`(period_tag=False, flatten=True)

  Bases: `matminer.featurizers.base.BaseFeaturizer`

  Representation based on the valence shell electrons of neighboring atoms.

  Each atom is described by a 32-element vector (or 39-element vector, see period tag for details) uniquely representing the valence subshell. A 32x32 (39x39) matrix is formed by multiplying two atomic vectors. An OFM for an atomic environment is the sum of these matrices for each atom the center atom coordinates with multiplied by a distance function (In this case, 1/r times the weight of the coordinating atom in the Voronoi

  > Polyhedra method). The OFM of a structure or molecule is the average of the OFMs for all the sites in the structure.

  Args:
    period_tag (bool): In the original OFM, an element is represented

      by a vector of length 32, where each element is 1 or 0, which represents the valence subshell of the element. With period_tag=True, the vector size is increased to 39, where the 7 extra elements represent the period of the element. Note lanthanides are treated as period 6, actinides as period 7. Default False as in the original paper.

    flatten (bool): Flatten the avg OFM to a 1024-vector (if period_tag

      False) or a 1521-vector (if period_tag=True).

  …attribute:: size

    Either 32 or 39, the size of the vectors used to describe elements.

  Reference:

    Pham et al. _Sci Tech Adv Mat_. 2017 <http://dx.doi.org/10.1080/14686996.2017.1378060>_

  `__init__`(period_tag=False, flatten=True)

    Initialize the featurizer

    Args:
      period_tag (bool): In the original OFM, an element is represented

        by a vector of length 32, where each element is 1 or 0, which represents the valence subshell of the element. With period_tag=True, the vector size is increased to 39, where the 7 extra elements represent the period of the element. Note lanthanides are treated as period 6, actinides as period 7. Default False as in the original paper.

  `citations`()

    Citation(s) and reference(s) for this feature.

    Returns:
      (list) each element should be a string citation,

        ideally in BibTeX format.

  `feature_labels`()

    Generate attribute names.

    Returns:

      ([str]) attribute labels.

  `featurize`(s)

    Makes a supercell for structure s (to protect sites from coordinating with themselves), and then finds the mean of the orbital field matrices of each site to characterize a structure

    Args:

      s (Structure): structure to characterize

    Returns:
      mean_ofm (size X size matrix): orbital field matrix

        characterizing s

  `get_atom_ofms`(struct, symm=False)

    Calls get_single_ofm for every site in struct. If symm=True, get_single_ofm is called for symmetrically distinct sites, and counts is constructed such that ofms[i] occurs counts[i] times in the structure

    Args:

      struct (Structure): structure for find ofms for symm (bool): whether to calculate ofm for only symmetrically

      > distinct sites

    Returns:

      ofms ([size X size matrix] X len(struct)): ofms for struct if symm:

      > ofms ([size X size matrix] X number of symmetrically distinct sites):

      >   ofms for struct

      > counts: number of identical sites for each ofm

  `get_mean_ofm`(ofms, counts)

    Averages a list of ofms, weights by counts

  `get_ohv`(sp, period_tag)

    Get the “one-hot-vector” for pymatgen Element sp. This 32 or 39-length vector represents the valence shell of the given element. Args:

    > sp (Element): element whose ohv should be returned period_tag (bool): If true, the vector contains items

    > > corresponding to the period of the element

    Returns:

      my_ohv (numpy array length 39 if period_tag, else 32): ohv for sp

  `get_single_ofm`(site, site_dict)

    Gets the orbital field matrix for a single chemical environment, where site is the center atom whose environment is characterized and site_dict is a dictionary of site : weight, where the weights are the Voronoi Polyhedra weights of the corresponding coordinating sites.

    Args:

      site (Site): center atom site_dict (dict of Site:float): chemical environment

    Returns:

      atom_ofm (size X size numpy matrix): ofm for site

  `get_structure_ofm`(struct)

    Calls get_mean_ofm on the results of get_atom_ofms to give a size X size matrix characterizing a structure

  `implementors`()

    List of implementors of the feature.

    Returns:
      (list) each element should either be a string with author name (e.g.,

        “Anubhav Jain”) or a dictionary with required key “name” and other keys like “email” or “institution” (e.g., {“name”: “Anubhav Jain”, “email”: “ajain@lbl.gov”, “institution”: “LBNL”}).

class `matminer.featurizers.structure.matrix.``SineCoulombMatrix`(diag_elems=True, flatten=True)

  Bases: `matminer.featurizers.base.BaseFeaturizer`

  A variant of the Coulomb matrix developed for periodic crystals.

  This function generates a variant of the Coulomb matrix developed for periodic crystals by Faber et al. (Inter. J. Quantum Chem. 115, 16, 2015). It is identical to the Coulomb matrix, except that the inverse distance function is replaced by the inverse of a sin**2 function of the vector between the sites which is periodic in the dimensions of the structure lattice. See paper for details.

  Coulomb Matrix features are flattened (for ML-readiness) by default. Use fit before featurizing to use flattened features. To return the matrix form, set flatten=False.

  Args:
    diag_elems (bool): flag indication whether (True, default) to use

      the original definition of the diagonal elements; if set to False, the diagonal elements are set to 0

    flatten (bool): If True, returns a flattened vector based on eigenvalues

      of the matrix form. Otherwise, returns a matrix object (single feature), which will likely need to be processed further.

  `__init__`(diag_elems=True, flatten=True)

    Initialize self. See help(type(self)) for accurate signature.

  `citations`()

    Citation(s) and reference(s) for this feature.

    Returns:
      (list) each element should be a string citation,

        ideally in BibTeX format.

  `feature_labels`()

    Generate attribute names.

    Returns:

      ([str]) attribute labels.

  `featurize`(s)
    Args:

      s (Structure or Molecule): input structure (or molecule)

    Returns:

      (Nsites x Nsites matrix) Sine matrix or

  `fit`(X, y=None)

    Fit the Sine Coulomb Matrix to a list of structures.

    Args:

      X ([Structure]): A list of pymatgen structures. y : unused (added for consistency with overridden method signature)

    Returns:

      self

  `implementors`()

    List of implementors of the feature.

    Returns:
      (list) each element should either be a string with author name (e.g.,

        “Anubhav Jain”) or a dictionary with required key “name” and other keys like “email” or “institution” (e.g., {“name”: “Anubhav Jain”, “email”: “ajain@lbl.gov”, “institution”: “LBNL”}).

## matminer.featurizers.structure.misc module

Miscellaneous structure featurizers.

class `matminer.featurizers.structure.misc.``EwaldEnergy`(accuracy=4, per_atom=True)

  Bases: `matminer.featurizers.base.BaseFeaturizer`

  Compute the energy from Coulombic interactions.

  Note: The energy is computed using _charges already defined for the structure_.

  Features:

    ewald_energy - Coulomb interaction energy of the structure

  `__init__`(accuracy=4, per_atom=True)
    Args:

      accuracy (int): Accuracy of Ewald summation, number of decimal places

  `citations`()

    Citation(s) and reference(s) for this feature.

    Returns:
      (list) each element should be a string citation,

        ideally in BibTeX format.

  `feature_labels`()

    Generate attribute names.

    Returns:

      ([str]) attribute labels.

  `featurize`(strc)
    Args:

      (Structure) - Structure being analyzed

    Returns:

      ([float]) - Electrostatic energy of the structure

  `implementors`()

    List of implementors of the feature.

    Returns:
      (list) each element should either be a string with author name (e.g.,

        “Anubhav Jain”) or a dictionary with required key “name” and other keys like “email” or “institution” (e.g., {“name”: “Anubhav Jain”, “email”: “ajain@lbl.gov”, “institution”: “LBNL”}).

class `matminer.featurizers.structure.misc.``StructureComposition`(featurizer=None)

  Bases: `matminer.featurizers.base.BaseFeaturizer`

  Features related to the composition of a structure

  This class is just a wrapper that calls a composition-based featurizer on the composition of a Structure

  Features:

    - Depends on the featurizer

  `__init__`(featurizer=None)

    Initialize the featurizer

    Args:

      featurizer (BaseFeaturizer) - Composition-based featurizer

  `citations`()

    Citation(s) and reference(s) for this feature.

    Returns:
      (list) each element should be a string citation,

        ideally in BibTeX format.

  `feature_labels`()

    Generate attribute names.

    Returns:

      ([str]) attribute labels.

  `featurize`(strc)

    Main featurizer function, which has to be implemented in any derived featurizer subclass.

    Args:

      x: input data to featurize (type depends on featurizer).

    Returns:

      (list) one or more features.

  `fit`(X, y=None, **fit_kwargs)

    Update the parameters of this featurizer based on available data

    Args:

      X - [list of tuples], training data

    Returns:

      self

  `implementors`()

    List of implementors of the feature.

    Returns:
      (list) each element should either be a string with author name (e.g.,

        “Anubhav Jain”) or a dictionary with required key “name” and other keys like “email” or “institution” (e.g., {“name”: “Anubhav Jain”, “email”: “ajain@lbl.gov”, “institution”: “LBNL”}).

class `matminer.featurizers.structure.misc.``XRDPowderPattern`(two_theta_range=0, 127, bw_method=0.05, pattern_length=None, **kwargs)

  Bases: `matminer.featurizers.base.BaseFeaturizer`

  1D array representing powder diffraction of a structure as calculated by pymatgen. The powder is smeared / normalized according to gaussian_kde.

  `__init__`(two_theta_range=0, 127, bw_method=0.05, pattern_length=None, **kwargs)

    Initialize the featurizer.

    Args:
      two_theta_range ([float of length 2]): Tuple for range of

        two_thetas to calculate in degrees. Defaults to (0, 90). Set to None if you want all diffracted beams within the limiting sphere of radius 2 / wavelength.

      bw_method (float): how much to smear the XRD pattern pattern_length (float): length of final array; defaults to one value

      > per degree (i.e. two_theta_range + 1)

      **kwargs: any other arguments to pass into pymatgen’s XRDCalculator,

        such as the type of radiation.

  `citations`()

    Citation(s) and reference(s) for this feature.

    Returns:
      (list) each element should be a string citation,

        ideally in BibTeX format.

  `feature_labels`()

    Generate attribute names.

    Returns:

      ([str]) attribute labels.

  `featurize`(strc)

    Main featurizer function, which has to be implemented in any derived featurizer subclass.

    Args:

      x: input data to featurize (type depends on featurizer).

    Returns:

      (list) one or more features.

  `implementors`()

    List of implementors of the feature.

    Returns:
      (list) each element should either be a string with author name (e.g.,

        “Anubhav Jain”) or a dictionary with required key “name” and other keys like “email” or “institution” (e.g., {“name”: “Anubhav Jain”, “email”: “ajain@lbl.gov”, “institution”: “LBNL”}).

## matminer.featurizers.structure.order module

Structure featurizers based on packing or ordering.

class `matminer.featurizers.structure.order.``ChemicalOrdering`(shells=1, 2, 3, weight='area')

  Bases: `matminer.featurizers.base.BaseFeaturizer`

  How much the ordering of species in the structure differs from random

  These parameters describe how much the ordering of all species in a structure deviates from random using a Warren-Cowley-like ordering parameter. The first step of this calculation is to determine the nearest neighbor shells of each site. Then, for each shell a degree of order for each type is determined by computing:

  where is the weight associated with a certain neighbor, is the type of the neighbor, and is the fraction of type t in the structure. For atoms that are randomly dispersed in a structure, this formula yields 0 for all types. For structures where each site is surrounded only by atoms of another type, this formula yields large values of .

  The mean absolute value of this parameter across all sites is used as a feature.

  Features:
    mean ordering parameter shell [n] - Mean ordering parameter for

      atoms in the n<sup>th</sup> neighbor shell

  References:

    Ward et al. _PRB_ 2017

  `__init__`(shells=1, 2, 3, weight='area')

    Initialize the featurizer

    Args:

      shells ([int]) - Which neighbor shells to evaluate weight (str) - Attribute used to weigh neighbor contributions

  `citations`()

    Citation(s) and reference(s) for this feature.

    Returns:
      (list) each element should be a string citation,

        ideally in BibTeX format.

  `feature_labels`()

    Generate attribute names.

    Returns:

      ([str]) attribute labels.

  `featurize`(strc)

    Main featurizer function, which has to be implemented in any derived featurizer subclass.

    Args:

      x: input data to featurize (type depends on featurizer).

    Returns:

      (list) one or more features.

  `implementors`()

    List of implementors of the feature.

    Returns:
      (list) each element should either be a string with author name (e.g.,

        “Anubhav Jain”) or a dictionary with required key “name” and other keys like “email” or “institution” (e.g., {“name”: “Anubhav Jain”, “email”: “ajain@lbl.gov”, “institution”: “LBNL”}).

class `matminer.featurizers.structure.order.``DensityFeatures`(desired_features=None)

  Bases: `matminer.featurizers.base.BaseFeaturizer`

  Calculates density and density-like features

  Features:

    - density

    - volume per atom

    - (“vpa”), and packing fraction

  `__init__`(desired_features=None)
    Args:
      desired_features: [str] - choose from “density”, “vpa”,

        “packing fraction”

  `citations`()

    Citation(s) and reference(s) for this feature.

    Returns:
      (list) each element should be a string citation,

        ideally in BibTeX format.

  `feature_labels`()

    Generate attribute names.

    Returns:

      ([str]) attribute labels.

  `featurize`(s)

    Main featurizer function, which has to be implemented in any derived featurizer subclass.

    Args:

      x: input data to featurize (type depends on featurizer).

    Returns:

      (list) one or more features.

  `implementors`()

    List of implementors of the feature.

    Returns:
      (list) each element should either be a string with author name (e.g.,

        “Anubhav Jain”) or a dictionary with required key “name” and other keys like “email” or “institution” (e.g., {“name”: “Anubhav Jain”, “email”: “ajain@lbl.gov”, “institution”: “LBNL”}).

  `precheck`(s: pymatgen.core.structure.Structure) → bool

    Precheck a single entry. DensityFeatures does not work for disordered structures. To precheck an entire dataframe (qnd automatically gather the fraction of structures that will pass the precheck), please use precheck_dataframe.

    Args:

      s (pymatgen.Structure): The structure to precheck.

    Returns:

      (bool): If True, s passed the precheck; otherwise, it failed.

class `matminer.featurizers.structure.order.``MaximumPackingEfficiency`

  Bases: `matminer.featurizers.base.BaseFeaturizer`

  Maximum possible packing efficiency of this structure

  Uses a Voronoi tessellation to determine the largest radius each atom can have before any atoms touches any one of their neighbors. Given the maximum radius size, this class computes the maximum packing efficiency of the structure as a feature.

  Features:

    max packing efficiency - Maximum possible packing efficiency

  `citations`()

    Citation(s) and reference(s) for this feature.

    Returns:
      (list) each element should be a string citation,

        ideally in BibTeX format.

  `feature_labels`()

    Generate attribute names.

    Returns:

      ([str]) attribute labels.

  `featurize`(strc)

    Main featurizer function, which has to be implemented in any derived featurizer subclass.

    Args:

      x: input data to featurize (type depends on featurizer).

    Returns:

      (list) one or more features.

  `implementors`()

    List of implementors of the feature.

    Returns:
      (list) each element should either be a string with author name (e.g.,

        “Anubhav Jain”) or a dictionary with required key “name” and other keys like “email” or “institution” (e.g., {“name”: “Anubhav Jain”, “email”: “ajain@lbl.gov”, “institution”: “LBNL”}).

class `matminer.featurizers.structure.order.``StructuralComplexity`(symprec=0.1)

  Bases: `matminer.featurizers.base.BaseFeaturizer`

  Shannon information entropy of a structure.

  This descriptor treat a structure as a message to evaluate structural complexity () using the following equation:

  where is the total number of atoms in the unit cell, is the probability mass function, is the number of symmetrically inequivalent sites, and is the number of sites classified in th symmetrically inequivalent site.

  Features:

    - information entropy (bits/atom)

    - information entropy (bits/unit cell)

  Args:

    symprec: precision for symmetrizing a structure

  `__init__`(symprec=0.1)

    Initialize self. See help(type(self)) for accurate signature.

  `citations`()

    Citation(s) and reference(s) for this feature.

    Returns:
      (list) each element should be a string citation,

        ideally in BibTeX format.

  `feature_labels`()

    Generate attribute names.

    Returns:

      ([str]) attribute labels.

  `featurize`(struct)

    Main featurizer function, which has to be implemented in any derived featurizer subclass.

    Args:

      x: input data to featurize (type depends on featurizer).

    Returns:

      (list) one or more features.

  `implementors`()

    List of implementors of the feature.

    Returns:
      (list) each element should either be a string with author name (e.g.,

        “Anubhav Jain”) or a dictionary with required key “name” and other keys like “email” or “institution” (e.g., {“name”: “Anubhav Jain”, “email”: “ajain@lbl.gov”, “institution”: “LBNL”}).

## matminer.featurizers.structure.rdf module

Structure featurizers implementing radial distribution functions.

class `matminer.featurizers.structure.rdf.``ElectronicRadialDistributionFunction`(cutoff=20, dr=0.05)

  Bases: `matminer.featurizers.base.BaseFeaturizer`

  Calculate the inherent electronic radial distribution function (ReDF)

  The ReDF is defined according to Willighagen et al., Acta Cryst., 2005, B61, 29-36.

  The ReDF is a structure-integral RDF (i.e., summed over all sites) in which the positions of neighboring sites are weighted by electrostatic interactions inferred from atomic partial charges. Atomic charges are obtained from the ValenceIonicRadiusEvaluator class.

  WARNING: The ReDF needs oxidation states to work correctly.

  Args:
    cutoff: (float) distance up to which the ReDF is to be

      calculated.

    dr: (float) width of bins (“x”-axis) of ReDF (default: 0.05 A).

  Attributes:

    distances (np.ndarray): The distances at which each bin begins.

  `__init__`(cutoff=20, dr=0.05)

    Initialize self. See help(type(self)) for accurate signature.

  `citations`()

    Citation(s) and reference(s) for this feature.

    Returns:
      (list) each element should be a string citation,

        ideally in BibTeX format.

  `feature_labels`()

    Generate attribute names.

    Returns:

      ([str]) attribute labels.

  `featurize`(s)

    Get ReDF of input structure.

    Args:

      s: input Structure object.

    Returns: (list) the ReDF

  `implementors`()

    List of implementors of the feature.

    Returns:
      (list) each element should either be a string with author name (e.g.,

        “Anubhav Jain”) or a dictionary with required key “name” and other keys like “email” or “institution” (e.g., {“name”: “Anubhav Jain”, “email”: “ajain@lbl.gov”, “institution”: “LBNL”}).

  `precheck`(s) → bool

    Check the structure to ensure the ReDF can be run. Args:

    > s (pymatgen. Structure): Structure to precheck

    Returns:

      (bool)

class `matminer.featurizers.structure.rdf.``PartialRadialDistributionFunction`(cutoff=20.0, bin_size=0.1, include_elems=(), exclude_elems=())

  Bases: `matminer.featurizers.base.BaseFeaturizer`

  Compute the partial radial distribution function (PRDF) of an xtal structure

  The PRDF of a crystal structure is the radial distibution function broken down for each pair of atom types. The PRDF was proposed as a structural descriptor by [Schutt et al.] (https://journals.aps.org/prb/abstract/10.1103/PhysRevB.89.205118)

  Args:

    cutoff: (float) distance up to which to calculate the RDF. bin_size: (float) size of each bin of the (discrete) RDF. include_elems: (list of string), list of elements that must be included in PRDF exclude_elems: (list of string), list of elmeents that should not be included in PRDF

  Features:

    Each feature corresponds to the density of number of bonds for a certain pair of elements at a certain range of distances. For example, “Al-Al PRDF r=1.00-1.50” corresponds to the density of Al-Al bonds between 1 and 1.5 distance units By default, this featurizer generates RDFs for each pair of elements in the training set.

  `__init__`(cutoff=20.0, bin_size=0.1, include_elems=(), exclude_elems=())

    Initialize self. See help(type(self)) for accurate signature.

  `citations`()

    Citation(s) and reference(s) for this feature.

    Returns:
      (list) each element should be a string citation,

        ideally in BibTeX format.

  `compute_prdf`(s)

    Compute the PRDF for a structure

    Args:

      s: (Structure), structure to be evaluated

    Returns:

      dist_bins - float, start of each of the bins prdf - dict, where the keys is a pair of elements (strings),

      > and the value is the radial distribution function for those paris of elements

  `feature_labels`()

    Generate attribute names.

    Returns:

      ([str]) attribute labels.

  `featurize`(s)

    Get PRDF of the input structure. Args:

    > s: Pymatgen Structure object.

    Returns:
      prdf, dist: (tuple of arrays) the first element is a

        dictionary where keys are tuples of element names and values are PRDFs.

  `fit`(X, y=None)

    Define the list of elements to be included in the PRDF. By default, the PRDF will include all of the elements in X

    Args:
      X: (numpy array nx1) structures used in the training set. Each entry

        must be Pymatgen Structure objects.

      y: Not used fit_kwargs: not used

    Returns:

      self

  `implementors`()

    List of implementors of the feature.

    Returns:
      (list) each element should either be a string with author name (e.g.,

        “Anubhav Jain”) or a dictionary with required key “name” and other keys like “email” or “institution” (e.g., {“name”: “Anubhav Jain”, “email”: “ajain@lbl.gov”, “institution”: “LBNL”}).

  `precheck`(s)

    Precheck the structure is ordered. Args:

    > s: (pymatgen.Struture)

    Returns:

      (bool): True if passing precheck, false if failing

class `matminer.featurizers.structure.rdf.``RadialDistributionFunction`(cutoff=20.0, bin_size=0.1)

  Bases: `matminer.featurizers.base.BaseFeaturizer`

  Calculate the radial distribution function (RDF) of a crystal structure.

  Features:

    - Radial distribution function. Each feature is the “density” of the distribution at a certain radius.

  Args:

    cutoff: (float) Angstrom distance up to which to calculate the RDF. bin_size: (float) size in Angstrom of each bin of the (discrete) RDF.

  Attributes:
    bin_distances (np.Ndarray): The distances each bin represents. Can be

      used for graphing the RDF.

  `__init__`(cutoff=20.0, bin_size=0.1)

    Initialize self. See help(type(self)) for accurate signature.

  `citations`()

    Citation(s) and reference(s) for this feature.

    Returns:
      (list) each element should be a string citation,

        ideally in BibTeX format.

  `feature_labels`()

    Generate attribute names.

    Returns:

      ([str]) attribute labels.

  `featurize`(s)

    Get RDF of the input structure. Args:

    > s (Structure): Pymatgen Structure object.

    Returns:
      rdf: (iterable) the first element is the

        normalized RDF, whereas the second element is the inner radius of the RDF bin.

  `implementors`()

    List of implementors of the feature.

    Returns:
      (list) each element should either be a string with author name (e.g.,

        “Anubhav Jain”) or a dictionary with required key “name” and other keys like “email” or “institution” (e.g., {“name”: “Anubhav Jain”, “email”: “ajain@lbl.gov”, “institution”: “LBNL”}).

  `precheck`(s)

    Precheck the structure is ordered. Args:

    > s: (pymatgen.Struture)

    Returns:

      (bool): True if passing precheck, false if failing

`matminer.featurizers.structure.rdf.``get_rdf_bin_labels`(bin_distances, cutoff)

  Common function for getting bin labels given the distances at which each bin begins and the ending cutoff. Args:

  > bin_distances (np.ndarray): The distances at which each bin begins. cutoff (float): The final cutoff value.

  Returns:

    [str]: The feature labels for the *RDF

## matminer.featurizers.structure.sites module

Structure featurizers based on aggregating site features.

class `matminer.featurizers.structure.sites.``SiteStatsFingerprint`(site_featurizer, stats='mean', 'std_dev', min_oxi=None, max_oxi=None, covariance=False)

  Bases: `matminer.featurizers.base.BaseFeaturizer`

  Computes statistics of properties across all sites in a structure.

  This featurizer first uses a site featurizer class (see site.py for options) to compute features of each site in a structure, and then computes features of the entire structure by measuring statistics of each attribute. Can optionally compute the the statistics of only sites with certain ranges of oxidation states (e.g., only anions).

  Features:

    - Returns each statistic of each site feature

  `__init__`(site_featurizer, stats='mean', 'std_dev', min_oxi=None, max_oxi=None, covariance=False)
    Args:

      site_featurizer (BaseFeaturizer): a site-based featurizer stats ([str]): list of weighted statistics to compute for each feature.

      > If stats is None, a list is returned for each features that contains the calculated feature for each site in the structure. *Note for nth mode, stat must be ‘n*_mode’; e.g. stat=’2nd_mode’

      min_oxi (int): minimum site oxidation state for inclusion (e.g.,

        zero means metals/cations only)

      max_oxi (int): maximum site oxidation state for inclusion covariance (bool): Whether to compute the covariance of site features

  `citations`()

    Citation(s) and reference(s) for this feature.

    Returns:
      (list) each element should be a string citation,

        ideally in BibTeX format.

  `feature_labels`()

    Generate attribute names.

    Returns:

      ([str]) attribute labels.

  `featurize`(s)

    Main featurizer function, which has to be implemented in any derived featurizer subclass.

    Args:

      x: input data to featurize (type depends on featurizer).

    Returns:

      (list) one or more features.

  `fit`(X, y=None, **fit_kwargs)

    Fit the SiteStatsFeaturizer using the fitting function of the underlying site featurizer. Only applicable if the site featurizer is fittable. See the “.fit()” method of the site_featurizer used to construct the class for more information. Args:

    > X (Iterable): y (optional, Iterable): **fit_kwargs: Keyword arguments used by the fit function of the

    > > site featurizer class.

    Returns:

      self (SiteStatsFeaturizer)

  static `from_preset`(preset, **kwargs)

    Create a SiteStatsFingerprint class according to a preset

    Args:

      preset (str) - Name of preset kwargs - Options for SiteStatsFingerprint

  `implementors`()

    List of implementors of the feature.

    Returns:
      (list) each element should either be a string with author name (e.g.,

        “Anubhav Jain”) or a dictionary with required key “name” and other keys like “email” or “institution” (e.g., {“name”: “Anubhav Jain”, “email”: “ajain@lbl.gov”, “institution”: “LBNL”}).

## matminer.featurizers.structure.symmetry module

Structure featurizers based on symmetry.

class `matminer.featurizers.structure.symmetry.``Dimensionality`(nn_method=<pymatgen.analysis.local_env.CrystalNN object>)

  Bases: `matminer.featurizers.base.BaseFeaturizer`

  Returns dimensionality of structure: 1 means linear chains of atoms OR isolated atoms/no bonds, 2 means layered, 3 means 3D connected structure. This feature is sensitive to bond length tables that you use.

  `__init__`(nn_method=<pymatgen.analysis.local_env.CrystalNN object>)
    Args:
      **nn_method: The nearest neighbor method used to determine atomic

        connectivity.

  `citations`()

    Citation(s) and reference(s) for this feature.

    Returns:
      (list) each element should be a string citation,

        ideally in BibTeX format.

  `feature_labels`()

    Generate attribute names.

    Returns:

      ([str]) attribute labels.

  `featurize`(s)

    Main featurizer function, which has to be implemented in any derived featurizer subclass.

    Args:

      x: input data to featurize (type depends on featurizer).

    Returns:

      (list) one or more features.

  `implementors`()

    List of implementors of the feature.

    Returns:
      (list) each element should either be a string with author name (e.g.,

        “Anubhav Jain”) or a dictionary with required key “name” and other keys like “email” or “institution” (e.g., {“name”: “Anubhav Jain”, “email”: “ajain@lbl.gov”, “institution”: “LBNL”}).

class `matminer.featurizers.structure.symmetry.``GlobalSymmetryFeatures`(desired_features=None)

  Bases: `matminer.featurizers.base.BaseFeaturizer`

  Determines symmetry features, e.g. spacegroup number and crystal system

  Features:

    - Spacegroup number

    - Crystal system (1 of 7)

    - Centrosymmetry (has inversion symmetry)

    - Number of symmetry ops, obtained from the spacegroup

  `__init__`(desired_features=None)

    Initialize self. See help(type(self)) for accurate signature.

  `all_features` = ['spacegroup_num', 'crystal_system', 'crystal_system_int', 'is_centrosymmetric', 'n_symmetry_ops']
  `citations`()

    Citation(s) and reference(s) for this feature.

    Returns:
      (list) each element should be a string citation,

        ideally in BibTeX format.

  `crystal_idx` = {'cubic': 1, 'hexagonal': 2, 'monoclinic': 6, 'orthorhombic': 5, 'tetragonal': 4, 'triclinic': 7, 'trigonal': 3}
  `feature_labels`()

    Generate attribute names.

    Returns:

      ([str]) attribute labels.

  `featurize`(s)

    Main featurizer function, which has to be implemented in any derived featurizer subclass.

    Args:

      x: input data to featurize (type depends on featurizer).

    Returns:

      (list) one or more features.

  `implementors`()

    List of implementors of the feature.

    Returns:
      (list) each element should either be a string with author name (e.g.,

        “Anubhav Jain”) or a dictionary with required key “name” and other keys like “email” or “institution” (e.g., {“name”: “Anubhav Jain”, “email”: “ajain@lbl.gov”, “institution”: “LBNL”}).

## Module contents