DynaPIN is a powerful and flexible analysis pipeline designed for Molecular Dynamics (MD) simulations. It specializes in dissecting protein-protein interactions, assessing structural stability, calculating energetic contributions and intermolecular interactions at the residue level.

Whether you are running a quick quality check or a deep-dive interface analysis, DynaPIN streamlines the process from trajectory to visualization.

DynaPIN performs analysis in three distinct yet integrated modules:

Assess the stability and reliability of your simulation.

• Structural Metrics: Root Mean Square Deviation (RMSD), Radius of Gyration (RG), Root Mean Square Fluctuation (RMSF).
• Interface Quality with CAPRI Metrics: Interface RMSD (iRMSD), Ligand RMSD (lRMSD), DockQ Score, Fraction of Native (Fnat) and Non-Native (Fnonnat) contacts.

Characterize the physicochemical evolution of interface residues.

• Dynamic Classification: Categorizes residues as Core, Rim, Support, Surface, or Interior based on the Levy (2010) model.
• Surface Analysis: Relative and Absolute Solvent Accessible Surface Area of complex and monomers (rASA/SASA).
• Energetics: Decomposition of binding energy (Van der Waals, Electrostatic) per residue using FoldX.
• Secondary Structure: Dynamic monitoring of structural changes at interface.

Map the specific atomic interaction networks over time.

• Bond Tracking: Detects Hydrogen bonds, Hydrophobic interactions, and Salt bridges (Ionic bonds).

DynaPIN is built on an object-oriented and modular Python architecture, integrating powerful libraries such as MDAnalysis and pdb-tools for trajectory handling, DockQ for interface quality assessment, FreeSASA for accessible surface area calculations, FoldX for energy analysis, DSSP for secondary structure tracking, and interfacea for interaction profiling. Results are automatically organized into tabular data (.csv) and visual plots (.png).

Before installing DynaPIN, please ensure you have the following:

• Operating System: Linux and macOS.
  • Note for Windows Users: It is recommended to use WSL (Windows Subsystem for Linux) for the best compatibility with DynaPIN.
• Package Manager: Anaconda or Miniconda is required to manage the environment.
• Version Control: Git is recommended for cloning the repository.
• Python: The package supports Python 3.10 and higher.

The dynapin Conda environment automatically installs all core libraries. However, the energy calculation module relies on FoldX, which requires a separate, manual installation due to academic licensing restrictions.

How to use FoldX with DynaPIN:

1. Download the FoldX executable from the FoldX Suite website.
2. When executing DynaPIN, pass the path to this executable using the --foldx_path argument.

Note: FoldX is entirely optional. If you do not provide the --foldx_path argument, DynaPIN will still run perfectly, but it will automatically bypass the energy calculation module.

DynaPIN utilizes a unified Conda environment to manage Python dependencies and system binaries (including the custom C-extensions for interfacea).

git clone https://github.com/aysebercin/DynaPIN.git
cd DynaPIN

This command installs all necessary dependencies

conda env create -f environment.yml
conda activate dynapin

DynaPIN is ready to use!

DynaPIN offers two primary ways to run analyses: via the Command Line Interface (CLI) for standard pipelines, or through the Python API for interactive exploration.

Run a complete analysis pipeline (Quality Control, ResidueBased, and InteractionBased modules) with a single command:

# Using a PDB trajectory
dynapin --output_dir=TestRun --trajectory_file=sim.pdb --commands=all_analysis,all_plots

# Using a DCD trajectory with topology
dynapin --output_dir=TestRun --trajectory_file=sim.dcd --topology_file=top.psf --stride=10 --foldx_path=/path/to/foldx --commands=all_analysis,all_plots

Beyond the command line, DynaPIN serves as a powerful Python library. We provide a comprehensive Jupyter Notebook that demonstrates this usage, allowing for inline 3D visualization and granular control over every analysis step.

• Notebook: DynaPIN_API_workflow.ipynb
• Use Case: Ideal for users who prefer an interactive environment (Jupyter/Lab) or wish to integrate DynaPIN into custom Python scripts.

