Szabó László István író, költő, az informatika tudományok tanára

2026. június 26., péntek

Tokaji vulkán kitörés modellezése

Egy vulkáni kitörés összetett fizikai folyamat (magma áramlása, gázok terjedése), így a modellezéséhez a Python nyelvben leggyakrabban a numpy és matplotlib csomagokat alkalmazzák a numerikus számításokhoz és az eredmények vizualizációjához.Az alábbi Python szkript egy Tokajhoz hasonló rétegvulkán kitörését szimulálja: lemodellezi a láva terjedését a gravitáció és a domborzat hatására, valamint a vulkáni hamu szélirány szerinti szóródását.

--------------

import numpy as np

import matplotlib.pyplot as plt

def simulacio_vulkan(grid_size=100, kitoresi_intenzitas=500):

# 1. Alapvető paraméterek és domborzat (Magassági mátrix)

# A kráter a mátrix közepén helyezkedik el

domborzat = np.zeros((grid_size, grid_size))

for i in range(grid_size):

for j in range(grid_size):

tav_kozponttol = np.sqrt((i - grid_size/2)**2 + (j - grid_size/2)**2)

# Egy kúp alakú hegy létrehozása (Tokaji-hegyek jellege)

domborzat[i, j] = 500 - tav_kozponttol * 10

if domborzat[i, j] < 0: domborzat[i, j] = 0

# 2. Láva szimuláció (egyszerűsített celluláris automata)

lava = np.zeros((grid_size, grid_size))

krat_x, krat_y = grid_size // 2, grid_size // 2

lava[krat_x, krat_y] = kitoresi_intenzitas

# Láva terjedése a lejtőn lefelé

for _ in range(20): # Szimulációs lépések

uj_lava = lava.copy()

for x in range(1, grid_size-1):

for y in range(1, grid_size-1):

if lava[x, y] > 0:

szomszedok = [

(x+1, y), (x-1, y), (x, y+1), (x, y-1)

]

for sx, sy in szomszedok:

if domborzat[sx, sy] < domborzat[x, y]:

atadas = lava[x, y] * 0.1

uj_lava[x, y] -= atadas

uj_lava[sx, sy] += atadas

lava = uj_lava

# 3. Hamuszórás szimuláció (Gauss-eloszlás a szélirány alapján)

# Tegyük fel, hogy a szél észak-keleti irányba fúj (Tokaj felé)

hamu = np.zeros((grid_size, grid_size))

szel_irany_x = 5

szel_irany_y = 5

for x in range(grid_size):

for y in range(grid_size):

# Távolság a krátertől szélirányban

dx = x - (krat_x + szel_irany_x)

dy = y - (krat_y + szel_irany_y)

tavolsag = np.sqrt(dx**2 + dy**2)

# Hamu vastagságának csökkenése távolsággal

hamu[x, y] = max(0, 1000 - tavolsag * 20)

# 4. Eredmények vizualizációja

fig, ax = plt.subplots(1, 2, figsize=(12, 6))

# Láva megjelenítése

im1 = ax[0].imshow(lava, cmap='hot', origin='lower')

ax[0].set_title("Láva terjedési modell")

ax[0].set_xlabel("X koordináta (km)")

ax[0].set_ylabel("Y koordináta (km)")

fig.colorbar(im1, ax=ax[0], label='Láva vastagság (m)')

# Hamu szóródás megjelenítése

im2 = ax[1].imshow(hamu, cmap='Greys', origin='lower')

ax[1].set_title("Vulkáni hamu lerakódás (Szélirány: ÉK)")

ax[1].set_xlabel("X koordináta (km)")

ax[1].set_ylabel("Y koordináta (km)")

fig.colorbar(im2, ax=ax[1], label='Hamu vastagság (mm)')

plt.tight_layout()

plt.show()

simulacio_vulkan()

---------------------

Mit csinál a program?

A simulacio_vulkan() függvény 4 fő lépést hajt végre:

Domborzat létrehozása

Láva terjedésének szimulálása

Hamu lerakódásának modellezése

Eredmények vizualizálása

A végén meghívja:

simulacio_vulkan()

1) Domborzat létrehozása

domborzat = np.zeros((grid_size, grid_size))

Ez egy grid_size x grid_size méretű mátrix, alapból 0-val feltöltve.

Ezután minden cellára kiszámolja a középponttól való távolságot:

tav_kozponttol = np.sqrt((i - grid_size/2)**2 + (j - grid_size/2)**2)

Majd ehhez rendeli a magasságot:

domborzat[i, j] = 500 - tav_kozponttol * 10

Tehát:

középen magas

kifelé haladva egyre alacsonyabb

ha negatív lenne, 0-ra állítja

Ez gyakorlatilag egy kúpszerű hegyet készít.

Megjegyzés

A komment szerint „Tokaji-hegyek jellege”, de valójában ez csak egy általános kúpmodell, nem valós topográfia.

2) Láva szimuláció

lava = np.zeros((grid_size, grid_size))

krat_x, krat_y = grid_size // 2, grid_size // 2

lava[krat_x, krat_y] = kitoresi_intenzitas

A kráter a rács közepére kerül, és oda kerül a kezdeti lávamennyiség.

Terjedési logika

A program 20 lépésen keresztül szimulálja a terjedést:

for _ in range(20):

Minden aktív cellánál megvizsgálja a 4 szomszédot:

szomszedok = [(x+1, y), (x-1, y), (x, y+1), (x, y-1)]

Ha a szomszéd alacsonyabban van, mint az aktuális cella:

if domborzat[sx, sy] < domborzat[x, y]:

akkor a láva 10%-át átadja:

