จำลองการไหลของของไหลแบบไม่มีความหนืดด้วย QUICK-PDE

หมายเหตุ

Qiskit Functions เป็นฟีเจอร์ทดลองที่ใช้ได้เฉพาะผู้ใช้แผน IBM Quantum® Premium Plan, Flex Plan และ On-Prem (ผ่าน IBM Quantum Platform API) เท่านั้น อยู่ในสถานะ preview release และอาจมีการเปลี่ยนแปลงได้

ประมาณการใช้งาน: 50 นาทีบนโปรเซสเซอร์ Heron r2 (หมายเหตุ: นี่เป็นเพียงการประมาณ ระยะเวลาจริงอาจแตกต่างกัน)

ระยะเวลาในการรันฟังก์ชันนี้โดยทั่วไปมักนานกว่า 20 นาที ดังนั้นอาจต้องการแบ่งบทแนะนำนี้ออกเป็นสองส่วน: ส่วนแรกที่อ่านเนื้อหาและส่งงาน และส่วนที่สองอีกไม่กี่ชั่วโมงต่อมา (เพื่อให้งานเสร็จสมบูรณ์) สำหรับการทำงานกับผลลัพธ์ของงาน

พื้นหลัง

บทแนะนำนี้มุ่งสอนระดับเบื้องต้นเกี่ยวกับการใช้ฟังก์ชัน QUICK-PDE เพื่อแก้ปัญหา multi-physics ที่ซับซ้อนบน QPU Heron R2 156Q โดยใช้ H-DES (Hybrid Differential Equation Solver) ของ ColibriTD อัลกอริทึมพื้นฐานอธิบายไว้ใน งานวิจัย H-DES โปรดทราบว่า solver นี้สามารถแก้สมการไม่เชิงเส้นได้ด้วย

ปัญหา multi-physics ไม่ว่าจะเป็นพลศาสตร์ของไหล การแพร่กระจายความร้อน และการเสียรูปของวัสดุ ล้วนสามารถอธิบายได้อย่างครอบคลุมผ่านสมการเชิงอนุพันธ์ย่อย (Partial Differential Equations หรือ PDEs)

ปัญหาเหล่านี้มีความสำคัญอย่างยิ่งต่ออุตสาหกรรมต่าง ๆ และถือเป็น สาขาสำคัญของคณิตศาสตร์ประยุกต์ อย่างไรก็ตาม การแก้ PDEs แบบไม่เชิงเส้น หลายตัวแปรและมีการจับคู่กันด้วยเครื่องมือแบบคลาสสิกยังคงเป็นความท้าทาย เนื่องจากต้องการทรัพยากรที่เพิ่มขึ้นแบบเอกซ์โพเนนเชียล

ฟังก์ชันนี้เหมาะสำหรับสมการที่มีความซับซ้อนและตัวแปรที่เพิ่มขึ้น และเป็นก้าวแรกในการปลดล็อกความเป็นไปได้ที่เคยถือว่าแก้ไม่ได้ เพื่ออธิบายปัญหาที่จำลองด้วย PDEs ได้อย่างครบถ้วน จำเป็นต้องทราบ เงื่อนไขเริ่มต้นและเงื่อนไขขอบเขต ซึ่งสิ่งเหล่านี้สามารถเปลี่ยนแปลง คำตอบของ PDE และแนวทางในการหาคำตอบได้อย่างมีนัยสำคัญ

บทแนะนำนี้สอนวิธีการ:

1. กำหนดพารามิเตอร์ของฟังก์ชันเงื่อนไขเริ่มต้น
2. ปรับจำนวน Qubit (ที่ใช้เข้ารหัสฟังก์ชันของสมการเชิงอนุพันธ์) ความลึก และจำนวนช็อต
3. รัน QUICK-PDE เพื่อแก้สมการเชิงอนุพันธ์ที่อยู่เบื้องหลัง

ข้อกำหนด

