epcsaft.regression#

Declare parameter estimation and read native predictions and exact derivatives.

Names map to native component/site indices. All property evaluations, equilibrium solves, coordinate transforms, hydration constraints and fitting iterations run in the native owners (ALG-FIT). Temperatures use K, pressures Pa and feed amounts mol. Observation units are stated by each constructor. Difference residuals are (prediction-observed)/scale; log-ratio residuals are natural ln(prediction/observed) and accept no supplied scale.

epcsaft.regression.measured_input(parameters: epcsaft.parameters.Parameters, kind: str, *, sigma: float, bounds: tuple[float, float], unit: str, species: str | None = None) → epcsaft._core.MeasuredInput#

Declare one uncertain physical input for native errors-in-variables estimation.

Parameters:
  • parameters (epcsaft.parameters.Parameters) – Ordered names used to resolve a mole-fraction species.

  • kind ({'temperature', 'pressure', 'mole_fraction', 'molality'}) – Measured input type; respective units are K, Pa, dimensionless and mol/kg solvent.

  • sigma (float) – Measurement standard deviation in the input’s physical unit. Native fitting admits finite nonnegative values; zero fixes this input and removes its fitted correction.

  • bounds (tuple of float) – Lower and upper true-input bounds in the same unit.

  • unit (str) – Exact native label: ‘K’, ‘Pa’, ‘mol/mol’ or ‘mol/kg’ for temperature, pressure, mole fraction or molality, respectively.

  • species (str, optional) – Required only for mole_fraction; identifies its component.

Returns:

input – Native input-error declaration; no reconciliation has been solved.

Return type:

MeasuredInput

Raises:

ParameterError – Unknown kind/species, or species supplied for a non-composition input or omitted for a mole-fraction input.

Notes

Native fitting checks finite bounds, the physical domain and the measured value’s inclusion in its bounds. MeasurementUncertainty may declare a joint covariance or correlation; without one, the measurement errors are treated independently (ALG-FIT).

epcsaft.regression.measurement_group(parameters: epcsaft.parameters.Parameters, rows: collections.abc.Sequence[int], inputs: collections.abc.Sequence[epcsaft._core.MeasuredInput], *, dependent_species: collections.abc.Sequence[str] | None = None, feed_total_mol: float | None = None) → epcsaft._core.MeasurementGroup#

Group observation rows sharing the same uncertain input measurement.

Parameters:
  • parameters (epcsaft.parameters.Parameters) – Component names used for dependent-species indices.

  • rows (sequence of int) – Zero-based observation-row indices sharing the inputs.

  • inputs (sequence of MeasuredInput) – Measurement declarations with K, Pa, dimensionless mole-fraction or mol/kg solvent units as appropriate.

  • dependent_species (sequence of str, optional) – Explicit dependent feed species for composition closure.

  • feed_total_mol (float, optional) – Fixed total feed amount in mol when required by the measurement chart.

Returns:

group – Native row/input group; independent input errors are not fitted here.

Return type:

MeasurementGroup

Raises:

ParameterError – A dependent-species identifier is unknown.

Notes

Native fitting validates row membership, closure and shared-measurement requirements before solving the input-error objective (ALG-FIT).

epcsaft.regression.active_parameter(parameters: epcsaft.parameters.Parameters, family: str, target: object) → epcsaft._core.ActiveParameter#

Resolve a named physical parameter into exact native derivative slots.

Parameters:
  • parameters (epcsaft.parameters.Parameters) – Component/site order and temperature-law coefficient identities.

  • family (str) – Native parameter-family name, e.g. segment_diameter or k_ij.

  • target (object) – Component identifier, unordered component pair, association-site pair, temperature-law coefficient identity, or None for a global scalar.

Returns:

parameter – One physical derivative coordinate owning the selected native slots. Native units include Å for diameters, K for energy/k, m³/mol for dielectric volume and dimensionless k_ij/l_ij (ALG-PARAMETERS).

Return type:

ActiveParameter

Raises:

ParameterError – Family/target is unknown, a global target is supplied, or an unlike component pair has equal endpoints.

Notes

Unlike pairs own both mirrored entries. Same-site association may own its one diagonal slot. No logarithmic coordinate transform is implied.

