aragog.phase

@override
def delta_specific_volume(self) -> npt.NDArray:
    """Difference of specific volume between melt and solid"""
    return self._delta_specific_volume

@override
def heat_capacity(self) -> npt.NDArray:
    """Heat capacity"""
    return self._heat_capacity

@override
def latent_heat(self) -> FloatOrArray:
    """Latent heat of fusion"""
    return self._mixed.latent_heat()

@override
def melt_fraction(self) -> npt.NDArray:
    """Melt fraction"""
    return self._mixed.melt_fraction()

@override
def relative_velocity(self) -> npt.NDArray:
    """Relative velocity between melt and solid"""
    return self._relative_velocity

@override
def set_pressure(self, pressure: npt.NDArray) -> None:
    """Sets pressure and updates quantities that only depend on pressure"""
    super().set_pressure(pressure)
    self._solid.set_pressure(pressure)
    self._liquid.set_pressure(pressure)
    self._mixed.set_pressure(pressure)

@override
def thermal_conductivity(self) -> npt.NDArray:
    """Thermal conductivity"""
    return self._thermal_conductivity

@override
def thermal_expansivity(self) -> npt.NDArray:
    """Thermal expansivity"""
    return self._thermal_expansivity

def viscosity(self) -> npt.NDArray:
    """Viscosity"""
    return self._viscosity

def gradient(self, pressure: npt.NDArray) -> npt.NDArray:
    """Computes the gradient"""
    return np.interp(pressure, self.value[:, 0], self._gradient)

def prepare_data_for_spline(self, data):
    """Ensure your data is on a regular grid for RectBivariateSpline"""
    # Extract x, y, and z values
    x_values = np.unique(data[:, 0])  # Unique pressure values
    y_values = np.unique(data[:, 1])  # Unique temperature values

    # Create a grid for z values
    z_values = np.full((x_values.size, y_values.size), np.nan)

    # Find the indices of the x and y values in the unique arrays
    x_indices = np.searchsorted(x_values, data[:, 0])
    y_indices = np.searchsorted(y_values, data[:, 1])

    # Fill the z_values grid
    z_values[x_indices, y_indices] = data[:, 2]

    return x_values, y_values, z_values

def dTdPs(self) -> npt.NDArray:
    """TODO: Update reference to sphinx: Solomatov (2007), Treatise on Geophysics, Eq. 3.2"""
    dTdPs: npt.NDArray = (
        self.thermal_expansivity() * self.temperature / (self.density() * self.heat_capacity())
    )

    return dTdPs

@override
def delta_specific_volume(self) -> npt.NDArray:
    """Difference of specific volume between melt and solid"""
    return self._delta_specific_volume

@override
def heat_capacity(self) -> FloatOrArray:
    """Heat capacity of the mixed phase :cite:p:`{Equation 4,}SOLO07`"""
    return self._heat_capacity

@override
def latent_heat(self) -> float:
    """Latent heat of fusion"""
    return self._latent_heat

def liquidus(self) -> npt.NDArray:
    """Liquidus"""
    liquidus: npt.NDArray = self._liquidus.eval(self.pressure)
    logger.debug("liquidus = %s", liquidus)

    return liquidus

def liquidus_gradient(self) -> npt.NDArray:
    """Liquidus gradient"""
    return self._liquidus.gradient(self.pressure)

@override
def melt_fraction(self) -> npt.NDArray:
    """Melt fraction of the mixed phase

    The melt fraction is always between zero and one.
    """
    return self._melt_fraction

def melt_fraction_no_clip(self) -> npt.NDArray:
    """Melt fraction without clipping"""
    return self._melt_fraction_no_clip

def porosity(self) -> npt.NDArray:
    """Porosity of the mixed phase, that is the volume fraction occupied by the melt"""
    return self._porosity

@override
def relative_velocity(self) -> npt.NDArray:
    """Relative velocity between melt and solid"""
    return self._relative_velocity

@override
def set_pressure(self, pressure: npt.NDArray) -> None:
    """Sets pressure and updates quantities that only depend on pressure"""
    super().set_pressure(pressure)
    # Sets the temperature of the solid and liquid phases to the appropriate melting curve in
    # order to evaluate mixed properties
    self._solid.set_temperature(self.solidus())
    self._solid.set_pressure(pressure)
    self._liquid.set_temperature(self.liquidus())
    self._liquid.set_pressure(pressure)
    self._delta_density = self._solid.density() - self._liquid.density()
    self._delta_specific_volume = 1.0/self._liquid.density() - 1.0/self._solid.density()
    self._delta_fusion = self.liquidus() - self.solidus()
    # Heat capacity of the mixed phase :cite:p:`{Equation 4,}SOLO07`
    self._heat_capacity = self.latent_heat() / self.delta_fusion()

