CITATION.cff

@@ -9,7 +9,7 @@ authors:
     affiliation: "German Aerospace Center (DLR)"
     address: "Linder Höhe"
     city: Köln
-version: v1.1.3
+version: v1.1.2
 date-released: "2025-06-24"
 #identifiers:
 #  - description: This is the collection of archived snapshots of all versions of Gaspype

docs/source/conf.py

@@ -10,7 +10,7 @@ import os
 import sys
 sys.path.insert(0, os.path.abspath("../src/"))
 
-project = 'Gaspype'
+project = 'gaspype'
 copyright = '2025, Nicolas Kruse'
 author = 'Nicolas Kruse'
 

examples/soec_syngas.md

@@ -24,7 +24,7 @@ p = 1e5  # Pa
 fs = gp.fluid_system('H2, H2O, O2, CH4, CO, CO2')
 feed_fuel = gp.fluid({'H2O': 2, 'CO2': 1}, fs)
 
-o2_full_conv = np.sum(gp.elements(feed_fuel).get_n(['C' ,'O']) * [-1/2, 1/2])
+o2_full_conv = np.sum(gp.elements(feed_fuel)[['C' ,'O']] * [-1/2, 1/2])
 
 feed_air = gp.fluid({'O2': 1, 'N2': 4}) * o2_full_conv * utilization * air_dilution
 

examples/sofc_methane.md

@@ -25,7 +25,7 @@ p = 1e5  # Pa
 fs = gp.fluid_system('H2, H2O, O2, CH4, CO, CO2')
 feed_fuel = gp.fluid({'CH4': 1, 'H2O': 0.1}, fs)
 
-o2_full_conv = np.sum(gp.elements(feed_fuel).get_n(['H', 'C' ,'O']) * [1/4, 1, -1/2])
+o2_full_conv = np.sum(gp.elements(feed_fuel)[['H', 'C' ,'O']] * [1/4, 1, -1/2])
 
 feed_air = gp.fluid({'O2': 1, 'N2': 4}) * o2_full_conv * fuel_utilization / air_utilization
 

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "gaspype"
-version = "1.1.3"
+version = "1.1.2"
 authors = [
   { name="Nicolas Kruse", email="nicolas.kruse@dlr.de" },
 ]
@@ -18,10 +18,9 @@ dependencies = [
 ]
 
 [project.urls]
-Homepage = "https://dlr-institute-of-future-fuels.github.io/gaspype/"
+Homepage = "https://github.com/DLR-Institute-of-Future-Fuels/gaspype"
-documentation = "https://dlr-institute-of-future-fuels.github.io/gaspype/api/"
-Repository = "https://github.com/DLR-Institute-of-Future-Fuels/gaspype.git"
 Issues = "https://github.com/DLR-Institute-of-Future-Fuels/gaspype/issues"
+documentation = "https://dlr-institute-of-future-fuels.github.io/gaspype/"
 
 [build-system]
 requires = ["setuptools>=61.0", "wheel"]

src/gaspype/_main.py

@@ -7,7 +7,7 @@ from gaspype._phys_data import atomic_weights, db_reader
 import re
 import pkgutil
 from .constants import R, epsy, p0
-from .typing import FloatArray, NDFloat, Shape, ArrayIndices
+from .typing import FloatArray, NDFloat, Shape
 
 T = TypeVar('T', 'fluid', 'elements')
 
@@ -483,28 +483,6 @@ class fluid:
             assert set(species) <= set(self.fs.species), f'Species {", ".join([s for s in species if s not in self.fs.species])} is/are not part of the fluid system'
             return self.array_fractions[..., [self.fs.species.index(k) for k in species]]
 
-    def get_n(self, species: str | list[str] | None = None) -> FloatArray:
-        """Get molar amount of fluid species
-
-        Args:
-            species: A single species name, a list of species names or None for
-                returning the amount of all species
-
-        Returns:
-            Returns an array of floats with the molar amount of the species.
-            If the a single species name is provided the return float array has
-            the same dimensions as the fluid type. If a list or None is provided
-            the return array has an additional dimension for the species.
-        """
-        if not species:
-            return self.array_composition
-        elif isinstance(species, str):
-            assert species in self.fs.species, f'Species {species} is not part of the fluid system'
-            return self.array_composition[..., self.fs.species.index(species)]
-        else:
-            assert set(species) <= set(self.fs.species), f'Species {", ".join([s for s in species if s not in self.fs.species])} is/are not part of the fluid system'
-            return self.array_composition[..., [self.fs.species.index(k) for k in species]]
-
     def __add__(self, other: T) -> T:
         return array_operation(self, other, np.add)
 
