gaspype 0.0.0__tar.gz

gaspype-0.0.0/PKG-INFO

@@ -0,0 +1,180 @@
+Metadata-Version: 2.2
+Name: gaspype
+Version: 0.0.0
+Summary: Calculates thermodynamics of gases
+Author-email: Nicolas Kruse <nicolas.kruse@nonan.net>
+Project-URL: Homepage, https://github.com/Nonannet/gaspype
+Project-URL: Issues, https://github.com/Nonannet/gaspype/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# Gaspype
+
+The Gaspype package will provide an high performance library for thermodynamic calculations.
+
+## Usage will be like as follows
+
+Gaspype provides two main classes: ```fluid``` and ```elements```.
+
+### Fluid
+
+A fluid class describes a mixture of molecular species and their individual molar amounts.
+
+``` python
+import gaspype as gp
+fl = gp.fluid({'H2O': 1, 'H2':2})
+fl
+```
+```
+Total            3.000e+00 mol
+H2O              33.33 %
+H2               66.67 %
+```
+
+Its' functions provides thermodynamic, mass balance and ideal gas properties of the mixture.
+
+``` python
+cp = fl.get_cp(t=800+273.15)
+mass = fl.get_mass()
+gas_volume = fl.get_v(t=800+273.15, p=1e5)
+```
+
+The arguments can be provided as numpy-arrays:
+
+``` python
+t_range = np.linspace(600, 800, 5) + 273.15
+fl.get_density(t=t_range, p=1e5)
+```
+```
+array([0.10122906, 0.09574625, 0.09082685, 0.08638827, 0.08236328])
+```
+A ```fluid``` object can have multiple compositions. A multidimensional ```fluid``` object can be created for example by multiplication with a numpy array:
+
+``` python
+fl2 = gp.fluid({'H2O': 1, 'N2':2}) + \
+      np.linspace(0, 10, 4) * gp.fluid({'H2': 1})
+fl2
+```
+```
+Total mol:
+array([ 3.        ,  6.33333333,  9.66666667, 13.        ])
+Species:
+             H2O         N2         H2
+Molar fractions:
+array([[0.33333333, 0.66666667, 0.        ],
+       [0.15789474, 0.31578947, 0.52631579],
+       [0.10344828, 0.20689655, 0.68965517],
+       [0.07692308, 0.15384615, 0.76923077]])
+```
+A fluid object can be converted to a pandas dataframe:
+``` python
+import pandas as pd
+pd.DataFrame(list(fl2))
+```
+|    | H2O | N2  |  H2 
+|----|-----|-----|-------
+|0   | 1.0 | 2.0 | 0.000000
+|1   | 1.0 | 2.0 | 3.333333
+|2   | 1.0 | 2.0 | 6.666667
+|3   | 1.0 | 2.0 | 10.000000
+
+The broadcasting behavior is not limited to 1D-arrays:
+
+``` python
+fl3 = gp.fluid({'H2O': 1}) + \
+      np.linspace(0, 10, 4) * gp.fluid({'H2': 1}) + \
+      np.expand_dims(np.linspace(1, 3, 3), axis=1) * gp.fluid({'N2': 1})
+fl3
+```
+```
+Total mol:
+array([[ 2.        ,  5.33333333,  8.66666667, 12.        ],
+       [ 3.        ,  6.33333333,  9.66666667, 13.        ],
+       [ 4.        ,  7.33333333, 10.66666667, 14.        ]])
+Species:
+             H2O         N2         H2
+Molar fractions:
+array([[[0.5       , 0.5       , 0.        ],
+        [0.1875    , 0.1875    , 0.625     ],
+        [0.11538462, 0.11538462, 0.76923077],
+        [0.08333333, 0.08333333, 0.83333333]],
+
+       [[0.33333333, 0.66666667, 0.        ],
+        [0.15789474, 0.31578947, 0.52631579],
+        [0.10344828, 0.20689655, 0.68965517],
+        [0.07692308, 0.15384615, 0.76923077]],
+
+       [[0.25      , 0.75      , 0.        ],
+        [0.13636364, 0.40909091, 0.45454545],
+        [0.09375   , 0.28125   , 0.625     ],
+        [0.07142857, 0.21428571, 0.71428571]]])
+```
+In some cases not the molecular but the atomic composition is of interest. The ```elements``` class can be used for atom based balances and works similar:
+
+``` python
+el = gp.elements({'N': 1, 'Cl': 2})
+el.get_mass()
+```
+```
+0.084907
+```
+A ```elements``` object can be as well instantiated from a ```fluid``` object. Arithmetic operations between ```elements``` and ```fluid``` result in an ```elements``` object:
+``` python
+el2 = gp.elements(fl) + el - 0.3 * fl
+el2
+```
+```
+Cl               2.000e+00 mol
+N                1.000e+00 mol
+O                7.000e-01 mol
+H                4.200e+00 mol
+```
+
+Going from an atomic composition to an molecular composition is a little bit less straight forward, since there is no universal approach. One way is to calculate the thermodynamic equilibrium for a mixture:
+
+``` python
+fs = gp.fluid_system('CH4, H2, CO, CO2, O2')
+el3 = gp.elements({'C': 1, 'H': 2, 'O':1}, fs)
+fl3 = gp.equilibrium(el3, t=800)
+fl3
+```
+```
+Total            1.204e+00 mol
+CH4              33.07 %
+H2               16.93 %
+CO               16.93 %
+CO2              33.07 %
+O2                0.00 %
+```
+
+The ```equilibrium``` function can be called with a ```fluid``` or ```elements``` object as first argument. ```fluid``` and ```elements``` referencing a ```fluid_system``` object witch can be be set as shown above during the object instantiation. If not provided, a new one will be created automatically. Providing a ```fluid_system``` gives more control over which molecular species are included in derived ```fluid``` objects. Furthermore arithmetic operations between objects with the same ```fluid_system``` are potentially faster:
+
+``` python
+fl3 + gp.fluid({'CH4': 1}, fs)
+```
+```
+Total            2.204e+00 mol
+CH4              63.44 %
+H2                9.24 %
+CO                9.24 %
+CO2              18.07 %
+O2                0.00 %
+```
+
+Especially if the ```fluid_system``` of one of the operants has not a subset of molecular species of the other ```fluid_system``` a new ```fluid_system``` will be created for the operation which might degrade performance:
+
+``` python
+fl3 + gp.fluid({'NH3': 1})
+```
+```
+Total            2.204e+00 mol
+NH3              45.38 %
+CH4              18.07 %
+H2                9.24 %
+O2                0.00 %
+CO                9.24 %
+CO2              18.07 %
+```