ก่อนเริ่มบทแนะนำนี้ ตรวจสอบให้แน่ใจว่าติดตั้งสิ่งต่อไปนี้แล้ว:

• Qiskit SDK v2.0 หรือสูงกว่า (pip install qiskit)
• Qiskit Functions Catalog (pip install qiskit-ibm-catalog)
• Matplotlib (pip install matplotlib)
• สิทธิ์การเข้าถึงฟังก์ชัน QUICK-PDE กรอก แบบฟอร์มเพื่อขอสิทธิ์การเข้าถึง

การตั้งค่า

ยืนยันตัวตนโดยใช้ API key และเลือกฟังก์ชันดังนี้:

# Added by doQumentation — required packages for this notebook
!pip install -q matplotlib numpy qiskit-ibm-catalog

import numpy as np
import matplotlib.pyplot as plt
from qiskit_ibm_catalog import QiskitFunctionsCatalog

catalog = QiskitFunctionsCatalog(
    channel="ibm_quantum_platform",
    instance="INSTANCE_CRN",
    token="YOUR_API_KEY",  # Use the 44-character API_KEY you created and saved from the IBM Quantum Platform Home dashboard
)

quick = catalog.load("colibritd/quick-pde")

ขั้นตอนที่ 1: กำหนดคุณสมบัติของปัญหาที่ต้องการแก้

บทแนะนำนี้ครอบคลุมประสบการณ์ผู้ใช้จากสองมุมมอง: ปัญหาทางฟิสิกส์ ที่กำหนดโดยเงื่อนไขเริ่มต้น และส่วนประกอบของอัลกอริทึมในการแก้ตัวอย่าง พลศาสตร์ของไหลบนคอมพิวเตอร์ควอนตัม

Computational Fluid Dynamics (CFD) มีขอบเขตการประยุกต์ใช้ที่กว้างขวาง จึงเป็นสิ่งสำคัญที่ต้องศึกษาและแก้ PDEs ที่อยู่เบื้องหลัง ตระกูล PDEs ที่สำคัญกลุ่มหนึ่งคือสมการ Navier-Stokes ซึ่งเป็นระบบ สมการเชิงอนุพันธ์ย่อยแบบไม่เชิงเส้นที่อธิบายการเคลื่อนที่ของของไหล สมการเหล่านี้มีความสำคัญอย่างยิ่งสำหรับปัญหาทางวิทยาศาสตร์และการประยุกต์ทางวิศวกรรม

ภายใต้เงื่อนไขบางประการ สมการ Navier-Stokes จะลดรูปเป็นสมการ Burgers' ซึ่งเป็นสมการการพาและการแพร่กระจายที่อธิบายปรากฏการณ์ต่าง ๆ ใน พลศาสตร์ของไหล พลศาสตร์ก๊าซ และอะคูสติกส์แบบไม่เชิงเส้น โดยจำลอง ระบบ dissipative

เวอร์ชันหนึ่งมิติของสมการขึ้นอยู่กับตัวแปรสองตัว: $t \in \mathbb{R}_{\geq 0}$ แทนมิติของเวลา และ $x \in \mathbb{R}$ แทนมิติของปริภูมิ รูปแบบทั่วไปของสมการเรียกว่า สมการ viscous Burgers' และมีรูปแบบดังนี้:

$\frac{\partial u}{\partial t} + u \frac{\partial u}{\partial x} = \nu \frac{\partial^2 u}{\partial^2 x},$

