2026 Volume 39 Issue 2
Article Contents

Miaolan Zhen, Mingyang Li, Jialei Xu, Rui Shi, Hujun Qian, Youliang Zhu, Zhongyuan Lu. A Multi-Scale Molecular Dynamics Scheme/Toolkit for Polymer Modeling†[J]. Chinese Journal of Chemical Physics, 2026, 39(2): 145-158. doi: 10.1063/1674-0068/cjcp2510160
Citation: Miaolan Zhen, Mingyang Li, Jialei Xu, Rui Shi, Hujun Qian, Youliang Zhu, Zhongyuan Lu. A Multi-Scale Molecular Dynamics Scheme/Toolkit for Polymer Modeling†[J]. Chinese Journal of Chemical Physics, 2026, 39(2): 145-158. doi: 10.1063/1674-0068/cjcp2510160

A Multi-Scale Molecular Dynamics Scheme/Toolkit for Polymer Modeling†

通讯作者: 陈斌, bchen63@163.com
  • 1. 

    沈阳化工大学材料科学与工程学院 沈阳 110142

  1. 本站搜索
  2. 百度学术搜索
  3. 万方数据库搜索
  4. CNKI搜索

Figures(9)

Article Metrics

Article views(302) PDF downloads(6) Cited by(0)

Access History

A Multi-Scale Molecular Dynamics Scheme/Toolkit for Polymer Modeling†

