molbuilder 1.0.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

molbuilder/visualization/interaction_viz.py

@@ -0,0 +1,615 @@
+"""Main animation renderer for extreme slow-motion atomic interactions.
+
+Provides ``InteractionVisualizer`` which builds matplotlib FuncAnimation
+pipelines that render MD trajectories at sub-femtosecond resolution,
+with optional overlays for electron density, curly arrows, energy bars,
+and time labels.
+
+Convenience functions:
+    - ``visualize_md_trajectory(mol, n_steps, ...)``
+    - ``visualize_reaction(mol, mechanism, ...)``
+    - ``visualize_bond_formation(mol, atom_i, atom_j, ...)``
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+try:
+    import matplotlib
+    import matplotlib.pyplot as plt
+    from matplotlib.animation import FuncAnimation
+    from matplotlib.patches import FancyArrowPatch
+    HAS_MATPLOTLIB = True
+except ImportError:
+    HAS_MATPLOTLIB = False
+
+from molbuilder.core.element_properties import cpk_color, covalent_radius_pm
+from molbuilder.core.elements import SYMBOL_TO_Z
+from molbuilder.visualization.theme import (
+    BG_COLOR, TEXT_COLOR, BOND_COLOR,
+    FORMING_BOND_COLOR, BREAKING_BOND_COLOR,
+    ELECTRON_CLOUD_COLOR, ARROW_COLOR, TRANSITION_STATE_COLOR,
+)
+
+if TYPE_CHECKING:
+    from molbuilder.molecule.graph import Molecule
+    from molbuilder.dynamics.trajectory import Trajectory
+    from molbuilder.dynamics.mechanisms import ReactionMechanism, ElectronFlow
+    from molbuilder.dynamics.mechanism_choreography import MechanismChoreographer
+
+
+# ===================================================================
+# Configuration
+# ===================================================================
+
+@dataclass
+class PlaybackConfig:
+    """Configuration for the interaction visualizer.
+
+    Attributes
+    ----------
+    slowmo_factor : float
+        Slowdown factor.  Default 1e15 means 1 fs of simulation time
+        maps to 1 second of animation (extreme slow motion).
+    fps : int
+        Animation frame rate.
+    show_electron_density : bool
+        Render electron density clouds during bond events.
+    show_electron_flows : bool
+        Render curly/fishhook arrows for electron flow.
+    show_energy_bar : bool
+        Show an energy bar overlay.
+    show_time_label : bool
+        Show a time label with SI prefix.
+    show_bond_orders : bool
+        Show fractional bond orders as annotations.
+    export_path : str or None
+        If set, export animation to this file path (.mp4 or .gif).
+    camera_follow : bool
+        Auto-track the reaction center.
+    dpi : int
+        Resolution for export.
+    figsize : tuple[float, float]
+        Figure size in inches.
+    """
+    slowmo_factor: float = 1e15
+    fps: int = 30
+    show_electron_density: bool = True
+    show_electron_flows: bool = True
+    show_energy_bar: bool = True
+    show_time_label: bool = True
+    show_bond_orders: bool = False
+    export_path: str | None = None
+    camera_follow: bool = False
+    dpi: int = 150
+    figsize: tuple[float, float] = (10, 8)
+
+
+def _time_label(t_fs: float) -> str:
+    """Format time with appropriate SI prefix."""
+    if abs(t_fs) < 1e-3:
+        return f"{t_fs * 1e3:.2f} as"
+    if abs(t_fs) < 1.0:
+        return f"{t_fs:.3f} fs"
+    if abs(t_fs) < 1000.0:
+        return f"{t_fs:.1f} fs"
+    return f"{t_fs / 1000.0:.2f} ps"
+
+
+def _bond_color_from_order(order: float) -> str:
+    """Choose bond color based on fractional bond order."""
+    if order < 0.3:
+        return BREAKING_BOND_COLOR
+    if order > 0.7 and order < 1.3:
+        return BOND_COLOR
+    if order >= 0.3 and order < 0.7:
+        return TRANSITION_STATE_COLOR
+    return FORMING_BOND_COLOR
+
+
+# ===================================================================
+# InteractionVisualizer
+# ===================================================================
+
+class InteractionVisualizer:
+    """Renders MD trajectories as slow-motion matplotlib animations.
+
+    Parameters
+    ----------
+    trajectory : Trajectory
+        The MD trajectory to visualize.
+    molecule : Molecule
+        Original molecule (for bond connectivity and atom symbols).
+    mechanism : ReactionMechanism or None
+        Optional mechanism for electron flow overlays.
+    choreographer : MechanismChoreographer or None
+        Optional choreographer for mechanism annotations.
+    config : PlaybackConfig or None
+        Playback configuration.
+    """
+
+    def __init__(self, trajectory, molecule,
+                 mechanism=None, choreographer=None,
+                 config: PlaybackConfig | None = None):
+        if not HAS_MATPLOTLIB:
+            raise ImportError("matplotlib is required for visualization")
+
+        self.trajectory = trajectory
+        self.molecule = molecule
+        self.mechanism = mechanism
+        self.choreographer = choreographer
+        self.config = config or PlaybackConfig()
+
+        # Precompute animation frames
+        duration_fs = trajectory.duration
+        duration_anim_s = duration_fs * self.config.slowmo_factor * 1e-15
+        # Minimum 2 seconds of animation
+        duration_anim_s = max(duration_anim_s, 2.0)
+        self.n_frames = max(int(duration_anim_s * self.config.fps), 2)
+
+        # Time array for each animation frame
+        self.frame_times = np.linspace(
+            trajectory.t_start, trajectory.t_end, self.n_frames)
+
+        # Electron density renderer
+        self._edensity = None
+        if self.config.show_electron_density:
+            from molbuilder.visualization.electron_density_viz import (
+                ElectronDensityRenderer,
+            )
+            self._edensity = ElectronDensityRenderer(n_points=2000)
+
+        self._fig = None
+        self._ax = None
+        self._anim = None
+        self._paused = False
+
+    def build_animation(self) -> FuncAnimation:
+        """Build and return the matplotlib FuncAnimation.
+
+        Returns
+        -------
+        FuncAnimation
+            The animation object.  Call ``plt.show()`` to display, or
+            use ``export()`` to save.
+        """
+        self._fig, self._ax = plt.subplots(
+            figsize=self.config.figsize,
+            facecolor=BG_COLOR,
+        )
+        self._ax.set_facecolor(BG_COLOR)
+        self._ax.set_aspect("equal")
+        self._ax.tick_params(colors=TEXT_COLOR)
+        for spine in self._ax.spines.values():
+            spine.set_color(TEXT_COLOR)
+
+        self._anim = FuncAnimation(
+            self._fig,
+            self._render_frame,
+            frames=self.n_frames,
+            interval=1000 // self.config.fps,
+            blit=False,
+            repeat=True,
+        )
+
+        return self._anim
+
+    def _render_frame(self, frame_idx: int):
+        """Render a single animation frame."""
+        ax = self._ax
+        ax.clear()
+        ax.set_facecolor(BG_COLOR)
+
+        t_fs = self.frame_times[frame_idx]
+        positions = self.trajectory.at_time(t_fs)
+
+        mol = self.molecule
+        symbols = [a.symbol for a in mol.atoms]
+
+        # Compute bounds for axis
+        margin = 2.0
+        x_min = positions[:, 0].min() - margin
+        x_max = positions[:, 0].max() + margin
+        y_min = positions[:, 1].min() - margin
+        y_max = positions[:, 1].max() + margin
+        ax.set_xlim(x_min, x_max)
+        ax.set_ylim(y_min, y_max)
+        ax.set_aspect("equal")
+
+        # Draw bonds
+        for bond in mol.bonds:
+            i, j = bond.atom_i, bond.atom_j
+            key = (min(i, j), max(i, j))
+            order = float(bond.order)
+
+            # Check for fractional bond order from trajectory
+            frac_order = self.trajectory.bond_order_at_time(t_fs, i, j)
+            if frac_order > 0.01:
+                order = frac_order
+
+            # Bond styling
+            color = BOND_COLOR
+            linestyle = "-"
+            linewidth = 1.5 * max(order, 0.2)
+
+            if frac_order > 0.01:
+                color = _bond_color_from_order(frac_order)
+                if frac_order < 0.5:
+                    linestyle = ":"
+                elif frac_order < 0.8:
+                    linestyle = "--"
+
+            pi = positions[i]
+            pj = positions[j]
+            ax.plot(
+                [pi[0], pj[0]], [pi[1], pj[1]],
+                color=color, linewidth=linewidth,
+                linestyle=linestyle, zorder=1,
+            )
+
+            # Bond order annotation
+            if self.config.show_bond_orders and frac_order > 0.05:
+                mid = 0.5 * (pi + pj)
+                ax.text(mid[0], mid[1] + 0.15, f"{frac_order:.2f}",
+                        color=TEXT_COLOR, fontsize=7, ha="center",
+                        va="bottom", zorder=5)
+
+        # Draw electron density
+        if self._edensity is not None and self.config.show_electron_density:
+            for bond in mol.bonds:
+                i, j = bond.atom_i, bond.atom_j
+                frac_order = self.trajectory.bond_order_at_time(t_fs, i, j)
+                if 0.1 < frac_order < 0.9:
+                    z_a = SYMBOL_TO_Z.get(symbols[i], 1)
+                    z_b = SYMBOL_TO_Z.get(symbols[j], 1)
+                    self._edensity.render_on_axis_2d(
+                        ax, positions[i], positions[j],
+                        z_a, z_b, frac_order, point_size=1.5)
+
+        # Draw electron flow arrows
+        if (self.config.show_electron_flows
+                and self.mechanism is not None
+                and self.choreographer is not None):
+            self._draw_electron_flows(ax, positions, t_fs, frame_idx)
+
+        # Draw atoms (on top of bonds)
+        for idx, atom in enumerate(mol.atoms):
+            x, y = positions[idx, 0], positions[idx, 1]
+            color = cpk_color(atom.symbol)
+            radius = covalent_radius_pm(atom.symbol) / 100.0 * 0.3
+            radius = max(radius, 0.15)
+
+            circle = plt.Circle(
+                (x, y), radius, color=color,
+                zorder=3, ec="#222222", linewidth=0.5)
+            ax.add_patch(circle)
+
+            # Atom label for non-hydrogen atoms
+            if atom.symbol != "H":
+                ax.text(x, y, atom.symbol,
+                        color="#000000", fontsize=7, fontweight="bold",
+                        ha="center", va="center", zorder=4)
+
+        # Overlays
+        if self.config.show_time_label:
+            ax.text(0.02, 0.98, _time_label(t_fs),
+                    transform=ax.transAxes,
+                    color=TEXT_COLOR, fontsize=12, fontweight="bold",
+                    va="top", ha="left",
+                    bbox=dict(boxstyle="round,pad=0.3",
+                              facecolor=BG_COLOR, alpha=0.8))
+
+        if self.config.show_energy_bar:
+            self._draw_energy_bar(ax, t_fs)
+
+        # Mechanism annotation
+        if self.choreographer is not None:
+            stage_idx = self._stage_for_time(t_fs)
+            if stage_idx is not None:
+                annotation = self.choreographer.stage_annotation(stage_idx)
+                if annotation:
+                    ax.text(0.5, 0.02, annotation,
+                            transform=ax.transAxes,
+                            color=TRANSITION_STATE_COLOR,
+                            fontsize=10, ha="center", va="bottom",
+                            bbox=dict(boxstyle="round,pad=0.3",
+                                      facecolor=BG_COLOR, alpha=0.8))
+
+        ax.set_xlabel("x (A)", color=TEXT_COLOR, fontsize=8)
+        ax.set_ylabel("y (A)", color=TEXT_COLOR, fontsize=8)
+
+    def _draw_electron_flows(self, ax, positions, t_fs, frame_idx):
+        """Draw curly/fishhook arrows for electron flows."""
+        from molbuilder.dynamics.mechanisms import FlowType
+
+        stage_idx = self._stage_for_time(t_fs)
+        if stage_idx is None:
+            return
+
+        total_steps = len(self.mechanism.stages)
+        progress = (frame_idx / max(1, self.n_frames - 1))
+        stage_progress = (progress * total_steps) - stage_idx
+
+        flows = self.choreographer.electron_flows_at(
+            stage_idx, stage_progress)
+
+        for flow in flows:
+            start = positions[flow.from_atom][:2]
+            mid_bond = 0.5 * (
+                positions[flow.to_bond[0]][:2]
+                + positions[flow.to_bond[1]][:2])
+
+            color = ARROW_COLOR
+            style = "Simple,tail_width=2,head_width=8,head_length=6"
+            if flow.flow_type == FlowType.FISHHOOK_ARROW:
+                style = "Simple,tail_width=1,head_width=5,head_length=4"
+
+            arrow = FancyArrowPatch(
+                posA=tuple(start), posB=tuple(mid_bond),
+                arrowstyle=style,
+                color=color, alpha=0.8,
+                connectionstyle="arc3,rad=0.3",
+                zorder=6,
+            )
+            ax.add_patch(arrow)
+
+            if flow.label:
+                label_pos = 0.5 * (start + mid_bond)
+                ax.text(label_pos[0], label_pos[1] + 0.3,
+                        flow.label, color=ARROW_COLOR,
+                        fontsize=6, ha="center", va="bottom",
+                        zorder=7)
+
+    def _draw_energy_bar(self, ax, t_fs):
+        """Draw a small energy bar overlay."""
+        times, ke, pe = self.trajectory.energies()
+        if len(times) < 2:
+            return
+
+        # Find closest frame
+        idx = np.searchsorted(times, t_fs)
+        idx = min(idx, len(times) - 1)
+        ke_val = ke[idx]
+        pe_val = pe[idx]
+        total = ke_val + pe_val
+
+        bar_text = f"KE: {ke_val:.1f}  PE: {pe_val:.1f}  Total: {total:.1f} kJ/mol"
+        ax.text(0.98, 0.98, bar_text,
+                transform=ax.transAxes,
+                color=TEXT_COLOR, fontsize=8,
+                va="top", ha="right",
+                bbox=dict(boxstyle="round,pad=0.3",
+                          facecolor=BG_COLOR, alpha=0.8))
+
+    def _stage_for_time(self, t_fs):
+        """Determine which mechanism stage corresponds to a time."""
+        if self.mechanism is None:
+            return None
+        n_stages = len(self.mechanism.stages)
+        if n_stages == 0:
+            return None
+        frac = (t_fs - self.trajectory.t_start) / max(
+            self.trajectory.duration, 1e-10)
+        stage = int(frac * n_stages)
+        return min(stage, n_stages - 1)
+
+    def show(self):
+        """Build and display the animation interactively."""
+        self.build_animation()
+        plt.show()
+
+    def export(self, path: str | None = None):
+        """Export the animation to a file.
+
+        Parameters
+        ----------
+        path : str or None
+            Output path.  If None, uses config.export_path.
+            Supports .mp4 (requires ffmpeg) and .gif (Pillow).
+        """
+        path = path or self.config.export_path
+        if path is None:
+            raise ValueError("No export path specified")
+
+        if self._anim is None:
+            self.build_animation()
+
+        if path.endswith(".mp4"):
+            try:
+                from matplotlib.animation import FFMpegWriter
+                writer = FFMpegWriter(fps=self.config.fps)
+                self._anim.save(path, writer=writer, dpi=self.config.dpi)
+            except Exception:
+                # Fallback to gif
+                path = path.replace(".mp4", ".gif")
+                from matplotlib.animation import PillowWriter
+                writer = PillowWriter(fps=self.config.fps)
+                self._anim.save(path, writer=writer, dpi=self.config.dpi)
+        elif path.endswith(".gif"):
+            from matplotlib.animation import PillowWriter
+            writer = PillowWriter(fps=self.config.fps)
+            self._anim.save(path, writer=writer, dpi=self.config.dpi)
+        else:
+            self._anim.save(path, dpi=self.config.dpi)
+
+        plt.close(self._fig)
+        return path
+
+    @property
+    def fig(self):
+        return self._fig
+
+
+# ===================================================================
+# Convenience functions
+# ===================================================================
+
+def visualize_md_trajectory(molecule,
+                            n_steps: int = 500,
+                            dt_fs: float = 0.5,
+                            temperature_K: float = 300.0,
+                            config: PlaybackConfig | None = None,
+                            show: bool = True):
+    """Quick MD simulation + visualization.
+
+    Parameters
+    ----------
+    molecule : Molecule
+        Molecule to simulate.
+    n_steps : int
+        Number of MD steps.
+    dt_fs : float
+        Timestep in fs.
+    temperature_K : float
+        Target temperature.
+    config : PlaybackConfig or None
+        Visualization config.
+    show : bool
+        If True, display interactively.
+
+    Returns
+    -------
+    InteractionVisualizer
+        The visualizer (can be used for export).
+    """
+    from molbuilder.dynamics.simulation import MDSimulation
+
+    sim = MDSimulation(molecule, dt_fs=dt_fs,
+                       temperature_K=temperature_K)
+    traj = sim.run(n_steps)
+
+    viz = InteractionVisualizer(traj, molecule, config=config)
+    if show:
+        viz.show()
+    return viz
+
+
+def visualize_reaction(molecule,
+                       mechanism,
+                       n_steps_per_stage: int = 200,
+                       dt_fs: float = 0.5,
+                       temperature_K: float = 50.0,
+                       config: PlaybackConfig | None = None,
+                       show: bool = True):
+    """Mechanism-steered MD + visualization.
+
+    Parameters
+    ----------
+    molecule : Molecule
+        Starting molecule.
+    mechanism : ReactionMechanism
+        Reaction mechanism template.
+    n_steps_per_stage : int
+        MD steps per mechanism stage.
+    dt_fs : float
+        Timestep.
+    temperature_K : float
+        Temperature (low for cleaner mechanism).
+    config : PlaybackConfig or None
+        Visualization config.
+    show : bool
+        Display interactively.
+
+    Returns
+    -------
+    InteractionVisualizer
+    """
+    from molbuilder.dynamics.simulation import MDSimulation
+    from molbuilder.dynamics.mechanism_choreography import MechanismChoreographer
+    from molbuilder.dynamics.forcefield import ForceField
+
+    sim = MDSimulation(molecule, dt_fs=dt_fs,
+                       temperature_K=temperature_K,
+                       thermostat=True,
+                       thermostat_tau_fs=50.0)
+    traj = sim.run_mechanism(mechanism, n_steps_per_stage)
+
+    choreographer = MechanismChoreographer(
+        mechanism, sim.ff, n_steps_per_stage)
+    viz = InteractionVisualizer(
+        traj, molecule,
+        mechanism=mechanism,
+        choreographer=choreographer,
+        config=config)
+    if show:
+        viz.show()
+    return viz
+
+
+def visualize_bond_formation(molecule,
+                             atom_i: int, atom_j: int,
+                             n_steps: int = 400,
+                             config: PlaybackConfig | None = None,
+                             show: bool = True):
+    """Visualize a single bond formation event.
+
+    Creates a simple mechanism that brings two atoms together and
+    forms a bond.
+
+    Parameters
+    ----------
+    molecule : Molecule
+        Molecule containing both atoms.
+    atom_i, atom_j : int
+        Atom indices for the bond to form.
+    n_steps : int
+        Total MD steps.
+    config : PlaybackConfig or None
+        Visualization config.
+    show : bool
+        Display interactively.
+
+    Returns
+    -------
+    InteractionVisualizer
+    """
+    from molbuilder.dynamics.mechanisms import (
+        ReactionMechanism, MechanismStage, MechanismType,
+        ElectronFlow, FlowType,
+    )
+    from molbuilder.core.bond_data import bond_length
+
+    sym_i = molecule.atoms[atom_i].symbol
+    sym_j = molecule.atoms[atom_j].symbol
+    target_bl = bond_length(sym_i, sym_j, 1)
+
+    key = (min(atom_i, atom_j), max(atom_i, atom_j))
+    mechanism = ReactionMechanism(
+        name=f"Bond formation {sym_i}-{sym_j}",
+        mechanism_type=MechanismType.SN2,
+        stages=[
+            MechanismStage(
+                name="Approach",
+                distance_targets={(atom_i, atom_j): target_bl * 1.5},
+                bond_order_changes={key: 0.3},
+                electron_flows=[
+                    ElectronFlow(atom_i, (atom_i, atom_j),
+                                 FlowType.CURLY_ARROW,
+                                 "Bond forming"),
+                ],
+                duration_weight=1.0,
+                annotation=f"Atoms approaching: {sym_i}...{sym_j}",
+            ),
+            MechanismStage(
+                name="Bond formation",
+                distance_targets={(atom_i, atom_j): target_bl},
+                bond_order_changes={key: 1.0},
+                electron_flows=[],
+                duration_weight=1.5,
+                annotation=f"Bond formed: {sym_i}-{sym_j}",
+            ),
+        ],
+        atom_roles={"atom_i": atom_i, "atom_j": atom_j},
+    )
+
+    return visualize_reaction(
+        molecule, mechanism,
+        n_steps_per_stage=n_steps // 2,
+        temperature_K=50.0,
+        config=config,
+        show=show)

molbuilder/visualization/theme.py

@@ -10,3 +10,10 @@ POSITIVE_COLOR = "#3399ff"
 NEGATIVE_COLOR = "#ff5533"
 NEUTRAL_COLOR = "#44ccff"
 ENERGY_COLOR = "#ffaa33"
+
+# Interaction visualization colors
+FORMING_BOND_COLOR = "#44ff88"
+BREAKING_BOND_COLOR = "#ff4444"
+ELECTRON_CLOUD_COLOR = "#6699ff"
+ARROW_COLOR = "#ff8800"
+TRANSITION_STATE_COLOR = "#ffff44"

{molbuilder-1.0.0.dist-info → molbuilder-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: molbuilder
-Version: 1.0.0
+Version: 1.1.0
 Summary: Professional-grade molecular engineering toolkit: atoms to retrosynthesis to process engineering
 Author: Taylor C. Powell
 License-Expression: MIT

{molbuilder-1.0.0.dist-info → molbuilder-1.1.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-molbuilder/__init__.py,sha256=0Nb0iCNk1ApK_Vx6m4oHxzhT_RiX97YYnVI_eTdAgbw,205
+molbuilder/__init__.py,sha256=XV1Q1NePEaugMbuY_n_ALj4OerKAIAZwdEtQh__YP7I,205
 molbuilder/__main__.py,sha256=F64UnMCnwJXEF59k6jtSoLga7al9rRvGxAOK2FCpA9U,123
 molbuilder/atomic/__init__.py,sha256=dUtMg4Wr76cszBJ061BmTZN3akN9gK2AnjpRIvaExyM,217
 molbuilder/atomic/bohr.py,sha256=IPZjQqW4BSl_f96JZ45gbQVykIh17gn5eYhZtlJDfWo,8941
@@ -10,8 +10,8 @@ molbuilder/bonding/covalent.py,sha256=ewvRvYzbsmuRaVLiXnRyUCU8F_CdDz4Reo5o7b2qbm
 molbuilder/bonding/lewis.py,sha256=q4uXjvGKn3NO-TaZzFn8P7WaRgz1QarKF_JbznnCrLU,11967
 molbuilder/bonding/vsepr.py,sha256=YU8h4dOdSfCwDSIfqwkFeAkHr1LS7_Kws6DFeseMB6g,14946
 molbuilder/cli/__init__.py,sha256=eo7LYBWtUUUf3HLI564gX1qFQpQczPclSVurANG-b_I,64
-molbuilder/cli/demos.py,sha256=EV3y6e7u6_b_1sht6mJUB9R75HPd1VVXOElDM9MfR8k,17681
-molbuilder/cli/menu.py,sha256=bRFbx4gSlBlTc4Usiq7C53UNZGYitEBHU2tpVc2oQ8Y,3469
+molbuilder/cli/demos.py,sha256=GuxeRXRiO1aZblvbj54Z2Ghm871ZfZanLt9oHUVU45s,20234
+molbuilder/cli/menu.py,sha256=vUGT56ueRp-Rhf748bEXqtFgneNxGlpe9_maHvgyxvY,3568
 molbuilder/cli/wizard.py,sha256=NVQ9mGLsdP_FmXX5ubpdfZImmPR4f04tNReL-bKRvHc,27335
 molbuilder/core/__init__.py,sha256=QtbG7DjHWuvu88AP3uRukb_Ax1tMKKSTFfbNoP5PjYA,428
 molbuilder/core/bond_data.py,sha256=S5TcK6nWVG5--cIkG3Rw6-_trHVkP7quVmwglS7LSSE,5675
@@ -19,8 +19,15 @@ molbuilder/core/constants.py,sha256=Asehj4DftFKXNteveljh9bTFQaYugGY-ErIHdXRxMuA,
 molbuilder/core/element_properties.py,sha256=jiiE527bRgFLQcDepOfZWIK-hsTCMDMFEQIoUg2RdwU,7575
 molbuilder/core/elements.py,sha256=vTx0A6j53E0fl-8uOYvJXirBW-xQKc8PTp4JhO9us44,6870
 molbuilder/core/geometry.py,sha256=ktvmZHhnm1dmhHpW-9iY-ugVPJlLml8n2TvcptmFjiI,7440
+molbuilder/dynamics/__init__.py,sha256=BK-b7XcXJ64H77Xgc4r8IbRZ4LUQFfPlUDl6m-qMVkA,1661
+molbuilder/dynamics/forcefield.py,sha256=rvX44zj3O2e_CVuEhZ80vK2ebL-CiD5Y2s1kv7xYxnU,20370
+molbuilder/dynamics/integrator.py,sha256=A6JKaS-8Mh6eysLa8asbZf559iVru_xOk-LfgELaETI,9130
+molbuilder/dynamics/mechanism_choreography.py,sha256=0JLfpQw-6w-XT7-mKzZjmuMH3_tOa3sGtTyOu582sc4,7113
+molbuilder/dynamics/mechanisms.py,sha256=PvmO3VqRyeeUpfXk6H8AkSIqo4fRbU3w-Fok5__NHVw,17773
+molbuilder/dynamics/simulation.py,sha256=yosysL4iHuHa_FwmZJbj65QU8LSFqmDkBexNSiD4li4,7200
+molbuilder/dynamics/trajectory.py,sha256=S7rofRDQucgXHt0EGTKXA2LyrB3gGJBD8BNuETzXYxk,6406
 molbuilder/gui/__init__.py,sha256=KqjMkDsQ5qIbSrK4C_YP45vHaomggTutwDg-dxmEmW4,99
-molbuilder/gui/app.py,sha256=O57Ksx9ajphXXlMbK5l-4zn0Nj2Ol1qvUhJv8uCXPkc,11507
+molbuilder/gui/app.py,sha256=EffmhcivoDLSbkPVJg-x9Ob2lXVC72FjXvktE4FklR4,16254
 molbuilder/gui/canvas3d.py,sha256=LHVbgGbNhmyN24oCQ8z8XhwWhP9ehapTcbaP7at_ivY,4735
 molbuilder/gui/dialogs.py,sha256=ULUX3YiUHSjqWi7fCnMsi-e0pbYxWINJmYcKX8eiKhU,4037
 molbuilder/gui/event_handler.py,sha256=p9FF75csq7pf5u2we3uVfebri-tFWbJtRPVW5jtQX3o,4341
@@ -65,14 +72,17 @@ molbuilder/smiles/__init__.py,sha256=KX9neiR2temLI71KaZS_apcbrWZpPAAgRt4Q5FIJ9G8
 molbuilder/smiles/parser.py,sha256=rFoUlXH2t2skbXQyP9Xwn4JRjvWg0JcRsmq7gpCOAyw,15963
 molbuilder/smiles/tokenizer.py,sha256=HAaA8Nok0dIRB2jXfNzAO2Yuv7KgAlL0zMyFXWIos2w,8709
 molbuilder/smiles/writer.py,sha256=x7s-Y6HsF5yEhijvtQIPRBTkxTFccFtzsL-pKKcTHAQ,12025
-molbuilder/visualization/__init__.py,sha256=LMqqek4hZqYHMeDRAFiFuQIPJCWBKc5KlfnOtWjnZGM,70
+molbuilder/visualization/__init__.py,sha256=EmYmHNXJs0veqnUeEX5tnQYP8q7zS_l1PWDgRJyVU9c,125
 molbuilder/visualization/bohr_viz.py,sha256=6lWZUOy4R1M6DdxJxHfBSY2DeW1KPDvbYKt5tXRx2t0,5624
+molbuilder/visualization/electron_density_viz.py,sha256=4bKR-qaa1b9dLqE38qBbPA5ImKPtT4nB5RVfVKyTj70,7809
+molbuilder/visualization/interaction_controls.py,sha256=YwHTU-QESi7hF0DWAQbEZlRdmxUhm9r9UrHxUyHcYJE,6363
+molbuilder/visualization/interaction_viz.py,sha256=vTCnPeOQW9csQtD4TVmr5u_W5o4U3zJhru_nY9yePpA,20954
 molbuilder/visualization/molecule_viz.py,sha256=SvDIFvGviCGs9g0W7wQQj9frGdPydoBc4v5EsacNkgM,14002
 molbuilder/visualization/quantum_viz.py,sha256=7vvr1KaUa_WZ4FIb2r8ih6nKjUjP4piJeJosUBtsdrQ,15187
-molbuilder/visualization/theme.py,sha256=BzR8NfqCZ2Lq1y3cdgRkN5Qg8GnRqZGdEc_gq_JAdjY,321
-molbuilder-1.0.0.dist-info/licenses/LICENSE,sha256=WEWbPnVFDQwVEHeX_mpHol-ByLsQWgQZDMjSNjdFq8w,1094
-molbuilder-1.0.0.dist-info/METADATA,sha256=JYT7g6C1x8oXbQsyod9LhWhIt6Ag_0WXEKcYdBP3UBo,14828
-molbuilder-1.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-molbuilder-1.0.0.dist-info/entry_points.txt,sha256=WkIjoyvOBBe_0KeT6ixldelD_7Hfj0mPADjamMmVgck,56
-molbuilder-1.0.0.dist-info/top_level.txt,sha256=zqS1kyhgo71hB_QcsI2eq5lO4w7VGiMaXH1f2Hn-kaA,11
-molbuilder-1.0.0.dist-info/RECORD,,
+molbuilder/visualization/theme.py,sha256=j_jZ4lqF8v1GdHbyMxrOW1BWtN4AwwWEaB2LBPiDUeI,512
+molbuilder-1.1.0.dist-info/licenses/LICENSE,sha256=WEWbPnVFDQwVEHeX_mpHol-ByLsQWgQZDMjSNjdFq8w,1094
+molbuilder-1.1.0.dist-info/METADATA,sha256=kkOi_8G6HZTxCQXdFDjGQw0ApxZInBLbvQcH2eDnIx0,14828
+molbuilder-1.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+molbuilder-1.1.0.dist-info/entry_points.txt,sha256=WkIjoyvOBBe_0KeT6ixldelD_7Hfj0mPADjamMmVgck,56
+molbuilder-1.1.0.dist-info/top_level.txt,sha256=zqS1kyhgo71hB_QcsI2eq5lO4w7VGiMaXH1f2Hn-kaA,11
+molbuilder-1.1.0.dist-info/RECORD,,