return [i.kg for i in self.Chemicals]<EOL>

r'''Pure component thermal conductivies of the chemicals in the mixture
        in the gas phase at its current temperature and pressure, in units of
        [W/m/K].

        Examples
        --------
        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5], T=320).kgs
        [0.011865404482987936, 0.010981336502491088]


return [i.sigma for i in self.Chemicals]<EOL>

r'''Pure component surface tensions of the chemicals in the mixture at
        its current temperature, in units of [N/m].

        Examples
        --------
        >>> Mixture(['benzene', 'toluene'], ws=[0.5, 0.5], T=320).sigmas
        [0.02533469712937521, 0.025254723406585546]


return [i.permittivity for i in self.Chemicals]<EOL>

r'''Pure component relative permittivities of the chemicals in the
        mixture at its current temperature, [dimensionless].

        Examples
        --------
        >>> Mixture(['benzene', 'hexane'], ws=[0.5, 0.5], T=320).permittivites
        [2.23133472, 1.8508128]


return [i.JTl for i in self.Chemicals]<EOL>

r'''Pure component Joule Thomson coefficients of the chemicals in the
        mixture in the liquid phase at its current temperature and pressure, in
        units of [K/Pa].

        .. math::
            \mu_{JT} = \left(\frac{\partial T}{\partial P}\right)_H = \frac{1}{C_p}
            \left[T \left(\frac{\partial V}{\partial T}\right)_P - V\right]
            = \frac{V}{C_p}\left(\beta T-1\right)

        Examples
        --------
        >>> Mixture(['benzene', 'hexane'], ws=[0.5, 0.5], T=320).JTls
        [-3.8633730709853161e-07, -3.464395792560331e-07]


return [i.JTg for i in self.Chemicals]<EOL>

r'''Pure component Joule Thomson coefficients of the chemicals in the
        mixture in the gas phase at its current temperature and pressure, in
        units of [K/Pa].

        .. math::
            \mu_{JT} = \left(\frac{\partial T}{\partial P}\right)_H = \frac{1}{C_p}
            \left[T \left(\frac{\partial V}{\partial T}\right)_P - V\right]
            = \frac{V}{C_p}\left(\beta T-1\right)

        Examples
        --------
        >>> Mixture(['benzene', 'hexane'], ws=[0.5, 0.5], T=320).JTgs
        [6.0940046688790938e-05, 4.1290005523287549e-05]


return [i.nul for i in self.Chemicals]<EOL>

r'''Pure component kinematic viscosities of the liquid phase of the
        chemicals in the mixture at its current temperature and pressure, in
        units of [m^2/s].

        .. math::
            \nu = \frac{\mu}{\rho}

        Examples
        --------
        >>> Mixture(['benzene', 'hexane'], ws=[0.5, 0.5], T=320).nuls
        [5.357870271650772e-07, 3.8127962283230277e-07]


r'''Pure component kinematic viscosities of the gas phase of the
        chemicals in the mixture at its current temperature and pressure, in
        units of [m^2/s].

        .. math::
            \nu = \frac{\mu}{\rho}

        Examples
        --------
        >>> Mixture(['benzene', 'hexane'], ws=[0.5, 0.5], T=320).nugs
        [5.357870271650772e-07, 3.8127962283230277e-07]


return [i.alphal for i in self.Chemicals]<EOL>

r'''Pure component thermal diffusivities of the chemicals in the
        mixture in the liquid phase at the current temperature and pressure, in
        units of [m^2/s].

        .. math::
            \alpha = \frac{k}{\rho Cp}

        Examples
        --------
        >>> Mixture(['benzene', 'hexane'], ws=[0.5, 0.5], T=320).alphals
        [8.732683564481583e-08, 7.57355434073289e-08]


return [i.alphag for i in self.Chemicals]<EOL>

r'''Pure component thermal diffusivities of the chemicals in the
        mixture in the gas phase at the current temperature and pressure, in
        units of [m^2/s].

        .. math::
            \alpha = \frac{k}{\rho Cp}

        Examples
        --------
        >>> Mixture(['benzene', 'hexane'], ws=[0.5, 0.5], T=320).alphags
        [3.3028044028118324e-06, 2.4412958544059014e-06]


return [i.Prl for i in self.Chemicals]<EOL>

r'''Pure component Prandtl numbers of the liquid phase of the chemicals
        in the mixture at its current temperature and pressure, [dimensionless].

        .. math::
            Pr = \frac{C_p \mu}{k}

        Examples
        --------
        >>> Mixture(['benzene', 'hexane'], ws=[0.5, 0.5], T=320).Prls
        [6.13542244155373, 5.034355147908088]


return [i.Prg for i in self.Chemicals]<EOL>

r'''Pure component Prandtl numbers of the gas phase of the chemicals
        in the mixture at its current temperature and pressure, [dimensionless].

        .. math::
            Pr = \frac{C_p \mu}{k}

        Examples
        --------
        >>> Mixture(['benzene', 'hexane'], ws=[0.5, 0.5], T=320).Prgs
        [0.7810364900059606, 0.784358381123896]


return [i.solubility_parameter for i in self.Chemicals]<EOL>

r'''Pure component solubility parameters of the chemicals in the
        mixture at its current temperature and pressure, in units of [Pa^0.5].

        .. math::
            \delta = \sqrt{\frac{\Delta H_{vap} - RT}{V_m}}

        Examples
        --------
        >>> Mixture(['benzene', 'hexane'], ws=[0.5, 0.5], T=320).solubility_parameters
        [18062.51359608708, 14244.12852702228]


Vml = self.Vml<EOL>if Vml:<EOL><INDENT>return Vm_to_rho(Vml, self.MW)<EOL><DEDENT>return None<EOL>

r'''Liquid-phase mass density of the mixture at its current
        temperature, pressure, and composition in units of [kg/m^3]. For
        calculation of this property at other temperatures, pressures,
        compositions or specifying manually the method used to calculate it,
        and more - see the object oriented interface
        :obj:`thermo.volume.VolumeLiquidMixture`; each Mixture instance
        creates one to actually perform the calculations. Note that that
        interface provides output in molar units.

        Examples
        --------
        >>> Mixture(['o-xylene'], ws=[1], T=297).rhol
        876.9946785618097


Vmg = self.Vmg<EOL>if Vmg:<EOL><INDENT>return Vm_to_rho(Vmg, self.MW)<EOL><DEDENT>return None<EOL>

r'''Gas-phase mass density of the mixture at its current temperature,
        pressure, and composition in units of [kg/m^3]. For calculation of this
        property at other temperatures, pressures, or compositions or
        specifying manually the method used to calculate it, and more - see the
        object oriented interface :obj:`thermo.volume.VolumeGasMixture`; each
        Mixture instance creates one to actually perform the calculations. Note
        that that interface provides output in molar units.

        Examples
        --------
        >>> Mixture(['hexane'], ws=[1], T=300, P=2E5).rhog
        7.914447603999089


Vml = self.Vml<EOL>if Vml:<EOL><INDENT>return <NUM_LIT:1.>/Vml<EOL><DEDENT>return None<EOL>

r'''Molar density of the mixture in the liquid phase at the
        current temperature, pressure, and composition in units of [mol/m^3].

        Utilizes the object oriented interface and
        :obj:`thermo.volume.VolumeLiquidMixture` to perform the actual
        calculation of molar volume.

        Examples
        --------
        >>> Mixture(['water'], ws=[1], T=300).rholm
        55317.352773503124


Vmg = self.Vmg<EOL>if Vmg:<EOL><INDENT>return <NUM_LIT:1.>/Vmg<EOL><DEDENT>return None<EOL>

r'''Molar density of the mixture in the gas phase at the
        current temperature, pressure, and composition in units of [mol/m^3].

        Utilizes the object oriented interface and
        :obj:`thermo.volume.VolumeGasMixture` to perform the actual
        calculation of molar volume.

        Examples
        --------
        >>> Mixture(['water'], ws=[1], T=500).rhogm
        24.467426039789093


Vml = self.Vml<EOL>if Vml:<EOL><INDENT>return Z(self.T, self.P, Vml)<EOL><DEDENT>return None<EOL>

r'''Compressibility factor of the mixture in the liquid phase at the
        current temperature, pressure, and composition, [dimensionless].

        Utilizes the object oriented interface and
        :obj:`thermo.volume.VolumeLiquidMixture` to perform the actual
        calculation of molar volume.

        Examples
        --------
        >>> Mixture(['water'], ws=[1]).Zl
        0.0007385375470263454


Vmg = self.Vmg<EOL>if Vmg:<EOL><INDENT>return Z(self.T, self.P, Vmg)<EOL><DEDENT>return None<EOL>

r'''Compressibility factor of the mixture in the gas phase at the
        current temperature, pressure, and composition, [dimensionless].

        Utilizes the object oriented interface and
        :obj:`thermo.volume.VolumeGasMixture` to perform the actual calculation
        of molar volume.

        Examples
        --------
        >>> Mixture(['hexane'], ws=[1], T=300, P=1E5).Zg
        0.9403859376888885


return self.HeatCapacitySolidMixture(self.T, self.P, self.zs, self.ws)<EOL>

r'''Solid-phase heat capacity of the mixture at its current temperature
        and composition, in units of [J/mol/K]. For calculation of this property
        at other temperatures or compositions, or specifying manually the
        method used to calculate it, and more - see the object oriented
        interface :obj:`thermo.heat_capacity.HeatCapacitySolidMixture`; each
        Mixture instance creates one to actually perform the calculations.

        Examples
        --------
        >>> Mixture(['silver', 'platinum'], ws=[0.95, 0.05]).Cpsm
        25.32745796347474


return self.HeatCapacityLiquidMixture(self.T, self.P, self.zs, self.ws)<EOL>

r'''Liquid-phase heat capacity of the mixture at its current
        temperature and composition, in units of [J/mol/K]. For calculation of
        this property at other temperatures or compositions, or specifying
        manually the method used to calculate it, and more - see the object
        oriented interface :obj:`thermo.heat_capacity.HeatCapacityLiquidMixture`;
        each Mixture instance creates one to actually perform the calculations.

        Examples
        --------
        >>> Mixture(['toluene', 'decane'], ws=[.9, .1], T=300).Cplm
        168.29127923518843


return self.HeatCapacityGasMixture(self.T, self.P, self.zs, self.ws)<EOL>

r'''Gas-phase heat capacity of the mixture at its current temperature
        and composition, in units of [J/mol/K]. For calculation of this property
        at other temperatures or compositions, or specifying manually the
        method used to calculate it, and more - see the object oriented
        interface :obj:`thermo.heat_capacity.HeatCapacityGasMixture`; each
        Mixture instance creates one to actually perform the calculations.

        Examples
        --------
        >>> Mixture(['oxygen', 'nitrogen'], ws=[.4, .6], T=350, P=1E6).Cpgm
        29.361044582498046


Cpsm = self.HeatCapacitySolidMixture(self.T, self.P, self.zs, self.ws)<EOL>if Cpsm:<EOL><INDENT>return property_molar_to_mass(Cpsm, self.MW)<EOL><DEDENT>return None<EOL>

r'''Solid-phase heat capacity of the mixture at its current temperature
        and composition, in units of [J/kg/K]. For calculation of this property
        at other temperatures or compositions, or specifying manually the
        method used to calculate it,  and more - see the object oriented
        interface :obj:`thermo.heat_capacity.HeatCapacitySolidMixture`; each
        Mixture instance creates one to actually perform the calculations. Note
        that that interface provides output in molar units.

        Examples
        --------
        >>> Mixture(['silver', 'platinum'], ws=[0.95, 0.05]).Cps
        229.55166388430328


Cplm = self.HeatCapacityLiquidMixture(self.T, self.P, self.zs, self.ws)<EOL>if Cplm:<EOL><INDENT>return property_molar_to_mass(Cplm, self.MW)<EOL><DEDENT>return None<EOL>

r'''Liquid-phase heat capacity of the mixture at its current
        temperature and composition, in units of [J/kg/K]. For calculation of
        this property at other temperatures or compositions, or specifying
        manually the method used to calculate it, and more - see the object
        oriented interface :obj:`thermo.heat_capacity.HeatCapacityLiquidMixture`;
        each Mixture instance creates one to actually perform the calculations.
        Note that that interface provides output in molar units.

        Examples
        --------
        >>> Mixture(['water', 'sodium chloride'], ws=[.9, .1], T=301.5).Cpl
        3735.4604049449786


Cpgm = self.HeatCapacityGasMixture(self.T, self.P, self.zs, self.ws)<EOL>if Cpgm:<EOL><INDENT>return property_molar_to_mass(Cpgm, self.MW)<EOL><DEDENT>return None<EOL>

r'''Gas-phase heat capacity of the mixture at its current temperature ,
        and composition in units of [J/kg/K]. For calculation of this property at
        other temperatures or compositions, or specifying manually the method
        used to calculate it, and more - see the object oriented interface
        :obj:`thermo.heat_capacity.HeatCapacityGasMixture`; each Mixture
        instance creates one to actually perform the calculations. Note that
        that interface provides output in molar units.

        Examples
        --------
        >>> Mixture(['oxygen', 'nitrogen'], ws=[.4, .6], T=350, P=1E6).Cpg
        995.8911053614883


