simjsr 0.0.2__tar.gz → 0.0.4__tar.gz

{simjsr-0.0.2 → simjsr-0.0.4}/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.3
 Name: simjsr
-Version: 0.0.2
+Version: 0.0.4
 Author: Andreas V. Copan
 Author-email: Andreas V. Copan <avcopan@uga.edu>
 Requires-Dist: cantera>=3.2.0
+Requires-Dist: func-timeout>=4.3.5
 Requires-Dist: polars>=1.41.2
 Requires-Dist: pydantic>=2.13.4
 Requires-Dist: pyyaml>=6.0.3

{simjsr-0.0.2 → simjsr-0.0.4}/pyproject.toml

@@ -1,10 +1,11 @@
 [project]
 name = "simjsr"
-version = "0.0.2"
+version = "0.0.4"
 authors = [{name = "Andreas V. Copan", email = "avcopan@uga.edu"}]
 requires-python = ">= 3.13"
 dependencies = [
     "cantera>=3.2.0",
+    "func-timeout>=4.3.5",
     "polars>=1.41.2",
     "pydantic>=2.13.4",
     "pyyaml>=6.0.3",

{simjsr-0.0.2 → simjsr-0.0.4}/src/simjsr/__init__.py

@@ -1,6 +1,6 @@
 """simrun."""
 
-__version__ = "0.0.2"
+__version__ = "0.0.4"
 
 from . import config, convert, run
 from .config import Config

{simjsr-0.0.2 → simjsr-0.0.4}/src/simjsr/cli.py

@@ -48,11 +48,8 @@ def run(
     ] = False,
 ) -> None:
     """Run a JSR simulation workflow."""