atadas = lava[x, y] * 0.1

uj_lava[x, y] -= atadas

uj_lava[sx, sy] += atadas

Fontos viselkedés

Ez azt modellezi, hogy a láva lefelé folyik a lejtőn.

Probléma

A modell egyszerűsége miatt:

egy cella több szomszédnak is adhat ugyanabban a körben

a láva gyorsan eloszlik

nem szerepel viszkozitás, hűlés, megszilárdulás

Ez inkább demonstrációs modell, nem fizikai szimuláció.

3) Hamu szóródás

hamu = np.zeros((grid_size, grid_size))

szel_irany_x = 5

szel_irany_y = 5

Itt feltételezi, hogy a szél észak-keleti irányba fúj.

Ezután minden cellára kiszámolja a krátertől való távolságot a szélirány eltolásával:

dx = x - (krat_x + szel_irany_x)

dy = y - (krat_y + szel_irany_y)

tavolsag = np.sqrt(dx**2 + dy**2)

hamu[x, y] = max(0, 1000 - tavolsag * 20)

Mit jelent ez?

a középponthoz közeli területeken vastagabb hamu

távolabb vékonyabb

a szélirány miatt az eloszlás eltolódik

Megjegyzés

Ez nem valódi légköri modell, hanem egy egyszerű Gauss-szerű lecsengés.

4) Vizualizáció

A program két ábrát rajzol:

Láva

im1 = ax[0].imshow(lava, cmap='hot', origin='lower')

hot színskála

alulról induló koordináta-rendszer

Hamu

im2 = ax[1].imshow(hamu, cmap='Greys', origin='lower')

szürke színskála

világosabb/sötétebb területek mutatják a vastagságot

A colorbar segít az értékek értelmezésében.

Erősségek

Egyszerűen érthető

Jól szemlélteti a rácsalapú modellezést

Szép vizualizációt ad

Jó demonstráció arra, hogyan lehet természeti jelenséget modellezni

Gyengeségek

1. Nem fizikai pontosságú

A láva terjedése túl egyszerű:

nincs hőmérséklet

nincs viszkozitás

nincs megszilárdulás

nincs térfogatmegmaradás

2. A hamu szóródás mesterséges

A szélirány csak egy eltolás:

nincs turbulencia

nincs légköri rétegződés

nincs valós terjedési modell

3. A domborzat statikus

A vulkán kitörése nem változtatja meg érdemben a hegy formáját.

4. A kód lassú lehet nagy rácsnál

Két egymásba ágyazott ciklus van több helyen, ami nagyobb grid_size esetén lassú.

Technikai megfigyelések

Importok

import numpy as np

import matplotlib.pyplot as plt

Ezek megfelelőek, nincs hiányzó import.

Paraméterek

A függvény paraméterei:

def simulacio_vulkan(grid_size=100, kitoresi_intenzitas=500):

Ez jó, mert könnyen állítható.

Szintaxis

A kód alapvetően szintaktikailag helyes.

Összegzés

Ez egy szemléltető, oktatási célú vulkánmodell, generál egy kúpszerű domborzatot,

indít egy láva-terjedést a középpontból, létrehoz egy egyszerű hamu-lerakódási mintát,

A Vesta és a Pallas kisbolygók ütközését modellezük python segítségével

Az alábbi Python program a 4 Vesta és a 2 Pallas kisbolygók feltételezett ütközését modellezi a fizikai törvényszerűségek (pl. kinetikus energia, kráterképződés) alapján. A számításokhoz a NumPy könyvtárat használjuk.

----------------

import numpy as np

import matplotlib.pyplot as plt

# --- 1. Alapadatok (Vesta és Pallas) ---

# Tömeg (kg)

m_vesta = 2.59e20

m_pallas = 2.11e20

# Átmérő (km)

d_vesta = 525.4

d_pallas = 512.0

# Ütközési sebesség km/s-ban (tipikus érték a kisbolygóövben)

v_impact_kms = 5.5

v_impact = v_impact_kms * 1000 # m/s

# --- 2. Ütközés modellezése ---

# Kinetikus energia kiszámítása (Joule)

# E = 0.5 * m * v^2

E_k = 0.5 * m_vesta * (v_impact**2)

def calculate_crater_diameter(energy_J, target_diameter_km):

# Egyszerűsített kráterbecslő képlet (skálázási törvények alapján)

# D_c ~ C * E^(1/3.4)

# Referenciaértékek becslése: Vesta kb. 500 km-es krátere (Rheasilvia) alapján

return (energy_J / 1e18)**0.28 * 0.1 * target_diameter_km

# Elemzés eredményei

D_crater = calculate_crater_diameter(E_k, d_vesta)

print("--- Ütközés és Elemzés Eredményei ---")

print(f"Becsült becsapódási energia: {E_k:.3e} Joule")

print(f"Várható kráter átmérő a Vestán: {D_crater:.2f} km")

print(f"Tömegvesztési becslés: A Vesta tömegének kb. 1%-a szabadulhat fel törmelékként.")

# --- 3. Eredmények Vizualizációja (Matplotlib) ---

labels = ['Vesta', 'Pallas', 'Ütközési törmelék (becsült)']

masses = [m_vesta, m_pallas, m_vesta * 0.01]

colors = ['#c79f45', '#5599cc', '#e25c5c']

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 6))

# Tömeg összehasonlítás

ax1.bar(labels, masses, color=colors)

ax1.set_title('Testek tömegének összehasonlítása (kg)')

ax1.set_ylabel('Tömeg (kg)')

ax1.set_yscale('log')

# Becsapódási energia vizualizáció