epcsaft.regression.coordinate(parameters: epcsaft.parameters.Parameters, targets: collections.abc.Sequence[tuple[str, object, float]], *, origin: float, scale: float, bounds: tuple[float, float] | None = None) → epcsaft._core.Coordinate#

Declare an affine optimizer coordinate tied to named physical parameters.

Parameters:
  • parameters (epcsaft.parameters.Parameters) – Names and native slots to resolve.

  • targets (sequence of tuple) – (Family, component/pair/coefficient identity or None, coefficient). A target’s value is coefficient times physical coordinate q; the coefficient converts q units into the native target-family unit.

  • origin (float) – Physical q origin, in the caller-declared coordinate unit.

  • scale (float) – Physical q increment per dimensionless optimizer increment.

  • bounds (tuple of float, optional) – Inclusive q bounds in the same physical unit; absent means unbounded.

Returns:

coordinate – Declaration with q = origin + scale*v for dimensionless optimizer v. Native target values are coefficient*q.

Return type:

Coordinate

Raises:

ParameterError – A family or target cannot be resolved by active_parameter rules.

Notes

Native chart admission checks scales, bounds and conflicting targets. For a source dielectric-volume coordinate in L/mol, coefficient 1e-3 converts to native m³/mol (ALG-PARAMETERS and ALG-FIT).

epcsaft.regression.reaction_coordinate(name: str, coefficient: str, *, origin: float, scale: float, bounds: tuple[float, float] | None = None) → epcsaft._core.Coordinate#

Declare a fitted coefficient of a named source-basis reaction law.

Parameters:
  • name (str) – Reaction name shared by the fitted observation declarations.

  • coefficient ({'a', 'b', 'c', 'd'}) – Coefficient of natural ln K(T) = a + b/T + c*ln(T/T_ref) + d*T. Units are dimensionless, K, dimensionless and 1/K respectively.

  • origin (float) – Physical coefficient origin in its stated unit.

  • scale (float) – Coefficient increment per dimensionless optimizer increment.

  • bounds (tuple of float, optional) – Inclusive physical coefficient bounds; default is unbounded.

Returns:

coordinate – Named reaction coordinate with the affine optimizer chart.

Return type:

Coordinate

Raises:

ParameterError – Coefficient is not a, b, c or d.

Notes

For a scalar reaction K, the a coordinate fits natural ln K. Native admission checks named-reaction consistency and source reference (ALG-FIT).

Examples

>>> from epcsaft.regression import reaction_coordinate
>>> coordinate = reaction_coordinate('reaction', 'b', origin=100.0, scale=10.0)
>>> coordinate.origin, coordinate.scale
(100.0, 10.0)
epcsaft.regression.reaction_enthalpy_shift(name: str, *, pivot_temperature: float, origin: float, scale: float, bounds: tuple[float, float]) → epcsaft._core.Coordinate#

Declare a reaction-enthalpy shift preserving ln K at a fixed pivot.

Parameters:
  • name (str) – Named source-basis reaction to shift.

  • pivot_temperature (float) – Required pivot temperature in K at which supplied natural ln K is kept.

  • origin (float) – Enthalpy-shift origin in J/mol of reaction as written.

  • scale (float) – J/mol shift per dimensionless optimizer increment.

  • bounds (tuple of float) – Inclusive enthalpy-shift bounds in J/mol.

Returns:

coordinate – Native EnthalpyShift declaration with the pivot recorded in K.

Return type:

Coordinate

Notes

The native reaction-coordinate owner performs the coupled coefficient change; this function does not evaluate or refit a reaction law (ALG-FIT).

Examples

>>> from epcsaft.regression import reaction_enthalpy_shift
>>> shift = reaction_enthalpy_shift('reaction', pivot_temperature=300.0,
...                                origin=0.0, scale=1000.0, bounds=(-2000.0, 2000.0))
>>> shift.reaction.pivot_temperature
300.0
epcsaft.regression.density(parameters: epcsaft.parameters.Parameters, T: float, P: float, x: collections.abc.Mapping[str, float], *, phase: str, observed: float, form: str, mass_basis: bool, scale: float | None = None) → epcsaft._core.Observation#

Declare a pressure-closed single-phase density observation.

Molar density in mol/m³, or mass density in kg/m³ with mass_basis.

