teqpflsh Package¶

class teqpflsh._teqpflsh_impl.AbstractScaler¶

Bases: object

C++ docs: AbstractScaler

class teqpflsh._teqpflsh_impl.ChebyshevApproximation1D(*args, **kwargs)¶

Bases: object

C++ docs: ChebyshevApproximation1D

count_x_for_y_many(self, arg0: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], arg1: int, arg2: int, arg3: float, arg4: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], /) → None¶

eval(self, arg: float, /) → float¶

eval_many(self, arg0: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], arg1: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], /) → None¶

property expansions¶: (self) -> list[teqpflsh._teqpflsh_impl.ChebyshevExpansion]

get_intervals_containing_y(self, arg: float, /) → list[teqpflsh._teqpflsh_impl.IntervalMatch]¶

get_x_for_y(self, *, y: float, bits: int = 64, max_iter: int = 100, boundsftol: float = 1e-13) → list[tuple[float, int]]¶

property monotonic_intervals¶: (self) -> list[teqpflsh::superancillary::IntervalMatch]

property x_at_extrema¶: (self) -> list[float]

property xmax¶: (self) -> float

property xmin¶: (self) -> float

class teqpflsh._teqpflsh_impl.ChebyshevExpansion(*args, **kwargs)¶

Bases: object

C++ docs: ChebyshevExpansion

property coeff¶: (self) -> numpy.ndarray[dtype=float64, shape=(*), order=’C’]

eval(self, arg: float, /) → float¶

eval_Eigen(self, arg0: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], arg1: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], /) → None¶

eval_many(self, arg0: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], arg1: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], /) → None¶

solve_for_x(self, arg0: float, arg1: float, arg2: float, arg3: int, arg4: int, arg5: float, /) → float¶

solve_for_x_count(self, arg0: float, arg1: float, arg2: float, arg3: int, arg4: int, arg5: float, /) → tuple[float, int]¶

solve_for_x_many(self, arg0: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], arg1: float, arg2: float, arg3: int, arg4: int, arg5: float, arg6: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], arg7: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], /) → None¶

property xmax¶: (self) -> float

property xmin¶: (self) -> float

class teqpflsh._teqpflsh_impl.CoordinateSequence(*args, **kwargs)¶

Bases: object

C++ docs: CoordinateSequence

add(self, arg0: float, arg1: float, /) → None¶

closeRing(self, arg: bool, /) → None¶

getSize(self) → int¶

getX(self, arg: int, /) → float¶

getY(self, arg: int, /) → float¶

class teqpflsh._teqpflsh_impl.Envelope¶

Bases: object

C++ docs: Envelope

property x_max¶: (self) -> float

property x_min¶: (self) -> float

property y_max¶: (self) -> float

property y_min¶: (self) -> float

class teqpflsh._teqpflsh_impl.FlashPhase¶

Bases: object

C++ docs: FlashPhase

property mole_fractions¶: (self) -> numpy.ndarray[dtype=float64, shape=(*), order=’C’]

property qmolar¶: (self) -> float

property rho_molm3¶: (self) -> float

class teqpflsh._teqpflsh_impl.FlashSolution¶

Bases: object

C++ docs: FlashSolution

property Nphases¶: (self) -> int

property T_K¶: (self) -> float

property phases¶: (self) -> list[teqpflsh._teqpflsh_impl.FlashPhase]

class teqpflsh._teqpflsh_impl.Geometry¶

Bases: object

C++ docs: Geometry

DelaunayTriangulate(self) → teqpflsh._teqpflsh_impl.Geometry¶

containsPoint(self, arg: teqpflsh._teqpflsh_impl.Point, /) → bool¶

difference(self, arg: teqpflsh._teqpflsh_impl.Geometry, /) → teqpflsh._teqpflsh_impl.Geometry¶

fastTriangulate(self) → teqpflsh._teqpflsh_impl.Geometry¶

getCentroid(self) → teqpflsh._teqpflsh_impl.Point¶

getCoordinates(self) → teqpflsh._teqpflsh_impl.CoordinateSequence¶

getGeometryN(self, arg: int, /) → teqpflsh._teqpflsh_impl.Geometry¶

getNumGeometries(self) → int¶

getNumPoints(self) → int¶

getXY(self) → tuple[numpy.ndarray[dtype=float64, shape=(*), order='C'], numpy.ndarray[dtype=float64, shape=(*), order='C']]¶: Convenience function to return the X, Y coordinates as numpy arrays in Python