def set_temperature(self, temperature: npt.NDArray) -> None:
    """Sets the temperature."""
    logger.debug("set_temperature = %s", temperature)
    self.temperature = temperature

def solidus(self) -> npt.NDArray:
    """Solidus"""
    solidus: npt.NDArray = self._solidus.eval(self.pressure)
    logger.debug("solidus = %s", solidus)

    return solidus

def solidus_gradient(self) -> npt.NDArray:
    """Solidus gradient"""
    return self._solidus.gradient(self.pressure)

@classmethod
def from_file(cls, *filenames) -> Self:
    """Parses the parameters in a configuration file(s)

    Args:
        *filenames: Filenames of the configuration data
    """
    parser: ConfigParser = ConfigParser()
    parser.read(*filenames)

    init_dict: dict[str, Any] = {}
    for section_name, dataclass_ in _get_dataclass_from_section_name().items():
        init_dict[section_name] = parser.parse_section(
            using_dataclass=dataclass_, section_name=section_name
        )
    radionuclides: list[_Radionuclide] = []
    for radionuclide_section in cls.radionuclide_sections(parser):
        radionuclide = parser.parse_section(
            using_dataclass=_Radionuclide, section_name=radionuclide_section
        )
        radionuclides.append(radionuclide)

    init_dict["radionuclides"] = radionuclides

    return cls(**init_dict)  # Unpacking gives required arguments so pylint: disable=E1125

@staticmethod
def radionuclide_sections(parser: ConfigParser) -> list[str]:
    """Section names relating to radionuclides

    Sections relating to radionuclides must have the prefix radionuclide_
    """
    return [
        parser[section].name
        for section in parser.sections()
        if section.startswith("radionuclide_")
    ]

def dTdPs(self) -> npt.NDArray:
    """TODO: Update reference to sphinx: Solomatov (2007), Treatise on Geophysics, Eq. 3.2"""
    dTdPs: npt.NDArray = (
        self.thermal_expansivity() * self.temperature / (self.density() * self.heat_capacity())
    )

    return dTdPs

def set_pressure(self, pressure: npt.NDArray) -> None:
    """Sets the pressure."""
    logger.debug("set_pressure = %s", pressure)
    self.pressure = pressure

def set_temperature(self, temperature: npt.NDArray) -> None:
    """Sets the temperature."""
    logger.debug("set_temperature = %s", temperature)
    self.temperature = temperature

def update(self) -> None:
    """Updates quantities to avoid repeat, possibly expensive, calculations."""

def dTdPs(self) -> npt.NDArray:
    """TODO: Update reference to sphinx: Solomatov (2007), Treatise on Geophysics, Eq. 3.2"""
    dTdPs: npt.NDArray = (
        self.thermal_expansivity() * self.temperature / (self.density() * self.heat_capacity())
    )

    return dTdPs

def set_pressure(self, pressure: npt.NDArray) -> None:
    """Sets the pressure."""
    logger.debug("set_pressure = %s", pressure)
    self.pressure = pressure

def set_temperature(self, temperature: npt.NDArray) -> None:
    """Sets the temperature."""
    logger.debug("set_temperature = %s", temperature)
    self.temperature = temperature

def update(self) -> None:
    """Updates quantities to avoid repeat, possibly expensive, calculations."""

def scale_attributes(self, scalings: _ScalingsParameters) -> None:
    """Scales the attributes

    Args:
        scalings: scalings
    """
    self.scalings_ = scalings
    self.latent_heat_of_fusion /= self.scalings_.latent_heat_per_mass
    self.grain_size /= self.scalings_.radius

def scale_attributes(self, scalings: _ScalingsParameters) -> None:
    """Scales the attributes if they are numbers.

    Args:
        scalings: scalings
    """
    self.scalings_ = scalings
    cls_fields: tuple[Field, ...] = fields(self.__class__)
    for field_ in cls_fields:
        value: Any = getattr(self, field_.name)
        try:
            scaling: float = getattr(self.scalings_, field_.name)
            scaled_value = value / scaling
            setattr(self, field_.name, scaled_value)
            logger.info(
                "%s is a number (value = %s, scaling = %s, scaled_value = %s)",
                field_.name,
                value,
                scaling,
                scaled_value,
            )
        except AttributeError:
            logger.info("No scaling found for %s", field_.name)
        except TypeError:
            logger.info(
                "%s is a string (path to a filename) so the data will be scaled later",
                field_.name,
            )