tboudreaux/GridFire
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(python): Python Bindings

Browse Source 
Python Bindings are working again
This commit is contained in:
Emily Boudreaux
2025-12-20 16:02:52 -05:00
parent d65c237b26
commit 11a596b75b
78 changed files with 4411 additions and 1110 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
stubs/gridfire/_gridfire/__init__.pyi
View File

@@ -2,6 +2,7 @@
Python bindings for the fourdst utility modules which are a part of the 4D-STAR project.
"""
from __future__ import annotations
from . import config
from . import engine
from . import exceptions
from . import io
@@ -12,4 +13,4 @@ from . import screening
from . import solver
from . import type
from . import utils
__all__: list[str] = ['engine', 'exceptions', 'io', 'partition', 'policy', 'reaction', 'screening', 'solver', 'type', 'utils']
__all__: list[str] = ['config', 'engine', 'exceptions', 'io', 'partition', 'policy', 'reaction', 'screening', 'solver', 'type', 'utils']

47
stubs/gridfire/_gridfire/config.pyi Normal file
View File

@@ -0,0 +1,47 @@
"""
GridFire configuration bindings
"""
from __future__ import annotations
import typing
__all__: list[str] = ['AdaptiveEngineViewConfig', 'CVODESolverConfig', 'EngineConfig', 'EngineViewConfig', 'GridFireConfig', 'SolverConfig']
class AdaptiveEngineViewConfig:
def __init__(self) -> None:
...
@property
def relativeCullingThreshold(self) -> float:
...
@relativeCullingThreshold.setter
def relativeCullingThreshold(self, arg0: typing.SupportsFloat) -> None:
...
class CVODESolverConfig:
def __init__(self) -> None:
...
@property
def absTol(self) -> float:
...
@absTol.setter
def absTol(self, arg0: typing.SupportsFloat) -> None:
...
@property
def relTol(self) -> float:
...
@relTol.setter
def relTol(self, arg0: typing.SupportsFloat) -> None:
...
class EngineConfig:
views: EngineViewConfig
def __init__(self) -> None:
...
class EngineViewConfig:
adaptiveEngineView: AdaptiveEngineViewConfig
def __init__(self) -> None:
...
class GridFireConfig:
engine: EngineConfig
solver: SolverConfig
def __init__(self) -> None:
...
class SolverConfig:
cvode: CVODESolverConfig
def __init__(self) -> None:
...

432
stubs/gridfire/_gridfire/engine/__init__.pyi
View File

@@ -14,110 +14,81 @@ import numpy
import numpy.typing
import typing
from . import diagnostics
__all__: list[str] = ['ACTIVE', 'ADAPTIVE_ENGINE_VIEW', 'AdaptiveEngineView', 'BuildDepthType', 'DEFAULT', 'DEFINED_ENGINE_VIEW', 'DefinedEngineView', 'DynamicEngine', 'EQUILIBRIUM', 'Engine', 'EngineTypes', 'FILE_DEFINED_ENGINE_VIEW', 'FULL_SUCCESS', 'FifthOrder', 'FileDefinedEngineView', 'FourthOrder', 'Full', 'GRAPH_ENGINE', 'GraphEngine', 'INACTIVE_FLOW', 'MAX_ITERATIONS_REACHED', 'MULTISCALE_PARTITIONING_ENGINE_VIEW', 'MultiscalePartitioningEngineView', 'NONE', 'NOT_PRESENT', 'NO_SPECIES_TO_PRIME', 'NetworkBuildDepth', 'NetworkConstructionFlags', 'NetworkJacobian', 'NetworkPrimingEngineView', 'PRIMING_ENGINE_VIEW', 'PrimingReport', 'PrimingReportStatus', 'REACLIB', 'REACLIB_STRONG', 'REACLIB_WEAK', 'SecondOrder', 'Shallow', 'SparsityPattern', 'SpeciesStatus', 'StepDerivatives', 'ThirdOrder', 'WRL_BETA_MINUS', 'WRL_BETA_PLUS', 'WRL_ELECTRON_CAPTURE', 'WRL_POSITRON_CAPTURE', 'WRL_WEAK', 'build_nuclear_network', 'diagnostics', 'primeNetwork', 'regularize_jacobian']
from . import scratchpads
__all__: list[str] = ['ACTIVE', 'ADAPTIVE_ENGINE_VIEW', 'AdaptiveEngineView', 'BuildDepthType', 'DEFAULT', 'DEFINED_ENGINE_VIEW', 'DefinedEngineView', 'DynamicEngine', 'EQUILIBRIUM', 'Engine', 'EngineTypes', 'FILE_DEFINED_ENGINE_VIEW', 'FULL_SUCCESS', 'FifthOrder', 'FileDefinedEngineView', 'FourthOrder', 'Full', 'GRAPH_ENGINE', 'GraphEngine', 'INACTIVE_FLOW', 'MAX_ITERATIONS_REACHED', 'MULTISCALE_PARTITIONING_ENGINE_VIEW', 'MultiscalePartitioningEngineView', 'NONE', 'NOT_PRESENT', 'NO_SPECIES_TO_PRIME', 'NetworkBuildDepth', 'NetworkConstructionFlags', 'NetworkJacobian', 'NetworkPrimingEngineView', 'PRIMING_ENGINE_VIEW', 'PrimingReport', 'PrimingReportStatus', 'REACLIB', 'REACLIB_STRONG', 'REACLIB_WEAK', 'SecondOrder', 'Shallow', 'SparsityPattern', 'SpeciesStatus', 'StepDerivatives', 'ThirdOrder', 'WRL_BETA_MINUS', 'WRL_BETA_PLUS', 'WRL_ELECTRON_CAPTURE', 'WRL_POSITRON_CAPTURE', 'WRL_WEAK', 'build_nuclear_network', 'diagnostics', 'primeNetwork', 'regularize_jacobian', 'scratchpads']
class AdaptiveEngineView(DynamicEngine):
def __init__(self, baseEngine: DynamicEngine) -> None:
"""
Construct an adaptive engine view with a base engine.
"""
def calculateEpsDerivatives(self, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
def calculateEpsDerivatives(self, ctx: scratchpads.StateBlob, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
"""
Calculate deps/dT and deps/drho
"""
def calculateMolarReactionFlow(self: DynamicEngine, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
def calculateMolarReactionFlow(self: DynamicEngine, ctx: scratchpads.StateBlob, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
"""
Calculate the molar reaction flow for a given reaction.
"""
def calculateRHSAndEnergy(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
def calculateRHSAndEnergy(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
"""
Calculate the right-hand side (dY/dt) and energy generation rate.
"""
def collectComposition(self, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
def collectComposition(self, ctx: scratchpads.StateBlob, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
"""
Recursively collect composition from current engine and any sub engines if they exist.
"""
@typing.overload
def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
"""
Generate the Jacobian matrix for the current state.
"""
@typing.overload
def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
"""
Generate the jacobian matrix only for the subset of the matrix representing the active species.
"""
@typing.overload
def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
"""
Generate the jacobian matrix for the given sparsity pattern
"""
def generateStoichiometryMatrix(self) -> None:
...
def getBaseEngine(self) -> DynamicEngine:
"""
Get the base engine associated with this adaptive engine view.
"""
def getDepth(self) -> gridfire._gridfire.engine.NetworkBuildDepth | int:
"""
Get the current build depth of the engine.
"""
def getNetworkReactions(self) -> gridfire._gridfire.reaction.ReactionSet:
def getNetworkReactions(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.reaction.ReactionSet:
"""
Get the set of logical reactions in the network.
"""
def getNetworkSpecies(self) -> list[fourdst._phys.atomic.Species]:
def getNetworkSpecies(self, arg0: scratchpads.StateBlob) -> list[fourdst._phys.atomic.Species]:
"""
Get the list of species in the network.
"""
def getScreeningModel(self) -> gridfire._gridfire.screening.ScreeningType:
def getScreeningModel(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.screening.ScreeningType:
"""
Get the current screening model of the engine.
"""
def getSpeciesDestructionTimescales(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
def getSpeciesDestructionTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
"""
Get the destruction timescales for each species in the network.
"""
def getSpeciesIndex(self, species: fourdst._phys.atomic.Species) -> int:
def getSpeciesIndex(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> int:
"""
Get the index of a species in the network.
"""
def getSpeciesStatus(self, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
def getSpeciesStatus(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
"""
Get the status of a species in the network.
"""
def getSpeciesTimescales(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
def getSpeciesTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
"""
Get the timescales for each species in the network.
"""
def getStoichiometryMatrixEntry(self, species: fourdst._phys.atomic.Species, reaction: ...) -> int:
"""
Get an entry from the stoichiometry matrix.
"""
def isStale(self, netIn: gridfire._gridfire.type.NetIn) -> bool:
"""
Check if the engine is stale based on the provided NetIn object.
"""
def mapNetInToMolarAbundanceVector(self, netIn: gridfire._gridfire.type.NetIn) -> list[float]:
"""
Map a NetIn object to a vector of molar abundances.
"""
def primeEngine(self, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
def primeEngine(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
"""
Prime the engine with a NetIn object to prepare for calculations.
"""
def rebuild(self, composition: ..., depth: gridfire._gridfire.engine.NetworkBuildDepth | typing.SupportsInt = ...) -> None:
"""
Rebuild the engine with a new composition and build depth.
"""
def setNetworkReactions(self, reactions: gridfire._gridfire.reaction.ReactionSet) -> None:
"""
Set the network reactions to a new set of reactions.
"""
def setScreeningModel(self, screeningModel: gridfire._gridfire.screening.ScreeningType) -> None:
"""
Set the screening model for the engine.
"""
def update(self, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
def project(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
"""
Update the engine state based on the provided NetIn object.
"""
@@ -128,104 +99,74 @@ class DefinedEngineView(DynamicEngine):
"""
Construct a defined engine view with a list of tracked reactions and a base engine.
"""
def calculateEpsDerivatives(self, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
def calculateEpsDerivatives(self, ctx: scratchpads.StateBlob, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
"""
Calculate deps/dT and deps/drho
"""
def calculateMolarReactionFlow(self: DynamicEngine, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
def calculateMolarReactionFlow(self: DynamicEngine, ctx: scratchpads.StateBlob, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
"""
Calculate the molar reaction flow for a given reaction.
"""
def calculateRHSAndEnergy(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
def calculateRHSAndEnergy(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
"""
Calculate the right-hand side (dY/dt) and energy generation rate.
"""
def collectComposition(self, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
def collectComposition(self, ctx: scratchpads.StateBlob, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
"""
Recursively collect composition from current engine and any sub engines if they exist.
"""
@typing.overload
def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
"""
Generate the Jacobian matrix for the current state.
"""
@typing.overload
def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
"""
Generate the jacobian matrix only for the subset of the matrix representing the active species.
"""
@typing.overload
def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
"""
Generate the jacobian matrix for the given sparsity pattern
"""
def generateStoichiometryMatrix(self) -> None:
...
def getBaseEngine(self) -> DynamicEngine:
"""
Get the base engine associated with this defined engine view.
"""
def getDepth(self) -> gridfire._gridfire.engine.NetworkBuildDepth | int:
"""
Get the current build depth of the engine.
"""
def getNetworkReactions(self) -> gridfire._gridfire.reaction.ReactionSet:
def getNetworkReactions(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.reaction.ReactionSet:
"""
Get the set of logical reactions in the network.
"""
def getNetworkSpecies(self) -> list[fourdst._phys.atomic.Species]:
def getNetworkSpecies(self, arg0: scratchpads.StateBlob) -> list[fourdst._phys.atomic.Species]:
"""
Get the list of species in the network.
"""
def getScreeningModel(self) -> gridfire._gridfire.screening.ScreeningType:
def getScreeningModel(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.screening.ScreeningType:
"""
Get the current screening model of the engine.
"""
def getSpeciesDestructionTimescales(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
def getSpeciesDestructionTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
"""
Get the destruction timescales for each species in the network.
"""
def getSpeciesIndex(self, species: fourdst._phys.atomic.Species) -> int:
def getSpeciesIndex(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> int:
"""
Get the index of a species in the network.
"""
def getSpeciesStatus(self, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
def getSpeciesStatus(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
"""
Get the status of a species in the network.
"""
def getSpeciesTimescales(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
def getSpeciesTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
"""
Get the timescales for each species in the network.
"""
def getStoichiometryMatrixEntry(self, species: fourdst._phys.atomic.Species, reaction: ...) -> int:
"""
Get an entry from the stoichiometry matrix.
"""
def isStale(self, netIn: gridfire._gridfire.type.NetIn) -> bool:
"""
Check if the engine is stale based on the provided NetIn object.
"""
def mapNetInToMolarAbundanceVector(self, netIn: gridfire._gridfire.type.NetIn) -> list[float]:
"""
Map a NetIn object to a vector of molar abundances.
"""
def primeEngine(self, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
def primeEngine(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
"""
Prime the engine with a NetIn object to prepare for calculations.
"""
def rebuild(self, composition: ..., depth: gridfire._gridfire.engine.NetworkBuildDepth | typing.SupportsInt = ...) -> None:
"""
Rebuild the engine with a new composition and build depth.
"""
def setNetworkReactions(self, reactions: gridfire._gridfire.reaction.ReactionSet) -> None:
"""
Set the network reactions to a new set of reactions.
"""
def setScreeningModel(self, screeningModel: gridfire._gridfire.screening.ScreeningType) -> None:
"""
Set the screening model for the engine.
"""
def update(self, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
def project(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
"""
Update the engine state based on the provided NetIn object.
"""
@@ -293,56 +234,50 @@ class FileDefinedEngineView(DefinedEngineView):
"""
Construct a defined engine view from a file and a base engine.
"""
def calculateEpsDerivatives(self, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
def calculateEpsDerivatives(self, ctx: scratchpads.StateBlob, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
"""
Calculate deps/dT and deps/drho
"""
def calculateMolarReactionFlow(self: DynamicEngine, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
def calculateMolarReactionFlow(self: DynamicEngine, ctx: scratchpads.StateBlob, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
"""
Calculate the molar reaction flow for a given reaction.
"""
def calculateRHSAndEnergy(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
def calculateRHSAndEnergy(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
"""
Calculate the right-hand side (dY/dt) and energy generation rate.
"""
def collectComposition(self, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
def collectComposition(self, ctx: scratchpads.StateBlob, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
"""
Recursively collect composition from current engine and any sub engines if they exist.
"""
@typing.overload
def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
"""
Generate the Jacobian matrix for the current state.
"""
@typing.overload
def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
"""
Generate the jacobian matrix only for the subset of the matrix representing the active species.
"""
@typing.overload
def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
"""
Generate the jacobian matrix for the given sparsity pattern
"""
def generateStoichiometryMatrix(self) -> None:
...
def getBaseEngine(self) -> DynamicEngine:
"""
Get the base engine associated with this file defined engine view.
"""
def getDepth(self) -> gridfire._gridfire.engine.NetworkBuildDepth | int:
"""
Get the current build depth of the engine.
"""
def getNetworkFile(self) -> str:
"""
Get the network file associated with this defined engine view.
"""
def getNetworkReactions(self) -> gridfire._gridfire.reaction.ReactionSet:
def getNetworkReactions(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.reaction.ReactionSet:
"""
Get the set of logical reactions in the network.
"""
def getNetworkSpecies(self) -> list[fourdst._phys.atomic.Species]:
def getNetworkSpecies(self, arg0: scratchpads.StateBlob) -> list[fourdst._phys.atomic.Species]:
"""
Get the list of species in the network.
"""
@@ -350,64 +285,35 @@ class FileDefinedEngineView(DefinedEngineView):
"""
Get the parser used for this defined engine view.
"""
def getScreeningModel(self) -> gridfire._gridfire.screening.ScreeningType:
def getScreeningModel(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.screening.ScreeningType:
"""
Get the current screening model of the engine.
"""
def getSpeciesDestructionTimescales(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
def getSpeciesDestructionTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
"""
Get the destruction timescales for each species in the network.
"""
def getSpeciesIndex(self, species: fourdst._phys.atomic.Species) -> int:
def getSpeciesIndex(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> int:
"""
Get the index of a species in the network.
"""
def getSpeciesStatus(self, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
def getSpeciesStatus(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
"""
Get the status of a species in the network.
"""
def getSpeciesTimescales(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
def getSpeciesTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
"""
Get the timescales for each species in the network.
"""
def getStoichiometryMatrixEntry(self, species: fourdst._phys.atomic.Species, reaction: ...) -> int:
"""
Get an entry from the stoichiometry matrix.
"""
def isStale(self, netIn: gridfire._gridfire.type.NetIn) -> bool:
"""
Check if the engine is stale based on the provided NetIn object.
"""
def mapNetInToMolarAbundanceVector(self, netIn: gridfire._gridfire.type.NetIn) -> list[float]:
"""
Map a NetIn object to a vector of molar abundances.
"""
def primeEngine(self, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
def primeEngine(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
"""
Prime the engine with a NetIn object to prepare for calculations.
"""
def rebuild(self, composition: ..., depth: gridfire._gridfire.engine.NetworkBuildDepth | typing.SupportsInt = ...) -> None:
"""
Rebuild the engine with a new composition and build depth.
"""
def setNetworkReactions(self, reactions: gridfire._gridfire.reaction.ReactionSet) -> None:
"""
Set the network reactions to a new set of reactions.
"""
def setScreeningModel(self, screeningModel: gridfire._gridfire.screening.ScreeningType) -> None:
"""
Set the screening model for the engine.
"""
def update(self, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
def project(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
"""
Update the engine state based on the provided NetIn object.
"""
class GraphEngine(DynamicEngine):
@staticmethod
def getNetReactionStoichiometry(reaction: ...) -> dict[fourdst._phys.atomic.Species, int]:
"""
Get the net stoichiometry for a given reaction.
"""
@typing.overload
def __init__(self, composition: fourdst._phys.composition.Composition, depth: gridfire._gridfire.engine.NetworkBuildDepth | typing.SupportsInt = ...) -> None:
"""
@@ -423,15 +329,15 @@ class GraphEngine(DynamicEngine):
"""
Initialize GraphEngine with a set of reactions.
"""
def calculateEpsDerivatives(self, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
def calculateEpsDerivatives(self, ctx: scratchpads.StateBlob, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
"""
Calculate deps/dT and deps/drho
"""
def calculateMolarReactionFlow(self: DynamicEngine, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
def calculateMolarReactionFlow(self: DynamicEngine, ctx: scratchpads.StateBlob, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
"""
Calculate the molar reaction flow for a given reaction.
"""
def calculateRHSAndEnergy(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
def calculateRHSAndEnergy(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
"""
Calculate the right-hand side (dY/dt) and energy generation rate.
"""
@@ -447,128 +353,90 @@ class GraphEngine(DynamicEngine):
"""
Calculate the derivative of the reverse rate for a two-body reaction at a specific temperature.
"""
def collectComposition(self, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
def collectComposition(self, ctx: scratchpads.StateBlob, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
"""
Recursively collect composition from current engine and any sub engines if they exist.
"""
def exportToCSV(self, filename: str) -> None:
def exportToCSV(self, ctx: scratchpads.StateBlob, filename: str) -> None:
"""
Export the network to a CSV file for analysis.
"""
def exportToDot(self, filename: str) -> None:
def exportToDot(self, ctx: scratchpads.StateBlob, filename: str) -> None:
"""
Export the network to a DOT file for visualization.
"""
@typing.overload
def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
"""
Generate the Jacobian matrix for the current state.
"""
@typing.overload
def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
"""
Generate the jacobian matrix only for the subset of the matrix representing the active species.
"""
@typing.overload
def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
"""
Generate the jacobian matrix for the given sparsity pattern
"""
def generateStoichiometryMatrix(self) -> None:
...
def getDepth(self) -> gridfire._gridfire.engine.NetworkBuildDepth | int:
"""
Get the current build depth of the engine.
"""
def getNetworkReactions(self) -> gridfire._gridfire.reaction.ReactionSet:
def getNetworkReactions(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.reaction.ReactionSet:
"""
Get the set of logical reactions in the network.
"""
def getNetworkSpecies(self) -> list[fourdst._phys.atomic.Species]:
def getNetworkSpecies(self, arg0: scratchpads.StateBlob) -> list[fourdst._phys.atomic.Species]:
"""
Get the list of species in the network.
"""
def getPartitionFunction(self) -> gridfire._gridfire.partition.PartitionFunction:
def getPartitionFunction(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.partition.PartitionFunction:
"""
Get the partition function used by the engine.
"""
def getScreeningModel(self) -> gridfire._gridfire.screening.ScreeningType:
def getScreeningModel(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.screening.ScreeningType:
"""
Get the current screening model of the engine.
"""
@typing.overload
def getSpeciesDestructionTimescales(self, composition: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeReactions: gridfire._gridfire.reaction.ReactionSet) -> ...:
def getSpeciesDestructionTimescales(self, ctx: scratchpads.StateBlob, composition: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeReactions: gridfire._gridfire.reaction.ReactionSet) -> ...:
...
@typing.overload
def getSpeciesDestructionTimescales(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
def getSpeciesDestructionTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
"""
Get the destruction timescales for each species in the network.
"""
def getSpeciesIndex(self, species: fourdst._phys.atomic.Species) -> int:
def getSpeciesIndex(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> int:
"""
Get the index of a species in the network.
"""
def getSpeciesStatus(self, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
def getSpeciesStatus(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
"""
Get the status of a species in the network.
"""
@typing.overload
def getSpeciesTimescales(self, composition: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeReactions: gridfire._gridfire.reaction.ReactionSet) -> ...:
def getSpeciesTimescales(self, ctx: scratchpads.StateBlob, composition: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeReactions: gridfire._gridfire.reaction.ReactionSet) -> ...:
...
@typing.overload
def getSpeciesTimescales(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
def getSpeciesTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
"""
Get the timescales for each species in the network.
"""
def getStoichiometryMatrixEntry(self, species: fourdst._phys.atomic.Species, reaction: ...) -> int:
"""
Get an entry from the stoichiometry matrix.
"""
def involvesSpecies(self, species: fourdst._phys.atomic.Species) -> bool:
def involvesSpecies(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> bool:
"""
Check if a given species is involved in the network.
"""
def isPrecomputationEnabled(self) -> bool:
def isPrecomputationEnabled(self, arg0: scratchpads.StateBlob) -> bool:
"""
Check if precomputation is enabled for the engine.
"""
def isStale(self, netIn: gridfire._gridfire.type.NetIn) -> bool:
"""
Check if the engine is stale based on the provided NetIn object.
"""
def isUsingReverseReactions(self) -> bool:
def isUsingReverseReactions(self, arg0: scratchpads.StateBlob) -> bool:
"""
Check if the engine is using reverse reactions.
"""
def mapNetInToMolarAbundanceVector(self, netIn: gridfire._gridfire.type.NetIn) -> list[float]:
"""
Map a NetIn object to a vector of molar abundances.
"""
def primeEngine(self, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
def primeEngine(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
"""
Prime the engine with a NetIn object to prepare for calculations.
"""
def rebuild(self, composition: ..., depth: gridfire._gridfire.engine.NetworkBuildDepth | typing.SupportsInt = ...) -> None:
"""
Rebuild the engine with a new composition and build depth.
"""
def setNetworkReactions(self, reactions: gridfire._gridfire.reaction.ReactionSet) -> None:
"""
Set the network reactions to a new set of reactions.
"""
def setPrecomputation(self, precompute: bool) -> None:
"""
Enable or disable precomputation for the engine.
"""
def setScreeningModel(self, screeningModel: gridfire._gridfire.screening.ScreeningType) -> None:
"""
Set the screening model for the engine.
"""
def setUseReverseReactions(self, useReverse: bool) -> None:
"""
Enable or disable the use of reverse reactions in the engine.
"""
def update(self, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
def project(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
"""
Update the engine state based on the provided NetIn object.
"""
@@ -577,142 +445,106 @@ class MultiscalePartitioningEngineView(DynamicEngine):
"""
Construct a multiscale partitioning engine view with a base engine.
"""
def calculateEpsDerivatives(self, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
def calculateEpsDerivatives(self, ctx: scratchpads.StateBlob, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
"""
Calculate deps/dT and deps/drho
"""
def calculateMolarReactionFlow(self: DynamicEngine, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
def calculateMolarReactionFlow(self: DynamicEngine, ctx: scratchpads.StateBlob, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
"""
Calculate the molar reaction flow for a given reaction.
"""
def calculateRHSAndEnergy(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
def calculateRHSAndEnergy(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
"""
Calculate the right-hand side (dY/dt) and energy generation rate.
"""
def collectComposition(self, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
def collectComposition(self, ctx: scratchpads.StateBlob, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
"""
Recursively collect composition from current engine and any sub engines if they exist.
"""
def exportToDot(self, filename: str, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> None:
def exportToDot(self, ctx: scratchpads.StateBlob, filename: str, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> None:
"""
Export the network to a DOT file for visualization.
"""
@typing.overload
def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
"""
Generate the Jacobian matrix for the current state.
"""
@typing.overload
def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
"""
Generate the jacobian matrix only for the subset of the matrix representing the active species.
"""
@typing.overload
def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
"""
Generate the jacobian matrix for the given sparsity pattern
"""
def generateStoichiometryMatrix(self) -> None:
...
def getBaseEngine(self) -> DynamicEngine:
"""
Get the base engine associated with this multiscale partitioning engine view.
"""
def getDepth(self) -> gridfire._gridfire.engine.NetworkBuildDepth | int:
"""
Get the current build depth of the engine.
"""
def getDynamicSpecies(self) -> list[fourdst._phys.atomic.Species]:
def getDynamicSpecies(self: scratchpads.StateBlob) -> list[fourdst._phys.atomic.Species]:
"""
Get the list of dynamic species in the network.
"""
def getFastSpecies(self) -> list[fourdst._phys.atomic.Species]:
def getFastSpecies(self, arg0: scratchpads.StateBlob) -> list[fourdst._phys.atomic.Species]:
"""
Get the list of fast species in the network.
"""
def getNetworkReactions(self) -> gridfire._gridfire.reaction.ReactionSet:
def getNetworkReactions(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.reaction.ReactionSet:
"""
Get the set of logical reactions in the network.
"""
def getNetworkSpecies(self) -> list[fourdst._phys.atomic.Species]:
def getNetworkSpecies(self, arg0: scratchpads.StateBlob) -> list[fourdst._phys.atomic.Species]:
"""
Get the list of species in the network.
"""
def getNormalizedEquilibratedComposition(self, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
def getNormalizedEquilibratedComposition(self, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
"""
Get the normalized equilibrated composition for the algebraic species.
"""
def getScreeningModel(self) -> gridfire._gridfire.screening.ScreeningType:
def getScreeningModel(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.screening.ScreeningType:
"""
Get the current screening model of the engine.
"""
def getSpeciesDestructionTimescales(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
def getSpeciesDestructionTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
"""
Get the destruction timescales for each species in the network.
"""
def getSpeciesIndex(self, species: fourdst._phys.atomic.Species) -> int:
def getSpeciesIndex(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> int:
"""
Get the index of a species in the network.
"""
def getSpeciesStatus(self, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
def getSpeciesStatus(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
"""
Get the status of a species in the network.
"""
def getSpeciesTimescales(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
def getSpeciesTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
"""
Get the timescales for each species in the network.
"""
def getStoichiometryMatrixEntry(self, species: fourdst._phys.atomic.Species, reaction: ...) -> int:
"""
Get an entry from the stoichiometry matrix.
"""
def involvesSpecies(self, species: fourdst._phys.atomic.Species) -> bool:
def involvesSpecies(self: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> bool:
"""
Check if a given species is involved in the network (in either the algebraic or dynamic set).
"""
def involvesSpeciesInDynamic(self, species: fourdst._phys.atomic.Species) -> bool:
def involvesSpeciesInDynamic(self: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> bool:
"""
Check if a given species is involved in the network's dynamic set.
"""
def involvesSpeciesInQSE(self, species: fourdst._phys.atomic.Species) -> bool:
def involvesSpeciesInQSE(self: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> bool:
"""
Check if a given species is involved in the network's algebraic set.
"""
def isStale(self, netIn: gridfire._gridfire.type.NetIn) -> bool:
"""
Check if the engine is stale based on the provided NetIn object.
"""
def mapNetInToMolarAbundanceVector(self, netIn: gridfire._gridfire.type.NetIn) -> list[float]:
"""
Map a NetIn object to a vector of molar abundances.
"""
@typing.overload
def partitionNetwork(self, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
def partitionNetwork(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
"""
Partition the network based on species timescales and connectivity.
"""
@typing.overload
def partitionNetwork(self, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
"""
Partition the network based on a NetIn object.
"""
def primeEngine(self, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
def primeEngine(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
"""
Prime the engine with a NetIn object to prepare for calculations.
"""
def rebuild(self, composition: ..., depth: gridfire._gridfire.engine.NetworkBuildDepth | typing.SupportsInt = ...) -> None:
"""
Rebuild the engine with a new composition and build depth.
"""
def setNetworkReactions(self, reactions: gridfire._gridfire.reaction.ReactionSet) -> None:
"""
Set the network reactions to a new set of reactions.
"""
def setScreeningModel(self, screeningModel: gridfire._gridfire.screening.ScreeningType) -> None:
"""
Set the screening model for the engine.
"""
def update(self, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
def project(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
"""
Update the engine state based on the provided NetIn object.
"""
@@ -893,113 +725,83 @@ class NetworkJacobian:
"""
class NetworkPrimingEngineView(DefinedEngineView):
@typing.overload
def __init__(self, primingSymbol: str, baseEngine: GraphEngine) -> None:
def __init__(self, ctx: scratchpads.StateBlob, primingSymbol: str, baseEngine: GraphEngine) -> None:
"""
Construct a priming engine view with a priming symbol and a base engine.
"""
@typing.overload
def __init__(self, primingSpecies: fourdst._phys.atomic.Species, baseEngine: GraphEngine) -> None:
def __init__(self, ctx: scratchpads.StateBlob, primingSpecies: fourdst._phys.atomic.Species, baseEngine: GraphEngine) -> None:
"""
Construct a priming engine view with a priming species and a base engine.
"""
def calculateEpsDerivatives(self, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
def calculateEpsDerivatives(self, ctx: scratchpads.StateBlob, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
"""
Calculate deps/dT and deps/drho
"""
def calculateMolarReactionFlow(self: DynamicEngine, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
def calculateMolarReactionFlow(self: DynamicEngine, ctx: scratchpads.StateBlob, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
"""
Calculate the molar reaction flow for a given reaction.
"""
def calculateRHSAndEnergy(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
def calculateRHSAndEnergy(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
"""
Calculate the right-hand side (dY/dt) and energy generation rate.
"""
def collectComposition(self, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
def collectComposition(self, ctx: scratchpads.StateBlob, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
"""
Recursively collect composition from current engine and any sub engines if they exist.
"""
@typing.overload
def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
"""
Generate the Jacobian matrix for the current state.
"""
@typing.overload
def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
"""
Generate the jacobian matrix only for the subset of the matrix representing the active species.
"""
@typing.overload
def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
"""
Generate the jacobian matrix for the given sparsity pattern
"""
def generateStoichiometryMatrix(self) -> None:
...
def getBaseEngine(self) -> DynamicEngine:
"""
Get the base engine associated with this priming engine view.
"""
def getDepth(self) -> gridfire._gridfire.engine.NetworkBuildDepth | int:
"""
Get the current build depth of the engine.
"""
def getNetworkReactions(self) -> gridfire._gridfire.reaction.ReactionSet:
def getNetworkReactions(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.reaction.ReactionSet:
"""
Get the set of logical reactions in the network.
"""
def getNetworkSpecies(self) -> list[fourdst._phys.atomic.Species]:
def getNetworkSpecies(self, arg0: scratchpads.StateBlob) -> list[fourdst._phys.atomic.Species]:
"""
Get the list of species in the network.
"""
def getScreeningModel(self) -> gridfire._gridfire.screening.ScreeningType:
def getScreeningModel(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.screening.ScreeningType:
"""
Get the current screening model of the engine.
"""
def getSpeciesDestructionTimescales(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
def getSpeciesDestructionTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
"""
Get the destruction timescales for each species in the network.
"""
def getSpeciesIndex(self, species: fourdst._phys.atomic.Species) -> int:
def getSpeciesIndex(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> int:
"""
Get the index of a species in the network.
"""
def getSpeciesStatus(self, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
def getSpeciesStatus(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
"""
Get the status of a species in the network.
"""
def getSpeciesTimescales(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
def getSpeciesTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
"""
Get the timescales for each species in the network.
"""
def getStoichiometryMatrixEntry(self, species: fourdst._phys.atomic.Species, reaction: ...) -> int:
"""
Get an entry from the stoichiometry matrix.
"""
def isStale(self, netIn: gridfire._gridfire.type.NetIn) -> bool:
"""
Check if the engine is stale based on the provided NetIn object.
"""
def mapNetInToMolarAbundanceVector(self, netIn: gridfire._gridfire.type.NetIn) -> list[float]:
"""
Map a NetIn object to a vector of molar abundances.
"""
def primeEngine(self, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
def primeEngine(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
"""
Prime the engine with a NetIn object to prepare for calculations.
"""
def rebuild(self, composition: ..., depth: gridfire._gridfire.engine.NetworkBuildDepth | typing.SupportsInt = ...) -> None:
"""
Rebuild the engine with a new composition and build depth.
"""
def setNetworkReactions(self, reactions: gridfire._gridfire.reaction.ReactionSet) -> None:
"""
Set the network reactions to a new set of reactions.
"""
def setScreeningModel(self, screeningModel: gridfire._gridfire.screening.ScreeningType) -> None:
"""
Set the screening model for the engine.
"""
def update(self, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
def project(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
"""
Update the engine state based on the provided NetIn object.
"""
@@ -1131,7 +933,7 @@ def build_nuclear_network(composition: ..., weakInterpolator: ..., maxLayers: gr
"""
Build a nuclear network from a composition using all archived reaction data.
"""
def primeNetwork(netIn: gridfire._gridfire.type.NetIn, engine: ..., ignoredReactionTypes: collections.abc.Sequence[...] | None = None) -> PrimingReport:
def primeNetwork(ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn, engine: ..., ignoredReactionTypes: collections.abc.Sequence[...] | None = None) -> PrimingReport:
"""
Prime a network with a short timescale ignition
"""

7
stubs/gridfire/_gridfire/engine/diagnostics.pyi
View File

@@ -5,11 +5,12 @@ from __future__ import annotations
import collections.abc
import fourdst._phys.composition
import gridfire._gridfire.engine
import gridfire._gridfire.engine.scratchpads
import typing
__all__: list[str] = ['inspect_jacobian_stiffness', 'inspect_species_balance', 'report_limiting_species']
def inspect_jacobian_stiffness(engine: gridfire._gridfire.engine.DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, json: bool) -> ... | None:
def inspect_jacobian_stiffness(ctx: gridfire._gridfire.engine.scratchpads.StateBlob, engine: gridfire._gridfire.engine.DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, json: bool) -> ... | None:
...
def inspect_species_balance(engine: gridfire._gridfire.engine.DynamicEngine, species_name: str, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, json: bool) -> ... | None:
def inspect_species_balance(ctx: gridfire._gridfire.engine.scratchpads.StateBlob, engine: gridfire._gridfire.engine.DynamicEngine, species_name: str, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, json: bool) -> ... | None:
...
def report_limiting_species(engine: gridfire._gridfire.engine.DynamicEngine, Y_full: collections.abc.Sequence[typing.SupportsFloat], E_full: collections.abc.Sequence[typing.SupportsFloat], relTol: typing.SupportsFloat, absTol: typing.SupportsFloat, top_n: typing.SupportsInt, json: bool) -> ... | None:
def report_limiting_species(ctx: gridfire._gridfire.engine.scratchpads.StateBlob, engine: gridfire._gridfire.engine.DynamicEngine, Y_full: collections.abc.Sequence[typing.SupportsFloat], E_full: collections.abc.Sequence[typing.SupportsFloat], relTol: typing.SupportsFloat, absTol: typing.SupportsFloat, top_n: typing.SupportsInt, json: bool) -> ... | None:
...

267
stubs/gridfire/_gridfire/engine/scratchpads.pyi Normal file
View File

@@ -0,0 +1,267 @@
"""
Engine ScratchPad bindings
"""
from __future__ import annotations
import fourdst._phys.atomic
import fourdst._phys.composition
import gridfire._gridfire.reaction
import typing
__all__: list[str] = ['ADAPTIVE_ENGINE_VIEW_SCRATCHPAD', 'ADFunRegistrationResult', 'ALREADY_REGISTERED', 'AdaptiveEngineViewScratchPad', 'DEFINED_ENGINE_VIEW_SCRATCHPAD', 'DefinedEngineViewScratchPad', 'GRAPH_ENGINE_SCRATCHPAD', 'GraphEngineScratchPad', 'MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD', 'MultiscalePartitioningEngineViewScratchPad', 'SCRATCHPAD_BAD_CAST', 'SCRATCHPAD_NOT_FOUND', 'SCRATCHPAD_NOT_INITIALIZED', 'SCRATCHPAD_OUT_OF_BOUNDS', 'SCRATCHPAD_TYPE_COLLISION', 'SCRATCHPAD_UNKNOWN_ERROR', 'SUCCESS', 'ScratchPadType', 'StateBlob', 'StateBlobError']
class ADFunRegistrationResult:
"""
Members:
SUCCESS
ALREADY_REGISTERED
"""
ALREADY_REGISTERED: typing.ClassVar[ADFunRegistrationResult] # value = <ADFunRegistrationResult.ALREADY_REGISTERED: 1>
SUCCESS: typing.ClassVar[ADFunRegistrationResult] # value = <ADFunRegistrationResult.SUCCESS: 0>
__members__: typing.ClassVar[dict[str, ADFunRegistrationResult]] # value = {'SUCCESS': <ADFunRegistrationResult.SUCCESS: 0>, 'ALREADY_REGISTERED': <ADFunRegistrationResult.ALREADY_REGISTERED: 1>}
def __eq__(self, other: typing.Any) -> bool:
...
def __getstate__(self) -> int:
...
def __hash__(self) -> int:
...
def __index__(self) -> int:
...
def __init__(self, value: typing.SupportsInt) -> None:
...
def __int__(self) -> int:
...
def __ne__(self, other: typing.Any) -> bool:
...
def __repr__(self) -> str:
...
def __setstate__(self, state: typing.SupportsInt) -> None:
...
def __str__(self) -> str:
...
@property
def name(self) -> str:
...
@property
def value(self) -> int:
...
class AdaptiveEngineViewScratchPad:
ID: typing.ClassVar[ScratchPadType] # value = <ScratchPadType.ADAPTIVE_ENGINE_VIEW_SCRATCHPAD: 2>
def __init__(self) -> None:
...
def __repr__(self) -> str:
...
def clone(self) -> ...:
...
def initialize(self, arg0: ...) -> None:
...
def is_initialized(self) -> bool:
...
@property
def active_reactions(self) -> gridfire._gridfire.reaction.ReactionSet:
...
@property
def active_species(self) -> list[fourdst._phys.atomic.Species]:
...
@property
def has_initialized(self) -> bool:
...
class DefinedEngineViewScratchPad:
ID: typing.ClassVar[ScratchPadType] # value = <ScratchPadType.DEFINED_ENGINE_VIEW_SCRATCHPAD: 3>
def __init__(self) -> None:
...
def __repr__(self) -> str:
...
def clone(self) -> ...:
...
def is_initialized(self) -> bool:
...
@property
def active_reactions(self) -> gridfire._gridfire.reaction.ReactionSet:
...
@property
def active_species(self) -> set[fourdst._phys.atomic.Species]:
...
@property
def has_initialized(self) -> bool:
...
@property
def reaction_index_map(self) -> list[int]:
...
@property
def species_index_map(self) -> list[int]:
...
class GraphEngineScratchPad:
ID: typing.ClassVar[ScratchPadType] # value = <ScratchPadType.GRAPH_ENGINE_SCRATCHPAD: 0>
def __init__(self) -> None:
...
def __repr__(self) -> str:
...
def clone(self) -> ...:
...
def initialize(self, engine: ...) -> None:
...
def is_initialized(self) -> bool:
...
@property
def has_initialized(self) -> bool:
...
@property
def local_abundance_cache(self) -> list[float]:
...
@property
def most_recent_rhs_calculation(self) -> ... | None:
...
@property
def stepDerivativesCache(self) -> dict[int, ...]:
...
class MultiscalePartitioningEngineViewScratchPad:
ID: typing.ClassVar[ScratchPadType] # value = <ScratchPadType.MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD: 1>
def __init__(self) -> None:
...
def __repr__(self) -> str:
...
def clone(self) -> ...:
...
def initialize(self) -> None:
...
def is_initialized(self) -> bool:
...
@property
def algebraic_species(self) -> list[fourdst._phys.atomic.Species]:
...
@property
def composition_cache(self) -> dict[int, fourdst._phys.composition.Composition]:
...
@property
def dynamic_species(self) -> list[fourdst._phys.atomic.Species]:
...
@property
def has_initialized(self) -> bool:
...
@property
def qse_groups(self) -> list[...]:
...
class ScratchPadType:
"""
Members:
GRAPH_ENGINE_SCRATCHPAD
MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD
ADAPTIVE_ENGINE_VIEW_SCRATCHPAD
DEFINED_ENGINE_VIEW_SCRATCHPAD
"""
ADAPTIVE_ENGINE_VIEW_SCRATCHPAD: typing.ClassVar[ScratchPadType] # value = <ScratchPadType.ADAPTIVE_ENGINE_VIEW_SCRATCHPAD: 2>
DEFINED_ENGINE_VIEW_SCRATCHPAD: typing.ClassVar[ScratchPadType] # value = <ScratchPadType.DEFINED_ENGINE_VIEW_SCRATCHPAD: 3>
GRAPH_ENGINE_SCRATCHPAD: typing.ClassVar[ScratchPadType] # value = <ScratchPadType.GRAPH_ENGINE_SCRATCHPAD: 0>
MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD: typing.ClassVar[ScratchPadType] # value = <ScratchPadType.MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD: 1>
__members__: typing.ClassVar[dict[str, ScratchPadType]] # value = {'GRAPH_ENGINE_SCRATCHPAD': <ScratchPadType.GRAPH_ENGINE_SCRATCHPAD: 0>, 'MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD': <ScratchPadType.MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD: 1>, 'ADAPTIVE_ENGINE_VIEW_SCRATCHPAD': <ScratchPadType.ADAPTIVE_ENGINE_VIEW_SCRATCHPAD: 2>, 'DEFINED_ENGINE_VIEW_SCRATCHPAD': <ScratchPadType.DEFINED_ENGINE_VIEW_SCRATCHPAD: 3>}
def __eq__(self, other: typing.Any) -> bool:
...
def __getstate__(self) -> int:
...
def __hash__(self) -> int:
...
def __index__(self) -> int:
...
def __init__(self, value: typing.SupportsInt) -> None:
...
def __int__(self) -> int:
...
def __ne__(self, other: typing.Any) -> bool:
...
def __repr__(self) -> str:
...
def __setstate__(self, state: typing.SupportsInt) -> None:
...
def __str__(self) -> str:
...
@property
def name(self) -> str:
...
@property
def value(self) -> int:
...
class StateBlob:
@staticmethod
def error_to_string(arg0: StateBlobError) -> str:
...
def __init__(self) -> None:
...
def __repr__(self) -> str:
...
def clone_structure(self) -> StateBlob:
...
def enroll(self, arg0: ScratchPadType) -> None:
...
def get(self, arg0: ScratchPadType) -> ...:
...
def get_registered_scratchpads(self) -> set[ScratchPadType]:
...
def get_status(self, arg0: ScratchPadType) -> ...:
...
def get_status_map(self) -> dict[ScratchPadType, ...]:
...
class StateBlobError:
"""
Members:
SCRATCHPAD_OUT_OF_BOUNDS
SCRATCHPAD_NOT_FOUND
SCRATCHPAD_BAD_CAST
SCRATCHPAD_NOT_INITIALIZED
SCRATCHPAD_TYPE_COLLISION
SCRATCHPAD_UNKNOWN_ERROR
"""
SCRATCHPAD_BAD_CAST: typing.ClassVar[StateBlobError] # value = <StateBlobError.SCRATCHPAD_BAD_CAST: 1>
SCRATCHPAD_NOT_FOUND: typing.ClassVar[StateBlobError] # value = <StateBlobError.SCRATCHPAD_NOT_FOUND: 0>
SCRATCHPAD_NOT_INITIALIZED: typing.ClassVar[StateBlobError] # value = <StateBlobError.SCRATCHPAD_NOT_INITIALIZED: 2>
SCRATCHPAD_OUT_OF_BOUNDS: typing.ClassVar[StateBlobError] # value = <StateBlobError.SCRATCHPAD_OUT_OF_BOUNDS: 4>
SCRATCHPAD_TYPE_COLLISION: typing.ClassVar[StateBlobError] # value = <StateBlobError.SCRATCHPAD_TYPE_COLLISION: 3>
SCRATCHPAD_UNKNOWN_ERROR: typing.ClassVar[StateBlobError] # value = <StateBlobError.SCRATCHPAD_UNKNOWN_ERROR: 5>
__members__: typing.ClassVar[dict[str, StateBlobError]] # value = {'SCRATCHPAD_OUT_OF_BOUNDS': <StateBlobError.SCRATCHPAD_OUT_OF_BOUNDS: 4>, 'SCRATCHPAD_NOT_FOUND': <StateBlobError.SCRATCHPAD_NOT_FOUND: 0>, 'SCRATCHPAD_BAD_CAST': <StateBlobError.SCRATCHPAD_BAD_CAST: 1>, 'SCRATCHPAD_NOT_INITIALIZED': <StateBlobError.SCRATCHPAD_NOT_INITIALIZED: 2>, 'SCRATCHPAD_TYPE_COLLISION': <StateBlobError.SCRATCHPAD_TYPE_COLLISION: 3>, 'SCRATCHPAD_UNKNOWN_ERROR': <StateBlobError.SCRATCHPAD_UNKNOWN_ERROR: 5>}
def __eq__(self, other: typing.Any) -> bool:
...
def __getstate__(self) -> int:
...
def __hash__(self) -> int:
...
def __index__(self) -> int:
...
def __init__(self, value: typing.SupportsInt) -> None:
...
def __int__(self) -> int:
...
def __ne__(self, other: typing.Any) -> bool:
...
def __repr__(self) -> str:
...
def __setstate__(self, state: typing.SupportsInt) -> None:
...
def __str__(self) -> str:
...
@property
def name(self) -> str:
...
@property
def value(self) -> int:
...
ADAPTIVE_ENGINE_VIEW_SCRATCHPAD: ScratchPadType # value = <ScratchPadType.ADAPTIVE_ENGINE_VIEW_SCRATCHPAD: 2>
ALREADY_REGISTERED: ADFunRegistrationResult # value = <ADFunRegistrationResult.ALREADY_REGISTERED: 1>
DEFINED_ENGINE_VIEW_SCRATCHPAD: ScratchPadType # value = <ScratchPadType.DEFINED_ENGINE_VIEW_SCRATCHPAD: 3>
GRAPH_ENGINE_SCRATCHPAD: ScratchPadType # value = <ScratchPadType.GRAPH_ENGINE_SCRATCHPAD: 0>
MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD: ScratchPadType # value = <ScratchPadType.MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD: 1>
SCRATCHPAD_BAD_CAST: StateBlobError # value = <StateBlobError.SCRATCHPAD_BAD_CAST: 1>
SCRATCHPAD_NOT_FOUND: StateBlobError # value = <StateBlobError.SCRATCHPAD_NOT_FOUND: 0>
SCRATCHPAD_NOT_INITIALIZED: StateBlobError # value = <StateBlobError.SCRATCHPAD_NOT_INITIALIZED: 2>
SCRATCHPAD_OUT_OF_BOUNDS: StateBlobError # value = <StateBlobError.SCRATCHPAD_OUT_OF_BOUNDS: 4>
SCRATCHPAD_TYPE_COLLISION: StateBlobError # value = <StateBlobError.SCRATCHPAD_TYPE_COLLISION: 3>
SCRATCHPAD_UNKNOWN_ERROR: StateBlobError # value = <StateBlobError.SCRATCHPAD_UNKNOWN_ERROR: 5>
SUCCESS: ADFunRegistrationResult # value = <ADFunRegistrationResult.SUCCESS: 0>

4
stubs/gridfire/_gridfire/exceptions.pyi
View File

@@ -2,7 +2,7 @@
GridFire exceptions bindings
"""
from __future__ import annotations
__all__: list[str] = ['BadCollectionError', 'BadRHSEngineError', 'CVODESolverFailureError', 'DebugException', 'EngineError', 'FailedToPartitionEngineError', 'GridFireError', 'HashingError', 'IllConditionedJacobianError', 'InvalidQSESolutionError', 'JacobianError', 'KINSolSolverFailureError', 'MissingBaseReactionError', 'MissingKeyReactionError', 'MissingSeedSpeciesError', 'NetworkResizedError', 'PolicyError', 'ReactionError', 'ReactionParsingError', 'SUNDIALSError', 'SingularJacobianError', 'SolverError', 'StaleJacobianError', 'UnableToSetNetworkReactionsError', 'UninitializedJacobianError', 'UnknownJacobianError', 'UtilityError']
__all__: list[str] = ['BadCollectionError', 'BadRHSEngineError', 'CVODESolverFailureError', 'DebugException', 'EngineError', 'FailedToPartitionEngineError', 'GridFireError', 'HashingError', 'IllConditionedJacobianError', 'InvalidQSESolutionError', 'JacobianError', 'KINSolSolverFailureError', 'MissingBaseReactionError', 'MissingKeyReactionError', 'MissingSeedSpeciesError', 'NetworkResizedError', 'PolicyError', 'ReactionError', 'ReactionParsingError', 'SUNDIALSError', 'ScratchPadError', 'SingularJacobianError', 'SolverError', 'StaleJacobianError', 'UnableToSetNetworkReactionsError', 'UninitializedJacobianError', 'UnknownJacobianError', 'UtilityError']
class BadCollectionError(EngineError):
pass
class BadRHSEngineError(EngineError):
@@ -43,6 +43,8 @@ class ReactionParsingError(ReactionError):
pass
class SUNDIALSError(SolverError):
pass
class ScratchPadError(GridFireError):
pass
class SingularJacobianError(SolverError):
pass
class SolverError(GridFireError):

23
stubs/gridfire/_gridfire/policy.pyi
View File

@@ -6,9 +6,11 @@ import collections.abc
import fourdst._phys.atomic
import fourdst._phys.composition
import gridfire._gridfire.engine
import gridfire._gridfire.engine.scratchpads
import gridfire._gridfire.partition
import gridfire._gridfire.reaction
import typing
__all__: list[str] = ['CNOChainPolicy', 'CNOIChainPolicy', 'CNOIIChainPolicy', 'CNOIIIChainPolicy', 'CNOIVChainPolicy', 'HotCNOChainPolicy', 'HotCNOIChainPolicy', 'HotCNOIIChainPolicy', 'HotCNOIIIChainPolicy', 'INITIALIZED_UNVERIFIED', 'INITIALIZED_VERIFIED', 'MISSING_KEY_REACTION', 'MISSING_KEY_SPECIES', 'MainSequencePolicy', 'MainSequenceReactionChainPolicy', 'MultiReactionChainPolicy', 'NetworkPolicy', 'NetworkPolicyStatus', 'ProtonProtonChainPolicy', 'ProtonProtonIChainPolicy', 'ProtonProtonIIChainPolicy', 'ProtonProtonIIIChainPolicy', 'ReactionChainPolicy', 'TemperatureDependentChainPolicy', 'TripleAlphaChainPolicy', 'UNINITIALIZED']
__all__: list[str] = ['CNOChainPolicy', 'CNOIChainPolicy', 'CNOIIChainPolicy', 'CNOIIIChainPolicy', 'CNOIVChainPolicy', 'ConstructionResults', 'HotCNOChainPolicy', 'HotCNOIChainPolicy', 'HotCNOIIChainPolicy', 'HotCNOIIIChainPolicy', 'INITIALIZED_UNVERIFIED', 'INITIALIZED_VERIFIED', 'MISSING_KEY_REACTION', 'MISSING_KEY_SPECIES', 'MainSequencePolicy', 'MainSequenceReactionChainPolicy', 'MultiReactionChainPolicy', 'NetworkPolicy', 'NetworkPolicyStatus', 'ProtonProtonChainPolicy', 'ProtonProtonIChainPolicy', 'ProtonProtonIIChainPolicy', 'ProtonProtonIIIChainPolicy', 'ReactionChainPolicy', 'TemperatureDependentChainPolicy', 'TripleAlphaChainPolicy', 'UNINITIALIZED', 'network_policy_status_to_string']
class CNOChainPolicy(MultiReactionChainPolicy):
def __eq__(self, other: ReactionChainPolicy) -> bool:
"""
@@ -224,6 +226,13 @@ class CNOIVChainPolicy(TemperatureDependentChainPolicy):
"""
Get the name of the reaction chain policy.
"""
class ConstructionResults:
@property
def engine(self) -> gridfire._gridfire.engine.DynamicEngine:
...
@property
def scratch_blob(self) -> gridfire._gridfire.engine.scratchpads.StateBlob:
...
class HotCNOChainPolicy(MultiReactionChainPolicy):
def __eq__(self, other: ReactionChainPolicy) -> bool:
"""
@@ -407,14 +416,18 @@ class MainSequencePolicy(NetworkPolicy):
"""
Construct MainSequencePolicy from seed species and mass fractions.
"""
def construct(self) -> gridfire._gridfire.engine.DynamicEngine:
def construct(self) -> ConstructionResults:
"""
Construct the network according to the policy.
"""
def get_engine_stack(self) -> list[gridfire._gridfire.engine.DynamicEngine]:
...
def get_engine_types_stack(self) -> list[gridfire._gridfire.engine.EngineTypes]:
"""
Get the types of engines in the stack constructed by the network policy.
"""
def get_partition_function(self) -> gridfire._gridfire.partition.PartitionFunction:
...
def get_seed_reactions(self) -> gridfire._gridfire.reaction.ReactionSet:
"""
Get the set of seed reactions required by the network policy.
@@ -423,6 +436,8 @@ class MainSequencePolicy(NetworkPolicy):
"""
Get the set of seed species required by the network policy.
"""
def get_stack_scratch_blob(self) -> gridfire._gridfire.engine.scratchpads.StateBlob:
...
def get_status(self) -> NetworkPolicyStatus:
"""
Get the current status of the network policy.
@@ -743,6 +758,10 @@ class TripleAlphaChainPolicy(TemperatureDependentChainPolicy):
"""
Get the name of the reaction chain policy.
"""
def network_policy_status_to_string(status: NetworkPolicyStatus) -> str:
"""
Convert a NetworkPolicyStatus enum value to its string representation.
"""
INITIALIZED_UNVERIFIED: NetworkPolicyStatus # value = <NetworkPolicyStatus.INITIALIZED_UNVERIFIED: 1>
INITIALIZED_VERIFIED: NetworkPolicyStatus # value = <NetworkPolicyStatus.INITIALIZED_VERIFIED: 4>
MISSING_KEY_REACTION: NetworkPolicyStatus # value = <NetworkPolicyStatus.MISSING_KEY_REACTION: 2>

135
stubs/gridfire/_gridfire/solver.pyi
View File

@@ -5,47 +5,113 @@ from __future__ import annotations
import collections.abc
import fourdst._phys.atomic
import gridfire._gridfire.engine
import gridfire._gridfire.engine.scratchpads
import gridfire._gridfire.type
import types
import typing
__all__: list[str] = ['CVODESolverStrategy', 'CVODETimestepContext', 'DynamicNetworkSolverStrategy', 'SolverContextBase']
class CVODESolverStrategy(DynamicNetworkSolverStrategy):
def __init__(self, engine: gridfire._gridfire.engine.DynamicEngine) -> None:
__all__: list[str] = ['GridSolver', 'GridSolverContext', 'MultiZoneDynamicNetworkSolver', 'PointSolver', 'PointSolverContext', 'PointSolverTimestepContext', 'SingleZoneDynamicNetworkSolver', 'SolverContextBase']
class GridSolver(MultiZoneDynamicNetworkSolver):
def __init__(self, engine: gridfire._gridfire.engine.DynamicEngine, solver: SingleZoneDynamicNetworkSolver) -> None:
"""
Initialize the CVODESolverStrategy object.
Initialize the GridSolver object.
"""
def evaluate(self, netIn: gridfire._gridfire.type.NetIn, display_trigger: bool = False) -> gridfire._gridfire.type.NetOut:
def evaluate(self, solver_ctx: SolverContextBase, netIns: collections.abc.Sequence[gridfire._gridfire.type.NetIn]) -> list[gridfire._gridfire.type.NetOut]:
"""
evaluate the dynamic engine using the dynamic engine class
"""
def get_absTol(self) -> float:
class GridSolverContext(SolverContextBase):
detailed_logging: bool
stdout_logging: bool
zone_completion_logging: bool
def __init__(self, ctx_template: gridfire._gridfire.engine.scratchpads.StateBlob) -> None:
...
@typing.overload
def clear_callback(self) -> None:
...
@typing.overload
def clear_callback(self, zone_idx: typing.SupportsInt) -> None:
...
def init(self) -> None:
...
def reset(self) -> None:
...
@typing.overload
def set_callback(self, callback: collections.abc.Callable[[...], None]) -> None:
...
@typing.overload
def set_callback(self, callback: collections.abc.Callable[[...], None], zone_idx: typing.SupportsInt) -> None:
...
class MultiZoneDynamicNetworkSolver:
def evaluate(self, solver_ctx: SolverContextBase, netIns: collections.abc.Sequence[gridfire._gridfire.type.NetIn]) -> list[gridfire._gridfire.type.NetOut]:
"""
Get the absolute tolerance for the CVODE solver.
evaluate the dynamic engine using the dynamic engine class for multiple zones (using openmp if available)
"""
def get_relTol(self) -> float:
class PointSolver(SingleZoneDynamicNetworkSolver):
def __init__(self, engine: gridfire._gridfire.engine.DynamicEngine) -> None:
"""
Get the relative tolerance for the CVODE solver.
Initialize the PointSolver object.
"""
def get_stdout_logging_enabled(self) -> bool:
def evaluate(self, solver_ctx: SolverContextBase, netIn: gridfire._gridfire.type.NetIn, display_trigger: bool = False, force_reinitialization: bool = False) -> gridfire._gridfire.type.NetOut:
"""
Check if solver logging to standard output is enabled.
evaluate the dynamic engine using the dynamic engine class
"""
def set_absTol(self, absTol: typing.SupportsFloat) -> None:
"""
Set the absolute tolerance for the CVODE solver.
"""
def set_callback(self, cb: collections.abc.Callable[[CVODETimestepContext], None]) -> None:
"""
Set a callback function which will run at the end of every successful timestep
"""
def set_relTol(self, relTol: typing.SupportsFloat) -> None:
"""
Set the relative tolerance for the CVODE solver.
"""
def set_stdout_logging_enabled(self, logging_enabled: bool) -> None:
"""
Enable logging to standard output.
"""
class CVODETimestepContext(SolverContextBase):
class PointSolverContext:
callback: collections.abc.Callable[[PointSolverTimestepContext], None] | None
detailed_logging: bool
stdout_logging: bool
def __init__(self, engine_ctx: gridfire._gridfire.engine.scratchpads.StateBlob) -> None:
...
def clear_context(self) -> None:
...
def has_context(self) -> bool:
...
def init(self) -> None:
...
def init_context(self) -> None:
...
def reset_all(self) -> None:
...
def reset_cvode(self) -> None:
...
def reset_user(self) -> None:
...
@property
def J(self) -> _generic_SUNMatrix:
...
@property
def LS(self) -> _generic_SUNLinearSolver:
...
@property
def Y(self) -> _generic_N_Vector:
...
@property
def YErr(self) -> _generic_N_Vector:
...
@property
def abs_tol(self) -> float:
...
@abs_tol.setter
def abs_tol(self, arg1: typing.SupportsFloat) -> None:
...
@property
def cvode_mem(self) -> types.CapsuleType:
...
@property
def engine_ctx(self) -> gridfire._gridfire.engine.scratchpads.StateBlob:
...
@property
def num_steps(self) -> int:
...
@property
def rel_tol(self) -> float:
...
@rel_tol.setter
def rel_tol(self, arg1: typing.SupportsFloat) -> None:
...
@property
def sun_ctx(self) -> SUNContext_:
...
class PointSolverTimestepContext:
@property
def T9(self) -> float:
...
@@ -77,16 +143,15 @@ class CVODETimestepContext(SolverContextBase):
def state(self) -> list[float]:
...
@property
def state_ctx(self) -> gridfire._gridfire.engine.scratchpads.StateBlob:
...
@property
def t(self) -> float:
...
class DynamicNetworkSolverStrategy:
def describe_callback_context(self) -> list[tuple[str, str]]:
class SingleZoneDynamicNetworkSolver:
def evaluate(self, solver_ctx: SolverContextBase, netIn: gridfire._gridfire.type.NetIn) -> gridfire._gridfire.type.NetOut:
"""
Get a structure representing what data is in the callback context in a human readable format
"""
def evaluate(self, netIn: gridfire._gridfire.type.NetIn) -> gridfire._gridfire.type.NetOut:
"""
evaluate the dynamic engine using the dynamic engine class
evaluate the dynamic engine using the dynamic engine class for a single zone
"""
class SolverContextBase:
pass

6
stubs/gridfire/_gridfire/type.pyi
View File

@@ -59,3 +59,9 @@ class NetOut:
@property
def num_steps(self) -> int:
...
@property
def specific_neutrino_energy_loss(self) -> float:
...
@property
def specific_neutrino_flux(self) -> float:
...

3
stubs/gridfire/_gridfire/utils/__init__.pyi
View File

@@ -4,10 +4,11 @@ GridFire utility method bindings
from __future__ import annotations
import fourdst._phys.composition
import gridfire._gridfire.engine
import gridfire._gridfire.engine.scratchpads
import typing
from . import hashing
__all__: list[str] = ['formatNuclearTimescaleLogString', 'hash_atomic', 'hash_reaction', 'hashing']
def formatNuclearTimescaleLogString(engine: gridfire._gridfire.engine.DynamicEngine, Y: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> str:
def formatNuclearTimescaleLogString(ctx: gridfire._gridfire.engine.scratchpads.StateBlob, engine: gridfire._gridfire.engine.DynamicEngine, Y: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> str:
"""
Format a string for logging nuclear timescales based on temperature, density, and energy generation rate.
"""