energies = [0.5 * m_vesta * v_impact**2, 0.5 * m_pallas * v_impact**2]

ax2.bar(['Vesta által kapott', 'Pallas által kapott'], energies, color=['#c79f45', '#5599cc'])

ax2.set_title('Becsapódási kinetikus energia (Joule)')

ax2.set_ylabel('Energia (J)')

ax2.set_yscale('log')

plt.tight_layout()

plt.show()

-------------------------

--- Ütközés és Elemzés Eredményei ---

Becsült becsapódási energia: 3.917e+27 Joule

Várható kráter átmérő a Vestán: 25499.33 km

Tömegvesztési becslés: A Vesta tömegének kb. 1%-a szabadulhat fel törmelékként.

A nagy hadron ütköztető

Ez a program Monte-Carlo szimulációt valósít meg, amely modellezi a részecskék (pl. protonok) gyorsítását, majd azok szembekapcsolását és ütközését a hadron ütköztetőben.

--------

import random

import math

import matplotlib.pyplot as plt

class HadronUtkozteto:

def __init__(self, nev: str, kor_sugar_m: float, max_energia_tev: float):

self.nev = nev

self.sugar = kor_sugar_m # Gyorsító gyűrű sugara (méterben)

self.max_energia = max_energia_tev # Maximális elérhető energia TeV-ben

self.nyalabok = []

def nyalab_feltoltes(self, reszecske_szam: int, energia_tev: float):

"""Feltölti a gyorsítót proton nyalábokkal."""

energia = min(energia_tev, self.max_energia)

self.nyalabok.append({

"resztvevok": reszecske_szam,

"energia": energia,

"vektor": 1 # 1 = óramutató járása szerint, -1 = ellenkezőleg

})

print(f"{self.nev} feltöltve: {reszecske_szam} részecske, egyenként {energia} TeV energiával.")

def utkozes(self):

"""Modellezi a két nyaláb frontális ütközését."""

if len(self.nyalabok) < 2:

print("Hiba: Az ütközéshez két ellentétes irányú nyaláb szükséges!")

return

nyalab1 = self.nyalabok[0]

nyalab2 = self.nyalabok[1]

# Összenergia a tömegközépponti rendszerben sqrt(s)

sqrt_s = 2 * nyalab1["energia"]

print(f"Ütközés történt! Összenergia: {sqrt_s:.2f} TeV")

# Egyszerűsített Monte-Carlo részecske generálás az ütközéshez

utkozesi_termekek = []

# Tömegközépponti energia konvertálása GeV-re (1 TeV = 1000 GeV)

hatar_energiak = [random.uniform(0.1, sqrt_s * 1000 / 2) for _ in range(500)]

for e in hatar_energiak:

# Statisztikai eloszlás az új részecskékre

if e < 500: utkozesi_termekek.append("Pion")

elif e < 800: utkozesi_termekek.append("Kaon")

elif e < 950: utkozesi_termekek.append("Proton")

else: utkozesi_termekek.append("Higgs / Z / W bozon")

return utkozesi_termekek

# --- Szimuláció futtatása ---

# 1. Ütköztető létrehozása (pl. LHC paramétereihez hasonlóan)

lhc = HadronUtkozteto(nev="Nagy Hadronütközztető (LHC)", kor_sugar_m=4267, max_energia_tev=7.0)

# 2. Nyalábok indítása

lhc.nyalab_feltoltes(reszecske_szam=10000, energia_tev=6.5)

# 3. Ütközés modellezése és az eredmények statisztikája

termekek = lhc.utkozes()

# 4. Vizualizáció (Eredmények összesítése tortadiagrammon)

if termekek:

kategoriak = {}

for t in termekek:

kategoriak[t] = kategoriak.get(t, 0) + 1

plt.figure(figsize=(8, 6))

plt.pie(kategoriak.values(), labels=kategoriak.keys(), autopct='%1.1f%%', startangle=140)

plt.title("Ütközés során keletkezett részecskék eloszlása")

plt.axis('equal')

plt.show()

----------------

Nagy Hadronütközztető (LHC) feltöltve: 10000 részecske, egyenként 6.5 TeV energiával.

Ütközés történt! Összenergia: 13.00 TeV

Járványok terjedésének modellezése

A járványok terjedésének modellezésére a legelterjedtebb matematikai eszköz az úgynevezett SIR (Fogékony, Fertőző, Gyógyult) modell. Ezzel a dinamikus rendszerrel szimulálható a betegség terjedése, a csúcspontok elérése és a lefolyás időtartama.A kipusztulás (amikor mindenki megfertőződik és belehal) egy speciális, végzetes forgatókönyv, ami akkor következik be, ha a betegség halálozási rátája $100\%$

-----------

import numpy as np

import matplotlib.pyplot as plt

from scipy.integrate import odeint

# 1. A modell paraméterei

N = 8000000000 # Kezdeti összlakosság (pl. 8 milliárd)

I0 = 1 # Kezdeti fertőzöttek száma

R0 = 0 # Kezdeti gyógyultak/halottak száma

S0 = N - I0 - R0 # Kezdeti fogékonyak száma

beta = 0.4 # Fertőzési ráta (kontaktusok száma * fertőzési esély)

gamma = 0.1 # Átlagos gyógyulási ráta (itt: 1/10 nap)

mortality_rate = 1.0 # Halálozási ráta (1.0 = minden fertőzött meghal)

# 2. A differenciálegyenlet-rendszer (SIR modell)

def sir_model(y, t, N, beta, gamma, mortality):

S, I, R = y

# Fogékonyak számának változása

dSdt = -beta * S * I / N