โดยที่ $u(x,t)$ คือสนามความเร็วของไหลที่ตำแหน่ง $x$ และเวลา $t$ และ $\nu$ คือความหนืดของของไหล ความหนืดเป็นคุณสมบัติสำคัญของของไหล ที่วัดความต้านทานต่อการเคลื่อนที่หรือการเปลี่ยนรูปซึ่งขึ้นอยู่กับอัตรา จึงมีบทบาทสำคัญในการกำหนดพลศาสตร์ของของไหล เมื่อ ความหนืดของของไหลเป็นศูนย์ ($\nu$ = 0) สมการจะกลายเป็นสมการอนุรักษ์ ที่สามารถพัฒนาความไม่ต่อเนื่อง (คลื่นกระแทก) ได้ เนื่องจากขาดความต้านทานภายใน ในกรณีนี้ สมการเรียกว่าสมการ inviscid Burgers' และเป็นกรณีพิเศษของสมการคลื่นแบบไม่เชิงเส้น

อย่างเคร่งครัดแล้ว การไหลแบบ inviscid ไม่เกิดขึ้นในธรรมชาติ แต่เมื่อจำลอง การไหลทางอากาศพลศาสตร์ เนื่องจากผลกระทบของการขนส่งที่เล็กน้อยมาก การใช้คำอธิบาย inviscid ของปัญหาจึงมีประโยชน์ น่าแปลกใจที่ กว่า 70% ของทฤษฎีอากาศพลศาสตร์เกี่ยวข้องกับการไหลแบบ inviscid

บทแนะนำนี้ใช้สมการ inviscid Burgers' เป็นตัวอย่าง CFD สำหรับแก้ บน IBM® QPUs โดยใช้ QUICK-PDE ตามสมการ:

$\frac{\partial u}{\partial t} + u\frac{\partial u}{\partial x} = 0$

เงื่อนไขเริ่มต้นของปัญหานี้กำหนดเป็นฟังก์ชันเชิงเส้น: $u(t=0,x) = ax + b,\text{ with }a,b\in\mathbb{R}$ โดยที่ $a$ และ $b$ เป็นค่าคงที่ที่กำหนดเองซึ่งมีผลต่อรูปร่างของ คำตอบ คุณสามารถปรับ $a$ และ $b$ เพื่อดูว่ามีผลต่อ กระบวนการแก้และคำตอบอย่างไร

job = quick.run(
    use_case="cfd",
    physical_parameters={"a": 1.0, "b": 1.0},
)

print(job.result())

{'functions': {'u': array([[1.        , 0.96112378, 0.9230742 , 0.88616096, 0.85058445,
        0.81644741, 0.78376878, 0.75249908, 0.72253689, 0.69374562,
        0.66597013, 0.63905258, 0.61284684, 0.58723093, 0.56211691,
        0.53745752, 0.51324915, 0.48953036, 0.46637547, 0.44388257,
        0.4221554 , 0.40127848, 0.38128488, 0.36211604, 0.34357308,
        0.32525895, 0.30651089, 0.28632252, 0.26325504, 0.23533692],
       [1.2375    , 1.19267729, 1.14850734, 1.10544526, 1.06382155,
        1.02385326, 0.98565757, 0.94926734, 0.91464784, 0.88171402,
        0.85034771, 0.82041411, 0.79177677, 0.76431068, 0.73791248,
        0.71250742, 0.68805224, 0.66453346, 0.64196021, 0.62035121,
        0.59971506, 0.5800232 , 0.56117499, 0.54295419, 0.52497612,
        0.50662498, 0.48698059, 0.4647339 , 0.43809065, 0.40466247],
       [1.475     , 1.4242308 , 1.37394048, 1.32472956, 1.27705866,
        1.23125911, 1.18754636, 1.1460356 , 1.10675879, 1.06968242,
        1.03472529, 1.00177563, 0.9707067 , 0.94139043, 0.91370806,
        0.88755732, 0.86285533, 0.83953655, 0.81754494, 0.79681986,
        0.77727473, 0.75876792, 0.74106511, 0.72379234, 0.70637915,
        0.687991  , 0.66745028, 0.64314527, 0.61292625, 0.57398802],
       [1.7125    , 1.65578431, 1.59937362, 1.54401386, 1.49029576,
        1.43866495, 1.38943515, 1.34280386, 1.29886974, 1.25765082,
        1.21910288, 1.18313715, 1.14963664, 1.11847019, 1.08950364,
        1.06260722, 1.03765842, 1.01453964, 0.99312968, 0.97328851,
        0.95483439, 0.93751264, 0.92095522, 0.90463049, 0.88778219,
        0.86935702, 0.84791997, 0.82155665, 0.78776186, 0.74331358],
       [1.95      , 1.88733782, 1.82480676, 1.76329816, 1.70353287,
        1.6460708 , 1.59132394, 1.53957212, 1.49098069, 1.44561922,
        1.40348046, 1.36449867, 1.32856657, 1.29554994, 1.26529921,
        1.23765712, 1.21246152, 1.18954273, 1.16871442, 1.14975716,
        1.13239406, 1.11625736, 1.10084533, 1.08546864, 1.06918523,
        1.05072304, 1.02838966, 0.99996803, 0.96259746, 0.91263913]])}, 'samples': {'t': array([0.        , 0.03275862, 0.06551724, 0.09827586, 0.13103448,
       0.1637931 , 0.19655172, 0.22931034, 0.26206897, 0.29482759,
       0.32758621, 0.36034483, 0.39310345, 0.42586207, 0.45862069,
       0.49137931, 0.52413793, 0.55689655, 0.58965517, 0.62241379,
       0.65517241, 0.68793103, 0.72068966, 0.75344828, 0.7862069 ,
       0.81896552, 0.85172414, 0.88448276, 0.91724138, 0.95      ]), 'x': array([0.    , 0.2375, 0.475 , 0.7125, 0.95  ])}}

