Quasi Steady State Approximation

[Antoine]

Hi all,

I was wondering if there is a way to test the quasi steady-state approximation (QSSA) with Cantera, i.e. using algebraic equations for fast radical pools?

I cannot see any information regarding this methodology and I am trying to modify the source code to enable the QSSA methodology. Any help on this matter would be greatly appreciated.

Thanks,

Antoine

[Ray Speth]

Antoine,

There is currently no support for QSSA within Cantera, but I'm sure that this is a feature a number of people would be interested in. I believe that only previous instances of reduced mechanisms based on QSSA that I have seen were hard-coded (i.e. as a Fortran function for computing the species rates of production). I would be very interested in knowing if there is a more flexible approach that could work with (more or less) arbitrary starting mechanisms and be done on the fly.

Regards,

Ray

[Kyle Niemeyer]

I am also interested in this, but haven't (yet) figured out a way to do it.

Ray, you're correct that previously (meaning, with Chemkin) this required a hard-coded routine for the rates of production. In fact, with the older Chemkin, you had to actually comment out the rate-of-production subroutine and link the Chemkin library files with your compiled routine, with the your custom routine named the same as the commented-out one. Modern Chemkin/Chemkin-Pro isn't all that different, in that you need to rebuild the appropriate executable with the user routines linked.

This would be worth pursuing. For either working with C++ or Cantera, it may be useful to allow the user to provide an alternate function to evaluate species production rates, that Cantera might also use internally (e.g., for advancing a Reactor).

Kyle

[Ray Speth]

Kyle,

I think there are a range of options for implementing this, with varying degrees of flexibility and ease-of-use. One end of this spectrum is in fact already possible in Cantera. If you are using Cantera from C++, you can just write a subclass of GasKinetics which implements the getNetProductionRates method, and use an object of this type when setting up the reactor network. Of course, this method requires recompiling in order to switch mechanisms, and doesn't work with the Python or Matlab toolboxes.

A more flexible approach would be to introduce a Kinetics class where the rate-of-production function is specified as being implemented in a separate shared library, which the user can compile separately and choose at runtime. This approach could enable users to work with various existing reduced mechanisms that are implemented in this way.

A third option would be to figure out whether it is possible to write a generic implementation of the QSSA equations that is still reasonably efficient, in which case you could define the reduced mechanism without having to compile any code (and could even pair this with the code used to generate the QSSA mechanism in the first place if you wanted). This option is certainly the most complex to implement, but also probably the most interesting in terms of the capabilities that it provides.

Regards,

Ray

[Hao Wu]

Ray,

FYI, the first option is what is currently used by the CERFACS in their mod of cantera (http://www.cerfacs.fr/cantera/installation.php).

For the third option, LQSSA (http://pubs.acs.org/doi/abs/10.1021/jp064482y) can be implemented in a rather general way. Given a skeletal mechanism, the only additional information required is the set of QSS species.

I'm interested in implementing it Cantera, but may need some help on the cti parser.

[Di Cheng]

HI Ray,

AFAIK, QSSA is converting the ODE to a DAE (or at least an ODE problem with rootfinding like the example `cvRoberts_dns.c` of CVODE). When the fast species are identified by some ranking algorithm, its time derivative is forced to be zero and the differential equation is converted to an algebraic constraint. The computation cost saving should come from dimension reduction in ODE system. If the reduced QSSA mechanism can be fit into the `ODE with root finding` framework of CVODE, it may be more easy to implement it with some variables re-arrangement.

I think LQSSA mentioned by Hao Wu sounds like the concept of DAC. I think DAC looks like a dynamic version of QSSA.

[Ingmar Schoegl]

I am likewise interested in this: however, I hope that linking external modules can be avoided, as it will get very limited use. While I haven't looked into the forward problem (I believe it's a DAE that is applied prior to the ODE); the reverse (QSS and partial equilibrium) is rather straight-forward, as I have coded this using python with cantera as a back-end a couple of years ago. I'd frankly be interested in anything that would help cantera speed up (preconditioners, parallel CVODE, etc.).

-ingmar-

[Di Cheng]

@Ray Speth, Sorry, I am wrong, root finding in CVODE cannot not be used for the purpose of QSSA.

@Hao Wu, now I think the method in Chao Xu's dissertation (URL: https://opencommons.uconn.edu/dissertations/1836) might be more suitable because LQSSA is still inaccurate. ANd the algebraic equations of QSS should be weakly nonlinear as disccussed in LQSSA paper, so functional iterative methods should be more suitable for this kind of problem.