# Fertőzöttek számának változása

dIdt = (beta * S * I / N) - (gamma * I)

# Gyógyultak és halottak számának változása

dRdt = gamma * I * mortality

return dSdt, dIdt, dRdt

# 3. Időtartomány meghatározása (pl. 300 nap)

t = np.linspace(0, 300, 301)

# 4. A szimuláció futtatása

y0 = S0, I0, R0

ret = odeint(sir_model, y0, t, args=(N, beta, gamma, mortality_rate))

S, I, R = ret.T

# 5. Eredmények vizualizációja

plt.figure(figsize=(10, 6))

plt.plot(t, S, 'b', alpha=0.7, linewidth=2, label='Fogékony (Susceptible)')

plt.plot(t, I, 'r', alpha=0.7, linewidth=2, label='Fertőzött (Infected)')

plt.plot(t, R, 'k', alpha=0.7, linewidth=2, label='Elhunyt (Dead/Removed)')

plt.title('Járvány terjedése és az emberiség kipusztulása', fontsize=14)

plt.xlabel('Idő (nap)', fontsize=12)

plt.ylabel('Népesség', fontsize=12)

plt.ylim(0, N + N*0.1)

plt.legend(loc='best')

plt.grid(True, linestyle='--', alpha=0.6)

plt.show()

# 6. Mennyi ideig tart?

# Megkeressük azt a napot, amikor a fertőzöttek száma 0 alá csökken

infection_days = np.where(I < 1)[0]

if len(infection_days) > 0:

end_day = np.max(infection_days)

print(f"A szimuláció szerint a járvány lefolyása: {end_day} nap.")

else:

print("A járvány nem ért véget a vizsgált időszakon belül.")

---------

A járvány 5 év alatt teljesen kiírtja az emberi fajt.

------------

Könyvek

https://mek.oszk.hu/08400/08435/08435.pdf

https://mtmi.unideb.hu/pluginfile.php/554/mod_resource/content/3/thinkcspy3.pdf

Atomtámadás hatásának modellezése

Az alábbi Python program a nukleáris fegyverek hatásait (hőhatás, lökéshullám, kezdeti sugárzás) modellezi a cube-root scalingot alkalmazva. A program kiszámítja az egyes pusztítási zónák sugarait egy megadott robbanási energia alapján:

---------

import math

class NuclearExplosionModel:

def __init__(self, yield_ktons):

"""

:param yield_ktons: A robbanás ereje kilotonnában (pl. 15 = Hiroshima)

"""

self.yield_ktons = yield_ktons

# Skálázási tényező (cube-root scaling)

self.scale_factor = math.pow(self.yield_ktons, 1/3)

def calculate_fireball_radius(self):

"""Tűzgömb sugara (hőhatás kezdete) méterben."""

return 670 * self.scale_factor

def calculate_blast_overpressure_radius(self, psi=5):

"""

Lökéshullám hatótávolsága méterben.

Alapértelmezetten az 5 PSI (súlyos épületkárok és emberi sérülések) zónát számolja.

"""

if psi == 20: # 20 PSI: Vasbeton épületek megsemmisülése

return 370 * self.scale_factor

elif psi == 5: # 5 PSI: Átlagos épületek összeomlása

return 740 * self.scale_factor

elif psi == 1: # 1 PSI: Ablaküvegek betörése

return 2130 * self.scale_factor

return 0

def calculate_radiation_radius(self, dose_Sv=5):

"""

Kezdeti ionizáló sugárzás hatótávolsága méterben (5 Sv halálos dózis).

"""

if dose_Sv == 5:

return 1100 * self.scale_factor

return 0

def print_report(self):

print(f"--- Atomcsapás Modell: {self.yield_ktons} kt TNT ---")

print(f"1. Tűzgömb sugara: ~{self.calculate_fireball_radius():.2f} m")

print(f"2. Lökéshullám (20 PSI - Teljes pusztulás): ~{self.calculate_blast_overpressure_radius(20):.2f} m")

print(f"3. Lökéshullám (5 PSI - Épületek dőlnek): ~{self.calculate_blast_overpressure_radius(5):.2f} m")

print(f"4. Lökéshullám (1 PSI - Ablakok törnek): ~{self.calculate_blast_overpressure_radius(1):.2f} m")

print(f"5. Ionizáló sugárzás (5 Sv - Halálos): ~{self.calculate_radiation_radius(5):.2f} m")

# Modell futtatása példa adattal (pl. 50 kilotonnás robbanás)

if __name__ == "__main__":

nuke = NuclearExplosionModel(yield_ktons=50)

nuke.print_report()

------------

--- Atomcsapás Modell: 50 kt TNT ---

1. Tűzgömb sugara: ~2468.30 m

2. Lökéshullám (20 PSI - Teljes pusztulás): ~1363.09 m

3. Lökéshullám (5 PSI - Épületek dőlnek): ~2726.18 m

4. Lökéshullám (1 PSI - Ablakok törnek): ~7846.99 m

5. Ionizáló sugárzás (5 Sv - Halálos): ~4052.43 m

----------

import numpy as np

import matplotlib.pyplot as plt

def nuklearis_modell(hatohato_kt, robbanasi_magassag_m=0):

"""

Atomeffektusok számítása (egyszerűsített skálázási törvények alapján).

hatohato_kt: Robbanóerő kilotonnában

robbanasi_magassag_m: Felszíni robbanás esetén 0

"""

# Hatósugarak számítása (közelítő empirikus képletek)

# Tűzgolyó sugara (km)

tuzgolyo = 0.16 * (hatohato_kt ** 0.38)

# 20 psi (súlyos épületkárok, zóna közepe)