gaspype-0.0.0/README.md

@@ -0,0 +1,167 @@
+# Gaspype
+
+The Gaspype package will provide an high performance library for thermodynamic calculations.
+
+## Usage will be like as follows
+
+Gaspype provides two main classes: ```fluid``` and ```elements```.
+
+### Fluid
+
+A fluid class describes a mixture of molecular species and their individual molar amounts.
+
+``` python
+import gaspype as gp
+fl = gp.fluid({'H2O': 1, 'H2':2})
+fl
+```
+```
+Total            3.000e+00 mol
+H2O              33.33 %
+H2               66.67 %
+```
+
+Its' functions provides thermodynamic, mass balance and ideal gas properties of the mixture.
+
+``` python
+cp = fl.get_cp(t=800+273.15)
+mass = fl.get_mass()
+gas_volume = fl.get_v(t=800+273.15, p=1e5)
+```
+
+The arguments can be provided as numpy-arrays:
+
+``` python
+t_range = np.linspace(600, 800, 5) + 273.15
+fl.get_density(t=t_range, p=1e5)
+```
+```
+array([0.10122906, 0.09574625, 0.09082685, 0.08638827, 0.08236328])
+```
+A ```fluid``` object can have multiple compositions. A multidimensional ```fluid``` object can be created for example by multiplication with a numpy array:
+
+``` python
+fl2 = gp.fluid({'H2O': 1, 'N2':2}) + \
+      np.linspace(0, 10, 4) * gp.fluid({'H2': 1})
+fl2
+```
+```
+Total mol:
+array([ 3.        ,  6.33333333,  9.66666667, 13.        ])
+Species:
+             H2O         N2         H2
+Molar fractions:
+array([[0.33333333, 0.66666667, 0.        ],
+       [0.15789474, 0.31578947, 0.52631579],
+       [0.10344828, 0.20689655, 0.68965517],
+       [0.07692308, 0.15384615, 0.76923077]])
+```
+A fluid object can be converted to a pandas dataframe:
+``` python
+import pandas as pd
+pd.DataFrame(list(fl2))
+```
+|    | H2O | N2  |  H2 
+|----|-----|-----|-------
+|0   | 1.0 | 2.0 | 0.000000
+|1   | 1.0 | 2.0 | 3.333333
+|2   | 1.0 | 2.0 | 6.666667
+|3   | 1.0 | 2.0 | 10.000000
+
+The broadcasting behavior is not limited to 1D-arrays:
+
+``` python
+fl3 = gp.fluid({'H2O': 1}) + \
+      np.linspace(0, 10, 4) * gp.fluid({'H2': 1}) + \
+      np.expand_dims(np.linspace(1, 3, 3), axis=1) * gp.fluid({'N2': 1})
+fl3
+```
+```
+Total mol:
+array([[ 2.        ,  5.33333333,  8.66666667, 12.        ],
+       [ 3.        ,  6.33333333,  9.66666667, 13.        ],
+       [ 4.        ,  7.33333333, 10.66666667, 14.        ]])
+Species:
+             H2O         N2         H2
+Molar fractions:
+array([[[0.5       , 0.5       , 0.        ],
+        [0.1875    , 0.1875    , 0.625     ],
+        [0.11538462, 0.11538462, 0.76923077],
+        [0.08333333, 0.08333333, 0.83333333]],
+
+       [[0.33333333, 0.66666667, 0.        ],
+        [0.15789474, 0.31578947, 0.52631579],
+        [0.10344828, 0.20689655, 0.68965517],
+        [0.07692308, 0.15384615, 0.76923077]],
+
+       [[0.25      , 0.75      , 0.        ],
+        [0.13636364, 0.40909091, 0.45454545],
+        [0.09375   , 0.28125   , 0.625     ],
+        [0.07142857, 0.21428571, 0.71428571]]])
+```
+In some cases not the molecular but the atomic composition is of interest. The ```elements``` class can be used for atom based balances and works similar:
+
+``` python
+el = gp.elements({'N': 1, 'Cl': 2})
+el.get_mass()
+```
+```
+0.084907
+```
+A ```elements``` object can be as well instantiated from a ```fluid``` object. Arithmetic operations between ```elements``` and ```fluid``` result in an ```elements``` object:
+``` python
+el2 = gp.elements(fl) + el - 0.3 * fl
+el2
+```
+```
+Cl               2.000e+00 mol
+N                1.000e+00 mol
+O                7.000e-01 mol
+H                4.200e+00 mol
+```
+
+Going from an atomic composition to an molecular composition is a little bit less straight forward, since there is no universal approach. One way is to calculate the thermodynamic equilibrium for a mixture:
+
+``` python
+fs = gp.fluid_system('CH4, H2, CO, CO2, O2')
+el3 = gp.elements({'C': 1, 'H': 2, 'O':1}, fs)
+fl3 = gp.equilibrium(el3, t=800)
+fl3
+```
+```
+Total            1.204e+00 mol
+CH4              33.07 %
+H2               16.93 %
+CO               16.93 %
+CO2              33.07 %
+O2                0.00 %
+```
+
+The ```equilibrium``` function can be called with a ```fluid``` or ```elements``` object as first argument. ```fluid``` and ```elements``` referencing a ```fluid_system``` object witch can be be set as shown above during the object instantiation. If not provided, a new one will be created automatically. Providing a ```fluid_system``` gives more control over which molecular species are included in derived ```fluid``` objects. Furthermore arithmetic operations between objects with the same ```fluid_system``` are potentially faster:
+
+``` python
+fl3 + gp.fluid({'CH4': 1}, fs)
+```
+```
+Total            2.204e+00 mol
+CH4              63.44 %
+H2                9.24 %
+CO                9.24 %
+CO2              18.07 %
+O2                0.00 %
+```
+
+Especially if the ```fluid_system``` of one of the operants has not a subset of molecular species of the other ```fluid_system``` a new ```fluid_system``` will be created for the operation which might degrade performance:
+
+``` python
+fl3 + gp.fluid({'NH3': 1})
+```
+```
+Total            2.204e+00 mol
+NH3              45.38 %
+CH4              18.07 %
+H2                9.24 %
+O2                0.00 %
+CO                9.24 %
+CO2              18.07 %
+```

