# Source code for pymatgen.analysis.thermochemistry

    # coding: utf-8
    # Copyright (c) Pymatgen Development Team.
    # Distributed under the terms of the MIT License.

    """
    A module to perform experimental thermochemical data analysis.
    """

    __author__ = "Shyue Ping Ong"
    __copyright__ = "Copyright 2012, The Materials Project"
    __version__ = "0.1"
    __maintainer__ = "Shyue Ping Ong"
    __email__ = "shyuep@gmail.com"
    __date__ = "Jun 10, 2012"

    from pymatgen.core.composition import Composition

    STANDARD_TEMP = 298.0

    class ThermoData:
        """
        A object container for an experimental Thermochemical Data.
        """
        def __init__(self, data_type, cpdname, phaseinfo, formula, value, ref="",
                     method="", temp_range=(298, 298), uncertainty=None):
            """
            Args:
                data_type: The thermochemical data type. Should be one of the
                    following: fH - Formation enthalpy, S - Entropy,
                    A, B, C, D, E, F, G, H - variables for use in the various
                    quations for generating formation enthaplies or Cp at
                    various temperatures.
                cpdname (str): A name for the compound. For example, hematite for
                    Fe2O3.
                phaseinfo (str): Denoting the phase. For example, "solid", "liquid",
                    "gas" or "tetragonal".
                formula (str): A proper string formula, e.g., Fe2O3
                value (float): The value of the data.
                ref (str): A reference, if any, for the data.
                method (str): The method by which the data was determined,
                    if available.
                temp_range ([float, float]): Temperature range of validity for the
                    data in Kelvin. Defaults to 298 K only.
                uncertainty (float):
                    An uncertainty for the data, if available.
            """
            self.type = data_type
            self.formula = formula
            self.composition = Composition(self.formula)
            self.reduced_formula = self.composition.reduced_formula
            self.compound_name = cpdname
            self.phaseinfo = phaseinfo
            self.value = value
            self.temp_range = temp_range
            self.method = method
            self.ref = ref
            self.uncertainty = uncertainty

        @classmethod
        def from_dict(cls, d):
            """
            Args:
                d (dict): Dict representation

            Returns:
                ThermoData
            """
            return ThermoData(d["type"], d["compound_name"],
                              d["phaseinfo"], d["formula"],
                              d["value"], d["ref"], d["method"],
                              d["temp_range"], d.get("uncertainty", None))

        def as_dict(self):
            """
            Returns: MSONable dict
            """
            return {"@module": self.__class__.__module__,
                    "@class": self.__class__.__name__, "type": self.type,
                    "formula": self.formula, "compound_name": self.compound_name,
                    "phaseinfo": self.phaseinfo, "value": self.value,
                    "temp_range": self.temp_range, "method": self.method,
                    "ref": self.ref, "uncertainty": self.uncertainty}

        def __repr__(self):
            props = ["formula", "compound_name", "phaseinfo", "type", "temp_range",
                     "value", "method", "ref", "uncertainty"]
            output = ["{} : {}".format(k, getattr(self, k)) for k in props]
            return "\n".join(output)

        def __str__(self):
            return "{}_{}_{} = {}, Valid T : {}, Ref = {}".format(
                self.type, self.formula, self.phaseinfo, self.value,
                self.temp_range, self.ref
            )