Cpgm = self.HeatCapacityGasMixture(self.T, self.P, self.zs, self.ws)<EOL>if Cpgm:<EOL><INDENT>return Cpgm - R<EOL><DEDENT>return None<EOL>

r'''Gas-phase ideal-gas contant-volume heat capacity of the mixture at
        its current temperature and composition, in units of [J/mol/K]. Subtracts R from
        the ideal-gas heat capacity; does not include pressure-compensation
        from an equation of state.

        Examples
        --------
        >>> Mixture(['water'], ws=[1], T=520).Cvgm
        27.13366316134193


Cvgm = self.Cvgm<EOL>if Cvgm:<EOL><INDENT>return property_molar_to_mass(Cvgm, self.MW)<EOL><DEDENT>return None<EOL>

r'''Gas-phase ideal-gas contant-volume heat capacity of the mixture at
        its current temperature, in units of [J/kg/K]. Subtracts R from
        the ideal-gas heat capacity; does not include pressure-compensation
        from an equation of state.

        Examples
        --------
        >>> Mixture(['water'], ws=[1], T=520).Cvg
        1506.1471795798861


Cp, Cv = self.Cpg, self.Cvg<EOL>if Cp and Cv:<EOL><INDENT>return isentropic_exponent(Cp, Cv)<EOL><DEDENT>return None<EOL>

r'''Gas-phase ideal-gas isentropic exponent of the mixture at its
        current temperature, [dimensionless]. Does not include
        pressure-compensation from an equation of state.

        Examples
        --------
        >>> Mixture(['hydrogen'], ws=[1]).isentropic_exponent
        1.405237786321222


if self.Vmg:<EOL><INDENT>return B_from_Z(self.Zg, self.T, self.P)<EOL><DEDENT>return None<EOL>

r'''Second virial coefficient of the gas phase of the mixture at its
        current temperature, pressure, and composition in units of [mol/m^3].

        This property uses the object-oriented interface
        :obj:`thermo.volume.VolumeGasMixture`, converting its result with
        :obj:`thermo.utils.B_from_Z`.

        Examples
        --------
        >>> Mixture(['hexane'], ws=[1], T=300, P=1E5).Bvirial
        -0.001486976173801296


Vml, Cplm, isobaric_expansion_l = self.Vml, self.Cplm, self.isobaric_expansion_l<EOL>if all((Vml, Cplm, isobaric_expansion_l)):<EOL><INDENT>return Joule_Thomson(T=self.T, V=Vml, Cp=Cplm, beta=isobaric_expansion_l)<EOL><DEDENT>return None<EOL>

r'''Joule Thomson coefficient of the liquid phase of the mixture if one
        exists at its current temperature and pressure, in units of [K/Pa].

        .. math::
            \mu_{JT} = \left(\frac{\partial T}{\partial P}\right)_H = \frac{1}{C_p}
            \left[T \left(\frac{\partial V}{\partial T}\right)_P - V\right]
            = \frac{V}{C_p}\left(\beta T-1\right)

        Examples
        --------
        >>> Mixture(['dodecane'], ws=[1], T=400).JTl
        -3.193910574559279e-07


Vmg, Cpgm, isobaric_expansion_g = self.Vmg, self.Cpgm, self.isobaric_expansion_g<EOL>if all((Vmg, Cpgm, isobaric_expansion_g)):<EOL><INDENT>return Joule_Thomson(T=self.T, V=Vmg, Cp=Cpgm, beta=isobaric_expansion_g)<EOL><DEDENT>return None<EOL>

r'''Joule Thomson coefficient of the gas phase of the mixture if one
        exists at its current temperature and pressure, in units of [K/Pa].

        .. math::
            \mu_{JT} = \left(\frac{\partial T}{\partial P}\right)_H = \frac{1}{C_p}
            \left[T \left(\frac{\partial V}{\partial T}\right)_P - V\right]
            = \frac{V}{C_p}\left(\beta T-1\right)

        Examples
        --------
        >>> Mixture(['dodecane'], ws=[1], T=400, P=1000).JTg
        5.4089897835384913e-05


mul, rhol = self.mul, self.rhol<EOL>if all([mul, rhol]):<EOL><INDENT>return nu_mu_converter(mu=mul, rho=rhol)<EOL><DEDENT>return None<EOL>

r'''Kinematic viscosity of the liquid phase of the mixture if one
        exists at its current temperature and pressure, in units of [m^2/s].

        .. math::
            \nu = \frac{\mu}{\rho}

        Examples
        --------
        >>> Mixture(['methane'], ws=[1], T=110).nul
        2.858088468937333e-07


mug, rhog = self.mug, self.rhog<EOL>if all([mug, rhog]):<EOL><INDENT>return nu_mu_converter(mu=mug, rho=rhog)<EOL><DEDENT>return None<EOL>

r'''Kinematic viscosity of the gas phase of the mixture if one exists
        at its current temperature and pressure, in units of [m^2/s].

        .. math::
            \nu = \frac{\mu}{\rho}

        Examples
        --------
        >>> Mixture(['methane'], ws=[1], T=115).nug
        2.5118460023343146e-06


kl, rhol, Cpl = self.kl, self.rhol, self.Cpl<EOL>if all([kl, rhol, Cpl]):<EOL><INDENT>return thermal_diffusivity(k=kl, rho=rhol, Cp=Cpl)<EOL><DEDENT>return None<EOL>

r'''Thermal diffusivity of the liquid phase of the mixture if one
        exists at its current temperature and pressure, in units of [m^2/s].

        .. math::
            \alpha = \frac{k}{\rho Cp}

        Examples
        --------
        >>> Mixture(['nitrogen'], ws=[1], T=70).alphal
        9.444949636299626e-08


kg, rhog, Cpg = self.kg, self.rhog, self.Cpg<EOL>if all([kg, rhog, Cpg]):<EOL><INDENT>return thermal_diffusivity(k=kg, rho=rhog, Cp=Cpg)<EOL><DEDENT>return None<EOL>

r'''Thermal diffusivity of the gas phase of the mixture if one exists
        at its current temperature and pressure, in units of [m^2/s].

        .. math::
            \alpha = \frac{k}{\rho Cp}

        Examples
        --------
        >>> Mixture(['ammonia'], ws=[1]).alphag
        1.6968517002221566e-05


Cpl, mul, kl = self.Cpl, self.mul, self.kl<EOL>if all([Cpl, mul, kl]):<EOL><INDENT>return Prandtl(Cp=Cpl, mu=mul, k=kl)<EOL><DEDENT>return None<EOL>

r'''Prandtl number of the liquid phase of the mixture if one exists at
        its current temperature and pressure, [dimensionless].

        .. math::
            Pr = \frac{C_p \mu}{k}

        Examples
        --------
        >>> Mixture(['nitrogen'], ws=[1], T=70).Prl
        2.782821450148889


Cpg, mug, kg = self.Cpg, self.mug, self.kg<EOL>if all([Cpg, mug, kg]):<EOL><INDENT>return Prandtl(Cp=Cpg, mu=mug, k=kg)<EOL><DEDENT>return None<EOL>

r'''Prandtl number of the gas phase of the mixture if one exists at its
        current temperature and pressure, [dimensionless].

        .. math::
            Pr = \frac{C_p \mu}{k}

        Examples
        --------
        >>> Mixture(['NH3'], ws=[1]).Prg
        0.8472637319330079


return self.VolumeLiquidMixture(T=self.T, P=self.P, zs=self.zs, ws=self.ws)<EOL>

r'''Liquid-phase molar volume of the mixture at its current
        temperature, pressure, and composition in units of [m^3/mol]. For
        calculation of this property at other temperatures or pressures or
        compositions, or specifying manually the method used to calculate it,
        and more - see the object oriented interface
        :obj:`thermo.volume.VolumeLiquidMixture`; each Mixture instance
        creates one to actually perform the calculations.

        Examples
        --------
        >>> Mixture(['cyclobutane'], ws=[1], T=225).Vml
        7.42395423425395e-05


return self.VolumeGasMixture(T=self.T, P=self.P, zs=self.zs, ws=self.ws)<EOL>

r'''Gas-phase molar volume of the mixture at its current
        temperature, pressure, and composition in units of [m^3/mol]. For
        calculation of this property at other temperatures or pressures or
        compositions, or specifying manually the method used to calculate it,
        and more - see the object oriented interface
        :obj:`thermo.volume.VolumeGasMixture`; each Mixture instance
        creates one to actually perform the calculations.

        Examples
        --------
        >>> Mixture(['hexane'], ws=[1], T=300, P=2E5).Vmg
        0.010888694235142216


Vmg = self.VolumeGasMixture(T=<NUM_LIT>, P=<NUM_LIT>, zs=self.zs, ws=self.ws)<EOL>if Vmg:<EOL><INDENT>rho = Vm_to_rho(Vmg, self.MW)<EOL>return SG(rho, rho_ref=<NUM_LIT>) <EOL><DEDENT>return None<EOL>

r'''Specific gravity of a hypothetical gas phase of the mixture, .
        [dimensionless]. The reference condition is air at 15.6 °C (60 °F) and
        1 atm (rho=1.223 kg/m^3). The definition for gases uses the
        compressibility factor of the reference gas and the mixture both at the
        reference conditions, not the conditions of the mixture.

        Examples
        --------
        >>> Mixture('argon').SGg
        1.3800407778218216


return self.ViscosityLiquidMixture(self.T, self.P, self.zs, self.ws)<EOL>

r'''Viscosity of the mixture in the liquid phase at its current
        temperature, pressure, and composition in units of [Pa*s].

        For calculation of this property at other temperatures and pressures,
        or specifying manually the method used to calculate it, and more - see
        the object oriented interface
        :obj:`thermo.viscosity.ViscosityLiquidMixture`; each Mixture instance
        creates one to actually perform the calculations.

        Examples
        --------
        >>> Mixture(['water'], ws=[1], T=320).mul
        0.0005767262693751547


return self.ViscosityGasMixture(self.T, self.P, self.zs, self.ws)<EOL>

r'''Viscosity of the mixture in the gas phase at its current
        temperature, pressure, and composition in units of [Pa*s].

        For calculation of this property at other temperatures and pressures,
        or specifying manually the method used to calculate it, and more - see
        the object oriented interface
        :obj:`thermo.viscosity.ViscosityGasMixture`; each Mixture instance
        creates one to actually perform the calculations.

        Examples
        --------
        >>> Mixture(['water'], ws=[1], T=500).mug
        1.7298722343367148e-05


return self.SurfaceTensionMixture(self.T, self.P, self.zs, self.ws)<EOL>

r'''Surface tension of the mixture at its current temperature and
        composition, in units of [N/m].

        For calculation of this property at other temperatures,
        or specifying manually the method used to calculate it, and more - see
        the object oriented interface :obj:`thermo.interface.SurfaceTensionMixture`;
        each Mixture instance creates one to actually perform the calculations.

        Examples
        --------
        >>> Mixture(['water'], ws=[1], T=300, P=1E5).sigma
        0.07176932405246211


return self.ThermalConductivityLiquidMixture(self.T, self.P, self.zs, self.ws)<EOL>

r'''Thermal conductivity of the mixture in the liquid phase at its current
        temperature, pressure, and composition in units of [Pa*s].

        For calculation of this property at other temperatures and pressures,
        or specifying manually the method used to calculate it, and more - see
        the object oriented interface
        :obj:`thermo.thermal_conductivity.ThermalConductivityLiquidMixture`;
        each Mixture instance creates one to actually perform the calculations.

        Examples
        --------
        >>> Mixture(['water'], ws=[1], T=320).kl
        0.6369957248212118


return self.ThermalConductivityGasMixture(self.T, self.P, self.zs, self.ws)<EOL>

r'''Thermal conductivity of the mixture in the gas phase at its current
        temperature, pressure, and composition in units of [Pa*s].

        For calculation of this property at other temperatures and pressures,
        or specifying manually the method used to calculate it, and more - see
        the object oriented interface
        :obj:`thermo.thermal_conductivity.ThermalConductivityGasMixture`;
        each Mixture instance creates one to actually perform the calculations.

        Examples
        --------
        >>> Mixture(['water'], ws=[1], T=500).kg
        0.036035173297862676


