MultiOptPy 1.20.2__py3-none-any.whl → 1.20.3__py3-none-any.whl

multioptpy/Optimizer/mf_rsirfo.py

@@ -0,0 +1,266 @@
+import numpy as np
+from multioptpy.Optimizer.hessian_update import ModelHessianUpdate
+from multioptpy.Optimizer.block_hessian_update import BlockHessianUpdate
+from multioptpy.Utils.calc_tools import Calculationtools
+
+# Import the original RSIRFO class for inheritance
+from multioptpy.Optimizer.rsirfo import RSIRFO
+from multioptpy.Optimizer.mode_following import ModeFollowing
+
+
+class MF_RSIRFO(RSIRFO):
+    """
+    Mode-Following RS-I-RFO Optimizer.
+    
+        References:
+        [1] Banerjee et al., Phys. Chem., 89, 52-57 (1985)
+        [2] Heyden et al., J. Chem. Phys., 123, 224101 (2005)
+        [3] Baker, J. Comput. Chem., 7, 385-395 (1986)
+        [4] Besalú and Bofill, Theor. Chem. Acc., 100, 265-274 (1998)
+        
+        This code is made based on the below codes.
+        1, https://github.com/eljost/pysisyphus/blob/master/pysisyphus/tsoptimizers/TSHessianOptimizer.py
+        2, https://github.com/eljost/pysisyphus/blob/master/pysisyphus/tsoptimizers/RSIRFOptimizer.py
+
+
+    Extended 'method' string support:
+      "method_name : target_index : ema<val> : grad<val>"
+      
+    Examples:
+      "block_fsb"              -> Default (Index 0, EMA=1.0 if adaptive, Grad=0.0)
+      "block_fsb:1"            -> Track Mode 1
+      "block_fsb:0:ema0.5"     -> Track Mode 0 with EMA alpha=0.5
+      "block_fsb:ema0.1:grad0.3" -> Track Mode 0, EMA=0.1, Gradient Bias=0.3
+    """
+    def __init__(self, **config):
+        # 1. Parse 'method' string for advanced configs
+        raw_method_str = config.get("method", "auto")
+        
+        # Initial Defaults
+        update_method = raw_method_str
+        target_mode_index = 0
+        
+        # Check config for fallback defaults
+        is_adaptive_config = config.get("adaptive_mode_following", True)
+        
+        # Placeholders for parsed values
+        parsed_update_rate = None
+        parsed_gradient_weight = 0.0
+        
+        # Parse logic
+        if ":" in raw_method_str:
+            parts = raw_method_str.split(":")
+            update_method = parts[0].strip() # First part is always method name
+            
+            for part in parts[1:]:
+                part = part.strip().lower()
+                if not part: continue
+                
+                if part.isdigit():
+                    # "1", "2" -> Target Index
+                    target_mode_index = int(part)
+                    
+                elif part.startswith("ema"):
+                    # "ema0.5" -> Update Rate
+                    try:
+                        val = float(part[3:])
+                        parsed_update_rate = val
+                    except ValueError:
+                        print(f"Warning: Invalid ema value in '{part}'. Ignoring.")
+                        
+                elif part.startswith("grad"):
+                    # "grad0.5" -> Gradient Weight
+                    try:
+                        val = float(part[4:])
+                        parsed_gradient_weight = val
+                    except ValueError:
+                        print(f"Warning: Invalid grad value in '{part}'. Ignoring.")
+        
+        # Resolve Update Rate (EMA) and Adaptive Flag
+        if parsed_update_rate is not None:
+            # Explicit string config overrides config dict
+            update_rate = parsed_update_rate
+            # If ema > 0, we must enable adaptive mode
+            adaptive = (update_rate > 1e-12)
+        else:
+            # Fallback to config dict or defaults
+            # "If ema not specified: 0 if static, 1 if adaptive"
+            adaptive = is_adaptive_config
+            update_rate = 1.0 if adaptive else 0.0
+            
+        # Resolve Gradient Weight
+        gradient_weight = parsed_gradient_weight
+        
+        # Update config for parent class
+        config['method'] = update_method
+        
+        # Initialize parent RSIRFO
+        super().__init__(**config)
+        self.hessian_update_method = update_method
+        
+        self.use_mode_following = config.get("use_mode_following", True)
+        
+        # Other configs
+        use_hungarian = config.get("use_hungarian", True)
+        element_list = config.get("element_list", None)
+        
+        # Initialize Mode Following with resolved parameters
+        self.mode_follower = ModeFollowing(
+            self.saddle_order, 
+            atoms=element_list,
+            initial_target_index=target_mode_index,
+            adaptive=adaptive,
+            update_rate=update_rate,
+            use_hungarian=use_hungarian,
+            gradient_weight=gradient_weight,
+            debug_mode=config.get("debug_mode", False)
+        )
+        
+        if self.display_flag:
+            print(f"MF-RS-I-RFO Initialized:")
+            print(f"  - Update Method: {self.hessian_update_method}")
+            print(f"  - Target Index: {target_mode_index}")
+            print(f"  - Mode Following: Adaptive={adaptive} (EMA Rate={update_rate})")
+            print(f"  - Gradient Bias: {gradient_weight}")
+            print(f"  - Matching: {'Hungarian' if use_hungarian else 'Greedy'}")
+            print(f"  - Mass-Weighted: {'Yes' if element_list else 'No'}")
+
+    def run(self, geom_num_list, B_g, pre_B_g=[], pre_geom=[], B_e=0.0, pre_B_e=0.0, pre_move_vector=[], initial_geom_num_list=[], g=[], pre_g=[]):
+        """
+        Execute one step of RS-I-RFO with Advanced Mode Following.
+        """
+        self.log(f"\n{'='*50}\nMF-RS-I-RFO Iteration {self.iteration}\n{'='*50}", force=True)
+        
+        if self.Initialization:
+            self.prev_eigvec_min = None
+            self.prev_eigvec_size = None
+            self.predicted_energy_changes = []
+            self.actual_energy_changes = []
+            self.prev_geometry = None
+            self.prev_gradient = None
+            self.prev_energy = None
+            self.converged = False
+            self.iteration = 0
+            self.Initialization = False
+        
+        if self.hessian is None:
+            raise ValueError("Hessian matrix must be set")
+        
+        if self.prev_geometry is not None and self.prev_gradient is not None and len(pre_g) > 0 and len(pre_geom) > 0:
+            self.update_hessian(geom_num_list, g, pre_geom, pre_g)
+            
+        gradient_norm = np.linalg.norm(B_g)
+        self.log(f"Gradient norm: {gradient_norm:.6f}", force=True)
+        
+        if gradient_norm < self.gradient_norm_threshold:
+            self.log(f"Converged: Gradient norm", force=True)
+            self.converged = True
+        
+        if self.actual_energy_changes and abs(self.actual_energy_changes[-1]) < self.energy_change_threshold:
+            self.log(f"Converged: Energy change", force=True)
+            self.converged = True
+
+        current_energy = B_e
+        gradient = np.asarray(B_g).ravel()
+        
+        tmp_hess = self.hessian
+        if self.bias_hessian is not None:
+            H_base = tmp_hess + self.bias_hessian
+        else:
+            H_base = tmp_hess
+            
+        H = Calculationtools().project_out_hess_tr_and_rot_for_coord(
+            H_base, geom_num_list.reshape(-1, 3), geom_num_list.reshape(-1, 3), False
+        )
+        H = 0.5 * (H + H.T)
+
+        eigvals, eigvecs = self.compute_eigendecomposition_with_shift(H)
+        self.check_hessian_conditioning(eigvals)
+
+        # =========================================================================
+        # Mode Following: Identify Targets
+        # =========================================================================
+        target_indices = []
+        
+        if self.saddle_order > 0:
+            if self.use_mode_following:
+                if self.iteration == 0:
+                    self.log(f"Init Mode Following...")
+                    self.mode_follower.set_references(eigvecs, eigvals)
+                    # For iter 0, use start indices directly
+                    start = self.mode_follower.target_offset
+                    target_indices = list(range(start, start + self.saddle_order))
+                else:
+                    # Find matching modes (pass gradient for optional bias)
+                    target_indices = self.mode_follower.get_matched_indices(
+                        eigvecs, eigvals, current_gradient=gradient
+                    )
+            else:
+                target_indices = list(range(self.saddle_order))
+        
+        # =========================================================================
+        # Trust Radius
+        # =========================================================================
+        if self.iteration > 0 and self.prev_energy is not None:
+            actual_change = B_e - self.prev_energy
+            if len(self.actual_energy_changes) >= 3:
+                self.actual_energy_changes.pop(0)
+            self.actual_energy_changes.append(actual_change)
+            
+            if self.predicted_energy_changes:
+                # Use curvature of the TRACKED mode
+                min_eigval_for_tr = eigvals[0]
+                if target_indices and target_indices[0] < len(eigvals):
+                    min_eigval_for_tr = eigvals[target_indices[0]]
+                
+                self.adjust_trust_radius(
+                    actual_change,
+                    self.predicted_energy_changes[-1],
+                    min_eigval_for_tr,
+                    gradient_norm
+                )
+
+        # =========================================================================
+        # Image Surface Construction
+        # =========================================================================
+        P = np.eye(gradient.size)
+        
+        for idx in target_indices:
+            if idx < len(eigvals) and np.abs(eigvals[idx]) > 1e-10:
+                trans_vec = eigvecs[:, idx]
+                if self.NEB_mode:
+                     P -= np.outer(trans_vec, trans_vec)
+                else:
+                     P -= 2 * np.outer(trans_vec, trans_vec)
+
+        H_star = np.dot(P, H)
+        H_star = 0.5 * (H_star + H_star.T)
+        grad_star = np.dot(P, gradient)
+        
+        eigvals_star, eigvecs_star = self.compute_eigendecomposition_with_shift(H_star)
+        eigvals_star, eigvecs_star = self.filter_small_eigvals(eigvals_star, eigvecs_star)
+        
+        current_eigvec_size = eigvecs_star.shape[1]
+        if self.prev_eigvec_size is not None and self.prev_eigvec_size != current_eigvec_size:
+            self.prev_eigvec_min = None
+        self.prev_eigvec_size = current_eigvec_size
+        
+        move_vector = self.get_rs_step(eigvals_star, eigvecs_star, grad_star)
+        
+        predicted_change = self.rfo_model(gradient, H, move_vector)
+        
+        if len(self.predicted_energy_changes) >= 3:
+            self.predicted_energy_changes.pop(0)
+        self.predicted_energy_changes.append(predicted_change)
+        
+        self.log(f"Predicted energy change: {predicted_change:.6f}", force=True)
+        
+        if self.actual_energy_changes and len(self.predicted_energy_changes) > 1:
+            self.evaluate_step_quality()
+            
+        self.prev_geometry = geom_num_list
+        self.prev_gradient = B_g
+        self.prev_energy = current_energy
+        self.iteration += 1
+        
+        return -1 * move_vector.reshape(-1, 1)