gaspype-0.0.0/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+name = "gaspype"
+version = "0.0.0"
+authors = [
+  { name="Nicolas Kruse", email="nicolas.kruse@nonan.net" },
+]
+description = "Calculates thermodynamics of gases"
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/Nonannet/gaspype"
+Issues = "https://github.com/Nonannet/gaspype/issues"
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+minversion = "6.0"
+addopts = "-ra -q"
+testpaths = ["tests"]
+pythonpath = ["src"]

gaspype-0.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

gaspype-0.0.0/src/gaspype/__init__.py

@@ -0,0 +1,2 @@
+def info():
+    print('is coming')

gaspype-0.0.0/src/gaspype.egg-info/PKG-INFO

@@ -0,0 +1,180 @@
+Metadata-Version: 2.2
+Name: gaspype
+Version: 0.0.0
+Summary: Calculates thermodynamics of gases
+Author-email: Nicolas Kruse <nicolas.kruse@nonan.net>
+Project-URL: Homepage, https://github.com/Nonannet/gaspype
+Project-URL: Issues, https://github.com/Nonannet/gaspype/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# Gaspype
+
+The Gaspype package will provide an high performance library for thermodynamic calculations.
+
+## Usage will be like as follows
+
+Gaspype provides two main classes: ```fluid``` and ```elements```.
+
+### Fluid
+
+A fluid class describes a mixture of molecular species and their individual molar amounts.
+
+``` python
+import gaspype as gp
+fl = gp.fluid({'H2O': 1, 'H2':2})
+fl
+```
+```
+Total            3.000e+00 mol
+H2O              33.33 %
+H2               66.67 %
+```
+
+Its' functions provides thermodynamic, mass balance and ideal gas properties of the mixture.
+
+``` python
+cp = fl.get_cp(t=800+273.15)
+mass = fl.get_mass()
+gas_volume = fl.get_v(t=800+273.15, p=1e5)
+```
+
+The arguments can be provided as numpy-arrays:
+
+``` python
+t_range = np.linspace(600, 800, 5) + 273.15
+fl.get_density(t=t_range, p=1e5)
+```
+```
+array([0.10122906, 0.09574625, 0.09082685, 0.08638827, 0.08236328])
+```
+A ```fluid``` object can have multiple compositions. A multidimensional ```fluid``` object can be created for example by multiplication with a numpy array:
+
+``` python
+fl2 = gp.fluid({'H2O': 1, 'N2':2}) + \
+      np.linspace(0, 10, 4) * gp.fluid({'H2': 1})
+fl2
+```
+```
+Total mol:
+array([ 3.        ,  6.33333333,  9.66666667, 13.        ])
+Species:
+             H2O         N2         H2
+Molar fractions:
+array([[0.33333333, 0.66666667, 0.        ],
+       [0.15789474, 0.31578947, 0.52631579],
+       [0.10344828, 0.20689655, 0.68965517],
+       [0.07692308, 0.15384615, 0.76923077]])
+```
+A fluid object can be converted to a pandas dataframe:
+``` python
+import pandas as pd
+pd.DataFrame(list(fl2))
+```
+|    | H2O | N2  |  H2 
+|----|-----|-----|-------
+|0   | 1.0 | 2.0 | 0.000000
+|1   | 1.0 | 2.0 | 3.333333
+|2   | 1.0 | 2.0 | 6.666667
+|3   | 1.0 | 2.0 | 10.000000
+
+The broadcasting behavior is not limited to 1D-arrays:
+
+``` python
+fl3 = gp.fluid({'H2O': 1}) + \
+      np.linspace(0, 10, 4) * gp.fluid({'H2': 1}) + \
+      np.expand_dims(np.linspace(1, 3, 3), axis=1) * gp.fluid({'N2': 1})
+fl3
+```
+```
+Total mol:
+array([[ 2.        ,  5.33333333,  8.66666667, 12.        ],
+       [ 3.        ,  6.33333333,  9.66666667, 13.        ],
+       [ 4.        ,  7.33333333, 10.66666667, 14.        ]])
+Species:
+             H2O         N2         H2
+Molar fractions:
+array([[[0.5       , 0.5       , 0.        ],
+        [0.1875    , 0.1875    , 0.625     ],
+        [0.11538462, 0.11538462, 0.76923077],
+        [0.08333333, 0.08333333, 0.83333333]],
+
+       [[0.33333333, 0.66666667, 0.        ],
+        [0.15789474, 0.31578947, 0.52631579],
+        [0.10344828, 0.20689655, 0.68965517],
+        [0.07692308, 0.15384615, 0.76923077]],
+
+       [[0.25      , 0.75      , 0.        ],
+        [0.13636364, 0.40909091, 0.45454545],
+        [0.09375   , 0.28125   , 0.625     ],
+        [0.07142857, 0.21428571, 0.71428571]]])
+```
+In some cases not the molecular but the atomic composition is of interest. The ```elements``` class can be used for atom based balances and works similar:
+
+``` python
+el = gp.elements({'N': 1, 'Cl': 2})
+el.get_mass()
+```
+```
+0.084907
+```
+A ```elements``` object can be as well instantiated from a ```fluid``` object. Arithmetic operations between ```elements``` and ```fluid``` result in an ```elements``` object:
+``` python
+el2 = gp.elements(fl) + el - 0.3 * fl
+el2
+```
+```
+Cl               2.000e+00 mol
+N                1.000e+00 mol
+O                7.000e-01 mol
+H                4.200e+00 mol
+```
+
+Going from an atomic composition to an molecular composition is a little bit less straight forward, since there is no universal approach. One way is to calculate the thermodynamic equilibrium for a mixture:
+
+``` python
+fs = gp.fluid_system('CH4, H2, CO, CO2, O2')
+el3 = gp.elements({'C': 1, 'H': 2, 'O':1}, fs)
+fl3 = gp.equilibrium(el3, t=800)
+fl3
+```
+```
+Total            1.204e+00 mol
+CH4              33.07 %
+H2               16.93 %
+CO               16.93 %
+CO2              33.07 %
+O2                0.00 %
+```
+
+The ```equilibrium``` function can be called with a ```fluid``` or ```elements``` object as first argument. ```fluid``` and ```elements``` referencing a ```fluid_system``` object witch can be be set as shown above during the object instantiation. If not provided, a new one will be created automatically. Providing a ```fluid_system``` gives more control over which molecular species are included in derived ```fluid``` objects. Furthermore arithmetic operations between objects with the same ```fluid_system``` are potentially faster:
+
+``` python
+fl3 + gp.fluid({'CH4': 1}, fs)
+```
+```
+Total            2.204e+00 mol
+CH4              63.44 %
+H2                9.24 %
+CO                9.24 %
+CO2              18.07 %
+O2                0.00 %
+```
+
+Especially if the ```fluid_system``` of one of the operants has not a subset of molecular species of the other ```fluid_system``` a new ```fluid_system``` will be created for the operation which might degrade performance:
+
+``` python
+fl3 + gp.fluid({'NH3': 1})
+```
+```
+Total            2.204e+00 mol
+NH3              45.38 %
+CH4              18.07 %
+H2                9.24 %
+O2                0.00 %
+CO                9.24 %
+CO2              18.07 %
+```

gaspype-0.0.0/src/gaspype.egg-info/SOURCES.txt

@@ -0,0 +1,7 @@
+README.md
+pyproject.toml
+src/gaspype/__init__.py
+src/gaspype.egg-info/PKG-INFO
+src/gaspype.egg-info/SOURCES.txt
+src/gaspype.egg-info/dependency_links.txt
+src/gaspype.egg-info/top_level.txt

gaspype-0.0.0/src/gaspype.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

gaspype-0.0.0/src/gaspype.egg-info/top_level.txt

@@ -0,0 +1 @@
+gaspype