-    typer.echo("Loading config file\n")
-    configs = Config.multi_from_yaml(file=config_file)
-
     multi(
-        configs,
+        config_file,
         pass_state=not no_pass_state,
         output_file=Path(output_file),
         logger=typer.echo,
@@ -118,9 +115,9 @@ def example(
     if multi_composition:
         composition_file = dir_path / File.composition
         data = {
-            "CH4": [0.05, 0.1, 0.15],
-            "O2": [0.21, 0.21, 0.21],
-            "N2": [0.74, 0.59, 0.44],
+            "CH4": [0.05, 0.05, 0.05],
+            "O2": [0.21, 0.22, 0.23],
+            "N2": [0.74, 0.73, 0.72],
         }
         pl.DataFrame(data).write_csv(composition_file)
         update[Key.composition] = File.composition

{simjsr-0.0.2 → simjsr-0.0.4}/src/simjsr/config.py

@@ -1,7 +1,7 @@
 """Configuration for simulations."""
 
 from pathlib import Path
-from typing import Any
+from typing import Any, Self
 
 import polars as pl
 import yaml
@@ -33,7 +33,7 @@ class Config(BaseModel):
         description="Starting composition (mole fractions)"
     )
     volume: float = Field(description="Reactor volume (cm^3)", default=1.0)
-    time_out: int | None = Field(
+    time_out: float | None = Field(
         description="Time limit for the simulation (s)", default=None
     )
     chemkin_file: Path | None = Field(
@@ -101,19 +101,21 @@ class Config(BaseModel):
     @classmethod
     def from_yaml(
         cls, *, file: str | Path | None = None, text: str | Path | None = None
-    ) -> "Config":
+    ) -> Self:
         """Instantiate from YAML file or text."""
-        config, *extra_configs = cls.multi_from_yaml(file=file, text=text)
+        (config, *extra_configs), _ = cls.all_with_dataframe_from_yaml(
+            file=file, text=text
+        )
         if extra_configs:
             msg = f"Cannot read config from multi-config YAML. {extra_configs = }"
             raise ValueError(msg)
         return config
 
     @classmethod
-    def multi_from_yaml(
+    def all_with_dataframe_from_yaml(
         cls, *, file: str | Path | None = None, text: str | Path | None = None
-    ) -> "list[Config]":
-        """Instantiate multiple configs from YAML file or text."""
+    ) -> tuple[list[Self], pl.DataFrame | None]:
+        """Instantiate  from YAML file or text and return as a DataFrame."""
         if file is not None:
             text = Path(file).read_text()
 
@@ -122,8 +124,6 @@ class Config(BaseModel):
             raise ValueError(msg)
 
         data = yaml.safe_load(text)
-
-        datas = [data]
         temperature = data.get(Key.temperature)
         composition = data.get(Key.composition)
 
@@ -131,32 +131,18 @@ class Config(BaseModel):
             msg = f"{temperature = } and {composition = } cannot both be file paths."
             raise TypeError(msg)
 
+        df = None
+        datas = [data]
         if isinstance(temperature, str):
-            ts = _load_temperatures_from_file(temperature)
-            datas = [{**data, "temperature": t} for t in ts]
+            df = pl.read_csv(temperature)
+            datas = [{**data, Key.temperature: t} for t in df[:, 0]]
 
         if isinstance(composition, str):
-            cs = _load_compositions_from_file(composition)
-            datas = [{**data, "composition": c} for c in cs]
-
-        return [cls.model_validate(d) for d in datas]
-
-
-def _to_yaml_serialized_value(value: object) -> str:
-    """Serialize a value to a YAML string."""
-    return yaml.safe_dump(value, default_flow_style=True).splitlines()[0]
-
-
-def _load_temperatures_from_file(temps_file: Path | str) -> list[float]:
-    """Load temperatures (K) from a CSV file with a 'temperature' column."""
-    df = pl.read_csv(temps_file)
-    return df.get_column(df.columns[0]).cast(pl.Float64).to_list()
+            df = pl.read_csv(composition)
+            datas = [{**data, Key.composition: c} for c in df.iter_rows(named=True)]
 
-
-def _load_compositions_from_file(comps_file: Path | str) -> list[dict[str, float]]:
-    """Load compositions from a YAML file with a 'compositions' key."""
-    df = pl.read_csv(comps_file)
-    return df.to_dicts()
+        configs = [cls.model_validate(d) for d in datas]
+        return configs, df
 
 
 class Key:
@@ -164,3 +150,9 @@ class Key:
 
     temperature = "temperature"
     composition = "composition"
+
+
+# Helpers
+def _to_yaml_serialized_value(value: object) -> str:
+    """Serialize a value to a YAML string."""
+    return yaml.safe_dump(value, default_flow_style=True).splitlines()[0]

simjsr-0.0.4/src/simjsr/run.py

@@ -0,0 +1,221 @@
+"""Reactors."""
+
+import textwrap
+from collections.abc import Callable, Sequence
+from copy import replace
+from datetime import UTC, datetime, timedelta
+from pathlib import Path
+from time import perf_counter
+from typing import Any, TypeGuard
+
+import cantera as ct
+import polars as pl
+from func_timeout import FunctionTimedOut, func_timeout
+
+from . import convert
+from .config import Config
+
+Logger = Callable[[str], Any]
+
+
+def multi(
+    config_: Sequence[Config] | Path | str,
+    *,
+    pass_state: bool = True,
+    output_file: Path | None = None,
+    logger: Logger = lambda _: None,
+) -> list[dict[str, float]]:
+    """Run multiple jet-stirred reactor simulations.
+
+    Args:
+        config_: Configurations for the simulations
+        pass_state: Whether to pass solved state to the next simulation, if its
+            initial composition is the same
+        logger: Optional logger for messages
+        output_file: Optional file to save simulation results
+
+    Returns:
+        Steady state mole fractions for each simulation
+    """
+    df = None
+    if isinstance(config_, Sequence) and not isinstance(config_, str):
+        configs = config_
+    else:
+        logger("Loading config file")
+
+        configs, df = Config.all_with_dataframe_from_yaml(file=config_)
+
+    if not is_sequence_of(configs, Config):
+        msg = "All configurations must be of type Config"
+        raise TypeError(msg)
+
+    config_count = len(configs)
+    last_config = last_mole_fracs = None
+    mole_fracs_lst = []
+    for num, init_config in enumerate(configs, start=1):
+        yaml_text = init_config.yaml_text(describe=True)
+        logger(f"Run {num} / {config_count}:")
+        logger(textwrap.indent(yaml_text.strip(), "  "))
+
+        # If requested, re-use solved composition
+        config = init_config
+        if (
+            pass_state
+            and init_config.is_compatible_with(last_config)
+            and last_mole_fracs is not None
+        ):
+            config = replace(init_config, composition=last_mole_fracs)
+
+        mole_fracs = single(config=config, logger=logger, raise_on_timout=False)
+        mole_fracs_lst.append(mole_fracs)
+
+        last_config = init_config
+        last_mole_fracs = mole_fracs
+
+        logger("")
+
+    if output_file is not None:
+        df_out = pl.from_dicts(mole_fracs_lst)
+        if df is not None:
+            df_out = hconcat_rename_left(df, df_out, suffix="_init")
+
+        df_out.write_csv(output_file)
+
+    return mole_fracs_lst
+
+
+def single(
+    config: Config | Path | str,
+    *,
+    logger: Logger = lambda _: None,
+    output_file: Path | None = None,
+    raise_on_timout: bool = True,
+) -> dict[str, float]:
+    """Run a single jet-stirred reactor simulation.
+
+    Args:
+        config: Configuration for the simulation
+        logger: Optional logger for messages
+        output_file: Optional file to save simulation results
+        raise_on_timout: Whether to raise a TimeoutError if the simulation times out
+
+    Returns:
+        Steady state mole fractions
+
+    Raises:
+        TimeoutError: If the simulation exceeds the configured time limit
+    """
+    start_counter = clock_start(logger, "Starting simulation")
+
+    config = config if isinstance(config, Config) else Config.from_yaml(file=config)
+
+    if not config.cantera_file.exists():
+        generate_cantera_file_from_chemkin(config, logger=logger)
+
+    phase = ct.Solution(config.cantera_file)
+
+    try:
+        mole_fracs = (
+            _single(config)
+            if config.time_out is None
+            else func_timeout(config.time_out, _single, (config,))
+        )
+    except FunctionTimedOut:
+        clock_end(logger, "Simulation timed out", start_counter)
+        mole_fracs = {s: float("nan") for s in phase.species_names}
+        if raise_on_timout:
+            raise
+    else:
+        clock_end(logger, "Finished simulation", start_counter)
+
+    if output_file is not None:
+        pl.from_dicts([mole_fracs]).write_csv(output_file)
+
+    return mole_fracs
+
+
+def _single(config: Config) -> dict[str, float]:
+    """Run a single jet-stirred reactor simulation (no timeout handling or logging).
+
+    Args:
+        config: Configuration for the simulation
+
+    Returns:
+        Steady state mole fractions
+    """
+    phase = ct.Solution(config.cantera_file)
+
+    # Use composition from the previous iteration to speed up convergence
+    phase.TPX = config.temperature, config.pressure * ct.one_atm, config.composition
+
+    # Set up JSR: inlet -> flow control -> reactor -> pressure control -> exhaust
+    volume_m3 = config.volume * (1e-2) ** 3
+    reactor = ct.IdealGasReactor(phase, energy="off", volume=volume_m3, clone=True)
+    exhaust = ct.Reservoir(phase, clone=True)
+    inlet = ct.Reservoir(phase, clone=True)
+    ct.PressureController(
+        upstream=reactor,
+        downstream=exhaust,
+        K=1e-3,
+        primary=ct.MassFlowController(
+            upstream=inlet,
+            downstream=reactor,
+            mdot=reactor.mass / config.residence_time,
+        ),
+    )
+    reactor_net = ct.ReactorNet([reactor])
+    reactor_net.advance_to_steady_state(max_steps=100000)
+    return reactor.phase.mole_fraction_dict()
+
+
+# Helpers
+def generate_cantera_file_from_chemkin(
+    config: Config, *, logger: Logger = lambda _: None
+) -> None:
+    """Ensure the Cantera file is available."""
+    if config.chemkin_file is None:
+        msg = "chemkin_file must be provided if cantera_file does not exist."
+        raise ValueError(msg)
+
+    if not config.chemkin_file.exists():
+        msg = f"{config.chemkin_file = } does not exist."
+        raise ValueError(msg)
+
+    logger(f"Converting {config.chemkin_file} to Cantera format")
+
+    convert.from_chemkin(
+        chemkin_file=config.chemkin_file,
+        chemkin_thermo_file=config.chemkin_thermo_file,
+        cantera_file=config.cantera_file,
+    )
+
+
+def clock_start(logger: Logger, event: str) -> float:
+    """Log the start time of an event."""
+    start_time = datetime.now(tz=UTC)
+    logger(f"{event} at {start_time:%Y-%m-%d %H:%M:%S}")
+    return perf_counter()
+
+
+def clock_end(logger: Logger, event: str, start_counter: float) -> None:
+    """Log the start time of a simulation."""
+    end_time = datetime.now(tz=UTC)
+    elapsed = timedelta(seconds=perf_counter() - start_counter)
+    logger(f"{event} at {end_time:%Y-%m-%d %H:%M:%S}")
+    logger(f"Elapsed time: {elapsed}")
+
+
+def is_sequence_of[T](seq: Sequence[object], typ: type[T]) -> TypeGuard[Sequence[T]]:
+    """Check the types of the elements in a sequence."""
+    return all(isinstance(x, typ) for x in seq)
+
+
+def hconcat_rename_left(
+    df1: pl.DataFrame, df2: pl.DataFrame, suffix: str = "_left"
+) -> pl.DataFrame:
+    """Horizontally concatenate dataframes, renaming the left dataframe columns."""
+    clashes = set(df1.columns) & set(df2.columns)
+
+    df1 = df1.rename({col: f"{col}{suffix}" for col in clashes})
+
+    return pl.concat([df1, df2], how="horizontal")

simjsr-0.0.2/src/simjsr/run.py

@@ -1,211 +0,0 @@
-"""Reactors."""
-
-import signal
-import textwrap
-from collections.abc import Callable, Mapping, Sequence
-from copy import replace
-from datetime import UTC, datetime, timedelta
-from pathlib import Path
-from time import perf_counter
-from typing import Any
-
-import cantera as ct
-import polars as pl
-
-from . import convert
-from .config import Config
-
-Logger = Callable[[str], Any]
-
-
-def single(
-    config: Config, *, logger: Logger | None = None, output_file: Path | None = None
-) -> dict[str, float]:
-    """Run a single jet-stirred reactor simulation.
-
-    Args:
-        config: Configuration for the simulation
-        logger: Optional logger for messages
-        output_file: Optional file to save simulation results
-
-    Returns:
-        Steady state mole fractions
-
-    Raises:
-        TimeoutError: If the simulation exceeds the configured time limit
-    """
-    # Set up a timeout handler to prevent simulations from running indefinitely
-    if config.time_out is not None:
-        signal.signal(signal.SIGALRM, _timeout_handler)
-        signal.alarm(config.time_out)
-
-    if logger is not None:
-        start_time = datetime.now(tz=UTC)
-        start_counter = perf_counter()
-        logger(f"Starting simulation at {start_time:%Y-%m-%d %H:%M:%S}")
-
-    if not config.cantera_file.exists():
-        if config.chemkin_file is None:
-            msg = "chemkin_file must be provided if cantera_file does not exist."
-            raise ValueError(msg)
-
-        if not config.chemkin_file.exists():
-            msg = f"{config.chemkin_file = } does not exist."
-            raise ValueError(msg)
-
-        if logger is not None:
-            logger(
-                f"Converting {config.chemkin_file} to Cantera format "
-                f"({config.cantera_file})"
-            )
-
-        convert.from_chemkin(
-            chemkin_file=config.chemkin_file,
-            chemkin_thermo_file=config.chemkin_thermo_file,
-            cantera_file=config.cantera_file,
-        )
-
-    try:
-        mole_fracs = _single(config=config)
-    finally:
-        signal.alarm(0)
-
-    if logger is not None:
-        end_time = datetime.now(tz=UTC)
-        end_counter = perf_counter()
-        elapsed = timedelta(seconds=end_counter - start_counter)
-        logger(f"Finished simulation at {end_time:%Y-%m-%d %H:%M:%S}")
-        logger(f"Elapsed time: {elapsed}")
-
-    if output_file is not None:
-        pl.from_dicts([mole_fracs]).write_csv(output_file)
-
-    return mole_fracs
-
-
-def multi(
-    configs: Sequence[Config],
-    *,
-    pass_state: bool = True,
-    output_file: Path | None = None,
-    logger: Logger | None = None,
-) -> list[dict[str, float]]:
-    """Run multiple jet-stirred reactor simulations.
-
-    Args:
-        configs: Configurations for the simulations
-        pass_state: Whether to pass solved state to the next simulation, if its
-            initial composition is the same
-        logger: Optional logger for messages
-        output_file: Optional file to save simulation results
-
-    Returns:
-        Steady state mole fractions for each simulation
-    """
-    config_count = len(configs)
-    last_config = last_mole_fracs = None
-    mole_fracs_lst = []
-    for num, init_config in enumerate(configs, start=1):
-        if logger is not None:
-            yaml_text = init_config.yaml_text(describe=True)
-            logger(f"Run {num} / {config_count}:")
-            logger(textwrap.indent(yaml_text.strip(), "  "))
-
-        # If requested, re-use solved composition
-        config = init_config
-        if (
-            pass_state
-            and init_config.is_compatible_with(last_config)
-            and last_mole_fracs is not None
-        ):
-            config = replace(init_config, composition=last_mole_fracs)
-
-        mole_fracs = single(config=config, logger=logger)
-        mole_fracs_lst.append(mole_fracs)
-
-        last_config = init_config
-        last_mole_fracs = mole_fracs
-
-        if logger is not None and num < config_count:
-            logger("")
-
-    if output_file is not None:
-        pl.from_dicts(mole_fracs_lst).write_csv(output_file)
-
-    return mole_fracs_lst
-
-
-def multi_temperature(
-    config: Config, temperatures: Sequence[float], *, logger: Logger | None = None
-) -> list[dict[str, float]]:
-    """Run multiple jet-stirred reactor simulations at different temperatures.
-
-    Args:
-        config: Base configuration for the simulations
-        temperatures: List of temperatures (K)
-        logger: Optional logger for messages
-
-    Returns:
-        Steady state mole fractions for each simulation
-    """
-    configs = [replace(config, temperature=t) for t in temperatures]
-    return multi(configs, logger=logger)
-
-
-def multi_composition(
-    config: Config,
-    compositions: Sequence[Mapping[str, float]],
-    *,
-    logger: Logger | None = None,
-) -> list[dict[str, float]]:
-    """Run multiple jet-stirred reactor simulations at different compositions.
-
-    Args:
-        config: Base configuration for the simulations
-        compositions: List of compositions (mole fractions)
-        logger: Optional logger for messages
-
-    Returns:
-        Steady state mole fractions for each simulation
-    """
-    configs = [replace(config, composition=comp) for comp in compositions]
-    return multi(configs, logger=logger)
-
-
-def _single(config: Config) -> dict[str, float]:
-    """Run a single jet-stirred reactor simulation (no timeout handling or logging).
-
-    Args:
-        config: Configuration for the simulation
-
-    Returns:
-        Steady state mole fractions
-    """
-    phase = ct.Solution(config.cantera_file)
-
-    # Use composition from the previous iteration to speed up convergence
-    phase.TPX = config.temperature, config.pressure * ct.one_atm, config.composition
-
-    # Set up JSR: inlet -> flow control -> reactor -> pressure control -> exhaust
-    volume_m3 = config.volume * (1e-2) ** 3
-    reactor = ct.IdealGasReactor(phase, energy="off", volume=volume_m3, clone=True)
-    exhaust = ct.Reservoir(phase, clone=True)
-    inlet = ct.Reservoir(phase, clone=True)
-    ct.PressureController(
-        upstream=reactor,
-        downstream=exhaust,
-        K=1e-3,
-        primary=ct.MassFlowController(
-            upstream=inlet,
-            downstream=reactor,
-            mdot=reactor.mass / config.residence_time,
-        ),
-    )
-    reactor_net = ct.ReactorNet([reactor])
-    reactor_net.advance_to_steady_state(max_steps=100000)
-    return reactor.phase.mole_fraction_dict()
-
-
-def _timeout_handler(_signum: int, _frame: object) -> None:
-    msg = "The simulation exceeded the configured time limit."
-    raise TimeoutError(msg)