get_PreparedGeometry(self) → teqpflsh._teqpflsh_impl.PreparedGeometry¶

intersection(self, arg: teqpflsh._teqpflsh_impl.Geometry, /) → teqpflsh._teqpflsh_impl.Geometry¶

property isSimple¶: (self) -> bool

property isValid¶: (self) -> bool

make_valid(self) → teqpflsh._teqpflsh_impl.Geometry¶

run_DouglasPeuckerSimplifier(self, tolerance: float) → teqpflsh._teqpflsh_impl.Geometry¶

run_TopologyPreservingSimplifier(self, tolerance: float) → teqpflsh._teqpflsh_impl.Geometry¶

class teqpflsh._teqpflsh_impl.GeometryFactory¶

Bases: object

C++ docs: GeometryFactory

createPolygon(self, arg: teqpflsh._teqpflsh_impl.Geometry, /) → teqpflsh._teqpflsh_impl.Geometry¶

class teqpflsh._teqpflsh_impl.GeometryFactoryHolder(*args, **kwargs)¶

Bases: object

C++ docs: GeometryFactoryHolder

createPoint(self, arg0: float, arg1: float, /) → teqpflsh._teqpflsh_impl.Point¶

createPolygon(self, arg: teqpflsh._teqpflsh_impl.CoordinateSequence, /) → teqpflsh._teqpflsh_impl.Geometry¶

makeclosedpolygon(self, x: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], y: ndarray[dtype=float64, shape=(*), order='C', device='cpu']) → teqpflsh._teqpflsh_impl.Geometry¶: A convenience function to make a closed polygon given numpy arrays

class teqpflsh._teqpflsh_impl.HelmholtzInterface¶

Bases: object

C++ docs: HelmholtzInterface

class teqpflsh._teqpflsh_impl.IntervalMatch¶

Bases: object

C++ docs: IntervalMatch

property expansioninfo¶: (self) -> list[teqpflsh._teqpflsh_impl.MonotonicExpansionMatch]

property xmax¶: (self) -> float

property xmin¶: (self) -> float

property ymax¶: (self) -> float

property ymin¶: (self) -> float

class teqpflsh._teqpflsh_impl.L2Tree¶

Bases: object

C++ docs: L2Tree

get_nearest_indexd2(self, x: float, y: float) → tuple[int, float]¶
get_nearest_indexd2(self, pt: numpy.ndarray[dtype=float64, shape=(2), order='C']) → tuple[int, float]

get_nearest_indexd2_many(self, x: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], y: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], idx: ndarray[dtype=int32, shape=(*), order='C', device='cpu'], d2: ndarray[dtype=float64, shape=(*), order='C', device='cpu']) → None¶

get_used_bytes(self) → int¶

class teqpflsh._teqpflsh_impl.L2TreeHolder(*args, **kwargs)¶

Bases: object

C++ docs: L2TreeHolder

property tree¶: (self) -> teqpflsh._teqpflsh_impl.L2Tree

class teqpflsh._teqpflsh_impl.LeafContents¶

Bases: object

C++ docs: LeafContents

property status¶: (self) -> teqpflsh::PQTStatus

class teqpflsh._teqpflsh_impl.MainFlasher(*args, **kwargs)¶

Bases: object

C++ docs: MainFlasher

flash(self, proppair: teqpflsh._teqpflsh_impl.PropertyPairs, val1: float, val2: float) → teqpflsh._teqpflsh_impl.FlashSolution | None¶

flash_many(self, proppair: teqpflsh._teqpflsh_impl.PropertyPairs, val1: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], val2: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], T: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], rho: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], q: ndarray[dtype=float64, shape=(*), order='C', device='cpu']) → None¶

property regioned_flasher¶: (self) -> teqpflsh._teqpflsh_impl.RegionedFlasher

class teqpflsh._teqpflsh_impl.MaxAbsErrorCondition(*args, **kwargs)¶

Bases: StoppingCondition

C++ docs: MaxAbsErrorCondition

class teqpflsh._teqpflsh_impl.MinMaxLogScaler(*args, **kwargs)¶

Bases: AbstractScaler

C++ docs: MinMaxLogScaler

class teqpflsh._teqpflsh_impl.MinMaxScaler(*args, **kwargs)¶

Bases: AbstractScaler

C++ docs: MinMaxScaler

class teqpflsh._teqpflsh_impl.MonotonicExpansionMatch¶

Bases: object

