mimicpy 0.2.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

mimicpy/__main__.py

@@ -4,6 +4,7 @@
 #    MiMiCPy: Python Based Tools for MiMiC
 #    Copyright (C) 2020-2023 Bharath Raghavan,
 #                            Florian Schackert
+#                            Sachin Shivakumar
 #
 #    This file is part of MiMiCPy.
 #
@@ -31,6 +32,29 @@ import itertools
 import threading
 import pandas as pd
 import mimicpy
+from mimicpy.force_matching import (
+    get_configurations,
+    get_optimize_ff_parameters,
+    get_configurations_optff,
+    opt_dresp,
+    compute_sd,
+    QMRegion
+)
+from mimicpy.scripts.fmdata import FMDataset
+from mimicpy.scripts.fm_input import FMInput
+from mimicpy.force_matching.opt_ff import (
+    unified_optimization_ff,
+    compare_optimization_methods
+)
+from mimicpy.force_matching.compare_top import compare_qm_parameters
+from pathlib import Path
+import logging
+from datetime import datetime
+import subprocess
+import shutil
+from os import environ
+import copy
+import numpy as np
 
 warnings.simplefilter(action='ignore', category=FutureWarning)  # Supress pandas warnings
 
@@ -460,6 +484,126 @@ def geom2coords(args):
 
     loader.close()
 
+def json2h5(args):
+    """
+    Convert large JSON Force Matching data files to HDF5 format using FMDataset functionality.
+    
+    Args:
+        args: Command line arguments containing input/output file paths
+    """
+    from pathlib import Path
+    import os
+    
+    input_file = Path(args.i)
+    output_file = Path(args.o) if args.o else input_file.with_suffix('.h5')
+    
+    if not input_file.exists():
+        print(f'\n\nError: Cannot find file {input_file}! Exiting..\n')
+        sys.exit(1)
+    
+    print('')
+    loader = Loader('**Converting JSON to HDF5**')
+    
+    try:
+        # Use the existing FMDataset functionality to convert JSON to HDF5
+        fm_dataset = FMDataset(input_file, output_file)
+        
+        loader.close()
+           
+    except Exception as e:
+        loader.close(halt=True)
+        print(f'\n\nError during conversion: {e}')
+        sys.exit(1)
+    # Calculate file sizes for comparison
+    input_size = input_file.stat().st_size / (1024 * 1024)  # MB
+    output_size = output_file.stat().st_size / (1024 * 1024)  # MB
+    compression_ratio = (1 - output_size / input_size) * 100 if input_size > 0 else 0
+    
+    
+    print(f'\nConversion completed successfully!')
+    print(f'Input file:  {input_file} ({input_size:.2f} MB)')
+    print(f'Output file: {output_file} ({output_size:.2f} MB)')
+    print(f'Compression: {compression_ratio:.1f}% reduction')
+    print(f'Configurations: {len(fm_dataset)}')
+
+def h5info(args):
+    """
+    Display information about HDF5 Force Matching data files.
+    
+    Args:
+        args: Command line arguments containing input file path
+    """
+    import h5py
+    import numpy as np
+    from pathlib import Path
+    
+    input_file = Path(args.i)
+    
+    if not input_file.exists():
+        print(f'\n\nError: Cannot find file {input_file}! Exiting..\n')
+        sys.exit(1)
+    
+    print('')
+    loader = Loader('**Reading HDF5 file**')
+    
+    try:
+        # Read the HDF5 file
+        with h5py.File(input_file, 'r') as f:
+            config_keys = [key for key in f.keys() if key.startswith('config_')]
+            config_keys.sort(key=lambda x: int(x.split('_')[1]))  # Sort by configuration number
+            
+            if not config_keys:
+                print('\n\nError: No configuration data found in HDF5 file! Exiting..\n')
+                sys.exit(1)
+            
+            loader.close()
+            
+            # Get file size
+            file_size = input_file.stat().st_size / (1024 * 1024)  # MB
+            
+            print(f'\nHDF5 File Information:')
+            print(f'File: {input_file}')
+            print(f'Size: {file_size:.2f} MB')
+            print(f'Configurations: {len(config_keys)}')
+            
+            # Show details for first few configurations
+            print(f'\nConfiguration Details:')
+            for i, config_key in enumerate(config_keys[:min(5, len(config_keys))]):
+                config_group = f[config_key]
+                atoms_data = config_group['atoms']
+                n_atoms = len(atoms_data)
+                
+                # Get some statistics
+                regions = atoms_data['region'][:]
+                qm_atoms = np.sum(regions == 1)
+                mm_atoms = np.sum(regions != 1)
+                
+                print(f'  {config_key}: {n_atoms} atoms ({qm_atoms} QM, {mm_atoms} MM)')
+            
+            if len(config_keys) > 5:
+                print(f'  ... and {len(config_keys) - 5} more configurations')
+            
+            # Show dataset structure
+            print(f'\nDataset Structure:')
+            first_config = f[config_keys[0]]
+            atoms_data = first_config['atoms']
+            
+            print(f'  Atom data fields:')
+            for field in atoms_data.dtype.names:
+                field_dtype = atoms_data.dtype[field]
+                print(f'    - {field}: {field_dtype}')
+            
+            # Show compression info if available
+            if hasattr(atoms_data, 'compression') and atoms_data.compression:
+                print(f'\nCompression: {atoms_data.compression}')
+            else:
+                print(f'\nCompression: None')
+        
+    except Exception as e:
+        loader.close(halt=True)
+        print(f'\n\nError reading HDF5 file: {e}')
+        sys.exit(1)
+
 def fixtop(args):
     nsa_dct = get_nsa_mpt(args, True)
     print("\n**Reading topology**\n")
