def search(
self,
band_gap: Optional[Tuple[float, float]] = None,
chemsys: Optional[Union[str, List[str]]] = None,
crystal_system: Optional[CrystalSystem] = None,
density: Optional[Tuple[float, float]] = None,
deprecated: Optional[bool] = None,
e_electronic: Optional[Tuple[float, float]] = None,
e_ionic: Optional[Tuple[float, float]] = None,
e_total: Optional[Tuple[float, float]] = None,
efermi: Optional[Tuple[float, float]] = None,
elastic_anisotropy: Optional[Tuple[float, float]] = None,
elements: Optional[List[str]] = None,
energy_above_hull: Optional[Tuple[float, float]] = None,
equilibrium_reaction_energy: Optional[Tuple[float, float]] = None,
exclude_elements: Optional[List[str]] = None,
formation_energy: Optional[Tuple[float, float]] = None,
formula: Optional[Union[str, List[str]]] = None,
g_reuss: Optional[Tuple[float, float]] = None,
g_voigt: Optional[Tuple[float, float]] = None,
g_vrh: Optional[Tuple[float, float]] = None,
has_props: Optional[List[HasProps]] = None,
has_reconstructed: Optional[bool] = None,
is_gap_direct: Optional[bool] = None,
is_metal: Optional[bool] = None,
is_stable: Optional[bool] = None,
k_reuss: Optional[Tuple[float, float]] = None,
k_voigt: Optional[Tuple[float, float]] = None,
k_vrh: Optional[Tuple[float, float]] = None,
magnetic_ordering: Optional[Ordering] = None,
material_ids: Optional[List[MPID]] = None,
n: Optional[Tuple[float, float]] = None,
num_elements: Optional[Tuple[int, int]] = None,
num_sites: Optional[Tuple[int, int]] = None,
num_magnetic_sites: Optional[Tuple[int, int]] = None,
num_unique_magnetic_sites: Optional[Tuple[int, int]] = None,
piezoelectric_modulus: Optional[Tuple[float, float]] = None,
poisson_ratio: Optional[Tuple[float, float]] = None,
possible_species: Optional[List[str]] = None,
shape_factor: Optional[Tuple[float, float]] = None,
spacegroup_number: Optional[int] = None,
spacegroup_symbol: Optional[str] = None,
surface_energy_anisotropy: Optional[Tuple[float, float]] = None,
theoretical: Optional[bool] = None,
total_energy: Optional[Tuple[float, float]] = None,
total_magnetization: Optional[Tuple[float, float]] = None,
total_magnetization_normalized_formula_units: Optional[
Tuple[float, float]
] = None,
total_magnetization_normalized_vol: Optional[Tuple[float, float]] = None,
uncorrected_energy: Optional[Tuple[float, float]] = None,
volume: Optional[Tuple[float, float]] = None,
weighted_surface_energy: Optional[Tuple[float, float]] = None,
weighted_work_function: Optional[Tuple[float, float]] = None,
sort_fields: Optional[List[str]] = None,
num_chunks: Optional[int] = None,
chunk_size: int = 1000,
all_fields: bool = True,
fields: Optional[List[str]] = None,
):
"""
Query core data using a variety of search criteria.
Arguments:
band_gap (Tuple[float,float]): Minimum and maximum band gap in eV to consider.
chemsys (str, List[str]): A chemical system, list of chemical systems
(e.g., Li-Fe-O, Si-*, [Si-O, Li-Fe-P]), or single formula (e.g., Fe2O3, Si*).
crystal_system (CrystalSystem): Crystal system of material.
density (Tuple[float,float]): Minimum and maximum density to consider.
deprecated (bool): Whether the material is tagged as deprecated.
e_electronic (Tuple[float,float]): Minimum and maximum electronic dielectric constant to consider.
e_ionic (Tuple[float,float]): Minimum and maximum ionic dielectric constant to consider.
e_total (Tuple[float,float]): Minimum and maximum total dielectric constant to consider.
efermi (Tuple[float,float]): Minimum and maximum fermi energy in eV to consider.
elastic_anisotropy (Tuple[float,float]): Minimum and maximum value to consider for the elastic anisotropy.
elements (List[str]): A list of elements.
energy_above_hull (Tuple[int,int]): Minimum and maximum energy above the hull in eV/atom to consider.
equilibrium_reaction_energy (Tuple[float,float]): Minimum and maximum equilibrium reaction energy in
eV/atom to consider.
exclude_elements (List(str)): List of elements to exclude.
formation_energy (Tuple[int,int]): Minimum and maximum formation energy in eV/atom to consider.
formula (str, List[str]): A formula including anonomyzed formula
or wild cards (e.g., Fe2O3, ABO3, Si*). A list of chemical formulas can also be passed
(e.g., [Fe2O3, ABO3]).
g_reuss (Tuple[float,float]): Minimum and maximum value in GPa to consider for the Reuss average
of the shear modulus.
g_voigt (Tuple[float,float]): Minimum and maximum value in GPa to consider for the Voigt average
of the shear modulus.
g_vrh (Tuple[float,float]): Minimum and maximum value in GPa to consider for the Voigt-Reuss-Hill
average of the shear modulus.
has_props: (List[HasProps]): The calculated properties available for the material.
has_reconstructed (bool): Whether the entry has any reconstructed surfaces.
is_gap_direct (bool): Whether the material has a direct band gap.
is_metal (bool): Whether the material is considered a metal.
k_reuss (Tuple[float,float]): Minimum and maximum value in GPa to consider for the Reuss average
of the bulk modulus.
k_voigt (Tuple[float,float]): Minimum and maximum value in GPa to consider for the Voigt average
of the bulk modulus.
k_vrh (Tuple[float,float]): Minimum and maximum value in GPa to consider for the Voigt-Reuss-Hill
average of the bulk modulus.
magnetic_ordering (Ordering): Magnetic ordering of the material.
material_ids (List[MPID]): List of Materials Project IDs to return data for.
n (Tuple[float,float]): Minimum and maximum refractive index to consider.
num_elements (Tuple[int,int]): Minimum and maximum number of elements to consider.
num_sites (Tuple[int,int]): Minimum and maximum number of sites to consider.
num_magnetic_sites (Tuple[int,int]): Minimum and maximum number of magnetic sites to consider.
num_unique_magnetic_sites (Tuple[int,int]): Minimum and maximum number of unique magnetic sites to consider.
piezoelectric_modulus (Tuple[float,float]): Minimum and maximum piezoelectric modulus to consider.
poisson_ratio (Tuple[float,float]): Minimum and maximum value to consider for Poisson's ratio.
possible_species (List(str)): List of element symbols appended with oxidation states. (e.g. Cr2+,O2-)
shape_factor (Tuple[float,float]): Minimum and maximum shape factor values to consider.
spacegroup_number (int): Space group number of material.
spacegroup_symbol (str): Space group symbol of the material in international short symbol notation.
surface_energy_anisotropy (Tuple[float,float]): Minimum and maximum surface energy anisotropy values
to consider.
theoretical: (bool): Whether the material is theoretical.
total_energy (Tuple[int,int]): Minimum and maximum corrected total energy in eV/atom to consider.
total_magnetization (Tuple[float,float]): Minimum and maximum total magnetization values to consider.
total_magnetization_normalized_formula_units (Tuple[float,float]): Minimum and maximum total magnetization
values normalized by formula units to consider.
total_magnetization_normalized_vol (Tuple[float,float]): Minimum and maximum total magnetization values
normalized by volume to consider.
uncorrected_energy (Tuple[int,int]): Minimum and maximum uncorrected total energy in eV/atom to consider.
volume (Tuple[float,float]): Minimum and maximum volume to consider.
weighted_surface_energy (Tuple[float,float]): Minimum and maximum weighted surface energy
in J/m² to consider.
weighted_work_function (Tuple[float,float]): Minimum and maximum weighted work function in eV to consider.
sort_fields (List[str]): Fields used to sort results. Prefixing with '-' will sort in descending order.
num_chunks (int): Maximum number of chunks of data to yield. None will yield all possible.
chunk_size (int): Number of data entries per chunk.
all_fields (bool): Whether to return all fields in the document. Defaults to True.
fields (List[str]): List of fields in SearchDoc to return data for.
Default is material_id if all_fields is False.
Returns:
([SummaryDoc]) List of SummaryDoc documents
"""
query_params = defaultdict(dict) # type: dict
min_max_name_dict = {
"total_energy": "energy_per_atom",
"formation_energy": "formation_energy_per_atom",
"energy_above_hull": "energy_above_hull",
"uncorrected_energy": "uncorrected_energy_per_atom",
"equilibrium_reaction_energy": "equilibrium_reaction_energy_per_atom",
"nsites": "nsites",
"volume": "volume",
"density": "density",
"band_gap": "band_gap",
"efermi": "efermi",
"total_magnetization": "total_magnetization",
"total_magnetization_normalized_vol": "total_magnetization_normalized_vol",
"total_magnetization_normalized_formula_units": "total_magnetization_normalized_formula_units",
"num_magnetic_sites": "num_magnetic_sites",
"num_unique_magnetic_sites": "num_unique_magnetic_sites",
"k_voigt": "k_voigt",
"k_reuss": "k_reuss",
"k_vrh": "k_vrh",
"g_voigt": "g_voigt",
"g_reuss": "g_reuss",
"g_vrh": "g_vrh",
"elastic_anisotropy": "universal_anisotropy",
"poisson_ratio": "homogeneous_poisson",
"e_total": "e_total",
"e_ionic": "e_ionic",
"e_electronic": "e_electronic",
"n": "n",
"num_sites": "nsites",
"num_elements": "nelements",
"piezoelectric_modulus": "e_ij_max",
"weighted_surface_energy": "weighted_surface_energy",
"weighted_work_function": "weighted_work_function",
"surface_energy_anisotropy": "surface_anisotropy",
"shape_factor": "shape_factor",
}
for param, value in locals().items():
if param in min_max_name_dict and value:
query_params.update(
{
"{}_min".format(min_max_name_dict[param]): value[0],
"{}_max".format(min_max_name_dict[param]): value[1],
}
)
if material_ids:
query_params.update({"material_ids": ",".join(validate_ids(material_ids))})
if deprecated is not None:
query_params.update({"deprecated": deprecated})
if formula:
if isinstance(formula, str):
formula = [formula]
query_params.update({"formula": ",".join(formula)})
if chemsys:
if isinstance(chemsys, str):
chemsys = [chemsys]
query_params.update({"chemsys": ",".join(chemsys)})
if elements:
query_params.update({"elements": ",".join(elements)})
if exclude_elements is not None:
query_params.update({"exclude_elements": ",".join(exclude_elements)})
if possible_species is not None:
query_params.update({"possible_species": ",".join(possible_species)})
query_params.update(
{
"crystal_system": crystal_system,
"spacegroup_number": spacegroup_number,
"spacegroup_symbol": spacegroup_symbol,
}
)
if is_stable is not None:
query_params.update({"is_stable": is_stable})
if is_gap_direct is not None:
query_params.update({"is_gap_direct": is_gap_direct})
if is_metal is not None:
query_params.update({"is_metal": is_metal})
if magnetic_ordering:
query_params.update({"ordering": magnetic_ordering.value})
if has_reconstructed is not None:
query_params.update({"has_reconstructed": has_reconstructed})
if has_props:
query_params.update({"has_props": ",".join([i.value for i in has_props])})
if theoretical is not None:
query_params.update({"theoretical": theoretical})
if sort_fields:
query_params.update({"_sort_fields": ",".join([s.strip() for s in sort_fields])})
query_params = {entry: query_params[entry] for entry in query_params if query_params[entry] is not None}
return super()._search(
num_chunks=num_chunks,
chunk_size=chunk_size,
all_fields=all_fields,
fields=fields,
**query_params
)
def get_data_by_id(
self,
document_id: str,
fields: Optional[List[str]] = None,
) -> T:
"""
Query the endpoint for a single document.
Arguments:
document_id: the unique key for this kind of document, typically a task_id
fields: list of fields to return, by default will return all fields
Returns:
A single document.
"""
if document_id is None:
raise ValueError(
"Please supply a specific ID. You can use the query method to find "
"ids of interest.")
if self.primary_key in ["material_id", "task_id"]:
validate_ids([document_id])
if fields is None:
criteria = {"_all_fields": True, "_limit": 1} # type: dict
else:
criteria = {"_limit": 1}
if isinstance(fields, str): # pragma: no cover
fields = (fields, )
results = [] # type: List
try:
results = self._query_resource_data(
criteria=criteria,
fields=fields,
suburl=document_id, # type: ignore
)
except MPRestError:
if self.primary_key == "material_id":
# see if the material_id has changed, perhaps a task_id was supplied
# this should likely be re-thought
from mp_api import MPRester
with MPRester(api_key=self.api_key,
endpoint=self.base_endpoint) as mpr:
new_document_id = mpr.get_materials_id_from_task_id(
document_id)
if new_document_id is not None:
warnings.warn(
f"Document primary key has changed from {document_id} to {new_document_id}, "
f"returning data for {new_document_id} in {self.suffix} route. "
)
document_id = new_document_id
results = self._query_resource_data(
criteria=criteria,
fields=fields,
suburl=document_id, # type: ignore
)
if not results:
raise MPRestError(f"No result for record {document_id}.")
elif len(results) > 1: # pragma: no cover
raise ValueError(
f"Multiple records for {document_id}, this shouldn't happen. Please report as a bug."
)
else:
return results[0]
def search(
self,
chemsys: Optional[str] = None,
gb_plane: Optional[List[str]] = None,
gb_energy: Optional[Tuple[float, float]] = None,
material_ids: Optional[List[str]] = None,
pretty_formula: Optional[str] = None,
rotation_axis: Optional[List[str]] = None,
rotation_angle: Optional[Tuple[float, float]] = None,
separation_energy: Optional[Tuple[float, float]] = None,
sigma: Optional[int] = None,
type: Optional[GBTypeEnum] = None,
sort_fields: Optional[List[str]] = None,
num_chunks: Optional[int] = None,
chunk_size: int = 1000,
all_fields: bool = True,
fields: Optional[List[str]] = None,
):
"""
Query grain boundary docs using a variety of search criteria.
Arguments:
chemsys (str): Dash-delimited string of elements in the material.
gb_plane(List[str]): The Miller index of grain boundary plane. e.g., [1, 1, 1]
gb_energy (Tuple[float,float]): Minimum and maximum grain boundary energy in J/m³ to consider.
material_ids (List[str]): List of Materials Project IDs to query with.
pretty_formula (str): Formula of the material.
rotation_angle (Tuple[float,float]): Minimum and maximum rotation angle in degrees to consider.
rotation_axis(List[str]): The Miller index of rotation axis. e.g., [1, 0, 0], [1, 1, 0], and [1, 1, 1]
sigma (int): Sigma value of grain boundary.
separation_energy (Tuple[float,float]): Minimum and maximum work of separation energy in J/m³ to consider.
sigma (int): Sigma value of the boundary.
type (GBTypeEnum): Grain boundary type.
sort_fields (List[str]): Fields used to sort results. Prefix with '-' to sort in descending order.
num_chunks (int): Maximum number of chunks of data to yield. None will yield all possible.
chunk_size (int): Number of data entries per chunk.
all_fields (bool): Whether to return all fields in the document. Defaults to True.
fields (List[str]): List of fields in GrainBoundaryDoc to return data for.
Default is material_id and last_updated if all_fields is False.
Returns:
([GrainBoundaryDoc]) List of grain boundary documents
"""
query_params = defaultdict(dict) # type: dict
if material_ids:
query_params.update(
{"task_ids": ",".join(validate_ids(material_ids))})
if gb_plane:
query_params.update(
{"gb_plane": ",".join([str(n) for n in gb_plane])})
if gb_energy:
query_params.update({
"gb_energy_min": gb_energy[0],
"gb_energy_max": gb_energy[1]
})
if separation_energy:
query_params.update({
"w_sep_min": separation_energy[0],
"w_sep_max": separation_energy[1]
})
if rotation_angle:
query_params.update({
"rotation_angle_min": rotation_angle[0],
"rotation_angle_max": rotation_angle[1],
})
if rotation_axis:
query_params.update(
{"rotation_axis": ",".join([str(n) for n in rotation_axis])})
if sigma:
query_params.update({"sigma": sigma})
if type:
query_params.update({"type": type.value})
if chemsys:
query_params.update({"chemsys": chemsys})
if pretty_formula:
query_params.update({"pretty_formula": pretty_formula})
if sort_fields:
query_params.update(
{"_sort_fields": ",".join([s.strip() for s in sort_fields])})
query_params = {
entry: query_params[entry]
for entry in query_params if query_params[entry] is not None
}
return super()._search(num_chunks=num_chunks,
chunk_size=chunk_size,
all_fields=all_fields,
fields=fields,
**query_params)
def search(
self,
chemsys: Optional[Union[str, List[str]]] = None,
crystal_system: Optional[CrystalSystem] = None,
density: Optional[Tuple[float, float]] = None,
deprecated: Optional[bool] = False,
elements: Optional[List[str]] = None,
exclude_elements: Optional[List[str]] = None,
formula: Optional[Union[str, List[str]]] = None,
num_elements: Optional[Tuple[int, int]] = None,
num_sites: Optional[Tuple[int, int]] = None,
spacegroup_number: Optional[int] = None,
spacegroup_symbol: Optional[str] = None,
task_ids: Optional[List[str]] = None,
volume: Optional[Tuple[float, float]] = None,
sort_fields: Optional[List[str]] = None,
num_chunks: Optional[int] = None,
chunk_size: int = 1000,
all_fields: bool = True,
fields: Optional[List[str]] = None,
):
"""
Query core material docs using a variety of search criteria.
Arguments:
chemsys (str, List[str]): A chemical system or list of chemical systems
(e.g., Li-Fe-O, Si-*, [Si-O, Li-Fe-P]).
crystal_system (CrystalSystem): Crystal system of material.
density (Tuple[float,float]): Minimum and maximum density to consider.
deprecated (bool): Whether the material is tagged as deprecated.
elements (List[str]): A list of elements.
exclude_elements (List[str]): A list of elements to exclude.
formula (str, List[str]): A formula including anonomyzed formula
or wild cards (e.g., Fe2O3, ABO3, Si*). A list of chemical formulas can also be passed
(e.g., [Fe2O3, ABO3]).
num_elements (Tuple[int,int]): Minimum and maximum number of elements to consider.
num_sites (Tuple[int,int]): Minimum and maximum number of sites to consider.
spacegroup_number (int): Space group number of material.
spacegroup_symbol (str): Space group symbol of the material in international short symbol notation.
task_ids (List[str]): List of Materials Project IDs to return data for.
volume (Tuple[float,float]): Minimum and maximum volume to consider.
sort_fields (List[str]): Fields used to sort results. Prefix with '-' to sort in descending order.
num_chunks (int): Maximum number of chunks of data to yield. None will yield all possible.
chunk_size (int): Number of data entries per chunk.
all_fields (bool): Whether to return all fields in the document. Defaults to True.
fields (List[str]): List of fields in MaterialsCoreDoc to return data for.
Default is material_id, last_updated, and formula_pretty if all_fields is False.
Returns:
([MaterialsDoc]) List of material documents
"""
query_params = {"deprecated": deprecated} # type: dict
if formula:
if isinstance(formula, str):
formula = [formula]
query_params.update({"formula": ",".join(formula)})
if chemsys:
if isinstance(chemsys, str):
chemsys = [chemsys]
query_params.update({"chemsys": ",".join(chemsys)})
if elements:
query_params.update({"elements": ",".join(elements)})
if exclude_elements:
query_params.update(
{"exclude_elements": ",".join(exclude_elements)})
if task_ids:
query_params.update({"task_ids": ",".join(validate_ids(task_ids))})
query_params.update({
"crystal_system": crystal_system,
"spacegroup_number": spacegroup_number,
"spacegroup_symbol": spacegroup_symbol,
})
if num_sites:
query_params.update({
"nsites_min": num_sites[0],
"nsites_max": num_sites[1]
})
if num_elements:
query_params.update({
"nelements_min": num_elements[0],
"nelements_max": num_elements[1]
})
if volume:
query_params.update({
"volume_min": volume[0],
"volume_max": volume[1]
})
if density:
query_params.update({
"density_min": density[0],
"density_max": density[1]
})
if sort_fields:
query_params.update(
{"_sort_fields": ",".join([s.strip() for s in sort_fields])})
query_params = {
entry: query_params[entry]
for entry in query_params if query_params[entry] is not None
}
return super()._search(num_chunks=num_chunks,
chunk_size=chunk_size,
all_fields=all_fields,
fields=fields,
**query_params)
def search(
self,
edge: Optional[Edge] = None,
absorbing_element: Optional[Element] = None,
formula: Optional[str] = None,
chemsys: Optional[Union[str, List[str]]] = None,
elements: Optional[List[str]] = None,
material_ids: Optional[List[str]] = None,
spectrum_type: Optional[Type] = None,
sort_fields: Optional[List[str]] = None,
num_chunks: Optional[int] = None,
chunk_size: int = 1000,
all_fields: bool = True,
fields: Optional[List[str]] = None,
):
"""
Query core XAS docs using a variety of search criteria.
Arguments:
edge (Edge): The absorption edge (e.g. K, L2, L3, L2,3).
absorbing_element (Element): The absorbing element.
formula (str): A formula including anonomyzed formula
or wild cards (e.g., Fe2O3, ABO3, Si*).
chemsys (str, List[str]): A chemical system or list of chemical systems
(e.g., Li-Fe-O, Si-*, [Si-O, Li-Fe-P]).
elements (List[str]): A list of elements.
material_ids (List[str]): List of Materials Project IDs to return data for.
spectrum_type (Type): Spectrum type (e.g. EXAFS, XAFS, or XANES).
sort_fields (List[str]): Fields used to sort results. Prefix with '-' to sort in descending order.
num_chunks (int): Maximum number of chunks of data to yield. None will yield all possible.
chunk_size (int): Number of data entries per chunk.
all_fields (bool): Whether to return all fields in the document. Defaults to True.
fields (List[str]): List of fields in MaterialsCoreDoc to return data for.
Default is material_id, last_updated, and formula_pretty if all_fields is False.
Returns:
([MaterialsDoc]) List of material documents
"""
query_params = {}
if edge:
query_params.update({"edge": edge})
if absorbing_element:
query_params.update(
{
"absorbing_element": str(absorbing_element.symbol)
if type(absorbing_element) == Element
else absorbing_element
}
)
if spectrum_type:
query_params.update({"spectrum_type": spectrum_type})
if formula:
query_params.update({"formula": formula})
if chemsys:
if isinstance(chemsys, str):
chemsys = [chemsys]
query_params.update({"chemsys": ",".join(chemsys)})
if elements:
query_params.update({"elements": ",".join(elements)})
if material_ids is not None:
query_params["material_ids"] = ",".join(validate_ids(material_ids))
if sort_fields:
query_params.update(
{"_sort_fields": ",".join([s.strip() for s in sort_fields])}
)
return super()._search(
num_chunks=num_chunks,
chunk_size=chunk_size,
all_fields=all_fields,
fields=fields,
**query_params,
)
def search(
self,
chemsys: Optional[Union[str, List[str]]] = None,
energy_above_hull: Optional[Tuple[float, float]] = None,
equilibrium_reaction_energy: Optional[Tuple[float, float]] = None,
formation_energy: Optional[Tuple[float, float]] = None,
formula: Optional[Union[str, List[str]]] = None,
is_stable: Optional[bool] = None,
material_ids: Optional[List[str]] = None,
num_elements: Optional[Tuple[int, int]] = None,
total_energy: Optional[Tuple[float, float]] = None,
uncorrected_energy: Optional[Tuple[float, float]] = None,
sort_fields: Optional[List[str]] = None,
num_chunks: Optional[int] = None,
chunk_size: int = 1000,
all_fields: bool = True,
fields: Optional[List[str]] = None,
):
"""
Query core material docs using a variety of search criteria.
Arguments:
chemsys (str, List[str]): A chemical system or list of chemical systems
(e.g., Li-Fe-O, Si-*, [Si-O, Li-Fe-P]).
energy_above_hull (Tuple[float,float]): Minimum and maximum energy above the hull in eV/atom to consider.
equilibrium_reaction_energy (Tuple[float,float]): Minimum and maximum equilibrium reaction energy
in eV/atom to consider.
formation_energy (Tuple[float,float]): Minimum and maximum formation energy in eV/atom to consider.
formula (str, List[str]): A formula including anonomyzed formula
or wild cards (e.g., Fe2O3, ABO3, Si*). A list of chemical formulas can also be passed
(e.g., [Fe2O3, ABO3]).
is_stable (bool): Whether the material is stable.
material_ids (List[str]): List of Materials Project IDs to return data for.
num_elements (Tuple[int,int]): Minimum and maximum number of elements in the material to consider.
total_energy (Tuple[float,float]): Minimum and maximum corrected total energy in eV/atom to consider.
uncorrected_energy (Tuple[float,float]): Minimum and maximum uncorrected total
energy in eV/atom to consider.
sort_fields (List[str]): Fields used to sort results. Prefix with '-' to sort in descending order.
num_chunks (int): Maximum number of chunks of data to yield. None will yield all possible.
chunk_size (int): Number of data entries per chunk.
all_fields (bool): Whether to return all fields in the document. Defaults to True.
fields (List[str]): List of fields in ThermoDoc to return data for.
Default is material_id and last_updated if all_fields is False.
Returns:
([ThermoDoc]) List of thermo documents
"""
query_params = defaultdict(dict) # type: dict
if formula:
if isinstance(formula, str):
formula = [formula]
query_params.update({"formula": ",".join(formula)})
if chemsys:
if isinstance(chemsys, str):
chemsys = [chemsys]
query_params.update({"chemsys": ",".join(chemsys)})
if material_ids:
query_params.update(
{"material_ids": ",".join(validate_ids(material_ids))})
if num_elements:
query_params.update({
"nelements_min": num_elements[0],
"nelements_max": num_elements[1]
})
if is_stable is not None:
query_params.update({"is_stable": is_stable})
if sort_fields:
query_params.update(
{"_sort_fields": ",".join([s.strip() for s in sort_fields])})
name_dict = {
"total_energy": "energy_per_atom",
"formation_energy": "formation_energy_per_atom",
"energy_above_hull": "energy_above_hull",
"equilibrium_reaction_energy":
"equilibrium_reaction_energy_per_atom",
"uncorrected_energy": "uncorrected_energy_per_atom",
}
for param, value in locals().items():
if "energy" in param and value:
query_params.update({
"{}_min".format(name_dict[param]):
value[0],
"{}_max".format(name_dict[param]):
value[1],
})
query_params = {
entry: query_params[entry]
for entry in query_params if query_params[entry] is not None
}
return super()._search(
num_chunks=num_chunks,
chunk_size=chunk_size,
all_fields=all_fields,
fields=fields,
**query_params,
)