libICEpost.src.thermophysicalModels.laminarFlameSpeedModels =========================================================== .. py:module:: libICEpost.src.thermophysicalModels.laminarFlameSpeedModels .. autoapi-nested-parse:: @author: F. Ramognino Last update: 9/03/2023 ... Submodules ---------- .. toctree:: :maxdepth: 1 /autoapi/libICEpost/src/thermophysicalModels/laminarFlameSpeedModels/LaminarFlameSpeedModel/index /autoapi/libICEpost/src/thermophysicalModels/laminarFlameSpeedModels/TabulatedLFS/index Classes ------- .. autoapisummary:: libICEpost.src.thermophysicalModels.laminarFlameSpeedModels.LaminarFlameSpeedModel libICEpost.src.thermophysicalModels.laminarFlameSpeedModels.TabulatedLFS Package Contents ---------------- .. py:class:: LaminarFlameSpeedModel Bases: :py:obj:`libICEpost.src.base.BaseClass.BaseClass`, :py:obj:`libICEpost.src.base.Utilities.Utilities` Base class for computation of laminar flame speed. .. py:method:: Su(p: float, T: float, phi: float, EGR: float = None) -> float | numpy.ndarray :abstractmethod: Used to compute laminar flame speed in derived class. Here in the base class it is used only for argument checking. :param p: Pressure [Pa]. :type p: float :param T: Unburnt gas temperature [K] :type T: float :param phi: Equivalence ratio [-]. :type phi: float :param EGR: (optional) mass fraction of recirculated exhaust gasses. Defaults to None. :type EGR: float, optional :returns: The computed laminar flame speed [m/s]. :rtype: float|np.ndarray .. py:method:: deltaL(p: float, T: float, phi: float, EGR: float = None) -> float | numpy.ndarray :abstractmethod: Used to compute laminar flame thickness in derived class. Here in the base class it is used only for argument checking. :param p: Pressure [Pa]. :type p: float :param T: Unburnt gas temperature [K] :type T: float :param phi: Equivalence ratio [-]. :type phi: float :param EGR: (optional) mass fraction of recirculated exhaust gasses. Defaults to None. :type EGR: float, optional :returns: The computed laminar flame thickness [m]. :rtype: float|np.ndarray .. py:class:: TabulatedLFS(*, Su: Iterable[float], deltaL: Iterable[float] = None, pRange: Iterable[float], TuRange: Iterable[float], phiRange: Iterable[float], egrRange: Iterable[float] = None, path: str = None, noWrite: bool = True, tablePropertiesParameters: dict[str, Any] = None, **kwargs) Bases: :py:obj:`libICEpost.src.base.dataStructures.Tabulation.OFTabulation.OFTabulation`, :py:obj:`libICEpost.src.thermophysicalModels.laminarFlameSpeedModels.LaminarFlameSpeedModel.LaminarFlameSpeedModel` Class for computation of unstained laminar flame speed from tabulation .. py:attribute:: __inputNames :type: list[str] :value: ['pValues', 'TuValues', 'eqvrValues', 'egrValues'] .. py:attribute:: __order :type: list[str] :value: ['p', 'Tu', 'phi', 'egr'] .. py:attribute:: __files :type: dict[str, str] .. py:method:: fromFile(path: str, readLaminarFlameThickness: bool = True, noWrite=True, **kwargs) -> TabulatedLFS :classmethod: Construct a table from files stored in an OpenFOAM-LibICE tabulation locted at 'path'. Directory structure as follows: \ path \ |-tableProperties \ |---constant \ | |-Su \ | |-deltaL \ |---system \ |-controlDict \ |-fvSchemes \ |-fvSolutions :param path: The master path where the tabulation is stored. :type path: str :param readLaminarFlameThickness: Is the laminar flame thickness to be loaded? (in case it was not tabulated). Defaults to True. :type readLaminarFlameThickness: bool, optional :param noWrite: Handle to prevent write access of this class to the tabulation (avoid overwrite). Defaults to True. :type noWrite: bool, optional :param \*\*kwargs: Optional keyword arguments of Tabulation.__init__ method of each Tabulation object. :returns: the tabulation :rtype: TabulatedLFS .. py:method:: fromDictionary(dictionary: dict) -> TabulatedLFS :classmethod: Construct from dictionary containing: path (str): The master path where the tabulation is stored. readLaminarFlameThickness (bool, optional): Is the laminar flame thickness to be loaded? (in case it was not tabulated). Defaults to True. noWrite (bool, optional): Handle to prevent write access of this class to the tabulation (avoid overwrite). Defaults to True. kwargs (dict, optional): The optional keyword arguments to pass to Tabulation instance for construction. Defaults to dict(). :param dictionary: The input dictionary. :type dictionary: dict :returns: TabulatedLFS .. py:method:: SuTable() -> libICEpost.src.base.dataStructures.Tabulation.Tabulation.Tabulation The tabulation of laminar flame speed (read-only) .. py:method:: deltaLTable() -> libICEpost.src.base.dataStructures.Tabulation.Tabulation.Tabulation | None The tabulation of laminar flame tickness (read-only) .. py:method:: Su(p: float, T: float, phi: float, EGR=None, **kwargs) Interpolate laminar flame speed from tabulation. :param p: Pressure [Pa]. :type p: float :param T: Unburnt gas temperature [K] :type T: float :param phi: Equivalence ratio [-]. :type phi: float :param EGR: (optional) mass fraction of recirculated exhaust gasses. Defaults to None. :type EGR: float, optional :param \*\*kwargs: The key-word arguments to pass to Tabulation.__call__ method. :returns: The computed laminar flame speed [m/s]. :rtype: float|np.ndarray[float] .. py:method:: deltaL(p, T, phi, EGR=None, **kwargs) Interpolate laminar flame thickness from tabulation. :param p: Pressure [Pa]. :type p: float :param T: Unburnt gas temperature [K] :type T: float :param phi: Equivalence ratio [-]. :type phi: float :param EGR: (optional) mass fraction of recirculated exhaust gasses. Defaults to None. :type EGR: float, optional :param \*\*kwargs: The key-word arguments to pass to Tabulation.__call__ method. :returns: The computed laminar flame thickness [m]. :rtype: float|np.ndarray[float]