Parameters:
  • parameters (epcsaft.parameters.Parameters) – Component order used to resolve named compositions.

  • T (float) – Absolute temperature in K.

  • P (float) – Pressure in Pa.

  • x (mapping of str to float) – Dimensionless mole fractions; missing model species are zero.

  • phase ({'liquid', 'vapor'}) – Required pressure-density branch.

  • observed (float) – Measured value in the units stated above.

  • form ({'difference', 'log_ratio'}) – Difference divided by scale, or natural ln(prediction/observed).

  • scale (float, optional) – Required positive scale in observed units for a difference residual; must be absent for a log-ratio residual.

  • mass_basis (bool) – False for molar density, true for mass density.

Returns:

observation – Native physical observation declaration; prediction is deferred.

Return type:

Observation

Raises:

ParameterError – A species/phase is unknown, residual form is unsupported or scale presence conflicts with the residual form.

Notes

Native prediction owns density closure, physical admission and typed unavailability. Total heat capacity requires fixed ideal thermochemistry; this declaration supplies no missing thermal reference (ALG-FIT).

epcsaft.regression.isobaric_heat_capacity(parameters: epcsaft.parameters.Parameters, T: float, P: float, x: collections.abc.Mapping[str, float], *, phase: str, observed: float, form: str, scale: float | None = None) → epcsaft._core.Observation#

Declare a fixed-composition total molar heat-capacity observation.

Total molar isobaric heat capacity in J/(mol K).

Parameters:
  • parameters (epcsaft.parameters.Parameters) – Component order used to resolve named compositions.

  • T (float) – Absolute temperature in K.

  • P (float) – Pressure in Pa.

  • x (mapping of str to float) – Dimensionless mole fractions; missing model species are zero.

  • phase ({'liquid', 'vapor'}) – Required pressure-density branch.

  • observed (float) – Measured value in the units stated above.

  • form ({'difference', 'log_ratio'}) – Difference divided by scale, or natural ln(prediction/observed).

  • scale (float, optional) – Required positive scale in observed units for a difference residual; must be absent for a log-ratio residual.

Returns:

observation – Native physical observation declaration; prediction is deferred.

Return type:

Observation

Raises:

ParameterError – A species/phase is unknown, residual form is unsupported or scale presence conflicts with the residual form.

Notes

Native prediction owns density closure, physical admission and typed unavailability. Total heat capacity requires fixed ideal thermochemistry; this declaration supplies no missing thermal reference (ALG-FIT).

epcsaft.regression.observation(parameters: epcsaft.parameters.Parameters, kind: str, problem: epcsaft.equilibrium.Problem, *, observed: float, form: str, mass_basis: bool | None = None, phase: str | None = None, species: collections.abc.Sequence[str] | None = None, scale: float | None = None, denominator_phase: str | None = None, denominator_species: collections.abc.Sequence[str] | None = None) → epcsaft._core.Observation#

Declare an observable of a solved equilibrium problem.

Parameters:
  • parameters (epcsaft.parameters.Parameters) – Model component order for species and problem conversion.

  • kind (str) – pressure (Pa), temperature (K), phase_density (mol/m³ or kg/m³), mole_fraction (dimensionless sum over selected species), partial_pressure (Pa, P times that sum), phase_fraction (dimensionless molar fraction), amount_ratio (dimensionless ratio of selected phase-component mol), or equilibrium_isobaric_heat_capacity (J/(mol-feed K), driven T/P or PH).

  • problem (Problem) – Declared phases and physical constraints; discovery is refused.

  • observed (float) – Measured quantity in the unit selected by kind.

  • form ({'difference', 'log_ratio'}) – Difference divided by scale or natural ln(prediction/observed).

  • mass_basis (bool, optional) – Required for phase density: true selects kg/m³, false mol/m³.

  • phase (str, optional) – Required phase name except for pressure, temperature and equilibrium heat capacity.

  • species (sequence of str, optional) – Selected numerator components for composition, pressure or amount rows.

  • scale (float, optional) – Required positive scale in observed units for difference residuals; absent for log-ratio residuals.

  • denominator_phase (str, optional) – Required denominator phase for an amount ratio.

  • denominator_species (sequence of str, optional) – Selected denominator components for an amount ratio.

Returns:

observation – Native problem and requested quantity with resolved component indices.

Return type:

Observation

Raises:

ParameterError – Unknown kind/phase/species, discovery, missing required phase/density basis, or inconsistent residual/scale declarations.

Notes

The native owner checks structural observability and availability after solving the declared problem. No equilibrium solve occurs here (ALG-FIT).

epcsaft.regression.addition_enthalpy(parameters: epcsaft.parameters.Parameters, initial: epcsaft.equilibrium.Problem, final: epcsaft.equilibrium.Problem, feed: collections.abc.Mapping[str, float], amount: float, T: float, P: float, *, phase: str, observed: float, form: str, scale: float | None = None) → epcsaft._core.Observation#

Declare signed enthalpy of addition between two equilibrium endpoints.

Parameters:
  • parameters (epcsaft.parameters.Parameters) – Component order used by endpoints and added-feed composition.

  • initial (Problem) – Declared endpoint problems with total enthalpies in J; discovery is refused at either endpoint.

  • final (Problem) – Declared endpoint problems with total enthalpies in J; discovery is refused at either endpoint.

  • feed (mapping of str to float) – Dimensionless mole fractions of the added feed.

  • amount (float) – Positive total added-feed amount in mol.

  • T (float) – Temperature of the added feed in K.

  • P (float) – Pressure of the added feed in Pa.

  • phase ({'liquid', 'vapor'}) – Branch for the added-feed enthalpy.

  • observed (float) – Signed molar addition enthalpy in J/mol of added feed.

  • form ({'difference', 'log_ratio'}) – Difference divided by scale or natural ln(prediction/observed).

  • scale (float, optional) – Difference scale in J/mol; absent for log-ratio residuals.

Returns:

observation – Native two-endpoint declaration; no endpoint solve is done here.

Return type:

Observation

Raises:

ParameterError – Discovery is requested, a species/branch is unknown, or residual form/scale presence is inconsistent.

Notes

Native prediction computes (H_final-H_initial)/amount-h_added_feed with total endpoint H in J and added-feed molar h in J/mol (ALG-FIT).

epcsaft.regression.predict(model: epcsaft.eos.Mixture | epcsaft.eos.Pure, item: epcsaft._core.Observation) → epcsaft._core.Prediction#

Evaluate one observation using the model’s shared native calculations.

Parameters:
  • model (Mixture or Pure) – Model with any required thermochemistry and active-parameter declaration.

  • item (Observation) – Physical observation, including its observed value, units and residual.

Returns:

prediction – Value in observation units and dimensionless residual, with typed unavailability, state/equilibrium/reference diagnostics as applicable.

Return type:

Prediction

Raises:

ParameterError – Native physical declaration admission fails.

Notes

Inspect the returned prediction cause before consuming its value. Failed trials are not observations of zero (ALG-FIT).

epcsaft.regression.differentiate(model: epcsaft.eos.Mixture | epcsaft.eos.Pure | epcsaft.parameters.Parameters, item: epcsaft._core.Observation | collections.abc.Sequence[epcsaft._core.Coordinate], observations: collections.abc.Sequence[epcsaft._core.Observation] | None = None, *, optimizer: collections.abc.Sequence[float] | None = None, thermochemistry: epcsaft.eos.ThermochemistryRecord | None = None, holds: collections.abc.Sequence[epcsaft._core.HydrationHold] | None = None, solver_options: collections.abc.Mapping[str, float] | None = None) → Any#

Evaluate exact native prediction or coordinate-aware residual derivatives.

Parameters:
  • model (Mixture, Pure or epcsaft.parameters.Parameters) – Fluid model for one-observation differentiation, or a parameter set for coordinate-aware evaluation.

  • item (Observation or sequence of Coordinate) – One observation for a model; coordinates for a parameter set.

  • observations (sequence of Observation, optional) – Required with a parameter set, in row order.

  • optimizer (sequence of float, optional) – Required dimensionless optimizer point for coordinate-aware evaluation.

  • thermochemistry (ThermochemistryRecord, optional) – Fixed ideal-gas molar thermochemistry for coordinate evaluation; temperature intervals K and standard pressure Pa.

  • holds (sequence of HydrationHold, optional) – Dependent Born-diameter constraints for coordinate evaluation.

  • solver_options (mapping of str to float, optional) – Native tolerances and work budgets for coordinate evaluation.