C++ docs: MonotonicExpansionMatch

property idx¶: (self) -> int

property xmax¶: (self) -> float

property xmin¶: (self) -> float

property ymax¶: (self) -> float

property ymin¶: (self) -> float

class teqpflsh._teqpflsh_impl.NRIterator¶

Bases: object

C++ docs: NRIterator

calc_J(self, arg0: float, arg1: float, /) → numpy.ndarray[dtype=float64, shape=(2, 2), order='F']¶

calc_just_step(self, arg0: float, arg1: float, /) → numpy.ndarray[dtype=float64, shape=(2), order='C']¶

calc_maxabsr(self, arg0: float, arg1: float, /) → float¶

calc_r(self, arg0: float, arg1: float, /) → numpy.ndarray[dtype=float64, shape=(2), order='C']¶

calc_step(self, arg0: float, arg1: float, /) → tuple[numpy.ndarray[dtype=float64, shape=(2), order='C'], teqp::cppinterface::IterationMatrices]¶

calc_vals(self, arg0: float, arg1: float, /) → numpy.ndarray[dtype=float64, shape=(2), order='C']¶

get_T(self) → float¶

get_maxabsr(self) → float¶

get_nonconstant_indices(self) → list[int]¶

get_rho(self) → float¶

get_step_count(self) → int¶

get_vals(self) → numpy.ndarray[dtype=float64, shape=(2), order='C']¶

path_integration(self, arg0: float, arg1: float, arg2: int, /) → tuple[float, float, float, float]¶

reset(self, arg0: float, arg1: float, /) → None¶

take_steps(self, N: int, apply_stopping: bool) → teqpflsh._teqpflsh_impl.StoppingConditionReason¶

property verbose¶: (self) -> bool

class teqpflsh._teqpflsh_impl.NanXDXErrorCondition(*args, **kwargs)¶

Bases: StoppingCondition

C++ docs: NanXDXErrorCondition

class teqpflsh._teqpflsh_impl.PQTStatus(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)¶

Bases: Enum

PQTStatus

inside = 0¶

intersection = 2¶

outside = 1¶

class teqpflsh._teqpflsh_impl.Point¶

Bases: Geometry

C++ docs: Point

DelaunayTriangulate(self) → teqpflsh._teqpflsh_impl.Geometry¶

containsPoint(self, arg: teqpflsh._teqpflsh_impl.Point, /) → bool¶

difference(self, arg: teqpflsh._teqpflsh_impl.Geometry, /) → teqpflsh._teqpflsh_impl.Geometry¶

fastTriangulate(self) → teqpflsh._teqpflsh_impl.Geometry¶

getCentroid(self) → teqpflsh._teqpflsh_impl.Point¶

getCoordinates(self) → teqpflsh._teqpflsh_impl.CoordinateSequence¶

getGeometryN(self, arg: int, /) → teqpflsh._teqpflsh_impl.Geometry¶

getNumGeometries(self) → int¶

getNumPoints(self) → int¶

getX(self) → float¶

getXY(self) → tuple[numpy.ndarray[dtype=float64, shape=(*), order='C'], numpy.ndarray[dtype=float64, shape=(*), order='C']]¶: Convenience function to return the X, Y coordinates as numpy arrays in Python

getY(self) → float¶

get_PreparedGeometry(self) → teqpflsh._teqpflsh_impl.PreparedGeometry¶

intersection(self, arg: teqpflsh._teqpflsh_impl.Geometry, /) → teqpflsh._teqpflsh_impl.Geometry¶

property isSimple¶: (self) -> bool

property isValid¶: (self) -> bool

make_valid(self) → teqpflsh._teqpflsh_impl.Geometry¶

run_DouglasPeuckerSimplifier(self, tolerance: float) → teqpflsh._teqpflsh_impl.Geometry¶

run_TopologyPreservingSimplifier(self, tolerance: float) → teqpflsh._teqpflsh_impl.Geometry¶

class teqpflsh._teqpflsh_impl.PolyQuadNode¶

Bases: object

C++ docs: PolyQuadNode

property NE¶: (self) -> teqpflsh._teqpflsh_impl.PolyQuadNode

property NW¶: (self) -> teqpflsh._teqpflsh_impl.PolyQuadNode

property SE¶: (self) -> teqpflsh._teqpflsh_impl.PolyQuadNode

property SW¶: (self) -> teqpflsh._teqpflsh_impl.PolyQuadNode