@@ -532,21 +510,16 @@ class fluid:
     # def __array__(self) -> FloatArray:
     #     return self.array_composition
 
-    @overload
+    def __getitem__(self, key: str | int | list[str] | list[int] | slice) -> FloatArray:
-    def __getitem__(self, key: str) -> FloatArray:
-        pass
-
-    @overload
-    def __getitem__(self, key: ArrayIndices) -> 'fluid':
-        pass
-
-    def __getitem__(self, key: str | ArrayIndices) -> Any:
         if isinstance(key, str):
             assert key in self.fs.species, f'Species {key} is not part of the fluid system'
             return self.array_composition[..., self.fs.species.index(key)]
+        elif isinstance(key, (slice, int)):
+            return self.array_composition[..., key]
         else:
-            key_tuple = key if isinstance(key, tuple) else (key,)
+            mset = set(self.fs.species) | set(range(len(self.fs.species)))
-            return fluid(self.array_composition[(*key_tuple, slice(None))], self.fs)
+            assert set(key) <= mset, f'Species {", ".join([str(s) for s in key if s not in mset])} is/are not part of the fluid system'
+            return self.array_composition[..., [self.fs.species.index(k) if isinstance(k, str) else k for k in key]]
 
     def __iter__(self) -> Iterator[dict[str, float]]:
         assert len(self.shape) < 2, 'Cannot iterate over species with more than one dimension'