Returns:

evaluation – For a model, prediction derivatives in active-parameter order, with observation units per native parameter unit; inspect status/message for unavailable derivatives. For a parameter set, gradient is row-major in observation order, with physical columns ordered as independent EOS targets, held Born diameters, then reaction coordinates. Optimizer columns follow coordinate order; optimizer_gradient contains prediction columns in observation units, and residual_optimizer_gradient contains dimensionless residual columns at unit observation weights. This path returns only a completed evaluation; unavailable rows raise ParameterError.

Return type:

PredictionGradient or ObservationEvaluation

Raises:

ParameterError – Parameters lack coordinates/observations/optimizer, a model receives multiple observations, native physical admission fails, or a requested coordinate-aware prediction, chart, hold or derivative is unavailable.

Notes

Thermochemistry, holds and solver_options are consumed only by the parameter set path. Derivatives follow the same native equations and solved branches as prediction (ALG-FIT and ALG-ACTIONS).

epcsaft.regression.fit(parameters: epcsaft.parameters.Parameters, coordinates: collections.abc.Sequence[epcsaft._core.Coordinate], observations: collections.abc.Sequence[epcsaft._core.Observation], *, weights: collections.abc.Sequence[float] | None = None, controls: epcsaft._core.FitControls, thermochemistry: epcsaft.eos.ThermochemistryRecord | None = None, holds: collections.abc.Sequence[epcsaft._core.HydrationHold] | None = None, checks: collections.abc.Sequence[epcsaft._core.CheckGroup] | None = None, baseline: epcsaft.parameters.Parameters | None = None, singular_vectors: bool | None = None, minimax: epcsaft._core.MinimaxRequest | None = None, uncertainty: epcsaft._core.MeasurementUncertainty | None = None) → epcsaft._core.FitResult#

Fit physical parameters with native least squares or declared guarded minimax.

Parameters:
  • parameters (epcsaft.parameters.Parameters) – Starting physical parameters in native units.

  • coordinates (sequence of Coordinate) – Affine physical-to-dimensionless-optimizer chart and bounds.

  • observations (sequence of Observation) – Ordered physical observations and residual definitions.

  • weights (sequence of float, optional) – Nonnegative dimensionless least-squares weights; residuals are multiplied by their square roots. Omitted/empty means unit weights.

  • controls (FitControls) – Required iteration and wall-time (s) budgets and stopping controls.

  • thermochemistry (ThermochemistryRecord, optional) – Fixed molar ideal-gas thermal record, interval bounds K and standard Pa.

  • holds (sequence of HydrationHold, optional) – Dependent physical constraints solved natively within the chart.

  • checks (sequence of CheckGroup, optional) – Declared final physical metrics and limits.

  • baseline (epcsaft.parameters.Parameters, optional) – Comparison parameter set for final check groups.

  • singular_vectors (bool, optional) – Request native singular vectors; default false.

  • starts (sequence of sequence of float, optional) – Dimensionless optimizer starts, attempted in supplied order while shared budgets remain. A reaction-enthalpy-shift start is an offset from the declared correlation.

  • shared_iterations (int, optional) – Positive shared iteration budget; defaults to controls.maximum_iterations.

  • shared_seconds (float, optional) – Positive shared wall-time budget in s; defaults to controls.maximum_elapsed_time_seconds.

  • minimax (MinimaxRequest, optional) – Explicit guarded minimax request instead of ordinary least squares.

  • uncertainty (MeasurementUncertainty, optional) – Input/output measurement-error declarations for native reconciliation.

Returns:

result – Fitted native parameters, physical/optimizer coordinates, costs, diagnostics and any admitted local covariance. Supplied starts return one entry per attempted start, in input order; exhausted shared budgets leave a shorter list. Inspect stopping and usability before use.

Return type:

FitResult or list of FitResult

Raises:

ParameterError – The required controls argument is omitted, solver options or shared budgets are invalid.

Notes

Native invalid fit declarations can return an unusable result with their message; unsupported uncertainty with minimax also returns a refusal. All fitting iterations, derivative columns, constraint solves and trial failures belong to ALG-FIT. A fitted parameter set is calibration evidence, not independent physical validation. Local covariance requires the native rank and error-model assumptions; unavailable covariance is not zero.