@@ -484,6 +628,425 @@ def fixtop(args):
         sys.exit(1)
     return top
 
+def compare_top(args):
+    """Command-line interface for comparing QM parameters between topologies"""
+    compare_qm_parameters(args.top1, args.top2, args.top3, args.coords, Path(args.sele))
+
+def qminfo(args):
+    """Print information about QM atoms in the QM region"""
+    print('')
+    loader = Loader('**Reading topology and coordinates**')
+    
+    try:
+        # Initialize QMRegion
+        qm_region = QMRegion(args.top, args.coords, gmxdata=args.ff, 
+                            buffer=args.buf, guess_elements=args.guess,
+                            nonstandard_atomtypes=get_nsa_mpt(args, only_nsa=True) if args.nsa else None)
+        
+        # Setup QM region with selection file and solvent names
+        qm_region.setup_qm_region(Path(args.sele))
+        
+        loader.close()
+
+        # Get output file if specified
+        output_file = getattr(args, 'out', None)
+        
+        # Format output
+        output_lines = []
+        output_lines.append("=" * 80)
+        output_lines.append("QM Region Information")
+        output_lines.append("=" * 80)
+        output_lines.append(f"\nTotal number of QM atoms: {len(qm_region.qm_atoms)}")
+        output_lines.append(f"QM total charge: {qm_region.qm_total_charge:.6f}")
+        
+        # Count boundary atoms if present
+        if not qm_region.boundary_atoms.empty:
+            output_lines.append(f"Number of boundary atoms: {len(qm_region.boundary_atoms)}")
+            output_lines.append(f"Number of core QM atoms: {len(qm_region.qm_atoms) - len(qm_region.boundary_atoms)}")
+        
+        # Count by molecule type
+        if 'mol' in qm_region.qm_atoms.columns:
+            mol_counts = qm_region.qm_atoms.groupby('mol').size()
+            output_lines.append(f"Number of molecule types: {len(mol_counts)}")
+            output_lines.append("\nAtoms per molecule type:")
+            for mol, count in mol_counts.items():
+                output_lines.append(f"  {mol}: {count} atoms")
+        
+        # Print detailed atom table
+        output_lines.append("\n" + "=" * 80)
+        output_lines.append("Detailed QM Atom Information")
+        output_lines.append("=" * 80)
+        
+        # Create formatted table
+        with pd.option_context('display.max_rows', None, 'display.max_columns', None, 
+                              'display.width', None, 'display.max_colwidth', None):
+            # Select columns to display (only include columns that exist)
+            display_cols = ['type', 'resid', 'resname', 'name', 'charge', 'mass']
+            available_cols = qm_region.qm_atoms.columns.tolist()
+            if 'element' in available_cols:
+                display_cols.insert(1, 'element')
+            if 'mol' in available_cols:
+                display_cols.append('mol')
+            if 'is_bound' in available_cols:
+                display_cols.append('is_bound')
+            
+            # Filter to only include columns that actually exist
+            display_cols = [col for col in display_cols if col in available_cols]
+            
+            # Create display dataframe with index as first column
+            display_df = qm_region.qm_atoms[display_cols].copy()
+            display_df.insert(0, 'atom_id', display_df.index)
+            
+            # Format the table
+            table_str = str(display_df)
+            output_lines.append("\n" + table_str)
+        
+        # Print boundary atoms separately if present
+        if not qm_region.boundary_atoms.empty:
+            output_lines.append("\n" + "=" * 80)
+            output_lines.append("Boundary Atoms")
+            output_lines.append("=" * 80)
+            # Filter display_cols to only include columns that exist in boundary_atoms
+            boundary_display_cols = [col for col in display_cols if col in qm_region.boundary_atoms.columns]
+            boundary_display = qm_region.boundary_atoms[boundary_display_cols].copy()
+            boundary_display.insert(0, 'atom_id', boundary_display.index)
+            with pd.option_context('display.max_rows', None, 'display.max_columns', None):
+                output_lines.append("\n" + str(boundary_display))
+        
+        # Print interactions summary if available
+        if hasattr(qm_region, 'qm_interactions') and qm_region.qm_interactions:
+            output_lines.append("\n" + "=" * 80)
+            output_lines.append("QM Interactions Summary")
+            output_lines.append("=" * 80)
+            output_lines.append(f"Bonds: {len(qm_region.qm_interactions.get('bonds', []))}")
+            output_lines.append(f"Angles: {len(qm_region.qm_interactions.get('angles', []))}")
+            output_lines.append(f"Dihedrals: {len(qm_region.qm_interactions.get('dihedrals', []))}")
+        
+        # Write or print output
+        output_text = '\n'.join(output_lines)
+        
+        if output_file:
+            try:
+                with open(output_file, 'w') as f:
+                    f.write(output_text)
+                print(f"\nQM region information written to {output_file}")
+            except Exception as e:
+                print(f"\nError writing to file {output_file}: {e}")
+                print(output_text)
+        else:
+            print(output_text)
+            
+    except FileNotFoundError as e:
+        print(f'\n\nError: Cannot find file {e.filename}! Exiting..\n')
+        loader.close(halt=True)
+        sys.exit(1)
+    except (mimicpy.utils.errors.ParserError, mimicpy.utils.errors.MiMiCPyError, mimicpy.utils.errors.SelectionError) as e:
+        print(f'\n\nError: {e}\n')
+        loader.close(halt=True)
+        sys.exit(1)
+    except KeyboardInterrupt:
+        print("\nReading halted\n")
+        loader.close(halt=True)
+        sys.exit(1)
+
+
+def fm(args):
+    """
+    Execute the force matching workflow.
+    
+    Args:
+        args: Command line arguments containing force matching parameters
+    """
+    log_file = 'fm.log'
+    file_handler = logging.FileHandler(log_file)
+    file_handler.setLevel(logging.DEBUG)
+    logging.getLogger().addHandler(file_handler)
+
+    start_time = datetime.now()
+    logging.info(f'Running Force matching in MiMiCPy {datetime.now()}')
+   
+    # Read the FM data
+    fm_file = Path(args.fmdata)
+    if not fm_file.exists():
+        raise FileNotFoundError(f'FM file {fm_file} not found.')
+    
+    flag = 'dresp' if args.dresp else 'opt_ff' if args.opt_ff else 'fm'
+
+    
+    logging.info(f'Loading FM data from {fm_file}')
+    fmdata = FMDataset(fm_file)
+    logging.debug('FM data loaded successfully.')
+    
+    # Read the fm input using the new FMInput class
+    fm_input = FMInput.from_file(args.fi)
+    
+    # Get solvent names from fm_input
+    solvent_names = {'resnames': fm_input.solvent_resnames, 'molecules': fm_input.solvent_molecules}
+    
+    # Initialize QMRegion
+    qm_region = QMRegion(args.top, args.coords, gmxdata=args.ff)
+    qm_region.setup_qm_region(Path(args.sele), solvent_names)
+    
+    # Parse ITP file and get equivalent mapping
+    if fm_input.eq_atoms == 'use_atomtypes':
+        eq_map = qm_region.get_equivalent_map(use_atomtypes=True)
+    else:
+        eq_map = qm_region.get_equivalent_map(fm_input.eq_atoms)
+    
+    logging.info(f'Stride: {fm_input.stride}')
+    logging.info(f'Equivalent atoms in gmx index: {fm_input.eq_atoms}')
+    logging.info(f'Reference charges: {fm_input.reference_charges}')
+    logging.info(f'Number of snapshots used for fitting: {len(range(fm_input.stride[0], fm_input.stride[1], fm_input.stride[2]))}')
+    
+    if fm_input.skip_solvent_optimization:
+        logging.info('Skipping solvent optimization')
+        fixed_charge_indices = set(qm_region.solvent_atom_indices)
+    else:
+        fixed_charge_indices = None
+    
+    charge_group_constraints = None
+    if fm_input.charge_group_constraints:
+        logging.info('Creating charge group constraints')
+        charge_group_constraints = qm_region.create_charge_group_constraints(group_by='mol')
+        for group_key, (atom_indices, target_charge) in charge_group_constraints.items():
+            logging.info(f'Charge group {group_key} with {len(atom_indices)} atoms: target charge = {target_charge:.6f}')
+        # charge_group_constraints = list(charge_group_constraints.values())
+    
+    check_dresp = False
+    # DRESP fitting
+    if flag in ['fm', 'dresp']:
+        if flag == 'dresp':
+            logging.info('Selected only DRESP optimization')
+        configurations = get_configurations(fmdata, fm_input.stride[0], fm_input.stride[1], fm_input.stride[2], qm_region)
+        ff_charges = qm_region.qm_charges
+        if fm_input.qm_total_charge is not None and fm_input.qm_total_charge != qm_region.qm_total_charge:
+            logging.warning(f'QM total charge mismatch: {qm_region.qm_total_charge} != {fm_input.qm_total_charge}')
+            logging.warning(f'Using user-defined total charge: {fm_input.qm_total_charge}')
+            qm_region.qm_total_charge = fm_input.qm_total_charge
+        logging.info(f'QM total charge: {qm_region.qm_total_charge}')
+        ff_charges = np.array(list(map(float, ff_charges)))
+        
+        if fm_input.reference_charges == 'ff_charges':
+            for config, index in zip(configurations, range(fm_input.stride[0], fm_input.stride[1], fm_input.stride[2])): 
+                config['reference_charge'] = ff_charges
+
+        # DRESP optimization
+        logging.info('Running DRESP optimization')
+        wv = fm_input.wv
+        we = fm_input.we
+        wh = fm_input.wh
+        wq = fm_input.wq
+
+        if args.grid_search:
+            # Grid search mode
+            wv_list = wv if isinstance(wv, list) else [wv]
+            we_list = we if isinstance(we, list) else [we]
+            wh_list = wh if isinstance(wh, list) else [wh]
+
+            best_sdv = float('inf')
+            best_params = None
+            best_charges = None
+            best_sd = None
+            grid_results = []  # Store all results for output
+
+            import itertools
+            for wv_val, we_val, wh_val in itertools.product(wv_list, we_list, wh_list):
+                logging.info(f"Trying DRESP with wv={wv_val}, we={we_val}, wh={wh_val}")
+                charges = opt_dresp(configurations, wv_val, we_val, wh_val, wq, 
+                                        qm_region.qm_total_charge, eq_map, args.n_processes,
+                                        fixed_charge_indices, list(charge_group_constraints.values()), fm_input.weights_to_fix_charges)
+                charges = qm_region.redistribute_charges_after_dresp(charges, fm_input.num_bonds_away, 
+                                                            fixed_charge_indices, charge_group_constraints)
+                sd = compute_sd(charges, configurations, args.n_processes)
+                sdv = sd[0] + sd[1]
+                logging.info(f"SDV for wv={wv_val}, we={we_val}, wh={wh_val}: {sdv}")
+                grid_results.append({'wv': wv_val, 'we': we_val, 'wh': wh_val, 'sd_potential': sd[0], 'sd_field': sd[1], 'sdv': sdv, 'charges': charges})
+                if sdv < best_sdv:
+                    best_sdv = sdv
+                    best_params = (wv_val, we_val, wh_val)
+                    best_charges = charges
+                    best_sd = sd
+
+            # Output all grid search results to CSV for plotting
+            import csv
+            with open('dresp_grid_search_results.csv', 'w', newline='') as csvfile:
+                fieldnames = ['wv', 'we', 'wh', 'sd_potential', 'sd_field', 'sdv', 'charges']
+                writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+                writer.writeheader()
+                for row in grid_results:
+                    writer.writerow(row)
+
+            # Use best parameters and charges for updating and writing topology
+            wv, we, wh = best_params
+            full_optimize_charges = best_charges
+            sd = best_sd
+            logging.info(f"Best DRESP parameters: wv={wv}, we={we}, wh={wh} with SDV={best_sdv}")
+        else:
+            # Single DRESP calculation (no grid search)
+            wv_val = wv[0] if isinstance(wv, list) else wv
+            we_val = we[0] if isinstance(we, list) else we
+            wh_val = wh[0] if isinstance(wh, list) else wh
+            charges = opt_dresp(configurations, wv_val, we_val, wh_val, wq, 
+                                qm_region.qm_total_charge, eq_map, args.n_processes,
+                                fixed_charge_indices, list(charge_group_constraints.values()), fm_input.weights_to_fix_charges)
+            charges = qm_region.redistribute_charges_after_dresp(charges, fm_input.num_bonds_away, 
+                                                        fixed_charge_indices, charge_group_constraints)
+            sd = compute_sd(charges, configurations, args.n_processes)
+            wv, we, wh = wv_val, we_val, wh_val
+            full_optimize_charges = charges
+            logging.info(f"Single DRESP run: wv={wv}, we={we}, wh={wh}")
+
+        logging.info(f'DRESP optimized charges:')
+        for i, charge in enumerate(full_optimize_charges):
+            logging.info(f'{charge:10.6f}')
+        logging.info(f'# Sum of the charges: {np.sum(full_optimize_charges):10.6f}')
+        logging.info(f'# Standard deviations of potential: {sd[0]}')
+        logging.info(f'# Standard deviations of electric field: {sd[1]}')
+
+        qm_region.update_qm_charges(full_optimize_charges)
+
+        logging.info(f'DRESP optimization completed.')
+
+        if flag == 'dresp':
+            try:
+                logging.info(f'Writing DRESP topology.')
+                qm_region.write_topology(prefix='resp_')
+                logging.info(f'MiMiCPy Force matching workflow completed {datetime.now()}.')
+                logging.info(f'wall time: {datetime.now() - start_time}')
+            except Exception as e:
+                logging.error(f'Failed to write DRESP topology: {str(e)}')
+            return
+        
+
+        logging.info(f'Starting Non-bonded force calculation.\n')
+        # Write non-bonded ITP file with prefixed name
+        try:
+            logging.info(f'Writing non-bonded topology.')
+            qm_region.write_non_bonded_itp(prefix='non_bonded_')
+        except Exception as e:
+            logging.error(f'Failed to write non-bonded topology: {str(e)}')
+
+    if not check_dresp:
+        logging.info(f'Starting Non-bonded force calculation.\n')
+        try:
+            logging.info(f'Writing non-bonded topology.')
+            qm_region.write_non_bonded_itp(prefix='non_bonded_')
+            logging.info(f'Non-bonded topology written.')
+        except Exception as e:
+            logging.error(f'Failed to write non-bonded topology: {str(e)}')
+
+    # Take the topology and prefix the name rerun
+    rerun_top_file = Path(args.top).with_name('rerun_' + Path(args.top).name)
+    shutil.copy(args.top, rerun_top_file)
+    
+    # Get the list of written .itp files from QMRegion
+    written_itp_files = qm_region.written_files
+    
+    # Read the topology file content
+    with open(rerun_top_file, 'r') as f:
+        content = f.read()
+    
+    # Replace each .itp file reference with its non-bonded version
+    for itp_file in written_itp_files:
+        # Get the original name by removing the 'non_bonded_' prefix
+        non_bonded_name = Path(itp_file).name
+        original_name = non_bonded_name.replace('non_bonded_', '')
+        # Replace both quoted and unquoted references
+        content = content.replace(f'#include "{original_name}"', f'#include "{non_bonded_name}"')
+        content = content.replace(f"#include '{original_name}'", f"#include '{non_bonded_name}'")
+        content = content.replace(f"#include {original_name}", f"#include {non_bonded_name}")
+    
+    # Write the updated content back to the rerun topology file
+    with open(rerun_top_file, 'w') as f:
+        f.write(content)
+    logging.info(f'Non-bonded topology written.')
+
+    
+    tpr_file = 'rerun_nonb.tpr'
+    trr_file = 'rerun_nonb.trr'
+    
+    logging.info(f'Running Non-bonded force calculation.\n')
+    # Generate tpr file
+    try:
+        cmd = f"{args.gmx} grompp -f {args.mdp} -c {args.coords} -p {rerun_top_file} -n {args.ndx} -o {tpr_file} -maxwarn 1 -quiet"
+        logging.info(f"Running command: {cmd}")
+        subprocess.run(cmd, shell=True, check=True)
+        
+        # Rerun the GROMACS trajectory
+        nthreads = environ.get('OMP_NUM_THREADS', 1)
+
+        cmd = f"{args.gmx} mdrun -s {tpr_file} -rerun {args.trr} -o {trr_file} -e rerun_nonb.edr -g rerun_nonb.log -ntomp {nthreads} -quiet"
+        logging.info(f"Running command: {cmd}")
+        subprocess.run(cmd, shell=True, check=True)
+
+    except subprocess.CalledProcessError as e:
+        print(f"Error running GROMACS command: {e}")
+        sys.exit(1)
+    
+    logging.info(f'Non-bonded force calculation Completed.\n')
+    logging.info(f'Running force field parameter optimization.')
+    
+    ff_optimize, bond2params, regularization = get_optimize_ff_parameters(
+        qm_region, 
+        eq_map,
+        fm_input
+    )
+    
+    configurations = get_configurations_optff(fmdata, tpr_file, trr_file, fm_input.stride[0], fm_input.stride[1], 
+                                              fm_input.stride[2], qm_region)
+    
+    # Check if hierarchical optimization is requested
+    if hasattr(args, 'compare_methods') and args.compare_methods:
+        logging.info('Comparing all optimization methods...')
+        results = compare_optimization_methods(
+            qm_region, ff_optimize, configurations, bond2params, 
+            'optimization_comparison', regularization, fm_input, args.n_processes
+        )
+        
+        # Use the best method based on final cost
+        best_method = None
+        best_cost = float('inf')
+        for method, result in results.items():
+            if 'error' not in result and result['final_cost'] < best_cost:
+                best_cost = result['final_cost']
+                best_method = method
+                ff_optimize = result['optimized_params']
+        
+        if best_method:
+            logging.info(f'Best method: {best_method} with cost: {best_cost:.6f}')
+        else:
+            logging.error('All optimization methods failed')
+            sys.exit(1)
+            
+    else:
+        # Use the optimization method specified in fm_input
+        logging.info(f'Using optimization method: {getattr(fm_input, "optimization_method", "hierarchical")}')
+        
+        # Pass n_processes to the optimization function
+        logging.info(f'Using {args.n_processes} processes for parallel computation')
+        
+        # Optimize force field parameters using unified interface
+        ff_optimize, res = unified_optimization_ff(
+            qm_region, ff_optimize, configurations, bond2params, 
+            'optimization_results.txt', regularization, fm_input, args.n_processes
+        )
+        
+        if res:
+            logging.info(f'Output from optimization: ')
+            logging.info(f'        status: {getattr(res, "status", "N/A")} ')
+            logging.info(f'        message: {getattr(res, "message", "N/A")} ')
+            logging.info(f'        success: {getattr(res, "success", True)} ')
+        else:
+            logging.info('Optimization completed successfully')
+    
+    logging.info(f'Force field parameter optimization completed.')
+
+    logging.info('Writing optimized force parameters to file.')
+    qm_region.update_topology(ff_optimize, bond2params)
+    qm_region.write_topology(prefix='opt_')
+    logging.info(f'MiMiCPy Force matching workflow completed {datetime.now()}.')
+    logging.info(f'wall time: {datetime.now() - start_time}')
+
 def main():
     print('\n \t                ***** MiMiCPy *****                  ')
     print('\n \t                Running version {}\n\tFor more information type mimicpy [subcommand] --help \n'.format(mimicpy.__version__))