To run the workflow interactively:

conda activate dynapin
jupyter notebook DynaPIN_API_Workflow.ipynb

DynaPIN organizes the analysis outputs into a structured directory as shown below. Results are automatically organized into tables/ (CSV data) and figures/ (High-quality Plots). (Note: *.png indicates multiple plot files generated for different metrics)

output_dir/
│
├── figures/                         # Visualization Plots
│   ├── int_pairwise_*.png           # Interaction frequency plots (H-bond, Hydrophobic, Ionic)
│   ├── qc_*.png                     # Quality control plots (RMSD, RMSF, DockQ, Rg, etc.)
│   └── res_*.png                    # Residue analysis plots (SASA, DSSP, FoldX, etc.)
│
├── tables/                          # Numerical Data (CSV)
│   ├── int_pairwise_trajectory.csv  # Detailed list of atomic interactions per frame
│   ├── qc_residue_rmsf.csv          # RMSF values per residue
│   ├── qc_trajectory_metrics.csv    # Time-series data for global metrics (RMSD, Rg, DockQ)
│   ├── res_interface_stats.csv      # Interface occupancy statistics (Core/Rim classification)
│   └── res_trajectory_props.csv     # Residue-wise properties (Energy, SASA, Secondary Structure)
│
├── models.zip                       # Archive of extracted PDB frames used for analysis
├── *_fixed_standardized.pdb         # Pre-processed structure files
├── plot_params.json                 # Configuration used for generating plots
└── table_params.json                # Configuration used for calculations

❗The full datasets (input MD trajectories) and application examples (DynaPIN analysis outputs) for the test cases presented in our manuscript are openly available on Zenodo:

This dataset includes:

• Trajectory_Inputs/: Raw trajectory (.dcd) and topology (.pdb) files for the Rigid, Medium, and Difficult test cases.
• DynaPIN_Outputs/: Full sets of outputs including tables, figures and intermediate datas generated by DynaPIN for these systems.

DynaPIN is currently under peer review. If you use DynaPIN in your research, please cite our upcoming paper:

@article{barlas_dynapin_2026,
  title={DynaPIN: A tool for characterizing dynamic protein interfaces},
  author={Barlas, Ayşe Berçin and Özsan, Atakan and Prévost, Chantal and Sacquin-Mora, Sophie and Karaca, Ezgi},
  journal={Under Review},
  year={2026}
}

DynaPIN seamlessly integrates several powerful structural analysis tools and methodologies to perform comprehensive interface profiling. If you use DynaPIN in your research, we highly encourage you to consider citing the underlying software and definitions that make this pipeline possible:

• MDAnalysis: Trajectory processing and core structural metrics. [Michaud-Agrawal et al., 2011]
• pdb-tools: Manipulation, cleaning, and preprocessing of PDB files. [Rodrigues et al., 2018]
• DockQ: Frame-resolved CAPRI interface quality metrics. [Basu & Wallner, 2016]
• FreeSASA & Levy's Definition: Computing accessible surface areas and mapping interface regions. [Mitternacht, 2016] / [Levy, 2010]
• DSSP: Monitoring secondary structure transitions. [Hekkelman et al., 2025]
• FoldX: Calculating van der Waals and electrostatic energy contributions. [Schymkowitz et al., 2005]
• interfacea: Atomistic profiling of non-covalent interactions. [Rodrigues et al., 2019]

This project is supported by TÜBİTAK (The Scientific and Technological Research Council of Türkiye) under the 2509 Bosphorus Türkiye-France Bilateral Cooperation Program (Project No: 122N790).

Developed by the Computational Structural Biology Lab (CSB) at Izmir Biomedicine and Genome Center (IBG).

If you have any questions, feedback, or issues related to DynaPIN, please feel free to contact the project team:

• Ayşe Berçin Barlas: aysebercin.barlas@ibg.edu.tr
• Ezgi Karaca: ezgi.karaca@ibg.edu.tr