The IGTools Module

The IGTools module (found in the package pyromat.igtools) provides the IgtMix class, which allows users to dynamically define mixtures of component ideal gases with a flexible interface convenient for the command line and scripts alike. IgtMix instances have property methods just like the rest of the PYroMat classes, but the total quanitity (the extent) of the mixture is specified. Therefore, properties are calculate in total and not per unit metter (not intensive).

In this example, we quickly compute the enthalpy of a mixture 35% hydrogen and balance argon by volume.

>>> from pyromat import igtools as igt
>>> mymix = igt.IgtMix('0.35 H2 + .65Ar', units='kmol')
>>> mymix.h(T=300)
array([43.67153007])

IgtMix instances provide the same properties as the core PYroMat classes

There is not currently a state() method, but there are plans to add one.

For information about the mixture, see:

To operate on the mixture like a Numpy array, see:

See also the indexing features described below.

To convert to other data types, see

There is also fromigmix() function.

The IgtMix class instances allow users to dynamically define mixtures of component ideal gases with a flexible interface convenient for the command line and scripts alike. IgtMix instances have property methods just like the rest of the PYroMat classes. Even though the extent of IgtMix instances is provided, the properties are still evaluated intensively.

In this example, we quickly compute the enthalpy of a mixture 35% hydrogen and balance argon by volume.

>>> mymix = IgtMix('0.35 H2 + .65 Ar', units='kmol')
>>> mymix.h(T=300)
array([43.67153007])

Defining a mixture

There are six ways to define a mixture:

(1) From a string: Strings are expected in the format: 'qty0 subst0 + qty1 subst1 + ...' Quantities specify an amount of each substance in the units configured in pm.config['unit_matter'] unless the optional 'units' keyword is set. Omitted quantities are presumed to be unity, and substances can be specified with or without their 'ig.' collection prefix. All whitespace is ignored.

>>> mymix = IgtMix('10 ig.N2')
>>> mymix = igt.IgtMix('2.4 N2 + Ar', units='kmol')
>>> print(mymix)
[2.4]N2 + [1.]Ar

NOTE: This method cannot be used to specify an ion like 'Ne+'. Instead, use the dictionary or list methods below.

(2) From keyword arguments: Keyword arguments accept abbreviated substance ID strings as keywords. These are the full substance ID strings with the ig. prefix omitted.

>>> air = IgtMix(N2=0.76, O2=0.23, Ar=0.01)
    

NOTE: This method cannot be used to specify an ion like 'Ne+'. Instead, use the dictionary or list methods below.

(3) A list of constituents with no quantities: This assigns zero matter to each mixture. Then, users are free to modify the mixture contents by indexing.

>>> mymix = IgtMix(['ig.N2', 'ig.O2', 'ig.Ar'])
>>> mymix['N2'] = 0.76
>>> mymix['O2'] = 0.23
>>> mymix['Ar'] = 0.01

(4) A dictionary of constituents with their quantities as values: Dictionary keys are interpreted to be substance identifiers, and the corresponding values are interpreted as quantities.

>>> air = IgtMix({'ig.N2':0.76, 'ig.O2':0.23, 'ig.Ar':.01})

(5) Algebraicaly: IgtMix instances can be combined with each other using addition and multiplication at the command line.

>>> air = IgtMix('.76 N2 + .23 O2 + .01 Ar')
>>> fuel = IgtMix('.23 CH4 + .44 C3H8')
>>> reactants = air + 0.4*fuel
>>> print(reactants)
[0.76]N2 + [0.23]O2 + [0.01]Ar + [0.092]CH4 + [0.176]C3H8

Any other data type in addition with an IgtMix is interpreted as a mixture definition as well. For example,

>>> reactants = '.76 N2 + .23 O2 + .01 Ar' + 0.4*fuel       # String
>>> reactants = {'N2':.75, 'O2':.23, 'Ar':.01} + 0.4*fuel   # Dictionary
>>> mymix = pm.get('ig.H2O') + 0.4 * air                    # Pure substance

(6) From an existing igmix instance: The fromigmix() function converts the PYroMat igmix instances into IgtMix instances.

>>> air = fromigmix(pm.get('ig.air'))
>>> print(air)
[0.00935019]Ar + [0.00031401]CO2 + [0.78085562]N2 + [0.20948019]O2

This is a useful trick if users want to make quick changes to an existing mixture. When the fromigmix() function is used, the igmix instance is split into its constituent gases to form the IgtMix instance, so the example above results in a mixture with argon, carbon dioxide, nitrogen, and oxygen. If an igmix instance is passed directly to the IgtMix class, it is treated the same as any other constituent gas, so the example below produces a mixture that only has one gas component.

>>> air = igt.IgtMix(pm.get('ig.air'))
>>> print(air)
[1.]air

Specifying substances

In the examples above, constituent gases can be identified three ways:

1. By their full substance ID string

   >>> mymix = IgtMix('ig.N2')
   

2. By their abbreviated substance ID string (with no leading ig.)

   >>> mymix = IgtMix('N2')
   