ขั้นตอนที่ 2 (ถ้าจำเป็น): ปรับปัญหาให้เหมาะสมสำหรับการรันบนฮาร์ดแวร์ควอนตัม

โดยค่าเริ่มต้น solver จะใช้พารามิเตอร์ที่อิงฟิสิกส์ ซึ่งเป็นพารามิเตอร์ Circuit เริ่มต้น สำหรับจำนวน Qubit และความลึกที่กำหนด ซึ่ง solver จะเริ่มต้นจากพารามิเตอร์เหล่านี้

ช็อตก็เป็นส่วนหนึ่งของพารามิเตอร์ด้วยค่าเริ่มต้น เนื่องจากการปรับแต่งมีความสำคัญ

ขึ้นอยู่กับการกำหนดค่าที่ต้องการแก้ พารามิเตอร์ของอัลกอริทึม เพื่อให้ได้คำตอบที่น่าพอใจอาจต้องปรับ เช่น อาจต้องการ Qubit ต่อตัวแปร $t$ และ $x$ มากขึ้นหรือน้อยลง ขึ้นอยู่กับ $a$ และ $b$ ต่อไปนี้ปรับจำนวน Qubit ต่อฟังก์ชันต่อตัวแปร ความลึกต่อฟังก์ชัน และจำนวนช็อต

นอกจากนี้ยังสามารถดูวิธีระบุ Backend และโหมดการรัน

นอกจากนี้ พารามิเตอร์ที่อิงฟิสิกส์อาจนำกระบวนการปรับแต่งไปในทิศทางที่ผิด ในกรณีนั้นสามารถปิดใช้งานได้โดยตั้งค่าสตราเทอีจี initialization เป็น "RANDOM"

job_2 = quick.run(
    use_case="cfd",
    physical_parameters={"a": 0.5, "b": 0.25},
    nb_qubits={"u": {"t": 2, "x": 1}},
    depth={"u": 3},
    shots=[500, 2500, 5000, 10000],
    initialization="RANDOM",
    backend="ibm_kingston",
    mode="session",
)

print(job_2.result())