return phase_select_property(phase=self.phase, s=self.Cps, l=self.Cpl, g=self.Cpg)<EOL>

r'''Mass heat capacity of the mixture at its current phase and
        temperature, in units of [J/kg/K].

        Examples
        --------
        >>> w = Mixture(['water'], ws=[1])
        >>> w.Cp, w.phase
        (4180.597021827336, 'l')
        >>> Pd = Mixture(['palladium'], ws=[1])
        >>> Pd.Cp, Pd.phase
        (234.26767209171211, 's')


return phase_select_property(phase=self.phase, s=self.Cpsm, l=self.Cplm, g=self.Cpgm)<EOL>

r'''Molar heat capacity of the mixture at its current phase and
        temperature, in units of [J/mol/K]. Available only if single phase.

        Examples
        --------
        >>> Mixture(['ethylbenzene'], ws=[1], T=550, P=3E6).Cpm
        294.18449553310046


return phase_select_property(phase=self.phase, s=self.Vms, l=self.Vml, g=self.Vmg)<EOL>

r'''Molar volume of the mixture at its current phase and
        temperature and pressure, in units of [m^3/mol].
        Available only if single phase.

        Examples
        --------
        >>> Mixture(['ethylbenzene'], ws=[1], T=550, P=3E6).Vm
        0.00017758024401627633


return phase_select_property(phase=self.phase, s=self.rhos, l=self.rhol, g=self.rhog)<EOL>

r'''Mass density of the mixture at its current phase and
        temperature and pressure, in units of [kg/m^3].
        Available only if single phase.

        Examples
        --------
        >>> Mixture(['decane'], ws=[1], T=550, P=2E6).rho
        498.67008448640604


return phase_select_property(phase=self.phase, s=None, l=self.rholm, g=self.rhogm)<EOL>

r'''Molar density of the mixture at its current phase and
        temperature and pressure, in units of [mol/m^3].
        Available only if single phase.

        Examples
        --------
        >>> Mixture(['1-hexanol'], ws=[1]).rhom
        7983.414573003429


Vm = self.Vm<EOL>if Vm:<EOL><INDENT>return Z(self.T, self.P, Vm)<EOL><DEDENT>return None<EOL>

r'''Compressibility factor of the mixture at its current phase and
        temperature and pressure, [dimensionless].
        Available only if single phase.

        Examples
        --------
        >>> Mixture(['MTBE'], ws=[1], T=900, P=1E-2).Z
        0.9999999999056374


return phase_select_property(phase=self.phase, s=self.SGs, l=self.SGl, g=self.SGg)<EOL>

r'''Specific gravity of the mixture, [dimensionless].

        For gas-phase conditions, this is calculated at 15.6 °C (60 °F) and 1
        atm for the mixture and the reference fluid, air.
        For liquid and solid phase conditions, this is calculated based on a
        reference fluid of water at 4°C at 1 atm, but the with the liquid or
        solid mixture's density at the currently specified conditions.

        Examples
        --------
        >>> Mixture('MTBE').SG
        0.7428160596603596


return phase_select_property(phase=self.phase, l=self.isobaric_expansion_l, g=self.isobaric_expansion_g)<EOL>

r'''Isobaric (constant-pressure) expansion of the mixture at its
        current phase, temperature, and pressure in units of [1/K].
        Available only if single phase.

        .. math::
            \beta = \frac{1}{V}\left(\frac{\partial V}{\partial T} \right)_P

        Examples
        --------
        >>> Mixture(['water'], ws=[1], T=647.1, P=22048320.0).isobaric_expansion
        0.34074205839222449


return phase_select_property(phase=self.phase, l=self.JTl, g=self.JTg)<EOL>

r'''Joule Thomson coefficient of the mixture at its
        current phase, temperature, and pressure in units of [K/Pa].
        Available only if single phase.

        .. math::
            \mu_{JT} = \left(\frac{\partial T}{\partial P}\right)_H = \frac{1}{C_p}
            \left[T \left(\frac{\partial V}{\partial T}\right)_P - V\right]
            = \frac{V}{C_p}\left(\beta T-1\right)

        Examples
        --------
        >>> Mixture(['water'], ws=[1]).JT
        -2.2150394958666412e-07


return phase_select_property(phase=self.phase, l=self.mul, g=self.mug)<EOL>

r'''Viscosity of the mixture at its current phase, temperature, and
        pressure in units of [Pa*s].
        Available only if single phase.

        Examples
        --------
        >>> Mixture(['ethanol'], ws=[1], T=400).mu
        1.1853097849748213e-05


return phase_select_property(phase=self.phase, s=None, l=self.kl, g=self.kg)<EOL>

r'''Thermal conductivity of the mixture at its current phase,
        temperature, and pressure in units of [W/m/K].
        Available only if single phase.

        Examples
        --------
        >>> Mixture(['ethanol'], ws=[1], T=300).kl
        0.16313594741877802


return phase_select_property(phase=self.phase, l=self.nul, g=self.nug)<EOL>

r'''Kinematic viscosity of the the mixture at its current temperature,
        pressure, and phase in units of [m^2/s].
        Available only if single phase.

        .. math::
            \nu = \frac{\mu}{\rho}

        Examples
        --------
        >>> Mixture(['argon'], ws=[1]).nu
        1.3842643382482236e-05


return phase_select_property(phase=self.phase, l=self.alphal, g=self.alphag)<EOL>

r'''Thermal diffusivity of the mixture at its current temperature,
        pressure, and phase in units of [m^2/s].
        Available only if single phase.

        .. math::
            \alpha = \frac{k}{\rho Cp}

        Examples
        --------
        >>> Mixture(['furfural'], ws=[1]).alpha
        8.696537158635412e-08


return phase_select_property(phase=self.phase, l=self.Prl, g=self.Prg)<EOL>

r'''Prandtl number of the mixture at its current temperature,
        pressure, and phase; [dimensionless].
        Available only if single phase.

        .. math::
            Pr = \frac{C_p \mu}{k}

        Examples
        --------
        >>> Mixture(['acetone'], ws=[1]).Pr
        4.183039103542711


return self.VolumeLiquidMixture(T=<NUM_LIT>, P=<NUM_LIT>, zs=self.zs, ws=self.ws)<EOL>

r'''Liquid-phase molar volume of the mixture at 298.15 K and 101.325 kPa,
        and the current composition in units of [m^3/mol].

        Examples
        --------
        >>> Mixture(['cyclobutane'], ws=[1]).Vml_STP
        8.143327329133706e-05


return self.VolumeGasMixture(T=<NUM_LIT>, P=<NUM_LIT>, zs=self.zs, ws=self.ws)<EOL>

r'''Gas-phase molar volume of the mixture at 298.15 K and 101.325 kPa,
        and the current composition in units of [m^3/mol].

        Examples
        --------
        >>> Mixture(['nitrogen'], ws=[1]).Vmg_STP
        0.02445443688838904


Vml = self.Vml_STP<EOL>if Vml:<EOL><INDENT>return Vm_to_rho(Vml, self.MW)<EOL><DEDENT>return None<EOL>

r'''Liquid-phase mass density of the mixture at 298.15 K and 101.325 kPa,
        and the current composition in units of [kg/m^3].

        Examples
        --------
        >>> Mixture(['cyclobutane'], ws=[1]).rhol_STP
        688.9851989526821


Vmg = self.Vmg_STP<EOL>if Vmg:<EOL><INDENT>return Vm_to_rho(Vmg, self.MW)<EOL><DEDENT>return None<EOL>

r'''Gas-phase mass density of the mixture at 298.15 K and 101.325 kPa,
        and the current composition in units of [kg/m^3].

        Examples
        --------
        >>> Mixture(['nitrogen'], ws=[1]).rhog_STP
        1.145534453639403


Vml = self.Vml<EOL>if Vml:<EOL><INDENT>return Z(self.T, self.P, Vml)<EOL><DEDENT>return None<EOL>

r'''Liquid-phase compressibility factor of the mixture at 298.15 K and 101.325 kPa,
        and the current composition, [dimensionless].

        Examples
        --------
        >>> Mixture(['cyclobutane'], ws=[1]).Zl_STP
        0.0033285083663950068


Vmg = self.Vmg<EOL>if Vmg:<EOL><INDENT>return Z(self.T, self.P, Vmg)<EOL><DEDENT>return None<EOL>

r'''Gas-phase compressibility factor of the mixture at 298.15 K and 101.325 kPa,
        and the current composition, [dimensionless].

        Examples
        --------
        >>> Mixture(['nitrogen'], ws=[1]).Zg_STP
        0.9995520809691023


Vml = self.Vml_STP<EOL>if Vml:<EOL><INDENT>return <NUM_LIT:1.>/Vml<EOL><DEDENT>return None<EOL>

r'''Molar density of the mixture in the liquid phase at 298.15 K and 101.325 kPa,
        and the current composition, in units of [mol/m^3].

        Examples
        --------
        >>> Mixture(['water'], ws=[1]).rholm_STP
        55344.59086372442


Vmg = self.Vmg_STP<EOL>if Vmg:<EOL><INDENT>return <NUM_LIT:1.>/Vmg<EOL><DEDENT>return None<EOL>

r'''Molar density of the mixture in the gas phase at 298.15 K and 101.325 kPa,
        and the current composition, in units of [mol/m^3].

        Examples
        --------
        >>> Mixture(['nitrogen'], ws=[1]).rhogm_STP
        40.892374850585895


Vml = self.VolumeLiquidMixture(T=<NUM_LIT>, P=<NUM_LIT>, zs=self.zs, ws=self.ws)<EOL>if Vml:<EOL><INDENT>rho = Vm_to_rho(Vml, self.MW)<EOL><DEDENT>sg = SG(rho, rho_ref=<NUM_LIT>)<EOL>return SG_to_API(sg)<EOL>

r'''API gravity of the hypothetical liquid phase of the mixture,
        [degrees]. The reference condition is water at 15.6 °C (60 °F) and 1 atm
        (rho=999.016 kg/m^3, standardized).

        Examples
        --------
        >>> Mixture(['hexane', 'decane'], ws=[0.5, 0.5]).API
        71.34707841728181


try:<EOL><INDENT>from rdkit.Chem import Draw<EOL>from rdkit.Chem.Draw import IPythonConsole<EOL>if Hs:<EOL><INDENT>mols = [i.rdkitmol_Hs for i in self.Chemicals]<EOL><DEDENT>else:<EOL><INDENT>mols = [i.rdkitmol for i in self.Chemicals]<EOL><DEDENT>return Draw.MolsToImage(mols)<EOL><DEDENT>except:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>

r'''Interface for drawing a 2D image of all the molecules in the
        mixture. Requires an HTML5 browser, and the libraries RDKit and
        IPython. An exception is raised if either of these libraries is
        absent.

        Parameters
        ----------
        Hs : bool
            Whether or not to show hydrogen

        Examples
        --------
        Mixture(['natural gas']).draw_2d()


def draw_2d(self, width=<NUM_LIT>, height=<NUM_LIT>, Hs=False):

try:<EOL><INDENT>from rdkit.Chem import Draw<EOL>from rdkit.Chem.Draw import IPythonConsole<EOL>if Hs:<EOL><INDENT>mol = self.rdkitmol_Hs<EOL><DEDENT>else:<EOL><INDENT>mol = self.rdkitmol<EOL><DEDENT>return Draw.MolToImage(mol, size=(width, height))<EOL><DEDENT>except:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>

r'''Interface for drawing a 2D image of the molecule.
        Requires an HTML5 browser, and the libraries RDKit and
        IPython. An exception is raised if either of these libraries is
        absent.

        Parameters
        ----------
        width : int
            Number of pixels wide for the view
        height : int
            Number of pixels tall for the view
        Hs : bool
            Whether or not to show hydrogen

        Examples
        --------
        >>> Chemical('decane').draw_2d() # doctest: +ELLIPSIS
        <PIL.Image.Image image mode=RGBA size=300x300 at 0x...>


def draw_3d(self, width=<NUM_LIT>, height=<NUM_LIT>, style='<STR_LIT>', Hs=True):

try:<EOL><INDENT>import py3Dmol<EOL>from IPython.display import display<EOL>if Hs:<EOL><INDENT>mol = self.rdkitmol_Hs<EOL><DEDENT>else:<EOL><INDENT>mol = self.rdkitmol<EOL><DEDENT>AllChem.EmbedMultipleConfs(mol)<EOL>mb = Chem.MolToMolBlock(mol)<EOL>p = py3Dmol.view(width=width,height=height)<EOL>p.addModel(mb,'<STR_LIT>')<EOL>p.setStyle({style:{}})<EOL>p.zoomTo()<EOL>display(p.show())<EOL><DEDENT>except:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>

r'''Interface for drawing an interactive 3D view of the molecule.
        Requires an HTML5 browser, and the libraries RDKit, pymol3D, and
        IPython. An exception is raised if all three of these libraries are
        not installed.

        Parameters
        ----------
        width : int
            Number of pixels wide for the view
        height : int
            Number of pixels tall for the view
        style : str
            One of 'stick', 'line', 'cross', or 'sphere'
        Hs : bool
            Whether or not to show hydrogen

        Examples
        --------
        >>> Chemical('cubane').draw_3d()
        <IPython.core.display.HTML object>


