과학적 파이썬에서 유한 차이 방법에 대한 권장 사항

내가 작업하고있는 프로젝트 (쌍곡 PDE에서)에 대해 숫자를 보면서 동작을 대략적으로 다루고 싶습니다. 그러나 나는 아주 좋은 프로그래머가 아닙니다.

Scientific Python에서 유한 차분 체계 를 효과적으로 코딩 하는 방법을 배우기위한 몇 가지 리소스를 추천 할 수 있습니까 (작은 학습 곡선이있는 다른 언어도 환영)?

이 추천에 대한 독자 (나)에 대한 아이디어를 제공하려면 :

• 나는 훈련을 통해 순수한 수학자이고 유한 차이 체계의 이론적 측면에 어느 정도 익숙합니다.
• 내가 도움이 필요한 것은 컴퓨터가 내가 계산하고 싶은 것을 계산하도록하는 방법, 특히 다른 사람들이 이미 시도한 노력을 너무 많이 반복하지 않는 방식으로 (바퀴를 다시 발명하지 않도록하는 방법) 패키지는 이미 사용 가능합니다). (내가 피하고 싶은 또 다른 것은 목적에 맞는 확립 된 데이터 구조가있을 때 손으로 무언가를 어리석게 코딩하는 것입니다.)
• 코딩 경험이 있습니다. 그러나 파이썬에는 아무것도 없었습니다 (따라서 다른 언어를 배우기위한 좋은 자료가 있는지는 신경 쓰지 않습니다 (예 : Octave)).
• 예제 코드 모음과 마찬가지로 책, 설명서 모두 유용합니다.

다음은 내가 관리 하는 py4sci 저장소 에서 David Ketcheson 교수가 제공 한 유한 차분 법을 사용하여 간단한 다변량 PDE를 해결하는 97 줄 예제입니다 . 유한 체적 이산화에서 충격이나 보존을 처리해야하는보다 복잡한 문제의 경우 , 개발에 도움이되는 소프트웨어 패키지 인 pyclaw 를 참조하십시오.

"""Pattern formation code

    Solves the pair of PDEs:
       u_t = D_1 \nabla^2 u + f(u,v)
       v_t = D_2 \nabla^2 v + g(u,v)
"""

import matplotlib
matplotlib.use('TkAgg')
import numpy as np
import matplotlib.pyplot as plt
from scipy.sparse import spdiags,linalg,eye
from time import sleep

#Parameter values
Du=0.500; Dv=1;
delta=0.0045; tau1=0.02; tau2=0.2; alpha=0.899; beta=-0.91; gamma=-alpha;
#delta=0.0045; tau1=0.02; tau2=0.2; alpha=1.9; beta=-0.91; gamma=-alpha;
#delta=0.0045; tau1=2.02; tau2=0.; alpha=2.0; beta=-0.91; gamma=-alpha;
#delta=0.0021; tau1=3.5; tau2=0; alpha=0.899; beta=-0.91; gamma=-alpha;
#delta=0.0045; tau1=0.02; tau2=0.2; alpha=1.9; beta=-0.85; gamma=-alpha;
#delta=0.0001; tau1=0.02; tau2=0.2; alpha=0.899; beta=-0.91; gamma=-alpha;
#delta=0.0005; tau1=2.02; tau2=0.; alpha=2.0; beta=-0.91; gamma=-alpha; nx=150;

#Define the reaction functions
def f(u,v):
    return alpha*u*(1-tau1*v**2) + v*(1-tau2*u);

def g(u,v):
    return beta*v*(1+alpha*tau1/beta*u*v) + u*(gamma+tau2*v);


def five_pt_laplacian(m,a,b):
    """Construct a matrix that applies the 5-point laplacian discretization"""
    e=np.ones(m**2)
    e2=([0]+[1]*(m-1))*m
    h=(b-a)/(m+1)
    A=np.diag(-4*e,0)+np.diag(e2[1:],-1)+np.diag(e2[1:],1)+np.diag(e[m:],m)+np.diag(e[m:],-m)
    A/=h**2
    return A

def five_pt_laplacian_sparse(m,a,b):
    """Construct a sparse matrix that applies the 5-point laplacian discretization"""
    e=np.ones(m**2)
    e2=([1]*(m-1)+[0])*m
    e3=([0]+[1]*(m-1))*m
    h=(b-a)/(m+1)
    A=spdiags([-4*e,e2,e3,e,e],[0,-1,1,-m,m],m**2,m**2)
    A/=h**2
    return A

# Set up the grid
a=-1.; b=1.
m=100; h=(b-a)/m; 
x = np.linspace(-1,1,m)
y = np.linspace(-1,1,m)
Y,X = np.meshgrid(y,x)

# Initial data
u=np.random.randn(m,m)/2.;
v=np.random.randn(m,m)/2.;
plt.hold(False)
plt.pcolormesh(x,y,u)
plt.colorbar; plt.axis('image'); 
plt.draw()
u=u.reshape(-1)
v=v.reshape(-1)

A=five_pt_laplacian_sparse(m,-1.,1.);
II=eye(m*m,m*m)

t=0.
dt=h/delta/5.;
plt.ion()

#Now step forward in time
for k in range(120):
    #Simple (1st-order) operator splitting:
    u = linalg.spsolve(II-dt*delta*Du*A,u)
    v = linalg.spsolve(II-dt*delta*Dv*A,v)

    unew=u+dt*f(u,v);
    v   =v+dt*g(u,v);
    u=unew;
    t=t+dt;

    #Plot every 3rd frame
    if k/3==float(k)/3:
        U=u.reshape((m,m))
        plt.pcolormesh(x,y,U)
        plt.colorbar
        plt.axis('image')
        plt.title(str(t))
        plt.draw()

plt.ioff()

특수 마크 업 언어를 사용하여 일반적인 방정식을 풀 수있는 python / C 프레임 워크 인 Fenics를 살펴볼 수 있습니다. 그것은 주로 유한 요소를 사용하지만 볼만한 가치가 있습니다. 이 튜토리얼 에서는 문제를 해결하는 것이 얼마나 쉬운 지 보여줄 것입니다.

이 참조는 매우 유용 할 수 있습니다. 인터넷에서 열린 책입니다. 이 책에서 파이썬을 배웠습니다 (여전히 배우고 있습니다). 나는 정말 좋은 자원을 찾았습니다.

http://www.openbookproject.net/thinkcs/python/english2e/

숫자 계산의 경우 분명히 'numpy'를 사용해야합니다. ( 'array'와 'matrix'와 'list'를 제대로 이해했는지 확인하십시오) (numpy documentation 참조)