Man kann von Propheten
nicht verlangen,
daß sie immer irren.
Voltaire

Ähnlichkeit von Bahnparametern – Kometengruppen

Verschiedene Kometen und auch Asteroiden können einen gmeinsamen Ursprung haben. Große Kometen zerfallen nach mehreren Umläufen, die kleineren Teile verteilen sich längs der Bahn. Bekanntheit haben die Kreutz- und die Meyer-Gruppe erreicht.

Um der Vermutung nachzuspüren, ob Kometen einen gemeinsamen Ursprung haben, muss man die Bahnparameter vergleichen.Hierzu wurde in Lauf der Zeit verschiedene Maße entwickelt. Für Kometenbahnen hat sich das Verfahren von Jack Drummond bewährt. Er wird auch allgemin für Kometen und Asteroide empfohlen.

Die Drummondsche Distanz D' der Bahnparameter ist 0 bei identischen Bahenen und erreicht den Wert von etwas mehr als 1,80 für maximal verschiedene Bahnen. Eine sinnvolle Grenze für miteinander verbundene Bahnen kann D'<0,1 gewählt werden.

Den Formalsatz kann man dem beiliegenden Python-Programm entnehmen.


# D_Drummond.py
# Abstand von Bahnelementen zuer Berechnung von Kometen-Gruppen
from math import *

# Winkelfunktionen in Gradmaß, wie im Meeus
def Sin(w):      return sin(pi * w / 180)
def Cos(w):      return cos(pi * w / 180)
def Tan(w):      return tan(pi * w / 180)
def Atan2(y, x): return 180 * atan2(y, x) / pi
def Asin(x):     return 180 * asin(x) / pi
def Acos(x):     return 180 * acos(x) / pi
def Atan(x):     return 180 * atan(x) / pi
def sq(x):       return x*x


# Main

# zu vergleichender Komet
e0=0.9999504
i0=144.5098
O0=7.869393
w0=86.46313
q0=0.0054713

# Liste der Kandidaten. Enthält zum Test den zu Vergleichenden (0)
e=[1.0000103, 0.9999449, 1.0002713, 1.0004913, 0.9999504] # e
i=[144.7588, 144.5948, 144.4434, 144.4307, 144.5098]      # i
O=[8.447535, 8.051859 , 6.431115, 6.576461, 7.869393]     # Ω
w=[86.68526, 86.23092, 85.04574, 82.41229, 86.46313]      # ω
q=[0.0053701, 0.0050209, 0.0053103, 0.0069616, 0.0054713] # q

name=["C1880C1", "C1963R1", "C2011N3", "C2012E2", "C2026A1"]

# die Liste gegen den Test
for j in range (0, len(e)):
    beta0=Asin(Sin(i0)*Sin(w0))
    beta=Asin(Sin(i[j])*Sin(w[j]))
    Lambda0=O0+Atan(Cos(i0)*Tan(w0))
    if Lambda0<0: Lambda0+=180
    Lambda=O[j]+Atan(Cos(i[j])*Tan(w[j]))
    if Lambda<0: Lambda+=180
    Theta=Acos(Sin(beta0)*Sin(beta)+Cos(beta0)*Cos(beta)*Cos(Lambda0-Lambda))
    I=Acos(Cos(i0)*Cos(i[j])+Sin(i0)*Sin(i[j])*Cos(O0-O[j]))
    t1=sq((e0-e[j])/(e0+e[j]))
    t2=sq((q0-q[j])/(q0+q[j]))
    t3=sq(I/180)
    t4=sq(0.5*(e0+e[j])*(Theta/180))
    D_D2=t1+t2+t3+t4
    D_D=sqrt(D_D2)
    print(D_D, name[j]) #  D_D zuerst,zum sortieren
print()

# die Liste gegen sich selbst.
for k in range (0, len(e)):
    for j in range (k+1, len(e)):
            beta0=Asin(Sin(i[k])*Sin(w[k]))
            beta=Asin(Sin(i[j])*Sin(w[j]))
            Lambda0=O[k]+Atan(Cos(i[k])*Tan(w[k]))
            if Lambda0<0: Lambda0+=180
            Lambda=O[j]+Atan(Cos(i[j])*Tan(w[j]))
            if Lambda<0: Lambda+=180
            Theta=Acos(Sin(beta0)*Sin(beta)+Cos(beta0)*Cos(beta)*Cos(Lambda0-Lambda))
            I=Acos(Cos(i[k])*Cos(i[j])+Sin(i[k])*Sin(i[j])*Cos(O[k]-O[j]))
            t1=sq((e[k]-e[j])/(e[k]+e[j]))
            t2=sq((q[k]-q[j])/(q[k]+q[j]))
            t3=sq(I/180)
            t4=sq(0.5*(e[k]+e[j])*(Theta/180))
            D_D2=t1+t2+t3+t4
            D_D=sqrt(D_D2)
            print(D_D, name[j], name[k])

Uwe Pilz, Januar 2026