psi_20 = 0.45 * (hatohato_kt ** 0.33)

# 5 psi (közepes épületkárok, légnyomás)

psi_5 = 0.98 * (hatohato_kt ** 0.33)

# 1 psi (ablaküveg törések, könnyű sérülések)

psi_1 = 2.45 * (hatohato_kt ** 0.33)

# Hősugárzás (3. fokozatú égési sérülések)

ho_sugar = 1.0 * (hatohato_kt ** 0.41)

return {

'tuzgolyo': tuzgolyo,

'psi_20': psi_20,

'psi_5': psi_5,

'psi_1': psi_1,

'ho_sugar': ho_sugar

}

def szimulacio_megjelenites(hatohato_kt):

adatok = nuklearis_modell(hatohato_kt)

# Vizuális körök beállítása

sugarak = [

('Tűzgolyó (minden elpárolog)', adatok['tuzgolyo'], 'darkred'),

('20 psi Túlnyomás (pusztító)', adatok['psi_20'], 'red'),

('5 psi Túlnyomás (súlyos kár)', adatok['psi_5'], 'orange'),

('Hősugárzás (3. fokú égés)', adatok['ho_sugar'], 'gold'),

('1 psi Túlnyomás (ablakok törnek)', adatok['psi_1'], 'yellow')

]

fig, ax = plt.subplots(figsize=(8, 8))

ax.set_facecolor('lightgray')

# Körök rajzolása

for nev, sugar, szin in reversed(sugarak):

circle = plt.Circle((0, 0), sugar, color=szin, alpha=0.5, label=f"{nev} ({sugar:.2f} km)")

ax.add_patch(circle)

# Célpont (epicentrum)

ax.plot(0, 0, 'kX', markersize=10, label="Epicentrum (becsapódási pont)")

# Grafikon beállítások

max_sugar = adatok['psi_1'] * 1.2

ax.set_xlim(-max_sugar, max_sugar)

ax.set_ylim(-max_sugar, max_sugar)

ax.set_aspect('equal')

ax.set_title(f"Atomcsapás szimulációja ({hatohato_kt} kt robbanóerő)\n Hatósugarak kilométerben", fontsize=14)

ax.set_xlabel("X távolság (km)")

ax.set_ylabel("Y távolság (km)")

# Jelmagyarázat és rács

ax.legend(loc='upper right', bbox_to_anchor=(1.35, 1))

ax.grid(True, linestyle='--', alpha=0.6)

plt.tight_layout()

plt.show()

# --- Szimuláció futtatása ---

# Példa egy tipikus kisebb taktikai atomfegyverre (pl. 15 kilotonna - Hirosima méret)

valasztott_kt = 15

print(f"{valasztott_kt} kilotonnás nukleáris robbanás hatásainak vizualizációja...")

szimulacio_megjelenites(valasztott_kt)

---------------

15 kilotonnás nukleáris robbanás hatásainak vizualizációja...

------------------

Könyvek

https://mek.oszk.hu/08400/08435/08435.pdf

https://mtmi.unideb.hu/pluginfile.php/554/mod_resource/content/3/thinkcspy3.pdf

A mohácsi csata sztochasztikus determinisztikus harcászati szimulációja

A mohácsi csata (1526. augusztus 29.) modellezése kiváló példa a sztochasztikus (véletlen faktorokat is tartalmazó) események és a determinisztikus harcászati szabályok kombinálására objektumorientált (OOP) Python programozásban. Az alábbi komplex, mégis átlátható mintakód a csata főbb fázisait (tüzérségi támadás, lovasroham, gyalogsági harc) szimulálja le, figyelembe véve a létszámot, a terepviszonyokat és a véletlenszerű harci eseményeket (morál, taktikai döntések). A szimuláció főbb lépései (OOP megközelítésben):Egység (Unit): Osztály a seregek (magyar és oszmán) csapatainak (gyalogság, lovasság, tüzérség) reprezentálására.Hadsereg (Army): Kezeli az egységeket, összesíti a morált és a létszámot.Csata (Battle): Szimulálja a fázisokat (köröket), ahol a sebzés a létszám, a fegyverzet és a szerencsefaktor alapján kerül kiszámításra. A mohácsi csata taktikai modellezését Pythonban legkönnyebben egy objektumorientált szimulációval (OOP) vagy egy ügynökalapú modellező keretrendszerrel (pl. Mesa) valósíthatjuk meg. Az alábbiakban egy olyan leegyszerűsített, de harcászatilag szemléletes Python-példát mutatok be, amely az alapvető tényezőket (létszám, fegyverzet, terep, morál) veszi alapul.Koncepcionális modell. A harcászati szimuláció az alábbi főbb paramétereket veszi figyelembe:Egységek (Units): Név, létszám, morál, sebzés (tűzerő/közelharc) és védelem.Interakció: A csata körökre (turn) van osztva. Minden körben a szembenálló felek támadást indítanak egymás ellen, figyelembe véve a veszteségeket és a morál csökkenését.A csata legfőbb taktikai elemei – mint a magyar lovasság elsöprő erejű rohama vagy a török janicsárok tűzfegyvereinek hatékonysága és a tüzérség – a megfelelő statisztikai értékekkel modellezhetők .

------------

import random

class Egyseg:

def __init__(self, nev, letszam, tamadas_ero, vedelem, tipus):

self.nev = nev

self.letszam = letszam

self.alap_letszam = letszam

self.tamadas_ero = tamadas_ero

self.vedelem = vedelem

self.tipus = tipus # 'gyalogsag', 'lovas', 'tuzerseg'

