Python integrator函数代码示例

    def run_sim(self):
        # start time
        timer = time.time()
        # create molecule
        mol = molecule(self.molecule, self.temperature)
        # create laser
        las = laser(self.pulse, self.intensity)

        # generate usefule quantities
        Jmax = mol.params()[3]
        delta_alpha = mol.params()[2]
        B = mol.params()[0]
        D = mol.params()[1]
        Jweight = mol.Boltzmann()

        sigma = las.pulse_FWHM*B/hbar
        E0 = 2.74*10**10*las.Int**.5 # electric field amplitude
        strength=0.5*4*np.pi*epsilon0*delta_alpha*E0**2/B

        # create integrator
        intSEq = integrator(mol.params()[3], las.pulse_FWHM*B/hbar, strength, B, D)

        # integrate
        Cstor = intSEq.integrate()


        # Expectation value, incoherent, thermal average.
        print('Sim done. \n \nCalculating cos**2.\n')
        exp_val = expectation_values(Jmax, sigma, strength, B, D)
        tt, cos2 = exp_val.cos2(Cstor, Jweight)
        
        # plot
        exp_val.cos2plot(tt,cos2, mol.mol_str)

        ## Expectation value, rho
        if self.calcrho == 'on':
            print('Calculating rotational density. This may take a while.\n')
            ttt, theta, rho = exp_val.rho(Cstor, Jweight)
        else:
            theta = 0
            ttt = 0
            rho = 0
            print('Rotational density not calculated.\n')
        # end timer
        elapsed = time.time() - timer
        print('Program took ' + str(round(elapsed)) + ' s to run. \n')
        
        return tt*hbar/B*10**12, cos2, theta, ttt*hbar/B*10**12, rho

    psi = InvPotentialVorticity(omegaNew);
    u = -partialY(psi);
    v = partialX(psi);
    dOmega = domegadt(dt, omegaNew, (u,v,forcing));
    return(dOmega);


def diffusion(dt, fields, args):
    omegaNew = fields;

    diffOmega = spectralDiffusion(dt, omegaNew, args);

    return(diffOmega);


stepper = integrator(h, [dSystemdt], \
                [diffusion], calcMax_omega,1);

ion();
omega_n = omega;
psi_n = InvPotentialVorticity(omega_n);
u_n = -partialY(psi_n);
v_n = partialX(psi_n);
Energy = mean(u_n*u_n) + mean(v_n*v_n) ;
Enstrophy = mean(omega_n * omega_n);
Ttt = 0.0;
en = 0.0;
#figure(figsize= (10,8));
figure(figsize= (16,5));
subplot(121)

prev_t = 0;

    print 'Gravity wave velocity: ', gravity_speed; 
    return amax((maximum,gravity_speed));


def calcPower(field):
    [x,y] = shape(field);
    power = zeros(y);

    for i in arange(x):
        power = power + abs(fft(field[i,:]));

    power = power/x;
    return log(power);

stepper_omega = integrator(h, [dudt,dvdt,dndt], [diffusion_SWE], calcMax_omega, dim=3);

ion();

figure(figsize= (18,6));

# making my own colormap
cdict = {
    'red'  :  ((0., 1., 1.), (0.5, 0.5, 0.5), (1., 0, 0)),
    'green':  ((0., 1., 1.), (0.5, 0.5, 0.5), (1., 0, 0)),
    'blue' :  ((0., 1., 1.), (0.5, 0.5, 0.5), (1., 0., 0.))
}
my_cmap = m.matplotlib.colors.LinearSegmentedColormap('my_colormap', cdict, 1024)