getNode(self, arg0: float, arg1: float, arg2: bool, /) → teqpflsh._teqpflsh_impl.PolyQuadNode¶

get_contents(self) → teqpflsh._teqpflsh_impl.LeafContents¶

property terminal¶: (self) -> bool

xmax(self) → float¶

xmin(self) → float¶

ymax(self) → float¶

ymin(self) → float¶

class teqpflsh._teqpflsh_impl.PolyQuadTree(*args, **kwargs)¶

Bases: object

C++ docs: PolyQuadTree

area_stats(self) → None¶

do_splits(self, arg: int, /) → None¶

get_leaves(self) → list[teqpflsh._teqpflsh_impl.PolyQuadNode]¶

get_polygon_xy(self, arg: teqpflsh._teqpflsh_impl.PolyQuadNode, /) → tuple[list[float], list[float]] | None¶

get_status(self, arg: teqpflsh._teqpflsh_impl.PolyQuadNode, /) → teqpflsh._teqpflsh_impl.PQTStatus¶

is_complete(self, arg: teqpflsh._teqpflsh_impl.PolyQuadNode, /) → bool¶

is_intersection(self, arg: teqpflsh._teqpflsh_impl.PolyQuadNode, /) → bool¶

property tree¶: (self) -> teqpflsh._teqpflsh_impl.PolyQuadNode

class teqpflsh._teqpflsh_impl.PreparedGeometry¶

Bases: object

C++ docs: PreparedGeometry

contains(self, arg: teqpflsh._teqpflsh_impl.Geometry, /) → bool¶

nearestPoints(self, arg: teqpflsh._teqpflsh_impl.Geometry, /) → teqpflsh._teqpflsh_impl.CoordinateSequence¶

class teqpflsh._teqpflsh_impl.PropertyPairs(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)¶

Bases: Enum

PropertyPairs

DH = 3¶

DP = 2¶

DS = 4¶

DT = 1¶

DU = 5¶

HP = 6¶

HS = 9¶

HT = 10¶

HU = 14¶

PS = 7¶

PT = 13¶

PU = 8¶

ST = 0¶

SU = 12¶

TU = 11¶

class teqpflsh._teqpflsh_impl.PropertySet¶

Bases: object

C++ docs: PropertySet

property T¶: (self) -> numpy.ndarray[dtype=float64, shape=(*), order=’C’]

get_array(self, arg: str, /) → numpy.ndarray[dtype=float64, shape=(*), order='C']¶

get_arrays(self, arg: teqpflsh._teqpflsh_impl.PropertyPairs, /) → tuple[numpy.ndarray[dtype=float64, shape=(*), order='C'], numpy.ndarray[dtype=float64, shape=(*), order='C']]¶

property h¶: (self) -> numpy.ndarray[dtype=float64, shape=(*), order=’C’]

property p¶: (self) -> numpy.ndarray[dtype=float64, shape=(*), order=’C’]

property rho¶: (self) -> numpy.ndarray[dtype=float64, shape=(*), order=’C’]

property s¶: (self) -> numpy.ndarray[dtype=float64, shape=(*), order=’C’]

property u¶: (self) -> numpy.ndarray[dtype=float64, shape=(*), order=’C’]

class teqpflsh._teqpflsh_impl.QuadRegion2D(*args, **kwargs)¶

Bases: object

C++ docs: QuadRegion2D

property bounding_polygon¶: (self) -> teqpflsh._teqpflsh_impl.Geometry

do_Delaunay_triangulation(self) → teqpflsh._teqpflsh_impl.Geometry¶

do_fast_triangulation(self) → teqpflsh._teqpflsh_impl.Geometry¶

do_splits(self, arg: int, /) → None¶

get_coords_xy(self) → tuple[list[float], list[float]]¶

get_envelope(self) → teqpflsh._teqpflsh_impl.Envelope¶

get_nonsimple_xy(self) → tuple[list[float], list[float]]¶

get_quadtree_ro(self) → teqpflsh._teqpflsh_impl.PolyQuadTree¶

get_quadtree_rw(self) → teqpflsh._teqpflsh_impl.PolyQuadTree¶

sample_gridded(self, arg0: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], arg1: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], arg2: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], arg3: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], /) → int¶

sample_gridded_w_tree(self, arg0: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], arg1: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], arg2: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], arg3: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], /) → int¶

sample_random(self, arg0: int, arg1: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], arg2: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], /) → None¶

class teqpflsh._teqpflsh_impl.RegionedFlashReturn¶