self.moral = 1.0 # 0.0 és 1.0 között

def tamad(self, celpont):

if self.letszam <= 0:

return 0

# Alapsebzés

sebzes = int(self.letszam * self.tamadas_ero * random.uniform(0.8, 1.2))

# Taktikai módosítók (pl. lovasroham gyalogság ellen)

if self.tipus == 'lovas' and celpont.tipus == 'gyalogsag':

sebzes = int(sebzes * 1.5)

elif self.tipus == 'tuzerseg':

sebzes = int(sebzes * 1.8)

# Védelem és morál levonása

elszivott_sebzes = max(0, sebzes - int(celpont.vedelem * 0.5))

elszivott_sebzes = int(elszivott_sebzes * self.moral)

# Sebzés alkalmazása a célponton

celpont.letszam = max(0, celpont.letszam - elszivott_sebzes)

return elszivott_sebzes

def serules(self, mertek):

self.letszam = max(0, self.letszam - mertek)

# Morál csökkenése a veszteségek arányában

self.moral = max(0.2, self.letszam / self.alap_letszam)

class Hadsereg:

def __init__(self, nev):

self.nev = nev

self.egysegek = []

def hozzaad_egyseg(self, egyseg):

self.egysegek.append(egyseg)

def elo_egysegek(self):

return [e for e in self.egysegek if e.letszam > 0]

def ossz_letszam(self):

return sum(e.letszam for e in self.egysegek)

class MohacsiCsataSzimulacio:

def __init__(self):

# Magyar sereg adatai (becslések alapján)

self.magyarok = Hadsereg("Magyar Királyi Sereg")

self.magyarok.hozzaad_egyseg(Egyseg("Könnyűlovasság", 4000, 1.2, 10, 'lovas'))

self.magyarok.hozzaad_egyseg(Egyseg("Nehézlovasság", 5000, 2.0, 30, 'lovas'))

self.magyarok.hozzaad_egyseg(Egyseg("Gyalogság", 15000, 0.8, 15, 'gyalogsag'))

self.magyarok.hozzaad_egyseg(Egyseg("Tüzérség (Ágyúk)", 85, 3.0, 5, 'tuzerseg'))

# Oszmán sereg adatai (becslések alapján)

self.torokok = Hadsereg("Oszmán Birodalmi Sereg")

self.torokok.hozzaad_egyseg(Egyseg("Akıncı (Könnyűlovasság)", 7000, 1.1, 12, 'lovas'))

self.torokok.hozzaad_egyseg(Egyseg("Szpáhi (Nehézlovasság)", 8000, 2.2, 35, 'lovas'))

self.torokok.hozzaad_egyseg(Egyseg("Janicsárok (Gyalogság)", 12000, 1.6, 25, 'gyalogsag'))

self.torokok.hozzaad_egyseg(Egyseg("Szultáni Gárda és Tüzérség", 8000, 2.5, 40, 'tuzerseg'))

def inditas(self):

print("=== A MOHÁCSI CSATA (1526. augusztus 29.) MODELLEZÉSE ===\n")

# 1. Fázis: Tüzérségi párbaj

print("--- 1. FÁZIS: Tüzérségi tűzváltás ---")

self.csata_faze("Tüzérség")

# 2. Fázis: Lovasrohamok

print("\n--- 2. FÁZIS: Lovasroham és összecsapás ---")

self.csata_faze("lovas")

# 3. Fázis: Általános gyalogsági harc és visszavonulás

print("\n--- 3. FÁZIS: Gyalogsági harc és a csata vége ---")

self.csata_faze("gyalogsag")

# Eredmény hirdetése

self.eredmeny_hirdetes()

def csata_faze(self, fegyvernem_szures):

for m_egyseg in self.magyarok.elo_egysegek():

if fegyvernem_szures == "Tüzérség" and m_egyseg.tipus != "tuzerseg": continue

if fegyvernem_szures == "lovas" and m_egyseg.tipus != "lovas": continue

if fegyvernem_szures == "gyalogsag" and m_egyseg.tipus != "gyalogsag": continue

for t_egyseg in self.torokok.elo_egysegek():

if fegyvernem_szures == "Tüzérség" and t_egyseg.tipus != "tuzerseg": continue

if fegyvernem_szures == "lovas" and t_egyseg.tipus != "lovas": continue

sebzes = m_egyseg.tamad(t_egyseg)

print(f"{m_egyseg.nev} támadja a(z) {t_egyseg.nev} egységet. Oszmán veszteség: {sebzes} fő.")

# Visszacsapás

for t_egyseg in self.torokok.elo_egysegek():

for m_egyseg in self.magyarok.elo_egysegek():

sebzes = t_egyseg.tamad(m_egyseg)

print(f"{t_egyseg.nev} támadja a(z) {m_egyseg.nev} egységet. Magyar veszteség: {sebzes} fő.")

print(f"Állás - Magyarok: {self.magyarok.ossz_letszam()} fő | Oszmánok: {self.torokok.ossz_letszam()} fő")

def eredmeny_hirdetes(self):

print("\n=== CSATA VÉGE ===")

m_maradek = self.magyarok.ossz_letszam()

t_maradek = self.torokok.ossz_letszam()

print(f"Magyar seregek túlélői: {m_maradek} harcos.")

print(f"Oszmán seregek túlélői: {t_maradek} harcos.")

if m_maradek > t_maradek:

print("GYŐZELEM: A magyar sereg nyerte a csatát!")

elif m_maradek < t_maradek:

print("VERESÉG: Az oszmán sereg győzedelmeskedett (történelmi hűség).")

else:

print("Döntetlen! A csatatér vértől ázva elhagyatott.")