multioptpy/Optimizer/mode_following.py

@@ -0,0 +1,273 @@
+import numpy as np
+from scipy.optimize import linear_sum_assignment
+# Import atomic_mass from your package
+from multioptpy.Parameters.atomic_mass import atomic_mass
+
+class ModeFollowing:
+    """
+    Mode Tracking Class.
+    
+    Features:
+    1. Mass-Weighted Overlap (MWO): Physically correct projection.
+    2. Adaptive / Static Reference: Follows mode rotation.
+    3. Gradient Overlap: Biases selection towards the current force direction.
+    4. Maximum Weight Matching (Hungarian Algo): Solves the global assignment problem
+       to prevent mode swapping in dense spectra.
+    5. Exponential Moving Average (EMA): Filters noise while adapting to mode rotation.
+    """
+    def __init__(self, saddle_order, atoms=None, initial_target_index=0, 
+                 adaptive=True, update_rate=1.0, 
+                 use_hungarian=True, gradient_weight=0.0, debug_mode=False):
+        """
+        Parameters:
+            saddle_order (int): Number of modes to track.
+            atoms (list): List of atomic numbers/symbols for MWO.
+            initial_target_index (int): 0-based index of the starting mode.
+            adaptive (bool): Update reference vectors (True) or keep static (False).
+            update_rate (float): EMA coefficient (alpha) for adaptive update.
+                                 1.0 = Full replacement (Standard Adaptive MOM).
+                                 0.5 = Balanced (Half old, half new).
+                                 0.0 = No update (Same as adaptive=False).
+            use_hungarian (bool): Use Kuhn-Munkres algorithm for global matching.
+            gradient_weight (float): Weight for Gradient Overlap (0.0 to 1.0).
+            debug_mode (bool): Verbose logging.
+        """
+        self.saddle_order = saddle_order
+        self.debug_mode = debug_mode
+        self.reference_modes = [] 
+        self.reference_indices = []
+        self.is_initialized = False
+        self.target_offset = initial_target_index
+        
+        self.adaptive = adaptive
+        self.update_rate = update_rate  # EMA alpha
+        self.use_hungarian = use_hungarian
+        self.gradient_weight = gradient_weight
+        
+        # Prepare Mass Weights
+        self.mass_weights = None
+        self.mass_sqrt = None
+        strategies = []
+        
+        if atoms is not None:
+            try:
+                masses = [atomic_mass(a) for a in atoms]
+                weights_list = []
+                for m in masses:
+                    weights_list.extend([m, m, m])
+                self.mass_weights = np.array(weights_list)
+                # Sqrt weights for norm calculation: |v|_M = |v * sqrt(M)|
+                self.mass_sqrt = np.sqrt(self.mass_weights)
+                self.log(f"Config: MWO enabled ({len(atoms)} atoms).")
+                strategies.append("Mass-Weighted")
+            except Exception as e:
+                print(f"[ModeFollowing] Warning: Mass init failed ({e}). Using Cartesian.")
+                self.mass_weights = None
+                strategies.append("Cartesian")
+        else:
+            strategies.append("Cartesian")
+        
+        if self.adaptive: 
+            strategies.append(f"Adaptive(EMA={self.update_rate})")
+        else: 
+            strategies.append("Static")
+            
+        if self.use_hungarian: 
+            strategies.append("Hungarian")
+        else: 
+            strategies.append("Greedy")
+            
+        if self.gradient_weight > 0: 
+            strategies.append(f"GradBias({self.gradient_weight})")
+        
+        self.log(f"Config: {', '.join(strategies)}")
+        self.strategies = strategies
+        
+    def log(self, message):
+        if self.debug_mode:
+            print(f"[ModeFollowing] {message}")
+
+    def _calc_overlap(self, v1, v2):
+        """
+        Calculate normalized Overlap (S_ij).
+        Returns signed value (-1.0 to 1.0).
+        """
+        if self.mass_weights is None:
+            dot_val = np.dot(v1, v2)
+            norm1 = np.linalg.norm(v1)
+            norm2 = np.linalg.norm(v2)
+        else:
+            dot_val = np.dot(v1 * self.mass_weights, v2)
+            # Use pre-calculated sqrt weights for efficiency if available
+            if self.mass_sqrt is not None:
+                norm1 = np.linalg.norm(v1 * self.mass_sqrt)
+                norm2 = np.linalg.norm(v2 * self.mass_sqrt)
+            else:
+                norm1 = np.sqrt(np.dot(v1 * self.mass_weights, v1))
+                norm2 = np.sqrt(np.dot(v2 * self.mass_weights, v2))
+        
+        if norm1 < 1e-12 or norm2 < 1e-12:
+            return 0.0
+        return dot_val / (norm1 * norm2)
+
+    def _normalize(self, v):
+        """Normalize vector according to the current metric (Mass-Weighted or Cartesian)."""
+        if self.mass_weights is None:
+            norm = np.linalg.norm(v)
+        else:
+            if self.mass_sqrt is not None:
+                norm = np.linalg.norm(v * self.mass_sqrt)
+            else:
+                norm = np.sqrt(np.dot(v * self.mass_weights, v))
+            
+        if norm < 1e-12:
+            return v # Avoid division by zero
+        return v / norm
+
+    def set_references(self, eigvecs, eigvals=None):
+        """Set initial reference modes."""
+        self.reference_modes = []
+        self.reference_indices = []
+        n_modes = eigvecs.shape[1]
+        
+        start_idx = self.target_offset
+        end_idx = start_idx + self.saddle_order
+        
+        if end_idx > n_modes:
+            start_idx = 0
+            end_idx = self.saddle_order
+            print(f"[ModeFollowing] Error: Index out of bounds. Fallback to 0.")
+
+        self.log(f"Initializing references using modes [{start_idx} to {end_idx-1}]")
+        
+        for i in range(start_idx, end_idx):
+            self.reference_modes.append(eigvecs[:, i].copy())
+            self.reference_indices.append(i)
+            val_str = f"{eigvals[i]:.6f}" if eigvals is not None else "N/A"
+            print(f"  [ModeFollowing] Target: Mode {i} (Val: {val_str})")
+            
+        self.is_initialized = True
+
+    def get_matched_indices(self, current_eigvecs, current_eigvals=None, current_gradient=None):
+        """
+        Find best matching modes using configured strategies.
+        Updates references using EMA if adaptive=True.
+        """
+        if not self.is_initialized:
+            raise RuntimeError("References not set.")
+
+        n_refs = len(self.reference_modes)
+        n_curr = current_eigvecs.shape[1]
+        
+        # 1. Build Similarity Matrix (Cost Matrix for Hungarian)
+        # Rows: References, Cols: Current Modes
+        # Values: Absolute Overlap (0.0 to 1.0)
+        similarity_matrix = np.zeros((n_refs, n_curr))
+        sign_matrix = np.zeros((n_refs, n_curr)) # Store signs for phase correction
+
+        # Pre-calculate Gradient Overlaps if enabled
+        grad_overlaps = np.zeros(n_curr)
+        if self.gradient_weight > 0 and current_gradient is not None:
+            g_norm = np.linalg.norm(current_gradient)
+            if g_norm > 1e-10:
+                normalized_grad = current_gradient / g_norm
+                for j in range(n_curr):
+                    # Use same metric (MWO/Cartesian) for consistency
+                    ov = abs(self._calc_overlap(normalized_grad, current_eigvecs[:, j]))
+                    grad_overlaps[j] = ov
+
+        for i in range(n_refs):
+            ref_vec = self.reference_modes[i]
+            for j in range(n_curr):
+                overlap_signed = self._calc_overlap(ref_vec, current_eigvecs[:, j])
+                overlap_abs = abs(overlap_signed)
+                
+                # Base Score: Eigenvector Overlap
+                score = overlap_abs
+                
+                # Add Gradient Bias
+                if self.gradient_weight > 0:
+                    score += self.gradient_weight * grad_overlaps[j]
+                
+                similarity_matrix[i, j] = score
+                sign_matrix[i, j] = 1.0 if overlap_signed >= 0 else -1.0
+
+        matched_indices = []
+        matched_pairs = [] # List of (ref_idx, curr_idx)
+
+        # 2. Solve Matching Problem
+        if self.use_hungarian:
+            # Hungarian Algorithm (Minimizes cost, so we neglect similarity)
+            cost_matrix = -1.0 * similarity_matrix
+            row_ind, col_ind = linear_sum_assignment(cost_matrix)
+            
+            # Extract pairs
+            for r, c in zip(row_ind, col_ind):
+                matched_pairs.append((r, c))
+                
+            # Sort by reference index order to keep list consistent
+            matched_pairs.sort(key=lambda x: x[0])
+            
+        else:
+            # Greedy Algorithm
+            used_cols = set()
+            for i in range(n_refs):
+                best_col = -1
+                max_sim = -1.0
+                for j in range(n_curr):
+                    if j in used_cols: continue
+                    if similarity_matrix[i, j] > max_sim:
+                        max_sim = similarity_matrix[i, j]
+                        best_col = j
+                
+                if best_col != -1:
+                    matched_pairs.append((i, best_col))
+                    used_cols.add(best_col)
+                else:
+                    # Fallback (Lost track)
+                    print(f"    [ModeFollowing] LOST TRACK of Ref {i}")
+                    matched_pairs.append((i, self.reference_indices[i] if self.reference_indices[i] < n_curr else 0))
+
+        # 3. Process Matches and Update References
+        print(f"  [ModeFollowing] --- Tracking Status ---")
+        print(" Strategies: ", self.strategies)
+        
+        for ref_i, curr_j in matched_pairs:
+            matched_indices.append(curr_j)
+            
+            # Stats for logging
+            sim_score = similarity_matrix[ref_i, curr_j]
+            prev_idx = self.reference_indices[ref_i]
+            val_str = f"{current_eigvals[curr_j]:.5f}" if current_eigvals is not None else ""
+            
+            # Phase correction sign
+            best_sign = sign_matrix[ref_i, curr_j]
+            
+            print(f"    Ref {ref_i} (was {prev_idx}) -> Mode {curr_j} (Score: {sim_score:.4f}) {val_str}")
+            
+            if sim_score < 0.3:
+                print(f"    WARNING: Very low match score!")
+
+            # --- Adaptive Update (EMA) ---
+            if self.adaptive:
+                alpha = self.update_rate
+                
+                old_vec = self.reference_modes[ref_i]
+                new_vec_aligned = current_eigvecs[:, curr_j] * best_sign
+                
+                # Linear combination: v_new = (1-a)*v_old + a*v_curr
+                if alpha >= 1.0:
+                    updated_vec = new_vec_aligned
+                elif alpha <= 0.0:
+                    updated_vec = old_vec
+                else:
+                    updated_vec = (1.0 - alpha) * old_vec + alpha * new_vec_aligned
+                
+                # Normalize (Important: Length must be 1 for next overlap calc)
+                # This normalization respects mass-weighting if enabled
+                self.reference_modes[ref_i] = self._normalize(updated_vec)
+            
+            self.reference_indices[ref_i] = curr_j
+
+        print(f"  [ModeFollowing] -----------------------")
+        return matched_indices