return self.eos_in_a_box[<NUM_LIT:0>]<EOL>

r'''Equation of state object held by the chemical; used to calculate
        excess thermodynamic quantities, and also provides a vapor pressure
        curve, enthalpy of vaporization curve, fugacity, thermodynamic partial
        derivatives, and more; see :obj:`thermo.eos` for a full listing.

        Examples
        --------
        >>> Chemical('methane').eos.V_g
        0.02441019502181826


return self.Hm - self.P*self.Vm if (self.Vm and self.Hm is not None) else None<EOL>

r'''Internal energy of the chemical at its current temperature and
        pressure, in units of [J/mol].

        This property requires that :obj:`thermo.chemical.set_thermo` ran
        successfully to be accurate.
        It also depends on the molar volume of the chemical at its current
        conditions.


return property_molar_to_mass(self.Um, self.MW) if (self.Um is not None) else None<EOL>

r'''Internal energy of the chemical at its current temperature and
        pressure, in units of [J/kg].

        This property requires that :obj:`thermo.chemical.set_thermo` ran
        successfully to be accurate.
        It also depends on the molar volume of the chemical at its current
        conditions.


return self.Um - self.T*self.Sm if (self.Um is not None and self.Sm is not None) else None<EOL>

r'''Helmholtz energy of the chemical at its current temperature and
        pressure, in units of [J/mol].

        This property requires that :obj:`thermo.chemical.set_thermo` ran
        successfully to be accurate.
        It also depends on the molar volume of the chemical at its current
        conditions.


return self.U - self.T*self.S if (self.U is not None and self.S is not None) else None<EOL>

r'''Helmholtz energy of the chemical at its current temperature and
        pressure, in units of [J/kg].

        This property requires that :obj:`thermo.chemical.set_thermo` ran
        successfully to be accurate.
        It also depends on the molar volume of the chemical at its current
        conditions.


try:<EOL><INDENT>if not self.rdkitmol:<EOL><INDENT>return charge_from_formula(self.formula)<EOL><DEDENT>else:<EOL><INDENT>return Chem.GetFormalCharge(self.rdkitmol)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>return charge_from_formula(self.formula)<EOL><DEDENT>

r'''Charge of a chemical, computed with RDKit from a chemical's SMILES.
        If RDKit is not available, holds None.

        Examples
        --------
        >>> Chemical('sodium ion').charge
        1


try:<EOL><INDENT>return Chem.Descriptors.RingCount(self.rdkitmol)<EOL><DEDENT>except:<EOL><INDENT>return None<EOL><DEDENT>

r'''Number of rings in a chemical, computed with RDKit from a
        chemical's SMILES. If RDKit is not available, holds None.

        Examples
        --------
        >>> Chemical('Paclitaxel').rings
        7


try:<EOL><INDENT>return Chem.Descriptors.NumAromaticRings(self.rdkitmol)<EOL><DEDENT>except:<EOL><INDENT>return None<EOL><DEDENT>

r'''Number of aromatic rings in a chemical, computed with RDKit from a
        chemical's SMILES. If RDKit is not available, holds None.

        Examples
        --------
        >>> Chemical('Paclitaxel').aromatic_rings
        3


if self.__rdkitmol:<EOL><INDENT>return self.__rdkitmol<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>self.__rdkitmol = Chem.MolFromSmiles(self.smiles)<EOL>return self.__rdkitmol<EOL><DEDENT>except:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>

r'''RDKit object of the chemical, without hydrogen. If RDKit is not
        available, holds None.

        For examples of what can be done with RDKit, see
        `their website <http://www.rdkit.org/docs/GettingStartedInPython.html>`_.


if self.__rdkitmol_Hs:<EOL><INDENT>return self.__rdkitmol_Hs<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>self.__rdkitmol_Hs = Chem.AddHs(self.rdkitmol)<EOL>return self.__rdkitmol_Hs<EOL><DEDENT>except:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>

r'''RDKit object of the chemical, with hydrogen. If RDKit is not
        available, holds None.

        For examples of what can be done with RDKit, see
        `their website <http://www.rdkit.org/docs/GettingStartedInPython.html>`_.


if self.__Hill:<EOL><INDENT>return self.__Hill<EOL><DEDENT>else:<EOL><INDENT>self.__Hill = atoms_to_Hill(self.atoms)<EOL>return self.__Hill<EOL><DEDENT>

r'''Hill formula of a compound. For a description of the Hill system,
        see :obj:`thermo.elements.atoms_to_Hill`.

        Examples
        --------
        >>> Chemical('furfuryl alcohol').Hill
        'C5H6O2'


if self.__atom_fractions:<EOL><INDENT>return self.__atom_fractions<EOL><DEDENT>else:<EOL><INDENT>self.__atom_fractions = atom_fractions(self.atoms)<EOL>return self.__atom_fractions<EOL><DEDENT>

r'''Dictionary of atom:fractional occurence of the elements in a
        chemical. Useful when performing element balances. For mass-fraction
        occurences, see :obj:`mass_fractions`.

        Examples
        --------
        >>> Chemical('Ammonium aluminium sulfate').atom_fractions
        {'H': 0.25, 'S': 0.125, 'Al': 0.0625, 'O': 0.5, 'N': 0.0625}


if self.__mass_fractions:<EOL><INDENT>return self.__mass_fractions<EOL><DEDENT>else:<EOL><INDENT>self.__mass_fractions =  mass_fractions(self.atoms, self.MW)<EOL>return self.__mass_fractions<EOL><DEDENT>

r'''Dictionary of atom:mass-weighted fractional occurence of elements.
        Useful when performing mass balances. For atom-fraction occurences, see
        :obj:`atom_fractions`.

        Examples
        --------
        >>> Chemical('water').mass_fractions
        {'H': 0.11189834407236524, 'O': 0.8881016559276347}


if self.__legal_status:<EOL><INDENT>return self.__legal_status<EOL><DEDENT>else:<EOL><INDENT>self.__legal_status = legal_status(self.CAS, Method='<STR_LIT>')<EOL>return self.__legal_status<EOL><DEDENT>

r'''Dictionary of legal status indicators for the chemical.

        Examples
        --------
        >>> pprint(Chemical('benzene').legal_status)
        {'DSL': 'LISTED',
         'EINECS': 'LISTED',
         'NLP': 'UNLISTED',
         'SPIN': 'LISTED',
         'TSCA': 'LISTED'}


if self.__economic_status:<EOL><INDENT>return self.__economic_status<EOL><DEDENT>else:<EOL><INDENT>self.__economic_status = economic_status(self.CAS, Method='<STR_LIT>')<EOL>return self.__economic_status<EOL><DEDENT>

r'''Dictionary of economic status indicators for the chemical.

        Examples
        --------
        >>> pprint(Chemical('benzene').economic_status)
        ["US public: {'Manufactured': 6165232.1, 'Imported': 463146.474, 'Exported': 271908.252}",
         u'1,000,000 - 10,000,000 tonnes per annum',
         u'Intermediate Use Only',
         'OECD HPV Chemicals']


if self.__UNIFAC_groups:<EOL><INDENT>return self.__UNIFAC_groups<EOL><DEDENT>else:<EOL><INDENT>load_group_assignments_DDBST()<EOL>if self.InChI_Key in DDBST_UNIFAC_assignments:<EOL><INDENT>self.__UNIFAC_groups = DDBST_UNIFAC_assignments[self.InChI_Key]<EOL>return self.__UNIFAC_groups<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>

r'''Dictionary of UNIFAC subgroup: count groups for the original
        UNIFAC subgroups, as determined by `DDBST's online service <http://www.ddbst.com/unifacga.html>`_.

        Examples
        --------
        >>> pprint(Chemical('Cumene').UNIFAC_groups)
        {1: 2, 9: 5, 13: 1}


if self.__UNIFAC_Dortmund_groups:<EOL><INDENT>return self.__UNIFAC_Dortmund_groups<EOL><DEDENT>else:<EOL><INDENT>load_group_assignments_DDBST()<EOL>if self.InChI_Key in DDBST_MODIFIED_UNIFAC_assignments:<EOL><INDENT>self.__UNIFAC_Dortmund_groups = DDBST_MODIFIED_UNIFAC_assignments[self.InChI_Key]<EOL>return self.__UNIFAC_Dortmund_groups<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>

r'''Dictionary of Dortmund UNIFAC subgroup: count groups for the
        Dortmund UNIFAC subgroups, as determined by `DDBST's online service <http://www.ddbst.com/unifacga.html>`_.

        Examples
        --------
        >>> pprint(Chemical('Cumene').UNIFAC_Dortmund_groups)
        {1: 2, 9: 5, 13: 1}


if self.__PSRK_groups:<EOL><INDENT>return self.__PSRK_groups<EOL><DEDENT>else:<EOL><INDENT>load_group_assignments_DDBST()<EOL>if self.InChI_Key in DDBST_PSRK_assignments:<EOL><INDENT>self.__PSRK_groups = DDBST_PSRK_assignments[self.InChI_Key]<EOL>return self.__PSRK_groups<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>

r'''Dictionary of PSRK subgroup: count groups for the PSRK subgroups,
        as determined by `DDBST's online service <http://www.ddbst.com/unifacga.html>`_.

        Examples
        --------
        >>> pprint(Chemical('Cumene').PSRK_groups)
        {1: 2, 9: 5, 13: 1}


if self.UNIFAC_groups:<EOL><INDENT>return UNIFAC_RQ(self.UNIFAC_groups)[<NUM_LIT:0>]<EOL><DEDENT>return None<EOL>

r'''UNIFAC `R` (normalized Van der Waals volume), dimensionless.
        Used in the UNIFAC model.

        Examples
        --------
        >>> Chemical('benzene').UNIFAC_R
        3.1878


if self.UNIFAC_groups:<EOL><INDENT>return UNIFAC_RQ(self.UNIFAC_groups)[<NUM_LIT:1>]<EOL><DEDENT>return None<EOL>

r'''UNIFAC `Q` (normalized Van der Waals area), dimensionless.
        Used in the UNIFAC model.

        Examples
        --------
        >>> Chemical('decane').UNIFAC_Q
        6.016


if self.UNIFAC_R:<EOL><INDENT>return Van_der_Waals_volume(self.UNIFAC_R)<EOL><DEDENT>return None<EOL>

r'''Unnormalized Van der Waals volume, in units of [m^3/mol].

        Examples
        --------
        >>> Chemical('hexane').Van_der_Waals_volume
        6.8261966e-05


if self.UNIFAC_Q:<EOL><INDENT>return Van_der_Waals_area(self.UNIFAC_Q)<EOL><DEDENT>return None<EOL>

r'''Unnormalized Van der Waals area, in units of [m^2/mol].

        Examples
        --------
        >>> Chemical('hexane').Van_der_Waals_area
        964000.0


return property_molar_to_mass(R, self.MW)<EOL>

r'''Specific gas constant, in units of [J/kg/K].

        Examples
        --------
        >>> Chemical('water').R_specific
        461.52265188218


return self.VaporPressure(self.T)<EOL>

r'''Vapor pressure of the chemical at its current temperature, in units
        of [Pa]. For calculation of this property at other temperatures,
        or specifying manually the method used to calculate it, and more - see
        the object oriented interface :obj:`thermo.vapor_pressure.VaporPressure`;
        each Chemical instance creates one to actually perform the calculations.

        Examples
        --------
        >>> Chemical('water', T=320).Psat
        10533.614271198725
        >>> Chemical('water').VaporPressure.T_dependent_property(320)
        10533.614271198725
        >>> Chemical('water').VaporPressure.all_methods
        set(['VDI_PPDS', 'BOILING_CRITICAL', 'WAGNER_MCGARRY', 'AMBROSE_WALTON', 'COOLPROP', 'LEE_KESLER_PSAT', 'EOS', 'ANTOINE_POLING', 'SANJARI', 'DIPPR_PERRY_8E', 'Edalat'])


