Struct FusionProps 

pub struct FusionProps {
    pub melting_point: Temperature,
    pub latent_heat: LatentHeat,
    pub liquid: Option<ThermalProps>,
}

What it takes to melt it.

One temperature, and the substances that do not have one

A pure substance melts at a temperature; an alloy, a polymer and a rock melt over a range, and this cannot say so. That is a real restriction rather than a simplification to be embarrassed about — the sharp-interface problem is the one with an exact solution to check against, and a mushy range is a different model with a different closed form.

So this is right for water, for a pure metal and for a paraffin phase-change material sold on its plateau. It is wrong for solder, and a domain given it for solder will put the whole latent heat on one temperature instead of spreading it over the twenty kelvin it really occupies.

Fields

melting_point: Temperature

The temperature at which it changes phase, and holds there while it does.

latent_heat: LatentHeat

The heat one kilogram absorbs melting, at no change in temperature.

liquid: Option<ThermalProps>

What the liquid conducts and holds, if it differs from the solid.

None is the one-phase model: the liquid is taken to have the solid’s conductivity and specific heat. That is not a simplification to apologise for — it is exact whenever the liquid sits at the melting point, because then no heat flows through it whatever its properties are, and it is the case Stefan’s original problem and Neumann’s solution are about.

It is wrong the moment the liquid is superheated, and wrong by a lot. Water conducts a quarter of what ice does and holds twice as much, and a liquid 20 K above freezing slows a front by 16% — from 15.85 mm to 13.33 mm at 900 s. That is far more than any discretisation error, so the one-phase answer is not a slightly worse two-phase answer.

The same type as the solid’s, because a phase is a thing that conducts and holds heat and there is no reason to describe it differently. expansion and emissivity are carried and unused by conduction; give the liquid’s if they are known.

Implementations

impl FusionProps

pub fn new(melting_point: Temperature, latent_heat: LatentHeat) -> FusionProps

A one-phase description: a melting point and a latent heat, and no separate liquid.

Because adding liquid broke every literal, twice over

Substance gained fusion and every struct literal outside this crate stopped compiling; builders were added so the next field would not do it again. Then FusionProps gained liquid and did exactly that one level down, to the tests written the week before.

So this pair exists for the same reason Substance::with_* does. A field added below here costs nothing to a caller who went through new and with_liquid.

pub fn with_liquid(self, liquid: ThermalProps) -> FusionProps

Name the liquid phase’s conductivity and specific heat, making a block two-phase.

Read liquid before reaching for this: it is the right model for a superheated liquid and it costs first-order accuracy at the interface, so it is not a strictly better version of the one-phase model.

pub fn sensible_equivalent(&self, specific_heat: SpecificHeat) -> Temperature

How many kelvin of sensible heat the phase change is worth: L / c_p.

The reciprocal of the Stefan number, and the number that says whether latent heat matters at all in a given problem. For ice it is 163 K, so a freezing front driven by a 10 K undercooling is overwhelmingly a latent-heat problem and only incidentally a conduction one.

Trait Implementations

impl Clone for FusionProps

fn clone(&self) -> FusionProps

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for FusionProps

impl Debug for FusionProps

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FusionProps

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for FusionProps

fn eq(&self, other: &FusionProps) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for FusionProps

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for FusionProps