epcsaft.regression.fitted_parameters(start: epcsaft.parameters.Parameters, result: epcsaft._core.FitResult) → epcsaft.parameters.Parameters#

Associate fitted native values with the starting component and site names.

Parameters:
Returns:

parameters – Fitted native values with the starting names. A representable source document is updated for export; otherwise its precise refusal is stored.

Return type:

epcsaft.parameters.Parameters

Notes

This function does not require a usable fit result; inspect fit diagnostics first. A source document that cannot express the fitted values does not invalidate the native parameter set. Subsequent ASL export raises the stored cause. No absent source document is invented.

epcsaft.regression.electrolyte(parameters: epcsaft.parameters.Parameters, kind: str, T: float, P: float, x: collections.abc.Mapping[str, float], *, ions: tuple[str, str], stoichiometry: tuple[int, int], molality: float, species: str | None = None, reference: collections.abc.Mapping[str, float] | None = None, observed: float, form: str, scale: float | None = None) → epcsaft._core.Observation#

Declare a liquid electrolyte or single-ion-energy observation.

Parameters:
  • parameters (epcsaft.parameters.Parameters) – Names and order for compositions and ions.

  • kind (str) – mean_ionic_activity_coefficient (dimensionless molality scale), osmotic_coefficient (dimensionless), solvation_gibbs_energy or transfer_gibbs_energy (J/mol of the selected ion), or bulk_relative_permittivity (dimensionless).

  • T (float) – Temperature in K.

  • P (float) – Pressure in Pa.

  • x (mapping of str to float) – Dimensionless mole fractions: full composition for bulk permittivity, solvent-only composition for the ionic reference/activity path; missing components are zero.

  • ions (tuple of str) – Two formula-ion identifiers, in declared ion order.

  • stoichiometry (tuple of int) – Positive dimensionless formula counts in ion order.

  • molality (float) – Formula molality in mol/kg solvent.

  • species (str, optional) – Selected ion for a single-ion energy observation.

  • reference (mapping of str to float, optional) – Dimensionless second solvent-reference composition for transfer energy; for bulk permittivity, a second full composition requests the relative permittivity at x divided by the relative permittivity at reference.

  • observed (float) – Value in the unit selected by kind.

  • form ({'difference', 'log_ratio'}) – Difference divided by scale or natural ln(prediction/observed).

  • scale (float, optional) – Required scale in observed units for difference residuals; absent for log-ratio residuals.

Returns:

observation – Liquid-branch native declaration with named indices resolved.

Return type:

Observation

Raises:

ParameterError – Kind/species/reference names are unknown, or residual/scale declarations conflict. Native physical admission is deferred to prediction/fitting.

Notes

Single-ion energies use RT times natural ln(phi) at infinite dilution or its transfer difference. They retain the declared single-ion convention (ALG-REFERENCE and ALG-FIT).

epcsaft.regression.mixture_osmotic_coefficient(parameters: epcsaft.parameters.Parameters, T: float, P: float, x: collections.abc.Mapping[str, float], *, observed: float, scale: float) → epcsaft._core.Observation#

Declare the practical osmotic coefficient of a full liquid composition.

Parameters:
  • parameters (epcsaft.parameters.Parameters) – Component order and solvent molar mass in kg/mol.

  • T (float) – Temperature in K.

  • P (float) – Pressure in Pa.

  • x (mapping of str to float) – Full electroneutral dimensionless mole fractions with one solvent; omitted species are zero.

  • observed (float) – Dimensionless practical osmotic coefficient.

  • scale (float) – Positive dimensionless difference-residual scale.

Returns:

observation – Liquid observation with residual (Phi-observed)/scale.

Return type:

Observation

Raises:

ParameterError – Unknown species; native prediction checks the physical declaration.

Notes

Native evaluation uses Phi = -ln(a_w)/(M_w*sum_j m_j) with natural logarithm, solvent molar mass M_w in kg/mol and individual solute-species molalities m_j in mol/kg solvent. This is a full-composition observation, not a single formula-ion dilution path (ALG-REFERENCE).

epcsaft.regression.hydration_hold(reference: epcsaft._core.Observation, *, bracket: tuple[float, float], energy_tolerance: float, diameter_tolerance: float, maximum_iterations: int) → epcsaft._core.HydrationHold#