Abstract: Multi-scale modeling of polymer systems remains a fundamental challenge in materials science due to the strongly coupled structures and dynamics across atomic, mesoscopic, and macroscopic scales. Here, we present PyGAMD-ChemFAST (Python GPU-accelerated molecular dynamics-chemical-friendly automated simulation toolkit), an integrated modeling and simulation framework that combines a molecular simulation platform with an automated modeling and processing toolkit. The framework supports bidirectional cross-scale modeling, integrating the mapping from all-atom (AA) to coarse-grained (CG) models in coarse-graining and from CG back to AA in fine-graining, while automating the entire workflow from model parameterization through dynamics simulation to property analysis. It accommodates complex polymer topologies and ensures cross-scale force field compatibility. By unifying modeling and simulation in a programmable environment, PyGAMD-ChemFAST enhances computational efficiency and ensures parameter consistency, especially in studying phase separation, glass transition, crystallization, and mechanical behavior. This integrated framework provides an efficient and reliable platform for high-throughput, multi-scale polymer research.

    • The multi-scale correlation of polymer system properties represents a central challenge in contemporary materials science. From transient fluctuations in electronic structure at the microscopic scale (angstrom-femtosecond scale) to the aging behavior of materials at the macroscopic scale (meter-year scale), physical processes across different hierarchical levels exhibit strong mutual coupling. This coupling endows materials with diverse functional properties. In polymers, which are characterized as soft matter, this spatiotemporal coupling is particularly pronounced. Fluctuations in molecular conformation directly modulate the formation of mesoscopic structures, which in turn determine the macroscopic rheological behavior and mechanical properties of the materials. This unique multi-scale feedback mechanism poses a fundamental challenge to traditional hierarchical modeling approaches. Specifically, the polarization of local chemical bonds at the atomistic scale may propagate to the mesoscopic scale via the cooperative motion of molecular chains, thereby altering the kinetics of phase separation or the crystallization process [1].

      To elucidate this intricate interconnection network, multi-scale modeling methodologies have been developed to establish multi-scale coupling mechanisms, thereby reconciling theoretical precision with computational tractability. Specifically, these methodologies aim to derive multi-scale equations, optimize parameterization strategies, or design coupling algorithms, leveraging information from more detailed scale models to characterize behaviors across diverse scales [2]. For instance, the coarse-graining framework developed by Qian et al. (Scheme 1 in Ref.[3]) delineates the representative structures and dynamic characteristics of the polymer system across spatial and temporal scales, thereby revealing the scale interdependence inherent in polymer systems [3]. Commencing from the chemical structure at the monomeric level, and through characteristic parameters such as Kuhn length, tube diameter (dT), and radius of gyration (Rg), a gradual association is forged with mesoscopic molecular assemblies and phase separation structures. In the temporal dimension, a comprehensive scale connection is achieved, spanning from chemical bond vibrations (ps), segmental relaxation (ns), to disentanglement dynamics (μs), and culminating in macroscopic stress relaxation phenomena. This bottom-up research paradigm not only offers a lucid perspective for comprehending the physical essence of polymer behavior but also furnishes theoretical framework support for the application of multi-scale modeling methodologies.

      However, the current multi-scale modeling methods still encounter significant challenges when applied to complex polymer systems. Although techniques such as coarse-grained molecular dynamics have achieved a degree of maturity—markedly enhancing computational efficiency through the systematic reduction of degrees of freedom—the construction of a potential function that preserves chemical specificity and is universally applicable across different systems remains a central bottleneck. This issue is especially pronounced in flexible chains and block copolymers. When traditional methods are employed to construct coarse-grained (CG) potential functions, they often struggle to balance the cross-scale fidelity of configurational entropy and dynamic behavior when dealing with polymer relaxation, viscoelastic responses, or non-equilibrium processes. This results in the loss of high-frequency degrees of freedom and significantly compromises the accuracy of material mechanical predictions [2]. Moreover, the limitations of existing modeling tools further exacerbate these challenges. For instance, the Polymer Builder module of Materials Studio 2020 software can generate conventional homopolymers and block copolymers through a graphical interface. However, for complex topologies such as hyperbranched structures or cross-linked networks, it relies on script extensions and lacks the ability to batch-process dendritic polymers. More critically, its polymer dynamics models only support terminal group effects and cannot handle the front-end effects of monomers such as acrylate [4]. The fragmented functions and insufficient chemical coverage of these tools force researchers to combine multiple software packages or develop their own scripts. This not only introduces human errors but also hinders the implementation of high-throughput screening and automated processes. This contradiction underscores the urgent need to develop a multi-scale modeling framework that integrates chemical flexibility, dynamic sensitivity, and computational efficiency.

      Therefore, in this work, we propose an end-to-end modeling-simulation coupling workflow, termed PyGAMD-ChemFAST. This workflow integrates the molecular dynamics simulation platform PyGAMD (Python GPU-accelerated Molecular Dynamics, http://pygamd.com/) with the newly developed processing software ChemFAST (Chemical-Friendly Automated Simulation Toolkit, https://github.com/DoMD-toolkit/DoMD) that has automatic modeling capabilities via the Python application programming interface (API). Compared to traditional toolchains (such as Materials Studio 2020, which relies on manual processes and discrete module switching), this workflow leverages the high-throughput modeling advantages of ChemFAST to achieve seamless connection throughout the entire process from initial conformation generation, cross-scale parameter transfer to molecular dynamics simulation. ChemFAST’s random walk algorithm can efficiently generate complex topological structures, such as gradient/irregular copolymers and highly branched systems. Moreover, its native multi-scale force field interface directly outputs PyGAMD-compatible input files, thereby circumventing parameter conversion errors associated with commercial software. This integrated design not only unifies the fragmented operations inherent in traditional workflows but also enables closed-loop optimization of modeling-simulation through the programmability of Python scripts. Consequently, it significantly enhances simulation efficiency and parameter consistency for systems such as block copolymer phase separation and materials with high mechanical responses. The performance of this framework will be systematically verified in subsequent chapters, encompassing the cross-scale simulation workflow of PyGAMD-ChemFAST (Section II) and typical polymer test cases (Section III).

    II.   MULTI-SCALE POLYMER MODELING AND SIMULATION WORKFLOW
    • This section outlines the automatic multi-scale polymer modeling and simulation workflow developed in this study. The overall procedure comprises three principal stages: CG modeling, molecular dynamics simulation, and fine-grained backmapping coupled with parameter reconstruction. Key algorithmic components in the coarse-graining and fine-graining stages are delivered by the ChemFAST software package. Meanwhile, PyGAMD acts as a unified simulation and analysis engine, providing high-performance computing support and multi-method integration capabilities throughout the workflow.

    • Traditionally, CG methods can be broadly categorized into two groups: bottom-up and top-down approaches. The bottom-up strategy employs higher-resolution simulation data encompassing all-atom (AA-MD) and ab initio molecular dynamics as a reference, from which the CG interaction potential is derived through mapping and inversion. Representative methods include iterative Boltzmann inversion (IBI) [5], force matching [6], and inverse Monte Carlo [7]. These approaches can accurately reproduce radial distribution functions, potential energy surfaces, and short-range interaction characteristics, offering considerable advantages in structural consistency. However, due to the reduction in degrees of freedom, their dynamic properties often exhibit acceleration effects compared to experimental data or all-atom models [2], and they face certain limitations in system scalability and transferability. In recent years, trajectory matching [8, 9] has incorporated Bayesian inference into the parameter optimization process, enabling the theoretically optimal reproduction of reference trajectories, though its accuracy depends heavily on the representativeness of the selected trajectories. Meanwhile, advances in machine learning have facilitated the development of CG optimization strategies based on neural network potentials [10], which can learn high-dimensional free energy surfaces from large datasets and offer enhanced flexibility and cross-system generalizability for bottom-up coarse-graining.

      In contrast, the top-down approach does not rely on atomic-level simulations. Instead, it constructs CG models through empirical parameterization, using experimentally measurable macroscopic or thermodynamic properties as constraints. Representative methods include the Martini force field [11], dissipative particle dynamics (DPD) [12], and the hybrid molecular dynamics-self-consistent field (MD-SCFT) method [13]. This approach is highly effective at capturing mesoscopic phase behavior, albeit often at the expense of local chemical detail.

      Here, we incorporate an automatic CG modeling algorithm for the bottom-up strategy based on iterative IBI. The process begins with all-atom reference data, from which target structural observables (such as radial distribution functions, g(r), and related thermodynamic quantities) are derived [14]. Also, using this potential of mean force, we developed a dynamics consistency model via generalized the Langevin equation [3].

    • In the coarse-graining stage of this workflow, the algorithm executes a closed refinement loop, which encompasses CG simulation, potential update, and re-simulation, to iteratively drive the CG model into agreement with the targets, as shown in FIG. 1. Throughout this process, ChemFAST optimizes the CG potential while preserving key microscopic structural features and thermodynamic properties of the atomic-level reference. It is capable of generating equilibrated CG conformations relatively quickly. The core formulation and implementation details are described below:

      The total potential energy of the CG model is decomposed into two independent components, assuming that bonded and non-bonded interactions are uncorrelated:

      For the bonded interactions, we adopted a pairwise approximation while explicitly excluding intramolecular 1-3 non-covalent interactions. The bonded energy includes contributions solely from bond stretching and angle bending between CG beads. Following prior research [15], dihedral interactions between 1-4 supramolecular units along the chain backbone can be neglected. The bonded interaction energy is derived from the Boltzmann inversion of their respective distribution functions:

      Among these, $ {k}_{\text{B}} $ is the Boltzmann constant, $ {P}^{\text{CG}}\left(l\right) $ and ${P}^{\text{CG}}\left(\theta \right)$ represent the distribution functions for bonds and angles, respectively. The terms $ {l}^{2} $ and $ \dfrac{1}{\sin\theta} $ denote the metric factors that account for the geometric contributions in the respective integrals.

      For non-bonded interactions, the potential of mean force (PMF) serves as the initial trial potential. $g^\text{ref}\left(r\right)$ corresponds to the reference radial distribution function (RDF) derived from all-atom simulations:

      PMF-based potentials often fail to reproduce the target structure in condensed systems due to multi-body correlations. To correct deviations between the simulated and reference RDFs, the CG potential was refined iteratively using the IBI method until quantitative agreement was achieved:

      Finally, because the structure-matching procedure does not guarantee thermodynamic consistency, the system pressure often deviates from the target value (1 atm). To address this, a linear perturbation term was applied to the non-bonded potential:

      Here, $\lambda$ is a constant whose sign is determined by whether the current pressure is above or below the target value (1 atm), and $ {r}_{\text{cut}} $ denotes the cutoff distance for non-bonded interactions. A schematic flowchart of this IBI process is illustrated in FIG. 1.

      Furthermore, based on the nature of the research subjects, CG models can be broadly categorized into two paradigms: (i) generic models, which emphasize universal polymer properties—exemplified by the Kremer−Grest model and DPD; and (ii) chemically specific CG models, which are tailored to particular chemical systems. In the latter, the choice of the mapping operator is critical. This is illustrated in FIG. 2 for the CG model of a polystyrene-poly(methyl methacrylate) block copolymer, where the center of mass of each chemical monomer is selected as the CG mapping site.

      By combining the IBI method with generalized Langevin equation (GLE) dynamics, we have established a coarse-graining method that is structurally, thermodynamically, and dynamically consistent, thereby establishing a reliable foundation for large-scale molecular dynamics simulations of polymer systems (see FIG. 3). Further details of this coarse-graining model can be found in our previous work. This approach allows researchers to efficiently develop chemically specific CG models for complex homopolymers [15], copolymers [14] and polymer composites [16]. The entire IBI optimization process, which includes potential function sampling, potential energy update, structural re-simulation, and dynamics memory kernel calculation can be automatically driven and monitored by PyGAMD. Furthermore, the numerical potential from IBI can be invoked via ${\mathrm{PairForceTable}} $, ${\mathrm{BondForceTable}} $, ${\mathrm{AngleForceTable}} $, and ${\mathrm{DihedralForceTable}} $ modules of PyGAMD.

    • PyGAMD integrates common system construction methods for all-atom models, united atom models, CG Martini models, DPD models, and MD-SCFT models. This integration avoids the errors in atomic type mapping and format conversion that are common in traditional multi-software workflows, significantly shortening the closed-loop cycle of “modeling-verification-re-modeling”. At the implementation level, the construction of the CG system is completed by the ${\mathrm{Molgen}} $ (molecular generator) module built in PyGAMD. This module implements the definition of molecular objects and system initialization in a highly scripted manner, including two core classes, “${\mathrm{Molecule}} $” and “${\mathrm{Object}} $”, corresponding to flexible chain-like molecules and rigid molecular entities. Users can directly specify key parameters such as particle number, particle type, topological connection, and bond length in Python scripts to achieve precise control of the system. For rigid objects, pre-defined ${\mathrm{MST}} $ or ${\mathrm{XML}} $ files can be directly imported for quick loading. The ${\mathrm{Molgen }}$ module provides two efficient construction schemes: (i) fully scripted definition, setting the simulation box size and adding molecular instances through the ${\mathrm{Generators}} $ class; (ii) hybrid mode definition, some parameters are read from external files, and some are supplemented through scripts. Therefore, based on this architecture, PyGAMD can both directly invoke the IBI CG potential energy files generated by ChemFAST, and execute multiple mainstream CG modeling routes in a unified framework:

      (1) DPD model: the DPD model naturally incorporates hydrodynamic interactions, making it highly effective for simulating large-scale phase separation and self-assembly processes. Users can define conservative force parameters and random force intensities via the ${\mathrm{DPDForce}} $ class. For instance, in an A5B5 block copolymer system:

      The preceding code sets the interaction strength between particle types A and B. A parameter of ${\alpha }_\text{AB}$= 40.0 signifies a strong repulsive potential between the components, driving the system toward spontaneous mesoscopic phase separation.

      (2) Martini model: this approach implements empirical parameterization within the top-down paradigm, ensuring broad transferability across systems. Users can apply the Martini force field by configuring parameters in the ${\mathrm{LJCoulombShiftForce}} $ class. The following code snippet illustrates representative parameter definitions:

      In this code, the ${\mathrm{setParams()}} $ function defines Lennard-Jones (LJ) parameters (including energy (ε), diameter (σ), cutoff distance, and smoothing coefficients) for different bead combinations. The ${\mathrm{setCoulomb()}} $ function specifies the dielectric constant and Coulomb cutoff distance, ensuring continuous differentiability of the interaction potential at the cutoff radius.

      In addition, PyGAMD supports hybrid methodologies such as the MD-SCFT approach. For further CG modeling schemes and application examples, readers are directed to the user documentation available on the PyGAMD website (http://pygamd.com/) and our previously published papers [17−19].

    • The PyGAMD-ChemFAST workflow introduced in this study utilizes the GPU-accelerated molecular dynamics platform, PyGAMD, as its simulation core. Evolving from the previously developed frameworks [20, 21], PyGAMD represents a cutting-edge molecular simulation platform by integrating diverse computational simulation tools to support complex procedural computations for material screening. In contrast to traditional CUDA-based compiled systems, PyGAMD operates through a cooperative runtime mechanism between the Python interpreter and precompiled GPU extension libraries. This architecture preserves flexibility and programmability while substantially improving computational efficiency and algorithmic scalability. PyGAMD adopts a modular design that integrates over 20 common molecular simulation methods alongside 9 innovative simulation techniques [17−19]. These encompass traditional approaches such as classical MD and DPD, as well as specialized modules for dynamic bond models and polymer reaction modeling. The platform’s computational core is built upon deeply optimized CUDA/C++ libraries, including the ${\mathrm{Molgen}} $ for configuration generation and the ${\mathrm{dataTackle}} $ for post-processing and property analysis, all managed uniformly through a Python interface. This structure enables users to directly define potential energy functions, integration schemes, and system parameters within Python scripts without code recompilation, thereby significantly lowering the threshold for algorithm development and force field extension. In addition, PyGAMD offers dual backend support for NVIDIA CUDA and heterogeneous computing architectures (e.g., HIP for domestic GPUs). Users only need to switch the module import (from poetry import ${\mathrm{cu\_gala}} $ or from poetry import ${\mathrm{hip\_gala}} $) at the beginning of the script to achieve cross-platform execution. This design ensures the platform’s universality, maintainability, and high performance across different computing architectures.

      Leveraging its script-based and modular architecture, PyGAMD enables users to execute the entire simulation workflow within a single Python script, encompassing system construction, interaction definition, and numerical integration. As a practical demonstration, the following example illustrates the simulation of glass transition behavior in a polyethylene oxide (PEO) system. It is worth noting that the initial configuration used in the simulation and the force field files (${\mathrm{peo.xml }}$ and ${\mathrm{peo.force\_field }}$) were all automatically generated by PyGAMD during the CG modeling stage invoked via the ChemFAST package. These files contain the equilibrium conformations of the system, topological connections, and interaction parameters. A representative simulation run script is shown in the following code snippet:

      The preceding code segment accomplishes the import of system topology, allocation of GPU resources, and configuration of the integration timestep. Utilizing the ${\mathrm{XMLReader}} $ module, PyGAMD automatically parses the initial CG configuration file (${\mathrm{peo.xml}} $), reading molecular structures, particle types, charge distributions, and parameters for bonded and non-bonded interactions. The simulation core object is then constructed via the ${\mathrm{Application()}} $ class.

      Subsequently, the neighbor list and various interaction potentials are defined to enable modular management of both short- and long-range forces. For non-bonded interactions, a hybrid LJ plus Ewald summation potential model is employed, formulated as follows:

      In the provided code, the .${\mathrm{force\_field file}} $ is directly parsed by PyGAMD’s ${\mathrm{force\_field\_gala}} $ module without requiring additional conversion steps. The platform automatically reads the parameter set from the ${\mathrm{peo.force\_field}}$ file and loads bond, angle, and dihedral parameters through corresponding classes such as ${\mathrm{BondForceHarmonic}} $.

      During the dynamics stage, PyGAMD provides a comprehensive set of integrators and controllers for various thermodynamic ensembles, ranging from microcanonical to isothermal-isobaric (NPT) conditions. Available algorithms include Langevin dynamics (${\mathrm{LangevinNVT/LangevinNVTRigid}} $), Nosé−Hoover thermostats (${\mathrm{NoseHooverNVT/NoseHooverChain}} $${\mathrm{NVT}} $), the Andersen barostat (NPT), and the Martyna−Tobias−Klein method (${\mathrm{NPTMTK}} $), among others. For the PEO system under study, the ${\mathrm{NPTMTK}} $ class, which implements the Martyna−Tobias−Klein algorithm, is invoked to perform equilibrium simulations in the isothermal-isobaric ensemble. In this context, T and P represent reduced units of temperature and pressure, while 0.2 and 2.0 are the coupling constants for temperature and pressure control, respectively. The corresponding script is as follows:

      To mitigate global system drift and ensure numerical stability, the ${\mathrm{Sort}} $ and ${\mathrm{ZeroMomentum}} $ modules are incorporated into the script. The former periodically reorders particle indices to enhance data reading efficiency, while the latter performs momentum zeroing corrections. The relevant code sections appear below:

      In terms of data output, PyGAMD adopts a multi-level recording framework: (1) the ${\mathrm{DumpInfo}} $ module logs macroscopic observables, such as system temperature, pressure, potential energy components, and box size in real time; (2) the ${\mathrm{XMLDump}} $ module outputs full trajectory data at specified intervals, capturing particle positions, types, charges, and bonded interactions for further structural and dynamical analysis. The corresponding script is provided below:

      Finally, after all the modules have been loaded, the simulation is started with a single command of ${\mathrm{app.run(5000000)}}.$

      The modular architecture of PyGAMD allows multiple physical modules to be flexibly combined and executed in parallel within a single script. Parameters are passed in real time to Numba-optimized GPU kernels for efficient parallel computation. Crucially, PyGAMD natively supports the direct definition of non-bonded interactions, aggregation reaction rules, and complex potential energy expressions. Compared with traditional molecular dynamics software that requires modifying keywords or recompiling code, it significantly lowers the threshold for algorithm development and force field expansion.

    • After obtaining a well-equilibrated CG system using PyGAMD, the subsequent step involves mapping the resulting mesoscopic configurations back to all-atom resolution. This ensures structural consistency and traceability across different modeling scales. The process is particularly critical for polymer systems, where the large number of degrees of freedom, complex chain conformations, and entanglement effects make it challenging to construct all-atom initial configurations that are close to equilibrium—a long-standing difficulty in molecular dynamics modeling. Conventional approaches often rely on commercial software such as Materials Studio 2020 to first build single-chain conformations via graphical user interface, or the ETKDG algorithm for coordinate construction, and then preliminarily optimized with low-precision force fields like UFF or MMFF. The resulting structures are then randomly packed into a low-density simulation box using tools such as Packmol. However, this methodology suffers from two major limitations: first, the conformation optimized for an isolated chain does not guarantee global equilibrium in a multi-chain system; second, random placement via PACKMOL is hard to capture the complex conformations such chain−chain packing or entanglement in polymer system. As a result, configurations generated in this manner typically exhibit low initial density and overly idealized chain packing, requiring extensive equilibration to approach a physically meaningful state.

      In the PyGAMD-ChemFAST workflow, we have implemented a SMILES/SMARTS-driven coarse-graining/fine-graining (S-CGFG) pipeline. The core concept involves first obtaining a near-equilibrium system conformation using a CG model at shorter time scales, followed by the use of this conformation as a structural template for rapid all-atom reconstruction via fine-grained mapping. ChemFAST provides a general pre-equilibration strategy for initial CG conformations. In our program, the distance from the center of mass to the farthest atom in the monomer is calculated to determine the non-bonded interaction radius σ. The solubility parameter prediction model from an in-house trained machine learning model is then employed to determine the non-bonded interaction strength ε. Subsequent parameters, such as bond lengths and bond angles between monomers, are derived. CG conformations are first constructed via a depth-first algorithm, followed by structural relaxation using the molecular dynamics simulation engine of PyGAMD. Then, the method combines SMILES/SMARTS descriptions with fragment assembly to automatically generate polymer molecules consistent with the given CG conformation. Based on the provided CG conformation and all-atom fragment information, the program first places the corresponding molecular fragments at the center-of-mass positions of each CG bead. It then performs intramolecular orientation optimization to minimize local overlap and bond-angle distortions, yielding an initial simulation box with sufficient interchain randomness and conformational relaxation. Compared to the conventional ETKDG+PACKMOL construction process, this CG-FG scheme demonstrates exceptional performance in both efficiency and structural rationality.

      To evaluate performance, we compared the configuration generation process using the S-CGFG pipeline in ChemFAST against the conventional ETKDG+PACKMOL method. Polyimide chains of varying lengths (degrees of polymerization: 10, 20, 30, 40, 50, 100, and 200) were selected as test systems. We recorded the total elapsed time for both methods. Given that the computational cost of the ETKDG algorithm becomes prohibitively high for chains exceeding 100 monomers, the conventional method was restricted to shorter chain lengths. All benchmarks were run three times on a workstation equipped with an Intel (R) Xeon(R) Silver 4310 CPU (2.10 GHz) and an NVIDIA GeForce RTX 4080 GPU. The results are shown in FIG. 4 (b) and (c), our tests on the polyimide system reveal that ChemFAST’s method significantly accelerates the generation of initial configurations with densities closer to the equilibrium value and more randomized chain orientations.

      Meanwhile, the construction of all-atom force fields for complex systems is often hindered by conventional tools [22, 23], which coan lead to incomplete force field coverage or inaccurate parameters. Although highly accurate quantum-mechanical calculations can be used to derive force field parameters, they suffer from efficiency bottlenecks. To address these challenges, we employed BOSS to compute nearly 160,000 OPLS-AA force field parameters for a wide variety of polymer oligomers. These parameters were used to train a machine learning model, enabling accurate and efficient prediction of force field parameters for large molecules.

    • In the third stage of the workflow, PyGAMD provides powerful analysis capabilities through the ${\mathrm{dataTackle}} $ post-processing tool. This module can be invoked directly via the Python interface (‘from poetry import ${\mathrm{dataTackle}} $’) or executed directly as a standalone command-line utility (‘./${\mathrm{dataTackle}} $’), supporting the processing of both single and multiple trajectory files in MST/XML/DCD formats (e.g., ‘${\mathrm{./dataTackle *.xml}} $’). Its innovative interactive interface offers unique advantages—upon execution, it automatically displays a menu of 44 analysis functions, allowing users to freely combine multiple analysis tasks by entering digital codes (e.g., ‘${\mathrm{4:npot=1000}} $’) and configuring parameters using the ‘|’ delimiter.

      The core functions of ${\mathrm{dataTackle}} $ are organized into four categories:

      (i) Structural analysis: provides basic characterizations including RDF, Rg2, stress tensor, etc.;

      (ii) Dynamics analysis: covers MSD, ISF, OACF, and other metrics for monitoring dynamic processes;

      (iii) Microstructure analysis: implements VORONOI tessellation, Q4, Q6 order parameters, crystallinity analysis, and related methods for advanced feature extraction;

      (iv) Special algorithm integration: incorporates specialized techniques such as dynamic structure factor, cage effect analysis, and 3D bond-orientational order parameters.

      The tool supports independent analysis of trajectory files, while processing DCD trajectories requires an accompanying topology file to define particle properties (e.g., ‘${\mathrm{dataTackle particle.xml trajectory.dcd}} $’). Its batch processing can be automated via shell scripts (e.g., ‘${\mathrm{echo -e '18:gpu=1|rmax=3.0' | dataTackle }} {\mathrm{particles.*.mst}} $’), with user-configurable parameter settings (e.g., ‘${\mathrm{14:h}} $’ to view detailed instructions for function 14). The output module employs optimized parallel algorithms and supports GPU acceleration (via the ‘${\mathrm{gpu=1}} $’ parameter), substantially enhancing analysis efficiency for large-scale systems.

    III.   Testing for typical polymer systems
    • To verify the reliability and efficiency of the multi-scale modeling method, we selected four typical polymer systems for testing. By comparing with single-scale simulations in Materials Studio 2020 software, we focused on examining key indicators such as structural characteristics, thermodynamic properties, and computational efficiency. The simulation results were visualized using VMD (1.9.3) [24] and Ovito (3.0.0) [25].

    • To address the key challenges in multi-scale modeling of typical cross-linked systems (particularly thermosetting polymers), we selected the DGEBA/DDS epoxy resin system as a research subject for systematic validation. Using the CG modeling tool ${\mathrm{Molgen}} $ from PyGAMD, we constructed the initial configuration. The model comprised DGEBA and DDS CG segments at a specified molar ratio (2:1) (as shown in FIG. 5(a, b)), with a total atom count reaching 86,360. The system was generated through random placement and uniform mixing under periodic boundary conditions. During simulation, the Martini CG force field and polymerization model were employed, and a 7 ns equilibrium molecular dynamics simulation was conducted in the NPT ensemble at 298 K and 1 bar. The results indicated a final cross-linking degree of 97.83%. After reverting the CG EP structure to the all-atom resolution using our in-house tool ChemFAST, the computed elastic modulus of the system was 15.74 GPa (as shown in FIG. 5(c, d)), which aligns in order of magnitude with experimental values reported in the literature [26], thereby confirming the accuracy of this multi-scale workflow. In comparison, traditional single-scale all-atom simulations performed using Materials Studio 2020 software for a system of the same scale require a 30 ns simulation time and up to 120 h of computation. In contrast, our method achieves comparable accuracy in only 20 h, significantly enhancing computational efficiency without compromising computational accuracy. This innovative and highly efficient simulation strategy has been demonstrated to provide a reliable technical means for the multi-scale research of complex cross-linked systems.

    • Taking polyvinyl alcohol (PVA) as an example, the structural characteristics of PVA were investigated using CG molecular dynamics simulation. The CG model was constructed with the ${\mathrm{Molgen}} $ tool, in which PVA chains were randomly arranged within a simulation box that was periodic only in the z-direction. The system comprised 700,800 atoms (as shown in FIG. 6). It is noteworthy that the PyGAMD-ChemFAST multi-scale modeling process required only 14 h, whereas all-atom modeling of the same system at single-scale in Materials Studio 2020 took up to 700 h, representing an improvement in computational efficiency of approximately 50 times. Based on the obtained PVA CG structure, a 1000 ns NPT molecular dynamics simulation was performed in the PyGAMD simulator using a CG force field consistent with Ref.[27]. The pressure was maintained at 1 bar, and the temperature was gradually decreased from 540 K to 297 K. Simulation results revealed that the system spontaneously formed a well-defined crystalline structure, consistent with literature reports. The ${\mathrm{dataTackle}} $ determined the final crystallinity rate to be 62.2%, which closely matches the experimental value [25].

    • For block copolymer systems, a thorough understanding of their complex microstructure formation mechanism is essential for precise control over morphological structure and size distribution. Accordingly, we selected poly (styrene-b-isoprene) (PS-b-PI) diblock copolymer as our research subject, and employed CG molecular dynamics simulation to investigate its structural evolution. Based on the approach by Li et al. [28], we developed a CG force field by mapping each monomer to a single bead and fitting the model to interfacial tension values from both all-atom simulations and experiments. Results demonstrate that the block copolymer successfully captures the typical dynamic formation process of a layered microstructure during the 100 ns equilibrium simulation (FIG. 7). More importantly, after fine-graining via ChemFAST, the resulting structures showed high consistency with experimentally observed phase-separation morphological features [29]. To highlight the advantages of the PyGAMD-ChemFAST workflow, we compared it with traditional single-scale all-atom simulation: using Materials Studio 2020 software, observing similar layering phenomena required simulations of up to 200 ns, with computational times reaching approximately 50 h. In contrast, the multi-scale simulation workflow proposed herein not only reduced the main simulation time by 50% while delivering reliable structural evolution data, but also cut the total computation time to under 30 h, achieving a 1.7 times improvement in computational efficiency with same computational resources. This marked improvement underscores the superiority of the proposed workflow in terms of both computational efficiency and accuracy of structural evolution.

    • To further investigate the molecular dynamic properties of the amorphous system in PEO, this study focused on its performance in predicting the glass transition temperature. Using the ${\mathrm{Molgen}} $ program, we constructed a coarse-grained model equivalent to a system of 19,656 atoms. Based on experimental data from Ref.[30], a high-accuracy CG force field was developed through a rigorous IBI procedure. Although the force field construction process required 15 h of computational resources, it remained considerably more economical compared to traditional all-atom simulation approaches. After achieving system equilibrium via 1 ns of CG molecular dynamics simulation, we applied the ChemFAST’s high-precision mapping algorithm for fine-graining following a standardized workflow. The resulting all-atom model required only short-range relaxation to yield a thermodynamically stable amorphous structure (FIG. 8). The computed glass transition temperature Tg was 232.56 K, which is close to the experimental value of 203 K [30], thus validating the reliability of the method. In comparison, conventional single-scale all-atom molecular dynamics simulations not only demand 30 h for basic model preparation, but also require a 30 ns initial equilibrium simulation to obtain Tg values matching experimental results, highlighting the inferior computational cost and time efficiency of the traditional approach. These outcomes strongly support the effectiveness of the multi-scale simulation workflow developed in this work, which integrates CG modeling, precise force field optimization, and efficient reverse mapping algorithms to construct a complete and reliable research process. Moreover, this method not only achieves a significant order-of-magnitude improvement in computational efficiency, but has also been systematically compared and verified, confirming its computational accuracy in predicting physical parameters that are consistent with experimental data. This provides a new research paradigm for computer-aided design and performance prediction of polymer materials.

    • Compared with traditional all-atom single-scale molecular dynamics simulations under identical hardware conditions, the PyGAMD-ChemFAST workflow reduces the computation time to as low as one-seventh of that required by the conventional all-atom method (FIG. 9), while maintaining comparable or even superior accuracy. We conducted three repeated simulations of the efficient and flexible PyGAMD-ChemFAST workflow to confirm its stability (cyan error bars are shown in FIG. 9). Each data point represents the average computing time of the corresponding 3 independent runs. A single test was performed for the computationally expensive Materials Studio workflow. All benchmark tests were conducted on a workstation equipped with an Intel Xeon Silver 4310 CPU (2.10 GHz) and a NVIDIA GeForce RTX 4080 SUPER. Moreover, this acceleration becomes more pronounced as the system size increases (from approximately 0.2×105 to 7×105 atoms). The improved efficiency originates from the introduction of the ChemFAST’s CG pre-equilibrium stage, which markedly lowers the computational cost associated with phase space exploration. The key point here is that the prediction accuracy of important physical properties such as density and Rg has not been affected. The multi-scale strategy proposed in this work not only maintains the structural reliability but also effectively resolves the time-consuming bottleneck problem in the simulation of polymer systems. This breakthrough provides an innovative technical path for high-precision simulation of large-scale polymer systems and achieves a reliable level capable of supporting practical applications.

    IV.   CHALLENGES AND PROSPECTS
    • Although multi-scale molecular dynamics methods have shown considerable advantages in polymer modeling, key challenges remain in cross-scale coupling and dynamic consistency. First, for systems exhibiting strong scale-coupling effects, including semi-crystalline polymers and block copolymers, existing parameterization strategies struggle to accurately capture dynamic multi-scale interactions. Using a typical test system as an example, phenomena such as chain-segment relaxation at crystalline/amorphous interfaces and the dynamic response of cross-linked networks under strain loading remain highly sensitive to parameter settings in transition regions, which limits the model’s predictive capability in complex scenarios. Moreover, traditional CG force fields suffer from limited transferability. When the chemical environment or physical state of the system changes, such as through variations in cross-linking density or a transition from the melt to the solution state, time-consuming manual parameter re-optimization is often necessary, which significantly increases the modeling cost.

      Future development should prioritize two key directions: intelligent force field development and computational framework optimization. For force fields, a more comprehensive multi-scale parameter transfer theory must be established, integrated with deep learning potentials capable of generating adaptive force field parameters to achieve a seamless connection from quantum chemical to mesoscopic scales. For instance, by incorporating neural network frameworks such as MACE and ANI, an intelligent potential function library tailored for long-chain polymer systems can be developed. On the computational framework side, the adaptability of simulation software such as PyGAMD on heterogeneous computing platforms needs enhancement, alongside the development of optimized algorithms leveraging FP16/INT8 mixed-precision computing. Additionally, for ultra-large-scale systems, improvements in MPI-CUDA collaborative parallel strategies are essential. It is important to emphasize that these technological innovations should remain centered on the unique cross-scale correlations inherent to polymers, with particular emphasis on strengthening the theoretical delineation of the “chemical structure-chain conformation-mesoscopic assembly” pathway. The ultimate goal is to establish a new generation multi-scale modeling paradigm that combines computational efficiency with physical accuracy.

    Figure (9)  Reference (30)

Catalog

    /

    DownLoad:  Full-Size Img  PowerPoint
    Return
    Return