सहानुभूतिशील एकीकृतकर्ताओं के साथ सहायता

Question

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

Answer 1

जैसा कि आपने स्रोत कोड के लिए कहा था: HERE से आप हैमिल्टनियन सिस्टम और समेकित समस्याओं के लिए सममित तरीकों के लिए सहानुभूतिपूर्ण तरीकों के लिए MATLAB और FORTRAN कोड डाउनलोड कर सकते हैं। और diff समीकरणों से निपटने के लिए कई अन्य तरीकों भी।

और THIS पेपर में आप एल्गोरिदम का विवरण पा सकते हैं।

संपादित

आप मेथेमेटिका this का उपयोग करते हैं भी मदद मिल सकती है।

Answer 2

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

एक खुला स्रोत मैटलैब आधारित ट्रैकिंग कोड एक्सेलेरेटर टूलबॉक्स कहा जाता है। एटकोलाब नामक सोर्सफोर्ज प्रोजेक्ट है। एक गंदा विकी यहाँ https://sourceforge.net/apps/mediawiki/atcollab/index.php?title=Main_Page

integrators के लिए देखें, आप यहाँ देख सकते हैं: https://sourceforge.net/p/atcollab/code-0/235/tree/trunk/atintegrators/ integrators मैटलैब को MEX लिंक के साथ सी में लिखा जाता है। क्योंकि इलेक्ट्रॉनों को सापेक्षिक और संभावित शब्द गैर-सापेक्ष मामले की तुलना में थोड़ा अलग दिखते हैं, लेकिन कोई भी हैमिल्टनियन को एच = एच 1 + एच 2 के रूप में लिख सकता है जहां एच 1 एक बहाव है और एच 2 एक किक है (चौकोर से कहें चुंबक या अन्य चुंबकीय क्षेत्र)।

Answer 3

वेरलेट योजना के आधार पर चौथी ऑर्डर संरचना विधि के लिए स्रोत कोड यहां दिया गया है। $ \ log_ {10} (\ डेल्टा टी) $ बनाम $ \ log_ {10} (त्रुटि) $ का एक रैखिक प्रतिगमन सिद्धांत की अपेक्षा के अनुसार 4 की ढलान दिखाएगा (नीचे ग्राफ देखें)। अधिक जानकारी here, here या here मिल सकती है।

#include <cmath> 
#include <iostream> 

using namespace std; 

const double total_time = 5e3; 

// Parameters for the potential. 
const double sigma = 1.0; 
const double sigma6 = pow(sigma, 6.0); 
const double epsilon = 1.0; 
const double four_epsilon = 4.0 * epsilon; 

// Constants used in the composition method. 
const double alpha = 1.0/(2.0 - cbrt(2.0)); 
const double beta = 1.0 - 2.0 * alpha; 


static double force(double q, double& potential); 

static void verlet(double dt, 
        double& q, double& p, 
        double& force, double& potential); 

static void composition_method(double dt, 
           double& q, double& p, 
           double& f, double& potential); 


int main() { 
    const double q0 = 1.5, p0 = 0.1; 
    double potential; 
    const double f0 = force(q0, potential); 
    const double total_energy_exact = p0 * p0/2.0 + potential; 

    for (double dt = 1e-2; dt <= 5e-2; dt *= 1.125) { 
    const long steps = long(total_time/dt); 

    double q = q0, p = p0, f = f0; 
    double total_energy_average = total_energy_exact; 

    for (long step = 1; step <= steps; ++step) { 
     composition_method(dt, q, p, f, potential); 
     const double total_energy = p * p/2.0 + potential; 
     total_energy_average += total_energy; 
    } 

    total_energy_average /= double(steps); 

    const double err = fabs(total_energy_exact - total_energy_average); 
    cout << log10(dt) << "\t" 
     << log10(err) << endl; 
    } 

    return 0; 
} 

double force(double q, double& potential) { 
    const double r2 = q * q; 
    const double r6 = r2 * r2 * r2; 
    const double factor6 = sigma6/r6; 
    const double factor12 = factor6 * factor6; 

    potential = four_epsilon * (factor12 - factor6); 
    return -four_epsilon * (6.0 * factor6 - 12.0 * factor12)/r2 * q; 
} 

void verlet(double dt, 
      double& q, double& p, 
      double& f, double& potential) { 
    p += dt/2.0 * f; 
    q += dt * p; 
    f = force(q, potential); 
    p += dt/2.0 * f; 
} 

void composition_method(double dt, 
         double& q, double& p, 
         double& f, double& potential) { 
    verlet(alpha * dt, q, p, f, potential); 
    verlet(beta * dt, q, p, f, potential); 
    verlet(alpha * dt, q, p, f, potential); 
}