Bases: object

C++ docs: RegionedFlashReturn

property T¶: Temperature, K

property candidate_duration_us¶: How long the candidate determination part took, in microseconds

property maxabsr¶: Maximum absolute residual

property msg¶: Message associated with stoppping reason

property newton_duration_us¶: How long the Newton part took, in microseconds

property reason¶: Enumerated value for stopping reason

property rho¶: Molar density, mol/m3

property step_count¶: How many Newton steps were takenm

property total_duration_us¶: How long the total calculation took, in microseconds

class teqpflsh._teqpflsh_impl.RegionedFlasher(*args, **kwargs)¶

Bases: object

C++ docs: RegionedFlasher

add_region(self, *, T: numpy.ndarray[dtype=float64, shape=(*), order='C'], rho: numpy.ndarray[dtype=float64, shape=(*), order='C'], NT: int, Nrho: int) → None¶: Add a region to the set of regions

flash(self, proppair: teqpflsh._teqpflsh_impl.PropertyPairs, val1: float, val2: float) → teqpflsh._teqpflsh_impl.RegionedFlashReturn¶: Do a flash calculation

flash_many(self, proppair: teqpflsh._teqpflsh_impl.PropertyPairs, val1: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], val2: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], T: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], rho: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], steps: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], maxabs: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], newtontime: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], candtime: ndarray[dtype=float64, shape=(*), order='C', device='cpu']) → None¶: Do many flash calculations, for testing in Python

get_NRIterator(self, arg0: collections.abc.Sequence[str], arg1: numpy.ndarray[dtype=float64, shape=(2), order='C'], arg2: float, arg3: float, arg4: numpy.ndarray[dtype=float64, shape=(*), order='C'], arg5: tuple[bool, bool], arg6: collections.abc.Sequence[teqpflsh._teqpflsh_impl.StoppingCondition], /) → teqpflsh._teqpflsh_impl.NRIterator¶: Construct a Newton iterator object

get_quadtree_intersections(self, arg0: teqpflsh._teqpflsh_impl.PropertyPairs, arg1: float, arg2: float, /) → list[teqpflsh._teqpflsh_impl.QuadRegion2D]¶

get_regions_ro(self) → list[teqpflsh._teqpflsh_impl.ThermodynamicRegion]¶: Get a read-only view of the regions

get_regions_rw(self) → list[teqpflsh._teqpflsh_impl.ThermodynamicRegion]¶: Get read-write access to the regions

get_starting_Trho(self, arg0: teqpflsh._teqpflsh_impl.PropertyPairs, arg1: float, arg2: float, /) → list[tuple[teqpflsh._teqpflsh_impl.ThermodynamicRegion, teqpflsh._teqpflsh_impl.TrhoLookup]]¶: Get the starting temperature, density pair from the K-D tree

remove_all_regions(self) → None¶: Remove all the regions to restore object to its initial state

class teqpflsh._teqpflsh_impl.StoppingCondition¶

Bases: object

C++ docs: StoppingCondition

class teqpflsh._teqpflsh_impl.StoppingConditionReason(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)¶

Bases: Enum

StoppingConditionReason

fatal = 3¶

keep_going = 1¶

success = 2¶

class teqpflsh._teqpflsh_impl.SuperAncillary(*args, **kwargs)¶

Bases: object

C++ docs: SuperAncillary

add_variable(self, *, k: str, caller: collections.abc.Callable[[float, float], float]) → None¶

eval_sat(self, *, T: float, k: str, q: int) → float¶

eval_sat_many(self, *, T: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], k: str, q: int, y: ndarray[dtype=float64, shape=(*), order='C', device='cpu']) → None¶

flash(self, arg0: teqpflsh._teqpflsh_impl.PropertyPairs, arg1: float, arg2: float, /) → teqpflsh._teqpflsh_impl.SuperAncillaryTwoPhaseSolution | None¶

flash_many(self, arg0: teqpflsh._teqpflsh_impl.PropertyPairs, arg1: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], arg2: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], arg3: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], arg4: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], arg5: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], /) → None¶

get_T_from_p(self, *, p: float) → float¶

get_approx1d(self, *, k: str, q: int) → teqpflsh._teqpflsh_impl.ChebyshevApproximation1D¶

get_vaporquality(self, *, T: float, propval: float, k: str) → float¶

get_yval(self, *, T: float, q: float, k: str) → float¶