# making my own colormap
cdict_vapor = {

    (beta,u,v) = args;
    maximum = sqrt(amax(amax(u*u),amax(v*v)));
    return maximum;


def calcPower(field):
    [x,y] = shape(field);
    power = zeros(y);

    for i in arange(x):
        power = power + abs(fft(field[i,:]));

    power = power/x;
    return log(power);

stepper_omega = integrator(h, [dudt_omega], [diffusion_omega], calcMax_omega);
stepper_vapor = integrator(h, [dudt_vapor], [diffusion_vapor], calcMax_vapor);

ion();
k = linspace(1,128,128);
vapor_n = vapor;
omega_n = omega;
rh = zeros((N,N/2-1));
beta = 2.0;

dy = 2*pi/N;
qs = zeros((N/2-1,1));
q0 = 0.3;

for i in arange(N/2-1):
    qs[N/2-i-2] = beta*dy*i + q0;

    print 'Gravity wave velocity: ', gravity_speed; 
    return 4*amax((maximum,gravity_speed));


def calcPower(field):
    [x,y] = shape(field);
    power = zeros(y);

    for i in arange(x):
        power = power + abs(fft(field[i,:]));

    power = power/x;
    return log(power);

stepper_omega = integrator(hx, [dSystemdt], [diffusion_SWE], calcMax_omega, dim=3);

ion();


prev_t = 0;

omega_n = (u,v,n);
#jet();

if(resume > 0):
   print 'Resuming from step: ',resume;
   eta = \
   np.load(path+'/eta_data_'+str(resume)+'.npy');

   u = np.load(path+'/uVel_data_'+str(resume)+'.npy');

    uHat = fourier(u);
    numvals = len(u);
    threshold = int(numvals/3);
    uHat[threshold:2*numvals/3] = 0;
    k = array(range(N), dtype=complex128) - N/2;
    k = ifftshift(k);
    k = 0.01*(k**2);
    k = -k*dt;
    multiplier = exp(k);
    uHat = uHat*multiplier;
    return real(invFourier(uHat));

def calcMax(u, args):
    return sqrt(amax(u*u));

stepper = integrator(h, [dudt], [diffusion], calcMax);
ion();
vn = v;
subplot(211);
handle, = plot(abs(fourier(v)));
subplot(212);
handle2, = plot(t,v);

tn = 0;
sec = 1;
while (sec < 30):
    (tn,vn) = stepper.integrate(tn,vn);
    if(tn > sec):
        handle.set_ydata((fourier(vn).real));
        handle2.set_ydata(vn);
        sec = sec+1;

#v = sin(t)+2*sin(t/4)+3*cos(t);

def dudt(dt, u, args):
    """ du/dt = -u*u_x 
    """
#    return 0;
    return real(-u*partialX(u));


def calcMax(u, args):
    return amax((0.2,sqrt(amax(u*u))));

for i in arange(N):
    v[i,:] = 0.1*sin(t[i])*cos(t);

stepper = integrator(h, [dudt], [spectralDiffusion], calcMax);
ion();
vn = v;
subplot(211);
handle = imshow(abs(fft2(v)));
subplot(212);
handle2 = imshow(v.transpose());
show();

tn = 0;
sec = 1;
while (sec < 500):
    (tn,vn) = stepper.integrate(tn,vn);
    if(tn > sec):
        print 'Time elapsed: ', tn;
        handle.set_array(abs(fft2(vn)));

from mynet import *
from scipy import signal
from integrator import *
from scipy.integrate import odeint
import numpy as np
import matplotlib.pyplot as plt

K = 4
X0 = -1 * np.ones((K, 2))
dt = 0.1
fs = 1 / dt
Nsteps = 10000
myintegrator = integrator(dt, Nsteps)
mynet = net(K)

# stimulation function
def mysin(x):
    if x > tstart and x <= period + tstart:
        return amp * np.sin(2 * np.pi * freq * (x - tstart) ** 2 / (2 * period)) + I0
    else:
        return I0


amp = 0.1  # ampplitude of stimulation
tstart = 100.0  # begining of stimulation
period = 400.0
freq = 0.4
I0 = 0.0  # dc
time = np.arange(Nsteps) * dt
nstart = int(tstart / dt)
nstop = int((tstart + period) / dt)

    print 'Gravity wave velocity: ', gravity_speed; 
    return amax((maximum,gravity_speed));


def calcPower(field):
    [x,y] = shape(field);
    power = zeros(y);

    for i in arange(x):
        power = power + abs(fft(field[i,:]));

    power = power/x;
    return log(power);

stepper_omega = integrator(h, [dOmegadt], [diffusion_SWE], calcMax_omega, dim=3);

ion();

figure(figsize= (18,6));

# making my own colormap
cdict = {
    'red'  :  ((0., 1., 1.), (0.5, 0.5, 0.5), (1., 0, 0)),
    'green':  ((0., 1., 1.), (0.5, 0.5, 0.5), (1., 0, 0)),
    'blue' :  ((0., 1., 1.), (0.5, 0.5, 0.5), (1., 0., 0.))
}
my_cmap = m.matplotlib.colors.LinearSegmentedColormap('my_colormap', cdict, 1024)

# making my own colormap
cdict_vapor = {

    inp[:,i] = sin(2*pi*j/N);

deriv = coupledDerivative(N,4,2*pi,2*pi);

def dudt(dt,u,args):

    return -u*deriv.partialX(u);

def diffusion(dt, u, args):
    return u;

def calcMax_omega(u,args):

    return amax(amax(u));

stepper_omega = integrator(h, [dudt], [diffusion], calcMax_omega);

ion();
output, =  plot(inp[:,1]);
#hold(True);
#plot(deriv.partialX(inp)[:,1]);
#draw();
#raw_input();
#exit();

while(1):

    print shape(inp);
    (dt, inp) = stepper_omega.integrate(0, inp,(),0);
    print shape(inp);
    output.set_ydata(inp[:,1]);