# A szimuláció futtatása

if __name__ == "__main__":

szim = MohacsiCsataSzimulacio()

szim.inditas()

-------------------

=== A MOHÁCSI CSATA (1526. augusztus 29.) MODELLEZÉSE ===

--- 1. FÁZIS: Tüzérségi tűzváltás ---

Tüzérség (Ágyúk) támadja a(z) Szultáni Gárda és Tüzérség egységet. Oszmán veszteség: 469 fő.

Akıncı (Könnyűlovasság) támadja a(z) Könnyűlovasság egységet. Magyar veszteség: 8324 fő.

Akıncı (Könnyűlovasság) támadja a(z) Nehézlovasság egységet. Magyar veszteség: 6282 fő.

Akıncı (Könnyűlovasság) támadja a(z) Gyalogság egységet. Magyar veszteség: 10298 fő.

Akıncı (Könnyűlovasság) támadja a(z) Tüzérség (Ágyúk) egységet. Magyar veszteség: 7419 fő.

Szpáhi (Nehézlovasság) támadja a(z) Gyalogság egységet. Magyar veszteség: 22574 fő.

Állás - Magyarok: 0 fő | Oszmánok: 34531 fő

--- 2. FÁZIS: Lovasroham és összecsapás ---

Állás - Magyarok: 0 fő | Oszmánok: 34531 fő

--- 3. FÁZIS: Gyalogsági harc és a csata vége ---

Állás - Magyarok: 0 fő | Oszmánok: 34531 fő

=== CSATA VÉGE ===

Magyar seregek túlélői: 0 harcos.

Oszmán seregek túlélői: 34531 harcos.

VERESÉG: Az oszmán sereg győzedelmeskedett (történelmi hűség).

------------------

import random

class Hadsereg:

def __init__(self, nev, gyalogsag, lovassag, agyuk):

self.nev = nev

self.gyalogsag = gyalogsag

self.lovassag = lovassag

self.agyuk = agyuk

self.moral = 1.0 # Kezdeti morál

@property

def ossz_ero(self):

return self.gyalogsag + (self.lovassag * 1.5) + (self.agyuk * 10)

def veszteseg(self, szazalek):

self.gyalogsag = int(self.gyalogsag * (1 - szazalek))

self.lovassag = int(self.lovassag * (1 - szazalek))

self.agyuk = int(self.agyuk * (1 - szazalek))

class MohacsiCsataSzimulacio:

def __init__(self):

# Történelmi adatok alapján meghatározott kezdeti létszámok

self.magyarok = Hadsereg("Magyar Királyság", 13000, 13000, 85)

self.torokok = Hadsereg("Oszmán Birodalom", 45000, 20000, 300)

def csata_inditasa(self):

print("--- MOHÁCSI CSATA SZIMULÁCIÓ (1526. AUGUSZTUS 29.) ---")

# 1. FÁZIS: Tomori taktikája - Magyar lovasroham a ruméliai hadtest ellen

self.fzis_1_tamadas()

# 2. FÁZIS: Janicsárok puskatüze és török ellentámadás

self.fzis_2_janicsar_vedelem()

# 3. FÁZIS: Végső felmorzsolódás

self.fzis_3_befejezes()

def fzis_1_tamadas(self):

print("\n[1. Fázis] A magyar hadsereg (Tomori Pál) támadást indít a ruméliai seregek ellen.")

# A magyarok kezdeményeznek, előnyben a lovasság

esely = min(0.85, self.magyarok.ossz_ero / self.torokok.ossz_ero)

if random.random() < esely:

print("-> A magyar lovasroham áttöri a ruméliaiak első vonalát!")

self.torokok.veszteseg(0.15)

else:

print("-> A török védvonalak tartanak.")

def fzis_2_janicsar_vedelem(self):

print("\n[2. Fázis] Az oszmán janicsárok megkezdik a puskatüzet, az anatóliai erők bekerítenek.")

# A török tüzérség és a janicsárok túlereje érvényesül

esely = min(0.9, self.torokok.ossz_ero / self.magyarok.ossz_ero)

if random.random() < esely:

print("-> A janicsárok puskatüze megakasztja a magyar rohamot, a törökök ellentámadásba lendülnek.")

self.magyarok.veszteseg(0.40)

else:

print("-> A magyarok hősiesen tartják pozícióikat.")

def fzis_3_befejezes(self):

print("\n[3. Fázis] A csata lezárása és a menekülés.")

self.magyarok.veszteseg(0.60) # Történelmi megsemmisülés

self.torokok.veszteseg(0.10)

print("\n--- CSATA VÉGE ---")

print(f"Magyar seregek megmaradt harcosai: {self.magyarok.gyalogsag + self.magyarok.lovassag} fő.")

print(f"Oszmán seregek megmaradt harcosai: {self.torokok.gyalogsag + self.torokok.lovassag} fő.")

print("\nEredmény: Döntő oszmán győzelem. Magyarország hadereje megsemmisült, II. Lajos király a Csele-patakba fulladt.")

# A szimulacio futtatasa

szim = MohacsiCsataSzimulacio()

szim.csata_inditasa()

-----------------

--- MOHÁCSI CSATA SZIMULÁCIÓ (1526. AUGUSZTUS 29.) ---

[1. Fázis] A magyar hadsereg (Tomori Pál) támadást indít a ruméliai seregek ellen.

-> A magyar lovasroham áttöri a ruméliaiak első vonalát!

[2. Fázis] Az oszmán janicsárok megkezdik a puskatüzet, az anatóliai erők bekerítenek.

-> A magyarok hősiesen tartják pozícióikat.