multioptpy/Utils/calc_tools.py

@@ -599,6 +599,7 @@ def calc_dihedral_angle_from_vec(vector1, vector2, vector3):
     norm_v1 = np.linalg.norm(v1)
     if np.abs(norm_v1) < 1e-15:
         norm_v1 += 1e-15 
+    norm_v2 = np.linalg.norm(v2)
     if np.abs(norm_v2) < 1e-15:
         norm_v2 += 1e-15
     

multioptpy/fileio.py

@@ -383,10 +383,10 @@ class FileIO:
         return [start_data], element_list, electric_charge_and_multiplicity
 
 
-    def print_geometry_list(self, new_geometry, element_list, electric_charge_and_multiplicity):
+    def print_geometry_list(self, new_geometry, element_list, electric_charge_and_multiplicity, display_flag=True):
         """load structure updated geometry for next QM calculation"""
         new_geometry = new_geometry.tolist()
-        print("\n")
+    
         
         # Process all geometries at once with list comprehension
         formatted_geometries = []
@@ -394,17 +394,24 @@ class FileIO:
             element = element_list[num]
             formatted_geometry = [element] + list(map(str, geometry))
             formatted_geometries.append(formatted_geometry)
-            print(f"{element:2}   {float(geometry[0]):>17.12f}   {float(geometry[1]):>17.12f}   {float(geometry[2]):>17.12f}")
         
