slow kinetics...

[atravert]

In this branch, I am improving the performances of the integration in ActionMassKinetics by generating the expressions of the rates of production instead of using the previous matrix expression which is simple to implement but very inefficient.

I still have a problem in trying to implement an exec() within the function thatr carry out the integration here: https://github.com/atravert/spectrochempy/blob/cf0eee1ff83e34867f57cc8da376d2f236abc82f/spectrochempy/analysis/kinetic_utilities.py#LL489C1-L501C1

... while the equivalent is working fine when used in a script, as in the example below which compare the execution times:

Any suggestion ?

import time
import spectrochempy as scp
import numpy as np
from scipy.integrate import solve_ivp
import matplotlib.pyplot as plt


R = 8.314


# %%
# A -> B -> C  at variable temperature

def T(t):
    return 298. + 10. * t

reactions = ("A -> B", "B -> C")
species_concentrations = {"A": 1.0, "B": 0.0, "C": 0.0}
arrhenius = np.array(((1e5, 50.e3), (1e5, 70.0e3)))
t_eval = np.arange(50)

# %%
kin = scp.ActionMassKinetics(reactions, species_concentrations, arrhenius, T=T)

# --------------------------------------
#  current matrix formulation (very slow....)
#---------------------------------------
tic = time.time()
Ckin = kin.integrate(t_eval)
exec_time_mat = time.time()-tic
print(f"Integration time matrix: {exec_time_mat}")
Ckin.T.plot()
plt.show()

# %%
# ---------------------------------------
# explicitly write ODE's : much more efficient 
# ---------------------------------------
def f(t, C):
    k = kin.k(t)   # use the kin object to compute k(t)
    return [-k[0] * C[0], k[0] * C[0] - k[1] * C[1], k[1] * C[1] ]
tic = time.time()
bunch = solve_ivp(f, (t_eval[0], t_eval[-1]), kin.init_concentrations, t_eval = t_eval)
exec_time_ode = time.time() - tic
print(f"Integration time ode explicit: {exec_time_ode}")
plt.plot(bunch.y.T)
plt.title('explicit')
plt.show()

# ---------------------------------------
# generated ode with exec in this script: very efficient too
# ---------------------------------------

exec(f"def f2(t, C): k = kin.k(t); return{kin.production_rates_str()}") # <-- here kin is recognized (see erroe below)
tic = time.time()
bunch = solve_ivp(f2,
                  (t_eval[0], t_eval[-1]), kin.init_concentrations, t_eval = t_eval)
exec_time_ode_str = time.time() - tic
print(f"Integration time ode_str: {exec_time_ode_str}")
plt.plot(bunch.y.T)
plt.title('ode_str')
plt.show()

# ---------------------------------------
# generated with exec from scpy: still not working... 
# ---------------------------------------
tic = time.time()
Ckin = kin.new_integrate(t_eval)  #  <-- ERROR | NameError: name 'self' is not defined <-- here self (within new_intergrate) is not recognised
exec_time_ode_str_2 = time.time()-tic
print(f"Integration time ode_str_2: {exec_time_ode_str_2}")

[fernandezc]

ok, but can you rebase your branch onto upstream/master because it is out of sync?. Then I will have a look.

[fernandezc]

Actually it would be better to make a draft PR, so I could comment in the code 😄

Ok I don't understand how this could work.

line 489

        exec(
            f"def f_(t, C): k = self.k(t); return{self.production_rates_str()}",
            global_env,
        )

self is not defined in the exec function, I think. Or I don't know how. I am not used to exec (I'll look at the doc, ASAP)

[fernandezc]

ok first, it seems to me that as f_ is a method (not a function) you should have

        exec(
            f"def f_(self, t, C): k = self.k(t); return{self.production_rates_str()}",
            global_env,
        )

[atravert]

I have rebased and made a draft PR.

regarding your remark: In the example script above, kin is also not defined within exec but it works.

exec(f"def f2(t, C): k = kin.k(t); return{kin.production_rates_str()}") # <-- here kin is recognized (see erroe below)```
 

[fernandezc]

Yes but here we are inside a class and the instance (self) is known only after initialization. A method should always have self as a first arguments except when defined as a staticmethod (decorator @staticmethod).

[fernandezc]

ok here something working:

        global_env = {}
        locals_env = {}
        exec(
            f"def f_(t, C, cls=None): k = cls.k(t); return{self.production_rates_str()}",
            global_env, locals_env
        )
        import functools 
        
        bunch = solve_ivp(
            functools.partial(locals_env["f_"], cls=self),
            (t[0], t[-1]),
            self.init_concentrations,
            t_eval=t,
            method=method,
        )

Not sure about globals or locals, but the trick is to pass a new parameter using the partial method of functools

[fernandezc]

but the time of exec ???? may be not what you expected.

[fernandezc]

ok I did a wrong thing this why it was slow,

        global_env = {}
        locals_env = {}
        exec(
            f"def f_(self, t, C): k = self.k(t); return{self.production_rates_str()}",
            global_env, locals_env
        )
        import functools

        bunch = solve_ivp(
            functools.partial(locals_env["f_"], self),
            (t[0], t[-1]),
            self.init_concentrations,
            t_eval=t,
            method=method,
        )

[fernandezc]

this work in 0.061 sec on my computer

[fernandezc]

but I let you investigate:
very strange:

SpectroChemPy's API - v.0.6.2.dev26
© Copyright 2014-2023 - A.Travert & C.Fernandez @ LCS
Integration time matrix: 0.04888105392456055
Integration time ode explicit: 0.02937769889831543
Integration time ode_str: 0.02445220947265625
Integration time ode_str_2: 0.06603884696960449

I don't see much the differences.

[atravert]

Many thanks !! . The matrix calculation was much much slower in my case. I will look at it. Le 10 mai 2023 20:05:55 GMT+02:00, Christian Fernandez ***@***.***> a écrit :

…

but I let you investigate: very strange: SpectroChemPy's API - v.0.6.2.dev26 © Copyright 2014-2023 - A.Travert & C.Fernandez @ LCS Integration time matrix: 0.04888105392456055 Integration time ode explicit: 0.02937769889831543 Integration time ode_str: 0.02445220947265625 Integration time ode_str_2: 0.06603884696960449 I don't see much the differences. — Reply to this email directly, view it on GitHub<#647 (reply in thread)>, or unsubscribe<https://github.com/notifications/unsubscribe-auth/ACNBNCRV6CSCHEIMUW2JFULXFPKIHANCNFSM6AAAAAAX46HHVA>. You are receiving this because you authored the thread.Message ID: ***@***.***>

-- Sent from /e/ Mail.

[fernandezc]

loop of 100 exec of each:

Integration time matrix: 5.250311851501465
Integration time ode explicit: 1.920600175857544
Integration time ode_str: 1.8605241775512695
Integration time ode_str_2: 4.13110089302063

matrix slower but not so much

[atravert]

The differences are larger for slightly more complex reaction and when using returnNDDataset=False.

Integration time mat: 10.472177982330322
Integration time ode: 5.694751262664795
Integration time ode_str: 5.522478103637695
Integration time ode_str_2: 5.9946534633636475