खगोल यंत्र to Physics Engine: वैदिक Celestial Mechanics Meet Simulation Rules

📅 एप्रिल २०२६ | 🏷️ Khagola Yantra · Celestial Mechanics · Orbital Algorithms · Nakshatra Grid · Yuga Cycles · Physics Engine · Gravitational Simulation

१. खगोल यंत्र म्हणजे काय? वैदिक-तांत्रिक संदर्भ

वैदिक परंपरेत खगोल यंत्र हे केवळ निरीक्षणाचे साधन नाही, तर एक परिष्कृत celestial simulation framework आहे. ही प्रणाली ग्रहांची गती, नक्षत्रांचे ग्रिड, आणि कालचक्रांचे मॉडेलिंग एका गणितीय कोडमध्ये एन्कोड करते.

सूर्यसिद्धांत आणि आर्यभटीय मध्ये हे नियम गणितीय सूत्रांमध्ये एन्कोड केले आहेत — हे आजच्या physics engine प्रमाणेच काम करतात.

२. खगोल यंत्र → Physics Engine Rules Mapping

३. गणितीय मॉडेल: Celestial Mechanics Functions

## Nakshatra Grid Coordinate System

# 27 nakshatras = 360° / 27 = 13°20' each
nakshatra_index = floor(celestial_longitude / 13.3333)
within_nakshatra = celestial_longitude % 13.3333  # 0-13.33° position

## Planetary Orbital Motion (Simplified Keplerian)

# Mean anomaly: M = M₀ + n × t
# where n = mean motion = 2π / orbital_period

# Eccentric anomaly (iterative):
E = M + e × sin(E)  # Solve via Newton-Raphson

# True anomaly (actual position):
ν = 2 × atan2(√(1+e) × sin(E/2), √(1-e) × cos(E/2))

# Heliocentric distance:
r = a × (1 - e × cos(E))

जिथे:
  M   = Mean anomaly (average angular position)
  E   = Eccentric anomaly (intermediate variable)  ν   = True anomaly (actual angular position)
  e   = Orbital eccentricity (0=circle, 1=parabola)
  a   = Semi-major axis (average distance from Sun)
  t   = Simulation time step

## Yuga Cycle Parameter Drift

# Dharma index decays across yugas:
dharma(t) = dharma₀ × (0.75)^(t / T_yuga)

# Entropy increases:
entropy(t) = entropy₀ + k × log(1 + t / T_yuga)

# Difficulty scaling:
difficulty(t) = base_diff × (1 + 0.25 × (t / T_yuga))

जिथे:
  T_yuga = Duration of one yuga (simulated time units)
  k      = Entropy growth constant
  t      = Current simulation time

## Planetary Conjunction Detection

def check_conjunction(planet1, planet2, threshold_deg=2.0):
    angular_sep = abs(planet1.longitude - planet2.longitude) % 360
    angular_sep = min(angular_sep, 360 - angular_sep)  # Shortest arc
    return angular_sep < threshold_deg

४. KhagolaYantraEngine: पूर्ण Celestial Physics System (Python)

from dataclasses import dataclass, field
from typing import List, Dict, Optional
import math

