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

moleditpy/plugins/Input Generator/orca_input_generator_neo.py

@@ -1,1028 +0,0 @@
-# -*- coding: utf-8 -*-
-import os
-from PyQt6.QtWidgets import (QMessageBox, QDialog, QVBoxLayout, QLabel, 
-                             QLineEdit, QSpinBox, QPushButton, QFileDialog, 
-                             QFormLayout, QGroupBox, QHBoxLayout, QComboBox, QTextEdit, 
-                             QTabWidget, QCheckBox, QWidget, QScrollArea, QMenu)
-from PyQt6.QtGui import QPalette, QColor, QAction, QFont
-from PyQt6.QtCore import Qt
-from rdkit import Chem
-from rdkit.Chem import rdMolTransforms
-import json
-
-__version__="2025.12.18"
-__author__="HiroYokoyama"
-PLUGIN_NAME = "ORCA Input Generator Neo"
-SETTINGS_FILE = os.path.join(os.path.dirname(__file__), "orca_input_generator_neo.json")
-
-class OrcaKeywordBuilderDialog(QDialog):
-    """
-    Dialog to construct the ORCA Job Route line.
-    """
-    def __init__(self, parent=None, current_route=""):
-        super().__init__(parent)
-        self.setWindowTitle("ORCA Keyword Builder")
-        self.resize(700, 600)
-        self.ui_ready = False
-        self.current_route = current_route
-        self.setup_ui()
-        self.parse_route(current_route)
-
-    def setup_ui(self):
-        layout = QVBoxLayout()
-        
-        self.tabs = QTabWidget()
-        
-        # --- Tab 1: Method & Basis ---
-        self.tab_method = QWidget()
-        self.setup_method_tab()
-        self.tabs.addTab(self.tab_method, "Method/Basis")
-        
-        # --- Tab 2: Job Type ---
-        self.tab_job = QWidget()
-        self.setup_job_tab()
-        self.tabs.addTab(self.tab_job, "Job Type")
-        
-        # --- Tab 3: Solvation & Disp ---
-        self.tab_solvation = QWidget()
-        self.setup_solvation_tab()
-        self.tabs.addTab(self.tab_solvation, "Solvation/Dispersion")
-        
-        # --- Tab 4: Properties ---
-        self.tab_props = QWidget()
-        self.setup_props_tab()
-        self.tabs.addTab(self.tab_props, "Properties")
-
-        layout.addWidget(self.tabs)
-
-        # --- Preview ---
-        preview_group = QGroupBox("Keyword Preview")
-        preview_layout = QVBoxLayout()
-        self.preview_label = QLabel()
-        self.preview_label.setWordWrap(True)
-        self.preview_label.setStyleSheet("font-weight: bold; color: blue; font-size: 14px;")
-        preview_layout.addWidget(self.preview_label)
-        preview_group.setLayout(preview_layout)
-        layout.addWidget(preview_group)
-
-        # --- Buttons ---
-        btn_layout = QHBoxLayout()
-        self.btn_ok = QPushButton("Apply to Job")
-        self.btn_ok.clicked.connect(self.accept)
-        self.btn_cancel = QPushButton("Cancel")
-        self.btn_cancel.clicked.connect(self.reject)
-        btn_layout.addStretch()
-        btn_layout.addWidget(self.btn_ok)
-        btn_layout.addWidget(self.btn_cancel)
-        layout.addLayout(btn_layout)
-
-        self.setLayout(layout)
-        
-        self.connect_signals()
-        self.ui_ready = True
-        self.update_ui_state() # Initial UI state update
-        self.update_preview()
-
-    def setup_method_tab(self):
-        layout = QFormLayout()
-
-        # Method Type
-        self.method_type = QComboBox()
-        self.method_type.addItems([
-            "DFT (GGA/Hybrid/Meta)", 
-            "DFT (Range-Separated)", 
-            "DFT (Double Hybrid)",
-            "Wavefunction (HF/MP2)",
-            "Wavefunction (Coupled Cluster)",
-            "Wavefunction (Multireference)",
-            "Semi-Empirical"
-        ])
-        self.method_type.currentIndexChanged.connect(self.update_method_list)
-        layout.addRow("Method Type:", self.method_type)
-        
-        # Method Name
-        self.method_name = QComboBox()
-        self.update_method_list()
-        layout.addRow("Method:", self.method_name)
-        
-        # Basis Set
-        self.basis_set = QComboBox()
-        basis_groups = [
-            "--- Karlsruhe (Def2) ---",
-            "def2-SV(P)", "def2-SVP", "def2-TZVP", "def2-QZVP",
-            "ma-def2-SVP", "ma-def2-TZVP", "ma-def2-QZVP",
-            "def2-TZVPP", "def2-QZVPP",
-            "--- Dunning (cc-pV) ---",
-            "cc-pVDZ", "cc-pVTZ", "cc-pVQZ", "cc-pV5Z",
-            "aug-cc-pVDZ", "aug-cc-pVTZ", "aug-cc-pVQZ", "aug-cc-pV5Z",
-            "--- Pople ---",
-            "6-31G", "6-31G*", "6-311G", "6-311G*", "6-311G**", 
-            "6-31+G*", "6-311+G**", "6-31++G**",
-            "--- Jensen (pc) ---",
-            "pc-0", "pc-1", "pc-2", "pc-3", "aug-pc-1", "aug-pc-2",
-            "--- Other ---",
-            "EPR-II", "EPR-III", "IGLO-II", "IGLO-III"
-        ]
-        self.basis_set.addItems(basis_groups)
-        self.basis_set.setCurrentText("def2-SVP")
-        layout.addRow("Basis Set:", self.basis_set)
-        
-        # Auxiliary Basis (RI/RIJCOSX)
-        self.aux_basis = QComboBox()
-        self.aux_basis.addItems([
-            "Auto (Def2/J, etc)", "None", "Def2/J", "Def2/JK", 
-            "AutoAux", "NoAux"
-        ])
-        layout.addRow("Aux Basis (RI):", self.aux_basis)
-
-        self.tab_method.setLayout(layout)
-
-    def update_method_list(self):
-        mtype = self.method_type.currentText()
-        self.method_name.blockSignals(True)
-        self.method_name.clear()
-        
-        if "GGA/Hybrid" in mtype:
-             self.method_name.addItems([
-                 "B3LYP", "PBE0", "PBE", "BP86", "BLYP", "PW91", 
-                 "TPSSh", "TPSS", "SCAN", "r2SCAN-3c", "B97-3c", "PBEh-3c", # 3c系を追加
-                 "M06", "M06-2X", "M06-HF", "M06-L",
-                 "X3LYP", "O3LYP", "B3PW91", "BHandHLYP" # BH&HLYPをBHandHLYPに修正
-             ])
-        elif "Range-Separated" in mtype:
-             self.method_name.addItems([
-                 "wB97X-D3", "wB97X-V", "wB97M-V", "wB97X", "wB97",
-                 "CAM-B3LYP", "LC-wPBE", "wPBE", "wPBEh"
-             ])
-        elif "Double Hybrid" in mtype:
-             self.method_name.addItems([
-                 "B2PLYP", "mPW2PLYP", "B2GP-PLYP", "DSD-PBEP86", "DSD-BLYP",
-                 "PTPSS-D3", "PWPB95"
-             ])
-        elif "Wavefunction (HF/MP2)" in mtype:
-             self.method_name.addItems([
-                 "HF", "HF-3c", "UHF", "ROHF", # HF-3cを追加
-                 "MP2", "RI-MP2", "SCS-MP2", "OO-RI-MP2"
-             ])
-        elif "Coupled Cluster" in mtype:
-             self.method_name.addItems([
-                 "DLPNO-CCSD(T)", "DLPNO-CCSD(T1)", "DLPNO-CCSD", 
-                 "CCSD(T)", "CCSD", "QCISD(T)", "CEPA/1"
-             ])
-        elif "Multireference" in mtype:
-             self.method_name.addItems([
-                 "CASSCF", "NEVPT2", "DLPNO-NEVPT2", "MRCI"
-             ])
-        elif "Semi-Empirical" in mtype:
-            self.method_name.addItems(["XT", "GFN1-xTB", "GFN2-xTB", "PM3", "AM1", "ZINDO/S", "PM6", "MNDO"])
-        else:
-            self.method_name.addItem("Custom")
-            
-        self.method_name.blockSignals(False)
-        self.update_ui_state() # Update visibility when method type changes
-        self.update_preview()
-
-    def setup_job_tab(self):
-        layout = QVBoxLayout()
-        
-        self.job_type = QComboBox()
-        self.job_type.addItems([
-            "Optimization + Freq (Opt Freq)", 
-            "Optimization Only (Opt)", 
-            "Frequency Only (Freq)", 
-            "Single Point Energy (SP)",
-            "Scan (Relaxed Surface)",
-            "Transition State Opt (OptTS)",
-            "Gradient",
-            "Hessian"
-        ])
-        layout.addWidget(QLabel("Job Task:"))
-        layout.addWidget(self.job_type)
-        self.job_type.currentIndexChanged.connect(self.update_ui_state)
-        
-        # Opt Options
-        self.opt_group = QGroupBox("Optimization Options")
-        opt_layout = QHBoxLayout()
-        self.opt_tight = QCheckBox("TightOpt")
-        self.opt_loose = QCheckBox("LooseOpt")
-        self.opt_calcfc = QCheckBox("CalcFC")
-        self.opt_ts_mode = QCheckBox("CalcHess (for TS)")
-        opt_layout.addWidget(self.opt_tight)
-        opt_layout.addWidget(self.opt_loose)
-        opt_layout.addWidget(self.opt_calcfc)
-        opt_layout.addWidget(self.opt_ts_mode)
-        self.opt_group.setLayout(opt_layout)
-        layout.addWidget(self.opt_group)
-        
-        # Freq Options
-        self.freq_group = QGroupBox("Freq Options")
-        freq_layout = QHBoxLayout()
-        self.freq_num = QCheckBox("NumFreq")
-        self.freq_raman = QCheckBox("Raman")
-        freq_layout.addWidget(self.freq_num)
-        freq_layout.addWidget(self.freq_raman)
-        self.freq_group.setLayout(freq_layout)
-        layout.addWidget(self.freq_group)
-        
-        layout.addStretch()
-        self.tab_job.setLayout(layout)
-
-    def setup_solvation_tab(self):
-        layout = QFormLayout()
-        
-        self.solv_model = QComboBox()
-        self.solv_model.addItems(["None", "CPCM", "SMD", "IEFPCM", "CPC(Water) (Short)"])
-        self.solv_model.currentIndexChanged.connect(self.update_ui_state)
-        layout.addRow("Solvation Model:", self.solv_model)
-        
-        self.solvent = QComboBox()
-        solvents = [
-            "Water", "Acetonitrile", "Methanol", "Ethanol", 
-            "Chloroform", "Dichloromethane", "Toluene", 
-            "THF", "DMSO", "Cyclohexane", "Benzene", "Acetone",
-            "CCl4", "DMF", "HMPA", "Pyridine"
-        ]
-        self.solvent.addItems(solvents)
-        layout.addRow("Solvent:", self.solvent)
-        
-        layout.addRow(QLabel(" "))
-        
-        self.dispersion = QComboBox()
-        self.dispersion.addItems(["None", "D3BJ", "D3Zero", "D4", "D2", "NL"])
-        layout.addRow("Dispersion Correction:", self.dispersion)
-        
-        self.tab_solvation.setLayout(layout)
-
-    def setup_props_tab(self):
-        layout = QFormLayout()
-        
-        self.rijcosx = QCheckBox("RIJCOSX / RI approximation")
-        self.rijcosx.setChecked(True)
-        layout.addRow(self.rijcosx)
-        
-        self.grid_combo = QComboBox()
-        self.grid_combo.addItems(["Default", "DefGrid2", "DefGrid3", "Grid4", "Grid5", "Grid6", "NoGrid"])
-        layout.addRow("Grid:", self.grid_combo)
-
-        self.scf_conv = QComboBox()
-        self.scf_conv.addItems(["Default", "LooseSCF", "TightSCF", "VeryTightSCF"])
-        layout.addRow("SCF Convergence:", self.scf_conv)
-
-        # NBO
-        self.pop_nbo = QCheckBox("NBO Analysis (! NBO)")
-        layout.addRow(self.pop_nbo)
-
-        self.tab_props.setLayout(layout)
-
-    def connect_signals(self):
-        widgets = [
-            self.method_type, self.method_name, self.basis_set, self.aux_basis,
-            self.job_type, self.opt_tight, self.opt_loose, self.opt_calcfc, self.opt_ts_mode,
-            self.freq_num, self.freq_raman,
-            self.solv_model, self.solvent, self.dispersion,
-            self.rijcosx, self.grid_combo, self.scf_conv, self.pop_nbo
-        ]
-        for w in widgets:
-            if isinstance(w, QComboBox):
-                w.currentIndexChanged.connect(self.update_preview)
-            elif isinstance(w, QCheckBox):
-                w.toggled.connect(self.update_preview)
-            elif isinstance(w, QSpinBox):
-                w.valueChanged.connect(self.update_preview)
-
-    def update_ui_state(self):
-        """Update usability of widgets based on current selection."""
-        if not getattr(self, 'ui_ready', False): return
-
-        # 1. Method Dependent
-        mtype = self.method_type.currentText()
-        is_semi = "Semi-Empirical" in mtype
-        
-        # Disable Basis Set & Aux Basis for Semi-Empirical
-        self.basis_set.setEnabled(not is_semi)
-        self.aux_basis.setEnabled(not is_semi)
-        
-        # Handling RI / RIJCOSX
-        if is_semi:
-            self.rijcosx.setEnabled(False)
-            self.rijcosx.setChecked(False)
-            self.rijcosx.setText("RIJCOSX (N/A)")
-        else:
-            self.rijcosx.setEnabled(True)
-            if "Wavefunction" in mtype:
-                self.rijcosx.setText("RI Approximation (! RI ...)")
-            else:
-                self.rijcosx.setText("RIJCOSX (Speed up Hybrid DFT)")
-
-        # 2. Solvation
-        solv = self.solv_model.currentText()
-        is_solvated = solv != "None"
-        self.solvent.setEnabled(is_solvated)
-        if "CPC(Water)" in solv:
-             self.solvent.setEnabled(False) # Water is implied
-
-        # 3. Job Type
-        job_txt = self.job_type.currentText()
-        is_opt = "Opt" in job_txt or "Scan" in job_txt
-        is_freq = "Freq" in job_txt
-        
-        self.opt_group.setVisible(is_opt)
-        self.freq_group.setVisible(is_freq)
-
-        # 4. TD-DFT (Removed from Route Builder, handled via blocks)
-
-    def update_preview(self):
-        if not getattr(self, 'ui_ready', False):
-            return
-
-        route_parts = ["!"]
-        
-        # Method / Basis
-        method = self.method_name.currentText()
-        basis = self.basis_set.currentText()
-        
-        # 3c methods usually don't need basis set
-        mtype = self.method_type.currentText()
-        if "Semi-Empirical" in mtype:
-            route_parts.append(method)
-        elif "3c" in method:
-            route_parts.append(method)
-        else:
-            route_parts.append(method)
-            route_parts.append(basis)
-            
-            # RIJCOSX / RI
-            if self.rijcosx.isEnabled() and self.rijcosx.isChecked():
-                if "Wavefunction" in mtype:
-                     route_parts.append("RI")
-                else:
-                     route_parts.append("RIJCOSX")
-                     
-                aux = self.aux_basis.currentText()
-                if "Def2/J" in aux: route_parts.append("Def2/J")
-                elif "Def2/JK" in aux: route_parts.append("Def2/JK")
-
-        # Job Type
-        job_txt = self.job_type.currentText()
-        if "Opt Freq" in job_txt: route_parts.extend(["Opt", "Freq"])
-        elif "Opt Only" in job_txt: route_parts.append("Opt")
-        elif "OptTS" in job_txt: route_parts.append("OptTS")
-        elif "Freq Only" in job_txt: route_parts.append("Freq")
-        elif "Scan" in job_txt: route_parts.append("Scan")
-        elif "Gradient" in job_txt: route_parts.append("Gradient")
-        elif "Hessian" in job_txt: route_parts.append("Hessian")
-        elif "SP" in job_txt: pass # No keyword
-        
-        # Opt Options
-        if self.opt_group.isVisible():
-            if self.opt_tight.isChecked(): route_parts.append("TightOpt")
-            if self.opt_loose.isChecked(): route_parts.append("LooseOpt")
-            if self.opt_calcfc.isChecked(): route_parts.append("CalcFC")
-            if self.opt_ts_mode.isChecked(): route_parts.append("CalcHess")
-        
-        # Freq Options
-        if self.freq_group.isVisible():
-            if self.freq_num.isChecked(): route_parts.append("NumFreq")
-        
-        # Solvation
-        solv = self.solv_model.currentText()
-        if solv != "None":
-            if "CPC(Water)" in solv:
-                 route_parts.append("CPC(Water)")
-            else:
-                solvent = self.solvent.currentText()
-                if "CPCM" == solv:
-                    route_parts.append(f"CPCM({solvent})")
-                elif "SMD" == solv:
-                    route_parts.append(f"CPCM({solvent})")
-                    route_parts.append("SMD")
-                elif "IEFPCM" == solv:
-                    route_parts.append(f"CPCM({solvent})") 
-
-        # Dispersion
-        disp = self.dispersion.currentText()
-        if disp != "None":
-            route_parts.append(disp)
-
-        # SCF / Grid
-        scf = self.scf_conv.currentText()
-        if scf != "Default": route_parts.append(scf)
-        
-        grid = self.grid_combo.currentText()
-        if grid != "Default": route_parts.append(grid)
-        
-        # NBO
-        if self.pop_nbo.isChecked(): route_parts.append("NBO")
-
-        self.preview_str = " ".join(route_parts)
-        self.preview_label.setText(self.preview_str)
-
-    def get_route(self):
-        return self.preview_str
-        
-    def parse_route(self, route):
-        pass
-
-class OrcaSetupDialogNeo(QDialog):
-    """
-    ORCA Input Generator Neo
-    """
-    def __init__(self, parent=None, mol=None, filename=None):
-        super().__init__(parent)
-        self.setWindowTitle(PLUGIN_NAME)
-        self.resize(600, 700)
-        self.mol = mol
-        self.filename = filename
-        self.setup_ui()
-        self.load_presets_from_file()
-        self.calc_initial_charge_mult()
-
-    def setup_ui(self):
-        main_layout = QVBoxLayout()
-
-        # --- 0. Preset Management ---
-        preset_group = QGroupBox("Preset Management")
-        preset_layout = QHBoxLayout()
-        
-        self.preset_combo = QComboBox()
-        self.preset_combo.currentIndexChanged.connect(self.apply_selected_preset)
-        preset_layout.addWidget(QLabel("Preset:"))
-        preset_layout.addWidget(self.preset_combo, 1)
-
-        self.btn_save_preset = QPushButton("Save New...")
-        self.btn_save_preset.clicked.connect(self.save_preset_dialog)
-        preset_layout.addWidget(self.btn_save_preset)
-
-        self.btn_del_preset = QPushButton("Delete")
-        self.btn_del_preset.clicked.connect(self.delete_preset)
-        preset_layout.addWidget(self.btn_del_preset)
-
-        preset_group.setLayout(preset_layout)
-        main_layout.addWidget(preset_group)
-
-        # --- 1. Resource Configuration ---
-        res_group = QGroupBox("Resources (%pal, %maxcore)")
-        res_layout = QFormLayout()
-
-        # NProcs
-        self.nproc_spin = QSpinBox()
-        self.nproc_spin.setRange(1, 128)
-        self.nproc_spin.setValue(4)
-        res_layout.addRow("Number of Processors (nprocs):", self.nproc_spin)
-
-        # Memory
-        self.mem_spin = QSpinBox()
-        self.mem_spin.setRange(100, 999999)
-        self.mem_spin.setValue(2000) 
-        self.mem_spin.setSuffix(" MB")
-        res_layout.addRow("Memory per Core (MaxCore):", self.mem_spin)
-
-        res_group.setLayout(res_layout)
-        main_layout.addWidget(res_group)
-
-        # --- 2. Simple Input Line ---
-        kw_group = QGroupBox("Simple Input Line (!)")
-        kw_layout = QVBoxLayout()
-        
-        kw_h_layout = QHBoxLayout()
-        self.keywords_edit = QLineEdit("! B3LYP def2-SVP Opt Freq")
-        self.btn_route = QPushButton("Keyword Builder...")
-        self.btn_route.clicked.connect(self.open_keyword_builder)
-        kw_h_layout.addWidget(self.keywords_edit)
-        kw_h_layout.addWidget(self.btn_route)
-        
-        kw_layout.addWidget(QLabel("Keywords (starts with !):"))
-        kw_layout.addLayout(kw_h_layout)
-        
-        # Comment
-        self.comment_edit = QLineEdit("Generated by MoleditPy ORCA Neo")
-        kw_layout.addWidget(QLabel("Comment (# ...):"))
-        kw_layout.addWidget(self.comment_edit)
-
-        kw_group.setLayout(kw_layout)
-        main_layout.addWidget(kw_group)
-
-        # --- 3. Molecular State ---
-        mol_group = QGroupBox("Molecular Specification")
-        mol_layout = QHBoxLayout()
-        
-        self.charge_spin = QSpinBox()
-        self.charge_spin.setRange(-10, 10)
-        self.charge_spin.valueChanged.connect(self.validate_charge_mult)
-        
-        self.mult_spin = QSpinBox()
-        self.mult_spin.setRange(1, 10)
-        self.mult_spin.valueChanged.connect(self.validate_charge_mult)
-
-        mol_layout.addWidget(QLabel("Charge:"))
-        mol_layout.addWidget(self.charge_spin)
-        mol_layout.addWidget(QLabel("Multiplicity:"))
-        mol_layout.addWidget(self.mult_spin)
-
-        self.default_palette = self.charge_spin.palette()
-        
-        mol_group.setLayout(mol_layout)
-        main_layout.addWidget(mol_group)
-
-        # --- 3b. Coordinate Format ---
-        coord_group = QGroupBox("Coordinate Format")
-        coord_layout = QHBoxLayout()
-        self.coord_format_combo = QComboBox()
-        self.coord_format_combo.addItems(["Cartesian (XYZ)", "Internal (Z-Matrix / * int)", "Internal (Z-Matrix / * gzmt)"])
-        self.coord_format_combo.setCurrentIndex(0)
-        self.coord_format_combo.setEnabled(True)
-        coord_layout.addWidget(QLabel("Format:"))
-        coord_layout.addWidget(self.coord_format_combo)
-        coord_group.setLayout(coord_layout)
-        main_layout.addWidget(coord_group)
-
-        # --- 4. Advanced/Blocks ---
-        adv_group = QGroupBox("Advanced Blocks (Pre/Post Coordinates)")
-        adv_layout = QVBoxLayout()
-        
-        # Block Helper
-        blk_h_layout = QHBoxLayout()
-        blk_h_layout.addWidget(QLabel("Block Helper:"))
-        
-        self.block_combo = QComboBox()
-        self.block_combo.addItems([
-             "Select Block to Insert...",
-             "%scf ... end",
-             "%output ... end",
-             "%geom ... end",
-             "%elprop ... end",
-             "%plots ... end",
-             "%tddft ... end",
-             "%cis ... end", 
-             "%mrci ... end",
-             "%casscf ... end",
-             "%eprnmr ... end (Post)",
-        ])
-        blk_h_layout.addWidget(self.block_combo, 1)
-        
-        self.btn_insert_block = QPushButton("Insert")
-        self.btn_insert_block.clicked.connect(self.insert_block_template)
-        blk_h_layout.addWidget(self.btn_insert_block)
-        
-        adv_layout.addLayout(blk_h_layout)
-        
-        # Tabs for Pre/Post
-        self.adv_tabs = QTabWidget()
-        
-        self.adv_edit = QTextEdit()
-        self.adv_edit.setPlaceholderText("Pre-Coordinate Blocks\nExample:\n%scf\n MaxIter 100\nend")
-        self.adv_tabs.addTab(self.adv_edit, "Pre-Coordinate")
-        
-        self.post_adv_edit = QTextEdit()
-        self.post_adv_edit.setPlaceholderText("Post-Coordinate Blocks")
-        self.adv_tabs.addTab(self.post_adv_edit, "Post-Coordinate")
-        
-        adv_layout.addWidget(self.adv_tabs)
-
-        adv_group.setLayout(adv_layout)
-        main_layout.addWidget(adv_group)
-
-        # --- Save/Preview Buttons ---
-        btn_box = QHBoxLayout()
-        
-        self.btn_preview = QPushButton("Preview Input")
-        self.btn_preview.clicked.connect(self.preview_file)
-        btn_box.addWidget(self.btn_preview)
-        
-        self.save_btn = QPushButton("Save Input File...")
-        self.save_btn.clicked.connect(self.save_file)
-        self.save_btn.setStyleSheet("font-weight: bold; padding: 5px;")
-        btn_box.addWidget(self.save_btn)
-        
-        main_layout.addLayout(btn_box)
-        
-        self.setLayout(main_layout)
-
-    def insert_block_template(self):
-        txt = self.block_combo.currentText()
-        if "Select" in txt: return
-        
-        template = ""
-        if "%scf" in txt:
-             template = "%scf\n MaxIter 125\nend\n"
-        elif "%output" in txt:
-             template = "%output\n  PrintLevel     Normal\nend\n"
-        elif "%geom" in txt:
-             template = "%geom\n MaxIter 100\nend\n"
-        elif "%elprop" in txt:
-             template = "%elprop\n Dipole True\n Quadrupole True\nend\n"
-        elif "%plots" in txt:
-             template = "%plots\n Format Gaussian_Cube\nend\n"
-        elif "%tddft" in txt:
-             template = (
-                 "%tddft\n"
-                 "  NRoots 10       # Number of excited states\n"
-                 "  MaxDim 10       # Max dimension of expansion space\n"
-                 "  TDA true        # Tamm-Dancoff Approximation (true/false)\n"
-                 "  IRoot 1         # State of interest for gradient properties\n"
-                 "  Triplets true   # Calculate triplet states\n"
-                 "  Singlets true   # Calculate singlet states\n"
-                 "  DoQuad true     # Compute quadrupole intensities\n"
-                 "end\n"
-             )
-        elif "%cis" in txt:
-             template = "%cis\n NRoots 10\nend\n"
-        elif "%mrci" in txt:
-             template = "%mrci\n NewBlocks 1 1\nend\n"
-        elif "%casscf" in txt:
-             template = "%casscf\n Nel 2\n Norb 2\n Mult 1\nend\n"
-        elif "%eprnmr" in txt:
-             template = "%eprnmr\n     nuclei = all h {shift, ssall}\nend\n"
-             # Switch to Post-Coordinate tab automatically
-             self.adv_tabs.setCurrentWidget(self.post_adv_edit)
-        
-        current_widget = self.adv_tabs.currentWidget()
-        if isinstance(current_widget, QTextEdit):
-            cursor = current_widget.textCursor()
-            cursor.insertText(template)
-
-    def open_keyword_builder(self):
-        dialog = OrcaKeywordBuilderDialog(self, self.keywords_edit.text())
-        if dialog.exec() == QDialog.DialogCode.Accepted:
-            self.keywords_edit.setText(dialog.get_route())
-
-    def get_coords_lines(self):
-        if not self.mol: return []
-        lines = []
-        try:
-            conf = self.mol.GetConformer()
-            for i in range(self.mol.GetNumAtoms()):
-                pos = conf.GetAtomPosition(i)
-                atom = self.mol.GetAtomWithIdx(i)
-                lines.append(f"  {atom.GetSymbol(): <4} {pos.x: >12.6f} {pos.y: >12.6f} {pos.z: >12.6f}")
-        except Exception as e:
-            return [f"# Error: {e}"]
-        return lines
-
-    def _build_zmatrix_data(self):
-        """Helper to build Z-Matrix connectivity and values."""
-        if not self.mol: return None
-        try:
-            atoms = list(self.mol.GetAtoms())
-            conf = self.mol.GetConformer()
-            
-            def get_dist(i, j): return rdMolTransforms.GetBondLength(conf, i, j)
-            def get_angle(i, j, k): return rdMolTransforms.GetAngleDeg(conf, i, j, k)
-            def get_dihedral(i, j, k, l): return rdMolTransforms.GetDihedralDeg(conf, i, j, k, l)
-            
-            defined = []
-            z_data = [] # List of dicts for each atom
-            
-            for i, atom in enumerate(atoms):
-                symbol = atom.GetSymbol()
-                
-                # Atom 0
-                if i == 0:
-                    z_data.append({"symbol": symbol, "refs": []})
-                    defined.append(i)
-                    continue
-                
-                # Find neighbors in defined set
-                current_idx = atom.GetIdx()
-                neighbors = [n.GetIdx() for n in atom.GetNeighbors()]
-                candidates = [n for n in neighbors if n in defined]
-                if not candidates: candidates = defined[:] # Fallback
-                
-                refs = []
-                # Ref 1 (Distance)
-                if candidates: refs.append(candidates[-1])
-                else: refs.append(0)
-                
-                # Ref 2 (Angle)
-                candidates_2 = [x for x in defined if x != refs[0]]
-                if candidates_2: refs.append(candidates_2[-1])
-                
-                # Ref 3 (Dihedral)
-                candidates_3 = [x for x in defined if x not in refs]
-                if candidates_3: refs.append(candidates_3[-1])
-                
-                # Calculate Values
-                row = {"symbol": symbol, "refs": [], "values": []}
-                
-                if len(refs) >= 1:
-                    row["refs"].append(refs[0]) # 0-based index for calculation
-                    row["values"].append(get_dist(i, refs[0]))
-                
-                if len(refs) >= 2:
-                    row["refs"].append(refs[1])
-                    row["values"].append(get_angle(i, refs[0], refs[1]))
-                
-                if len(refs) >= 3:
-                    row["refs"].append(refs[2])
-                    row["values"].append(get_dihedral(i, refs[0], refs[1], refs[2]))
-                
-                z_data.append(row)
-                defined.append(i)
-                
-            return z_data
-        except Exception as e:
-            raise e
-
-    def get_zmatrix_standard_lines(self):
-        """
-        Generates * int style lines.
-        Format: Symbol Ref1 Ref2 Ref3 R Angle Dihed
-        Refs are 1-based integers. Missing refs/values are 0/0.0.
-        """
-        try:
-            data = self._build_zmatrix_data()
-            if not data: return []
-            
-            lines = []
-            for i, row in enumerate(data):
-                symbol = row["symbol"]
-                
-                # Prepare 3 refs (1-based) and 3 values
-                refs_out = [0, 0, 0]
-                vals_out = [0.0, 0.0, 0.0]
-                
-                current_refs = row["refs"]
-                current_vals = row.get("values", [])
-                
-                for k in range(min(3, len(current_refs))):
-                    refs_out[k] = current_refs[k] + 1 # Convert to 1-based
-                    vals_out[k] = current_vals[k]
-                    
-                line = f"  {symbol: <3} {refs_out[0]: >3} {refs_out[1]: >3} {refs_out[2]: >3} " \
-                       f"{vals_out[0]: >10.6f} {vals_out[1]: >10.6f} {vals_out[2]: >10.6f}"
-                lines.append(line)
-            return lines
-        except Exception as e:
-            return [f"# Error generating Standard Z-Matrix: {e}"]
-
-    def get_zmatrix_gzmt_lines(self):
-        """
-        Generates * gzmt style lines (Compact).
-        Format: Symbol Ref1 R Ref2 Angle Ref3 Dihed
-        Refs are 1-based.
-        """
-        try:
-            data = self._build_zmatrix_data()
-            if not data: return []
-            
-            lines = []
-            for i, row in enumerate(data):
-                symbol = row["symbol"]
-                line = f"  {symbol: <3}"
-                
-                current_refs = row["refs"]
-                current_vals = row.get("values", [])
-                
-                # Z-Matrix logic:
-                # Atom 1: Symbol
-                # Atom 2: Symbol Ref1 R
-                # Atom 3: Symbol Ref1 R Ref2 A
-                # Atom 4: Symbol Ref1 R Ref2 A Ref3 D
-                
-                if i == 0:
-                    pass
-                else:
-                    count = len(current_refs)
-                    if count >= 1:
-                        line += f"  {current_refs[0] + 1: >3} {current_vals[0]: .6f}"
-                    if count >= 2:
-                        line += f"  {current_refs[1] + 1: >3} {current_vals[1]: .6f}"
-                    if count >= 3:
-                        line += f"  {current_refs[2] + 1: >3} {current_vals[2]: .6f}"
-                
-                lines.append(line)
-            return lines
-        except Exception as e:
-            return [f"# Error generating GZMT Z-Matrix: {e}"]
-
-
-    def generate_input_content(self):
-        """Generates the full content of the input file as a string."""
-        content = []
-        
-        comment = self.comment_edit.text().strip()
-        if comment:
-                content.append(f"# {comment}")
-        
-        # Resources
-        nprocs = self.nproc_spin.value()
-        if nprocs > 1:
-            content.append(f"%pal nprocs {nprocs} end")
-        content.append(f"%maxcore {self.mem_spin.value()}\n")
-        
-        # Keywords
-        kw = self.keywords_edit.text().strip()
-        if not kw.startswith("!"): kw = "! " + kw
-        content.append(f"{kw}\n")
-        
-        # Advanced Blocks
-        adv = self.adv_edit.toPlainText().strip()
-        if adv:
-            content.append(f"{adv}\n")
-        
-        # Coordinates
-        is_cartesian = "Cartesian" in self.coord_format_combo.currentText()
-        coord_lines = self.get_coords_lines()
-        
-        if is_cartesian:
-            content.append(f"* xyz {self.charge_spin.value()} {self.mult_spin.value()}")
-            content.extend(coord_lines)
-            content.append("*")
-        else:
-            # Z-Matrix
-            is_gzmt = "gzmt" in self.coord_format_combo.currentText()
-            
-            if is_gzmt:
-                zmat_lines = self.get_zmatrix_gzmt_lines()
-                header = "* gzmt"
-            else:
-                zmat_lines = self.get_zmatrix_standard_lines()
-                header = "* int"
-                
-            if any("Error" in line for line in zmat_lines):
-                    content.append(f"# ERROR: Z-Matrix generation failed.")
-                    content.append(f"* xyz {self.charge_spin.value()} {self.mult_spin.value()}")
-                    content.extend(self.get_coords_lines())
-                    content.append("*")
-            else:
-                    content.append(f"{header} {self.charge_spin.value()} {self.mult_spin.value()}")
-                    content.extend(zmat_lines)
-                    content.append("*")
-                    
-        # Post-Coordinate Blocks
-        adv_post = self.post_adv_edit.toPlainText().strip()
-        if adv_post:
-            content.append(f"\n{adv_post}")
-            
-        return "\n".join(content)
-
-    def preview_file(self):
-        content = self.generate_input_content()
-        
-        d = QDialog(self)
-        d.setWindowTitle("Preview Input - ORCA Neo")
-        d.resize(600, 500)
-        l = QVBoxLayout()
-        t = QTextEdit()
-        t.setPlainText(content)
-        t.setReadOnly(True)
-        t.setFont(QFont("Courier New", 10))
-        l.addWidget(t)
-        
-        btn = QPushButton("Close")
-        btn.clicked.connect(d.accept)
-        l.addWidget(btn)
-        d.setLayout(l)
-        d.exec()
-
-    def save_file(self):
-        # Validation Check (e.g. Z-Matrix Error)
-        # We can re-check here or just trust generate_input_content
-        
-        default_name = ""
-        if self.filename:
-            base, _ = os.path.splitext(self.filename)
-            default_name = base + ".inp"
-        
-        file_path, _ = QFileDialog.getSaveFileName(
-            self, "Save ORCA Input", default_name, "ORCA Input (*.inp);;All Files (*)"
-        )
-
-        if file_path:
-            try:
-                content = self.generate_input_content()
-                with open(file_path, 'w', encoding='utf-8') as f:
-                    f.write(content)
-
-                QMessageBox.information(self, "Success", f"File saved:\n{file_path}")
-                self.accept()
-            except Exception as e:
-                QMessageBox.critical(self, "Error", f"Failed to save file:\n{e}")
-
-    # --- Preset Management (Similar to Gaussian Neo) ---
-    def load_presets_from_file(self):
-        self.presets_data = {}
-        if os.path.exists(SETTINGS_FILE):
-            try:
-                with open(SETTINGS_FILE, 'r', encoding='utf-8') as f:
-                    self.presets_data = json.load(f)
-            except Exception as e:
-                print(f"Error loading presets: {e}")
-        
-        if "Default" not in self.presets_data:
-            self.presets_data["Default"] = {
-                "nproc": 4, "maxcore": 2000, 
-                "route": "! B3LYP def2-SVP Opt Freq", "adv": "", "adv_post": ""
-            }
-        
-        self.update_preset_combo()
-
-    def update_preset_combo(self):
-        current = self.preset_combo.currentText()
-        self.preset_combo.blockSignals(True)
-        self.preset_combo.clear()
-        self.preset_combo.addItems(sorted(self.presets_data.keys()))
-        
-        if current in self.presets_data:
-            self.preset_combo.setCurrentText(current)
-        elif "Default" in self.presets_data:
-            self.preset_combo.setCurrentText("Default")
-        
-        self.preset_combo.blockSignals(False)
-        self.apply_selected_preset()
-
-    def apply_selected_preset(self):
-        name = self.preset_combo.currentText()
-        if name not in self.presets_data: return
-        data = self.presets_data[name]
-        
-        self.nproc_spin.setValue(data.get("nproc", 4))
-        self.mem_spin.setValue(data.get("maxcore", 2000))
-        self.keywords_edit.setText(data.get("route", "! B3LYP def2-SVP Opt Freq"))
-        self.adv_edit.setPlainText(data.get("adv", ""))
-        self.post_adv_edit.setPlainText(data.get("adv_post", ""))
-
-    def save_preset_dialog(self):
-        name, ok = QInputDialog.getText(self, "Save Preset", "Preset Name:")
-        if ok and name:
-            self.presets_data[name] = {
-                "nproc": self.nproc_spin.value(),
-                "maxcore": self.mem_spin.value(),
-                "route": self.keywords_edit.text(),
-                "adv": self.adv_edit.toPlainText(),
-                "adv_post": self.post_adv_edit.toPlainText()
-            }
-            self.save_presets_to_file()
-            self.update_preset_combo()
-            self.preset_combo.setCurrentText(name)
-
-    def delete_preset(self):
-        name = self.preset_combo.currentText()
-        if name == "Default":
-             QMessageBox.warning(self, "Warning", "Cannot delete Default preset.")
-             return
-        
-        confirm = QMessageBox.question(self, "Confirm", f"Delete preset '{name}'?")
-        if confirm == QMessageBox.StandardButton.Yes:
-            del self.presets_data[name]
-            self.save_presets_to_file()
-            self.update_preset_combo()
-
-    def save_presets_to_file(self):
-        try:
-            with open(SETTINGS_FILE, 'w', encoding='utf-8') as f:
-                json.dump(self.presets_data, f, indent=4)
-        except Exception as e:
-            QMessageBox.warning(self, "Error", f"Failed to save presets: {e}")
-
-    # --- Charge/Mult Logic ---
-    def calc_initial_charge_mult(self):
-        if not self.mol: return
-        try:
-            try: charge = Chem.GetFormalCharge(self.mol)
-            except: charge = 0
-            
-            num_radical = sum(atom.GetNumRadicalElectrons() for atom in self.mol.GetAtoms())
-            mult = num_radical + 1
-            
-            self.charge_spin.setValue(int(charge))
-            self.mult_spin.setValue(int(mult))
-            self.validate_charge_mult()
-        except Exception: pass
-
-    def validate_charge_mult(self):
-        if not self.mol: return
-        try:
-            charge = self.charge_spin.value()
-            mult = self.mult_spin.value()
-            
-            total_protons = sum(atom.GetAtomicNum() for atom in self.mol.GetAtoms())
-            total_electrons = total_protons - charge
-            
-            is_valid = (total_electrons % 2 == 0 and mult % 2 != 0) or \
-                       (total_electrons % 2 != 0 and mult % 2 == 0)
-                       
-            if is_valid:
-                self.charge_spin.setPalette(self.default_palette)
-                self.mult_spin.setPalette(self.default_palette)
-            else:
-                p = self.charge_spin.palette()
-                p.setColor(QPalette.ColorRole.Base, QColor("#FFDDDD"))
-                p.setColor(QPalette.ColorRole.Text, Qt.GlobalColor.red)
-                self.charge_spin.setPalette(p)
-                self.mult_spin.setPalette(p)
-        except: pass
-
-from PyQt6.QtWidgets import QInputDialog 
-
-def run(mw):
-    mol = getattr(mw, 'current_mol', None)
-    if not mol:
-        QMessageBox.warning(mw, PLUGIN_NAME, "No molecule loaded.")
-        return
-        
-    filename = getattr(mw, 'current_file_path', None)
-    dialog = OrcaSetupDialogNeo(parent=mw, mol=mol, filename=filename)
-    dialog.exec()
-
-# initialize removed as it only registered the menu action