MoleditPy 2.2.0a2__py3-none-any.whl → 2.2.1__py3-none-any.whl

moleditpy/plugins/File/orca_out_freq_analyzer.py

@@ -1,1226 +0,0 @@
-import os
-import numpy as np
-import traceback
-from PyQt6.QtWidgets import (QDialog, QVBoxLayout, QHBoxLayout, QPushButton, QLabel, 
-                             QListWidget, QSlider, QCheckBox, QFileDialog, QMessageBox,
-                             QDockWidget, QWidget, QFormLayout, QDialogButtonBox, QSpinBox, QApplication, QTreeWidget, QTreeWidgetItem, QHeaderView, QDoubleSpinBox)
-from PyQt6.QtGui import QImage, QPainter, QPen, QColor, QFont, QPaintEvent
-try:
-    from PIL import Image
-    HAS_PIL = True
-except ImportError:
-    HAS_PIL = False
-from PyQt6.QtCore import Qt, QTimer, pyqtSignal
-
-# Try to import RDKit
-try:
-    from rdkit import Chem
-    from rdkit.Geometry import Point3D
-except ImportError:
-    Chem = None
-
-PLUGIN_NAME = "ORCA Freq Analyzer"
-__version__="2025.12.25"
-__author__="HiroYokoyama"
-
-class OrcaParser:
-    def __init__(self):
-        self.filename = ""
-        self.atoms = []
-        self.coords = []
-        self.frequencies = []
-        self.intensities = [] # IR Intensities
-        self.vib_modes = [] # list of list of (dx, dy, dz)
-        self.charge = 0
-        self.multiplicity = 1
-
-    def parse(self, filename):
-        self.filename = filename
-        self.atoms = []
-        self.coords = []
-        self.frequencies = []
-        self.vib_modes = []
-        self.charge = 0
-        self.multiplicity = 1
-        
-        with open(filename, 'r', encoding='utf-8', errors='replace') as f:
-            lines = f.readlines()
-            
-        # 1. basic properties: charge, mult
-        # Look for "Total Charge           Charge          ....   0"
-        # OR In input block: "* xyz   0   1"
-        # scan lines
-        
-        # 2. Geometry: Look for "CARTESIAN COORDINATES (ANGSTROEM)" or similar.
-        # Use the LAST occurrence to get optimized geometry.
-        
-        coord_start_lines = []
-        freq_start_line = -1
-        modes_start_line = -1
-        
-        for i, line in enumerate(lines):
-            line_s = line.strip()
-            if "CARTESIAN COORDINATES (ANGSTROEM)" in line:
-                coord_start_lines.append(i)
-            elif "CARTESIAN COORDINATES (A.U.)" in line:
-                pass # ignore AU for now unless needed
-            elif "VIBRATIONAL FREQUENCIES" in line:
-                freq_start_line = i
-            elif "NORMAL MODES" in line:
-                modes_start_line = i
-            elif "Total Charge" in line and "Charge" in line:
-                 # e.g. "Total Charge           Charge          ....   0"
-                 parts = line.split()
-                 try:
-                     self.charge = int(parts[-1])
-                 except: pass
-            elif "Multiplicity" in line and "Mult" in line:
-                 parts = line.split()
-                 try:
-                     self.multiplicity = int(parts[-1])
-                 except: pass
-        
-        # Parse Geometry (Last one)
-        if coord_start_lines:
-            start = coord_start_lines[-1]
-            try:
-                # format:
-                # CARTESIAN COORDINATES (ANGSTROEM)
-                # ---------------------------------
-                #   O      0.000000    0.000000    0.000000
-                #   H      0.000000    0.759337    0.596043
-                
-                # Check where data starts. Usually start+2
-                curr = start + 2
-                while curr < len(lines):
-                    l = lines[curr].strip()
-                    if not l:
-                        curr += 1
-                        # If multiple empty lines, maybe end
-                        if curr < len(lines) and not lines[curr].strip():
-                            break
-                        continue
-                        
-                    parts = l.split()
-                    if len(parts) >= 4:
-                        sym = parts[0]
-                        # Check if sym is element
-                        if not sym[0].isalpha(): 
-                             break # End of block
-                             
-                        try:
-                            x = float(parts[1])
-                            y = float(parts[2])
-                            z = float(parts[3])
-                            
-                            # Valid atom
-                            # Convert Sym to atomic num? RDKit needs num or Valid symbol
-                            # We can keep symbol or convert
-                            # Let's keep symbol for now, convert to num for uniformity if needed
-                            # RDKit Atom(symbol) works
-                            self.atoms.append(sym)
-                            self.coords.append((x, y, z))
-                        except ValueError:
-                            pass
-                    else:
-                        break
-                    curr += 1
-            except Exception as e:
-                print(f"Error parsing coords: {e}")
-
-        # Parse Frequencies
-        # -----------------------
-        # VIBRATIONAL FREQUENCIES
-        # -----------------------
-        # ...
-        #    0:       0.00 cm**-1
-        #    6:    1709.03 cm**-1
-        
-        if freq_start_line > 0:
-            curr = freq_start_line + 4 # skip header
-            while curr < len(lines):
-                l = lines[curr].strip()
-                if not l: 
-                    curr += 1
-                    continue
-                if "NORMAL MODES" in l: # safe guard
-                    break
-                # Format: "   6:    1709.03 cm**-1"
-                if ":" in l and "cm**-1" in l:
-                    parts = l.split()
-                    # parts example: ['6:', '1709.03', 'cm**-1']
-                    # sometimes: '0:', '0.00', 'cm**-1'
-                    try:
-                        val_str = parts[1]
-                        val = float(val_str)
-                        if val != 0.0: # Only non-zero? FCHK has all. User wants vibrations.
-                             # But let's verify if user wants 0 modes (translation/rotation). Usually not.
-                             # But keeping index alignment with Normal Modes is crucial.
-                             # ORCA Normal Modes output block usually includes all 3*N modes.
-                             pass
-                        self.frequencies.append(val)
-                    except: pass
-                elif "NORMAL MODES" in l or "-----" in l:
-                    if len(self.frequencies) > 0: # If we parsed some, stop
-                         break
-                curr += 1
-
-        # Parse IR Spectrum for Intensities
-        # Store as a dictionary: mode_id -> intensity
-        intensity_map = {}  # {mode_idx: intensity}
-        
-        ir_start = -1
-        for i, line in enumerate(lines):
-             if "IR SPECTRUM" in line:
-                 ir_start = i  # Keep updating to get the LAST occurrence
-                 # Don't break - continue to find last one
-                 
-        if ir_start > 0:
-            curr = ir_start + 6 # Skip headers and dashed line
-            # Expected format:
-            #  Mode   freq       eps      Int      T**2         TX        TY        TZ
-            #        cm**-1   L/(mol*cm) km/mol    a.u.
-            # ----------------------------------------------------------------------------
-            #   6:   1709.03   0.015725   79.47  0.002871  (-0.001018 -0.053574 -0.000000)
-            
-            while curr < len(lines):
-                l = lines[curr].strip()
-                if not l:
-                    curr += 1
-                    continue
-                if "-----" in l or "The first frequency" in l or "*" in l:
-                    break
-                    
-                # line: "   6:   1709.03   0.015725   79.47  0.002871 ..."
-                if ":" in l:
-                    parts = l.split()
-                    # parts[0] -> "6:"
-                    # parts[1] -> Freq
-                    # parts[2] -> eps
-                    # parts[3] -> Int (km/mol)
-                    # parts[4] -> T**2
-                    try:
-                         mode_id_str = parts[0].rstrip(':')
-                         mode_id = int(mode_id_str)
-                         if len(parts) >= 4:
-                             inten = float(parts[3])
-                             intensity_map[mode_id] = inten
-                    except: 
-                        pass
-                curr += 1
-
-        # Parse Normal Modes
-        # ------------
-        # NORMAL MODES
-        # ------------
-        # ...
-        #                   0          1          2          3          4          5
-        #       0       0.000000   0.000000   ...
-        # ...
-        #                   6          7          8
-        #       0       0.001345  -0.000914   0.069964
-        
-        if modes_start_line > 0 and len(self.atoms) > 0:
-            # We need to reconstruct full vectors for each mode.
-            # ORCA output is blocked by columns (modes).
-            # Rows are atoms * 3 (X, Y, Z coordinates).
-            
-            n_atoms = len(self.atoms)
-            n_coords = n_atoms * 3
-            # Initialize empty modes
-            # We don't know exactly how many modes total yet, but freq list gives a hint.
-            # Let's verify number of frequencies to initialize
-            
-            # Since parsing columnar data is tricky line-by-line without knowing total columns,
-            # we will create a dictionary mode_index -> [vector]
-            
-            mode_data = {} # {mode_idx: [val0, val1, ...]}
-            
-            curr = modes_start_line + 7 # skip headers (approx)
-            # Find first line of numbers
-            while curr < len(lines) and not lines[curr].strip():
-                curr += 1
-                
-            # Now we are at column headers: "                  0          1          2  ..."
-            while curr < len(lines):
-                header = lines[curr].strip()
-                if not header:
-                    curr += 1
-                    continue
-                if "IR SPECTRUM" in header or "--------" in header:
-                    break
-                    
-                # Parse column indices
-                try:
-                    cols = [int(c) for c in header.split()]
-                except ValueError:
-                    # Maybe not a header line, skip
-                    curr += 1
-                    continue
-                
-                # Check next line: "      0       0.000000   0.000000 ..."
-                # This corresponds to coordinate index 0 (Atom 0, X)
-                
-                start_data = curr + 1
-                # Read 3*N lines for coordinates
-                for row_idx in range(n_coords):
-                    if start_data + row_idx >= len(lines): break
-                    row_line = lines[start_data + row_idx].strip()
-                    row_parts = row_line.split()
-                    
-                    # First part is coordinate index (0, 1, 2...)
-                    # Remaining parts are values for the columns
-                    values = row_parts[1:]
-                    
-                    if len(values) != len(cols):
-                        # Mismatched data?
-                        continue
-                        
-                    for c_idx, val_str in enumerate(values):
-                        mode_idx = cols[c_idx]
-                        val = float(val_str)
-                        if mode_idx not in mode_data:
-                            mode_data[mode_idx] = []
-                        mode_data[mode_idx].append(val)
-                
-                curr = start_data + n_coords
-                
-            # Convert mode_data to self.vib_modes aligned with self.frequencies?
-            # Frequencies list has indices 0...N.
-            # We only care about modes that match frequencies we found.
-            # Note ORCA freq list usually filters out 0.00 translations if "VIBRATIONAL FREQUENCIES" is used, 
-            # BUT the list index in freq block ("   6: ...") matches the mode index.
-            
-            # Let's align them.
-            # `self.frequencies` is just a flat list of values found. We need pairs (index, freq).
-            # The freq parsing above was simplistic. Let's re-parse freq to get IDs.
-            
-            # Re-scanning frequencies for ID mapping:
-            freq_map = {} # id -> freq
-            if freq_start_line > 0:
-                curr = freq_start_line + 4
-                while curr < len(lines):
-                    l = lines[curr].strip()
-                    if ":" in l and "cm**-1" in l:
-                        parts = l.split(':')
-                        try:
-                            mid = int(parts[0].strip())
-                            freq_val = float(parts[1].split()[0])
-                            freq_map[mid] = freq_val
-                        except: pass
-                    if "NORMAL MODES" in l: break
-                    curr += 1
-            
-            # Now build final list
-            sorted_mids = sorted(mode_data.keys())
-            
-            # Only keep modes that have frequencies (or all?)
-            # Usually we only want non-zero modes (vibrations).
-            # ORCA often prints 0-5 as translations/rotations.
-            
-            # Let's store pairs: (freq, vector)
-            # Filter: only if freq > 10.0 cm-1 (avoid translations)
-            
-            self.final_modes = [] # item: {'freq': f, 'intensity': I, 'vector': [(x,y,z),...]}
-            
-            for mid in sorted_mids:
-                freq = freq_map.get(mid, 0.0)
-                # Use abs() to preserve imaginary frequencies (negative values)
-                # Only exclude low-frequency modes (translations/rotations)
-                if abs(freq) < 10.0: continue
-                
-                raw_vec = mode_data[mid]
-                if len(raw_vec) != n_coords: continue
-                
-                # format to list of (dx,dy,dz)
-                vec_formatted = []
-                for k in range(0, len(raw_vec), 3):
-                    vec_formatted.append((raw_vec[k], raw_vec[k+1], raw_vec[k+2]))
-                
-                # Get intensity for this mode from intensity_map
-                intensity = intensity_map.get(mid, None)
-                    
-                self.final_modes.append({'freq': freq, 'intensity': intensity, 'vector': vec_formatted})
-
-
-class OrcaOutFreqAnalyzer(QWidget):
-    def __init__(self, main_window, dock_widget=None):
-        super().__init__(main_window)
-        self.mw = main_window
-        self.dock = dock_widget # Store reference
-        self.setAcceptDrops(True)
-        
-        self.parser = None
-        self.base_mol = None 
-        self.timer = QTimer()
-        self.timer.timeout.connect(self.animate_frame)
-        self.animation_step = 0
-        self.is_playing = False
-        self.vector_actor = None
-        
-        self.init_ui()
-
-        
-    def init_ui(self):
-        layout = QVBoxLayout(self)
-        
-        # Info Label
-        self.lbl_info = QLabel("Drop .out file here or click Open")
-        self.lbl_info.setAlignment(Qt.AlignmentFlag.AlignCenter)
-        self.lbl_info.setStyleSheet("border: 2px dashed #AAA; padding: 20px; color: #555;")
-        layout.addWidget(self.lbl_info)
-        
-        # Open Button
-        btn_open = QPushButton("Open ORCA Output")
-        btn_open.clicked.connect(self.open_file_dialog)
-        layout.addWidget(btn_open)
-        
-
-        # Frequency List
-        # Frequency List
-        layout.addWidget(QLabel("Vibrational Frequencies:"))
-        self.list_freq = QTreeWidget()
-        self.list_freq.setColumnCount(3)
-        self.list_freq.setHeaderLabels(["No.", "Frequency (cm⁻¹)", "Intensity (km/mol)"])
-        self.list_freq.header().setSectionResizeMode(0, QHeaderView.ResizeMode.ResizeToContents)
-        self.list_freq.header().setSectionResizeMode(1, QHeaderView.ResizeMode.ResizeToContents)
-        self.list_freq.headerItem().setTextAlignment(0, Qt.AlignmentFlag.AlignCenter)  # Center No. header
-        self.list_freq.headerItem().setTextAlignment(1, Qt.AlignmentFlag.AlignCenter)  # Center Frequency header
-        self.list_freq.headerItem().setTextAlignment(2, Qt.AlignmentFlag.AlignCenter)  # Center Intensity header
-        self.list_freq.currentItemChanged.connect(self.on_freq_selected)
-        layout.addWidget(self.list_freq)
-
-        # Spectrum Button
-        btn_spectrum = QPushButton("Show Spectrum")
-        btn_spectrum.clicked.connect(self.show_spectrum)
-        layout.addWidget(btn_spectrum)
-        
-        # Animation Controls
-        anim_layout = QVBoxLayout()
-        
-        # Vector Controls
-        vec_layout = QHBoxLayout()
-        self.chk_vectors = QCheckBox("Show Vectors")
-        self.chk_vectors.setChecked(False)
-        self.chk_vectors.stateChanged.connect(lambda state: self.update_vectors())
-        vec_layout.addWidget(self.chk_vectors)
-        
-        vec_layout.addWidget(QLabel("Scale:"))
-        self.spin_vec_scale = QDoubleSpinBox()
-        self.spin_vec_scale.setRange(0.1, 200.0)
-        self.spin_vec_scale.setSingleStep(1.0)
-        self.spin_vec_scale.setValue(2.0)
-        self.spin_vec_scale.valueChanged.connect(lambda val: self.update_vectors())
-        vec_layout.addWidget(self.spin_vec_scale)
-        vec_layout.addStretch()
-        
-        anim_layout.addLayout(vec_layout)
-        
-        # Amplitude
-        amp_layout = QHBoxLayout()
-        amp_layout.addWidget(QLabel("Amplitude:"))
-        self.slider_amp = QSlider(Qt.Orientation.Horizontal)
-        self.slider_amp.setRange(1, 20)
-        self.slider_amp.setValue(5)
-        
-        self.lbl_amp_val = QLabel("5")
-        self.slider_amp.valueChanged.connect(lambda v: self.lbl_amp_val.setText(str(v)))
-        
-        amp_layout.addWidget(self.slider_amp)
-        amp_layout.addWidget(self.lbl_amp_val)
-        anim_layout.addLayout(amp_layout)
-        
-        # FPS (Speed)
-        speed_layout = QHBoxLayout()
-        speed_layout.addWidget(QLabel("FPS:"))
-        self.slider_speed = QSlider(Qt.Orientation.Horizontal)
-        self.slider_speed.setRange(1, 60)
-        self.slider_speed.setValue(20) 
-        
-        self.lbl_speed_val = QLabel("20")
-        self.slider_speed.valueChanged.connect(lambda v: self.lbl_speed_val.setText(str(v)))
-        
-        self.slider_speed.valueChanged.connect(self.update_timer_interval)
-        speed_layout.addWidget(self.slider_speed)
-        speed_layout.addWidget(self.lbl_speed_val)
-        anim_layout.addLayout(speed_layout)
-        
-        # Buttons
-        btn_layout = QHBoxLayout()
-        self.btn_play = QPushButton("Play")
-        self.btn_play.clicked.connect(self.toggle_play)
-        self.btn_stop = QPushButton("Stop")
-        self.btn_stop.clicked.connect(self.stop_play)
-        
-        btn_layout.addWidget(self.btn_play)
-        btn_layout.addWidget(self.btn_stop)
-        anim_layout.addLayout(btn_layout)
-        
-        layout.addLayout(anim_layout)
-        
-        # Export GIF Button
-        self.btn_gif = QPushButton("Export GIF")
-        self.btn_gif.clicked.connect(self.save_as_gif)
-        self.btn_gif.setEnabled(HAS_PIL)
-        layout.addWidget(self.btn_gif)
-        
-        # Metadata Info
-        self.lbl_meta = QLabel("")
-        layout.addWidget(self.lbl_meta)
-        
-        layout.addStretch()
-        
-        # Close Button
-        btn_close = QPushButton("Close")
-        def close_action():
-            self.stop_play()
-            self.reset_geometry()
-            self.remove_vectors()
-            if self.dock:
-                self.dock.close()
-            else:
-                self.close()
-        btn_close.clicked.connect(close_action)
-        layout.addWidget(btn_close)
-        
-        self.setLayout(layout)
-        
-    def dragEnterEvent(self, event):
-        if event.mimeData().hasUrls():
-            for url in event.mimeData().urls():
-                fname = url.toLocalFile().lower()
-                if fname.endswith(".out") or fname.endswith(".log"):
-                    event.acceptProposedAction()
-                    return
-        event.ignore()
-        
-    def dropEvent(self, event):
-        for url in event.mimeData().urls():
-            file_path = url.toLocalFile()
-            if file_path.lower().endswith((".out", ".log")):
-                self.load_file(file_path)
-                event.acceptProposedAction()
-                break
-                
-    def open_file_dialog(self):
-        fname, _ = QFileDialog.getOpenFileName(self, "Open ORCA Out", "", "Output Files (*.out *.log)")
-        if fname:
-            self.load_file(fname)
-            
-    def load_file(self, filename):
-        # Validation before parsing
-        if not is_valid_orca_file(filename):
-            QMessageBox.critical(self, "Invalid File", "The selected file does not appear to be a valid ORCA output file.\n(Missing 'ORCA' header)")
-            return
-
-        self.parser = OrcaParser()
-        try:
-            self.parser.parse(filename)
-            self.update_ui_after_load()
-            self.lbl_info.setText(os.path.basename(filename))
-            self.lbl_info.setStyleSheet("border: 2px solid #4CAF50; padding: 10px; color: #4CAF50;")
-            
-            # Update Main Window Context
-            if hasattr(self.mw, 'current_file_path'):
-                self.mw.current_file_path = filename
-                if hasattr(self.mw, 'update_window_title'):
-                    self.mw.update_window_title()
-                else:
-                    self.mw.setWindowTitle(f"{os.path.basename(filename)} - MoleditPy")
-                
-        except Exception as e:
-            QMessageBox.critical(self, "Error", f"Failed to parse Output:\n{e}")
-            traceback.print_exc()
-
-    def update_ui_after_load(self):
-        self.list_freq.clear()
-        if hasattr(self.parser, 'final_modes'):
-            for i, mode in enumerate(self.parser.final_modes):
-                freq = mode['freq']
-                item = QTreeWidgetItem()
-                item.setText(0, str(i + 1))  # Mode number
-                item.setText(1, f"{freq:.2f}")
-                
-                # Get intensity from the mode dictionary
-                inten = mode.get('intensity')
-                if inten is not None:
-                     item.setText(2, f"{inten:.2f}")
-                else:
-                     item.setText(2, "-")
-                item.setTextAlignment(0, Qt.AlignmentFlag.AlignCenter)  # Center mode number
-                item.setTextAlignment(1, Qt.AlignmentFlag.AlignCenter)  # Center frequency
-                item.setTextAlignment(2, Qt.AlignmentFlag.AlignCenter)  # Center intensity
-                self.list_freq.addTopLevelItem(item)
-            
-        self.lbl_meta.setText(f"Charge: {self.parser.charge}, Multiplicity: {self.parser.multiplicity}\nAtoms: {len(self.parser.atoms)}")
-        
-        # Load molecule into main window
-        if len(self.parser.atoms) > 0 and Chem:
-            self.create_base_molecule()
-
-    def create_base_molecule(self):
-        if not self.parser: return
-        
-        mol = Chem.RWMol()
-        
-        for sym in self.parser.atoms:
-            atom = Chem.Atom(sym)
-            mol.AddAtom(atom)
-            
-        conf = Chem.Conformer(len(self.parser.atoms))
-        for idx, (x, y, z) in enumerate(self.parser.coords):
-            conf.SetAtomPosition(idx, Point3D(x, y, z))
-        mol.AddConformer(conf)
-        
-        if hasattr(self.mw, 'estimate_bonds_from_distances'):
-            self.mw.estimate_bonds_from_distances(mol)
-            
-        self.base_mol = mol.GetMol()
-        self.mw.current_mol = self.base_mol
-        
-        if hasattr(self.mw, '_enter_3d_viewer_ui_mode'):
-            self.mw._enter_3d_viewer_ui_mode()
-            
-        self.mw.draw_molecule_3d(self.base_mol)
-        if hasattr(self.mw, 'plotter'):
-            self.mw.plotter.reset_camera()
-
-    def on_freq_selected(self, current, previous):
-        if self.is_playing:
-            # Transition smoothly: Reset geometry base for next frame calculation? 
-            # animate_frame uses base coords + displacement, so it handles switch naturally.
-            # Just ensure vectors update if needed (animate_frame updates them too)
-            pass 
-        else:
-            self.reset_geometry()
-            self.update_vectors()
-
-    def toggle_play(self):
-        curr = self.list_freq.currentItem()
-        if not curr:
-            return
-            
-        row = self.list_freq.indexOfTopLevelItem(curr)
-        if row < 0: return
-            
-        if self.is_playing:
-            # Pause logic
-            self.is_playing = False
-            self.timer.stop()
-            self.btn_play.setText("Play")
-            # Do NOT reset geometry
-            return
-            
-        self.is_playing = True
-        self.btn_play.setText("Pause")
-        self.timer.start(50) 
-        self.update_timer_interval()
-        
-    def stop_play(self):
-        self.is_playing = False
-        self.timer.stop()
-        self.btn_play.setText("Play")
-
-        self.reset_geometry()
-        QApplication.processEvents()
-
-    def update_timer_interval(self):
-        fps = self.slider_speed.value()
-        if fps <= 0: fps = 1
-        interval = 1000 / fps
-        self.timer.setInterval(int(interval))
-
-    def reset_geometry(self):
-        if not self.base_mol or not self.parser: return
-        conf = self.base_mol.GetConformer()
-        for idx, (x, y, z) in enumerate(self.parser.coords):
-            conf.SetAtomPosition(idx, Point3D(x, y, z))
-        self.mw.draw_molecule_3d(self.base_mol)
-        self.mw.draw_molecule_3d(self.base_mol)
-        
-        self.update_vectors()
-        
-        if hasattr(self.mw, 'plotter'):
-            self.mw.plotter.render()
-
-    def animate_frame(self):
-        if not self.parser or not self.base_mol:
-            self.stop_play()
-            return
-            
-        curr = self.list_freq.currentItem()
-        if not curr:
-             self.stop_play()
-             return
-        row = self.list_freq.indexOfTopLevelItem(curr)
-        if row < 0 or row >= len(self.parser.final_modes):
-            return
-            
-        mode_data = self.parser.final_modes[row]
-        mode_vecs = mode_data['vector']
-        
-        self.animation_step += 1
-        cycle_pos = (self.animation_step % 20) / 20.0
-        phase = cycle_pos * 2 * np.pi
-        
-        scale = self.slider_amp.value() / 20.0
-        factor = np.sin(phase) * scale
-        
-        self.apply_displacement(mode_vecs, factor)
-        self.mw.draw_molecule_3d(self.base_mol)
-        self.update_vectors(mode_vecs=mode_vecs, scale_factor=factor)
-
-    def apply_displacement(self, mode_vecs, factor):
-        conf = self.base_mol.GetConformer()
-        base_coords = self.parser.coords
-        
-        for idx, (bx, by, bz) in enumerate(base_coords):
-            if idx < len(mode_vecs):
-                dx, dy, dz = mode_vecs[idx]
-                nx = bx + dx * factor
-                ny = by + dy * factor
-                nz = bz + dz * factor
-                conf.SetAtomPosition(idx, Point3D(nx, ny, nz))
-
-    def remove_vectors(self):
-        if self.vector_actor and hasattr(self.mw, 'plotter'):
-            try:
-                self.mw.plotter.remove_actor(self.vector_actor)
-            except: pass
-        self.vector_actor = None
-
-    def update_vectors(self, mode_vecs=None, scale_factor=0.0):
-        # Clean up existing vectors
-        self.remove_vectors()
-        
-        if not self.chk_vectors.isChecked():
-            return
-            
-        if not self.parser or not self.base_mol or not hasattr(self.mw, 'plotter'):
-            return
-
-        # Get current frequency
-        curr = self.list_freq.currentItem()
-        if not curr: return
-        row = self.list_freq.indexOfTopLevelItem(curr)
-        if row < 0 or row >= len(self.parser.final_modes): return
-        
-        # Get vectors if not provided
-        if mode_vecs is None:
-            mode_data = self.parser.final_modes[row]
-            mode_vecs = mode_data['vector']
-            
-        # Current coords from molecule conformer
-        conf = self.base_mol.GetConformer()
-        coords = []
-        vectors = []
-        
-        # Amplitude for vector length scaling
-        # Now decoupled from animation amplitude
-        vis_scale = self.spin_vec_scale.value()
-        
-        for idx in range(len(mode_vecs)):
-             pos = conf.GetAtomPosition(idx)
-             coords.append([pos.x, pos.y, pos.z])
-             
-             dx, dy, dz = mode_vecs[idx]
-             vectors.append([dx, dy, dz])
-             
-        if not coords: return
-        
-        coords = np.array(coords)
-        vectors = np.array(vectors)
-        
-        try:
-            self.vector_actor = self.mw.plotter.add_arrows(coords, vectors, mag=vis_scale, color='lightgreen', show_scalar_bar=False)
-        except Exception as e:
-            print(f"Error adding arrows: {e}")
-
-    def save_as_gif(self):
-        if not self.parser or not self.base_mol: return
-        
-        was_playing = self.is_playing
-        if self.is_playing:
-            self.toggle_play()
-
-        curr = self.list_freq.currentItem()
-        if not curr:
-            QMessageBox.warning(self, "Select Frequency", "Please select a frequency to export.")
-            return
-        row = self.list_freq.indexOfTopLevelItem(curr)
-
-        dialog = QDialog(self)
-        dialog.setWindowTitle("Export GIF Settings")
-        form = QFormLayout(dialog)
-        
-        # Calculate current FPS
-        # Slider value is now FPS directly
-        current_fps = self.slider_speed.value()
-        
-        spin_fps = QSpinBox()
-        spin_fps.setRange(1, 60)
-        spin_fps.setValue(current_fps)
-        
-        chk_transparent = QCheckBox()
-        chk_transparent.setChecked(True)
-        
-        chk_hq = QCheckBox()
-        chk_hq.setChecked(True)
-        
-        form.addRow("FPS:", spin_fps)
-        form.addRow("Transparent Background:", chk_transparent)
-        form.addRow("High Quality (Adaptive):", chk_hq)
-        
-        btns = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
-        btns.accepted.connect(dialog.accept)
-        btns.rejected.connect(dialog.reject)
-        form.addRow(btns)
-        
-        if dialog.exec() != QDialog.DialogCode.Accepted:
-            if was_playing: self.toggle_play()
-            return
-
-        target_fps = spin_fps.value()
-        use_transparent = chk_transparent.isChecked()
-        use_hq = chk_hq.isChecked()
-        
-        file_path, _ = QFileDialog.getSaveFileName(self, "Save GIF", "", "GIF Files (*.gif)")
-        if not file_path:
-            if was_playing: self.toggle_play()
-            return
-            
-        if not file_path.lower().endswith('.gif'):
-             file_path += '.gif'
-             
-        # Generate Frames
-        images = []
-        mode_data = self.parser.final_modes[row]
-        mode_vecs = mode_data['vector']
-        
-        self.reset_geometry()
-        
-        try:
-            for i in range(20):
-                cycle_pos = i / 20.0
-                phase = cycle_pos * 2 * np.pi
-                scale = self.slider_amp.value() / 20.0
-                factor = np.sin(phase) * scale
-                
-                self.apply_displacement(mode_vecs, factor)
-                self.mw.draw_molecule_3d(self.base_mol)
-                self.update_vectors(mode_vecs, factor)
-                self.mw.plotter.render()
-                
-                img_array = self.mw.plotter.screenshot(transparent_background=use_transparent, return_img=True)
-                if img_array is not None:
-                     img = Image.fromarray(img_array)
-                     images.append(img)
-            
-            if images:
-                duration_ms = int(1000 / target_fps)
-                processed_images = []
-                for img in images:
-                    if use_hq:
-                        if use_transparent:
-                            # Alpha preservation with adaptive palette wrapper
-                            alpha = img.split()[3]
-                            img_rgb = img.convert("RGB")
-                            # Quantize to 255 colors to leave room for transparency
-                            img_p = img_rgb.convert('P', palette=Image.Palette.ADAPTIVE, colors=255)
-                            # Set simple transparency
-                            mask = Image.eval(alpha, lambda a: 255 if a <= 128 else 0)
-                            img_p.paste(255, mask)
-                            img_p.info['transparency'] = 255
-                            processed_images.append(img_p)
-                        else:
-                            processed_images.append(img.convert("P", palette=Image.Palette.ADAPTIVE, colors=256))
-                    else:
-                        if use_transparent:
-                            processed_images.append(img.convert("RGBA"))
-                        else:
-                            processed_images.append(img.convert("RGB"))
-
-                processed_images[0].save(file_path, save_all=True, append_images=processed_images[1:], duration=duration_ms, loop=0, disposal=2)
-                QMessageBox.information(self, "Success", f"Saved GIF to:\n{file_path}")
-                
-        except Exception as e:
-            QMessageBox.critical(self, "Error", f"Failed to save GIF: {e}")
-            traceback.print_exc()
-        finally:
-            self.reset_geometry()
-            if was_playing:
-                 self.toggle_play()
-
-    
-    def on_dock_visibility_changed(self, visible):
-        if not visible and self.is_playing:
-            self.stop_play()
-
-    def close_plugin(self):
-        self.stop_play()
-        self.remove_vectors()
-        self.animation_step = 0
-    def show_spectrum(self):
-        # Use final_modes which has proper freq-intensity alignment
-        # and already filters out low frequencies (translations/rotations)
-        
-        if not hasattr(self.parser, 'final_modes') or not self.parser.final_modes:
-             QMessageBox.warning(self, "No Data", "No vibrational frequencies available.")
-             return
-        
-        freqs = []
-        intensities = []
-        
-        for mode in self.parser.final_modes:
-            freqs.append(mode['freq'])
-            intensities.append(mode.get('intensity', 0.0))
-        
-        dlg = SpectrumDialog(freqs, intensities, self)
-        dlg.exec()
-
-
-class SpectrumDialog(QDialog):
-    def __init__(self, freqs, intensities, parent=None):
-        super().__init__(parent)
-        self.setWindowTitle("IR Spectrum")
-        self.resize(800, 600)
-        
-        self.freqs = np.array(freqs)
-        self.intensities = np.array(intensities)
-        
-        # Layout
-        layout = QVBoxLayout(self)
-        
-        # Plot Area
-        self.plot_widget = SpectrumPlotWidget(self.freqs, self.intensities)
-        layout.addWidget(self.plot_widget)
-        
-        # Controls
-        controls = QHBoxLayout()
-        
-        controls.addWidget(QLabel("Gaussian Broadening (FWHM, cm⁻¹):"))
-        self.spin_fwhm = QSpinBox()
-        self.spin_fwhm.setRange(1, 500)
-        self.spin_fwhm.setValue(50)
-        self.spin_fwhm.valueChanged.connect(self.on_fwhm_changed)
-        controls.addWidget(self.spin_fwhm)
-        
-        controls.addWidget(self.spin_fwhm)
-        
-        # Axis Range
-        controls.addWidget(QLabel("Min WN:"))
-        self.spin_min = QSpinBox()
-        self.spin_min.setRange(0, 5000)
-        self.spin_min.setValue(0)
-        self.spin_min.setSingleStep(100)
-        self.spin_min.valueChanged.connect(self.on_range_changed)
-        controls.addWidget(self.spin_min)
-
-        controls.addWidget(QLabel("Max WN:"))
-        self.spin_max = QSpinBox()
-        self.spin_max.setRange(0, 5000)
-        self.spin_max.setValue(4000)
-        self.spin_max.setSingleStep(100)
-        self.spin_max.valueChanged.connect(self.on_range_changed)
-        controls.addWidget(self.spin_max)
-        
-        btn_csv = QPushButton("Export CSV")
-        btn_csv.clicked.connect(self.export_csv)
-        controls.addWidget(btn_csv)
-        
-        btn_png = QPushButton("Export Image")
-        btn_png.clicked.connect(self.export_png)
-        controls.addWidget(btn_png)
-        
-        btn_close = QPushButton("Close")
-        btn_close.clicked.connect(self.accept)
-        controls.addWidget(btn_close)
-        
-        layout.addLayout(controls)
-        self.setLayout(layout)
-        
-        # Initial Plot
-        self.on_range_changed()
-
-    def on_fwhm_changed(self, val):
-        self.plot_widget.set_fwhm(val)
-
-    def on_range_changed(self):
-        mn = self.spin_min.value()
-        mx = self.spin_max.value()
-        if mx > mn:
-             self.plot_widget.set_range(mn, mx)
-
-    def export_csv(self):
-        fname, _ = QFileDialog.getSaveFileName(self, "Save Spectrum Data", "", "CSV Files (*.csv)")
-        if fname:
-            if not fname.lower().endswith('.csv'): fname += '.csv'
-            try:
-                x, y = self.plot_widget.get_curve_data()
-                with open(fname, 'w') as f:
-                    f.write("Frequency,Intensity\n")
-                    for xi, yi in zip(x, y):
-                        f.write(f"{xi:.2f},{yi:.4f}\n")
-                QMessageBox.information(self, "Success", "Saved CSV.")
-            except Exception as e:
-                QMessageBox.critical(self, "Error", str(e))
-
-    def export_png(self):
-        fname, _ = QFileDialog.getSaveFileName(self, "Save Spectrum Image", "", "PNG Files (*.png)")
-        if fname:
-            if not fname.lower().endswith('.png'): fname += '.png'
-            try:
-                # Capture the widget
-                pixmap = self.plot_widget.grab()
-                pixmap.save(fname)
-                QMessageBox.information(self, "Success", "Saved Image.")
-            except Exception as e:
-                QMessageBox.critical(self, "Error", str(e))
-
-class SpectrumPlotWidget(QWidget):
-    def __init__(self, freqs, intensities, parent=None):
-        super().__init__(parent)
-        self.freqs = freqs
-        self.intensities = intensities
-        self.fwhm = 80.0
-        self.curve_x = []
-        self.curve_y = []
-
-        self.setAutoFillBackground(True)
-        self.setStyleSheet("background-color: white;")
-        
-        self.min_x = 0.0
-        self.max_x = 4000.0
-
-    def set_fwhm(self, val):
-        self.fwhm = val
-        self.recalc_curve()
-        self.update()
-
-    def set_range(self, mn, mx):
-        self.min_x = float(mn)
-        self.max_x = float(mx)
-        self.recalc_curve()
-        self.update()
-
-    def get_curve_data(self):
-        return self.curve_x, self.curve_y
-
-    def recalc_curve(self):
-        if len(self.freqs) == 0: return
-        
-        # X resolution based on custom range
-        self.curve_x = np.linspace(self.min_x, self.max_x, 1000)
-        self.curve_y = np.zeros_like(self.curve_x)
-        
-        # Sum Gaussians
-        sigma = self.fwhm / 2.35482 
-        
-        for f, i in zip(self.freqs, self.intensities):
-            self.curve_y += i * np.exp(-(self.curve_x - f)**2 / (2 * sigma**2))
-            
-        # Do NOT normalize - preserve actual intensity values
-
-    def paintEvent(self, event):
-        painter = QPainter(self)
-        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
-        
-        w = self.width()
-        h = self.height()
-        
-        # Margins
-        margin_l = 50
-        margin_r = 20
-        margin_t = 20
-        margin_b = 60  # Increased from 40 for better spacing
-        
-        plot_w = w - margin_l - margin_r
-        plot_h = h - margin_t - margin_b
-        
-        if len(self.curve_x) == 0:
-            painter.drawText(self.rect(), Qt.AlignmentFlag.AlignCenter, "No Data")
-            return
-            
-        # Calculate max_y from both curve AND raw intensities to prevent stick normalization
-        # Add 10% padding for better visibility
-        max_curve = np.max(self.curve_y) if len(self.curve_y) > 0 else 1.0
-        max_intensity = np.max(self.intensities) if len(self.intensities) > 0 else 1.0
-        max_y = max(max_curve, max_intensity) * 1.1  # 1.1x for padding
-        if max_y == 0: max_y = 1.0
-        min_x = np.min(self.curve_x)
-        max_x = np.max(self.curve_x)
-        range_x = max_x - min_x
-        if range_x == 0: range_x = 100
-        
-        # Helper to transform
-        # Inverted X: Max (left) -> Min (right)
-        # Inverted Y: 0 (top) -> Max (bottom) 
-        
-        def to_screen(x, y):
-            # X: margin_l corresponds to max_x, w - margin_r corresponds to min_x
-            # formula: x_ratio = (max_x - x) / range_x
-            # sx = margin_l + x_ratio * plot_w
-            sx = margin_l + (max_x - x) / range_x * plot_w
-            
-            # Y: margin_t corresponds to 0, h - margin_b corresponds to max_y
-            # formula: y_ratio = y / max_y
-            # sy = margin_t + y_ratio * plot_h
-            sy = margin_t + (y / max_y) * plot_h
-            return sx, sy
-
-        # Draw Axes
-        painter.setPen(QPen(Qt.GlobalColor.black, 2))
-        painter.drawLine(margin_l, margin_t, w - margin_r, margin_t) # X-axis at top (Baseline)
-        painter.drawLine(margin_l, h - margin_b, w - margin_r, h - margin_b) # X-axis at bottom
-        
-        painter.drawLine(margin_l, h - margin_b, margin_l, margin_t) # Y (Left)
-        painter.drawLine(w - margin_r, h - margin_b, w - margin_r, margin_t) # Y (Right border)
-
-        # Draw Ticks / Labels (Simplified)
-        font = painter.font()
-        font.setPointSize(12)  # Increased from 8
-        painter.setFont(font)
-        
-        # X Ticks (approx 5)
-        # Inverted: Left is Max, Right is Min
-        n_ticks = 5
-        for i in range(n_ticks + 1):
-            # val goes from max_x to min_x
-            val = max_x - (range_x * i / n_ticks)
-            px, py = to_screen(val, 0)
-            # Label at bottom
-            painter.drawText(int(px)-20, h - margin_b + 5, 40, 20, Qt.AlignmentFlag.AlignCenter, f"{int(val)}")
-            painter.drawLine(int(px), h - margin_b, int(px), h - margin_b + 5)
-
-        # Labels
-        font.setPointSize(14)  # Increased from 10
-        font.setBold(True)
-        painter.setFont(font)
-        painter.drawText(0, h-25, w, 20, Qt.AlignmentFlag.AlignCenter, "Wavenumber (cm⁻¹)")
-        
-        # Draw baseline at y=0
-        baseline_x_start, baseline_y = to_screen(max_x, 0)
-        baseline_x_end, _ = to_screen(min_x, 0)
-        painter.setPen(QPen(QColor(150, 150, 150), 1, Qt.PenStyle.DashLine))
-        painter.drawLine(int(baseline_x_start), int(baseline_y), int(baseline_x_end), int(baseline_y))
-        
-        # Draw Curve
-        painter.setPen(QPen(Qt.GlobalColor.blue, 2))
-        path_points = []
-        for x, y in zip(self.curve_x, self.curve_y):
-            sx, sy = to_screen(x, y)
-            path_points.append( (sx, sy) )
-            
-        if len(path_points) > 1:
-            from PyQt6.QtCore import QPointF
-            qpoints = [QPointF(x, y) for x, y in path_points]
-            painter.drawPolyline(qpoints)
-            
-        # Draw Sticks (Bars) for original frequencies
-        painter.setPen(QPen(QColor(255, 0, 0, 100), 1))
-        for f, i in zip(self.freqs, self.intensities):
-             sx, sy = to_screen(f, i)
-             px_base, py_base = to_screen(f, 0)
-             painter.drawLine(int(sx), int(py_base), int(sx), int(sy))
-
-    # def closeEvent(self, event):
-    #     self.close_plugin()
-    #     super().closeEvent(event)
-
-
-    
-    def on_dock_visibility_changed(self, visible):
-        if not visible:
-            self.stop_play()
-            self.animation_step = 0
-            if self.base_mol:
-                self.reset_geometry()
-                 # Force redraw
-                if hasattr(self.mw, 'plotter'):
-                    self.mw.plotter.render()
-
-
-def load_from_file(main_window, fname):
-    dock = None
-    analyzer = None
-    
-    # Check existing docks
-    for d in main_window.findChildren(QDockWidget):
-        if d.windowTitle() == "ORCA Output Freq Analyzer":
-            dock = d
-            analyzer = d.widget()
-            break
-            
-    if not dock:
-        dock = QDockWidget("ORCA Output Freq Analyzer", main_window)
-        dock.setAllowedAreas(Qt.DockWidgetArea.LeftDockWidgetArea | Qt.DockWidgetArea.RightDockWidgetArea)
-        analyzer = OrcaOutFreqAnalyzer(main_window, dock)
-        dock.setWidget(analyzer)
-        main_window.addDockWidget(Qt.DockWidgetArea.RightDockWidgetArea, dock)
-        
-        # Connect visibility change
-        dock.visibilityChanged.connect(analyzer.on_dock_visibility_changed)
-    
-    dock.show()
-    dock.raise_()
-    
-    if analyzer:
-        analyzer.load_file(fname)
-
-def is_valid_orca_file(filepath):
-    try:
-        with open(filepath, 'r', errors='ignore') as f:
-            # Check first 500 lines for "ORCA" keyword to be safe
-            for _ in range(500):
-                line = f.readline()
-                if not line: break
-                if "ORCA" in line or "O   R   C   A" in line:
-                    return True
-        return False
-    except:
-        return False
-
-def run(mw):
-    # Smart Open Logic
-    if hasattr(mw, 'current_file_path') and mw.current_file_path:
-        fpath = mw.current_file_path.lower()
-        if fpath.endswith((".out", ".log")):
-                if is_valid_orca_file(mw.current_file_path):
-                    load_from_file(mw, mw.current_file_path)
-                    return
-    
-    fname, _ = QFileDialog.getOpenFileName(mw, "Open ORCA Output", "", "ORCA Output (*.out *.log);;All Files (*)")
-    if not fname: return
-    
-    if is_valid_orca_file(fname):
-        load_from_file(mw, fname)
-    else:
-        QMessageBox.warning(mw, "Invalid File", "This does not appear to be a valid ORCA output file.")
-
-def initialize(context):
-    mw = context.get_main_window()
-    
-    def load_wrapper(fname):
-        # Validate ORCA file before loading
-        if is_valid_orca_file(fname):
-            load_from_file(mw, fname)
-        else:
-             print(f"Skipping invalid ORCA file: {fname}")
-
-    # 1. Register File Openers
-    # Note: .log can be generic, but our valid check helps
-    context.register_file_opener('.out', load_wrapper)
-    context.register_file_opener('.log', load_wrapper)
-
-    # 2. Register Drop Handler
-    def drop_handler(file_path):
-        fpath = file_path.lower()
-        if fpath.endswith(('.out', '.log')):
-            if is_valid_orca_file(file_path):
-                load_from_file(mw, file_path)
-                return True
-        return False
-
-    if hasattr(context, 'register_drop_handler'):
-        context.register_drop_handler(drop_handler, priority=10)
-