[3. Fázis] A csata lezárása és a menekülés.

--- CSATA VÉGE ---

Magyar seregek megmaradt harcosai: 10400 fő.

Oszmán seregek megmaradt harcosai: 49725 fő.

Eredmény: Döntő oszmán győzelem. Magyarország hadereje megsemmisült, II. Lajos király a Csele-patakba fulladt.

-----------

import random

class Egyseg:

def __init__(self, nev, letszam, tamadas, vedelem, moral):

self.nev = nev

self.letszam = letszam

self.alap_letszam = letszam

self.tamadas = tamadas

self.vedelem = vedelem

self.moral = moral

self.allapot = "Harcol"

def tamad(self, celpont):

if self.allapot == "Futás" or self.allapot == "Megsemmisült":

return 0

sebzes = int(self.tamadas * self.letszam * (self.moral / 100))

elszenvedett_sebzes = max(0, sebzes - celpont.vedelem)

celpont.veszit(elszenvedett_sebzes)

return elszenvedett_sebzes

def veszit(self, veszteseg):

if veszteseg > 0:

self.letszam = max(0, self.letszam - veszteseg)

veszteseg_szazalek = (veszteseg / self.alap_letszam) * 100

self.moral = max(10, self.moral - veszteseg_szazalek)

if self.letszam == 0:

self.allapot = "Megsemmisült"

elif self.moral < 30:

self.allapot = "Futás"

@property

def veszteseg(self):

return self.alap_letszam - self.letszam

magyar_tuzerseg = Egyseg("Magyar tüzérség és gyalogság", 4000, tamadas=120, vedelem=20, moral=80)

magyar_lovas = Egyseg("Magyar nehézlovasság", 10000, tamadas=250, vedelem=50, moral=90)

magyar_zaszlok = [magyar_tuzerseg, magyar_lovas]

torok_elcsapat = Egyseg("Török előhad (Ruméliaiak)", 15000, tamadas=100, vedelem=30, moral=70)

torok_janicsar = Egyseg("Janicsárok (Tűzfegyverek)", 12000, tamadas=220, vedelem=40, moral=95)

torok_szuzerseg = Egyseg("Oszmán tüzérség", 3000, tamadas=150, vedelem=10, moral=85)

torok_zaszlok = [torok_elcsapat, torok_janicsar, torok_szuzerseg]

print("--- A mohácsi csata szimulációja indul ---\n")

for kor in range(1, 10):

print(f"--- {kor}. Kör ---")

for mg_egyseg in magyar_zaszlok:

for tr_egyseg in torok_zaszlok:

sebzes = mg_egyseg.tamad(tr_egyseg)

print(f"{mg_egyseg.nev} támadja a következőt: {tr_egyseg.nev}. Okozat: {sebzes} veszteség.")

for tr_egyseg in torok_zaszlok:

for mg_egyseg in magyar_zaszlok:

sebzes = tr_egyseg.tamad(mg_egyseg)

print(f"{tr_egyseg.nev} támadja a következőt: {mg_egyseg.nev}. Okozat: {sebzes} veszteség.")

print("\n--- Állapotok a kör végén ---")

for egyseg in magyar_zaszlok + torok_zaszlok:

print(f"{egyseg.nev} | Létszám: {egyseg.letszam} | Morál: {int(egyseg.moral)} | Státusz: {egyseg.allapot}")

print("\n")

print("--- Szimuláció vége ---")

------------

--- A mohácsi csata szimulációja indul ---

--- 1. Kör ---

Magyar tüzérség és gyalogság támadja a következőt: Török előhad (Ruméliaiak). Okozat: 383970 veszteség.

Magyar tüzérség és gyalogság támadja a következőt: Janicsárok (Tűzfegyverek). Okozat: 383960 veszteség.

Magyar tüzérség és gyalogság támadja a következőt: Oszmán tüzérség. Okozat: 383990 veszteség.

Magyar nehézlovasság támadja a következőt: Török előhad (Ruméliaiak). Okozat: 2249970 veszteség.

Magyar nehézlovasság támadja a következőt: Janicsárok (Tűzfegyverek). Okozat: 2249960 veszteség.

Magyar nehézlovasság támadja a következőt: Oszmán tüzérség. Okozat: 2249990 veszteség.

Török előhad (Ruméliaiak) támadja a következőt: Magyar tüzérség és gyalogság. Okozat: 0 veszteség.

Török előhad (Ruméliaiak) támadja a következőt: Magyar nehézlovasság. Okozat: 0 veszteség.

Janicsárok (Tűzfegyverek) támadja a következőt: Magyar tüzérség és gyalogság. Okozat: 0 veszteség.

Janicsárok (Tűzfegyverek) támadja a következőt: Magyar nehézlovasság. Okozat: 0 veszteség.

Oszmán tüzérség támadja a következőt: Magyar tüzérség és gyalogság. Okozat: 0 veszteség.

Oszmán tüzérség támadja a következőt: Magyar nehézlovasság. Okozat: 0 veszteség.

--- Állapotok a kör végén ---

Magyar tüzérség és gyalogság | Létszám: 4000 | Morál: 80 | Státusz: Harcol

Magyar nehézlovasság | Létszám: 10000 | Morál: 90 | Státusz: Harcol

Török előhad (Ruméliaiak) | Létszám: 0 | Morál: 10 | Státusz: Megsemmisült

Janicsárok (Tűzfegyverek) | Létszám: 0 | Morál: 10 | Státusz: Megsemmisült

Oszmán tüzérség | Létszám: 0 | Morál: 10 | Státusz: Megsemmisült

--- 2. Kör ---