return self.EnthalpyVaporization(self.T)<EOL>

r'''Enthalpy of vaporization of the chemical at its current temperature,
        in units of [J/mol]. For calculation of this property at other
        temperatures, or specifying manually the method used to calculate it,
        and more - see the object oriented interface
        :obj:`thermo.phase_change.EnthalpyVaporization`; each Chemical instance
        creates one to actually perform the calculations.

        Examples
        --------
        >>> Chemical('water', T=320).Hvapm
        43048.23612280223
        >>> Chemical('water').EnthalpyVaporization.T_dependent_property(320)
        43048.23612280223
        >>> Chemical('water').EnthalpyVaporization.all_methods
        set(['VDI_PPDS', 'MORGAN_KOBAYASHI', 'VETERE', 'VELASCO', 'LIU', 'COOLPROP', 'CRC_HVAP_298', 'CLAPEYRON', 'SIVARAMAN_MAGEE_KOBAYASHI', 'ALIBAKHSHI', 'DIPPR_PERRY_8E', 'RIEDEL', 'CHEN', 'PITZER', 'CRC_HVAP_TB'])


Hvamp = self.Hvapm<EOL>if Hvamp:<EOL><INDENT>return property_molar_to_mass(Hvamp, self.MW)<EOL><DEDENT>return None<EOL>

r'''Enthalpy of vaporization of the chemical at its current temperature,
        in units of [J/kg].

        This property uses the object-oriented interface
        :obj:`thermo.phase_change.EnthalpyVaporization`, but converts its
        results from molar to mass units.

        Examples
        --------
        >>> Chemical('water', T=320).Hvap
        2389540.219347256


return self.HeatCapacitySolid(self.T)<EOL>

r'''Solid-phase heat capacity of the chemical at its current temperature,
        in units of [J/mol/K]. For calculation of this property at other
        temperatures, or specifying manually the method used to calculate it,
        and more - see the object oriented interface
        :obj:`thermo.heat_capacity.HeatCapacitySolid`; each Chemical instance
        creates one to actually perform the calculations.

        Examples
        --------
        >>> Chemical('palladium').Cpsm
        24.930765664000003
        >>> Chemical('palladium').HeatCapacitySolid.T_dependent_property(320)
        25.098979200000002
        >>> Chemical('palladium').HeatCapacitySolid.all_methods
        set(["Perry's Table 2-151", 'CRC Standard Thermodynamic Properties of Chemical Substances', 'Lastovka, Fulem, Becerra and Shaw (2008)'])


return self.HeatCapacityLiquid(self.T)<EOL>

r'''Liquid-phase heat capacity of the chemical at its current temperature,
        in units of [J/mol/K]. For calculation of this property at other
        temperatures, or specifying manually the method used to calculate it,
        and more - see the object oriented interface
        :obj:`thermo.heat_capacity.HeatCapacityLiquid`; each Chemical instance
        creates one to actually perform the calculations.

        Notes
        -----
        Some methods give heat capacity along the saturation line, some at
        1 atm but only up to the normal boiling point, and some give heat
        capacity at 1 atm up to the normal boiling point and then along the
        saturation line. Real-liquid heat capacity is pressure dependent, but
        this interface is not.

        Examples
        --------
        >>> Chemical('water').Cplm
        75.31462591538556
        >>> Chemical('water').HeatCapacityLiquid.T_dependent_property(320)
        75.2591744360631
        >>> Chemical('water').HeatCapacityLiquid.T_dependent_property_integral(300, 320)
        1505.0619005000553


return self.HeatCapacityGas(self.T)<EOL>

r'''Gas-phase ideal gas heat capacity of the chemical at its current
        temperature, in units of [J/mol/K]. For calculation of this property at
        other temperatures, or specifying manually the method used to calculate
        it, and more - see the object oriented interface
        :obj:`thermo.heat_capacity.HeatCapacityGas`; each Chemical instance
        creates one to actually perform the calculations.

        Examples
        --------
        >>> Chemical('water').Cpgm
        33.583577868850675
        >>> Chemical('water').HeatCapacityGas.T_dependent_property(320)
        33.67865044005934
        >>> Chemical('water').HeatCapacityGas.T_dependent_property_integral(300, 320)
        672.6480417835064


Cpsm = self.HeatCapacitySolid(self.T)<EOL>if Cpsm:<EOL><INDENT>return property_molar_to_mass(Cpsm, self.MW)<EOL><DEDENT>return None<EOL>

r'''Solid-phase heat capacity of the chemical at its current temperature,
        in units of [J/kg/K]. For calculation of this property at other
        temperatures, or specifying manually the method used to calculate it,
        and more - see the object oriented interface
        :obj:`thermo.heat_capacity.HeatCapacitySolid`; each Chemical instance
        creates one to actually perform the calculations. Note that that
        interface provides output in molar units.

        Examples
        --------
        >>> Chemical('palladium', T=400).Cps
        241.63563239992484
        >>> Pd = Chemical('palladium', T=400)
        >>> Cpsms = [Pd.HeatCapacitySolid.T_dependent_property(T) for T in np.linspace(300,500, 5)]
        >>> [property_molar_to_mass(Cps, Pd.MW) for Cps in Cpsms]
        [234.40150347679008, 238.01856793835751, 241.63563239992484, 245.25269686149224, 248.86976132305958]


Cplm = self.HeatCapacityLiquid(self.T)<EOL>if Cplm:<EOL><INDENT>return property_molar_to_mass(Cplm, self.MW)<EOL><DEDENT>return None<EOL>

r'''Liquid-phase heat capacity of the chemical at its current temperature,
        in units of [J/kg/K]. For calculation of this property at other
        temperatures, or specifying manually the method used to calculate it,
        and more - see the object oriented interface
        :obj:`thermo.heat_capacity.HeatCapacityLiquid`; each Chemical instance
        creates one to actually perform the calculations. Note that that
        interface provides output in molar units.

        Examples
        --------
        >>> Chemical('water', T=320).Cpl
        4177.518996988284

        Ideal entropy change of water from 280 K to 340 K, output converted
        back to mass-based units of J/kg/K.

        >>> dSm = Chemical('water').HeatCapacityLiquid.T_dependent_property_integral_over_T(280, 340)
        >>> property_molar_to_mass(dSm, Chemical('water').MW)
        812.1024585274956


Cpgm = self.HeatCapacityGas(self.T)<EOL>if Cpgm:<EOL><INDENT>return property_molar_to_mass(Cpgm, self.MW)<EOL><DEDENT>return None<EOL>

r'''Gas-phase heat capacity of the chemical at its current temperature,
        in units of [J/kg/K]. For calculation of this property at other
        temperatures, or specifying manually the method used to calculate it,
        and more - see the object oriented interface
        :obj:`thermo.heat_capacity.HeatCapacityGas`; each Chemical instance
        creates one to actually perform the calculations. Note that that
        interface provides output in molar units.

        Examples
        --------
        >>> w = Chemical('water', T=520)
        >>> w.Cpg
        1967.6698314620658


Cpgm = self.HeatCapacityGas(self.T)<EOL>if Cpgm:<EOL><INDENT>return Cpgm - R<EOL><DEDENT>return None<EOL>

r'''Gas-phase ideal-gas contant-volume heat capacity of the chemical at
        its current temperature, in units of [J/mol/K]. Subtracts R from
        the ideal-gas heat capacity; does not include pressure-compensation
        from an equation of state.

        Examples
        --------
        >>> w = Chemical('water', T=520)
        >>> w.Cvgm
        27.13366316134193


Cvgm = self.Cvgm<EOL>if Cvgm:<EOL><INDENT>return property_molar_to_mass(Cvgm, self.MW)<EOL><DEDENT>return None<EOL>

r'''Gas-phase ideal-gas contant-volume heat capacity of the chemical at
        its current temperature, in units of [J/kg/K]. Subtracts R from
        the ideal-gas heat capacity; does not include pressure-compensation
        from an equation of state.

        Examples
        --------
        >>> w = Chemical('water', T=520)
        >>> w.Cvg
        1506.1471795798861


Cp, Cv = self.Cpg, self.Cvg<EOL>if all((Cp, Cv)):<EOL><INDENT>return isentropic_exponent(Cp, Cv)<EOL><DEDENT>return None<EOL>

r'''Gas-phase ideal-gas isentropic exponent of the chemical at its
        current temperature, [dimensionless]. Does not include
        pressure-compensation from an equation of state.

        Examples
        --------
        >>> Chemical('hydrogen').isentropic_exponent
        1.405237786321222


return self.VolumeSolid(self.T)<EOL>

r'''Solid-phase molar volume of the chemical at its current
        temperature, in units of [m^3/mol]. For calculation of this property at
        other temperatures, or specifying manually the method used to calculate
        it, and more - see the object oriented interface
        :obj:`thermo.volume.VolumeSolid`; each Chemical instance
        creates one to actually perform the calculations.

        Examples
        --------
        >>> Chemical('iron').Vms
        7.09593392630242e-06


return self.VolumeLiquid(self.T, self.P)<EOL>

r'''Liquid-phase molar volume of the chemical at its current
        temperature and pressure, in units of [m^3/mol]. For calculation of this
        property at other temperatures or pressures, or specifying manually the
        method used to calculate it, and more - see the object oriented interface
        :obj:`thermo.volume.VolumeLiquid`; each Chemical instance
        creates one to actually perform the calculations.

        Examples
        --------
        >>> Chemical('cyclobutane', T=225).Vml
        7.42395423425395e-05


return self.VolumeGas(self.T, self.P)<EOL>

r'''Gas-phase molar volume of the chemical at its current
        temperature and pressure, in units of [m^3/mol]. For calculation of this
        property at other temperatures or pressures, or specifying manually the
        method used to calculate it, and more - see the object oriented interface
        :obj:`thermo.volume.VolumeGas`; each Chemical instance
        creates one to actually perform the calculations.

        Examples
        --------
        Estimate the molar volume of the core of the sun, at 15 million K and
        26.5 PetaPascals, assuming pure helium (actually 68% helium):

        >>> Chemical('helium', T=15E6, P=26.5E15).Vmg
        4.805464238181197e-07


Vms = self.Vms<EOL>if Vms:<EOL><INDENT>return Vm_to_rho(Vms, self.MW)<EOL><DEDENT>return None<EOL>

r'''Solid-phase mass density of the chemical at its current temperature,
        in units of [kg/m^3]. For calculation of this property at
        other temperatures, or specifying manually the method used
        to calculate it, and more - see the object oriented interface
        :obj:`thermo.volume.VolumeSolid`; each Chemical instance
        creates one to actually perform the calculations. Note that that
        interface provides output in molar units.

        Examples
        --------
        >>> Chemical('iron').rhos
        7869.999999999994


Vml = self.Vml<EOL>if Vml:<EOL><INDENT>return Vm_to_rho(Vml, self.MW)<EOL><DEDENT>return None<EOL>

r'''Liquid-phase mass density of the chemical at its current
        temperature and pressure, in units of [kg/m^3]. For calculation of this
        property at other temperatures and pressures, or specifying manually
        the method used to calculate it, and more - see the object oriented
        interface :obj:`thermo.volume.VolumeLiquid`; each Chemical instance
        creates one to actually perform the calculations. Note that that
        interface provides output in molar units.

        Examples
        --------
        >>> Chemical('o-xylene', T=297).rhol
        876.9946785618097


Vmg = self.Vmg<EOL>if Vmg:<EOL><INDENT>return Vm_to_rho(Vmg, self.MW)<EOL><DEDENT>return None<EOL>

r'''Gas-phase mass density of the chemical at its current temperature
        and pressure, in units of [kg/m^3]. For calculation of this property at
        other temperatures or pressures, or specifying manually the method used
        to calculate it, and more - see the object oriented interface
        :obj:`thermo.volume.VolumeGas`; each Chemical instance
        creates one to actually perform the calculations. Note that that
        interface provides output in molar units.

        Examples
        --------
        Estimate the density of the core of the sun, at 15 million K and
        26.5 PetaPascals, assuming pure helium (actually 68% helium):

        >>> Chemical('helium', T=15E6, P=26.5E15).rhog
        8329.27226509739

        Compared to a result on
        `Wikipedia <https://en.wikipedia.org/wiki/Solar_core>`_ of 150000
        kg/m^3, the fundamental equation of state performs poorly.

        >>> He = Chemical('helium', T=15E6, P=26.5E15)
        >>> He.VolumeGas.set_user_methods_P(['IDEAL']); He.rhog
        850477.8065477367

        The ideal-gas law performs somewhat better, but vastly overshoots
        the density prediction.


Vms = self.Vms<EOL>if Vms:<EOL><INDENT>return <NUM_LIT:1.>/Vms<EOL><DEDENT>return None<EOL>

r'''Molar density of the chemical in the solid phase at the
        current temperature and pressure, in units of [mol/m^3].

        Utilizes the object oriented interface and
        :obj:`thermo.volume.VolumeSolid` to perform the actual calculation of
        molar volume.

        Examples
        --------
        >>> Chemical('palladium').rhosm
        112760.75925577903


