Python

import math
from typing import Optional, Callable

# Material database (auto-load for k, c)
MATERIAL_DB = {
    "granite": (1.8e9, 0.0001),   # k (N/m), c (N·s/m)
    "quartz": (7.3e9, 0.00001),
    "steel": (2e11, 0.001),
    "wood": (1e8, 0.01),
    "bone": (1.5e9, 0.0005),
    "water": (2.2e9, 0.0002)
}

class EnergyTuner:
    def __init__(self, m: float, k: Optional[float] = None, 
                 c: Optional[float] = None, material: Optional[str] = None):
        self.m = m  # Mass in kg
        self.k = k  # Stiffness in N/m
        self.c = c  # Damping in N·s/m
        self.material = material

        # Auto-load k and c from database if material provided
        if material and material in MATERIAL_DB:
            self.k, self.c = MATERIAL_DB[material]
        elif not self.k:
            raise ValueError("Stiffness (k) must be provided if material isn't specified.")
        elif not self.c:
            self.c = 0.0  # Default to no damping

        self.f0 = None
        self.f_d = None
        self.zeta = None

    def calculate_natural_freq(self) -> float:
        """Calculate undamped natural frequency f0 (Hz)"""
        self.f0 = (1 / (2 * math.pi)) * math.sqrt(self.k / self.m)
        return self.f0

    def calculate_damped_freq(self, threshold: float = 0.05) -> float:
        """Calculate damped natural frequency if damping is significant"""
        if self.c == 0:
            return self.f0

        # Damping ratio ζ = c / (2√(k·m))
        zeta = self.c / (2 * math.sqrt(self.k * self.m))
        self.zeta = zeta

        if zeta < threshold:
            return self.f0

        # Damped frequency ω_d = ω0 √(1 - ζ²)
        omega0 = 2 * math.pi * self.f0
        omega_d = omega0 * math.sqrt(1 - zeta**2)
        self.f_d = omega_d / (2 * math.pi)  # Convert to Hz
        return self.f_d

    def auto_scan_mode(self, f_min: float, f_max: float, step: float, 
                      response_func: Callable[[float], float]) -> tuple[float, float]:
        """Find resonant frequency via frequency sweep and Lorentzian fitting"""
        frequencies = []
        responses = []
        f = f_min
        while f <= f_max:
            responses.append(response_func(f))
            frequencies.append(f)
            f += step

        # Find peak frequency (f0)
        max_index = responses.index(max(responses))
        f0_peak = frequencies[max_index]

        # Fit Lorentzian to get damping ratio ζ
        A0 = max(responses)
        half_max = A0 / 2.0
        # Find full width at half maximum (Γ)
        left_idx = next(i for i, r in enumerate(responses) 
                       if frequencies[i] <= f0_peak and r >= half_max)
        right_idx = next(i for i, r in enumerate(responses) 
                         if frequencies[i] >= f0_peak and r >= half_max)
        Gamma = frequencies[right_idx] - frequencies[left_idx]

        # ζ = Γ / (2π·f0_peak)
        zeta = Gamma / (2 * math.pi * f0_peak)
        return f0_peak, zeta

    # --- OUTPUT MODES ---
    def generate_tone(self, f: float, duration: float, amplitude: float = 1.0) -> None:
        """Generate pure sine wave via speaker/piezoelectric"""
        # Hardware integration point (e.g., control Arduino)
        print(f"Generating tone at {f:.2f} Hz | Amplitude: {amplitude}")

    def generate_chant(self, f: float, note_name: Optional[str] = None) -> None:
        """Convert frequency to musical note and generate chant"""
        # Frequency to note conversion (A4=440Hz)
        n = 69.5 + 12 * math.log2(f / 440.0)  # MIDI note number
        octave = int(n // 12) - 6
        note_name = self._note_to_name(int(n % 12), octave) if note_name is None else note_name

        # Chant generation (e.g., "Om" at Schumann resonance)
        chant = "Om" if f ≈ 136.1 else "Amen"  # Simplified; real implementation uses frequency mapping
        print(f"Chant: {chant} | Note: {note_name} | Frequency: {f:.2f} Hz")

    def generate_light_pulses(self, f: float, pulse_width: float, duty_cycle: float = 0.5) -> None:
        """Modulate LED/laser at resonant frequency"""
        # Hardware integration (e.g., control PWM)
        print(f"Light pulses at {f:.2f} Hz | Duty cycle: {duty_cycle*100:.1f}%")

    def intention_amplifier(self, f: float, intention: str = None) -> None:
        """Visualize frequency with mandala/glyph + encode intention"""
        # Visualization (e.g., waveforms in GUI)
        print(f"Resonant frequency: {f:.2f} Hz")
        if intention:
            print(f"Intention: {intention}")
            # Carrier wave encoding (e.g., AM modulation)
            print(f"Intention encoded at carrier {f + 1000} Hz")

    # Helper: Convert MIDI note to name (e.g., 60 -> "C4")
    def _note_to_name(self, note: int, octave: int) -> str:
        note_names = ["C", "D", "E", "F", "G", "A", "B"]
        return f"{note_names[note % 12]}{octave}"

# Example Usage
if __name__ == "__main__":
    # Case 1: Granite object (m=1kg, auto-load k,c)
    tuner = EnergyTuner(m=1.0, material="granite")
    tuner.calculate_natural_freq()
    print(f"Natural frequency: {tuner.f0:.2f} Hz")

    # Case 2: Steel object with damping
    tuner.calculate_damped_freq(threshold=0.05)
    print(f"Damped frequency: {tuner.f_d:.2f} Hz")

    # Case 3: Auto-scan (simulate response function)
    def simulate_response(f: float, f0: float, Gamma: float) -> float:
        return 1.0 / ((f - f0)**2 + (Gamma/2)**2)  # Lorentzian response

    f0_peak, zeta = tuner.auto_scan_mode(
        f_min=50, f_max=200, step=0.5,
        response_func=lambda f: simulate_response(f, 100, 1.0)
    )
    print(f"Auto-scan f0: {f0_peak:.2f} Hz | Damping ratio: {zeta:.4f}")

    # Output modes
    tuner.generate_tone(f0_peak, duration=5)
    tuner.generate_chant(f0_peak)
    tuner.generate_light_pulses(f0_peak, pulse_width=0.1)
    tuner.intention_amplifier(f0_peak, "Harmony")