{'functions': {'u': array([[0.25      , 0.24856543, 0.24687708, 0.2449444 , 0.24277686,
        0.24038389, 0.23777496, 0.23495952, 0.23194702, 0.22874691,
        0.22536866, 0.22182171, 0.21811551, 0.21425952, 0.2102632 ,
        0.20613599, 0.20188736, 0.19752675, 0.19306361, 0.18850741,
        0.18386759, 0.1791536 , 0.17437491, 0.16954096, 0.16466122,
        0.15974512, 0.15480213, 0.1498417 , 0.14487328, 0.13990632],
       [0.36875   , 0.36681313, 0.36457201, 0.36203594, 0.35921422,
        0.35611615, 0.35275103, 0.34912817, 0.34525687, 0.34114643,
        0.33680614, 0.33224532, 0.32747327, 0.32249928, 0.31733266,
        0.31198271, 0.30645873, 0.30077002, 0.29492589, 0.28893564,
        0.28280857, 0.27655397, 0.27018116, 0.26369944, 0.2571181 ,
        0.25044645, 0.24369378, 0.23686941, 0.22998264, 0.22304275],
       [0.4875    , 0.48506084, 0.48226695, 0.47912748, 0.47565158,
        0.47184841, 0.46772711, 0.46329683, 0.45856672, 0.45354594,
        0.44824363, 0.44266894, 0.43683103, 0.43073904, 0.42440212,
        0.41782942, 0.4110301 , 0.4040133 , 0.39678818, 0.38936388,
        0.38174955, 0.37395435, 0.36598742, 0.35785791, 0.34957498,
        0.34114777, 0.33258544, 0.32389713, 0.315092  , 0.30617919],
       [0.60625   , 0.60330854, 0.59996188, 0.59621902, 0.59208895,
        0.58758067, 0.58270318, 0.57746549, 0.57187658, 0.56594545,
        0.55968112, 0.55309256, 0.54618879, 0.53897879, 0.53147158,
        0.52367614, 0.51560147, 0.50725658, 0.49865046, 0.48979211,
        0.48069053, 0.47135472, 0.46179367, 0.45201638, 0.44203186,
        0.4318491 , 0.42147709, 0.41092485, 0.40020136, 0.38931562],
       [0.725     , 0.72155625, 0.71765682, 0.71331056, 0.70852631,
        0.70331293, 0.69767926, 0.69163414, 0.68518643, 0.67834497,
        0.6711186 , 0.66351618, 0.65554655, 0.64721855, 0.63854104,
        0.62952285, 0.62017284, 0.61049986, 0.60051274, 0.59022035,
        0.57963151, 0.56875509, 0.55759992, 0.54617486, 0.53448874,
        0.52255042, 0.51036875, 0.49795257, 0.48531072, 0.47245205]])}, 'samples': {'t': array([0.        , 0.03275862, 0.06551724, 0.09827586, 0.13103448,
       0.1637931 , 0.19655172, 0.22931034, 0.26206897, 0.29482759,
       0.32758621, 0.36034483, 0.39310345, 0.42586207, 0.45862069,
       0.49137931, 0.52413793, 0.55689655, 0.58965517, 0.62241379,
       0.65517241, 0.68793103, 0.72068966, 0.75344828, 0.7862069 ,
       0.81896552, 0.85172414, 0.88448276, 0.91724138, 0.95      ]), 'x': array([0.    , 0.2375, 0.475 , 0.7125, 0.95  ])}}

ขั้นตอนที่ 3: เปรียบเทียบประสิทธิภาพของอัลกอริทึม

สามารถเปรียบเทียบกระบวนการ convergence ของคำตอบ (HDES) จาก job_2 กับประสิทธิภาพของ อัลกอริทึม physics-informed neural networks (PINN) และ solver (ดู งานวิจัย และ GitHub repository ที่เกี่ยวข้อง)

ในตัวอย่างผลลัพธ์ของ job_2 (วิธีการแบบควอนตัม) มีเพียง 13 พารามิเตอร์ (12 พารามิเตอร์ Circuit บวก 1 พารามิเตอร์การปรับสเกล) ที่ถูกปรับแต่งด้วย solver แบบคลาสสิก กระบวนการ convergence มีดังนี้:

optimizers:
   CMA: {'ftarget': np.float64(0.1), 'verb_disp': 10, 'maxiter': 100}
   CMA: {'ftarget': np.float64(0.005), 'verb_disp': 10, 'maxiter': 20}
   CMA: {'ftarget': np.float64(0.0025), 'verb_disp': 10, 'maxiter': 30}
   CMA: {'ftarget': np.float64(0.0005), 'verb_disp': 10, 'maxiter': 10}

500 shots
================== CMA =================
option:  {'ftarget': np.float64(0.1), 'verb_disp': 10, 'maxiter': 100}
0/100, loss: 0.02456641

1000 shots
================== CMA =================
option:  {'ftarget': np.float64(0.005), 'verb_disp': 10, 'maxiter': 20}
0/20, loss: 0.03641833
1/20, loss: 0.02461719
2/20, loss: 0.0283689
3/20, loss: 0.009898383
4/20, loss: 0.04454522
5/20, loss: 0.007019971
6/20, loss: 0.00811147
7/20, loss: 0.01592619
8/20, loss: 0.00764708
9/20, loss: 0.01401516
10/20, loss: 0.01767467
11/20, loss: 0.01220387

5000 shots
================== CMA =================
option:  {'ftarget': np.float64(0.0025), 'verb_disp': 10, 'maxiter': 30}
0/30, loss: 0.01024792
1/30, loss: 0.004343748
2/30, loss: 0.01450951
3/30, loss: 0.008591284
4/30, loss: 0.00266414
5/30, loss: 0.007923613
6/30, loss: 0.02023853
7/30, loss: 0.01031438
8/30, loss: 0.009513116
9/30, loss: 0.008132266
10/30, loss: 0.005787766
11/30, loss: 0.00390582

10000 shots
================== CMA =================
option:  {'ftarget': np.float64(0.0005), 'verb_disp': 10, 'maxiter': 10}
0/10, loss: 0.002386168
1/10, loss: 0.004024823
2/10, loss: 0.001311999
3/10, loss: 0.003433991
4/10, loss: 0.002339664
5/10, loss: 0.002978438
6/10, loss: 0.005458391
7/10, loss: 0.002026701
8/10, loss: 0.00207467
9/10, loss: 0.001947627
final_loss: 0.00151994463476429

นั่นหมายความว่า loss ต่ำกว่า 0.0015 สามารถทำได้ภายใน 28 รอบการทำซ้ำ และโดยการปรับแต่งพารามิเตอร์คลาสสิกเพียงไม่กี่ตัว

ตอนนี้สามารถเปรียบเทียบกับคำตอบ PINN ด้วยการกำหนดค่าเริ่มต้นที่แนะนำโดยงานวิจัยโดยใช้ gradient-based optimizer เทียบเท่าของ Circuit ที่มี 13 พารามิเตอร์ที่ต้องปรับแต่งคือ neural network ซึ่งต้องใช้อย่างน้อยแปดชั้นที่มี 20 นิวรอน จึงต้องปรับแต่งพารามิเตอร์ถึง 3021 ตัว จากนั้น target loss จะถึงจุดนั้นที่ Step 315, loss: 0.0014988397

เพื่อให้การเปรียบเทียบเป็นธรรม ควรใช้ optimizer เดียวกันในทั้งสองกรณี จำนวนรอบการทำซ้ำที่น้อยที่สุดที่พบสำหรับ 12 ชั้นที่มี 20 นิวรอน = 4701 พารามิเตอร์:

(10_w,20)-aCMA-ES (mu_w=5.9,w_1=27%) in dimension 4701 (seed=351961)
Iterat #Fevals   function value  axis ratio  sigma  min&max std  t[m:s]
    1     20 5.398521572351456e-02 1.0e+00 9.98e-03  1e-02  1e-02 0:02.3
    2     40 5.444650724530220e-02 1.0e+00 9.97e-03  1e-02  1e-02 0:05.1
    3     60 4.447407275438309e-02 1.0e+00 9.95e-03  1e-02  1e-02 0:08.2
    4     80 2.068969979882240e-02 1.0e+00 9.94e-03  1e-02  1e-02 0:11.7
    6    120 1.028892211616039e-02 1.0e+00 9.91e-03  1e-02  1e-02 0:20.1
    7    140 5.140972323715687e-03 1.0e+00 9.90e-03  1e-02  1e-02 0:25.4
    9    180 3.811701666563749e-03 1.0e+00 9.87e-03  1e-02  1e-02 0:37.4
   10    200 3.189878538250923e-03 1.0e+00 9.85e-03  1e-02  1e-02 0:44.2
   12    240 2.547040116041899e-03 1.0e+00 9.83e-03  1e-02  1e-02 0:59.7
   14    280 2.166548743844032e-03 1.0e+00 9.80e-03  1e-02  1e-02 1:18.0
   15    300 1.783065614290535e-03 1.0e+00 9.79e-03  1e-02  1e-02 1:28.4
   16    320 2.045844215899706e-03 1.0e+00 9.78e-03  1e-02  1e-02 1:39.8
Stopping early: loss 0.001405 <= target 0.0015
CMA-ES finished. Best loss: 0.001404788694344461

สามารถทำสิ่งเดียวกันกับข้อมูลจาก job_2 และพล็อตการเปรียบเทียบกับคำตอบ PINN

# check the loss function and compare between the two approaches
print(job_2.logs())

ขั้นตอนที่ 4: นำผลลัพธ์ไปใช้

เมื่อได้ผลลัพธ์แล้ว คุณสามารถเลือกทำอะไรกับมันก็ได้ ตัวอย่างด้านล่างแสดงวิธีพล็อตผลลัพธ์

solution = job.result()

# Plot the solution of the second simulation job_2
_ = plt.figure()
ax = plt.axes(projection="3d")

# plot the solution using the 3d plotting capabilities of pyplot
t, x = np.meshgrid(solution["samples"]["t"], solution["samples"]["x"])
ax.plot_surface(
    t,
    x,
    solution["functions"]["u"],
    edgecolor="royalblue",
    lw=0.25,
    rstride=26,
    cstride=26,
    alpha=0.3,
)
ax.scatter(t, x, solution, marker=".")
ax.set(xlabel="t", ylabel="x", zlabel="u(t,x)")

plt.show()

สังเกตความแตกต่างของเงื่อนไขเริ่มต้นในการรันครั้งที่สองและผลกระทบต่อผลลัพธ์:

solution_2 = job_2.result()

# Plot the solution of the second simulation job_2
_ = plt.figure()
ax = plt.axes(projection="3d")

# plot the solution using the 3d plotting capabilities of pyplot
t, x = np.meshgrid(solution_2["samples"]["t"], solution_2["samples"]["x"])
ax.plot_surface(
    t,
    x,
    solution_2["functions"]["u"],
    edgecolor="royalblue",
    lw=0.25,
    rstride=26,
    cstride=26,
    alpha=0.3,
)
ax.scatter(t, x, solution_2, marker=".")
ax.set(xlabel="t", ylabel="x", zlabel="u(t,x)")

plt.show()

แบบสำรวจบทแนะนำ

กรุณาสละเวลาสักครู่เพื่อให้ข้อเสนอแนะเกี่ยวกับบทแนะนำนี้ ความคิดเห็นของคุณจะช่วยให้เราปรับปรุงเนื้อหาและประสบการณ์การใช้งาน:

ลิงก์ไปยังแบบสำรวจ

Note: This survey is provided by IBM Quantum and relates to the original English content. To give feedback on doQumentation's website, translations, or code execution, please open a GitHub issue.