Vml = self.Vml<EOL>if Vml:<EOL><INDENT>return <NUM_LIT:1.>/Vml<EOL><DEDENT>return None<EOL>

r'''Molar density of the chemical in the liquid phase at the
        current temperature and pressure, in units of [mol/m^3].

        Utilizes the object oriented interface and
        :obj:`thermo.volume.VolumeLiquid` to perform the actual calculation of
        molar volume.

        Examples
        --------
        >>> Chemical('nitrogen', T=70).rholm
        29937.20179186975


Vmg = self.Vmg<EOL>if Vmg:<EOL><INDENT>return <NUM_LIT:1.>/Vmg<EOL><DEDENT>return None<EOL>

r'''Molar density of the chemical in the gas phase at the
        current temperature and pressure, in units of [mol/m^3].

        Utilizes the object oriented interface and
        :obj:`thermo.volume.VolumeGas` to perform the actual calculation of
        molar volume.

        Examples
        --------
        >>> Chemical('tungsten hexafluoride').rhogm
        42.01349946063116


Vms = self.Vms<EOL>if Vms:<EOL><INDENT>return Z(self.T, self.P, Vms)<EOL><DEDENT>return None<EOL>

r'''Compressibility factor of the chemical in the solid phase at the
        current temperature and pressure, [dimensionless].

        Utilizes the object oriented interface and
        :obj:`thermo.volume.VolumeSolid` to perform the actual calculation of
        molar volume.

        Examples
        --------
        >>> Chemical('palladium').Z
        0.00036248477437931853


Vml = self.Vml<EOL>if Vml:<EOL><INDENT>return Z(self.T, self.P, Vml)<EOL><DEDENT>return None<EOL>

r'''Compressibility factor of the chemical in the liquid phase at the
        current temperature and pressure, [dimensionless].

        Utilizes the object oriented interface and
        :obj:`thermo.volume.VolumeLiquid` to perform the actual calculation of
        molar volume.

        Examples
        --------
        >>> Chemical('water').Zl
        0.0007385375470263454


Vmg = self.Vmg<EOL>if Vmg:<EOL><INDENT>return Z(self.T, self.P, Vmg)<EOL><DEDENT>return None<EOL>

r'''Compressibility factor of the chemical in the gas phase at the
        current temperature and pressure, [dimensionless].

        Utilizes the object oriented interface and
        :obj:`thermo.volume.VolumeGas` to perform the actual calculation of
        molar volume.

        Examples
        --------
        >>> Chemical('sulfur hexafluoride', T=700, P=1E9).Zg
        11.140084184207813


rhos = self.rhos<EOL>if rhos is not None:<EOL><INDENT>return SG(rhos)<EOL><DEDENT>return None<EOL>

r'''Specific gravity of the solid phase of the chemical at the
        specified temperature and pressure, [dimensionless].
        The reference condition is water at 4 °C and 1 atm
        (rho=999.017 kg/m^3). The SG varries with temperature and pressure
        but only very slightly.

        Examples
        --------
        >>> Chemical('iron').SGs
        7.87774317235069


rhol = self.rhol<EOL>if rhol is not None:<EOL><INDENT>return SG(rhol)<EOL><DEDENT>return None<EOL>

r'''Specific gravity of the liquid phase of the chemical at the
        specified temperature and pressure, [dimensionless].
        The reference condition is water at 4 °C and 1 atm
        (rho=999.017 kg/m^3). For liquids, SG is defined that the reference
        chemical's T and P are fixed, but the chemical itself varies with
        the specified T and P.

        Examples
        --------
        >>> Chemical('water', T=365).SGl
        0.9650065522428539


Vmg = self.VolumeGas(T=<NUM_LIT>, P=<NUM_LIT>)<EOL>if Vmg:<EOL><INDENT>rho = Vm_to_rho(Vmg, self.MW)<EOL>return SG(rho, rho_ref=<NUM_LIT>) <EOL><DEDENT>return None<EOL>

r'''Specific gravity of the gas phase of the chemical, [dimensionless].
        The reference condition is air at 15.6 °C (60 °F) and 1 atm
        (rho=1.223 kg/m^3). The definition for gases uses the compressibility
        factor of the reference gas and the chemical both at the reference
        conditions, not the conditions of the chemical.

        Examples
        --------
        >>> Chemical('argon').SGg
        1.3795835970877504


Vml = self.VolumeLiquid(T=<NUM_LIT>, P=<NUM_LIT>)<EOL>if Vml:<EOL><INDENT>rho = Vm_to_rho(Vml, self.MW)<EOL><DEDENT>sg = SG(rho, rho_ref=<NUM_LIT>)<EOL>return SG_to_API(sg)<EOL>

r'''API gravity of the liquid phase of the chemical, [degrees].
        The reference condition is water at 15.6 °C (60 °F) and 1 atm
        (rho=999.016 kg/m^3, standardized).

        Examples
        --------
        >>> Chemical('water').API
        9.999752435378895


if self.Vmg:<EOL><INDENT>return B_from_Z(self.Zg, self.T, self.P)<EOL><DEDENT>return None<EOL>

r'''Second virial coefficient of the gas phase of the chemical at its
        current temperature and pressure, in units of [mol/m^3].

        This property uses the object-oriented interface
        :obj:`thermo.volume.VolumeGas`, converting its result with
        :obj:`thermo.utils.B_from_Z`.

        Examples
        --------
        >>> Chemical('water').Bvirial
        -0.0009596286322838357


dV_dT = self.VolumeLiquid.TP_dependent_property_derivative_T(self.T, self.P)<EOL>Vm = self.Vml<EOL>if dV_dT and Vm:<EOL><INDENT>return isobaric_expansion(V=Vm, dV_dT=dV_dT)<EOL><DEDENT>

r'''Isobaric (constant-pressure) expansion of the liquid phase of the
        chemical at its current temperature and pressure, in units of [1/K].

        .. math::
            \beta = \frac{1}{V}\left(\frac{\partial V}{\partial T} \right)_P

        Utilizes the temperature-derivative method of
        :obj:`thermo.volume.VolumeLiquid` to perform the actual calculation.
        The derivatives are all numerical.

        Examples
        --------
        >>> Chemical('dodecane', T=400).isobaric_expansion_l
        0.0011617555762469477


dV_dT = self.VolumeGas.TP_dependent_property_derivative_T(self.T, self.P)<EOL>Vm = self.Vmg<EOL>if dV_dT and Vm:<EOL><INDENT>return isobaric_expansion(V=Vm, dV_dT=dV_dT)<EOL><DEDENT>

r'''Isobaric (constant-pressure) expansion of the gas phase of the
        chemical at its current temperature and pressure, in units of [1/K].

        .. math::
            \beta = \frac{1}{V}\left(\frac{\partial V}{\partial T} \right)_P

        Utilizes the temperature-derivative method of
        :obj:`thermo.VolumeGas` to perform the actual calculation.
        The derivatives are all numerical.

        Examples
        --------
        >>> Chemical('Hexachlorobenzene', T=900).isobaric_expansion_g
        0.001151869741981048


return self.ViscosityLiquid(self.T, self.P)<EOL>

r'''Viscosity of the chemical in the liquid phase at its current
        temperature and pressure, in units of [Pa*s].

        For calculation of this property at other temperatures and pressures,
        or specifying manually the method used to calculate it, and more - see
        the object oriented interface
        :obj:`thermo.viscosity.ViscosityLiquid`; each Chemical instance
        creates one to actually perform the calculations.

        Examples
        --------
        >>> Chemical('water', T=320).mul
        0.0005767262693751547


return self.ViscosityGas(self.T, self.P)<EOL>

r'''Viscosity of the chemical in the gas phase at its current
        temperature and pressure, in units of [Pa*s].

        For calculation of this property at other temperatures and pressures,
        or specifying manually the method used to calculate it, and more - see
        the object oriented interface
        :obj:`thermo.viscosity.ViscosityGas`; each Chemical instance
        creates one to actually perform the calculations.

        Examples
        --------
        >>> Chemical('water', T=320, P=100).mug
        1.0431450856297212e-05


return self.ThermalConductivityLiquid(self.T, self.P)<EOL>

r'''Thermal conductivity of the chemical in the liquid phase at its
        current temperature and pressure, in units of [W/m/K].

        For calculation of this property at other temperatures and pressures,
        or specifying manually the method used to calculate it, and more - see
        the object oriented interface
        :obj:`thermo.thermal_conductivity.ThermalConductivityLiquid`; each
        Chemical instance creates one to actually perform the calculations.

        Examples
        --------
        >>> Chemical('water', T=320).kl
        0.6369957248212118


return self.ThermalConductivityGas(self.T, self.P)<EOL>

r'''Thermal conductivity of the chemical in the gas phase at its
        current temperature and pressure, in units of [W/m/K].

        For calculation of this property at other temperatures and pressures,
        or specifying manually the method used to calculate it, and more - see
        the object oriented interface
        :obj:`thermo.thermal_conductivity.ThermalConductivityGas`; each
        Chemical instance creates one to actually perform the calculations.

        Examples
        --------
        >>> Chemical('water', T=320).kg
        0.021273128263091207


return self.SurfaceTension(self.T)<EOL>

r'''Surface tension of the chemical at its current temperature, in
        units of [N/m].

        For calculation of this property at other temperatures,
        or specifying manually the method used to calculate it, and more - see
        the object oriented interface :obj:`thermo.interface.SurfaceTension`;
        each Chemical instance creates one to actually perform the calculations.

        Examples
        --------
        >>> Chemical('water', T=320).sigma
        0.06855002575793023
        >>> Chemical('water', T=320).SurfaceTension.solve_prop(0.05)
        416.8307110842183


return self.Permittivity(self.T)<EOL>

r'''Relative permittivity (dielectric constant) of the chemical at its
        current temperature, [dimensionless].

        For calculation of this property at other temperatures,
        or specifying manually the method used to calculate it, and more - see
        the object oriented interface :obj:`thermo.permittivity.Permittivity`;
        each Chemical instance creates one to actually perform the calculations.

        Examples
        --------
        >>> Chemical('toluene', T=250).permittivity
        2.49775625


permittivity = self.permittivity<EOL>if permittivity is not None:<EOL><INDENT>return permittivity*physical_constants['<STR_LIT>'][<NUM_LIT:0>]<EOL><DEDENT>return None<EOL>

r'''Absolute permittivity of the chemical at its current temperature,
        in units of [farad/meter]. Those units are equivalent to
        ampere^2*second^4/kg/m^3.

        Examples
        --------
        >>> Chemical('water', T=293.15).absolute_permittivity
        7.096684821859018e-10


Vml, Cplm, isobaric_expansion_l = self.Vml, self.Cplm, self.isobaric_expansion_l<EOL>if all((Vml, Cplm, isobaric_expansion_l)):<EOL><INDENT>return Joule_Thomson(T=self.T, V=Vml, Cp=Cplm, beta=isobaric_expansion_l)<EOL><DEDENT>return None<EOL>

r'''Joule Thomson coefficient of the chemical in the liquid phase at
        its current temperature and pressure, in units of [K/Pa].

        .. math::
            \mu_{JT} = \left(\frac{\partial T}{\partial P}\right)_H = \frac{1}{C_p}
            \left[T \left(\frac{\partial V}{\partial T}\right)_P - V\right]
            = \frac{V}{C_p}\left(\beta T-1\right)

        Utilizes the temperature-derivative method of
        :obj:`thermo.volume.VolumeLiquid` and the temperature-dependent heat
        capacity method :obj:`thermo.heat_capacity.HeatCapacityLiquid` to
        obtain the properties required for the actual calculation.

        Examples
        --------
        >>> Chemical('dodecane', T=400).JTl
        -3.0827160465192742e-07


Vmg, Cpgm, isobaric_expansion_g = self.Vmg, self.Cpgm, self.isobaric_expansion_g<EOL>if all((Vmg, Cpgm, isobaric_expansion_g)):<EOL><INDENT>return Joule_Thomson(T=self.T, V=Vmg, Cp=Cpgm, beta=isobaric_expansion_g)<EOL><DEDENT>return None<EOL>