@@ -641,28 +614,6 @@ class elements:
         """
         return np.sum(self.array_elemental_composition * self.fs.array_atomic_mass, axis=-1, dtype=NDFloat)
 
-    def get_n(self, elemental_species: str | list[str] | None = None) -> FloatArray:
-        """Get molar amount of elements
-
-        Args:
-            elemental_species: A single element name, a list of element names or None for
-                returning the amount of all element
-
-        Returns:
-            Returns an array of floats with the molar amount of the elements.
-            If the a single element name is provided the return float array has
-            the same dimensions as the fluid type. If a list or None is provided
-            the return array has an additional dimension for the elements.
-        """
-        if not elemental_species:
-            return self.array_elemental_composition
-        elif isinstance(elemental_species, str):
-            assert elemental_species in self.fs.elements, f'Element {elemental_species} is not part of the fluid system'
-            return self.array_elemental_composition[..., self.fs.elements.index(elemental_species)]
-        else:
-            assert set(elemental_species) <= set(self.fs.elements), f'Elements {", ".join([s for s in elemental_species if s not in self.fs.elements])} is/are not part of the fluid system'
-            return self.array_elemental_composition[..., [self.fs.elements.index(k) for k in elemental_species]]
-
     def __add__(self, other: 'fluid | elements') -> 'elements':
         return array_operation(self, other, np.add)
 
@@ -688,21 +639,16 @@ class elements:
     def __array__(self) -> FloatArray:
         return self.array_elemental_composition
 
-    @overload
+    def __getitem__(self, key: str | int | list[str] | list[int] | slice) -> FloatArray:
-    def __getitem__(self, key: str) -> FloatArray:
-        pass
-
-    @overload
-    def __getitem__(self, key: ArrayIndices) -> 'elements':
-        pass
-
-    def __getitem__(self, key: str | ArrayIndices) -> Any:
         if isinstance(key, str):
             assert key in self.fs.elements, f'Element {key} is not part of the fluid system'
             return self.array_elemental_composition[..., self.fs.elements.index(key)]
+        elif isinstance(key, (slice, int)):
+            return self.array_elemental_composition[..., key]
         else:
-            key_tuple = key if isinstance(key, tuple) else (key,)
+            mset = set(self.fs.elements) | set(range(len(self.fs.elements)))
-            return elements(self.array_elemental_composition[(*key_tuple, slice(None))], self.fs)
+            assert set(key) <= mset, f'Elements {", ".join([str(s) for s in key if s not in mset])} is/are not part of the fluid system'
+            return self.array_elemental_composition[..., [self.fs.elements.index(k) if isinstance(k, str) else k for k in key]]
 
     def __iter__(self) -> Iterator[dict[str, float]]:
         assert len(self.shape) < 2, 'Cannot iterate over elements with more than one dimension'

src/gaspype/typing.py

@@ -1,10 +1,6 @@
 from numpy import float64
 from numpy.typing import NDArray
-from typing import Sequence
-from types import EllipsisType
 
 Shape = tuple[int, ...]
 NDFloat = float64
 FloatArray = NDArray[NDFloat]
-ArrayIndex = int | slice | None | EllipsisType | Sequence[int]
-ArrayIndices = ArrayIndex | tuple[ArrayIndex, ...]

tests/benchmark_cp.py

@@ -1,42 +0,0 @@
-import cantera as ct
-import numpy as np
-import time
-import gaspype as gp
-
-gas = ct.Solution("gri30.yaml")
-composition = {"H2": 0.3, "H2O": 0.3, "N2": 0.4}
-
-n_species = gas.n_species
-n_states = 1_000_000
-
-# Random temperatures and pressures
-temperatures = np.linspace(300.0, 2500.0, n_states)
-pressures = np.full(n_states, ct.one_atm)
-
-# Create a SolutionArray with many states at once
-states = ct.SolutionArray(gas, len(temperatures))
-
-time.sleep(0.5)
-
-# Vectorized assignment
-t0 = time.perf_counter()
-states.TPX = temperatures, pressures, composition
-cp_values = states.cp_mole
-elapsed = time.perf_counter() - t0
-
-print(f"Computed {n_states} Cp values in {elapsed:.4f} seconds (vectorized cantera)")
-print("First 5 Cp values (J/mol-K):", cp_values[:5] / 1000)
-
-
-# Vectorized fluid creation
-fluid = gp.fluid(composition)
-
-time.sleep(0.5)
-
-# Benchmark: calculate Cp for all states at once
-t0 = time.perf_counter()
-cp_values = fluid.get_cp(t=temperatures)
-elapsed = time.perf_counter() - t0
-
-print(f"Computed {n_states} Cp values in {elapsed:.4f} seconds (vectorized Gaspype)")
-print("First 5 Cp values (J/mol·K):", cp_values[:5])

tests/benchmark_cp_comp.py

@@ -1,55 +0,0 @@
-import cantera as ct
-import numpy as np
-import time
-import gaspype as gp
-
-gas = ct.Solution("gri30.yaml")
-n_species = gas.n_species
-n_states = 1_000_000
-
-# Random temperatures and pressures
-temperatures = np.linspace(300.0, 2500.0, n_states)
-pressures = np.full(n_states, ct.one_atm)
-
-# Generate random compositions for H2, H2O, N2
-rng = np.random.default_rng(seed=42)
-fractions = rng.random((n_states, 3))
-fractions /= fractions.sum(axis=1)[:, None]  # normalize
-
-# Convert to full 53-species mole fraction array
-X = np.zeros((n_states, n_species))
-X[:, gas.species_index('H2')] = fractions[:, 0]
-X[:, gas.species_index('H2O')] = fractions[:, 1]
-X[:, gas.species_index('N2')] = fractions[:, 2]
-
-# Build SolutionArray
-states = ct.SolutionArray(gas, n_states)
-
-time.sleep(0.5)
-
-# Vectorized assignment
-t0 = time.perf_counter()
-states.TPX = temperatures, pressures, X
-cp_values = states.cp_mole
-elapsed = time.perf_counter() - t0
-
-print(f"Computed {n_states} Cp values in {elapsed:.4f} seconds (vectorized cantera)")
-print("First 5 Cp values (J/mol-K):", cp_values[:5] / 1000)
-
-
-# Vectorized fluid creation
-fluid = (
-    gp.fluid({'H2': 1}) * fractions[:, 0]
-    + gp.fluid({'H2O': 1}) * fractions[:, 1]
-    + gp.fluid({'N2': 1}) * fractions[:, 2]
-)
-
-time.sleep(0.5)
-
-# Benchmark: calculate Cp for all states at once
-t0 = time.perf_counter()
-cp_values = fluid.get_cp(t=temperatures)
-elapsed = time.perf_counter() - t0
-
-print(f"Computed {n_states} Cp values in {elapsed:.4f} seconds (vectorized Gaspype)")
-print("First 5 Cp values (J/mol·K):", cp_values[:5])

tests/benchmark_equalibrium.py

@@ -1,54 +0,0 @@
-import cantera as ct
-import gaspype as gp
-import numpy as np
-import time
-from gaspype import fluid_system
-
-# -----------------------
-# Settings
-# -----------------------
-n_temps = 1000
-temps_C = np.linspace(300, 1000, n_temps)     # °C
-temperatures = temps_C + 273.15               # K
-pressure = 101325                             # Pa (1 atm)
-
-composition = {"CH4": 0.8, "H2O": 0.2}
-species_to_track = ["CH4", "H2O", "CO", "CO2", "H2", "O2"]
-
-# -----------------------
-# Cantera benchmark
-# -----------------------
-gas = ct.Solution("gri30.yaml")
-gas.TPX = temperatures[0], pressure, composition
-
-eq_cantera = np.zeros((n_temps, len(species_to_track)))
-
-time.sleep(0.5)
-t0 = time.perf_counter()
-for i, T in enumerate(temperatures):
-    gas.TP = T, pressure
-    gas.equilibrate('TP')
-    eq_cantera[i, :] = [gas.X[gas.species_index(s)] for s in species_to_track]
-elapsed_cantera = time.perf_counter() - t0
-print(f"Cantera: {elapsed_cantera:.4f} s")
-
-# -----------------------
-# Gaspype benchmark
-# -----------------------
-# Construct the fluid with composition and tracked species
-fluid = gp.fluid(composition, fs=fluid_system(species_to_track))
-
-time.sleep(0.5)
-t0 = time.perf_counter()
-eq_gaspype = gp.equilibrium(fluid, t=temperatures, p=pressure)
-elapsed_gaspype = time.perf_counter() - t0
-print(f"Gaspype: {elapsed_gaspype:.4f} s")
-
-# -----------------------
-# Compare first 5 results
-# -----------------------
-print("First 5 equilibrium compositions (mole fractions):")
-for i in range(5):
-    print(f"T = {temperatures[i]:.1f} K")
-    print("  Cantera:", eq_cantera[i])
-    print("  Gaspype :", eq_gaspype.array_composition[i])

tests/test_slicing.py

@@ -12,28 +12,28 @@ def test_str_index():
     assert el['C'].shape == (2, 3, 4)
 
 
-def test_single_axis_int_index():
+def test_str_list_index():
-    assert fl[0].shape == (3, 4)
+    assert fl[['CO2', 'H2', 'CO']].shape == (2, 3, 4, 3)
-    assert fl[1].shape == (3, 4)
+    assert el[['C', 'H', 'O']].shape == (2, 3, 4, 3)
-    assert el[1].shape == (3, 4)
-    assert el[0].shape == (3, 4)
 
 
-def test_single_axis_int_list():
+def test_int_list_index():
-    assert fl[:, [0, 1]].shape == (2, 2, 4)
+    assert fl[[1, 2, 0, 5]].shape == (2, 3, 4, 4)
-    assert el[:, [0, 1]].shape == (2, 2, 4)
+    assert el[[1, 2, 0, 3]].shape == (2, 3, 4, 4)
 
 
-def test_multi_axis_int_index():
+def test_mixed_list_index():
-    assert fl[0, 1].shape == (4,)
+    assert el[[1, 'H', 0, 'O']].shape == (2, 3, 4, 4)
-    assert fl[0, 1, 2].shape == tuple()
+
-    assert fl[0, 2].shape == (4,)
+
-    assert fl[:, 2, :].shape == (2, 4)
+def test_int_index():
-    assert fl[0, [1, 2]].shape == (2, 4)
+    assert fl[5].shape == (2, 3, 4)
-    assert fl[..., 0].shape == (2, 3)
+    assert el[-1].shape == (2, 3, 4)
-    assert el[0, 1].shape == (4,)
+
-    assert el[0, 1, 2].shape == tuple()
+
-    assert el[0, 2].shape == (4,)
+def test_slice_index():
-    assert el[:, 2, :].shape == (2, 4)
+    assert fl[0:3].shape == (2, 3, 4, 3)
-    assert el[0, [1, 2]].shape == (2, 4)
+    assert fl[:].shape == (2, 3, 4, 6)
-    assert el[..., 0].shape == (2, 3)
+
+    assert el[0:3].shape == (2, 3, 4, 3)
+    assert el[:].shape == (2, 3, 4, 4)