Declare an infinite-dilution energy constraint with dependent Born diameter.

Parameters:
  • reference (Observation) – Single-ion reference energy target in J/mol, at declared T (K), P (Pa) and solvent composition.

  • bracket (tuple of float) – Lower and upper dependent Born diameters in native Å.

  • energy_tolerance (float) – Positive energy-residual tolerance in J/mol.

  • diameter_tolerance (float) – Positive diameter-bracket tolerance in Å.

  • maximum_iterations (int) – Native constraint-solve iteration budget.

Returns:

hold – Native declaration for H = RT*ln(phi_i at infinite dilution)-target; H has units J/mol. No constraint solve occurs here.

Return type:

HydrationHold

Notes

Native coordinate evaluation owns the bracket solve and implicit exact chart derivative. Invalid or unresolved holds retain their causes (ALG-FIT).

epcsaft.regression.evaluate_coordinates(parameters: epcsaft.parameters.Parameters, coordinates: collections.abc.Sequence[epcsaft._core.Coordinate], optimizer: collections.abc.Sequence[float], holds: collections.abc.Sequence[epcsaft._core.HydrationHold], thermochemistry: epcsaft.eos.ThermochemistryRecord | None = None, solver_options: collections.abc.Mapping[str, float] | None = None) → epcsaft._core.EvaluatedCoordinates#

Evaluate the physical parameter chart and its exact native derivative.

Parameters:
  • parameters (epcsaft.parameters.Parameters) – Starting native physical parameter set.

  • coordinates (sequence of Coordinate) – Ordered affine coordinates and physical bounds.

  • optimizer (sequence of float) – Dimensionless optimizer point in coordinate order.

  • holds (sequence of HydrationHold) – Dependent Born-diameter constraints; empty means none.

  • thermochemistry (ThermochemistryRecord, optional) – Fixed ideal-gas molar thermochemistry with intervals in K and standard Pa.

  • solver_options (mapping of str to float, optional) – Native solver tolerances and work limits.

Returns:

evaluation – Completed physical chart values in native parameter units and exact D columns per dimensionless optimizer increment, including dependent holds. No unavailable chart or derivative record is returned.

Return type:

EvaluatedCoordinates

Raises:

ParameterError – The chart, optimizer dimensions, bounds or hold declarations are invalid, or a hold reference/action is unavailable, its root is not bracketed, its derivative is singular, or its iteration budget is exhausted (ALG-FIT).

epcsaft.regression.evaluate_checks(parameters: epcsaft.parameters.Parameters, observations: collections.abc.Sequence[epcsaft._core.Observation], checks: collections.abc.Sequence[epcsaft._core.CheckGroup], baseline: epcsaft.parameters.Parameters | None = None, solver_options: collections.abc.Mapping[str, float] | None = None) → list[epcsaft._core.CheckResult]#

Evaluate unweighted final physical metrics on stored parameters.

Parameters:
  • parameters (epcsaft.parameters.Parameters) – Physical parameter values to check.

  • observations (sequence of Observation) – Observation declarations used by each check group’s row indices.

  • checks (sequence of CheckGroup) – Native metric groups and admitted limits; units follow each named physical metric or its dimensionless relative/log definition.

  • baseline (epcsaft.parameters.Parameters, optional) – Comparison physical parameter set for baseline checks.

  • solver_options (mapping of str to float, optional) – Native solver tolerances and work budgets.

Returns:

results – Unweighted metrics and check diagnostics in check-group order, retaining unavailable observations and their causes.

Return type:

list of CheckResult

Raises:

ParameterError – Native observations, groups or baseline requirements are inadmissible.

Notes

No hydration holds are re-solved. These metrics evaluate stored physical parameters, separately from weighted fit objectives (ALG-FIT).

epcsaft.regression.saturation_pressure_observation(parameters: epcsaft.parameters.Parameters, *, component: str, T: float, observed: float, form: str, scale: float | None = None) → epcsaft._core.Observation#

Declare pure saturation pressure (Pa) at T (K), seeded by observed pressure.

The one-mol feed has liquid L and incipient vapor V pinned to zero. Select a single component in parameters. Residual form is explicit: log_ratio has no scale; difference requires a positive scale in Pa. Native observation admission and fitting remain unchanged.

Re-exported names#