get_yval_many(self, *, T: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], k: str, q: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], y: ndarray[dtype=float64, shape=(*), order='C', device='cpu']) → None¶

property invlnp¶: (self) -> teqpflsh._teqpflsh_impl.ChebyshevApproximation1D

solve_for_T(self, *, propval: float, k: str, q: bool, bits: int = 64, max_iter: int = 100, boundsftol: float = 1e-13) → list[tuple[float, int]]¶

solve_for_Tq_DX(self, arg0: float, arg1: float, arg2: str, arg3: int, arg4: int, arg5: float, /) → teqpflsh._teqpflsh_impl.SuperAncillaryTwoPhaseSolution | None¶

solve_for_Tq_DX_many(self, arg0: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], arg1: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], arg2: str, arg3: int, arg4: int, arg5: float, arg6: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], arg7: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], arg8: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], /) → None¶

class teqpflsh._teqpflsh_impl.SuperAncillaryTwoPhaseSolution¶

Bases: object

C++ docs: SuperAncillaryTwoPhaseSolution

property T¶: (self) -> float

property counter¶: (self) -> int

property q¶: (self) -> float

class teqpflsh._teqpflsh_impl.ThermodynamicRegion¶

Bases: object

C++ docs: ThermodynamicRegion

add_pair(self, *, proppair: teqpflsh._teqpflsh_impl.PropertyPairs, Nsplit: int, and_kdtree: bool = True) → None¶

get_kdtree(self, arg: teqpflsh._teqpflsh_impl.PropertyPairs, /) → teqpflsh._teqpflsh_impl.L2Tree¶

get_starting_Trho_many(self, proppair: teqpflsh._teqpflsh_impl.PropertyPairs, val1: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], val2: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], T: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], rho: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], d2: ndarray[dtype=float64, shape=(*), order='C', device='cpu']) → None¶

get_transformed_region(self, arg: teqpflsh._teqpflsh_impl.PropertyPairs, /) → teqpflsh._teqpflsh_impl.QuadRegion2D¶

has_pair(self, arg: teqpflsh._teqpflsh_impl.PropertyPairs, /) → bool¶

property propset_Trhogrid¶: (self) -> teqpflsh::properties::PropertySet<Eigen::Array<double, -1, 1, 0, -1, 1> >

property propset_bounding¶: (self) -> teqpflsh::properties::PropertySet<Eigen::Array<double, -1, 1, 0, -1, 1> >

property transformed_regions¶: (self) -> dict[teqpflsh::properties::PropertyPairs, teqpflsh._teqpflsh_impl.QuadRegion2D]

class teqpflsh._teqpflsh_impl.TrhoLookup¶

Bases: object

C++ docs: TrhoLookup

property T¶: (self) -> float

property d2¶: (self) -> float

property rho¶: (self) -> float

teqpflsh._teqpflsh_impl.add(arg0: int, arg1: int, /) → int¶: add

teqpflsh._teqpflsh_impl.get_pair_from_chars(arg0: str, arg1: str, /) → teqpflsh._teqpflsh_impl.PropertyPairs¶: get_pair_from_chars

teqpflsh._teqpflsh_impl.get_pair_log_scaling(arg: teqpflsh._teqpflsh_impl.PropertyPairs, /) → tuple[bool, bool]¶: get_pair_log_scaling

teqpflsh._teqpflsh_impl.get_property_chars(arg: teqpflsh._teqpflsh_impl.PropertyPairs, /) → tuple[str, str]¶: get_property_chars

teqpflsh._teqpflsh_impl.indexer(arg0: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], arg1: int, /) → float¶: indexer

teqpflsh._teqpflsh_impl.indexer33(arg0: ndarray[dtype=float64, shape=(3, 3), order='C', device='cpu'], arg1: int, arg2: int, arg3: str, /) → float¶: indexer33

teqpflsh._teqpflsh_impl.sample_random(arg0: teqpflsh._teqpflsh_impl.Geometry, arg1: int, arg2: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], arg3: ndarray[dtype=float64, shape=(*), order='C', device='cpu'], /) → None¶: sample_random

class teqpflsh._teqpflsh_impl.teqpHelmholtzInterface(*args, **kwargs)¶

Bases: HelmholtzInterface

C++ docs: teqpHelmholtzInterface

teqpflsh._teqpflsh_impl.toms748_solve(arg0: collections.abc.Callable[[float], float], arg1: float, arg2: float, arg3: int, arg4: int, /) → tuple[tuple[float, float], int]¶: toms748_solve