वैज्ञानिक पायथन में परिमित अंतर विधि के लिए सिफारिश

Question

एक ऐसी परियोजना के लिए, जिस पर (अतिशयोक्तिपूर्ण पीडीई में) मैं काम कर रहा हूं, मैं कुछ संख्याओं को देखकर व्यवहार पर कुछ हद तक संभालना चाहता हूं। हालाँकि, मैं बहुत अच्छा प्रोग्रामर नहीं हूँ।

क्या आप वैज्ञानिक पायथन में परिमित अंतर योजनाओं को प्रभावी ढंग से कोड करने के लिए सीखने के लिए कुछ संसाधनों की सिफारिश कर सकते हैं (छोटी सीखने की अवस्था के साथ अन्य भाषाएँ भी स्वागत करती हैं)?

इस सिफारिश के लिए आपको दर्शकों (मुझे) का एक विचार देने के लिए:

• मैं प्रशिक्षण द्वारा एक शुद्ध गणितज्ञ हूं, और परिमित अंतर योजनाओं के सैद्धांतिक पहलुओं से कुछ हद तक परिचित हूं
• मुझे कंप्यूटर के साथ कंप्यूटर की गणना कैसे करनी है, इसके लिए मुझे क्या चाहिए, विशेषकर इस तरह से कि मैं पहले से ही दूसरों द्वारा डाले गए प्रयास के बहुत अधिक नकल न करूं (ताकि पहिया को फिर से आविष्कार न करूं एक पैकेज पहले से ही उपलब्ध है)। (एक और चीज जो मैं बचना चाहूंगा, वह है हाथ से कुछ कोड करना जब उद्देश्य स्थापित करने वाली डेटा संरचनाएं हों।)
• मुझे कुछ कोडिंग का अनुभव हुआ है; लेकिन मेरे पास पाइथन में कोई नहीं है (इसलिए मुझे कोई आपत्ति नहीं है अगर एक अलग भाषा सीखने के लिए अच्छे संसाधन हैं [उदाहरण के लिए, ओक्टेव कहते हैं)।
• उदाहरण कोड के संग्रह के रूप में किताबें, प्रलेखन दोनों उपयोगी होंगे।

Comments

मुख्य समस्या यह है कि मुझे यह भी पता नहीं है कि कहां से शुरू करना है: इसलिए भी मूल सुझाव मददगार होंगे।

— विली वोंग

प्रतिबंध केवल इतना है कि मैं परिमित मात्रा के तरीकों से परिचित नहीं हूं (अभी तक); इसलिए मुझे संयोजन में विधि सीखना होगा। मैं निश्चित रूप से इस तरह के जवाब पर आपत्ति नहीं जताऊंगा।

— विली वोंग

PyClaw nonlinear स्रोत शब्दों को संभाल सकता है, लेकिन अपने खुद के रिमैन सॉल्वर को लिखना जटिल होगा, विशेष रूप से 2 या उच्च आयामों में। यदि आप संरचित ग्रिड के साथ एक सरल परिमित-भिन्न योजना का प्रयास करना चाहते हैं, तो आपका अगला विकल्प पेट्सकॉपी में कुछ प्रयास करना होगा , (प्रकटीकरण: मैं इस परियोजना के साथ भी संबद्ध हूं), जो अधिक सामान्य उद्देश्य है और साथ ही नहीं- दस्तावेज।

— एरॉन अहमदिया

आइए इस चर्चा को चैट में जारी रखें

— एरन अहमदिया

हाय विली (और पाठकों के लिए जिसने चैट को नहीं देखा है), मुझे लगता है कि आप पहले से ही यह जानते हैं, लेकिन जब से आपने हाइपरबोलिक पीडीई का उल्लेख किया है तो आप शायद एक परिमित मात्रा विधि के साथ बेहतर होंगे।

— मैथ्यू एम्मेट

Answer 1

यहाँ एक साधारण बहुभिन्नरूपी पीडीई को परिमित अंतर विधियों का उपयोग करके हल करने का एक 97-लाइन उदाहरण है , जो कि मैं डेविड रेस्चेटरी द्वारा बनाए गए py4sci रिपॉजिटरी मैं योगदान देता हूं। अधिक जटिल समस्याओं के लिए जहां आपको एक परिमाण-मात्रा विवेकाधिकार में झटके या संरक्षण को संभालने की आवश्यकता होती है, मैं पॉलीकॉव को देखने की सलाह देता हूं , एक सॉफ्टवेयर पैकेज जिसे मैं विकसित करने में मदद करता हूं।

"""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()

Answer 2

आप पर एक नजर डाल सकते हैं फेनिक्स डाल सकते हैं , जो कि एक अजगर / सी फ्रैमवर्क है जो एक विशेष मार्कअप भाषा का उपयोग करके काफी सामान्य समीकरणों को हल करने की अनुमति देता है। यह ज्यादातर परिमित तत्वों का उपयोग करता है, लेकिन देखने लायक है। ट्यूटोरियल आप कितना आसान है की समस्याओं को हल किया जा सकता है की एक छाप देना चाहिए।

Answer 3

यह संदर्भ आपके लिए बहुत उपयोगी हो सकता है। यह इंटरनेट पर एक खुली किताब है। मैंने सीखा (अभी भी सीख रहा हूं), इस किताब से अजगर। मुझे यह वास्तव में बहुत अच्छा संसाधन लगा।

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

संख्यात्मक गणना के लिए, व्यक्ति को निश्चित रूप से 'सुन्न' के लिए जाना चाहिए। (बस यह सुनिश्चित करें कि आप 'सरणी' और 'मैट्रिक्स' और 'सूची' को ठीक से समझ चुके हैं) (इसके लिए संख्यात्मक दस्तावेज देखें)