最大应用空间（存储）(Max app space (storage))

 我想我们至少可以指出你正确的方向。 光学bloch方程是一个在科学界很好理解的问题，虽然不是我:-)，因此互联网上已经存在解决这一特定问题的方法。 
 
 http://massey.dur.ac.uk/jdp/code.html 
 
 但是，为了满足您的需求，您谈到了使用complex_ode，我认为这很好，但我认为简单的scipy.integrate.ode也可以正常工作，根据他们的文档： 
 
 from scipy import eye
 from scipy.integrate import ode

 y0, t0 = [1.0j, 2.0], 0

 def f(t, y, arg1):
     return [1j*arg1*y[0] + y[1], -arg1*y[1]**2]
 def jac(t, y, arg1):
     return [[1j*arg1, 1], [0, -arg1*2*y[1]]]
 r = ode(f, jac).set_integrator('zvode', method='bdf', with_jacobian=True)
 r.set_initial_value(y0, t0).set_f_params(2.0).set_jac_params(2.0)
 t1 = 10
 dt = 1
 while r.successful() and r.t < t1:
     r.integrate(r.t+dt)
     print r.t, r.y
 
 您还可以获得更老，更成熟，更好记录的功能。 我很惊讶你有8个而不是9个耦合的ODE，但我相信你比我更了解这个。是的，你是对的，你的函数应该是ydot = f(t,y) ，你称之为def derv()但是你需要确保你的函数至少有两个参数，比如derv(t,y) 。 如果你的y在矩阵中，没问题！ 只需在derv(t,y)函数中“重塑”它就像这样： 
 
Y = numpy.reshape(y,(num_rows,num_cols));
 
 只要num_rows*num_cols = 8 ，您的ODE数就应该没问题。 然后在计算中使用矩阵。 完成所有操作后，请确保返回一个向量，而不是像以下矩阵： 
 
out = numpy.reshape(Y,(8,1));
 
 Jacobian不是必需的，但它可能会使计算更快地进行。 如果你不知道如何计算这个，你可能想咨询维基百科或微积分教科书。 这很简单，但可能很耗时。 
 
 就初始条件而言，你应该已经知道应该是什么，无论它是复杂的还是真正有价值的。 只要您选择合理的值，它就不重要了。 

I think we can at least point you in the right direction. The optical bloch equation is a problem which is well understood in the scientific community, although not by me :-), so there are already solutions on the internet to this particular problem.
 
http://massey.dur.ac.uk/jdp/code.html
 
However, to address your needs, you spoke of using complex_ode, which I suppose is fine, but I think just plain scipy.integrate.ode will work just fine as well according to their documentation:
 
 from scipy import eye
 from scipy.integrate import ode

 y0, t0 = [1.0j, 2.0], 0

 def f(t, y, arg1):
     return [1j*arg1*y[0] + y[1], -arg1*y[1]**2]
 def jac(t, y, arg1):
     return [[1j*arg1, 1], [0, -arg1*2*y[1]]]
 r = ode(f, jac).set_integrator('zvode', method='bdf', with_jacobian=True)
 r.set_initial_value(y0, t0).set_f_params(2.0).set_jac_params(2.0)
 t1 = 10
 dt = 1
 while r.successful() and r.t < t1:
     r.integrate(r.t+dt)
     print r.t, r.y
 
You also have the added benefit of an older more established and better documented function. I am surprised you have 8 and not 9 coupled ODE's, but I'm sure you understand this better than I. Yes, you are correct, your function should be of the form ydot = f(t,y), which you call def derv() but you're going to need to make sure your function takes at least two parameters like derv(t,y). If your y is in matrix, no problem! Just "reshape" it in the derv(t,y) function like so:
 
Y = numpy.reshape(y,(num_rows,num_cols));
 
As long as num_rows*num_cols = 8, your number of ODE's you should be fine. Then use the matrix in your computations. When you're all done, just be sure to return a vector and not a matrix like:
 
out = numpy.reshape(Y,(8,1));
 
The Jacobian is not required, but it will likely allow the computation to proceed much more quickly. If you do not know how to compute this you may want to consult wikipedia or a calculus text book. It's pretty simple, but can be time consuming.
 
As far as initial conditions, you should probably already know what those should be, whether it's complex or real valued. As long as you select values that are within reason, it shouldn't matter much.