@@ -620,6 +1183,7 @@ def main():
     cpmd2coords_others = parser_cpmd2coords.add_argument_group('other options')
     cpmd2coords_others.add_argument('-guess',
                               required=False,
+                              default=True,
                               type=__str2bool,
                               help='toggle guessing atomic elements',
                               metavar='(True)')
@@ -668,7 +1232,7 @@ def main():
                               metavar='')
     fixtop_others.add_argument('-cls',
                               required=False,
-                              default=False,
+                              default=None,
                               type=__str2bool,
                               help='toggle clear [ atomtypes ] sections from files',
                               metavar='(False)')
@@ -753,6 +1317,166 @@ def main():
                                metavar='[.gro/.pdb] (GEOMETRY.gro)')
     parser_geom2coords.set_defaults(func=geom2coords)
     ##
+    #####
+    parser_json2h5 = subparsers.add_parser('json2h5',
+                                          help='convert large JSON Force Matching data files to HDF5 format')
+    json2h5_input = parser_json2h5.add_argument_group('options to specify input files')
+    json2h5_input.add_argument('-i',
+                              required=True,
+                              help='input JSON file containing Force Matching data',
+                              metavar='[.json]')
+    json2h5_output = parser_json2h5.add_argument_group('options to specify output files')
+    json2h5_output.add_argument('-o',
+                               required=False,
+                               help='output HDF5 file (default: input file with .h5 extension)',
+                               metavar='[.h5]')
+    parser_json2h5.set_defaults(func=json2h5)
+    ##
+    #####
+    parser_h5info = subparsers.add_parser('h5info',
+                                         help='display information about HDF5 Force Matching data files')
+    h5info_input = parser_h5info.add_argument_group('options to specify input files')
+    h5info_input.add_argument('-i',
+                             required=True,
+                             help='input HDF5 file containing Force Matching data',
+                             metavar='[.h5]')
+    parser_h5info.set_defaults(func=h5info)
+    ##
+    #####
+    # Add compare-top command
+    parser_compare = subparsers.add_parser('compare-top',
+                                          help='compare QM parameters between two topologies')
+    compare_input = parser_compare.add_argument_group('options to specify inputs')
+    compare_input.add_argument('-top1',
+                             required=True,
+                             help='First topology file',
+                             metavar='[.top]')
+    compare_input.add_argument('-top2',
+                             required=True,
+                             help='Second topology file',
+                             metavar='[.top]')
+    compare_input.add_argument('-top3',
+                             required=False,
+                             help='Third topology file',
+                             metavar='[.top]')
+    compare_input.add_argument('-coords',
+                                required=True,
+                                help='Coordinate file (gro/pdb)',
+                                metavar='[.gro/.pdb]')
+    compare_input.add_argument('-sele',
+                         required=True,
+                         help='qm selection',
+                         metavar='[.txt/.dat]')
+    parser_compare.set_defaults(func=compare_top)
+    ##
+    #####
+    parser_qminfo = subparsers.add_parser('qminfo',
+                                         help='print information about QM atoms in the QM region')
+    qminfo_input = parser_qminfo.add_argument_group('options to specify input files')
+    qminfo_input.add_argument('-top',
+                             required=True,
+                             help='GROMACS topology file',
+                             metavar='[.top]')
+    qminfo_input.add_argument('-coords',
+                             required=True,
+                             help='GROMACS coordinate file',
+                             metavar='[.gro/.pdb]')
+    qminfo_input.add_argument('-sele',
+                             required=True,
+                             help='QM selection file',
+                             metavar='[.txt/.dat]')
+    qminfo_output = parser_qminfo.add_argument_group('options to specify output files')
+    qminfo_output.add_argument('-out',
+                              required=False,
+                              help='output file to write QM information (default: print to console)',
+                              metavar='[.txt]')
+    qminfo_others = parser_qminfo.add_argument_group('other options')
+    qminfo_others.add_argument('-ff',
+                             required=False,
+                             help='path to force field data directory',
+                             metavar='')
+    qminfo_others.add_argument('-guess',
+                              required=False,
+                              default=True,
+                              type=__str2bool,
+                              help='toggle guessing atomic elements',
+                              metavar='(True)')
+    qminfo_others.add_argument('-nsa',
+                             required=False,
+                             help='file containing non-standard atomtypes in 2-column format',
+                             metavar='[.txt/.dat]')
+    qminfo_others.add_argument('-buf',
+                             required=False,
+                             default=1000,
+                             type=__str2int,
+                             help='buffer size for reading input topology',
+                             metavar='(1000)')
+    parser_qminfo.set_defaults(func=qminfo)
+    ##
+    #####
+    parser_fm = subparsers.add_parser('fm',
+                                     help='run force matching workflow')
+    fm_input = parser_fm.add_argument_group('options to specify input files')
+    fm_input.add_argument('-top',
+                         required=True,
+                         help='GROMACS topology file',
+                         metavar='[.top]')
+    fm_input.add_argument('-sele',
+                         required=True,
+                         help='qm selection',
+                         metavar='[.txt/.dat]')
+    fm_input.add_argument('-fmdata',
+                         required=True,
+                         help='Force matching data file',
+                         metavar='[.json]')
+    fm_input.add_argument('-fi',
+                         required=True,
+                         help='Force matching input file',
+                         metavar='[.inp]')
+    fm_input.add_argument('-trr',
+                         required=True,
+                         help='GROMACS trajectory file',
+                         metavar='[.trr]')
+    fm_input.add_argument('-mdp',
+                         required=False,
+                         help='GROMACS MDP file',
+                         metavar='[.mdp]')
+    fm_input.add_argument('-ndx',
+                         required=True,
+                         help='GROMACS index file',
+                         metavar='[.ndx]')
+    fm_input.add_argument('-coords',
+                         required=True,
+                         help='GROMACS coordinate file',
+                         metavar='[.gro/.pdb]')
+    fm_others = parser_fm.add_argument_group('other options')
+    fm_others.add_argument('-ff',
+                          required=False,
+                          help='path to force field data directory',
+                          metavar='')
+    fm_others.add_argument('-gmx',
+                          default='gmx',
+                          help='GROMACS executable',
+                          metavar='(gmx)')
+    fm_others.add_argument('-dresp',
+                          action='store_true',
+                          help='run only DRESP optimization')
+    fm_others.add_argument('-opt_ff',
+                          action='store_true',
+                          help='run only force field optimization')
+    fm_others.add_argument('-grid_search',
+                          action='store_true',
+                          help='perform grid search over wv, we, wh and output CSV')
+    fm_others.add_argument('-compare_methods',
+                          action='store_true',
+                          help='compare all optimization methods and use the best one')
+    fm_others.add_argument('-n_processes',
+                          type=int,
+                          default=None,
+                          help='number of processes for parallel force computation (default: auto-detect)')
+    parser_fm.set_defaults(func=fm)
+    ##
+
     args = parser.parse_args()
     if vars(args) == {}:
         sys.exit()