r'''Joule Thomson coefficient of the chemical in the gas phase at
        its current temperature and pressure, in units of [K/Pa].

        .. math::
            \mu_{JT} = \left(\frac{\partial T}{\partial P}\right)_H = \frac{1}{C_p}
            \left[T \left(\frac{\partial V}{\partial T}\right)_P - V\right]
            = \frac{V}{C_p}\left(\beta T-1\right)

        Utilizes the temperature-derivative method of
        :obj:`thermo.volume.VolumeGas` and the temperature-dependent heat
        capacity method :obj:`thermo.heat_capacity.HeatCapacityGas` to
        obtain the properties required for the actual calculation.

        Examples
        --------
        >>> Chemical('dodecane', T=400, P=1000).JTg
        5.4089897835384913e-05


mul, rhol = self.mul, self.rhol<EOL>if all([mul, rhol]):<EOL><INDENT>return nu_mu_converter(mu=mul, rho=rhol)<EOL><DEDENT>return None<EOL>

r'''Kinematic viscosity of the liquid phase of the chemical at its
        current temperature and pressure, in units of [m^2/s].

        .. math::
            \nu = \frac{\mu}{\rho}

        Utilizes the temperature and pressure dependent object oriented
        interfaces :obj:`thermo.volume.VolumeLiquid`,
        :obj:`thermo.viscosity.ViscosityLiquid`  to calculate the
        actual properties.

        Examples
        --------
        >>> Chemical('methane', T=110).nul
        2.858088468937331e-07


mug, rhog = self.mug, self.rhog<EOL>if all([mug, rhog]):<EOL><INDENT>return nu_mu_converter(mu=mug, rho=rhog)<EOL><DEDENT>return None<EOL>

r'''Kinematic viscosity of the gas phase of the chemical at its
        current temperature and pressure, in units of [m^2/s].

        .. math::
            \nu = \frac{\mu}{\rho}

        Utilizes the temperature and pressure dependent object oriented
        interfaces :obj:`thermo.volume.VolumeGas`,
        :obj:`thermo.viscosity.ViscosityGas`  to calculate the
        actual properties.

        Examples
        --------
        >>> Chemical('methane', T=115).nug
        2.5056924327995865e-06


kl, rhol, Cpl = self.kl, self.rhol, self.Cpl<EOL>if all([kl, rhol, Cpl]):<EOL><INDENT>return thermal_diffusivity(k=kl, rho=rhol, Cp=Cpl)<EOL><DEDENT>return None<EOL>

r'''Thermal diffusivity of the liquid phase of the chemical at its
        current temperature and pressure, in units of [m^2/s].

        .. math::
            \alpha = \frac{k}{\rho Cp}

        Utilizes the temperature and pressure dependent object oriented
        interfaces :obj:`thermo.volume.VolumeLiquid`,
        :obj:`thermo.thermal_conductivity.ThermalConductivityLiquid`,
        and :obj:`thermo.heat_capacity.HeatCapacityLiquid` to calculate the
        actual properties.

        Examples
        --------
        >>> Chemical('nitrogen', T=70).alphal
        9.444949636299626e-08


kg, rhog, Cpg = self.kg, self.rhog, self.Cpg<EOL>if all([kg, rhog, Cpg]):<EOL><INDENT>return thermal_diffusivity(k=kg, rho=rhog, Cp=Cpg)<EOL><DEDENT>return None<EOL>

r'''Thermal diffusivity of the gas phase of the chemical at its
        current temperature and pressure, in units of [m^2/s].

        .. math::
            \alpha = \frac{k}{\rho Cp}

        Utilizes the temperature and pressure dependent object oriented
        interfaces :obj:`thermo.volume.VolumeGas`,
        :obj:`thermo.thermal_conductivity.ThermalConductivityGas`,
        and :obj:`thermo.heat_capacity.HeatCapacityGas` to calculate the
        actual properties.

        Examples
        --------
        >>> Chemical('ammonia').alphag
        1.6931865425158556e-05


Cpl, mul, kl = self.Cpl, self.mul, self.kl<EOL>if all([Cpl, mul, kl]):<EOL><INDENT>return Prandtl(Cp=Cpl, mu=mul, k=kl)<EOL><DEDENT>return None<EOL>

r'''Prandtl number of the liquid phase of the chemical at its
        current temperature and pressure, [dimensionless].

        .. math::
            Pr = \frac{C_p \mu}{k}

        Utilizes the temperature and pressure dependent object oriented
        interfaces :obj:`thermo.viscosity.ViscosityLiquid`,
        :obj:`thermo.thermal_conductivity.ThermalConductivityLiquid`,
        and :obj:`thermo.heat_capacity.HeatCapacityLiquid` to calculate the
        actual properties.

        Examples
        --------
        >>> Chemical('nitrogen', T=70).Prl
        2.7828214501488886


Cpg, mug, kg = self.Cpg, self.mug, self.kg<EOL>if all([Cpg, mug, kg]):<EOL><INDENT>return Prandtl(Cp=Cpg, mu=mug, k=kg)<EOL><DEDENT>return None<EOL>

r'''Prandtl number of the gas phase of the chemical at its
        current temperature and pressure, [dimensionless].

        .. math::
            Pr = \frac{C_p \mu}{k}

        Utilizes the temperature and pressure dependent object oriented
        interfaces :obj:`thermo.viscosity.ViscosityGas`,
        :obj:`thermo.thermal_conductivity.ThermalConductivityGas`,
        and :obj:`thermo.heat_capacity.HeatCapacityGas` to calculate the
        actual properties.

        Examples
        --------
        >>> Chemical('NH3').Prg
        0.847263731933008


return solubility_parameter(T=self.T, Hvapm=self.Hvapm, Vml=self.Vml,<EOL>Method=self.solubility_parameter_method,<EOL>CASRN=self.CAS)<EOL>

r'''Solubility parameter of the chemical at its
        current temperature and pressure, in units of [Pa^0.5].

        .. math::
            \delta = \sqrt{\frac{\Delta H_{vap} - RT}{V_m}}

        Calculated based on enthalpy of vaporization and molar volume.
        Normally calculated at STP. For uses of this property, see
        :obj:`thermo.solubility.solubility_parameter`.

        Examples
        --------
        >>> Chemical('NH3').solubility_parameter
        24766.329043856073


sigma, rhol, rhog = self.sigma, self.rhol, self.rhog<EOL>if all((sigma, rhol, rhog, self.MW)):<EOL><INDENT>return Parachor(sigma=sigma, MW=self.MW, rhol=rhol, rhog=rhog)<EOL><DEDENT>return None<EOL>

r'''Parachor of the chemical at its
        current temperature and pressure, in units of [N^0.25*m^2.75/mol].

        .. math::
            P = \frac{\sigma^{0.25} MW}{\rho_L - \rho_V}

        Calculated based on surface tension, density of the liquid and gas
        phase, and molecular weight. For uses of this property, see
        :obj:`thermo.utils.Parachor`.

        Examples
        --------
        >>> Chemical('octane').Parachor
        6.291693072841486e-05


return phase_select_property(phase=self.phase, s=self.Cps, l=self.Cpl, g=self.Cpg)<EOL>

r'''Mass heat capacity of the chemical at its current phase and
        temperature, in units of [J/kg/K].

        Utilizes the object oriented interfaces
        :obj:`thermo.heat_capacity.HeatCapacitySolid`,
        :obj:`thermo.heat_capacity.HeatCapacityLiquid`,
        and :obj:`thermo.heat_capacity.HeatCapacityGas` to perform the
        actual calculation of each property. Note that those interfaces provide
        output in molar units (J/mol/K).

        Examples
        --------
        >>> w = Chemical('water')
        >>> w.Cp, w.phase
        (4180.597021827336, 'l')
        >>> Chemical('palladium').Cp
        234.26767209171211


return phase_select_property(phase=self.phase, s=self.Cpsm, l=self.Cplm, g=self.Cpgm)<EOL>

r'''Molar heat capacity of the chemical at its current phase and
        temperature, in units of [J/mol/K].

        Utilizes the object oriented interfaces
        :obj:`thermo.heat_capacity.HeatCapacitySolid`,
        :obj:`thermo.heat_capacity.HeatCapacityLiquid`,
        and :obj:`thermo.heat_capacity.HeatCapacityGas` to perform the
        actual calculation of each property.

        Examples
        --------
        >>> Chemical('cubane').Cpm
        137.05489206785944
        >>> Chemical('ethylbenzene', T=550, P=3E6).Cpm
        294.18449553310046


return phase_select_property(phase=self.phase, s=self.Vms, l=self.Vml, g=self.Vmg)<EOL>

r'''Molar volume of the chemical at its current phase and
        temperature and pressure, in units of [m^3/mol].

        Utilizes the object oriented interfaces
        :obj:`thermo.volume.VolumeSolid`,
        :obj:`thermo.volume.VolumeLiquid`,
        and :obj:`thermo.volume.VolumeGas` to perform the
        actual calculation of each property.

        Examples
        --------
        >>> Chemical('ethylbenzene', T=550, P=3E6).Vm
        0.00017758024401627633


return phase_select_property(phase=self.phase, s=self.rhos, l=self.rhol, g=self.rhog)<EOL>

r'''Mass density of the chemical at its current phase and
        temperature and pressure, in units of [kg/m^3].

        Utilizes the object oriented interfaces
        :obj:`thermo.volume.VolumeSolid`,
        :obj:`thermo.volume.VolumeLiquid`,
        and :obj:`thermo.volume.VolumeGas` to perform the
        actual calculation of each property. Note that those interfaces provide
        output in units of m^3/mol.

        Examples
        --------
        >>> Chemical('decane', T=550, P=2E6).rho
        498.67008448640604


return phase_select_property(phase=self.phase, s=self.rhosm, l=self.rholm, g=self.rhogm)<EOL>

r'''Molar density of the chemical at its current phase and
        temperature and pressure, in units of [mol/m^3].

        Utilizes the object oriented interfaces
        :obj:`thermo.volume.VolumeSolid`,
        :obj:`thermo.volume.VolumeLiquid`,
        and :obj:`thermo.volume.VolumeGas` to perform the
        actual calculation of each property. Note that those interfaces provide
        output in units of m^3/mol.

        Examples
        --------
        >>> Chemical('1-hexanol').rhom
        7983.414573003429


Vm = self.Vm<EOL>if Vm:<EOL><INDENT>return Z(self.T, self.P, Vm)<EOL><DEDENT>return None<EOL>

r'''Compressibility factor of the chemical at its current phase and
        temperature and pressure, [dimensionless].

        Examples
        --------
        >>> Chemical('MTBE', T=900, P=1E-2).Z
        0.9999999999079768


phase = self.phase<EOL>if phase == '<STR_LIT:l>':<EOL><INDENT>return self.SGl<EOL><DEDENT>elif phase == '<STR_LIT:s>':<EOL><INDENT>return self.SGs<EOL><DEDENT>elif phase == '<STR_LIT:g>':<EOL><INDENT>return self.SGg<EOL><DEDENT>rho = self.rho<EOL>if rho is not None:<EOL><INDENT>return SG(rho)<EOL><DEDENT>return None<EOL>

r'''Specific gravity of the chemical, [dimensionless].

        For gas-phase conditions, this is calculated at 15.6 °C (60 °F) and 1
        atm for the chemical and the reference fluid, air.
        For liquid and solid phase conditions, this is calculated based on a
        reference fluid of water at 4°C at 1 atm, but the with the liquid or
        solid chemical's density at the currently specified conditions.

        Examples
        --------
        >>> Chemical('MTBE').SG
        0.7428160596603596


return phase_select_property(phase=self.phase, l=self.isobaric_expansion_l, g=self.isobaric_expansion_g)<EOL>

r'''Isobaric (constant-pressure) expansion of the chemical at its
        current phase and temperature, in units of [1/K].

        .. math::
            \beta = \frac{1}{V}\left(\frac{\partial V}{\partial T} \right)_P

        Examples
        --------
        Radical change  in value just above and below the critical temperature
        of water:

        >>> Chemical('water', T=647.1, P=22048320.0).isobaric_expansion
        0.34074205839222449

        >>> Chemical('water', T=647.2, P=22048320.0).isobaric_expansion
        0.18143324022215077


return phase_select_property(phase=self.phase, l=self.JTl, g=self.JTg)<EOL>

r'''Joule Thomson coefficient of the chemical at its
        current phase and temperature, in units of [K/Pa].

        .. math::
            \mu_{JT} = \left(\frac{\partial T}{\partial P}\right)_H = \frac{1}{C_p}
            \left[T \left(\frac{\partial V}{\partial T}\right)_P - V\right]
            = \frac{V}{C_p}\left(\beta T-1\right)

        Examples
        --------
        >>> Chemical('water').JT
        -2.2150394958666407e-07