+        if display_flag:
+            for num, geometry in enumerate(new_geometry):    
+                element = element_list[num]
+                print(f"{element:2}   {float(geometry[0]):>17.12f}   {float(geometry[1]):>17.12f}   {float(geometry[2]):>17.12f}")
+            print("\n")
+            
         geometry_list = [[electric_charge_and_multiplicity, *formatted_geometries]]
-        print("")
         
         return geometry_list
         
     
-    def make_psi4_input_file(self, geometry_list, iter):#geometry_list: ang.
+    def make_psi4_input_file(self, geometry_list, iter, path=None):#geometry_list: ang.
         """structure updated geometry is saved."""
-        file_directory = self.work_directory+"samples_"+self.NOEXT_START_FILE+"_"+str(iter)
+        if path is not None:
+            file_directory = os.path.join(path, f"samples_{self.NOEXT_START_FILE}_{iter}")
+        else:
+            file_directory = self.work_directory+"samples_"+self.NOEXT_START_FILE+"_"+str(iter)
         tmp_cs = ["SAMPLE"+str(iter), ""]
 
 

multioptpy/interface.py

@@ -189,11 +189,12 @@ def call_optimizeparser(parser):
     parser.add_argument('-modelhess','--use_model_hessian', nargs='?', help="use model hessian. (Default: not using model hessian If you specify only option, Improved Lindh + Grimme's D3 dispersion model hessian is used.) (ex. lindh, gfnff, gfn0xtb, fischer, fischerd3, fischerd4, schlegel, swart, lindh2007, lindh2007d3, lindh2007d4)", action=ModelhessAction, default=None)
     parser.add_argument("-sc", "--shape_conditions", nargs="*", type=str, default=[], help="Exit optimization if these conditions are not satisfied. (e.g.) [[(ang.) gt(lt) 2,3 (bond)] [(deg.) gt(lt) 2,3,4 (bend)] ...] [[(deg.) gt(lt) 2,3,4,5 (torsion)] ...]")
     parser.add_argument("-pc", "--projection_constrain", nargs="*",  type=str, default=[], help='apply constrain conditions with projection of gradient and hessian (ex.) [[(constraint condition name) (atoms(ex. 1,2))] ...] ')