3. Or by their full data instance

   >>> n2 = pm.get('ig.N2')
   >>> mymix = IgtMix(n2)
   

Any of these ('N2', 'ig.N2', or pm.get('ig.N2')) may be used as the substance identifier in the mixture list or dictionary methods above.

Arithmetic with mixtures

Because mixtures work in absolute quantities (as opposed to mass or mole fractions), they can be incrased, decreased, subtracted from, or added to using basic math operations at the command line. In this example, mix3 has 1 kmol of water, 2 kmol carbon dioxide, and 2 kmol each of nitrogen and argon.

>>> pm.config['unit_matter'] = 'kmol'
>>> mix1 = IgtMix({'H2O':2, 'CO2':4})
>>> mix2 = IgtMix({'N2':1, 'Ar':1})
>>> mix3 = 0.5*mix1 + 2*mix2

Addition and subtraction attempt to convert non-IgtMix instances to IgtMix instances. That means that strings, lists, dictionaries, and ordinary PYroMat instances may be folded into mixtures using plain command-line arithmetic.

>>> mix4 = mix2 + '0.5 CO'
>>> mix5 = mix2 + pm.get('ig.H2O')
>>> mix6 = mix2 + {'H2O':[0.5,0.12], 'C2H2':0.8}

The last examples show how mixture arrays can be defined. Array broadcasting is inherently supported, so even though H2O was the only substance with multiple values, all other values are broadcast,

>>> print(mix6)
N2   : array([1., 1.])
Ar   : array([1., 1.])
H2O  : array([0.5 , 0.12])
C2H2 : array([0.8, 0.8])

Quantities and units

When an IgtMix instance is initialized, the quantities are interpreted in PYroMat's currently configured 'unit_matter' unless the behavior is overridden by the optional units keyword.

>>> pm.config['unit_matter'] = 'kg'
>>> mymix = IgtMix({'H2O':5.2, 'CO2':4.7}, units='kmol')

Changes to the 'unit_matter' configuration parameter do not affect the mixture's definition. Instead, it only changes the way the mixture's quantities are represented in a print() operation.

Arrays and indexing

Quantities are always handled as arrays, so a single IgtMix instance can actually manage arrays of mixtures with an arbitrary shape. In this example the mixture instance is an array of mixtures of neon, its first ion, and the free electron.

>>> x = np.linspace(0,1,11)
>>> mymix = IgtMix{{'Ne':1-x, 'Ne+':x, 'e':x}, units='kmol')
>>> print(mymix)
Ne  : array([1. , 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 0. ])
Ne+ : array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])
e-  : array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])
    

The shape() method returns a tuple like Numpy's shape attribute, but it describes only the array of mixtures. It excludes the axis with the constituent substances. To obtain the number of substances, use the nsubst() method.

>>> mymix.shape()
(11,)
>>> mymix.nsubst()
3
    

To change the shape of the array, see reshape().

IgtMix instances may be indexed like a normal Numpy array, but with the special rule that the first dimension of the array is always indexed by a substance ID. From the example above,

>>> mymix['Ne']
array([1. , 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 0. ])
>>> mymix['Ne',4]
0.6

When the first index is a slice, the value returned is a sub-mixture instead of an array.

>>> print(mymix[:,4])
0.6Ne + 0.4Ne+ + 0.4e- (kmol)
>>> print(mymix[:,3:6])
Ne  : array([0.7 , 0.65, 0.5 ])
Ne+ : array([0.3 , 0.35, 0.5 ])
e-  : array([0.3 , 0.35, 0.5 ])

Assignment works as well. The example below overwrites the fifth mixture.