return phase_select_property(phase=self.phase, l=self.mul, g=self.mug)<EOL>

r'''Viscosity of the chemical at its current phase, temperature, and
        pressure in units of [Pa*s].

        Utilizes the object oriented interfaces
        :obj:`thermo.viscosity.ViscosityLiquid` and
        :obj:`thermo.viscosity.ViscosityGas` to perform the
        actual calculation of each property.

        Examples
        --------
        >>> Chemical('ethanol', T=300).mu
        0.001044526538460911
        >>> Chemical('ethanol', T=400).mu
        1.1853097849748217e-05


return phase_select_property(phase=self.phase, s=None, l=self.kl, g=self.kg)<EOL>

r'''Thermal conductivity of the chemical at its current phase,
        temperature, and pressure in units of [W/m/K].

        Utilizes the object oriented interfaces
        :obj:`thermo.thermal_conductivity.ThermalConductivityLiquid` and
        :obj:`thermo.thermal_conductivity.ThermalConductivityGas` to perform
        the actual calculation of each property.

        Examples
        --------
        >>> Chemical('ethanol', T=300).kl
        0.16313594741877802
        >>> Chemical('ethanol', T=400).kg
        0.026019924109310026


return phase_select_property(phase=self.phase, l=self.nul, g=self.nug)<EOL>

r'''Kinematic viscosity of the the chemical at its current temperature,
        pressure, and phase in units of [m^2/s].

        .. math::
            \nu = \frac{\mu}{\rho}

        Examples
        --------
        >>> Chemical('argon').nu
        1.3846930410865003e-05


return phase_select_property(phase=self.phase, l=self.alphal, g=self.alphag)<EOL>

r'''Thermal diffusivity of the chemical at its current temperature,
        pressure, and phase in units of [m^2/s].

        .. math::
            \alpha = \frac{k}{\rho Cp}

        Examples
        --------
        >>> Chemical('furfural').alpha
        8.696537158635412e-08


return phase_select_property(phase=self.phase, l=self.Prl, g=self.Prg)<EOL>

r'''Prandtl number of the chemical at its current temperature,
        pressure, and phase; [dimensionless].

        .. math::
            Pr = \frac{C_p \mu}{k}

        Examples
        --------
        >>> Chemical('acetone').Pr
        4.183039103542709


Vml, Psat = self.Vml, self.Psat<EOL>if Vml and Psat:<EOL><INDENT>return exp(Vml*(self.P-Psat)/R/self.T)<EOL><DEDENT>return None<EOL>

r'''Poynting correction factor [dimensionless] for use in phase
        equilibria methods based on activity coefficients or other reference
        states. Performs the shortcut calculation assuming molar volume is
        independent of pressure.

        .. math::
            \text{Poy} =  \exp\left[\frac{V_l (P-P^{sat})}{RT}\right]

        The full calculation normally returns values very close to the
        approximate ones. This property is defined in terms of
        pure components only.

        Examples
        --------
        >>> Chemical('pentane', T=300, P=1E7).Poynting
        1.5743051250679803

        Notes
        -----
        The full equation shown below can be used as follows:

        .. math::
            \text{Poy} = \exp\left[\frac{\int_{P_i^{sat}}^P V_i^l dP}{RT}\right]

        >>> from scipy.integrate import quad
        >>> c = Chemical('pentane', T=300, P=1E7)
        >>> exp(quad(lambda P : c.VolumeLiquid(c.T, P), c.Psat, c.P)[0]/R/c.T)
        1.5821826990975127


self._parent_path = value<EOL>self.path = value + r'<STR_LIT:/>' + self.name<EOL>self._update_childrens_parent_path()<EOL>

Set the parent path and the path from the new parent path.

:param value: The path to the object's parent


def create_account(self, name, number=None, description=None):

new_account = GeneralLedgerAccount(name, description, number,<EOL>self.account_type)<EOL>new_account.set_parent_path(self.path)<EOL>self.accounts.append(new_account)<EOL>return new_account<EOL>

Create a sub account in the account.

:param name: The account name.
:param description: The account description.
:param number: The account number.

:returns: The created account.


acc_to_remove = None<EOL>for a in self.accounts:<EOL><INDENT>if a.name == name:<EOL><INDENT>acc_to_remove = a<EOL><DEDENT><DEDENT>if acc_to_remove is not None:<EOL><INDENT>self.accounts.remove(acc_to_remove)<EOL><DEDENT>

Remove an account from the account's sub accounts.

:param name: The name of the account to remove.


if r'<STR_LIT:/>' in account_name:<EOL><INDENT>accs_in_path = account_name.split(r'<STR_LIT:/>', <NUM_LIT:1>)<EOL>curr_acc = self[accs_in_path[<NUM_LIT:0>]]<EOL>if curr_acc is None:<EOL><INDENT>return None<EOL><DEDENT>return curr_acc.get_child_account(accs_in_path[<NUM_LIT:1>])<EOL>pass<EOL><DEDENT>else:<EOL><INDENT>return self[account_name]<EOL><DEDENT>

Retrieves a child account.
This could be a descendant nested at any level.

:param account_name: The name of the account to retrieve.

:returns: The child account, if found, else None.


def _create_account_(self, name, number, account_type):

new_acc = GeneralLedgerAccount(name, None, number, account_type)<EOL>self.accounts.append(new_acc)<EOL>return new_acc<EOL>

Create an account in the general ledger structure.

:param name: The account name.
:param number: The account number.
:param account_type: The account type.

:returns: The created account.


Retrieves an account from the general ledger structure
given the account name.

:param account_name: The account name.

:returns: The requested account, if found, else None.


result = []<EOL>for child in account.accounts:<EOL><INDENT>self._get_account_and_descendants_(child, result)<EOL><DEDENT>return result<EOL>

Retrieves an account's descendants from the general ledger structure
given the account name.

:param account_name: The account name.

:returns: The decendants of the account.


def _get_account_and_descendants_(self, account, result):

result.append(account)<EOL>for child in account.accounts:<EOL><INDENT>self._get_account_and_descendants_(child, result)<EOL><DEDENT>

Returns the account and all of it's sub accounts.

:param account: The account.
:param result: The list to add all the accounts to.


for name in names:<EOL><INDENT>if self.get_account(name) is None:<EOL><INDENT>raise ValueError("<STR_LIT>"<EOL>"<STR_LIT>".format(name))<EOL><DEDENT><DEDENT>

Validates whether the accounts in a list of account names exists.

:param names: The names of the accounts.

:returns: The descendants of the account.


def report(self, format=ReportFormat.printout, output_path=None):

rpt = GlsRpt(self, output_path)<EOL>return rpt.render(format)<EOL>

Returns a report of this class.

:param format: The format of the report.
:param output_path: The path to the file the report is written to.
  If None, then the report is not written to a file.

:returns: The descendants of the account.


def create_transaction(self, name, description=None,<EOL>tx_date=datetime.min.date(),<EOL>dt_account=None, cr_account=None,<EOL>source=None, amount=<NUM_LIT>):

new_tx = Transaction(name, description, tx_date,<EOL>dt_account, cr_account, source, amount)<EOL>self.transactions.append(new_tx)<EOL>return new_tx<EOL>

Create a transaction in the general ledger.

:param name: The transaction's name.
:param description: The transaction's description.
:param tx_date: The date of the transaction.
:param cr_account: The transaction's credit account's name.
:param dt_account: The transaction's debit account's name.
:param source: The name of source the transaction originated from.
:param amount: The transaction amount.

:returns: The created transaction.


rpt = TransactionList(self, start, end, component_path, output_path)<EOL>return rpt.render(format)<EOL>

Generate a transaction list report.

:param start: The start date to generate the report for.
:param end: The end date to generate the report for.
:param format: The format of the report.
:param component_path: The path of the component to filter the report's
  transactions by.
:param output_path: The path to the file the report is written to.
  If None, then the report is not written to a file.

:returns: The generated report.


def balance_sheet(self, end=datetime.max,<EOL>format=ReportFormat.printout, output_path=None):

rpt = BalanceSheet(self, end, output_path)<EOL>return rpt.render(format)<EOL>

Generate a transaction list report.

:param end: The end date to generate the report for.
:param format: The format of the report.
:param output_path: The path to the file the report is written to.
  If None, then the report is not written to a file.

:returns: The generated report.


rpt = IncomeStatement(self, start, end, component_path, output_path)<EOL>return rpt.render(format)<EOL>


pass<EOL>

Run the model.

:param streams: A dictionary of streams in the model.
:returns: The streams dictionary with the output streams calculated by
this model.

If the input streams to required by the model is not found in the
dictionary, the model will create the streams by itself based on its
parameters and input variables.


result = list()<EOL>for line in lines:<EOL><INDENT>line = line.strip()<EOL>line = line.replace("<STR_LIT:\t>", "<STR_LIT:U+0020>")<EOL>while line.find("<STR_LIT:U+0020>") > -<NUM_LIT:1>:<EOL><INDENT>line = line.replace("<STR_LIT:U+0020>", "<STR_LIT:U+0020>")<EOL><DEDENT>result.append(line)<EOL><DEDENT>return result<EOL>

Prepare the lines read from the text file before starting to
process it.

:param lines: The lines to prepare.


element_set = stoich.elements(self.compounds)<EOL>return sorted(list(element_set))<EOL>

Extract an alphabetically sorted list of elements from the
material's compounds.

:returns: Alphabetically sorted list of elements.


return self.compounds.index(compound)<EOL>

Determine the specified compound's index.

:param compound: Formula and phase of a compound, e.g. "Fe2O3[S1]".

:returns: Compound index.


return numpy.zeros(self.compound_count)<EOL>

Create an empty array to store an assay.

The array's length will be equal to the number of compounds in the
material.

:returns: Empty assay array.


if not type(assay) is numpy.ndarray:<EOL><INDENT>raise Exception("<STR_LIT>")<EOL><DEDENT>elif not assay.shape == (self.compound_count,):<EOL><INDENT>raise Exception("<STR_LIT>"<EOL>"<STR_LIT>")<EOL><DEDENT>elif name in self.raw_assays.keys():<EOL><INDENT>raise Exception("<STR_LIT>"<EOL>"<STR_LIT>")<EOL><DEDENT>self.raw_assays[name] = assay<EOL>self.converted_assays[name] = assay<EOL>

Add an assay to the material.

:param name:  Assay name.
:param assay: Numpy array containing the compound mass fractions for
  the assay. The sequence of the assay's elements must correspond to
  the sequence of the material's compounds.


return sum(self.converted_assays[name])<EOL>

Calculate the total/sum of the specified assay's mass fractions.

:param name: Assay name.

:returns: Total mass fraction.


def create_package(self, assay=None, mass=<NUM_LIT:0.0>, P=<NUM_LIT:1.0>, T=<NUM_LIT>,<EOL>normalise=True):

if assay is None:<EOL><INDENT>return MaterialPackage(self, self.create_empty_assay(), P, T)<EOL><DEDENT>if normalise:<EOL><INDENT>assay_total = self.get_assay_total(assay)<EOL><DEDENT>else:<EOL><INDENT>assay_total = <NUM_LIT:1.0><EOL><DEDENT>return MaterialPackage(self, mass * self.converted_assays[assay] /<EOL>assay_total, P, T, self._isCoal(assay),<EOL>self._get_HHV(assay))<EOL>

Create a MaterialPackage based on the specified parameters.

:param assay:     Name of the assay to be used to create the package.
:param mass:      Package mass. [kg]
:param P:         Package pressure. [atm]
:param T:         Package temperature. [°C]
:param normalise: Indicates whether the assay must be normalised
  before creating the package.

:returns: MaterialPackage object.


def create_stream(self, assay=None, mfr=<NUM_LIT:0.0>, P=<NUM_LIT:1.0>, T=<NUM_LIT>,<EOL>normalise=True):

if assay is None:<EOL><INDENT>return MaterialStream(self, self.create_empty_assay(), P, T)<EOL><DEDENT>if normalise:<EOL><INDENT>assay_total = self.get_assay_total(assay)<EOL><DEDENT>else:<EOL><INDENT>assay_total = <NUM_LIT:1.0><EOL><DEDENT>return MaterialStream(self, mfr * self.converted_assays[assay] /<EOL>assay_total, P, T, self._isCoal(assay),<EOL>self._get_HHV(assay))<EOL>

Create a MaterialStream based on the specified parameters.

:param assay: Name of the assay to be used to create the stream.
:param mfr: Stream mass flow rate. [kg/h]
:param P: Stream pressure. [atm]
:param T: Stream temperature. [°C]
:param normalise: Indicates whether the assay must be normalised
before creating the Stream.

:returns: MaterialStream object.