# ─── Celestial Body Model ─────────────────────────────────────
@dataclass
class Graha:
    """Vedic planetary body with orbital parameters"""
    name: str                    # e.g., "Surya", "Chandra", "Mangala"
    semi_major_axis: float      # AU (astronomical units)    eccentricity: float         # 0.0-1.0
    orbital_period_days: float  # Sidereal period
    mean_longitude_0: float     # Initial position at epoch (degrees)
    inclination: float = 0.0    # Orbital tilt (degrees)
    
    # Runtime state
    current_longitude: float = field(init=False)
    current_nakshatra: int = field(init=False)
    
    def __post_init__(self):
        self.current_longitude = self.mean_longitude_0
        self.current_nakshatra = self._compute_nakshatra()
    
    def _compute_nakshatra(self) -> int:
        """27 nakshatras = 360° / 27 = 13.333° each"""
        return int(self.current_longitude // 13.3333) % 27
    
    def update_position(self, delta_days: float):
        """Update planetary position using mean motion"""
        # Mean motion: n = 360° / orbital_period
        n = 360.0 / self.orbital_period_days
        self.current_longitude = (self.current_longitude + n * delta_days) % 360
        self.current_nakshatra = self._compute_nakshatra()
    
    def get_cartesian(self) -> tuple:
        """Convert polar (r, θ) to cartesian (x, y) for rendering"""
        r = self.semi_major_axis * (1 - self.eccentricity**2) / \
            (1 + self.eccentricity * math.cos(math.radians(self.current_longitude)))
        x = r * math.cos(math.radians(self.current_longitude))
        y = r * math.sin(math.radians(self.current_longitude))
        return (x, y)

# ─── Khagola Yantra Engine ────────────────────────────────────
class KhagolaYantraEngine:
    """
    खगोल यंत्र → Celestial Physics & Grid Simulation Engine
    Handles: Planetary motion, Nakshatra grid, Yuga cycles, Conjunctions
    """
    
    NAKSHATRA_COUNT = 27
    NAKSHATRA_SIZE = 360.0 / NAKSHATRA_COUNT  # 13.333°
    YUGA_DURATIONS = {  # In simulated years
        "Krita": 1728000, "Treta": 1296000,
        "Dvapara": 864000, "Kali": 432000
    }
    
    def __init__(self, epoch_year: float = 2000.0):
        self.epoch = epoch_year
        self.current_time = epoch_year
        self.grahas: Dict[str, Graha] = {}        self.current_yuga = "Kali"
        self.yuga_start_time = epoch_year - 3102  # Kali Yuga start
        self.events_log: List[dict] = []
    
    def add_graha(self, graha: Graha):
        self.grahas[graha.name] = graha
        print(f"🪐 Added: {graha.name} @ {graha.current_longitude:.2f}° (Nakshatra #{graha.current_nakshatra})")
    
    def _get_current_yuga_progress(self) -> float:
        """Returns 0.0-1.0 progress through current yuga"""
        yuga_duration = self.YUGA_DURATIONS[self.current_yuga]
        elapsed = self.current_time - self.yuga_start_time
        return min(1.0, elapsed / yuga_duration)
    
    def _check_conjunctions(self) -> List[dict]:
        """Detect planetary conjunctions (Graha Yuddha)"""
        conjunctions = []
        graha_list = list(self.grahas.values())
        for i, g1 in enumerate(graha_list):
            for g2 in graha_list[i+1:]:
                sep = abs(g1.current_longitude - g2.current_longitude) % 360
                sep = min(sep, 360 - sep)
                if sep < 2.0:  # Within 2 degrees = conjunction
                    conjunctions.append({"planets": (g1.name, g2.name),
                                            "separation": sep,
                                            "nakshatra": g1.current_nakshatra})
        return conjunctions
    
    def step_simulation(self, delta_days: float = 1.0) -> Dict:
        """
        Main Simulation Step:
        1. Update all planetary positions
        2. Check for conjunctions/events
        3. Update yuga progress & parameters
        4. Return current celestial state
        """
        # Step 1: Update positions
        for graha in self.grahas.values():
            graha.update_position(delta_days)
        
        # Step 2: Check events
        conjunctions = self._check_conjunctions()
        if conjunctions:
            for conj in conjunctions:
                print(f"⚡ Conjunction: {conj['planets'][0]} & {conj['planets'][1]} "
                f"@ Nakshatra #{conj['nakshatra']}")
                self.events_log.append({"type": "conjunction", "data": conj,
                "time": self.current_time})
        
        # Step 3: Update time & yuga        self.current_time += delta_days / 365.25  # Convert days to years
        yuga_progress = self._get_current_yuga_progress()
        if yuga_progress >= 1.0:
            print(f"🔄 Yuga transition: {self.current_yuga} → next")
            # Simplified: cycle back to Krita
            self.current_yuga = "Krita"
            self.yuga_start_time = self.current_time
        
        # Step 4: Return state
        return {
            "time": self.current_time,
            "yuga": self.current_yuga,
            "yuga_progress": yuga_progress,
            "grahas": {name: {"lon": g.current_longitude, "nak": g.current_nakshatra}
            for name, g in self.grahas.items()},
            "events": conjunctions
        }
    
    def get_nakshatra_name(self, index: int) -> str:
        """Map nakshatra index to traditional name"""
        names = ["Ashwini","Bharani","Krittika","Rohini","Mrigashira",
        "Ardra","Punarvasu","Pushya","Ashlesha","Magha",
        "PurvaPhalguni","UttaraPhalguni","Hasta","Chitra","Swati",
        "Vishakha","Anuradha","Jyeshtha","Mula","PurvaAshadha",
        "UttaraAshadha","Shravana","Dhanishta","Shatabhisha",
        "PurvaBhadrapada","UttaraBhadrapada","Revati"]
        return names[index % 27]


# ─── Demo: Initialize Khagola Yantra ─────────────────────────
engine = KhagolaYantraEngine(epoch_year=2026.0)

# Add major grahas (simplified orbital params)
engine.add_graha(Graha("Surya", 1.0, 0.0167, 365.25, 280.0))
engine.add_graha(Graha("Chandra", 0.00257, 0.0549, 27.32, 120.0))
engine.add_graha(Graha("Mangala", 1.524, 0.0934, 687.0, 45.0))
engine.add_graha(Graha("Budha", 0.387, 0.2056, 88.0, 200.0))
engine.add_graha(Graha("Guru", 5.204, 0.0489, 4333.0, 150.0))

# Run simulation for 30 days
print(f"\n🔭 Starting Khagola Yantra simulation...")
for day in range(30):
    state = engine.step_simulation(delta_days=1.0)
    if state["events"]:
        print(f"Day {day+1}: {len(state['events'])} event(s) detected")

print(f"\n✅ Simulation complete. Current time: {engine.current_time:.2f}")
print(f"   Current Yuga: {engine.current_yuga} ({engine._get_current_yuga_progress()*100:.1f}% complete)")

५. खगोल यंत्र फिजिक्स इंजिन: अल्गोरिदम फ्लो

## Khagola Yantra Simulation Pipeline

INPUT:
  grahas[]     = List of celestial bodies (orbital params, initial position)
  epoch        = Reference time (e.g., 2000.0 = J2000 epoch)
  delta_time   = Simulation step (days)

PROCESS:
  1. FOR each graha:
     a. Compute mean motion: n = 360° / orbital_period
     b. Update longitude: θ_new = (θ_old + n × Δt) % 360
     c. Compute nakshatra: index = floor(θ / 13.333) % 27
  
  2. CHECK conjunctions:
     FOR each pair (g1, g2):
       sep = min(|θ₁-θ₂|, 360-|θ₁-θ₂|)
       IF sep < 2.0° → trigger conjunction event
  
  3. UPDATE yuga progress:
     elapsed = current_time - yuga_start
     progress = elapsed / yuga_duration
     IF progress >= 1.0 → transition to next yuga
  
  4. COMPUTE derived parameters:
     dharma_index = dharma₀ × (0.75)^progress
     entropy = entropy₀ + k × log(1 + progress)

OUTPUT:
  simulation_state {
    time: current_simulation_year
    yuga: current_yuga_name
    grahas: {name: {longitude, nakshatra_index}}
    events: [conjunctions, eclipses, etc.]
    parameters: {dharma, entropy, difficulty}
  }

## Nakshatra-Based Event Triggering:
  Certain nakshatras trigger specific simulation events:
  • Ashwini (#0)   → New beginnings, initialization events
  • Magha (#9)     → Ancestral/karmic events
  • Mula (#18)     → Transformation/root-level changes
  • Revati (#26)   → Completion, cycle-end events

६. निष्कर्ष: खगोल यंत्र = Celestial Simulation Framework

Vedic Yantra-Tantra Multiverse – Branch 2 | Post 18 of 25
ही पोस्ट प्रेरणादायी analogy आहे — तांत्रिक आणि वैदिक frameworks यांचा creative संगम.