>>> mymix[:,4] = {'Ne':0.65, 'Ne+':0.35, 'e':0.35}
>>> print(mymix)
Ne  : array([1.  , 0.9 , 0.8 , 0.7 , 0.65, 0.5 , 0.4 , 0.3 , ...
Ne+ : array([0.  , 0.1 , 0.2 , 0.3 , 0.35, 0.5 , 0.6 , 0.7 , ...
e-  : array([0.  , 0.1 , 0.2 , 0.3 , 0.35, 0.5 , 0.6 , 0.7 , ...

Iterating

IgtMix instances act much like an ordered dictionary with PYroMat ideal gas class isntances as keys and quantitiy arrays as values. The items() method allows simultaneous iteration over the substances and quantities.

>>> for subst,qty in mymix.items():
...     # subst is now a PYroMat substance instance
...     # qty is now a Numpy array of the substance's quantity
     
>>> for subst in mymix:
...     # subst is now a PYroMat substance instance

Initializers

Instances of the IgtMix class are created by the class initializer or by the fromigmix() function. The class initializer signature appears

IgtMix(contents=None, units=None, ...)

Called with no arguments, this creates an empty mixture - one with no substances. It can be expanded later using the other class methods. The contents keyword contains a string, list, dictionary, PYroMat substance, or another IgtMix instance. See the examples above for usage.

Any other keyword arguments are interpreted as string substance identifiers, and the corresponding values are interpreted as quantities.

Property Methods

The IgtMix class calculates properties extensively, (as opposed to intensively, which is how the internal PYroMat classes work). That means that energies and enthalpy are calculated in absolute energy units (as opposed to energy per unit matter). This is true of all properties with only a few exceptions (like molecular weight and gas constant).

Properties all have the call signature

IgtMix.__property__(...)

>>> m.cp(s=3.24, p=.05)

Mixture methods

IgtMix.atoms()

>>> pm.config['unit_matter'] = 'kmol'
>>> m = igt.IgtMix('H2O + 5C2H2')
>>> m.atoms()
{'H': array([12.]), 'O': array([1.]), 'C': array([10.])}

mas = IgtMix.mass()
mol = IgtMix.molar()

Tmin, Tmax = IgtMix.Tlim()

X = IgtMix.X()
Y = IgtMix.Y()

m = igt.IgtMix('4.5 O2 + 2 N2', units='kmol')
>>> m.X()
{'ig.O2': array([0.69230769]), 'ig.N2': array([0.30769231])}
>>> m.Y()
{'ig.O2': array([0.7198954]), 'ig.N2': array([0.2801046])}

Array methods

IgtMix.insert(sid, qty, units=None)

>>> m = IgtMix('2 N2')
>>> m.insert('O2', [0,1])
>>> print(m)
N2 : array([2., 2.])
O2 : array([0., 1.])

n = IgtMix.nsubst()

>>> m = IgtMix('3 C3H8 + 4.7 CH4')
>>> m.nsubst()
2

n = IgtMix.ndim()

>>> m = IgtMix({'C2H2':[[0, 0.1],[0, 0.1]], 'C3H8':[[0,0],[0.1,0.1]]})
>>> print(m)
C2H2 : array([[0. , 0.1],
       [0. , 0.1]])
C3H8 : array([[0. , 0. ],
       [0.1, 0.1]])
>>> m.ndim()
2

IgtMix.remove(sid)

>>> m = IgtMix('3 C3H8 + 4.7 CH4')
>>> m.remove('C3H8')
>>> print(m)
[4.7]CH4

IgtMix.reshape(shape)

>>> m = IgtMix({'C2H2':[[0, 0.1],[0, 0.1]], 'C3H8':[[0,0],[0.1,0.1]]})
>>> print(m)
C2H2 : array([[0. , 0.1],
       [0. , 0.1]])
C3H8 : array([[0. , 0. ],
       [0.1, 0.1]])
>>> m.reshape((4,))
>>> print(m)
C2H2 : array([0. , 0.1, 0. , 0.1])
C3H8 : array([0. , 0. , 0.1, 0.1])
>>> m.reshape((1,2,2))
>>> print(m)
C2H2 : array([[[0. , 0.1],
        [0. , 0.1]]])
C3H8 : array([[[0. , 0. ],
        [0.1, 0.1]]])

shape = IgtMix.shape()

>>> m = IgtMix({'C2H2':[[0, 0.1],[0, 0.1]], 'C3H8':[[0,0],[0.1,0.1]]})
>>> print(m)
C2H2 : array([[0. , 0.1],
       [0. , 0.1]])
C3H8 : array([[0. , 0. ],
       [0.1, 0.1]])
>>> m.shape()
(2,2)

Data conversion methods

mdict = IgtMix.todict()

>>> m = IgtMix({'C2H2':[[0, 0.1],[0, 0.1]], 'C3H8':[[0,0],[0.1,0.1]]})
>>> print(m)
C2H2 : array([[0. , 0.1],
       [0. , 0.1]])
C3H8 : array([[0. , 0. ],
       [0.1, 0.1]])
>>> m.todict()
{'ig.C2H2': array([[0. , 0.1],
       [0. , 0.1]]), 'ig.C3H8': array([[0. , 0. ],
       [0.1, 0.1]])}

mmix = IgtMix.toigmix(sid)

>>> m = IgtMix({'C2H2':[[1, 2],[1, 2]], 'C3H8':[[1,1],[2,2]]}, units='kmol')
>>> m2 = m.toigmix('ig.c')
>>> print(m2)
[<igmix, ig.c_0>, <igmix, ig.c_1>, <igmix, ig.c_2>, <igmix, ig.c_3>]
>>> m.cp(T=400) / m.mass()
array([[2.00136859, 1.94695158],
       [2.04718287, 2.00136859]])
>>> for this in m2:
...     this.cp(T=400)
... 
array([2.00136859])
array([1.94695158])
array([2.04718287])
array([2.00136859])

subst = IgtMix.tolist(mode='sid')

>>> m.tolist()
['ig.C2H2', 'ig.C3H8']
>>> m.tolist('hill')
['C2H2', 'C3H8']
>>> m.tolist('instance')
[<ig2, ig.C2H2>, <ig2, ig.C3H8>]

m = fromigmix(subst)

>>> air = pm.get('ig.air')
>>> mix = fromigmix(air)
>>> print(mix)
[0.01289563]Ar + [0.00047711]CO2 + [0.75520558]N2 + [0.23142168]O2