-    parser.add_argument("-oniom", "--oniom_flag", nargs="*",  type=str, default=[], help='apply ONIOM method (low layer: GFN1-xTB) (ex.) [(atom_number of high layer (ex. 1,2))] (caution) -pc option is not available. If there are not link atoms, please input "none"')
+    parser.add_argument("-oniom", "--oniom_flag", nargs="*",  type=str, default=[], help='apply ONIOM method (Warning: This option is unavailable.)')
     parser.add_argument("-freq", "--frequency_analysis",  help="Perform normal vibrational analysis after converging geometry optimization. (Caution: Unable to use this analysis with oniom method)", action='store_true')
     parser.add_argument("-temp", "--temperature",  type=float, default='298.15', help='temperatrue to calculate thermochemistry (Unit: K) (default: 298.15K)')
     parser.add_argument("-press", "--pressure",  type=float, default='101325', help='pressure to calculate thermochemistry (Unit: Pa) (default: 101325Pa)')
-    parser.add_argument("-negeigval", "--detect_negative_eigenvalues", help="Detect negative eigenvalues in the Hessian matrix at ITR. 0 if you caluculate exact hessian (-fc >0). If negative eigenvalues are not detected and saddle_order > 0, the optimization is stopped.", action='store_true')
+    parser.add_argument("-negeigval", "--detect_negative_eigenvalues", help="Detect negative eigenvalues in the Hessian matrix at ITR. 0 if you calculate exact hessian (-fc >0). If negative eigenvalues are not detected and saddle_order > 0, the optimization is stopped.", action='store_true')
+    parser.add_argument("-mf", "--model_function", nargs="*",  type=str, default=[], help='minimize model function(ex.) [[model function type (seam, avoid, conical etc.)] [electronic charge] [spin multiplicity]] ')
     
     return parser