From d3d004cfefd18b309f8deccfff4fd43ee59929f4 Mon Sep 17 00:00:00 2001 From: marjanalbouye Date: Mon, 31 Jul 2023 15:23:26 -0600 Subject: [PATCH 01/54] Add Joss paper templates. --- paper/paper.bib | 0 paper/paper.md | 25 +++++++++++++++++++++++++ 2 files changed, 25 insertions(+) create mode 100644 paper/paper.bib create mode 100644 paper/paper.md diff --git a/paper/paper.bib b/paper/paper.bib new file mode 100644 index 00000000..e69de29b diff --git a/paper/paper.md b/paper/paper.md new file mode 100644 index 00000000..ab9e9c6a --- /dev/null +++ b/paper/paper.md @@ -0,0 +1,25 @@ +--- +title: +tags: + - Python + - Molecular Dynamics + - Materials Science + +authors: + - name: - + affiliation: 1 +affiliations: + - name: - + index: 1 +date: +bibliography: paper.bib +--- + +# Summary + +# Statement of need + +# Acknowledgements + + +# References \ No newline at end of file From afa7ab28f8b030fed1c3cda4d43339380e67e5fe Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Fri, 25 Aug 2023 10:15:53 -0600 Subject: [PATCH 02/54] Pulling in first draft --- paper/paper.bib | 125 ++++++++++++++++++++++++++++++++++++++++++++++++ paper/paper.md | 97 +++++++++++++++++++++++++++++++++---- 2 files changed, 214 insertions(+), 8 deletions(-) diff --git a/paper/paper.bib b/paper/paper.bib index e69de29b..50363240 100644 --- a/paper/paper.bib +++ b/paper/paper.bib @@ -0,0 +1,125 @@ + +@article{fritz_coarse-grained_2009, + title = {Coarse-grained polymer melts based on isolated atomistic chains: {Simulation} of polystyrene of different tacticities}, + volume = {42}, + issn = {00249297}, + doi = {10.1021/ma901242h}, + abstract = {We present a molecular coarse-graining approach applied to polystyrene which obtains both the bonded and nonbonded interactions of the coarse-grained model from the sampling of isolated atomistic chains and pairs of oligomers. Atomistic melt properties are not used in the parametrization. We show that the coarse-grained polystyrene model not only predicts melt properties, including the melt packing and the density between 400 and 520 K, in satisfactory agreement with the atomistic model, but also reproduces the local chain conformations of atactic as well as stereoregular polystyrene. The model takes into account and reproduces correlations between neighboring bonded degrees of freedom and therefore reproduces the conformations of detailed atomistic chains in the melt on all length scales. © 2009 American Chemical Society.}, + number = {19}, + journal = {Macromolecules}, + author = {Fritz, Dominik and Harmandaris, Vagelis A. and Kremer, Kurt and Vegt, Nico F. A. Van Der}, + year = {2009}, + pages = {7579--7588}, + file = {Fritz et al. - 2009 - Coarse-grained polymer melts based on isolated ato.pdf:C\:\\Users\\Rainier\\Zotero\\storage\\J22BGUI5\\Fritz et al. - 2009 - Coarse-grained polymer melts based on isolated ato.pdf:application/pdf}, +} + +@article{hsu_systematic_2014, + title = {Systematic method for thermomechanically consistent coarse-graining: {A} universal model for methacrylate-based polymers}, + volume = {10}, + issn = {15499626}, + doi = {10.1021/ct500080h}, + abstract = {We present a versatile systematic two-bead-per-monomer coarse-grain modeling strategy for simulating the thermomechanical behavior of methacrylate polymers at length and time scales far exceeding atomistic simulations. We establish generic bonded interaction parameters via Boltzmann inversion of probability distributions obtained from the common coarse-grain bead center locations of five different methacrylate polymers. Distinguishing features of each monomer side-chain group are captured using Lennard-Jones nonbonded potentials with parameters specified to match the density and glass-transition temperature values obtained from all-atomistic simulations. The developed force field is validated using Flory-Fox scaling relationships, self-diffusion coefficients of monomers, and modulus of elasticity for p(MMA). Our approach establishes a transferable, efficient, and accurate scale-bridging strategy for investigating the thermomechanics of copolymers, polymer blends, and nanocomposites. © 2014 American Chemical Society.}, + number = {6}, + journal = {Journal of Chemical Theory and Computation}, + author = {Hsu, David D. and Xia, Wenjie and Arturo, Steven G. and Keten, Sinan}, + year = {2014}, + pages = {2514--2527}, +} + +@article{moore_derivation_2014, + title = {Derivation of coarse-grained potentials via multistate iterative {Boltzmann} inversion}, + volume = {140}, + issn = {0021-9606}, + url = {http://aip.scitation.org/doi/10.1063/1.4880555 http://www.ncbi.nlm.nih.gov/pubmed/24929371}, + doi = {10.1063/1.4880555}, + abstract = {In this work, an extension is proposed to the standard iterative Boltzmann inversion (IBI) method used to derive coarse-grained potentials. It is shown that the inclusion of target data from multiple states yields a less state-dependent potential, and is thus better suited to simulate systems over a range of thermodynamic states than the standard IBI method. The inclusion of target data from multiple states forces the algorithm to sample regions of potential phase space that match the radial distribution function at multiple state points, thus producing a derived potential that is more representative of the underlying interactions. It is shown that the algorithm is able to converge to the true potential for a system where the underlying potential is known. It is also shown that potentials derived via the proposed method better predict the behavior of n-alkane chains than those derived via the standard IBI method. Additionally, through the examination of alkane monolayers, it is shown that the relative weight given to each state in the fitting procedure can impact bulk system properties, allowing the potentials to be further tuned in order to match the properties of reference atomistic and/or experimental systems.}, + number = {22}, + journal = {The Journal of Chemical Physics}, + author = {Moore, Timothy C. and Iacovella, Christopher R. and McCabe, Clare}, + month = jun, + year = {2014}, + pmid = {24929371}, + note = {ISBN: 9789811011269 +Publisher: American Institute of Physics}, + keywords = {coarse-graining, dni, nice, nrel, nsf\_msn, opv}, + pages = {224104}, +} + +@article{moore_development_2015, + title = {Development of a coarse-grained water forcefield via multistate iterative {Boltzmann} inversion}, + volume = {1509.07887}, + url = {http://arxiv.org/abs/1509.07887}, + abstract = {A coarse-grained water model is developed using multistate iterative Boltzmann inversion. Following previous work, the k-means algorithm is used to dynamically map multiple water molecules to a single coarse-grained bead, allowing the use of structure-based coarse-graining methods. The model is derived to match the bulk and interfacial properties of liquid water and improves upon previous work that used single state iterative Boltzmann inversion. The model accurately reproduces the density and structural correlations of water at 305 K and 1.0 atm, stability of a liquid droplet at 305 K, and shows little tendency to crystallize at physiological conditions. This work also illustrates several advantages of using multistate iterative Boltzmann inversion for deriving generally applicable coarse-grained forcefields.}, + journal = {arXiv}, + author = {Moore, Timothy C. and Iacovella, Christopher R. and McCabe, Clare}, + month = sep, + year = {2015}, + keywords = {and clare mccabe, christopher r, elopment of a coarse-grained, iacovella, moore, multistate iterative boltzmann inversion, timothy c, water forcefield via}, +} + +@article{moore_coarse-grained_2016, + title = {A {Coarse}-{Grained} {Model} of {Stratum} {Corneum} {Lipids}: {Free} {Fatty} {Acids} and {Ceramide} {NS}}, + volume = {120}, + issn = {15205207}, + doi = {10.1021/acs.jpcb.6b08046}, + abstract = {Ceramide (CER)-based biological membranes are used both experimentally and in simulations as simplified model systems of the skin barrier. Molecular dynamics studies have generally focused on simulating preassembled structures using atomistically detailed models of CERs, which limit the system sizes and time scales that can practically be probed, rendering them ineffective for studying particular phenomena, including self-assembly into bilayer and lamellar superstructures. Here, we report on the development of a coarse-grained (CG) model for CER NS, the most abundant CER in human stratum corneum. Multistate iterative Boltzmann inversion is used to derive the intermolecular pair potentials, resulting in a force field that is applicable over a range of state points and suitable for studying ceramide self-assembly. The chosen CG mapping, which includes explicit interaction sites for hydroxyl groups, captures the directional nature of hydrogen bonding and allows for accurate predictions of several key structural properties of CER NS bilayers. Simulated wetting experiments allow the hydrophobicity of CG beads to be accurately tuned to match atomistic wetting behavior, which affects the whole system, since inaccurate hydrophobic character is found to unphysically alter the lipid packing in hydrated lamellar states. We find that CER NS can self-assemble into multilamellar structures, enabling the study of lipid systems more representative of the multilamellar lipid structures present in the skin barrier. The coarse-grained force field derived herein represents an important step in using molecular dynamics to study the human skin barrier, which gives a resolution not available through experiment alone.}, + number = {37}, + journal = {Journal of Physical Chemistry B}, + author = {Moore, Timothy C. and Iacovella, Christopher R. and Hartkamp, Remco and Bunge, Annette L. and McCabe, Clare}, + year = {2016}, + pmid = {27564869}, + pages = {9944--9958}, +} + +@article{moore_molecular_2018, + title = {Molecular dynamics simulations of stratum corneum lipid mixtures: {A} multiscale perspective}, + volume = {498}, + issn = {10902104}, + url = {https://doi.org/10.1016/j.bbrc.2017.09.040}, + doi = {10.1016/j.bbrc.2017.09.040}, + abstract = {The lipid matrix of the stratum corneum (SC) layer of skin is essential for human survival; it acts as a barrier to prevent rapid dehydration while keeping potentially hazardous material outside the body. While the composition of the SC lipid matrix is known, the molecular-level details of its organization are difficult to infer experimentally, hindering the discovery of structure-property relationships. To this end, molecular dynamics simulations, which give molecular-level resolution, have begun to play an increasingly important role in understanding these relationships. However, most simulation studies of SC lipids have focused on preassembled bilayer configurations, which, owing to the slow dynamics of the lipids, may influence the final structure and hence the calculated properties. Self-assembled structures would avoid this dependence on the initial configuration, however, the size and length scales involved make self-assembly impractical to study with atomistic models. Here, we report on the development of coarse-grained models of SC lipids designed to study self-assembly. Building on previous work, we present the interactions between the headgroups of ceramide and free fatty acid developed using the multistate iterative Boltzmann inversion method. Validation of the new interactions is performed with simulations of preassembled bilayers and good agreement between the atomistic and coarse-grained models is found for structural properties. The self-assembly of mixtures of ceramide and free fatty acid is investigated and both bilayer and multilayer structures are found to form. This work therefore represents a necessary step in studying SC lipid systems on multiple time and length scales.}, + number = {2}, + journal = {Biochemical and Biophysical Research Communications}, + author = {Moore, Timothy C. and Iacovella, Christopher R. and Leonhard, Anne C. and Bunge, Annette L. and McCabe, C.}, + year = {2018}, + pmid = {28911866}, + note = {Publisher: Elsevier Ltd}, + keywords = {Ceramide, Coarse-grained, Multistate iterative Boltzmann inversion, Self-assembly, Skin}, + pages = {313--318}, +} + +@article{JankowskiTRUE2020, +title = {Perspective on coarse-graining, cognitive load, and materials simulation}, +journal = {Computational Materials Science}, +volume = {171}, +pages = {109129}, +year = {2020}, +issn = {0927-0256}, +doi = {https://doi.org/10.1016/j.commatsci.2019.109129}, +url = {https://www.sciencedirect.com/science/article/pii/S0927025619304203}, +author = {Eric Jankowski and Neale Ellyson and Jenny W. Fothergill and Michael M. Henry and Mitchell H. Leibowitz and Evan D. Miller and Mone’t Alberts and Samantha Chesser and Jaime D. Guevara and Chris D. Jones and Mia Klopfenstein and Kendra K. Noneman and Rachel Singleton and Ramon A. Uriarte-Mendoza and Stephen Thomas and Carla E. Estridge and Matthew L. Jones}, +keywords = {Coarse-grained models, Cognitive load, Molecular dynamics, Organic photovoltaics, Epoxy, Thermosets, Teaching, Software, Thermodynamics}, +abstract = {The predictive capabilities of computational materials science today derive from overlapping advances in simulation tools, modeling techniques, and best practices. We outline this ecosystem of molecular simulations by explaining how important contributions in each of these areas have fed into each other. The combined output of these tools, techniques, and practices is the ability for researchers to advance understanding by efficiently combining simple models with powerful software. As specific examples, we show how the prediction of organic photovoltaic morphologies have improved by orders of magnitude over the last decade, and how the processing of reacting epoxy thermosets can now be investigated with million-particle models. We discuss these two materials systems and the training of materials simulators through the lens of cognitive load theory. For students, the broad view of ecosystem components should facilitate understanding how the key parts relate to each other first, followed by targeted exploration. In this way, the paper is organized in loose analogy to a coarse-grained model: The main components provide basic framing and accelerated sampling from which deeper research is better contextualized. For mentors, this paper is organized to provide a snapshot in time of the current simulation ecosystem and an on-ramp for simulation experts into the literature on pedagogical practice.} +} + +@article{MooreMSIBI2014, +author = {Moore,Timothy C. and Iacovella,Christopher R. and McCabe,Clare }, +title = {Derivation of coarse-grained potentials via multistate iterative Boltzmann inversion}, +journal = {The Journal of Chemical Physics}, +volume = {140}, +number = {22}, +pages = {224104}, +year = {2014}, +doi = {10.1063/1.4880555}, + +URL = { + https://doi.org/10.1063/1.4880555 + +}, +eprint = { + https://doi.org/10.1063/1.4880555 + +} + +} + diff --git a/paper/paper.md b/paper/paper.md index ab9e9c6a..a683cade 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -1,25 +1,106 @@ --- -title: +title: 'Polybinder: A Python package for streamlined polymer molecular dynamics' tags: - Python - - Molecular Dynamics - - Materials Science - + - materials science + - molecular dynamics + - polymers + - HOOMD-blue authors: - - name: - + - name: Chris Jones + orcid: 0000-0002-6196-5274 + equal-contrib: true + affiliation: 1 + - name: Rainier Barrett + orcid: 0000-0002-5728-9074 + equal-contrib: true + affiliation: 1 + - name: Eric Jankowski + orcid: 0000-0002-3267-1410 + corresponding: true affiliation: 1 affiliations: - - name: - + - name: Boise State University, Boise, ID, USA index: 1 -date: +date: 01 January 2001 bibliography: paper.bib + --- +# Statement of need + +One of the steeper learning curves on the road to using molecular dynamics (MD) simulations +of polymer systems is +the initialization of particle positions, topology, and force field parameters. +Especially for researchers new to the computational community, generating particle +positions and initializing their velocities alone can be a daunting task, let alone +specifying bond topology. The concept of a force field file and how it interacts with +different MD engines is also non-trivial to understand. +Further, besides the difficulty in starting simulations, another part of the cognitive +load involved in learning to perform informative MD investigations is that it can be +difficult to keep track of many simulations, especially when scanning over a wide +range of thermodynamic state points, system chemistries, etc. +These wide scans can quickly create an unmanageable amount of data to analyze, +or even store, requiring further learning of data management skills on top of an already +cumbersome training process. +Moreover, even with a high-throughput workflow and good grasp of theory, it can still +prove difficult to produce TRUE (standing for "Transparent, Reproducible, Usable, and +Extensible") MD simulations with reliable, accurate results. `@JankowskiTRUE2020` + +In particular, when we want to probe complex variable spaces, +such as process control variables in a composite material manufacture process, +we need to run several large-volume, high-density, long-time simulations, +many of which may not reveal relevant information for process control. +This search process is further delayed due to the increasing CPU time required to +simulate such large systems. A common solution for this problem of scale in MD +is coarse grain (CG) modeling, where atomistic accuracy is traded for speed. +This likewise comes with some subtle barriers between concept and practice. +For instance, to produce a CG model of a given polymer that is transferable across +state points, many simulations at various state points must be run and managed, +increasing the desirability of a reliable and easy way to keep track of these, +particularly for the multi-state iterative Boltzmann inversion (MSIBI)`@MooreMSIBI2014` +method of parameterization. All these aspects complicate and prolong the algready time- +and labor-intensive process of training new computational researchers +to perform sufficiently many simulations to meaningfully investigate polymer systems. + +These factors indicate a need for a streamlined tool for creating (optionally CG) +MD polymer systems, launching one or many simulations across state points and/or +system type, and managing and analyzing the results. Ideally such a tool should be +approachable for novice programmers, to maximize time spent investigating research +questions and minimize the learning curve for new researchers, while preserving +the accuracy and rigor of the resultant research. + # Summary -# Statement of need +Polybinder, the suite of tools introduced here, was built to enable materials scientists +to use molecular simulation to quickly and reproducibly simulate +large, coarse- or fine-grained polymer systems to investigate and predict trends in +their properties, all with a much lower barrier to entry than starting from scratch. Because it is designed +with modularity in mind, it will also ease adoption by other research groups, +and quicken the investigation process of new materials systems. + +Polybinder is a Python package that uses the [foyer](https://github.com/mosdef-hub/foyer/), +[mbuild](https://github.com/mosdef-hub/mbuild/), and [signac](https://github.com/mosdef-hub/signac) packages from +the [MoSDeF suite of tools](https://github.com/mosdef-hub/) to quickly, easily, and reproducibly initialize and run polymer +simulations in the [HOOMD-blue](https://github.com/glotzerlab/hoomd-blue) engine. +Polybinder was made with the TRUE principles in mind `@JankowskiTRUE2020`, with the goal of allowing ease +of use and adoption, and reducing the learning curve for starting simulations. +This package allows for a variety of simulation types of interest, +such as bulk thermoplastic melts, annealing, welding interface interpenetration, and tensile testing of +the resultant welded systems. +Presently polybinder has methods for three common thermoplastic polymer chemistries: +polyether ether ketone (PEEK), polyether ketone ketone (PEKK), +and polyphenylene sulfide (PPS). However, polybinder is designed such that any +monomer units can be implemented and added to the internal library of available +structures via mbuild. + + +# Accessing the Software + +Polybinder is freely available under the GNU General Public License (version 3) on [github](https://github.com/cmelab/polybinder). # Acknowledgements +We acknowledge contributions from [ULI Advisory board, NASA, etc] # References \ No newline at end of file From e4aaee0cfd8d2ead83ab1505817608fcf525bee7 Mon Sep 17 00:00:00 2001 From: marjanalbouye Date: Thu, 5 Oct 2023 13:10:01 -0600 Subject: [PATCH 03/54] transfer citations --- paper/paper.bib | 397 +++++++++++++++++++++++++++++++++--------------- 1 file changed, 277 insertions(+), 120 deletions(-) diff --git a/paper/paper.bib b/paper/paper.bib index 50363240..497c1cf5 100644 --- a/paper/paper.bib +++ b/paper/paper.bib @@ -1,125 +1,282 @@ -@article{fritz_coarse-grained_2009, - title = {Coarse-grained polymer melts based on isolated atomistic chains: {Simulation} of polystyrene of different tacticities}, - volume = {42}, - issn = {00249297}, - doi = {10.1021/ma901242h}, - abstract = {We present a molecular coarse-graining approach applied to polystyrene which obtains both the bonded and nonbonded interactions of the coarse-grained model from the sampling of isolated atomistic chains and pairs of oligomers. Atomistic melt properties are not used in the parametrization. We show that the coarse-grained polystyrene model not only predicts melt properties, including the melt packing and the density between 400 and 520 K, in satisfactory agreement with the atomistic model, but also reproduces the local chain conformations of atactic as well as stereoregular polystyrene. The model takes into account and reproduces correlations between neighboring bonded degrees of freedom and therefore reproduces the conformations of detailed atomistic chains in the melt on all length scales. © 2009 American Chemical Society.}, - number = {19}, - journal = {Macromolecules}, - author = {Fritz, Dominik and Harmandaris, Vagelis A. and Kremer, Kurt and Vegt, Nico F. A. Van Der}, - year = {2009}, - pages = {7579--7588}, - file = {Fritz et al. - 2009 - Coarse-grained polymer melts based on isolated ato.pdf:C\:\\Users\\Rainier\\Zotero\\storage\\J22BGUI5\\Fritz et al. - 2009 - Coarse-grained polymer melts based on isolated ato.pdf:application/pdf}, -} - -@article{hsu_systematic_2014, - title = {Systematic method for thermomechanically consistent coarse-graining: {A} universal model for methacrylate-based polymers}, - volume = {10}, - issn = {15499626}, - doi = {10.1021/ct500080h}, - abstract = {We present a versatile systematic two-bead-per-monomer coarse-grain modeling strategy for simulating the thermomechanical behavior of methacrylate polymers at length and time scales far exceeding atomistic simulations. We establish generic bonded interaction parameters via Boltzmann inversion of probability distributions obtained from the common coarse-grain bead center locations of five different methacrylate polymers. Distinguishing features of each monomer side-chain group are captured using Lennard-Jones nonbonded potentials with parameters specified to match the density and glass-transition temperature values obtained from all-atomistic simulations. The developed force field is validated using Flory-Fox scaling relationships, self-diffusion coefficients of monomers, and modulus of elasticity for p(MMA). Our approach establishes a transferable, efficient, and accurate scale-bridging strategy for investigating the thermomechanics of copolymers, polymer blends, and nanocomposites. © 2014 American Chemical Society.}, - number = {6}, - journal = {Journal of Chemical Theory and Computation}, - author = {Hsu, David D. and Xia, Wenjie and Arturo, Steven G. and Keten, Sinan}, - year = {2014}, - pages = {2514--2527}, -} - -@article{moore_derivation_2014, - title = {Derivation of coarse-grained potentials via multistate iterative {Boltzmann} inversion}, - volume = {140}, - issn = {0021-9606}, - url = {http://aip.scitation.org/doi/10.1063/1.4880555 http://www.ncbi.nlm.nih.gov/pubmed/24929371}, - doi = {10.1063/1.4880555}, - abstract = {In this work, an extension is proposed to the standard iterative Boltzmann inversion (IBI) method used to derive coarse-grained potentials. It is shown that the inclusion of target data from multiple states yields a less state-dependent potential, and is thus better suited to simulate systems over a range of thermodynamic states than the standard IBI method. The inclusion of target data from multiple states forces the algorithm to sample regions of potential phase space that match the radial distribution function at multiple state points, thus producing a derived potential that is more representative of the underlying interactions. It is shown that the algorithm is able to converge to the true potential for a system where the underlying potential is known. It is also shown that potentials derived via the proposed method better predict the behavior of n-alkane chains than those derived via the standard IBI method. Additionally, through the examination of alkane monolayers, it is shown that the relative weight given to each state in the fitting procedure can impact bulk system properties, allowing the potentials to be further tuned in order to match the properties of reference atomistic and/or experimental systems.}, - number = {22}, - journal = {The Journal of Chemical Physics}, - author = {Moore, Timothy C. and Iacovella, Christopher R. and McCabe, Clare}, - month = jun, - year = {2014}, - pmid = {24929371}, - note = {ISBN: 9789811011269 -Publisher: American Institute of Physics}, - keywords = {coarse-graining, dni, nice, nrel, nsf\_msn, opv}, - pages = {224104}, -} - -@article{moore_development_2015, - title = {Development of a coarse-grained water forcefield via multistate iterative {Boltzmann} inversion}, - volume = {1509.07887}, - url = {http://arxiv.org/abs/1509.07887}, - abstract = {A coarse-grained water model is developed using multistate iterative Boltzmann inversion. Following previous work, the k-means algorithm is used to dynamically map multiple water molecules to a single coarse-grained bead, allowing the use of structure-based coarse-graining methods. The model is derived to match the bulk and interfacial properties of liquid water and improves upon previous work that used single state iterative Boltzmann inversion. The model accurately reproduces the density and structural correlations of water at 305 K and 1.0 atm, stability of a liquid droplet at 305 K, and shows little tendency to crystallize at physiological conditions. This work also illustrates several advantages of using multistate iterative Boltzmann inversion for deriving generally applicable coarse-grained forcefields.}, - journal = {arXiv}, - author = {Moore, Timothy C. and Iacovella, Christopher R. and McCabe, Clare}, - month = sep, - year = {2015}, - keywords = {and clare mccabe, christopher r, elopment of a coarse-grained, iacovella, moore, multistate iterative boltzmann inversion, timothy c, water forcefield via}, -} - -@article{moore_coarse-grained_2016, - title = {A {Coarse}-{Grained} {Model} of {Stratum} {Corneum} {Lipids}: {Free} {Fatty} {Acids} and {Ceramide} {NS}}, - volume = {120}, - issn = {15205207}, - doi = {10.1021/acs.jpcb.6b08046}, - abstract = {Ceramide (CER)-based biological membranes are used both experimentally and in simulations as simplified model systems of the skin barrier. Molecular dynamics studies have generally focused on simulating preassembled structures using atomistically detailed models of CERs, which limit the system sizes and time scales that can practically be probed, rendering them ineffective for studying particular phenomena, including self-assembly into bilayer and lamellar superstructures. Here, we report on the development of a coarse-grained (CG) model for CER NS, the most abundant CER in human stratum corneum. Multistate iterative Boltzmann inversion is used to derive the intermolecular pair potentials, resulting in a force field that is applicable over a range of state points and suitable for studying ceramide self-assembly. The chosen CG mapping, which includes explicit interaction sites for hydroxyl groups, captures the directional nature of hydrogen bonding and allows for accurate predictions of several key structural properties of CER NS bilayers. Simulated wetting experiments allow the hydrophobicity of CG beads to be accurately tuned to match atomistic wetting behavior, which affects the whole system, since inaccurate hydrophobic character is found to unphysically alter the lipid packing in hydrated lamellar states. We find that CER NS can self-assemble into multilamellar structures, enabling the study of lipid systems more representative of the multilamellar lipid structures present in the skin barrier. The coarse-grained force field derived herein represents an important step in using molecular dynamics to study the human skin barrier, which gives a resolution not available through experiment alone.}, - number = {37}, - journal = {Journal of Physical Chemistry B}, - author = {Moore, Timothy C. and Iacovella, Christopher R. and Hartkamp, Remco and Bunge, Annette L. and McCabe, Clare}, - year = {2016}, - pmid = {27564869}, - pages = {9944--9958}, -} - -@article{moore_molecular_2018, - title = {Molecular dynamics simulations of stratum corneum lipid mixtures: {A} multiscale perspective}, - volume = {498}, - issn = {10902104}, - url = {https://doi.org/10.1016/j.bbrc.2017.09.040}, - doi = {10.1016/j.bbrc.2017.09.040}, - abstract = {The lipid matrix of the stratum corneum (SC) layer of skin is essential for human survival; it acts as a barrier to prevent rapid dehydration while keeping potentially hazardous material outside the body. While the composition of the SC lipid matrix is known, the molecular-level details of its organization are difficult to infer experimentally, hindering the discovery of structure-property relationships. To this end, molecular dynamics simulations, which give molecular-level resolution, have begun to play an increasingly important role in understanding these relationships. However, most simulation studies of SC lipids have focused on preassembled bilayer configurations, which, owing to the slow dynamics of the lipids, may influence the final structure and hence the calculated properties. Self-assembled structures would avoid this dependence on the initial configuration, however, the size and length scales involved make self-assembly impractical to study with atomistic models. Here, we report on the development of coarse-grained models of SC lipids designed to study self-assembly. Building on previous work, we present the interactions between the headgroups of ceramide and free fatty acid developed using the multistate iterative Boltzmann inversion method. Validation of the new interactions is performed with simulations of preassembled bilayers and good agreement between the atomistic and coarse-grained models is found for structural properties. The self-assembly of mixtures of ceramide and free fatty acid is investigated and both bilayer and multilayer structures are found to form. This work therefore represents a necessary step in studying SC lipid systems on multiple time and length scales.}, - number = {2}, - journal = {Biochemical and Biophysical Research Communications}, - author = {Moore, Timothy C. and Iacovella, Christopher R. and Leonhard, Anne C. and Bunge, Annette L. and McCabe, C.}, - year = {2018}, - pmid = {28911866}, - note = {Publisher: Elsevier Ltd}, - keywords = {Ceramide, Coarse-grained, Multistate iterative Boltzmann inversion, Self-assembly, Skin}, - pages = {313--318}, -} - -@article{JankowskiTRUE2020, -title = {Perspective on coarse-graining, cognitive load, and materials simulation}, -journal = {Computational Materials Science}, -volume = {171}, -pages = {109129}, -year = {2020}, -issn = {0927-0256}, -doi = {https://doi.org/10.1016/j.commatsci.2019.109129}, -url = {https://www.sciencedirect.com/science/article/pii/S0927025619304203}, -author = {Eric Jankowski and Neale Ellyson and Jenny W. Fothergill and Michael M. Henry and Mitchell H. Leibowitz and Evan D. Miller and Mone’t Alberts and Samantha Chesser and Jaime D. Guevara and Chris D. Jones and Mia Klopfenstein and Kendra K. Noneman and Rachel Singleton and Ramon A. Uriarte-Mendoza and Stephen Thomas and Carla E. Estridge and Matthew L. Jones}, -keywords = {Coarse-grained models, Cognitive load, Molecular dynamics, Organic photovoltaics, Epoxy, Thermosets, Teaching, Software, Thermodynamics}, -abstract = {The predictive capabilities of computational materials science today derive from overlapping advances in simulation tools, modeling techniques, and best practices. We outline this ecosystem of molecular simulations by explaining how important contributions in each of these areas have fed into each other. The combined output of these tools, techniques, and practices is the ability for researchers to advance understanding by efficiently combining simple models with powerful software. As specific examples, we show how the prediction of organic photovoltaic morphologies have improved by orders of magnitude over the last decade, and how the processing of reacting epoxy thermosets can now be investigated with million-particle models. We discuss these two materials systems and the training of materials simulators through the lens of cognitive load theory. For students, the broad view of ecosystem components should facilitate understanding how the key parts relate to each other first, followed by targeted exploration. In this way, the paper is organized in loose analogy to a coarse-grained model: The main components provide basic framing and accelerated sampling from which deeper research is better contextualized. For mentors, this paper is organized to provide a snapshot in time of the current simulation ecosystem and an on-ramp for simulation experts into the literature on pedagogical practice.} -} - -@article{MooreMSIBI2014, -author = {Moore,Timothy C. and Iacovella,Christopher R. and McCabe,Clare }, -title = {Derivation of coarse-grained potentials via multistate iterative Boltzmann inversion}, -journal = {The Journal of Chemical Physics}, -volume = {140}, -number = {22}, -pages = {224104}, -year = {2014}, -doi = {10.1063/1.4880555}, - -URL = { - https://doi.org/10.1063/1.4880555 - -}, -eprint = { - https://doi.org/10.1063/1.4880555 - +@article{hayashi_radonpy_2022, + title = {{RadonPy}: automated physical property calculation using all-atom classical molecular dynamics simulations for polymer informatics}, + volume = {8}, + issn = {2057-3960}, + url = {https://www.nature.com/articles/s41524-022-00906-4}, + doi = {10.1038/s41524-022-00906-4}, + shorttitle = {{RadonPy}}, + abstract = {Abstract + + The spread of data-driven materials research has increased the need for systematically designed materials property databases. However, the development of polymer databases has lagged far behind other material systems. We present {RadonPy}, an open-source library that can automate the complete process of all-atom classical molecular dynamics ({MD}) simulations applicable to a wide variety of polymeric materials. Herein, 15 different properties were calculated for more than 1000 amorphous polymers. The {MD}-calculated properties were systematically compared with experimental data to validate the calculation conditions; the bias and variance in the {MD}-calculated properties were successfully calibrated by a machine learning technique. During the high-throughput data production, we identified eight amorphous polymers with extremely high thermal conductivity ({\textgreater}0.4 W ∙ m + –1 +  ∙ K + –1 + ) and their underlying mechanisms. Similar to the advancement of materials informatics since the advent of computational property databases for inorganic crystals, database construction using {RadonPy} will promote the development of polymer informatics.}, + pages = {222}, + number = {1}, + journaltitle = {npj Computational Materials}, + shortjournal = {npj Comput Mater}, + author = {Hayashi, Yoshihiro and Shiomi, Junichiro and Morikawa, Junko and Yoshida, Ryo}, + urldate = {2023-09-26}, + date = {2022-11-08}, + langid = {english}, + file = {Hayashi et al. - 2022 - RadonPy automated physical property calculation u.pdf:/home/marjan/Zotero/storage/CV4ZA7SU/Hayashi et al. - 2022 - RadonPy automated physical property calculation u.pdf:application/pdf}, +} + +@article{thompson_towards_2020, + title = {Towards molecular simulations that are transparent, reproducible, usable by others, and extensible ({TRUE})}, + volume = {118}, + issn = {0026-8976, 1362-3028}, + url = {https://www.tandfonline.com/doi/full/10.1080/00268976.2020.1742938}, + doi = {10.1080/00268976.2020.1742938}, + abstract = {Systems composed of soft matter (e.g., liquids, polymers, foams, gels, colloids, and most biological materials) are ubiquitous in science and engineering, but molecular simulations of such systems pose particular computational challenges, requiring time and/or ensemble-averaged data to be collected over long simulation trajectories for property evaluation. Performing a molecular simulation of a soft matter system involves multiple steps, which have traditionally been performed by researchers in a “bespoke” fashion, resulting in many published soft matter simulations not being reproducible based on the information provided in the publications. To address the issue of reproducibility and to provide tools for computational screening, we have been developing the open-source Molecular Simulation and Design Framework ({MoSDeF}) software suite.}, + pages = {e1742938}, + number = {9}, + journaltitle = {Molecular Physics}, + shortjournal = {Molecular Physics}, + author = {Thompson, Matthew W. and Gilmer, Justin B. and Matsumoto, Ray A. and Quach, Co D. and Shamaprasad, Parashara and Yang, Alexander H. and Iacovella, Christopher R. and {McCabe}, Clare and Cummings, Peter T.}, + urldate = {2023-09-27}, + date = {2020-06-01}, + langid = {english}, + file = {Thompson et al. - 2020 - Towards molecular simulations that are transparent.pdf:/home/marjan/Zotero/storage/2R32UBC3/Thompson et al. - 2020 - Towards molecular simulations that are transparent.pdf:application/pdf}, +} + +@article{hedges_biosimspace_2019, + title = {{BioSimSpace}: An interoperable Python framework for biomolecular simulation}, + volume = {4}, + issn = {2475-9066}, + url = {https://joss.theoj.org/papers/10.21105/joss.01831}, + doi = {10.21105/joss.01831}, + shorttitle = {{BioSimSpace}}, + abstract = {Biomolecular simulation is a diverse and growing area of research, making important contributions to structural biology and pharmaceutical research (Huggins et al., 2019). Within the community there are a several significant and widely used software packages that have evolved from within various research groups over the past 20 or more years. For example, the molecular dynamics packages {AMBER} (Case et al., 2005), {GROMACS} (Abraham et al., 2015), and {NAMD} (Phillips et al., 2005), which are all capable of running biomolecular simulations for systems consisting of hundreds of thousands of atoms and can be run on hardware ranging from laptops, to graphics processing units ({GPUs}), to the latest high-performance computing clusters. Since different software packages were developed independently, interoperability between them is poor. In large part this is the result of major differences in the supported file formats, which makes it difficult to translate the inputs and outputs of one program to another. As a consequence, expertise in one package doesn’t immediately apply to another, making it hard to share methodology and knowledge between different research communities, as evidenced, for instance, by a recent study on reproducibility of relative hydration free energies across simulation packages (Loeffler et al., 2018). The issue is compounded by the increasing use of biomolecular simulations as components of larger scientific workflows for bioengineering or computer-aided drug design purposes. A lack of interoperability leads to brittle workflows, poor reproducibility, and lock in to specific software that hinders dissemination of biomolecular simulation methodologies to other communities.}, + pages = {1831}, + number = {43}, + journaltitle = {Journal of Open Source Software}, + shortjournal = {{JOSS}}, + author = {Hedges, Lester and Mey, Antonia and Laughton, Charles and Gervasio, Francesco and Mulholland, Adrian and Woods, Christopher and Michel, Julien}, + urldate = {2023-09-27}, + date = {2019-11-22}, + langid = {english}, + file = {Hedges et al. - 2019 - BioSimSpace An interoperable Python framework for.pdf:/home/marjan/Zotero/storage/V89VIW2E/Hedges et al. - 2019 - BioSimSpace An interoperable Python framework for.pdf:application/pdf}, +} + +@article{shirts_statistically_2008, + title = {Statistically optimal analysis of samples from multiple equilibrium states}, + volume = {129}, + issn = {0021-9606, 1089-7690}, + url = {https://pubs.aip.org/jcp/article/129/12/124105/957527/Statistically-optimal-analysis-of-samples-from}, + doi = {10.1063/1.2978177}, + abstract = {We present a new estimator for computing free energy differences and thermodynamic expectations as well as their uncertainties from samples obtained from multiple equilibrium states via either simulation or experiment. The estimator, which we call the multistate Bennett acceptance ratio estimator ({MBAR}) because it reduces to the Bennett acceptance ratio estimator ({BAR}) when only two states are considered, has significant advantages over multiple histogram reweighting methods for combining data from multiple states. It does not require the sampled energy range to be discretized to produce histograms, eliminating bias due to energy binning and significantly reducing the time complexity of computing a solution to the estimating equations in many cases. Additionally, an estimate of the statistical uncertainty is provided for all estimated quantities. In the large sample limit, {MBAR} is unbiased and has the lowest variance of any known estimator for making use of equilibrium data collected from multiple states. We illustrate this method by producing a highly precise estimate of the potential of mean force for a {DNA} hairpin system, combining data from multiple optical tweezer measurements under constant force bias.}, + pages = {124105}, + number = {12}, + journaltitle = {The Journal of Chemical Physics}, + author = {Shirts, Michael R. and Chodera, John D.}, + urldate = {2023-10-02}, + date = {2008-09-28}, + langid = {english}, + file = {Shirts and Chodera - 2008 - Statistically optimal analysis of samples from mul.pdf:/home/marjan/Zotero/storage/8W27U635/Shirts and Chodera - 2008 - Statistically optimal analysis of samples from mul.pdf:application/pdf}, +} + +@article{chodera_use_2007, + title = {Use of the Weighted Histogram Analysis Method for the Analysis of Simulated and Parallel Tempering Simulations}, + volume = {3}, + issn = {1549-9618, 1549-9626}, + url = {https://pubs.acs.org/doi/10.1021/ct0502864}, + doi = {10.1021/ct0502864}, + abstract = {The growing adoption of generalized-ensemble algorithms for biomolecular simulation has resulted in a resurgence in the use of the weighted histogram analysis method ({WHAM}) to make use of all data generated by these simulations. Unfortunately, the original presentation of {WHAM} by Kumar et al. is not directly applicable to data generated by these methods. {WHAM} was originally formulated to combine data from independent samplings of the canonical ensemble, whereas many generalized-ensemble algorithms sample from mixtures of canonical ensembles at different temperatures. Sorting configurations generated from a parallel tempering simulation by temperature obscures the temporal correlation in the data and results in an improper treatment of the statistical uncertainties used in constructing the estimate of the density of states. Here we present variants of {WHAM}, {STWHAM} and {PTWHAM}, derived with the same set of assumptions, that can be directly applied to several generalized ensemble algorithms, including simulated tempering, parallel tempering (better known as replica-exchange among temperatures), and replica-exchange simulated tempering. We present methods that explicitly capture the considerable temporal correlation in sequentially generated configurations using autocorrelation analysis. This allows estimation of the statistical uncertainty in {WHAM} estimates of expectations for the canonical ensemble. We test the method with a one-dimensional model system and then apply it to the estimation of potentials of mean force from parallel tempering simulations of the alanine dipeptide in both implicit and explicit solvent.}, + pages = {26--41}, + number = {1}, + journaltitle = {Journal of Chemical Theory and Computation}, + shortjournal = {J. Chem. Theory Comput.}, + author = {Chodera, John D. and Swope, William C. and Pitera, Jed W. and Seok, Chaok and Dill, Ken A.}, + urldate = {2023-10-02}, + date = {2007-01-01}, + langid = {english}, + file = {Chodera et al. - 2007 - Use of the Weighted Histogram Analysis Method for .pdf:/home/marjan/Zotero/storage/L38UQDMW/Chodera et al. - 2007 - Use of the Weighted Histogram Analysis Method for .pdf:application/pdf}, +} + +@misc{anderson_hoomd-blue_2019, + title = {{HOOMD}-blue: A Python package for high-performance molecular dynamics and hard particle Monte Carlo simulations}, + url = {http://arxiv.org/abs/1308.5587}, + shorttitle = {{HOOMD}-blue}, + abstract = {{HOOMD}-blue is a particle simulation engine designed for nano- and colloidal-scale molecular dynamics and hard particle Monte Carlo simulations. It has been actively developed since March 2007 and available open source since August 2008. {HOOMD}-blue is a Python package with a high performance C++/{CUDA} backend that we built from the ground up for {GPU} acceleration. The Python interface allows users to combine {HOOMD}-blue with with other packages in the Python ecosystem to create simulation and analysis workflows. We employ software engineering practices to develop, test, maintain, and expand the code.}, + number = {{arXiv}:1308.5587}, + publisher = {{arXiv}}, + author = {Anderson, Joshua A. and Glaser, Jens and Glotzer, Sharon C.}, + urldate = {2023-10-03}, + date = {2019-10-18}, + langid = {english}, + eprinttype = {arxiv}, + eprint = {1308.5587 [physics]}, + keywords = {Physics - Computational Physics}, + file = {Anderson et al. - 2019 - HOOMD-blue A Python package for high-performance .pdf:/home/marjan/Zotero/storage/C6IKKZYP/Anderson et al. - 2019 - HOOMD-blue A Python package for high-performance .pdf:application/pdf}, +} + +@article{grunewald_polyply_2022, + title = {Polyply; a python suite for facilitating simulations of macromolecules and nanomaterials}, + volume = {13}, + issn = {2041-1723}, + url = {https://www.nature.com/articles/s41467-021-27627-4}, + doi = {10.1038/s41467-021-27627-4}, + abstract = {Abstract + Molecular dynamics simulations play an increasingly important role in the rational design of (nano)-materials and in the study of biomacromolecules. However, generating input files and realistic starting coordinates for these simulations is a major bottleneck, especially for high throughput protocols and for complex multi-component systems. To eliminate this bottleneck, we present the polyply software suite that provides 1) a multi-scale graph matching algorithm designed to generate parameters quickly and for arbitrarily complex polymeric topologies, and 2) a generic multi-scale random walk protocol capable of setting up complex systems efficiently and independent of the target force-field or model resolution. We benchmark quality and performance of the approach by creating realistic coordinates for polymer melt simulations, single-stranded as well as circular single-stranded {DNA}. We further demonstrate the power of our approach by setting up a microphase-separated block copolymer system, and by generating a liquid-liquid phase separated system inside a lipid vesicle.}, + pages = {68}, + number = {1}, + journaltitle = {Nature Communications}, + shortjournal = {Nat Commun}, + author = {Grünewald, Fabian and Alessandri, Riccardo and Kroon, Peter C. and Monticelli, Luca and Souza, Paulo C. T. and Marrink, Siewert J.}, + urldate = {2023-10-03}, + date = {2022-01-10}, + langid = {english}, + file = {Grünewald et al. - 2022 - Polyply\; a python suite for facilitating simulatio.pdf:/home/marjan/Zotero/storage/BDEA9LQX/Grünewald et al. - 2022 - Polyply\; a python suite for facilitating simulatio.pdf:application/pdf}, +} + +@article{pronk_gromacs_2013, + title = {{GROMACS} 4.5: a high-throughput and highly parallel open source molecular simulation toolkit}, + volume = {29}, + issn = {1367-4811, 1367-4803}, + url = {https://academic.oup.com/bioinformatics/article/29/7/845/253065}, + doi = {10.1093/bioinformatics/btt055}, + shorttitle = {{GROMACS} 4.5}, + abstract = {Motivation: Molecular simulation has historically been a lowthroughput technique, but faster computers and increasing amounts of genomic and structural data are changing this by enabling large-scale automated simulation of, for instance, many conformers or mutants of biomolecules with or without a range of ligands. At the same time, advances in performance and scaling now make it possible to model complex biomolecular interaction and function in a manner directly testable by experiment. These applications share a need for fast and efficient software that can be deployed on massive scale in clusters, web servers, distributed computing or cloud resources.}, + pages = {845--854}, + number = {7}, + journaltitle = {Bioinformatics}, + author = {Pronk, Sander and Páll, Szilárd and Schulz, Roland and Larsson, Per and Bjelkmar, Pär and Apostolov, Rossen and Shirts, Michael R. and Smith, Jeremy C. and Kasson, Peter M. and Van Der Spoel, David and Hess, Berk and Lindahl, Erik}, + urldate = {2023-10-03}, + date = {2013-04-01}, + langid = {english}, + file = {Pronk et al. - 2013 - GROMACS 4.5 a high-throughput and highly parallel.pdf:/home/marjan/Zotero/storage/P3G6GWA3/Pronk et al. - 2013 - GROMACS 4.5 a high-throughput and highly parallel.pdf:application/pdf}, +} + +@article{hess_gromacs_2008, + title = {{GROMACS} 4: Algorithms for Highly Efficient, Load-Balanced, and Scalable Molecular Simulation}, + volume = {4}, + issn = {1549-9618, 1549-9626}, + url = {https://pubs.acs.org/doi/10.1021/ct700301q}, + doi = {10.1021/ct700301q}, + shorttitle = {{GROMACS} 4}, + abstract = {Molecular simulation is an extremely useful, but computationally very expensive tool for studies of chemical and biomolecular systems. Here, we present a new implementation of our molecular simulation toolkit {GROMACS} which now both achieves extremely high performance on single processors from algorithmic optimizations and hand-coded routines and simultaneously scales very well on parallel machines. The code encompasses a minimal-communication domain decomposition algorithm, full dynamic load balancing, a state-of-the-art parallel constraint solver, and efficient virtual site algorithms that allow removal of hydrogen atom degrees of freedom to enable integration time steps up to 5 fs for atomistic simulations also in parallel. To improve the scaling properties of the common particle mesh Ewald electrostatics algorithms, we have in addition used a Multiple-Program, Multiple-Data approach, with separate node domains responsible for direct and reciprocal space interactions. Not only does this combination of algorithms enable extremely long simulations of large systems but also it provides that simulation performance on quite modest numbers of standard cluster nodes.}, + pages = {435--447}, + number = {3}, + journaltitle = {Journal of Chemical Theory and Computation}, + shortjournal = {J. Chem. Theory Comput.}, + author = {Hess, Berk and Kutzner, Carsten and Van Der Spoel, David and Lindahl, Erik}, + urldate = {2023-10-03}, + date = {2008-03-01}, + langid = {english}, + file = {Hess et al. - 2008 - GROMACS 4 Algorithms for Highly Efficient, Load-B.pdf:/home/marjan/Zotero/storage/S2YWMFVZ/Hess et al. - 2008 - GROMACS 4 Algorithms for Highly Efficient, Load-B.pdf:application/pdf}, +} + +@article{berendsen_gromacs_1995, + title = {{GROMACS}: A message-passing parallel molecular dynamics implementation}, + volume = {91}, + issn = {00104655}, + url = {https://linkinghub.elsevier.com/retrieve/pii/001046559500042E}, + doi = {10.1016/0010-4655(95)00042-E}, + shorttitle = {{GROMACS}}, + abstract = {A parallel message-passing implementation of a molecular dynamics ({MD}) program that is useful for bio(macro)molecules in aqueous environment is described. The software has been developed for a custom-designed 32-processor ring {GROMACS} ({GROningen} {MAchine} for Chemical Simulation) with communication to and from left and right neighbours, but can mn on any parallel system onto which a a ring of processors can be mapped and which supports {PVM}-like block send and receive calls. The {GROMACS} software consists of a preprocessor, a parallel {MD} and energy minimization p{\textasciitilde}ogram that can use an arbitrary number of processors (including one), an optional monitor, and several analysis tools. The programs are written in {ANSI} C and available by ftp (information: gromacs@chem.rug.nl). The functionality is based on the {GROMOS} ({GROningen} {MOlecular} Simulation) package (van Gunsteren and Berendsen, 1987; {BIOMOS} B.V., Nijenborgh 4, 9747 {AG} Groningen). Conversion programs between {GROMOS} and {GROMACS} formats are included.}, + pages = {43--56}, + number = {1}, + journaltitle = {Computer Physics Communications}, + shortjournal = {Computer Physics Communications}, + author = {Berendsen, H.J.C. and Van Der Spoel, D. and Van Drunen, R.}, + urldate = {2023-10-03}, + date = {1995-09}, + langid = {english}, + file = {Berendsen et al. - 1995 - GROMACS A message-passing parallel molecular dyna.pdf:/home/marjan/Zotero/storage/NQBQTWNV/Berendsen et al. - 1995 - GROMACS A message-passing parallel molecular dyna.pdf:application/pdf}, +} + +@article{abraham_gromacs_2015, + title = {{GROMACS}: High performance molecular simulations through multi-level parallelism from laptops to supercomputers}, + volume = {1-2}, + issn = {23527110}, + url = {https://linkinghub.elsevier.com/retrieve/pii/S2352711015000059}, + doi = {10.1016/j.softx.2015.06.001}, + shorttitle = {{GROMACS}}, + abstract = {{GROMACS} is one of the most widely used open-source and free software codes in chemistry, used primarily for dynamical simulations of biomolecules. It provides a rich set of calculation types, preparation and analysis tools. Several advanced techniques for free-energy calculations are supported. In version 5, it reaches new performance heights, through several new and enhanced parallelization algorithms. These work on every level; {SIMD} registers inside cores, multithreading, heterogeneous {CPU}–{GPU} acceleration, state-of-the-art 3D domain decomposition, and ensemble-level parallelization through built-in replica exchange and the separate Copernicus framework. The latest best-in-class compressed trajectory storage format is supported.}, + pages = {19--25}, + journaltitle = {{SoftwareX}}, + shortjournal = {{SoftwareX}}, + author = {Abraham, Mark James and Murtola, Teemu and Schulz, Roland and Páll, Szilárd and Smith, Jeremy C. and Hess, Berk and Lindahl, Erik}, + urldate = {2023-10-03}, + date = {2015-09}, + langid = {english}, + file = {Abraham et al. - 2015 - GROMACS High performance molecular simulations th.pdf:/home/marjan/Zotero/storage/GS2XGYLP/Abraham et al. - 2015 - GROMACS High performance molecular simulations th.pdf:application/pdf}, } +@incollection{szilard_tackling_2015, + title = {Tackling Exascale Software Challenges in Molecular Dynamics Simulations with {GROMACS}}, + volume = {8759}, + url = {http://arxiv.org/abs/1506.00716}, + abstract = {{GROMACS} is a widely used package for biomolecular simulation, and over the last two decades it has evolved from small-scale efficiency to advanced heterogeneous acceleration and multi-level parallelism targeting some of the largest supercomputers in the world. Here, we describe some of the ways we have been able to realize this through the use of parallelization on all levels, combined with a constant focus on absolute performance. Release 4.6 of {GROMACS} uses {SIMD} acceleration on a wide range of architectures, {GPU} offloading acceleration, and both {OpenMP} and {MPI} parallelism within and between nodes, respectively. The recent work on acceleration made it necessary to revisit the fundamental algorithms of molecular simulation, including the concept of neighborsearching, and we discuss the present and future challenges we see for exascale simulation - in particular a very fine-grained task parallelism. We also discuss the software management, code peer review and continuous integration testing required for a project of this complexity.}, + pages = {3--27}, + author = {Szilárd, Páll and Abraham, Mark James and Kutzner, Carsten and Hess, Berk and Lindahl, Erik}, + urldate = {2023-10-03}, + date = {2015}, + langid = {english}, + doi = {10.1007/978-3-319-15976-8_1}, + eprinttype = {arxiv}, + eprint = {1506.00716 [cs]}, + keywords = {Computer Science - Computational Engineering, Finance, and Science, I.6.8, J.2}, + file = {Szilárd et al. - 2015 - Tackling Exascale Software Challenges in Molecular.pdf:/home/marjan/Zotero/storage/2888WILV/Szilárd et al. - 2015 - Tackling Exascale Software Challenges in Molecular.pdf:application/pdf}, } +@article{santana-bonilla_modular_2023, + title = {Modular Software for Generating and Modeling Diverse Polymer Databases}, + volume = {63}, + issn = {1549-9596, 1549-960X}, + url = {https://pubs.acs.org/doi/10.1021/acs.jcim.3c00081}, + doi = {10.1021/acs.jcim.3c00081}, + abstract = {Machine learning methods offer the opportunity to design new functional materials on an unprecedented scale; however, building the large, diverse databases of molecules on which to train such methods remains a daunting task. Automated computational chemistry modeling workflows are therefore becoming essential tools in this data-driven hunt for new materials with novel properties, since they offer a means by which to create and curate molecular databases without requiring significant levels of user input. This ensures that well-founded concerns regarding data provenance, reproducibility, and replicability are mitigated. We have developed a versatile and flexible software package, {PySoftK} (Python Soft Matter at King’s College London) that provides flexible, automated computational workflows to create, model, and curate libraries of polymers with minimal user intervention. {PySoftK} is available as an efficient, fully tested, and easily installable Python package. Key features of the software include the wide range of different polymer topologies that can be automatically generated and its fully parallelized library generation tools. It is anticipated that {PySoftK} will support the generation, modeling, and curation of large polymer libraries to support functional materials discovery in the nanotechnology and biotechnology arenas.}, + pages = {3761--3771}, + number = {12}, + journaltitle = {Journal of Chemical Information and Modeling}, + shortjournal = {J. Chem. Inf. Model.}, + author = {Santana-Bonilla, Alejandro and López-Ríos De Castro, Raquel and Sun, Peike and Ziolek, Robert M. and Lorenz, Christian D.}, + urldate = {2023-10-03}, + date = {2023-06-26}, + langid = {english}, + file = {Santana-Bonilla et al. - 2023 - Modular Software for Generating and Modeling Diver.pdf:/home/marjan/Zotero/storage/AE3GZU56/Santana-Bonilla et al. - 2023 - Modular Software for Generating and Modeling Diver.pdf:application/pdf}, +} + +@incollection{snurr_hierarchical_2016, + location = {Singapore}, + title = {A Hierarchical, Component Based Approach to Screening Properties of Soft Matter}, + isbn = {978-981-10-1126-9 978-981-10-1128-3}, + url = {http://link.springer.com/10.1007/978-981-10-1128-3_5}, + pages = {79--92}, + booktitle = {Foundations of Molecular Modeling and Simulation}, + publisher = {Springer Singapore}, + author = {Klein, Christoph and Sallai, János and Jones, Trevor J. and Iacovella, Christopher R. and {McCabe}, Clare and Cummings, Peter T.}, + editor = {Snurr, Randall Q and Adjiman, Claire S. and Kofke, David A.}, + urldate = {2023-10-05}, + date = {2016}, + langid = {english}, + doi = {10.1007/978-981-10-1128-3_5}, + note = {Series Title: Molecular Modeling and Simulation}, + file = {Klein et al. - 2016 - A Hierarchical, Component Based Approach to Screen.pdf:/home/marjan/Zotero/storage/FU5HX33B/Klein et al. - 2016 - A Hierarchical, Component Based Approach to Screen.pdf:application/pdf}, +} + +@article{thompson_lammps_2022, + title = {{LAMMPS} - a flexible simulation tool for particle-based materials modeling at the atomic, meso, and continuum scales}, + volume = {271}, + issn = {00104655}, + url = {https://linkinghub.elsevier.com/retrieve/pii/S0010465521002836}, + doi = {10.1016/j.cpc.2021.108171}, + pages = {108171}, + journaltitle = {Computer Physics Communications}, + shortjournal = {Computer Physics Communications}, + author = {Thompson, Aidan P. and Aktulga, H. Metin and Berger, Richard and Bolintineanu, Dan S. and Brown, W. Michael and Crozier, Paul S. and In 'T Veld, Pieter J. and Kohlmeyer, Axel and Moore, Stan G. and Nguyen, Trung Dac and Shan, Ray and Stevens, Mark J. and Tranchida, Julien and Trott, Christian and Plimpton, Steven J.}, + urldate = {2023-10-05}, + date = {2022-02}, + langid = {english}, + file = {Thompson et al. - 2022 - LAMMPS - a flexible simulation tool for particle-b.pdf:/home/marjan/Zotero/storage/YY2CV6SA/Thompson et al. - 2022 - LAMMPS - a flexible simulation tool for particle-b.pdf:application/pdf}, +} + +@software{noauthor_gmso_nodate, + title = {{GMSO}: General Molecular Simulation Object.}, + url = {https://gmso.mosdef.org/en/stable/}, + publisher = {mosdef-hub, Vanderbilt University}, +} From 291cb5106dd76e8174d953eee6996d1c3b6150e4 Mon Sep 17 00:00:00 2001 From: marjanalbouye Date: Thu, 5 Oct 2023 13:10:18 -0600 Subject: [PATCH 04/54] transfer text from overleaf --- paper/paper.md | 196 +++++++++++++++++++++++++++++++------------------ 1 file changed, 126 insertions(+), 70 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index a683cade..b8680f74 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -1,5 +1,5 @@ --- -title: 'Polybinder: A Python package for streamlined polymer molecular dynamics' +title: 'JankFlow: A Flexible Python Library for Organic Workflows' tags: - Python - materials science @@ -11,9 +11,13 @@ authors: orcid: 0000-0002-6196-5274 equal-contrib: true affiliation: 1 + - name: Marjan Albooyeh + orcid: 0009-0001-9565-3076 + equal-contrib: true + affiliation: 1 - name: Rainier Barrett orcid: 0000-0002-5728-9074 - equal-contrib: true + corresponding: true affiliation: 1 - name: Eric Jankowski orcid: 0000-0002-3267-1410 @@ -26,81 +30,133 @@ date: 01 January 2001 bibliography: paper.bib --- +# Summary +JankFlow is a package for reproducibly performing complex HOOMD-Blue simulation workflows. It enables the programmatic specification of tasks including +definition of molecular structures, forcefield definition and application, chaining +together simulation stages (e.g., shrinking, equilibration, simulating a sequence +of ensembles, tensile testing), and trajectory analysis through an extensible set +of python classes. Common tasks and forcefields for organic macrmolecular and +polymer simulations are included, as are tutorials demonstrating customization +and extensibility. # Statement of need -One of the steeper learning curves on the road to using molecular dynamics (MD) simulations -of polymer systems is -the initialization of particle positions, topology, and force field parameters. -Especially for researchers new to the computational community, generating particle -positions and initializing their velocities alone can be a daunting task, let alone -specifying bond topology. The concept of a force field file and how it interacts with -different MD engines is also non-trivial to understand. -Further, besides the difficulty in starting simulations, another part of the cognitive -load involved in learning to perform informative MD investigations is that it can be -difficult to keep track of many simulations, especially when scanning over a wide -range of thermodynamic state points, system chemistries, etc. -These wide scans can quickly create an unmanageable amount of data to analyze, -or even store, requiring further learning of data management skills on top of an already -cumbersome training process. -Moreover, even with a high-throughput workflow and good grasp of theory, it can still -prove difficult to produce TRUE (standing for "Transparent, Reproducible, Usable, and -Extensible") MD simulations with reliable, accurate results. `@JankowskiTRUE2020` - -In particular, when we want to probe complex variable spaces, -such as process control variables in a composite material manufacture process, -we need to run several large-volume, high-density, long-time simulations, -many of which may not reveal relevant information for process control. -This search process is further delayed due to the increasing CPU time required to -simulate such large systems. A common solution for this problem of scale in MD -is coarse grain (CG) modeling, where atomistic accuracy is traded for speed. -This likewise comes with some subtle barriers between concept and practice. -For instance, to produce a CG model of a given polymer that is transferable across -state points, many simulations at various state points must be run and managed, -increasing the desirability of a reliable and easy way to keep track of these, -particularly for the multi-state iterative Boltzmann inversion (MSIBI)`@MooreMSIBI2014` -method of parameterization. All these aspects complicate and prolong the algready time- -and labor-intensive process of training new computational researchers -to perform sufficiently many simulations to meaningfully investigate polymer systems. - -These factors indicate a need for a streamlined tool for creating (optionally CG) -MD polymer systems, launching one or many simulations across state points and/or -system type, and managing and analyzing the results. Ideally such a tool should be -approachable for novice programmers, to maximize time spent investigating research -questions and minimize the learning curve for new researchers, while preserving -the accuracy and rigor of the resultant research. +High-level programmatic specification of molecular simulation workflows are +needed for two reasons: First: They provide the information necessary for a +simulation study to be repeated, and Second: They facilitate accessible peda- +gogy of molecular simulation by minimizing the cognitive load needed to get +started[?]. -# Summary +Most molecular simulations are performed using a combination of tools: +Text editors (to copy and edit plain text files that specify molecular +configurations, forcefield files, simulation engine input files and/or simulation scripts), +command-line interfaces for submitting simulations to a local processor or HPC +cluster qeueing system, and numerical analysis and visualization software to +inspect simulation data. When simulations are set up manually and iteratively, +it is difficult to maintain data provenance, that is, a record of what files and +choices determine the outputs of a simulation. -Polybinder, the suite of tools introduced here, was built to enable materials scientists -to use molecular simulation to quickly and reproducibly simulate -large, coarse- or fine-grained polymer systems to investigate and predict trends in -their properties, all with a much lower barrier to entry than starting from scratch. Because it is designed -with modularity in mind, it will also ease adoption by other research groups, -and quicken the investigation process of new materials systems. - -Polybinder is a Python package that uses the [foyer](https://github.com/mosdef-hub/foyer/), -[mbuild](https://github.com/mosdef-hub/mbuild/), and [signac](https://github.com/mosdef-hub/signac) packages from -the [MoSDeF suite of tools](https://github.com/mosdef-hub/) to quickly, easily, and reproducibly initialize and run polymer -simulations in the [HOOMD-blue](https://github.com/glotzerlab/hoomd-blue) engine. -Polybinder was made with the TRUE principles in mind `@JankowskiTRUE2020`, with the goal of allowing ease -of use and adoption, and reducing the learning curve for starting simulations. -This package allows for a variety of simulation types of interest, -such as bulk thermoplastic melts, annealing, welding interface interpenetration, and tensile testing of -the resultant welded systems. -Presently polybinder has methods for three common thermoplastic polymer chemistries: -polyether ether ketone (PEEK), polyether ketone ketone (PEKK), -and polyphenylene sulfide (PPS). However, polybinder is designed such that any -monomer units can be implemented and added to the internal library of available -structures via mbuild. - - -# Accessing the Software - -Polybinder is freely available under the GNU General Public License (version 3) on [github](https://github.com/cmelab/polybinder). +Even for simulations of “relatively simple” single-component systems at a +single thermodynamic state point, it is challenging for users to manage records +of which exact forcefield was applied, whether any forcefield parameters were +modified, whether a sequence of short simulations was needed to create the +initial conditions, which microstates were included in analysis, and whether +human intervention occurred at any step to inform the next. Furthermore, for +a researcher new to molecular simulations, the details of generating an initial +condition for a thermodynamic simulation are simultaneously: (a) not germane +to understanding the concept of a simulation overall, (b) crucial to get right so +the researcher can get started, and (c) likely specifyable using community best +practices for configuration initialization. -# Acknowledgements +Recent advances in well-documented open-source tools [?, ?, ?, ?] have made +the programmatic specification of molecular simulation components easier than +ever. Individually, each of these tools lower the cognitive load of one aspect of +an overall workflow tailored to answer a specific research question. However, +the challenge of stitching the pieces together to create a complete workflow still +contains several barriers. + +The computational researcher who follows best practices for accurate, +accessible and reproducible results may create a programmatic layer over these +individual software packages (i.e. wrapper) that serves to consolidate and +automate a complete workflow. However, these efforts often use a bespoke approach +where the entire workflow design is tailored towards the specific question or +project. Design choices might include the materials studied, the model used +(e.g. atomistic or coarse-grained), the source of the forcefield in the model, and +the simulation protocols followed. As a result, this wrapper is likely unusable +for the next project where one of the aforementioned choices changes, and the +process of designing a workflow must begin again from scratch. + +Regardless of the goal at hand, designing any MD workflow typically involves +the same preliminary steps: +1. Creating molecules. +2. Building up larger, complex compounds from smaller molecules (e.g. poly- +mers, surfaces) +3. Designate the initial structure and topology of a system of compounds. +4. Choose and correctly apply a forcefield to the system. +5. Pass off the initial topology and forcefield information to a simulation +engine + +Therefore, the goal of a package that aims to consolidate and automate +complete workflows should have a TRUE foundational base from which workflows +can inherit, making it significantly easier to construct new workflows without +starting from scratch. It should be extensible; a workflow from beginning to +end should not depend on the chemistry chosen, whether or not the model is +atomistic or coarse-grained, or if interaction parameters come from established +forcefields or from a machine learned model. This tool should be modular, +allowing workflows to evolve into highly specific applications further down the +pipeline, without concerns about design choices limiting or interfering with other +use cases. Moreover, the continuous maintenance, updates, and addition of features to this foundational base permeate throughout the library of workflows. +If executed thoughtfully and accurately, this enables the creation of a library +of versatile, open-source, and version-controlled workflows. JankFlow is an +attempt at making this tool by creating a TRUE base and beginning a library of +workflow modules. + +[//]: # (1-2 sentnces about the popular simulation engines (gromacs, lammps, hoomd,) + +[//]: # (openmm). Gromacs and lammps have lots of cool features, but don’t have rich) + +[//]: # (APIs, and involve text based input files which make it hard to be TRUE. Hoomd) +[//]: # (and openmm have robust APIs, but don’t have the same level of featureizaiton) + +[//]: # (as lammps and gromacs. This package aims to add a layer of featureizaiton on) + +[//]: # (top of hoomd.) + + +# Building Blocks +JankFlow simplifies the execution of molecular dynamics simulations by +integrating the capabilities of molecular builder packages like GMSO[?] and MBuild[2] +with the HOOMD[1] simulation engine, offering a comprehensive end-to-end simulation recipe development tool. +This is accomplished through three building block classes: + +• Molecule utilizes the mBuild and GMSO packages to initialize chemical +structures from a variety of input formats. This class provides methods +for building polymers and copolymer structures and supports straightforward +coarse-graining process. + +• System class serves as an intermediary between molecular initialization +and simulation setup. This class is responsible for arrangement of a mixture +of molecules in a box and facilitates the configuration of particle +interactions. + +• Simulation class employs the HOOMD-blue [1] simulation object, offering +additional strategies and simulation processes tailored to specific research +needs. It also facilitates the process of quickly resuming a simulation. + + +# Recipes +The JankFlow package, with its flexible and extendable design, allows users +to utilize its core classes as building blocks, enabling the formulation of +customized recipes for various molecular simulation processes in accordance with +their specific research needs. To illustrate this process, we offer the two +following examples of such recipes in this package, with the expectation of introducing +more recipes in the future. + +1)Welding recipe with example code +2)Tensile recipe with example code + +# Acknowledgements We acknowledge contributions from [ULI Advisory board, NASA, etc] # References \ No newline at end of file From cc30848d959cc9a8bb4264b3607a2b3d652543db Mon Sep 17 00:00:00 2001 From: marjanalbouye Date: Thu, 5 Oct 2023 13:16:23 -0600 Subject: [PATCH 05/54] remove abstract from bib --- paper/paper.bib | 22 +--------------------- 1 file changed, 1 insertion(+), 21 deletions(-) diff --git a/paper/paper.bib b/paper/paper.bib index 497c1cf5..e58100a4 100644 --- a/paper/paper.bib +++ b/paper/paper.bib @@ -6,13 +6,6 @@ @article{hayashi_radonpy_2022 url = {https://www.nature.com/articles/s41524-022-00906-4}, doi = {10.1038/s41524-022-00906-4}, shorttitle = {{RadonPy}}, - abstract = {Abstract - - The spread of data-driven materials research has increased the need for systematically designed materials property databases. However, the development of polymer databases has lagged far behind other material systems. We present {RadonPy}, an open-source library that can automate the complete process of all-atom classical molecular dynamics ({MD}) simulations applicable to a wide variety of polymeric materials. Herein, 15 different properties were calculated for more than 1000 amorphous polymers. The {MD}-calculated properties were systematically compared with experimental data to validate the calculation conditions; the bias and variance in the {MD}-calculated properties were successfully calibrated by a machine learning technique. During the high-throughput data production, we identified eight amorphous polymers with extremely high thermal conductivity ({\textgreater}0.4 W ∙ m - –1 -  ∙ K - –1 - ) and their underlying mechanisms. Similar to the advancement of materials informatics since the advent of computational property databases for inorganic crystals, database construction using {RadonPy} will promote the development of polymer informatics.}, pages = {222}, number = {1}, journaltitle = {npj Computational Materials}, @@ -30,7 +23,6 @@ @article{thompson_towards_2020 issn = {0026-8976, 1362-3028}, url = {https://www.tandfonline.com/doi/full/10.1080/00268976.2020.1742938}, doi = {10.1080/00268976.2020.1742938}, - abstract = {Systems composed of soft matter (e.g., liquids, polymers, foams, gels, colloids, and most biological materials) are ubiquitous in science and engineering, but molecular simulations of such systems pose particular computational challenges, requiring time and/or ensemble-averaged data to be collected over long simulation trajectories for property evaluation. Performing a molecular simulation of a soft matter system involves multiple steps, which have traditionally been performed by researchers in a “bespoke” fashion, resulting in many published soft matter simulations not being reproducible based on the information provided in the publications. To address the issue of reproducibility and to provide tools for computational screening, we have been developing the open-source Molecular Simulation and Design Framework ({MoSDeF}) software suite.}, pages = {e1742938}, number = {9}, journaltitle = {Molecular Physics}, @@ -49,7 +41,6 @@ @article{hedges_biosimspace_2019 url = {https://joss.theoj.org/papers/10.21105/joss.01831}, doi = {10.21105/joss.01831}, shorttitle = {{BioSimSpace}}, - abstract = {Biomolecular simulation is a diverse and growing area of research, making important contributions to structural biology and pharmaceutical research (Huggins et al., 2019). Within the community there are a several significant and widely used software packages that have evolved from within various research groups over the past 20 or more years. For example, the molecular dynamics packages {AMBER} (Case et al., 2005), {GROMACS} (Abraham et al., 2015), and {NAMD} (Phillips et al., 2005), which are all capable of running biomolecular simulations for systems consisting of hundreds of thousands of atoms and can be run on hardware ranging from laptops, to graphics processing units ({GPUs}), to the latest high-performance computing clusters. Since different software packages were developed independently, interoperability between them is poor. In large part this is the result of major differences in the supported file formats, which makes it difficult to translate the inputs and outputs of one program to another. As a consequence, expertise in one package doesn’t immediately apply to another, making it hard to share methodology and knowledge between different research communities, as evidenced, for instance, by a recent study on reproducibility of relative hydration free energies across simulation packages (Loeffler et al., 2018). The issue is compounded by the increasing use of biomolecular simulations as components of larger scientific workflows for bioengineering or computer-aided drug design purposes. A lack of interoperability leads to brittle workflows, poor reproducibility, and lock in to specific software that hinders dissemination of biomolecular simulation methodologies to other communities.}, pages = {1831}, number = {43}, journaltitle = {Journal of Open Source Software}, @@ -67,7 +58,6 @@ @article{shirts_statistically_2008 issn = {0021-9606, 1089-7690}, url = {https://pubs.aip.org/jcp/article/129/12/124105/957527/Statistically-optimal-analysis-of-samples-from}, doi = {10.1063/1.2978177}, - abstract = {We present a new estimator for computing free energy differences and thermodynamic expectations as well as their uncertainties from samples obtained from multiple equilibrium states via either simulation or experiment. The estimator, which we call the multistate Bennett acceptance ratio estimator ({MBAR}) because it reduces to the Bennett acceptance ratio estimator ({BAR}) when only two states are considered, has significant advantages over multiple histogram reweighting methods for combining data from multiple states. It does not require the sampled energy range to be discretized to produce histograms, eliminating bias due to energy binning and significantly reducing the time complexity of computing a solution to the estimating equations in many cases. Additionally, an estimate of the statistical uncertainty is provided for all estimated quantities. In the large sample limit, {MBAR} is unbiased and has the lowest variance of any known estimator for making use of equilibrium data collected from multiple states. We illustrate this method by producing a highly precise estimate of the potential of mean force for a {DNA} hairpin system, combining data from multiple optical tweezer measurements under constant force bias.}, pages = {124105}, number = {12}, journaltitle = {The Journal of Chemical Physics}, @@ -84,7 +74,6 @@ @article{chodera_use_2007 issn = {1549-9618, 1549-9626}, url = {https://pubs.acs.org/doi/10.1021/ct0502864}, doi = {10.1021/ct0502864}, - abstract = {The growing adoption of generalized-ensemble algorithms for biomolecular simulation has resulted in a resurgence in the use of the weighted histogram analysis method ({WHAM}) to make use of all data generated by these simulations. Unfortunately, the original presentation of {WHAM} by Kumar et al. is not directly applicable to data generated by these methods. {WHAM} was originally formulated to combine data from independent samplings of the canonical ensemble, whereas many generalized-ensemble algorithms sample from mixtures of canonical ensembles at different temperatures. Sorting configurations generated from a parallel tempering simulation by temperature obscures the temporal correlation in the data and results in an improper treatment of the statistical uncertainties used in constructing the estimate of the density of states. Here we present variants of {WHAM}, {STWHAM} and {PTWHAM}, derived with the same set of assumptions, that can be directly applied to several generalized ensemble algorithms, including simulated tempering, parallel tempering (better known as replica-exchange among temperatures), and replica-exchange simulated tempering. We present methods that explicitly capture the considerable temporal correlation in sequentially generated configurations using autocorrelation analysis. This allows estimation of the statistical uncertainty in {WHAM} estimates of expectations for the canonical ensemble. We test the method with a one-dimensional model system and then apply it to the estimation of potentials of mean force from parallel tempering simulations of the alanine dipeptide in both implicit and explicit solvent.}, pages = {26--41}, number = {1}, journaltitle = {Journal of Chemical Theory and Computation}, @@ -100,7 +89,6 @@ @misc{anderson_hoomd-blue_2019 title = {{HOOMD}-blue: A Python package for high-performance molecular dynamics and hard particle Monte Carlo simulations}, url = {http://arxiv.org/abs/1308.5587}, shorttitle = {{HOOMD}-blue}, - abstract = {{HOOMD}-blue is a particle simulation engine designed for nano- and colloidal-scale molecular dynamics and hard particle Monte Carlo simulations. It has been actively developed since March 2007 and available open source since August 2008. {HOOMD}-blue is a Python package with a high performance C++/{CUDA} backend that we built from the ground up for {GPU} acceleration. The Python interface allows users to combine {HOOMD}-blue with with other packages in the Python ecosystem to create simulation and analysis workflows. We employ software engineering practices to develop, test, maintain, and expand the code.}, number = {{arXiv}:1308.5587}, publisher = {{arXiv}}, author = {Anderson, Joshua A. and Glaser, Jens and Glotzer, Sharon C.}, @@ -119,8 +107,6 @@ @article{grunewald_polyply_2022 issn = {2041-1723}, url = {https://www.nature.com/articles/s41467-021-27627-4}, doi = {10.1038/s41467-021-27627-4}, - abstract = {Abstract - Molecular dynamics simulations play an increasingly important role in the rational design of (nano)-materials and in the study of biomacromolecules. However, generating input files and realistic starting coordinates for these simulations is a major bottleneck, especially for high throughput protocols and for complex multi-component systems. To eliminate this bottleneck, we present the polyply software suite that provides 1) a multi-scale graph matching algorithm designed to generate parameters quickly and for arbitrarily complex polymeric topologies, and 2) a generic multi-scale random walk protocol capable of setting up complex systems efficiently and independent of the target force-field or model resolution. We benchmark quality and performance of the approach by creating realistic coordinates for polymer melt simulations, single-stranded as well as circular single-stranded {DNA}. We further demonstrate the power of our approach by setting up a microphase-separated block copolymer system, and by generating a liquid-liquid phase separated system inside a lipid vesicle.}, pages = {68}, number = {1}, journaltitle = {Nature Communications}, @@ -139,7 +125,6 @@ @article{pronk_gromacs_2013 url = {https://academic.oup.com/bioinformatics/article/29/7/845/253065}, doi = {10.1093/bioinformatics/btt055}, shorttitle = {{GROMACS} 4.5}, - abstract = {Motivation: Molecular simulation has historically been a lowthroughput technique, but faster computers and increasing amounts of genomic and structural data are changing this by enabling large-scale automated simulation of, for instance, many conformers or mutants of biomolecules with or without a range of ligands. At the same time, advances in performance and scaling now make it possible to model complex biomolecular interaction and function in a manner directly testable by experiment. These applications share a need for fast and efficient software that can be deployed on massive scale in clusters, web servers, distributed computing or cloud resources.}, pages = {845--854}, number = {7}, journaltitle = {Bioinformatics}, @@ -157,7 +142,6 @@ @article{hess_gromacs_2008 url = {https://pubs.acs.org/doi/10.1021/ct700301q}, doi = {10.1021/ct700301q}, shorttitle = {{GROMACS} 4}, - abstract = {Molecular simulation is an extremely useful, but computationally very expensive tool for studies of chemical and biomolecular systems. Here, we present a new implementation of our molecular simulation toolkit {GROMACS} which now both achieves extremely high performance on single processors from algorithmic optimizations and hand-coded routines and simultaneously scales very well on parallel machines. The code encompasses a minimal-communication domain decomposition algorithm, full dynamic load balancing, a state-of-the-art parallel constraint solver, and efficient virtual site algorithms that allow removal of hydrogen atom degrees of freedom to enable integration time steps up to 5 fs for atomistic simulations also in parallel. To improve the scaling properties of the common particle mesh Ewald electrostatics algorithms, we have in addition used a Multiple-Program, Multiple-Data approach, with separate node domains responsible for direct and reciprocal space interactions. Not only does this combination of algorithms enable extremely long simulations of large systems but also it provides that simulation performance on quite modest numbers of standard cluster nodes.}, pages = {435--447}, number = {3}, journaltitle = {Journal of Chemical Theory and Computation}, @@ -176,7 +160,6 @@ @article{berendsen_gromacs_1995 url = {https://linkinghub.elsevier.com/retrieve/pii/001046559500042E}, doi = {10.1016/0010-4655(95)00042-E}, shorttitle = {{GROMACS}}, - abstract = {A parallel message-passing implementation of a molecular dynamics ({MD}) program that is useful for bio(macro)molecules in aqueous environment is described. The software has been developed for a custom-designed 32-processor ring {GROMACS} ({GROningen} {MAchine} for Chemical Simulation) with communication to and from left and right neighbours, but can mn on any parallel system onto which a a ring of processors can be mapped and which supports {PVM}-like block send and receive calls. The {GROMACS} software consists of a preprocessor, a parallel {MD} and energy minimization p{\textasciitilde}ogram that can use an arbitrary number of processors (including one), an optional monitor, and several analysis tools. The programs are written in {ANSI} C and available by ftp (information: gromacs@chem.rug.nl). The functionality is based on the {GROMOS} ({GROningen} {MOlecular} Simulation) package (van Gunsteren and Berendsen, 1987; {BIOMOS} B.V., Nijenborgh 4, 9747 {AG} Groningen). Conversion programs between {GROMOS} and {GROMACS} formats are included.}, pages = {43--56}, number = {1}, journaltitle = {Computer Physics Communications}, @@ -195,7 +178,6 @@ @article{abraham_gromacs_2015 url = {https://linkinghub.elsevier.com/retrieve/pii/S2352711015000059}, doi = {10.1016/j.softx.2015.06.001}, shorttitle = {{GROMACS}}, - abstract = {{GROMACS} is one of the most widely used open-source and free software codes in chemistry, used primarily for dynamical simulations of biomolecules. It provides a rich set of calculation types, preparation and analysis tools. Several advanced techniques for free-energy calculations are supported. In version 5, it reaches new performance heights, through several new and enhanced parallelization algorithms. These work on every level; {SIMD} registers inside cores, multithreading, heterogeneous {CPU}–{GPU} acceleration, state-of-the-art 3D domain decomposition, and ensemble-level parallelization through built-in replica exchange and the separate Copernicus framework. The latest best-in-class compressed trajectory storage format is supported.}, pages = {19--25}, journaltitle = {{SoftwareX}}, shortjournal = {{SoftwareX}}, @@ -210,7 +192,6 @@ @incollection{szilard_tackling_2015 title = {Tackling Exascale Software Challenges in Molecular Dynamics Simulations with {GROMACS}}, volume = {8759}, url = {http://arxiv.org/abs/1506.00716}, - abstract = {{GROMACS} is a widely used package for biomolecular simulation, and over the last two decades it has evolved from small-scale efficiency to advanced heterogeneous acceleration and multi-level parallelism targeting some of the largest supercomputers in the world. Here, we describe some of the ways we have been able to realize this through the use of parallelization on all levels, combined with a constant focus on absolute performance. Release 4.6 of {GROMACS} uses {SIMD} acceleration on a wide range of architectures, {GPU} offloading acceleration, and both {OpenMP} and {MPI} parallelism within and between nodes, respectively. The recent work on acceleration made it necessary to revisit the fundamental algorithms of molecular simulation, including the concept of neighborsearching, and we discuss the present and future challenges we see for exascale simulation - in particular a very fine-grained task parallelism. We also discuss the software management, code peer review and continuous integration testing required for a project of this complexity.}, pages = {3--27}, author = {Szilárd, Páll and Abraham, Mark James and Kutzner, Carsten and Hess, Berk and Lindahl, Erik}, urldate = {2023-10-03}, @@ -229,7 +210,6 @@ @article{santana-bonilla_modular_2023 issn = {1549-9596, 1549-960X}, url = {https://pubs.acs.org/doi/10.1021/acs.jcim.3c00081}, doi = {10.1021/acs.jcim.3c00081}, - abstract = {Machine learning methods offer the opportunity to design new functional materials on an unprecedented scale; however, building the large, diverse databases of molecules on which to train such methods remains a daunting task. Automated computational chemistry modeling workflows are therefore becoming essential tools in this data-driven hunt for new materials with novel properties, since they offer a means by which to create and curate molecular databases without requiring significant levels of user input. This ensures that well-founded concerns regarding data provenance, reproducibility, and replicability are mitigated. We have developed a versatile and flexible software package, {PySoftK} (Python Soft Matter at King’s College London) that provides flexible, automated computational workflows to create, model, and curate libraries of polymers with minimal user intervention. {PySoftK} is available as an efficient, fully tested, and easily installable Python package. Key features of the software include the wide range of different polymer topologies that can be automatically generated and its fully parallelized library generation tools. It is anticipated that {PySoftK} will support the generation, modeling, and curation of large polymer libraries to support functional materials discovery in the nanotechnology and biotechnology arenas.}, pages = {3761--3771}, number = {12}, journaltitle = {Journal of Chemical Information and Modeling}, @@ -275,7 +255,7 @@ @article{thompson_lammps_2022 file = {Thompson et al. - 2022 - LAMMPS - a flexible simulation tool for particle-b.pdf:/home/marjan/Zotero/storage/YY2CV6SA/Thompson et al. - 2022 - LAMMPS - a flexible simulation tool for particle-b.pdf:application/pdf}, } -@software{noauthor_gmso_nodate, +@software{gmso, title = {{GMSO}: General Molecular Simulation Object.}, url = {https://gmso.mosdef.org/en/stable/}, publisher = {mosdef-hub, Vanderbilt University}, From c22343971608ab73bd720a1f8d9faf99b834fe65 Mon Sep 17 00:00:00 2001 From: marjanalbouye Date: Thu, 5 Oct 2023 13:16:34 -0600 Subject: [PATCH 06/54] test citation --- paper/paper.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index b8680f74..62f1d1e6 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -126,8 +126,8 @@ workflow modules. # Building Blocks JankFlow simplifies the execution of molecular dynamics simulations by -integrating the capabilities of molecular builder packages like GMSO[?] and MBuild[2] -with the HOOMD[1] simulation engine, offering a comprehensive end-to-end simulation recipe development tool. +integrating the capabilities of molecular builder packages like GMSO{@gmso} and MBuild{@snurr_hierarchical_2016} +with the HOOMD{@anderson_hoomd-blue_2019} simulation engine, offering a comprehensive end-to-end simulation recipe development tool. This is accomplished through three building block classes: • Molecule utilizes the mBuild and GMSO packages to initialize chemical @@ -140,7 +140,7 @@ and simulation setup. This class is responsible for arrangement of a mixture of molecules in a box and facilitates the configuration of particle interactions. -• Simulation class employs the HOOMD-blue [1] simulation object, offering +• Simulation class employs the HOOMD-blue simulation object, offering additional strategies and simulation processes tailored to specific research needs. It also facilitates the process of quickly resuming a simulation. From 3fb59e0bb002f9237c89b8b4684b4f41f424bd9d Mon Sep 17 00:00:00 2001 From: marjanalbouye Date: Thu, 5 Oct 2023 13:23:01 -0600 Subject: [PATCH 07/54] add availability section --- paper/paper.md | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/paper/paper.md b/paper/paper.md index 62f1d1e6..03fd1be3 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -156,6 +156,13 @@ more recipes in the future. 1)Welding recipe with example code 2)Tensile recipe with example code +# Availability +JankFlow is freely available under the GNU General Public License (version 3) +on [github](https://github.com/cmelab/JankFlow). For installation instructions, +and Python API documentation +please visit the [documentation](https://jankflow.readthedocs.io/en/latest/). +For examples of how to use JankFlow, +please visit the [tutorials](https://github.com/cmelab/JankFlow/tree/main/tutorials) # Acknowledgements We acknowledge contributions from [ULI Advisory board, NASA, etc] From 260c27070258878d80209d6ddf8f807cf93c38b4 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 5 Oct 2023 19:23:37 +0000 Subject: [PATCH 08/54] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- paper/paper.md | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index 03fd1be3..fab9a179 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -21,7 +21,7 @@ authors: affiliation: 1 - name: Eric Jankowski orcid: 0000-0002-3267-1410 - corresponding: true + corresponding: true affiliation: 1 affiliations: - name: Boise State University, Boise, ID, USA @@ -48,10 +48,10 @@ gogy of molecular simulation by minimizing the cognitive load needed to get started[?]. Most molecular simulations are performed using a combination of tools: -Text editors (to copy and edit plain text files that specify molecular +Text editors (to copy and edit plain text files that specify molecular configurations, forcefield files, simulation engine input files and/or simulation scripts), command-line interfaces for submitting simulations to a local processor or HPC -cluster qeueing system, and numerical analysis and visualization software to +cluster qeueing system, and numerical analysis and visualization software to inspect simulation data. When simulations are set up manually and iteratively, it is difficult to maintain data provenance, that is, a record of what files and choices determine the outputs of a simulation. @@ -75,9 +75,9 @@ an overall workflow tailored to answer a specific research question. However, the challenge of stitching the pieces together to create a complete workflow still contains several barriers. -The computational researcher who follows best practices for accurate, +The computational researcher who follows best practices for accurate, accessible and reproducible results may create a programmatic layer over these -individual software packages (i.e. wrapper) that serves to consolidate and +individual software packages (i.e. wrapper) that serves to consolidate and automate a complete workflow. However, these efforts often use a bespoke approach where the entire workflow design is tailored towards the specific question or project. Design choices might include the materials studied, the model used @@ -96,7 +96,7 @@ mers, surfaces) 5. Pass off the initial topology and forcefield information to a simulation engine -Therefore, the goal of a package that aims to consolidate and automate +Therefore, the goal of a package that aims to consolidate and automate complete workflows should have a TRUE foundational base from which workflows can inherit, making it significantly easier to construct new workflows without starting from scratch. It should be extensible; a workflow from beginning to @@ -107,7 +107,7 @@ allowing workflows to evolve into highly specific applications further down the pipeline, without concerns about design choices limiting or interfering with other use cases. Moreover, the continuous maintenance, updates, and addition of features to this foundational base permeate throughout the library of workflows. If executed thoughtfully and accurately, this enables the creation of a library -of versatile, open-source, and version-controlled workflows. JankFlow is an +of versatile, open-source, and version-controlled workflows. JankFlow is an attempt at making this tool by creating a TRUE base and beginning a library of workflow modules. @@ -125,18 +125,18 @@ workflow modules. # Building Blocks -JankFlow simplifies the execution of molecular dynamics simulations by +JankFlow simplifies the execution of molecular dynamics simulations by integrating the capabilities of molecular builder packages like GMSO{@gmso} and MBuild{@snurr_hierarchical_2016} with the HOOMD{@anderson_hoomd-blue_2019} simulation engine, offering a comprehensive end-to-end simulation recipe development tool. This is accomplished through three building block classes: • Molecule utilizes the mBuild and GMSO packages to initialize chemical structures from a variety of input formats. This class provides methods -for building polymers and copolymer structures and supports straightforward +for building polymers and copolymer structures and supports straightforward coarse-graining process. • System class serves as an intermediary between molecular initialization -and simulation setup. This class is responsible for arrangement of a mixture +and simulation setup. This class is responsible for arrangement of a mixture of molecules in a box and facilitates the configuration of particle interactions. @@ -147,9 +147,9 @@ needs. It also facilitates the process of quickly resuming a simulation. # Recipes The JankFlow package, with its flexible and extendable design, allows users -to utilize its core classes as building blocks, enabling the formulation of +to utilize its core classes as building blocks, enabling the formulation of customized recipes for various molecular simulation processes in accordance with -their specific research needs. To illustrate this process, we offer the two +their specific research needs. To illustrate this process, we offer the two following examples of such recipes in this package, with the expectation of introducing more recipes in the future. @@ -157,13 +157,13 @@ more recipes in the future. 2)Tensile recipe with example code # Availability -JankFlow is freely available under the GNU General Public License (version 3) +JankFlow is freely available under the GNU General Public License (version 3) on [github](https://github.com/cmelab/JankFlow). For installation instructions, -and Python API documentation +and Python API documentation please visit the [documentation](https://jankflow.readthedocs.io/en/latest/). For examples of how to use JankFlow, please visit the [tutorials](https://github.com/cmelab/JankFlow/tree/main/tutorials) # Acknowledgements We acknowledge contributions from [ULI Advisory board, NASA, etc] -# References \ No newline at end of file +# References From c7506dc613797d90be98cca0c513c91ec2466e15 Mon Sep 17 00:00:00 2001 From: marjanalbouye Date: Thu, 5 Oct 2023 13:41:36 -0600 Subject: [PATCH 09/54] summarize bib items --- paper/paper.bib | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/paper/paper.bib b/paper/paper.bib index e58100a4..feb48bce 100644 --- a/paper/paper.bib +++ b/paper/paper.bib @@ -1,5 +1,5 @@ -@article{hayashi_radonpy_2022, +@article{radonpy_2022, title = {{RadonPy}: automated physical property calculation using all-atom classical molecular dynamics simulations for polymer informatics}, volume = {8}, issn = {2057-3960}, @@ -17,7 +17,7 @@ @article{hayashi_radonpy_2022 file = {Hayashi et al. - 2022 - RadonPy automated physical property calculation u.pdf:/home/marjan/Zotero/storage/CV4ZA7SU/Hayashi et al. - 2022 - RadonPy automated physical property calculation u.pdf:application/pdf}, } -@article{thompson_towards_2020, +@article{TRUE_2020, title = {Towards molecular simulations that are transparent, reproducible, usable by others, and extensible ({TRUE})}, volume = {118}, issn = {0026-8976, 1362-3028}, @@ -34,7 +34,7 @@ @article{thompson_towards_2020 file = {Thompson et al. - 2020 - Towards molecular simulations that are transparent.pdf:/home/marjan/Zotero/storage/2R32UBC3/Thompson et al. - 2020 - Towards molecular simulations that are transparent.pdf:application/pdf}, } -@article{hedges_biosimspace_2019, +@article{biosimspace_2019, title = {{BioSimSpace}: An interoperable Python framework for biomolecular simulation}, volume = {4}, issn = {2475-9066}, @@ -68,7 +68,7 @@ @article{shirts_statistically_2008 file = {Shirts and Chodera - 2008 - Statistically optimal analysis of samples from mul.pdf:/home/marjan/Zotero/storage/8W27U635/Shirts and Chodera - 2008 - Statistically optimal analysis of samples from mul.pdf:application/pdf}, } -@article{chodera_use_2007, +@article{chodera_2007, title = {Use of the Weighted Histogram Analysis Method for the Analysis of Simulated and Parallel Tempering Simulations}, volume = {3}, issn = {1549-9618, 1549-9626}, @@ -85,7 +85,7 @@ @article{chodera_use_2007 file = {Chodera et al. - 2007 - Use of the Weighted Histogram Analysis Method for .pdf:/home/marjan/Zotero/storage/L38UQDMW/Chodera et al. - 2007 - Use of the Weighted Histogram Analysis Method for .pdf:application/pdf}, } -@misc{anderson_hoomd-blue_2019, +@misc{hoomd_2019, title = {{HOOMD}-blue: A Python package for high-performance molecular dynamics and hard particle Monte Carlo simulations}, url = {http://arxiv.org/abs/1308.5587}, shorttitle = {{HOOMD}-blue}, @@ -101,7 +101,7 @@ @misc{anderson_hoomd-blue_2019 file = {Anderson et al. - 2019 - HOOMD-blue A Python package for high-performance .pdf:/home/marjan/Zotero/storage/C6IKKZYP/Anderson et al. - 2019 - HOOMD-blue A Python package for high-performance .pdf:application/pdf}, } -@article{grunewald_polyply_2022, +@article{polyply_2022, title = {Polyply; a python suite for facilitating simulations of macromolecules and nanomaterials}, volume = {13}, issn = {2041-1723}, @@ -118,7 +118,7 @@ @article{grunewald_polyply_2022 file = {Grünewald et al. - 2022 - Polyply\; a python suite for facilitating simulatio.pdf:/home/marjan/Zotero/storage/BDEA9LQX/Grünewald et al. - 2022 - Polyply\; a python suite for facilitating simulatio.pdf:application/pdf}, } -@article{pronk_gromacs_2013, +@article{gromacs_2013, title = {{GROMACS} 4.5: a high-throughput and highly parallel open source molecular simulation toolkit}, volume = {29}, issn = {1367-4811, 1367-4803}, @@ -135,7 +135,7 @@ @article{pronk_gromacs_2013 file = {Pronk et al. - 2013 - GROMACS 4.5 a high-throughput and highly parallel.pdf:/home/marjan/Zotero/storage/P3G6GWA3/Pronk et al. - 2013 - GROMACS 4.5 a high-throughput and highly parallel.pdf:application/pdf}, } -@article{hess_gromacs_2008, +@article{gromacs_2008, title = {{GROMACS} 4: Algorithms for Highly Efficient, Load-Balanced, and Scalable Molecular Simulation}, volume = {4}, issn = {1549-9618, 1549-9626}, @@ -153,7 +153,7 @@ @article{hess_gromacs_2008 file = {Hess et al. - 2008 - GROMACS 4 Algorithms for Highly Efficient, Load-B.pdf:/home/marjan/Zotero/storage/S2YWMFVZ/Hess et al. - 2008 - GROMACS 4 Algorithms for Highly Efficient, Load-B.pdf:application/pdf}, } -@article{berendsen_gromacs_1995, +@article{gromacs_1995, title = {{GROMACS}: A message-passing parallel molecular dynamics implementation}, volume = {91}, issn = {00104655}, @@ -171,7 +171,7 @@ @article{berendsen_gromacs_1995 file = {Berendsen et al. - 1995 - GROMACS A message-passing parallel molecular dyna.pdf:/home/marjan/Zotero/storage/NQBQTWNV/Berendsen et al. - 1995 - GROMACS A message-passing parallel molecular dyna.pdf:application/pdf}, } -@article{abraham_gromacs_2015, +@article{gromacs_2015, title = {{GROMACS}: High performance molecular simulations through multi-level parallelism from laptops to supercomputers}, volume = {1-2}, issn = {23527110}, @@ -188,7 +188,7 @@ @article{abraham_gromacs_2015 file = {Abraham et al. - 2015 - GROMACS High performance molecular simulations th.pdf:/home/marjan/Zotero/storage/GS2XGYLP/Abraham et al. - 2015 - GROMACS High performance molecular simulations th.pdf:application/pdf}, } -@incollection{szilard_tackling_2015, +@incollection{Szilárd_gromacs_2015, title = {Tackling Exascale Software Challenges in Molecular Dynamics Simulations with {GROMACS}}, volume = {8759}, url = {http://arxiv.org/abs/1506.00716}, @@ -204,7 +204,7 @@ @incollection{szilard_tackling_2015 file = {Szilárd et al. - 2015 - Tackling Exascale Software Challenges in Molecular.pdf:/home/marjan/Zotero/storage/2888WILV/Szilárd et al. - 2015 - Tackling Exascale Software Challenges in Molecular.pdf:application/pdf}, } -@article{santana-bonilla_modular_2023, +@article{Santana-Bonilla_2023, title = {Modular Software for Generating and Modeling Diverse Polymer Databases}, volume = {63}, issn = {1549-9596, 1549-960X}, @@ -221,7 +221,7 @@ @article{santana-bonilla_modular_2023 file = {Santana-Bonilla et al. - 2023 - Modular Software for Generating and Modeling Diver.pdf:/home/marjan/Zotero/storage/AE3GZU56/Santana-Bonilla et al. - 2023 - Modular Software for Generating and Modeling Diver.pdf:application/pdf}, } -@incollection{snurr_hierarchical_2016, +@incollection{mbuild_2016, location = {Singapore}, title = {A Hierarchical, Component Based Approach to Screening Properties of Soft Matter}, isbn = {978-981-10-1126-9 978-981-10-1128-3}, @@ -239,7 +239,7 @@ @incollection{snurr_hierarchical_2016 file = {Klein et al. - 2016 - A Hierarchical, Component Based Approach to Screen.pdf:/home/marjan/Zotero/storage/FU5HX33B/Klein et al. - 2016 - A Hierarchical, Component Based Approach to Screen.pdf:application/pdf}, } -@article{thompson_lammps_2022, +@article{lammps_2022, title = {{LAMMPS} - a flexible simulation tool for particle-based materials modeling at the atomic, meso, and continuum scales}, volume = {271}, issn = {00104655}, From f30172f97379b6c82b8c205b86cf374af16784c4 Mon Sep 17 00:00:00 2001 From: marjanalbouye Date: Thu, 5 Oct 2023 13:41:47 -0600 Subject: [PATCH 10/54] fix citation --- paper/paper.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index fab9a179..cede48da 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -126,8 +126,9 @@ workflow modules. # Building Blocks JankFlow simplifies the execution of molecular dynamics simulations by -integrating the capabilities of molecular builder packages like GMSO{@gmso} and MBuild{@snurr_hierarchical_2016} -with the HOOMD{@anderson_hoomd-blue_2019} simulation engine, offering a comprehensive end-to-end simulation recipe development tool. +integrating the capabilities of molecular builder packages like GMSO [@gms] and +MBuild [@mbuild_2016] +with the HOOMD [@hoomd_2019] simulation engine, offering a comprehensive end-to-end simulation recipe development tool. This is accomplished through three building block classes: • Molecule utilizes the mBuild and GMSO packages to initialize chemical From 3d086a13f996ce398f5e785b09a13e384bdf6e4b Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 5 Oct 2023 19:42:19 +0000 Subject: [PATCH 11/54] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- paper/paper.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/paper/paper.md b/paper/paper.md index cede48da..b243d6e0 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -126,7 +126,7 @@ workflow modules. # Building Blocks JankFlow simplifies the execution of molecular dynamics simulations by -integrating the capabilities of molecular builder packages like GMSO [@gms] and +integrating the capabilities of molecular builder packages like GMSO [@gms] and MBuild [@mbuild_2016] with the HOOMD [@hoomd_2019] simulation engine, offering a comprehensive end-to-end simulation recipe development tool. This is accomplished through three building block classes: From 2017f6320d230ddab1fce867c38ccf4d020a2f93 Mon Sep 17 00:00:00 2001 From: marjanalbouye Date: Thu, 5 Oct 2023 13:52:10 -0600 Subject: [PATCH 12/54] package name in --- paper/paper.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index cede48da..46253b71 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -1,7 +1,7 @@ --- title: 'JankFlow: A Flexible Python Library for Organic Workflows' tags: - - Python + - molecular simulation - materials science - molecular dynamics - polymers @@ -31,7 +31,7 @@ bibliography: paper.bib --- # Summary -JankFlow is a package for reproducibly performing complex HOOMD-Blue simulation workflows. It enables the programmatic specification of tasks including +`JankFlow` is a package for reproducibly performing complex HOOMD-Blue simulation workflows. It enables the programmatic specification of tasks including definition of molecular structures, forcefield definition and application, chaining together simulation stages (e.g., shrinking, equilibration, simulating a sequence of ensembles, tensile testing), and trajectory analysis through an extensible set @@ -107,7 +107,7 @@ allowing workflows to evolve into highly specific applications further down the pipeline, without concerns about design choices limiting or interfering with other use cases. Moreover, the continuous maintenance, updates, and addition of features to this foundational base permeate throughout the library of workflows. If executed thoughtfully and accurately, this enables the creation of a library -of versatile, open-source, and version-controlled workflows. JankFlow is an +of versatile, open-source, and version-controlled workflows. `JankFlow` is an attempt at making this tool by creating a TRUE base and beginning a library of workflow modules. @@ -125,7 +125,7 @@ workflow modules. # Building Blocks -JankFlow simplifies the execution of molecular dynamics simulations by +`JankFlow` simplifies the execution of molecular dynamics simulations by integrating the capabilities of molecular builder packages like GMSO [@gms] and MBuild [@mbuild_2016] with the HOOMD [@hoomd_2019] simulation engine, offering a comprehensive end-to-end simulation recipe development tool. @@ -147,7 +147,7 @@ needs. It also facilitates the process of quickly resuming a simulation. # Recipes -The JankFlow package, with its flexible and extendable design, allows users +The `JankFlow` package, with its flexible and extendable design, allows users to utilize its core classes as building blocks, enabling the formulation of customized recipes for various molecular simulation processes in accordance with their specific research needs. To illustrate this process, we offer the two @@ -158,11 +158,11 @@ more recipes in the future. 2)Tensile recipe with example code # Availability -JankFlow is freely available under the GNU General Public License (version 3) +`JankFlow` is freely available under the GNU General Public License (version 3) on [github](https://github.com/cmelab/JankFlow). For installation instructions, and Python API documentation please visit the [documentation](https://jankflow.readthedocs.io/en/latest/). -For examples of how to use JankFlow, +For examples of how to use `JankFlow`, please visit the [tutorials](https://github.com/cmelab/JankFlow/tree/main/tutorials) # Acknowledgements We acknowledge contributions from [ULI Advisory board, NASA, etc] From a93b33ec28dcbe5516fba3a207215b1383a552a9 Mon Sep 17 00:00:00 2001 From: chrisjonesbsu Date: Thu, 5 Oct 2023 16:33:13 -0600 Subject: [PATCH 13/54] clean up statement of need --- paper/paper.md | 72 ++++++++++++++++++-------------------------------- 1 file changed, 26 insertions(+), 46 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index b243d6e0..915a0ea0 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -43,42 +43,26 @@ and extensibility. High-level programmatic specification of molecular simulation workflows are needed for two reasons: First: They provide the information necessary for a -simulation study to be repeated, and Second: They facilitate accessible peda- -gogy of molecular simulation by minimizing the cognitive load needed to get -started[?]. - -Most molecular simulations are performed using a combination of tools: -Text editors (to copy and edit plain text files that specify molecular -configurations, forcefield files, simulation engine input files and/or simulation scripts), -command-line interfaces for submitting simulations to a local processor or HPC -cluster qeueing system, and numerical analysis and visualization software to -inspect simulation data. When simulations are set up manually and iteratively, -it is difficult to maintain data provenance, that is, a record of what files and -choices determine the outputs of a simulation. - -Even for simulations of “relatively simple” single-component systems at a -single thermodynamic state point, it is challenging for users to manage records -of which exact forcefield was applied, whether any forcefield parameters were -modified, whether a sequence of short simulations was needed to create the -initial conditions, which microstates were included in analysis, and whether -human intervention occurred at any step to inform the next. Furthermore, for -a researcher new to molecular simulations, the details of generating an initial -condition for a thermodynamic simulation are simultaneously: (a) not germane -to understanding the concept of a simulation overall, (b) crucial to get right so -the researcher can get started, and (c) likely specifyable using community best -practices for configuration initialization. - -Recent advances in well-documented open-source tools [?, ?, ?, ?] have made -the programmatic specification of molecular simulation components easier than -ever. Individually, each of these tools lower the cognitive load of one aspect of -an overall workflow tailored to answer a specific research question. However, -the challenge of stitching the pieces together to create a complete workflow still -contains several barriers. +simulation study to be reproducible, and Second: They minimize the cognitive +load of getting started with running experiments [?]. +For a researcher new to molecular simulations, building the necessary set +of computational tools needed to actually perform experiments simultaneously: +(a) requires skills and knowledge different from those needed to do research, +(b) involves repeating work that others have already done. + +This is a well recognized problem, and recent advances in well-documented +open-source tools have made the programmatic specification of +molecular simulation components easier than ever [? ? ? ?]. +Individually, each of these tools lower the cognitive load of one aspect of an +overall workflow such as representing molecules, building initial structures, +paramaterizing and applying a forcefield, to running simulations. +However, the challenge of stitching the pieces together to create a complete +workflow still contains several barriers. The computational researcher who follows best practices for accurate, accessible and reproducible results may create a programmatic layer over these individual software packages (i.e. wrapper) that serves to consolidate and -automate a complete workflow. However, these efforts often use a bespoke approach +automate a complete workflow [?, ?, ?]. However, these efforts often use a bespoke approach where the entire workflow design is tailored towards the specific question or project. Design choices might include the materials studied, the model used (e.g. atomistic or coarse-grained), the source of the forcefield in the model, and @@ -86,20 +70,16 @@ the simulation protocols followed. As a result, this wrapper is likely unusable for the next project where one of the aforementioned choices changes, and the process of designing a workflow must begin again from scratch. -Regardless of the goal at hand, designing any MD workflow typically involves -the same preliminary steps: -1. Creating molecules. -2. Building up larger, complex compounds from smaller molecules (e.g. poly- -mers, surfaces) -3. Designate the initial structure and topology of a system of compounds. -4. Choose and correctly apply a forcefield to the system. -5. Pass off the initial topology and forcefield information to a simulation -engine - -Therefore, the goal of a package that aims to consolidate and automate -complete workflows should have a TRUE foundational base from which workflows -can inherit, making it significantly easier to construct new workflows without -starting from scratch. It should be extensible; a workflow from beginning to +Software packages such as Radonpy exist that provide an automated workflow for +building molecules and bulk structures to calculating physical properties of polymers. +This doesn't work when modeling complex experimental processes that go beyond measuring +material properties such as fusion weding of polymer interface, surface wetting, [?, ?, ?] + +Jankflow is a python package that consolidates and automates +end-to-end workflows for modeling such processes with a focus on organic molecules. + + +It is extensible; a workflow from beginning to end should not depend on the chemistry chosen, whether or not the model is atomistic or coarse-grained, or if interaction parameters come from established forcefields or from a machine learned model. This tool should be modular, From 74633eb4dbaca9b376e3f70e870d24c748cac5fb Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 5 Oct 2023 22:33:25 +0000 Subject: [PATCH 14/54] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- paper/paper.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index 915a0ea0..1f748aa6 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -70,13 +70,13 @@ the simulation protocols followed. As a result, this wrapper is likely unusable for the next project where one of the aforementioned choices changes, and the process of designing a workflow must begin again from scratch. -Software packages such as Radonpy exist that provide an automated workflow for -building molecules and bulk structures to calculating physical properties of polymers. +Software packages such as Radonpy exist that provide an automated workflow for +building molecules and bulk structures to calculating physical properties of polymers. This doesn't work when modeling complex experimental processes that go beyond measuring material properties such as fusion weding of polymer interface, surface wetting, [?, ?, ?] Jankflow is a python package that consolidates and automates -end-to-end workflows for modeling such processes with a focus on organic molecules. +end-to-end workflows for modeling such processes with a focus on organic molecules. It is extensible; a workflow from beginning to From b0ddbcea8db72f9350e01c764ae72c98eecdb4d7 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 6 Oct 2023 15:45:37 +0000 Subject: [PATCH 15/54] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- paper/paper.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index a229cd85..7a991aed 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -77,9 +77,9 @@ material properties such as fusion weding of polymer interface, surface wetting, Jankflow is a python package that consolidates and automates end-to-end workflows for modeling such processes with a focus on organic molecules. -Following the principals of Transparent, Reproducible, Usable by others, and Extensible (TRUE) [?] +Following the principals of Transparent, Reproducible, Usable by others, and Extensible (TRUE) [?] software design, the modular design of `JankFlow` facilitates building and -running workflows for specific materials science research applications, +running workflows for specific materials science research applications, while reducing the cognitive load and programming demands on the user's part. From 0dfc579d4161809ad8d152b6ecacde969cc570e9 Mon Sep 17 00:00:00 2001 From: chrisjonesBSU Date: Fri, 6 Oct 2023 11:54:40 -0600 Subject: [PATCH 16/54] more progress in recipes and building blocks --- paper/paper.md | 53 +++++++++++++------------------------------------- 1 file changed, 13 insertions(+), 40 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index a229cd85..354e27ae 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -81,7 +81,7 @@ Following the principals of Transparent, Reproducible, Usable by others, and Ext software design, the modular design of `JankFlow` facilitates building and running workflows for specific materials science research applications, while reducing the cognitive load and programming demands on the user's part. - +############### It is extensible; a workflow from beginning to end should not depend on the chemistry chosen, whether or not the model is @@ -95,32 +95,11 @@ of versatile, open-source, and version-controlled workflows. `JankFlow` is an attempt at making this tool by creating a TRUE base and beginning a library of workflow modules. -[//]: # (1-2 sentnces about the popular simulation engines (gromacs, lammps, hoomd,) - -[//]: # (openmm). Gromacs and lammps have lots of cool features, but don’t have rich) - -[//]: # (APIs, and involve text based input files which make it hard to be TRUE. Hoomd) - -[//]: # (and openmm have robust APIs, but don’t have the same level of featureizaiton) - -[//]: # (as lammps and gromacs. This package aims to add a layer of featureizaiton on) - -[//]: # (top of hoomd.) - # Building Blocks `JankFlow` encompasses flexible base classes (building blocks) that lays the -foundations for constructing workflow recipies. Because of this modular design the recipies are agnostic to choices such as chemistry, model resolution -(atomistic or coarse grained) or forcefields. - -For example, the welding workflow (recipie) could be utilized for an atomistic -polyethylene model or coarse grained bead spring model. - - -`JankFlow` simplifies the execution of molecular dynamics simulations by -integrating the capabilities of molecular builder packages like GMSO [@gms] and -MBuild [@mbuild_2016] with the HOOMD [@hoomd_2019] simulation engine, offering a comprehensive end-to-end simulation recipe development tool. -This is accomplished through three building block classes: +foundations for constructing segregated workflow recipies. Because of this modular design the recipies are agnostic to choices such as chemistry, model resolution +(atomistic or coarse grained) or forcefields. This is accomplished by utilizing three base classes: • Molecule utilizes the mBuild and GMSO packages to initialize chemical structures from a variety of input formats. This class provides methods @@ -128,25 +107,19 @@ for building polymers and copolymer structures and supports straightforward coarse-graining process. • System class serves as an intermediary between molecular initialization -and simulation setup. This class is responsible for arrangement of a mixture -of molecules in a box and facilitates the configuration of particle -interactions. - -• Simulation class employs the HOOMD-blue simulation object, offering -additional strategies and simulation processes tailored to specific research -needs. It also facilitates the process of quickly resuming a simulation. +and simulation setup. This class builds the initial configuration and +generates the focefield that defines particle interactions. +• Simulation class adds a layer on top of the HOOMD-blue simulation object, which +adds additional methods and features that simplifies the process of starting and +resuming a HOOMD-blue simulation. -# Recipes -The `JankFlow` package, with its flexible and extendable design, allows users -to utilize its core classes as building blocks, enabling the formulation of -customized recipes for various molecular simulation processes in accordance with -their specific research needs. To illustrate this process, we offer the two -following examples of such recipes in this package, with the expectation of introducing -more recipes in the future. +# Library and Recipes +..... +`JankFlow` offers the following two ready-to-go recipes to illustrate how the design creates potential for expanding the library of workflows. -1)Welding recipe with example code -2)Tensile recipe with example code +• Welding: What does this recipe do. Simulation to create slabs, building up an interface from slabs, simulation to preform welding. +• Tensile Testing # Availability `JankFlow` is freely available under the GNU General Public License (version 3) From 2e2c8fbc0e4210be9f7e287271d98d3f2e2b7e71 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 6 Oct 2023 17:55:00 +0000 Subject: [PATCH 17/54] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- paper/paper.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index 09563839..ecc2d274 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -107,11 +107,11 @@ for building polymers and copolymer structures and supports straightforward coarse-graining process. • System class serves as an intermediary between molecular initialization -and simulation setup. This class builds the initial configuration and +and simulation setup. This class builds the initial configuration and generates the focefield that defines particle interactions. • Simulation class adds a layer on top of the HOOMD-blue simulation object, which -adds additional methods and features that simplifies the process of starting and +adds additional methods and features that simplifies the process of starting and resuming a HOOMD-blue simulation. # Library and Recipes From 08b411cb2d9b3248d692a31e7cc41fc721ed765d Mon Sep 17 00:00:00 2001 From: marjanalbouye Date: Fri, 6 Oct 2023 13:46:44 -0600 Subject: [PATCH 18/54] polishing text --- paper/paper.md | 49 +++++++++++++++++++++---------------------------- 1 file changed, 21 insertions(+), 28 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index ecc2d274..a47ed1f1 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -17,7 +17,7 @@ authors: affiliation: 1 - name: Rainier Barrett orcid: 0000-0002-5728-9074 - corresponding: true + equal-contrib: false affiliation: 1 - name: Eric Jankowski orcid: 0000-0002-3267-1410 @@ -31,13 +31,15 @@ bibliography: paper.bib --- # Summary -`JankFlow` is a package for reproducibly performing complex HOOMD-Blue simulation workflows. It enables the programmatic specification of tasks including -definition of molecular structures, forcefield definition and application, chaining +`JankFlow` is a package for reproducibly performing complex HOOMD-Blue simulation workflows. +It enables the programmatic specification of tasks including +definition of molecular structures, forcefield definition and application and chaining together simulation stages (e.g., shrinking, equilibration, simulating a sequence -of ensembles, tensile testing), and trajectory analysis through an extensible set -of python classes. Common tasks and forcefields for organic macrmolecular and -polymer simulations are included, as are tutorials demonstrating customization -and extensibility. +of ensembles, tensile testing) through an extensible set +of Python classes. The modular design supports a library of complex workflows +for organic macrmolecular and polymer simulations. +Tutorials are provided to demonstrate package features and flexibility. + # Statement of need @@ -78,27 +80,14 @@ material properties such as fusion weding of polymer interface, surface wetting, Jankflow is a python package that consolidates and automates end-to-end workflows for modeling such processes with a focus on organic molecules. Following the principals of Transparent, Reproducible, Usable by others, and Extensible (TRUE) [?] -software design, the modular design of `JankFlow` facilitates building and +software design, the modular design of `JankFlow` facilitates building and running workflows for specific materials science research applications, while reducing the cognitive load and programming demands on the user's part. -############### - -It is extensible; a workflow from beginning to -end should not depend on the chemistry chosen, whether or not the model is -atomistic or coarse-grained, or if interaction parameters come from established -forcefields or from a machine learned model. This tool should be modular, -allowing workflows to evolve into highly specific applications further down the -pipeline, without concerns about design choices limiting or interfering with other -use cases. Moreover, the continuous maintenance, updates, and addition of features to this foundational base permeate throughout the library of workflows. -If executed thoughtfully and accurately, this enables the creation of a library -of versatile, open-source, and version-controlled workflows. `JankFlow` is an -attempt at making this tool by creating a TRUE base and beginning a library of -workflow modules. - # Building Blocks -`JankFlow` encompasses flexible base classes (building blocks) that lays the -foundations for constructing segregated workflow recipies. Because of this modular design the recipies are agnostic to choices such as chemistry, model resolution +`JankFlow` is extensible; flexible and modular base classes in form of building blocks lay the +foundations for constructing segregated workflow recipes designed for specific applications. +The recipes are agnostic to choices such as chemistry, model resolution (atomistic or coarse grained) or forcefields. This is accomplished by utilizing three base classes: • Molecule utilizes the mBuild and GMSO packages to initialize chemical @@ -114,11 +103,15 @@ generates the focefield that defines particle interactions. adds additional methods and features that simplifies the process of starting and resuming a HOOMD-blue simulation. -# Library and Recipes -..... -`JankFlow` offers the following two ready-to-go recipes to illustrate how the design creates potential for expanding the library of workflows. +Additionally, `JankFlow` offers a library pre-defined subclasses of the above base classes +including common polymers, forcefields and bulk system initialization algorithms. + +# Recipes +`JankFlow` offers the following two ready-to-go recipes to illustrate how the design creates +potential for expanding the library of open-source and version-controlled workflows. -• Welding: What does this recipe do. Simulation to create slabs, building up an interface from slabs, simulation to preform welding. +• Welding: What does this recipe do. Simulation to create slabs, building up an +interface from slabs, simulation to preform welding. • Tensile Testing # Availability From d1d68de5982a391577398df884fe641e38446cf6 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 6 Oct 2023 19:47:04 +0000 Subject: [PATCH 19/54] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- paper/paper.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index a47ed1f1..9cbd05d5 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -37,8 +37,8 @@ definition of molecular structures, forcefield definition and application and ch together simulation stages (e.g., shrinking, equilibration, simulating a sequence of ensembles, tensile testing) through an extensible set of Python classes. The modular design supports a library of complex workflows -for organic macrmolecular and polymer simulations. -Tutorials are provided to demonstrate package features and flexibility. +for organic macrmolecular and polymer simulations. +Tutorials are provided to demonstrate package features and flexibility. # Statement of need @@ -86,7 +86,7 @@ while reducing the cognitive load and programming demands on the user's part. # Building Blocks `JankFlow` is extensible; flexible and modular base classes in form of building blocks lay the -foundations for constructing segregated workflow recipes designed for specific applications. +foundations for constructing segregated workflow recipes designed for specific applications. The recipes are agnostic to choices such as chemistry, model resolution (atomistic or coarse grained) or forcefields. This is accomplished by utilizing three base classes: @@ -104,13 +104,13 @@ adds additional methods and features that simplifies the process of starting and resuming a HOOMD-blue simulation. Additionally, `JankFlow` offers a library pre-defined subclasses of the above base classes -including common polymers, forcefields and bulk system initialization algorithms. +including common polymers, forcefields and bulk system initialization algorithms. # Recipes -`JankFlow` offers the following two ready-to-go recipes to illustrate how the design creates +`JankFlow` offers the following two ready-to-go recipes to illustrate how the design creates potential for expanding the library of open-source and version-controlled workflows. -• Welding: What does this recipe do. Simulation to create slabs, building up an +• Welding: What does this recipe do. Simulation to create slabs, building up an interface from slabs, simulation to preform welding. • Tensile Testing From c79677ca723ef694a92c77a26e027a3e1cb2e0ac Mon Sep 17 00:00:00 2001 From: marjanalbouye Date: Fri, 6 Oct 2023 14:22:25 -0600 Subject: [PATCH 20/54] add code block for welding and tensile --- paper/paper.md | 43 ++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 42 insertions(+), 1 deletion(-) diff --git a/paper/paper.md b/paper/paper.md index 9cbd05d5..404fb0b7 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -57,7 +57,7 @@ open-source tools have made the programmatic specification of molecular simulation components easier than ever [? ? ? ?]. Individually, each of these tools lower the cognitive load of one aspect of an overall workflow such as representing molecules, building initial structures, -paramaterizing and applying a forcefield, to running simulations. +parameterizing and applying a forcefield, to running simulations. However, the challenge of stitching the pieces together to create a complete workflow still contains several barriers. @@ -113,6 +113,47 @@ potential for expanding the library of open-source and version-controlled workfl • Welding: What does this recipe do. Simulation to create slabs, building up an interface from slabs, simulation to preform welding. • Tensile Testing +```python +from jankflow.library import PolyEthylene, OPLS_AA, Tensile +from jankflow.base import Pack +from jankflow.modules.welding import SlabSimulation, Interface, WeldSimulation + +# initialize a polymer system using poly(ethylene) and OPLS-AA forcefield +molecule = PolyEthylene(num_mols=30, lengths=12) +system = Pack(molecules=molecule, density=1.1) +system.apply_forcefield(r_cut=2.5, force_field=OPLS_AA(), auto_scale=True, + remove_charges=True, remove_hydrogens=True) +# saving forces for later use +hoomd_forces = system.hoomd_forcefield +# run a slab simulation +sim = SlabSimulation.from_system(system=system, interface_axis=(1, 0, 0), + gsd_file_name="slab_x_interface.gsd") +# shrink the box to reach the desired density +sim.run_update_volume(final_density=1.2, n_steps=5e4, kT=5.0, period=100, + tau_kt=0.001) +# run NVT ensemble +sim.run_NVT(kT=5.0, n_steps=4e4, tau_kt=0.001) + +# create an interface from the slab +interface = Interface(gsd_file="slab_x_interface.gsd", interface_axis=(1, 0, 0), + gap=0.05) +# run the welding simulation +weld_sim = WeldSimulation(initial_state=interface.hoomd_snapshot, + forcefield=hoomd_forces, interface_axis=(1, 0, 0), + gsd_file_name="weld.gsd", log_file_name="weld_log.txt", + log_write_freq=500, dt=0.0003) +weld_sim.run_NVT(kT=10.0, n_steps=7e4, tau_kt=0.001) +cooling_ramp = weld_sim.temperature_ramp(n_steps=2e4, kT_start=10.0, kT_final=2.0) +weld_sim.run_NVT(kT=cooling_ramp, n_steps=2e4, tau_kt=0.001) +weld_sim.save_restart_gsd("weld_restart.gsd") +# Running a tensile test simulation +tensile_sim = Tensile(initial_state="weld_restart.gsd", forcefield=hoomd_forces, + tensile_axis=(1,0,0), gsd_file_name="tensile.gsd", + gsd_write_freq=1000, log_file_name="tensile_log.txt", + log_write_freq=500, fix_ratio=0.30) +tensile_sim.run_tensile(n_steps=1e5, strain=0.70, period=500, kT=2.0, tau_kt=0.001) +# for more details on the tensile test results, please see the tutorials. +``` # Availability `JankFlow` is freely available under the GNU General Public License (version 3) From 97dccfa2d8894dc5e89fcece2bf401d7be19a9de Mon Sep 17 00:00:00 2001 From: marjanalbouye Date: Fri, 6 Oct 2023 14:24:24 -0600 Subject: [PATCH 21/54] add code block for welding and tensile --- paper/paper.md | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index 404fb0b7..83f17166 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -127,16 +127,15 @@ system.apply_forcefield(r_cut=2.5, force_field=OPLS_AA(), auto_scale=True, hoomd_forces = system.hoomd_forcefield # run a slab simulation sim = SlabSimulation.from_system(system=system, interface_axis=(1, 0, 0), - gsd_file_name="slab_x_interface.gsd") + gsd_file_name="slab.gsd") # shrink the box to reach the desired density -sim.run_update_volume(final_density=1.2, n_steps=5e4, kT=5.0, period=100, - tau_kt=0.001) +sim.run_update_volume(final_density=1.2, n_steps=5e4, kT=5.0, + period=100, tau_kt=0.001) # run NVT ensemble sim.run_NVT(kT=5.0, n_steps=4e4, tau_kt=0.001) # create an interface from the slab -interface = Interface(gsd_file="slab_x_interface.gsd", interface_axis=(1, 0, 0), - gap=0.05) +interface = Interface(gsd_file="slab.gsd", interface_axis=(1, 0, 0), gap=0.05) # run the welding simulation weld_sim = WeldSimulation(initial_state=interface.hoomd_snapshot, forcefield=hoomd_forces, interface_axis=(1, 0, 0), From 7d75d2c01190d87859c53a7b7d491172974a4065 Mon Sep 17 00:00:00 2001 From: marjanalbouye Date: Fri, 6 Oct 2023 14:43:56 -0600 Subject: [PATCH 22/54] add citations --- paper/paper.md | 27 +++++++++++++++------------ 1 file changed, 15 insertions(+), 12 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index 83f17166..32801443 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -31,14 +31,14 @@ bibliography: paper.bib --- # Summary -`JankFlow` is a package for reproducibly performing complex HOOMD-Blue simulation workflows. -It enables the programmatic specification of tasks including +`JankFlow` is a package for reproducibly performing complex HOOMD-blue [@hoomd_2019] +simulation workflows. It enables the programmatic specification of tasks including definition of molecular structures, forcefield definition and application and chaining together simulation stages (e.g., shrinking, equilibration, simulating a sequence -of ensembles, tensile testing) through an extensible set -of Python classes. The modular design supports a library of complex workflows -for organic macrmolecular and polymer simulations. -Tutorials are provided to demonstrate package features and flexibility. +of ensembles, tensile testing) through an extensible set of Python classes. +The modular design supports a library of complex workflows for organic +macrmolecular and polymer simulations. Tutorials are provided to demonstrate +package features and flexibility. # Statement of need @@ -54,7 +54,9 @@ of computational tools needed to actually perform experiments simultaneously: This is a well recognized problem, and recent advances in well-documented open-source tools have made the programmatic specification of -molecular simulation components easier than ever [? ? ? ?]. +molecular simulation components easier than ever +[@hoomd_2019, @lammps_2022, @gromacs_2015, @mbuild_2016, @gmso, +@Santana-Bonilla_2023, @polyply_2022, @biosimspace_2019]. Individually, each of these tools lower the cognitive load of one aspect of an overall workflow such as representing molecules, building initial structures, parameterizing and applying a forcefield, to running simulations. @@ -72,14 +74,15 @@ the simulation protocols followed. As a result, this wrapper is likely unusable for the next project where one of the aforementioned choices changes, and the process of designing a workflow must begin again from scratch. -Software packages such as Radonpy exist that provide an automated workflow for +Software packages such as Radonpy [@radonpy_2022] exist that provide an automated workflow for building molecules and bulk structures to calculating physical properties of polymers. -This doesn't work when modeling complex experimental processes that go beyond measuring -material properties such as fusion weding of polymer interface, surface wetting, [?, ?, ?] +However, these tools may not be suitable for modeling complex experimental +processes that extend beyond measuring material properties, such as +simulating fusion welding of polymer interfaces [@?] and surface wetting [@]. Jankflow is a python package that consolidates and automates end-to-end workflows for modeling such processes with a focus on organic molecules. -Following the principals of Transparent, Reproducible, Usable by others, and Extensible (TRUE) [?] +Following the principals of Transparent, Reproducible, Usable by others, and Extensible (TRUE) [@TRUE_2020] software design, the modular design of `JankFlow` facilitates building and running workflows for specific materials science research applications, while reducing the cognitive load and programming demands on the user's part. @@ -133,7 +136,7 @@ sim.run_update_volume(final_density=1.2, n_steps=5e4, kT=5.0, period=100, tau_kt=0.001) # run NVT ensemble sim.run_NVT(kT=5.0, n_steps=4e4, tau_kt=0.001) - +sim.operations.writers[0].flush() # create an interface from the slab interface = Interface(gsd_file="slab.gsd", interface_axis=(1, 0, 0), gap=0.05) # run the welding simulation From c280bcfff8b047384bcf033c39a4fa8f04aca9de Mon Sep 17 00:00:00 2001 From: marjanalbouye Date: Fri, 6 Oct 2023 15:36:35 -0600 Subject: [PATCH 23/54] add new citations --- paper/paper.bib | 80 +++++++++++++++++++++++++++++++++++++++---------- paper/paper.md | 3 +- 2 files changed, 66 insertions(+), 17 deletions(-) diff --git a/paper/paper.bib b/paper/paper.bib index feb48bce..d1344bd9 100644 --- a/paper/paper.bib +++ b/paper/paper.bib @@ -14,7 +14,6 @@ @article{radonpy_2022 urldate = {2023-09-26}, date = {2022-11-08}, langid = {english}, - file = {Hayashi et al. - 2022 - RadonPy automated physical property calculation u.pdf:/home/marjan/Zotero/storage/CV4ZA7SU/Hayashi et al. - 2022 - RadonPy automated physical property calculation u.pdf:application/pdf}, } @article{TRUE_2020, @@ -31,7 +30,6 @@ @article{TRUE_2020 urldate = {2023-09-27}, date = {2020-06-01}, langid = {english}, - file = {Thompson et al. - 2020 - Towards molecular simulations that are transparent.pdf:/home/marjan/Zotero/storage/2R32UBC3/Thompson et al. - 2020 - Towards molecular simulations that are transparent.pdf:application/pdf}, } @article{biosimspace_2019, @@ -49,7 +47,6 @@ @article{biosimspace_2019 urldate = {2023-09-27}, date = {2019-11-22}, langid = {english}, - file = {Hedges et al. - 2019 - BioSimSpace An interoperable Python framework for.pdf:/home/marjan/Zotero/storage/V89VIW2E/Hedges et al. - 2019 - BioSimSpace An interoperable Python framework for.pdf:application/pdf}, } @article{shirts_statistically_2008, @@ -65,7 +62,6 @@ @article{shirts_statistically_2008 urldate = {2023-10-02}, date = {2008-09-28}, langid = {english}, - file = {Shirts and Chodera - 2008 - Statistically optimal analysis of samples from mul.pdf:/home/marjan/Zotero/storage/8W27U635/Shirts and Chodera - 2008 - Statistically optimal analysis of samples from mul.pdf:application/pdf}, } @article{chodera_2007, @@ -82,7 +78,6 @@ @article{chodera_2007 urldate = {2023-10-02}, date = {2007-01-01}, langid = {english}, - file = {Chodera et al. - 2007 - Use of the Weighted Histogram Analysis Method for .pdf:/home/marjan/Zotero/storage/L38UQDMW/Chodera et al. - 2007 - Use of the Weighted Histogram Analysis Method for .pdf:application/pdf}, } @misc{hoomd_2019, @@ -98,7 +93,6 @@ @misc{hoomd_2019 eprinttype = {arxiv}, eprint = {1308.5587 [physics]}, keywords = {Physics - Computational Physics}, - file = {Anderson et al. - 2019 - HOOMD-blue A Python package for high-performance .pdf:/home/marjan/Zotero/storage/C6IKKZYP/Anderson et al. - 2019 - HOOMD-blue A Python package for high-performance .pdf:application/pdf}, } @article{polyply_2022, @@ -115,7 +109,6 @@ @article{polyply_2022 urldate = {2023-10-03}, date = {2022-01-10}, langid = {english}, - file = {Grünewald et al. - 2022 - Polyply\; a python suite for facilitating simulatio.pdf:/home/marjan/Zotero/storage/BDEA9LQX/Grünewald et al. - 2022 - Polyply\; a python suite for facilitating simulatio.pdf:application/pdf}, } @article{gromacs_2013, @@ -132,7 +125,6 @@ @article{gromacs_2013 urldate = {2023-10-03}, date = {2013-04-01}, langid = {english}, - file = {Pronk et al. - 2013 - GROMACS 4.5 a high-throughput and highly parallel.pdf:/home/marjan/Zotero/storage/P3G6GWA3/Pronk et al. - 2013 - GROMACS 4.5 a high-throughput and highly parallel.pdf:application/pdf}, } @article{gromacs_2008, @@ -150,7 +142,6 @@ @article{gromacs_2008 urldate = {2023-10-03}, date = {2008-03-01}, langid = {english}, - file = {Hess et al. - 2008 - GROMACS 4 Algorithms for Highly Efficient, Load-B.pdf:/home/marjan/Zotero/storage/S2YWMFVZ/Hess et al. - 2008 - GROMACS 4 Algorithms for Highly Efficient, Load-B.pdf:application/pdf}, } @article{gromacs_1995, @@ -168,7 +159,6 @@ @article{gromacs_1995 urldate = {2023-10-03}, date = {1995-09}, langid = {english}, - file = {Berendsen et al. - 1995 - GROMACS A message-passing parallel molecular dyna.pdf:/home/marjan/Zotero/storage/NQBQTWNV/Berendsen et al. - 1995 - GROMACS A message-passing parallel molecular dyna.pdf:application/pdf}, } @article{gromacs_2015, @@ -185,7 +175,6 @@ @article{gromacs_2015 urldate = {2023-10-03}, date = {2015-09}, langid = {english}, - file = {Abraham et al. - 2015 - GROMACS High performance molecular simulations th.pdf:/home/marjan/Zotero/storage/GS2XGYLP/Abraham et al. - 2015 - GROMACS High performance molecular simulations th.pdf:application/pdf}, } @incollection{Szilárd_gromacs_2015, @@ -201,7 +190,6 @@ @incollection{Szilárd_gromacs_2015 eprinttype = {arxiv}, eprint = {1506.00716 [cs]}, keywords = {Computer Science - Computational Engineering, Finance, and Science, I.6.8, J.2}, - file = {Szilárd et al. - 2015 - Tackling Exascale Software Challenges in Molecular.pdf:/home/marjan/Zotero/storage/2888WILV/Szilárd et al. - 2015 - Tackling Exascale Software Challenges in Molecular.pdf:application/pdf}, } @article{Santana-Bonilla_2023, @@ -218,7 +206,6 @@ @article{Santana-Bonilla_2023 urldate = {2023-10-03}, date = {2023-06-26}, langid = {english}, - file = {Santana-Bonilla et al. - 2023 - Modular Software for Generating and Modeling Diver.pdf:/home/marjan/Zotero/storage/AE3GZU56/Santana-Bonilla et al. - 2023 - Modular Software for Generating and Modeling Diver.pdf:application/pdf}, } @incollection{mbuild_2016, @@ -236,7 +223,6 @@ @incollection{mbuild_2016 langid = {english}, doi = {10.1007/978-981-10-1128-3_5}, note = {Series Title: Molecular Modeling and Simulation}, - file = {Klein et al. - 2016 - A Hierarchical, Component Based Approach to Screen.pdf:/home/marjan/Zotero/storage/FU5HX33B/Klein et al. - 2016 - A Hierarchical, Component Based Approach to Screen.pdf:application/pdf}, } @article{lammps_2022, @@ -252,7 +238,6 @@ @article{lammps_2022 urldate = {2023-10-05}, date = {2022-02}, langid = {english}, - file = {Thompson et al. - 2022 - LAMMPS - a flexible simulation tool for particle-b.pdf:/home/marjan/Zotero/storage/YY2CV6SA/Thompson et al. - 2022 - LAMMPS - a flexible simulation tool for particle-b.pdf:application/pdf}, } @software{gmso, @@ -260,3 +245,68 @@ @software{gmso url = {https://gmso.mosdef.org/en/stable/}, publisher = {mosdef-hub, Vanderbilt University}, } + +@article{aggarwal_molecular_2020, + title = {Molecular dynamics studies on the strength and ductility of symmetric thermally welded joints}, + issn = {0965-0393, 1361-651X}, + url = {https://iopscience.iop.org/article/10.1088/1361-651X/ab6a44}, + doi = {10.1088/1361-651X/ab6a44}, + journaltitle = {Modelling and Simulation in Materials Science and Engineering}, + shortjournal = {Modelling Simul. Mater. Sci. Eng.}, + author = {Aggarwal, Ishu and Paul, Saptarshi and Sinha, Nishant K and Basu, Sumit}, + urldate = {2023-08-09}, + date = {2020-01-10}, + langid = {english}, +} + +@article{bukowski_load-bearing_2021, + title = {Load-bearing entanglements in polymer glasses}, + volume = {7}, + issn = {2375-2548}, + url = {https://www.science.org/doi/10.1126/sciadv.abg9763}, + doi = {10.1126/sciadv.abg9763}, + pages = {eabg9763}, + number = {38}, + journaltitle = {Science Advances}, + shortjournal = {Sci. Adv.}, + author = {Bukowski, Cynthia and Zhang, Tianren and Riggleman, Robert A. and Crosby, Alfred J.}, + urldate = {2023-10-06}, + date = {2021-09-17}, + langid = {english}, +} + +@article{fan_wetting_1995, + title = {Wetting of crystalline polymer surfaces: A molecular dynamics simulation}, + volume = {103}, + issn = {0021-9606, 1089-7690}, + url = {https://pubs.aip.org/jcp/article/103/20/9053/179676/Wetting-of-crystalline-polymer-surfaces-A}, + doi = {10.1063/1.470016}, + shorttitle = {Wetting of crystalline polymer surfaces}, + abstract = {Molecular dynamics has been used to study the wetting of model polymer surfaces, the crystal surfaces of polyethylene ({PE}), poly(tetrafluoroethylene) ({PTFE}), and poly(ethylene terephthalate) ({PET}) by water and methylene iodide. In the simulation a liquid droplet is placed on a model surface and constant temperature, rigid body molecular dynamics is carried out while the model surface is kept fixed. A generally defined microscopic contact angle between a liquid droplet and a solid surface is quantitatively calculated from the volume of the droplet and the interfacial area between the droplet and the surface. The simulation results agree with the trend in experimental data for both water and methylene iodide. The shape of the droplets on the surface is analyzed and no obvious anisotropy of the droplets is seen in the surface plane, even though the crystal surfaces are highly oriented. The surface free energies of the model polymer surfaces are estimated from their contact angles with the two different liquid droplets.}, + pages = {9053--9061}, + number = {20}, + journaltitle = {The Journal of Chemical Physics}, + author = {Fan, Cun Feng and Caǧin, Tahir}, + urldate = {2023-10-06}, + date = {1995-11-22}, + langid = {english}, + file = {Accepted Version:/home/marjan/Zotero/storage/X8LJLYKB/Fan and Caǧin - 1995 - Wetting of crystalline polymer surfaces A molecul.pdf:application/pdf}, +} + +@article{bamane_wetting_2021, + title = {Wetting Simulations of High-Performance Polymer Resins on Carbon Surfaces as a Function of Temperature Using Molecular Dynamics}, + volume = {13}, + issn = {2073-4360}, + url = {https://www.mdpi.com/2073-4360/13/13/2162}, + doi = {10.3390/polym13132162}, + abstract = {Resin/reinforcement wetting is a key parameter in the manufacturing of carbon nanotube ({CNT})-based composite materials. Determining the contact angle between combinations of liquid resin and reinforcement surfaces is a common method for quantifying wettability. As experimental measurement of contact angle can be difficult when screening multiple high-performance resins with {CNT} materials such as {CNT} bundles or yarns, computational approaches are necessary to facilitate {CNT} composite material design. A molecular dynamics simulation method is developed to predict the contact angle of high-performance polymer resins on {CNT} surfaces dominated by aromatic carbon, aliphatic carbon, or a mixture thereof (amorphous carbon). Several resin systems are simulated and compared. The results indicate that the monomer chain length, chemical groups on the monomer, and simulation temperature have a significant impact on the predicted contact angle values on the {CNT} surface. Difunctional epoxy and cyanate ester resins show the overall highest levels of wettability, regardless of the aromatic/aliphatic nature of the {CNT} material surface. Tetrafunctional epoxy demonstrates excellent wettability on aliphatic-dominated surfaces at elevated temperatures. Bismaleimide and benzoxazine resins show intermediate levels of wetting, while typical molecular weights of polyether ether ketone demonstrate poor wetting on the {CNT} surfaces.}, + pages = {2162}, + number = {13}, + journaltitle = {Polymers}, + shortjournal = {Polymers}, + author = {Bamane, Swapnil S. and Gaikwad, Prashik S. and Radue, Matthew S. and Gowtham, S. and Odegard, Gregory M.}, + urldate = {2023-10-06}, + date = {2021-06-30}, + langid = {english}, + file = {Bamane et al. - 2021 - Wetting Simulations of High-Performance Polymer Re.pdf:/home/marjan/Zotero/storage/JPFTYNU9/Bamane et al. - 2021 - Wetting Simulations of High-Performance Polymer Re.pdf:application/pdf}, +} diff --git a/paper/paper.md b/paper/paper.md index 32801443..3e699fd9 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -28,7 +28,6 @@ affiliations: index: 1 date: 01 January 2001 bibliography: paper.bib - --- # Summary `JankFlow` is a package for reproducibly performing complex HOOMD-blue [@hoomd_2019] @@ -80,7 +79,7 @@ However, these tools may not be suitable for modeling complex experimental processes that extend beyond measuring material properties, such as simulating fusion welding of polymer interfaces [@?] and surface wetting [@]. -Jankflow is a python package that consolidates and automates +`JankFlow` is a python package that consolidates and automates end-to-end workflows for modeling such processes with a focus on organic molecules. Following the principals of Transparent, Reproducible, Usable by others, and Extensible (TRUE) [@TRUE_2020] software design, the modular design of `JankFlow` facilitates building and From f83a6b796253d78a2d89ef2a9c00cd701f1ea7c9 Mon Sep 17 00:00:00 2001 From: marjanalbouye Date: Fri, 6 Oct 2023 15:36:52 -0600 Subject: [PATCH 24/54] add wetting and welding citations --- paper/paper.md | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index 3e699fd9..d58edb7f 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -65,7 +65,7 @@ workflow still contains several barriers. The computational researcher who follows best practices for accurate, accessible and reproducible results may create a programmatic layer over these individual software packages (i.e. wrapper) that serves to consolidate and -automate a complete workflow [?, ?, ?]. However, these efforts often use a bespoke approach +automate a complete workflow. However, these efforts often use a bespoke approach where the entire workflow design is tailored towards the specific question or project. Design choices might include the materials studied, the model used (e.g. atomistic or coarse-grained), the source of the forcefield in the model, and @@ -77,7 +77,9 @@ Software packages such as Radonpy [@radonpy_2022] exist that provide an automate building molecules and bulk structures to calculating physical properties of polymers. However, these tools may not be suitable for modeling complex experimental processes that extend beyond measuring material properties, such as -simulating fusion welding of polymer interfaces [@?] and surface wetting [@]. +simulating fusion welding of polymer interfaces +[@aggarwal_molecular_2020, @bukowski_load-bearing_2021] and surface wetting +[@fan_wetting_1995, bamane_wetting_2021]. `JankFlow` is a python package that consolidates and automates end-to-end workflows for modeling such processes with a focus on organic molecules. @@ -92,7 +94,7 @@ foundations for constructing segregated workflow recipes designed for specific a The recipes are agnostic to choices such as chemistry, model resolution (atomistic or coarse grained) or forcefields. This is accomplished by utilizing three base classes: -• Molecule utilizes the mBuild and GMSO packages to initialize chemical +• Molecule utilizes the mBuild [@mbuild_2016] and GMSO [@gmso] packages to initialize chemical structures from a variety of input formats. This class provides methods for building polymers and copolymer structures and supports straightforward coarse-graining process. From fa5d8474424bd12ab8f9f4d792e8303da1ddf5f3 Mon Sep 17 00:00:00 2001 From: Marjan Date: Mon, 9 Oct 2023 08:58:04 -0600 Subject: [PATCH 25/54] minor fixes --- paper/paper.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index d58edb7f..39c0fa7c 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -34,7 +34,7 @@ bibliography: paper.bib simulation workflows. It enables the programmatic specification of tasks including definition of molecular structures, forcefield definition and application and chaining together simulation stages (e.g., shrinking, equilibration, simulating a sequence -of ensembles, tensile testing) through an extensible set of Python classes. +of ensembles, tensile testing, etc.) through an extensible set of Python classes. The modular design supports a library of complex workflows for organic macrmolecular and polymer simulations. Tutorials are provided to demonstrate package features and flexibility. @@ -94,16 +94,16 @@ foundations for constructing segregated workflow recipes designed for specific a The recipes are agnostic to choices such as chemistry, model resolution (atomistic or coarse grained) or forcefields. This is accomplished by utilizing three base classes: -• Molecule utilizes the mBuild [@mbuild_2016] and GMSO [@gmso] packages to initialize chemical +• `Molecule` class utilizes the mBuild [@mbuild_2016] and GMSO [@gmso] packages to initialize chemical structures from a variety of input formats. This class provides methods for building polymers and copolymer structures and supports straightforward coarse-graining process. -• System class serves as an intermediary between molecular initialization +• `System` class serves as an intermediary between molecular initialization and simulation setup. This class builds the initial configuration and generates the focefield that defines particle interactions. -• Simulation class adds a layer on top of the HOOMD-blue simulation object, which +• `Simulation` class adds a layer on top of the HOOMD-blue simulation object, which adds additional methods and features that simplifies the process of starting and resuming a HOOMD-blue simulation. From 4e98fa9a8e7c0a7d16dc1dfbcbff1ff6bc3bf9f4 Mon Sep 17 00:00:00 2001 From: Marjan Date: Mon, 9 Oct 2023 09:09:33 -0600 Subject: [PATCH 26/54] add yml file for creating joss pdf --- .github/workflows/draft-pdf.yml | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 .github/workflows/draft-pdf.yml diff --git a/.github/workflows/draft-pdf.yml b/.github/workflows/draft-pdf.yml new file mode 100644 index 00000000..f85b711e --- /dev/null +++ b/.github/workflows/draft-pdf.yml @@ -0,0 +1,23 @@ +on: [push] + +jobs: + paper: + runs-on: ubuntu-latest + name: Paper Draft + steps: + - name: Checkout + uses: actions/checkout@v3 + - name: Build draft PDF + uses: openjournals/openjournals-draft-action@master + with: + journal: joss + # This should be the path to the paper within your repo. + paper-path: paper/paper.md + - name: Upload + uses: actions/upload-artifact@v1 + with: + name: paper + # This is the output path where Pandoc will write the compiled + # PDF. Note, this should be the same directory as the input + # paper.md + path: paper/paper.pdf From 749d62dd9254ba84986d65776b509076e1f27152 Mon Sep 17 00:00:00 2001 From: Marjan Albooyeh Date: Mon, 9 Oct 2023 09:29:48 -0600 Subject: [PATCH 27/54] add branch name to yml file --- .github/workflows/draft-pdf.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.github/workflows/draft-pdf.yml b/.github/workflows/draft-pdf.yml index f85b711e..cb726039 100644 --- a/.github/workflows/draft-pdf.yml +++ b/.github/workflows/draft-pdf.yml @@ -1,4 +1,6 @@ -on: [push] +on: + push: + branches: [joss] jobs: paper: From a917502ec9ae986b7cc7c7189745f44a1712c217 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 9 Oct 2023 15:29:58 +0000 Subject: [PATCH 28/54] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- .github/workflows/draft-pdf.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/draft-pdf.yml b/.github/workflows/draft-pdf.yml index cb726039..665727c2 100644 --- a/.github/workflows/draft-pdf.yml +++ b/.github/workflows/draft-pdf.yml @@ -1,4 +1,4 @@ -on: +on: push: branches: [joss] From a9bd420a29a9d6dbff94c37adf8f2eb5621ef034 Mon Sep 17 00:00:00 2001 From: Marjan Albooyeh Date: Mon, 9 Oct 2023 09:39:47 -0600 Subject: [PATCH 29/54] add pull_request flag --- .github/workflows/draft-pdf.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.github/workflows/draft-pdf.yml b/.github/workflows/draft-pdf.yml index 665727c2..820ee350 100644 --- a/.github/workflows/draft-pdf.yml +++ b/.github/workflows/draft-pdf.yml @@ -1,6 +1,8 @@ on: push: branches: [joss] + pull_request: + branches: [ joss ] jobs: paper: From 3373db663f3ff0a5834adcf49ae1ec20456f5230 Mon Sep 17 00:00:00 2001 From: marjanalbouye Date: Tue, 10 Oct 2023 12:52:06 -0600 Subject: [PATCH 30/54] change package title in paper.md --- paper/paper.md | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index 39c0fa7c..d6251bbb 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -1,5 +1,5 @@ --- -title: 'JankFlow: A Flexible Python Library for Organic Workflows' +title: 'FlowerMD: Flexible Library of Organic Workflows and Extensible Recipes for Molecular Dynamics' tags: - molecular simulation - materials science @@ -30,7 +30,7 @@ date: 01 January 2001 bibliography: paper.bib --- # Summary -`JankFlow` is a package for reproducibly performing complex HOOMD-blue [@hoomd_2019] +`flowerMD` is a package for reproducibly performing complex HOOMD-blue [@hoomd_2019] simulation workflows. It enables the programmatic specification of tasks including definition of molecular structures, forcefield definition and application and chaining together simulation stages (e.g., shrinking, equilibration, simulating a sequence @@ -81,15 +81,15 @@ simulating fusion welding of polymer interfaces [@aggarwal_molecular_2020, @bukowski_load-bearing_2021] and surface wetting [@fan_wetting_1995, bamane_wetting_2021]. -`JankFlow` is a python package that consolidates and automates +`flowerMD` is a python package that consolidates and automates end-to-end workflows for modeling such processes with a focus on organic molecules. Following the principals of Transparent, Reproducible, Usable by others, and Extensible (TRUE) [@TRUE_2020] -software design, the modular design of `JankFlow` facilitates building and +software design, the modular design of `flowerMD` facilitates building and running workflows for specific materials science research applications, while reducing the cognitive load and programming demands on the user's part. # Building Blocks -`JankFlow` is extensible; flexible and modular base classes in form of building blocks lay the +`flowerMD` is extensible; flexible and modular base classes in form of building blocks lay the foundations for constructing segregated workflow recipes designed for specific applications. The recipes are agnostic to choices such as chemistry, model resolution (atomistic or coarse grained) or forcefields. This is accomplished by utilizing three base classes: @@ -107,20 +107,20 @@ generates the focefield that defines particle interactions. adds additional methods and features that simplifies the process of starting and resuming a HOOMD-blue simulation. -Additionally, `JankFlow` offers a library pre-defined subclasses of the above base classes +Additionally, `flowerMD` offers a library pre-defined subclasses of the above base classes including common polymers, forcefields and bulk system initialization algorithms. # Recipes -`JankFlow` offers the following two ready-to-go recipes to illustrate how the design creates +`flowerMD` offers the following two ready-to-go recipes to illustrate how the design creates potential for expanding the library of open-source and version-controlled workflows. • Welding: What does this recipe do. Simulation to create slabs, building up an interface from slabs, simulation to preform welding. • Tensile Testing ```python -from jankflow.library import PolyEthylene, OPLS_AA, Tensile -from jankflow.base import Pack -from jankflow.modules.welding import SlabSimulation, Interface, WeldSimulation +from flowermd.library import PolyEthylene, OPLS_AA, Tensile +from flowermd.base import Pack +from flowermd.modules.welding import SlabSimulation, Interface, WeldSimulation # initialize a polymer system using poly(ethylene) and OPLS-AA forcefield molecule = PolyEthylene(num_mols=30, lengths=12) @@ -159,12 +159,12 @@ tensile_sim.run_tensile(n_steps=1e5, strain=0.70, period=500, kT=2.0, tau_kt=0.0 ``` # Availability -`JankFlow` is freely available under the GNU General Public License (version 3) -on [github](https://github.com/cmelab/JankFlow). For installation instructions, +`flowerMD` is freely available under the GNU General Public License (version 3) +on [github](https://github.com/cmelab/flowerMD). For installation instructions, and Python API documentation -please visit the [documentation](https://jankflow.readthedocs.io/en/latest/). -For examples of how to use `JankFlow`, -please visit the [tutorials](https://github.com/cmelab/JankFlow/tree/main/tutorials) +please visit the [documentation](https://flowermd.readthedocs.io/en/latest/). +For examples of how to use `flowerMD`, +please visit the [tutorials](https://github.com/cmelab/flowerMD/tree/main/tutorials) # Acknowledgements We acknowledge contributions from [ULI Advisory board, NASA, etc] From c56f8eb36b6634b51443500c8472e2e12bdb0e9a Mon Sep 17 00:00:00 2001 From: marjanalbouye Date: Tue, 10 Oct 2023 12:52:35 -0600 Subject: [PATCH 31/54] update config on draft-pdf.yml --- .github/workflows/draft-pdf.yml | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/.github/workflows/draft-pdf.yml b/.github/workflows/draft-pdf.yml index 820ee350..a6255bb7 100644 --- a/.github/workflows/draft-pdf.yml +++ b/.github/workflows/draft-pdf.yml @@ -1,8 +1,17 @@ on: push: - branches: [joss] + # Action will run when any changes to these paths are pushed or pr'ed to master + branches: [ main ] + paths: + - flowermd/** + - .github/workflows/draft-pdf.yml pull_request: - branches: [ joss ] + branches: [ main ] + paths: + - flowermd/** + - .github/workflows/draft-pdf.yml + # Allows workflow to be manually triggered + workflow_dispatch: jobs: paper: From a1efbdec8444c54671574bb9ece04aa977ccafdf Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Wed, 11 Oct 2023 11:29:42 -0600 Subject: [PATCH 32/54] Minor grammar/wording fixes --- paper/paper.md | 54 ++++++++++++++++++++++++++------------------------ 1 file changed, 28 insertions(+), 26 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index d6251bbb..a6486ee2 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -30,25 +30,25 @@ date: 01 January 2001 bibliography: paper.bib --- # Summary -`flowerMD` is a package for reproducibly performing complex HOOMD-blue [@hoomd_2019] +`flowerMD` is a package for reproducibly performing multi-stage HOOMD-blue [@hoomd_2019] simulation workflows. It enables the programmatic specification of tasks including definition of molecular structures, forcefield definition and application and chaining together simulation stages (e.g., shrinking, equilibration, simulating a sequence of ensembles, tensile testing, etc.) through an extensible set of Python classes. -The modular design supports a library of complex workflows for organic +The modular design supports a library of workflows for organic macrmolecular and polymer simulations. Tutorials are provided to demonstrate package features and flexibility. # Statement of need -High-level programmatic specification of molecular simulation workflows are -needed for two reasons: First: They provide the information necessary for a -simulation study to be reproducible, and Second: They minimize the cognitive -load of getting started with running experiments [?]. +High-level programmatic specifications of molecular simulation workflows are +needed for two reasons. First, they provide the information necessary for a +simulation study to be reproducible, and second, they minimize the cognitive +load of getting started with running simulations. For a researcher new to molecular simulations, building the necessary set of computational tools needed to actually perform experiments simultaneously: -(a) requires skills and knowledge different from those needed to do research, +(a) requires skills and knowledge different from those needed to do research, and (b) involves repeating work that others have already done. This is a well recognized problem, and recent advances in well-documented @@ -58,15 +58,15 @@ molecular simulation components easier than ever @Santana-Bonilla_2023, @polyply_2022, @biosimspace_2019]. Individually, each of these tools lower the cognitive load of one aspect of an overall workflow such as representing molecules, building initial structures, -parameterizing and applying a forcefield, to running simulations. -However, the challenge of stitching the pieces together to create a complete -workflow still contains several barriers. +parameterizing and applying a forcefield, and running simulations. +However, stitching these pieces together to create a complete workflow still +poses challenges. The computational researcher who follows best practices for accurate, accessible and reproducible results may create a programmatic layer over these individual software packages (i.e. wrapper) that serves to consolidate and automate a complete workflow. However, these efforts often use a bespoke approach -where the entire workflow design is tailored towards the specific question or +where the entire workflow design is tailored toward the specific question or project. Design choices might include the materials studied, the model used (e.g. atomistic or coarse-grained), the source of the forcefield in the model, and the simulation protocols followed. As a result, this wrapper is likely unusable @@ -81,7 +81,7 @@ simulating fusion welding of polymer interfaces [@aggarwal_molecular_2020, @bukowski_load-bearing_2021] and surface wetting [@fan_wetting_1995, bamane_wetting_2021]. -`flowerMD` is a python package that consolidates and automates +`flowerMD` is a Python package that consolidates and automates end-to-end workflows for modeling such processes with a focus on organic molecules. Following the principals of Transparent, Reproducible, Usable by others, and Extensible (TRUE) [@TRUE_2020] software design, the modular design of `flowerMD` facilitates building and @@ -89,33 +89,34 @@ running workflows for specific materials science research applications, while reducing the cognitive load and programming demands on the user's part. # Building Blocks -`flowerMD` is extensible; flexible and modular base classes in form of building blocks lay the -foundations for constructing segregated workflow recipes designed for specific applications. -The recipes are agnostic to choices such as chemistry, model resolution -(atomistic or coarse grained) or forcefields. This is accomplished by utilizing three base classes: +`flowerMD` is extensible. Modular base classes serve as building blocks that lay the +foundation for constructing segregated workflow recipes designed for specific applications. +The resultant recipes are agnostic to choices such as chemistry, model resolution +(e.g. atomistic vs. coarse grained) and forcefield selection. +This is accomplished via three base classes: -• `Molecule` class utilizes the mBuild [@mbuild_2016] and GMSO [@gmso] packages to initialize chemical +• The `Molecule` class utilizes the mBuild [@mbuild_2016] and GMSO [@gmso] packages to initialize chemical structures from a variety of input formats. This class provides methods -for building polymers and copolymer structures and supports straightforward -coarse-graining process. +for building polymers and copolymer structures, and supports a straightforward +coarse-graining process by leveraging SMARTS matching. -• `System` class serves as an intermediary between molecular initialization +• The `System` class serves as an intermediary between molecular initialization and simulation setup. This class builds the initial configuration and -generates the focefield that defines particle interactions. +applies a chosen forcefield that defines particle interactions. -• `Simulation` class adds a layer on top of the HOOMD-blue simulation object, which -adds additional methods and features that simplifies the process of starting and +• The `Simulation` class adds a layer on top of the HOOMD-blue simulation object, +adding additional methods and features to simplify the process of starting and resuming a HOOMD-blue simulation. -Additionally, `flowerMD` offers a library pre-defined subclasses of the above base classes -including common polymers, forcefields and bulk system initialization algorithms. +Additionally, `flowerMD` offers a library pre-defined subclasses of these base classes +including common polymers, forcefields, and bulk system initialization algorithms. # Recipes `flowerMD` offers the following two ready-to-go recipes to illustrate how the design creates potential for expanding the library of open-source and version-controlled workflows. • Welding: What does this recipe do. Simulation to create slabs, building up an -interface from slabs, simulation to preform welding. +interface from slabs, simulation to perform welding. • Tensile Testing ```python from flowermd.library import PolyEthylene, OPLS_AA, Tensile @@ -165,6 +166,7 @@ and Python API documentation please visit the [documentation](https://flowermd.readthedocs.io/en/latest/). For examples of how to use `flowerMD`, please visit the [tutorials](https://github.com/cmelab/flowerMD/tree/main/tutorials) + # Acknowledgements We acknowledge contributions from [ULI Advisory board, NASA, etc] From faa4d4d4e6ee03ab1b75146efbc4b64f59b608ea Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Wed, 11 Oct 2023 13:12:39 -0600 Subject: [PATCH 33/54] Expand recipes section --- paper/paper.md | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index a6486ee2..93bb8feb 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -113,11 +113,14 @@ including common polymers, forcefields, and bulk system initialization algorithm # Recipes `flowerMD` offers the following two ready-to-go recipes to illustrate how the design creates -potential for expanding the library of open-source and version-controlled workflows. +potential for expanding the library of open-source and version-controlled workflows. The included example +code demonstrates how the modularity of `flowerMD` allows use and re-use of workflows, using + pre-built recipe subclasses included in the repository: `SlabSimulation`, `WeldSimulation`, and `Tensile`. +This script creates two "slabs" of polyethylene, simulates welding at their interface, then simulates a tensile +test of the resultant weld. Note that each of these steps can be run independently, and each simulation +type is agnostic to system and force field selection, enabling easy iteration with different +materials, force fields, etc. without replicating the workflow code itself. -• Welding: What does this recipe do. Simulation to create slabs, building up an -interface from slabs, simulation to perform welding. -• Tensile Testing ```python from flowermd.library import PolyEthylene, OPLS_AA, Tensile from flowermd.base import Pack From 7555d48400356d52964442d7286724ea81c50c3c Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Wed, 11 Oct 2023 19:13:29 +0000 Subject: [PATCH 34/54] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- paper/paper.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/paper/paper.md b/paper/paper.md index 93bb8feb..2a1148de 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -104,7 +104,7 @@ coarse-graining process by leveraging SMARTS matching. and simulation setup. This class builds the initial configuration and applies a chosen forcefield that defines particle interactions. -• The `Simulation` class adds a layer on top of the HOOMD-blue simulation object, +• The `Simulation` class adds a layer on top of the HOOMD-blue simulation object, adding additional methods and features to simplify the process of starting and resuming a HOOMD-blue simulation. From 22847a06108bde54c66a1868bbe208b5bbf60a57 Mon Sep 17 00:00:00 2001 From: marjanalbouye Date: Wed, 11 Oct 2023 14:10:42 -0600 Subject: [PATCH 35/54] remove code block --- paper/paper.md | 41 ----------------------------------------- 1 file changed, 41 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index 2a1148de..15e63464 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -121,47 +121,6 @@ test of the resultant weld. Note that each of these steps can be run independent type is agnostic to system and force field selection, enabling easy iteration with different materials, force fields, etc. without replicating the workflow code itself. -```python -from flowermd.library import PolyEthylene, OPLS_AA, Tensile -from flowermd.base import Pack -from flowermd.modules.welding import SlabSimulation, Interface, WeldSimulation - -# initialize a polymer system using poly(ethylene) and OPLS-AA forcefield -molecule = PolyEthylene(num_mols=30, lengths=12) -system = Pack(molecules=molecule, density=1.1) -system.apply_forcefield(r_cut=2.5, force_field=OPLS_AA(), auto_scale=True, - remove_charges=True, remove_hydrogens=True) -# saving forces for later use -hoomd_forces = system.hoomd_forcefield -# run a slab simulation -sim = SlabSimulation.from_system(system=system, interface_axis=(1, 0, 0), - gsd_file_name="slab.gsd") -# shrink the box to reach the desired density -sim.run_update_volume(final_density=1.2, n_steps=5e4, kT=5.0, - period=100, tau_kt=0.001) -# run NVT ensemble -sim.run_NVT(kT=5.0, n_steps=4e4, tau_kt=0.001) -sim.operations.writers[0].flush() -# create an interface from the slab -interface = Interface(gsd_file="slab.gsd", interface_axis=(1, 0, 0), gap=0.05) -# run the welding simulation -weld_sim = WeldSimulation(initial_state=interface.hoomd_snapshot, - forcefield=hoomd_forces, interface_axis=(1, 0, 0), - gsd_file_name="weld.gsd", log_file_name="weld_log.txt", - log_write_freq=500, dt=0.0003) -weld_sim.run_NVT(kT=10.0, n_steps=7e4, tau_kt=0.001) -cooling_ramp = weld_sim.temperature_ramp(n_steps=2e4, kT_start=10.0, kT_final=2.0) -weld_sim.run_NVT(kT=cooling_ramp, n_steps=2e4, tau_kt=0.001) -weld_sim.save_restart_gsd("weld_restart.gsd") -# Running a tensile test simulation -tensile_sim = Tensile(initial_state="weld_restart.gsd", forcefield=hoomd_forces, - tensile_axis=(1,0,0), gsd_file_name="tensile.gsd", - gsd_write_freq=1000, log_file_name="tensile_log.txt", - log_write_freq=500, fix_ratio=0.30) -tensile_sim.run_tensile(n_steps=1e5, strain=0.70, period=500, kT=2.0, tau_kt=0.001) -# for more details on the tensile test results, please see the tutorials. -``` - # Availability `flowerMD` is freely available under the GNU General Public License (version 3) on [github](https://github.com/cmelab/flowerMD). For installation instructions, From b9daf9df3ca48b093cf2bc2c181f0eb1d39a2df1 Mon Sep 17 00:00:00 2001 From: marjanalbouye Date: Wed, 11 Oct 2023 14:15:22 -0600 Subject: [PATCH 36/54] change branch in draft-pdf yml --- .github/workflows/draft-pdf.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/draft-pdf.yml b/.github/workflows/draft-pdf.yml index a6255bb7..95ae7ffa 100644 --- a/.github/workflows/draft-pdf.yml +++ b/.github/workflows/draft-pdf.yml @@ -1,12 +1,12 @@ on: push: # Action will run when any changes to these paths are pushed or pr'ed to master - branches: [ main ] + branches: [ joss ] paths: - flowermd/** - .github/workflows/draft-pdf.yml pull_request: - branches: [ main ] + branches: [ joss ] paths: - flowermd/** - .github/workflows/draft-pdf.yml From c76bf3e4f9a1599455858ca9e02305a7027350fb Mon Sep 17 00:00:00 2001 From: marjanalbouye Date: Wed, 11 Oct 2023 15:10:00 -0600 Subject: [PATCH 37/54] fix citation format --- paper/paper.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index 15e63464..92aa3a46 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -54,8 +54,8 @@ of computational tools needed to actually perform experiments simultaneously: This is a well recognized problem, and recent advances in well-documented open-source tools have made the programmatic specification of molecular simulation components easier than ever -[@hoomd_2019, @lammps_2022, @gromacs_2015, @mbuild_2016, @gmso, -@Santana-Bonilla_2023, @polyply_2022, @biosimspace_2019]. +[@hoomd_2019; @lammps_2022; @gromacs_2015; @mbuild_2016; @gmso; +@Santana-Bonilla_2023; @polyply_2022; @biosimspace_2019]. Individually, each of these tools lower the cognitive load of one aspect of an overall workflow such as representing molecules, building initial structures, parameterizing and applying a forcefield, and running simulations. @@ -78,8 +78,8 @@ building molecules and bulk structures to calculating physical properties of pol However, these tools may not be suitable for modeling complex experimental processes that extend beyond measuring material properties, such as simulating fusion welding of polymer interfaces -[@aggarwal_molecular_2020, @bukowski_load-bearing_2021] and surface wetting -[@fan_wetting_1995, bamane_wetting_2021]. +[@aggarwal_molecular_2020; @bukowski_load-bearing_2021] and surface wetting +[@fan_wetting_1995; bamane_wetting_2021]. `flowerMD` is a Python package that consolidates and automates end-to-end workflows for modeling such processes with a focus on organic molecules. From d0c6aa36d6eac8aab129f2ff00c628d30e1d7601 Mon Sep 17 00:00:00 2001 From: marjanalbouye Date: Wed, 11 Oct 2023 15:10:12 -0600 Subject: [PATCH 38/54] update gmso ref --- paper/paper.bib | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/paper/paper.bib b/paper/paper.bib index d1344bd9..89ce8e35 100644 --- a/paper/paper.bib +++ b/paper/paper.bib @@ -241,9 +241,11 @@ @article{lammps_2022 } @software{gmso, + author = {mosdef-hub, Vanderbilt University}, title = {{GMSO}: General Molecular Simulation Object.}, url = {https://gmso.mosdef.org/en/stable/}, - publisher = {mosdef-hub, Vanderbilt University}, + year = {2023}, + publisher = {GitHub}, } @article{aggarwal_molecular_2020, From 7ea36dd29eafef232546fd763af396937da49fbd Mon Sep 17 00:00:00 2001 From: marjanalbouye Date: Thu, 12 Oct 2023 13:49:19 -0600 Subject: [PATCH 39/54] add acknowlegments --- paper/paper.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/paper/paper.md b/paper/paper.md index 92aa3a46..8def3b70 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -130,6 +130,10 @@ For examples of how to use `flowerMD`, please visit the [tutorials](https://github.com/cmelab/flowerMD/tree/main/tutorials) # Acknowledgements -We acknowledge contributions from [ULI Advisory board, NASA, etc] +This research was partially supported by the National Aeronautics and Space +Administration (NASA) under the University Leadership Initiative program; +grant number 80NSSC20M0165. +This material is based upon work supported by the National Science Foundation +under Grant Numbers: 1653954, 1835593, and 2118217. # References From 8e4f8322bce5f84244b26a9a739d647c769bbe06 Mon Sep 17 00:00:00 2001 From: marjanalbouye Date: Thu, 12 Oct 2023 14:09:16 -0600 Subject: [PATCH 40/54] change trigger path in action --- .github/workflows/draft-pdf.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/draft-pdf.yml b/.github/workflows/draft-pdf.yml index 95ae7ffa..e0fd2d0d 100644 --- a/.github/workflows/draft-pdf.yml +++ b/.github/workflows/draft-pdf.yml @@ -8,7 +8,7 @@ on: pull_request: branches: [ joss ] paths: - - flowermd/** + - paper/** - .github/workflows/draft-pdf.yml # Allows workflow to be manually triggered workflow_dispatch: From ec85a8dbf1cbfd0beff40eab5e7f2f41d1c0e3bc Mon Sep 17 00:00:00 2001 From: marjanalbouye Date: Thu, 12 Oct 2023 14:09:37 -0600 Subject: [PATCH 41/54] fix citation --- paper/paper.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/paper/paper.md b/paper/paper.md index 8def3b70..05fd66d4 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -79,7 +79,7 @@ However, these tools may not be suitable for modeling complex experimental processes that extend beyond measuring material properties, such as simulating fusion welding of polymer interfaces [@aggarwal_molecular_2020; @bukowski_load-bearing_2021] and surface wetting -[@fan_wetting_1995; bamane_wetting_2021]. +[@fan_wetting_1995; @bamane_wetting_2021]. `flowerMD` is a Python package that consolidates and automates end-to-end workflows for modeling such processes with a focus on organic molecules. From 4a33b6d736cde6612fc587a0ec1ae6d3a20df4df Mon Sep 17 00:00:00 2001 From: RainierBarrett Date: Fri, 13 Oct 2023 14:45:56 -0600 Subject: [PATCH 42/54] Restructure recipe section to be more recipe-like --- paper/paper.md | 22 ++++++++++++++++------ 1 file changed, 16 insertions(+), 6 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index 05fd66d4..12d64f29 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -113,13 +113,23 @@ including common polymers, forcefields, and bulk system initialization algorithm # Recipes `flowerMD` offers the following two ready-to-go recipes to illustrate how the design creates -potential for expanding the library of open-source and version-controlled workflows. The included example -code demonstrates how the modularity of `flowerMD` allows use and re-use of workflows, using - pre-built recipe subclasses included in the repository: `SlabSimulation`, `WeldSimulation`, and `Tensile`. -This script creates two "slabs" of polyethylene, simulates welding at their interface, then simulates a tensile -test of the resultant weld. Note that each of these steps can be run independently, and each simulation +potential for expanding the library of open-source and version-controlled workflows. The example +code included in this repository demonstrates how the modularity of `flowerMD` allows use and re-use of workflows, using +pre-built "recipe steps" (subclasses) included in the repository: +`flowerMD.modules.welding.SlabSimulation`, `flowerMD.modules.welding.Interface`, `flowerMD.modules.welding.WeldSimulation`, +and `flowerMD.library.simulations.Tensile`. + +We can use these four blocks to build the following recipe: +1. `SlabSimulation` creates two "slabs" of e.g. polyethylene +2. `Interface` joins two resultant slabs at an interface +3. `WeldSimulation` simulates thermal welding at this interface, and +4. `Tensile` simulates a tensile test of the resultant weld to create a stress/strain curve. +Note that each of these steps can be run independently, and each simulation type is agnostic to system and force field selection, enabling easy iteration with different -materials, force fields, etc. without replicating the workflow code itself. +materials, force fields, etc. without replicating the workflow code itself. One example might be +that we could instead run `SlabSimulation` on two different bulk polymers, then reuse the rest of +the recipe unchanged. We could also iterate over new weld temperatures pending results of `Tensile` runs, etc. +We hope this flexible and modular design will be a boon to many future molecular simulation researchers. # Availability `flowerMD` is freely available under the GNU General Public License (version 3) From 87fc6ee77c1f719bd613de186cf02801466da63c Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 13 Oct 2023 20:46:15 +0000 Subject: [PATCH 43/54] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- paper/paper.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/paper/paper.md b/paper/paper.md index 12d64f29..8729874d 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -115,7 +115,7 @@ including common polymers, forcefields, and bulk system initialization algorithm `flowerMD` offers the following two ready-to-go recipes to illustrate how the design creates potential for expanding the library of open-source and version-controlled workflows. The example code included in this repository demonstrates how the modularity of `flowerMD` allows use and re-use of workflows, using -pre-built "recipe steps" (subclasses) included in the repository: +pre-built "recipe steps" (subclasses) included in the repository: `flowerMD.modules.welding.SlabSimulation`, `flowerMD.modules.welding.Interface`, `flowerMD.modules.welding.WeldSimulation`, and `flowerMD.library.simulations.Tensile`. From f3a11e2e7502bc7b9302bedac7b98e9f11f475b1 Mon Sep 17 00:00:00 2001 From: Rainier Barrett Date: Mon, 16 Oct 2023 08:34:47 -0600 Subject: [PATCH 44/54] Additional closing wordage, separate paragraph --- paper/paper.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/paper/paper.md b/paper/paper.md index 8729874d..519c50a2 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -124,11 +124,15 @@ We can use these four blocks to build the following recipe: 2. `Interface` joins two resultant slabs at an interface 3. `WeldSimulation` simulates thermal welding at this interface, and 4. `Tensile` simulates a tensile test of the resultant weld to create a stress/strain curve. + Note that each of these steps can be run independently, and each simulation type is agnostic to system and force field selection, enabling easy iteration with different materials, force fields, etc. without replicating the workflow code itself. One example might be that we could instead run `SlabSimulation` on two different bulk polymers, then reuse the rest of the recipe unchanged. We could also iterate over new weld temperatures pending results of `Tensile` runs, etc. + +This flexibility and ease of iteration is the core design principle of flowerMD, and enables +both new and experienced researchers to more quickly begin the process of scientific inquiry via molecular dynamics. We hope this flexible and modular design will be a boon to many future molecular simulation researchers. # Availability From 4e6f8d46a7d9296dc6ccc799945dafd7b4c2b5d8 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 16 Oct 2023 14:34:56 +0000 Subject: [PATCH 45/54] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- paper/paper.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/paper/paper.md b/paper/paper.md index 519c50a2..ad927b50 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -124,7 +124,7 @@ We can use these four blocks to build the following recipe: 2. `Interface` joins two resultant slabs at an interface 3. `WeldSimulation` simulates thermal welding at this interface, and 4. `Tensile` simulates a tensile test of the resultant weld to create a stress/strain curve. - + Note that each of these steps can be run independently, and each simulation type is agnostic to system and force field selection, enabling easy iteration with different materials, force fields, etc. without replicating the workflow code itself. One example might be From 67a2000ff851e5a1593ce8150a370b35675bb0ae Mon Sep 17 00:00:00 2001 From: chrisjonesbsu Date: Mon, 16 Oct 2023 08:38:56 -0600 Subject: [PATCH 46/54] adding a word --- paper/paper.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/paper/paper.md b/paper/paper.md index 8729874d..86719990 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -49,7 +49,7 @@ load of getting started with running simulations. For a researcher new to molecular simulations, building the necessary set of computational tools needed to actually perform experiments simultaneously: (a) requires skills and knowledge different from those needed to do research, and -(b) involves repeating work that others have already done. +(b) often involves repeating work that others have already done. This is a well recognized problem, and recent advances in well-documented open-source tools have made the programmatic specification of From df2d2b65ae80aa5a5a825c8984f0e5e6de4c3806 Mon Sep 17 00:00:00 2001 From: erjank Date: Mon, 16 Oct 2023 09:42:02 -0600 Subject: [PATCH 47/54] Update paper.md Small language polish. --- paper/paper.md | 69 ++++++++++++++++++++++++++------------------------ 1 file changed, 36 insertions(+), 33 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index d7d1d148..e58f0e0e 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -44,23 +44,27 @@ package features and flexibility. High-level programmatic specifications of molecular simulation workflows are needed for two reasons. First, they provide the information necessary for a -simulation study to be reproducible, and second, they minimize the cognitive -load of getting started with running simulations. -For a researcher new to molecular simulations, building the necessary set -of computational tools needed to actually perform experiments simultaneously: -(a) requires skills and knowledge different from those needed to do research, and -(b) often involves repeating work that others have already done. - -This is a well recognized problem, and recent advances in well-documented -open-source tools have made the programmatic specification of +simulation study to be reproduced, and second, they help lower the cognitive +load associated with learning and performing simulations in general. +Reproducible simulations benefit the research community by enabling studies +to be validated and extended. +Lowering the cognitive load of performing molecular simulations helps +computational researchers of all levels of expertise reason about the logic +of a simulation study. This is particularly important for researchers new to +the discipline becuase developing the tools needed to perform experiments often +involves: (a) gaining new software development skills and knowledge, and +(b) repeating work that others have already performed. + + +Recent advances in open-source tools have made the programmatic specification of molecular simulation components easier than ever [@hoomd_2019; @lammps_2022; @gromacs_2015; @mbuild_2016; @gmso; @Santana-Bonilla_2023; @polyply_2022; @biosimspace_2019]. Individually, each of these tools lower the cognitive load of one aspect of an overall workflow such as representing molecules, building initial structures, parameterizing and applying a forcefield, and running simulations. -However, stitching these pieces together to create a complete workflow still -poses challenges. +However, stitching these pieces together to create a complete workflow presents +a need that we address in the present work. The computational researcher who follows best practices for accurate, accessible and reproducible results may create a programmatic layer over these @@ -73,32 +77,31 @@ the simulation protocols followed. As a result, this wrapper is likely unusable for the next project where one of the aforementioned choices changes, and the process of designing a workflow must begin again from scratch. -Software packages such as Radonpy [@radonpy_2022] exist that provide an automated workflow for -building molecules and bulk structures to calculating physical properties of polymers. -However, these tools may not be suitable for modeling complex experimental -processes that extend beyond measuring material properties, such as +Software packages such as Radonpy [@radonpy_2022] exist that provide an automated +workflow for building molecules and bulk structures to calculating physical +properties of polymers. However, these tools may not be suitable for modeling complex +experimental processes that extend beyond measuring material properties, such as simulating fusion welding of polymer interfaces [@aggarwal_molecular_2020; @bukowski_load-bearing_2021] and surface wetting [@fan_wetting_1995; @bamane_wetting_2021]. `flowerMD` is a Python package that consolidates and automates -end-to-end workflows for modeling such processes with a focus on organic molecules. -Following the principals of Transparent, Reproducible, Usable by others, and Extensible (TRUE) [@TRUE_2020] -software design, the modular design of `flowerMD` facilitates building and -running workflows for specific materials science research applications, -while reducing the cognitive load and programming demands on the user's part. +end-to-end workflows for modeling such engineering processes with a focus on organic +molecules. Following the principals of Transparent, Reproducible, Usable by others, +and Extensible (TRUE) [@TRUE_2020] software design, the modular design of `flowerMD` +facilitates building and running workflows for specific materials science research +applications, while reducing the cognitive load and programming demands on the user's part. # Building Blocks `flowerMD` is extensible. Modular base classes serve as building blocks that lay the -foundation for constructing segregated workflow recipes designed for specific applications. +foundation for constructing workflow recipes designed for specific applications. The resultant recipes are agnostic to choices such as chemistry, model resolution (e.g. atomistic vs. coarse grained) and forcefield selection. This is accomplished via three base classes: -• The `Molecule` class utilizes the mBuild [@mbuild_2016] and GMSO [@gmso] packages to initialize chemical -structures from a variety of input formats. This class provides methods -for building polymers and copolymer structures, and supports a straightforward -coarse-graining process by leveraging SMARTS matching. +• The `Molecule` class utilizes the mBuild [@mbuild_2016] and GMSO [@gmso] packages to initialize chemical structures from a variety of common input formats. This class provides +methods for building polymers and copolymer structures, and supports coarse-graining +processes by leveraging SMARTS matching. • The `System` class serves as an intermediary between molecular initialization and simulation setup. This class builds the initial configuration and @@ -113,9 +116,9 @@ including common polymers, forcefields, and bulk system initialization algorithm # Recipes `flowerMD` offers the following two ready-to-go recipes to illustrate how the design creates -potential for expanding the library of open-source and version-controlled workflows. The example -code included in this repository demonstrates how the modularity of `flowerMD` allows use and re-use of workflows, using -pre-built "recipe steps" (subclasses) included in the repository: +potential for expanding the library of open-source and version-controlled workflows. The example code included in this repository demonstrates how the modularity of `flowerMD` +allows use and re-use of workflows, using pre-built "recipe steps" (subclasses) included in +the repository: `flowerMD.modules.welding.SlabSimulation`, `flowerMD.modules.welding.Interface`, `flowerMD.modules.welding.WeldSimulation`, and `flowerMD.library.simulations.Tensile`. @@ -127,13 +130,13 @@ We can use these four blocks to build the following recipe: Note that each of these steps can be run independently, and each simulation type is agnostic to system and force field selection, enabling easy iteration with different -materials, force fields, etc. without replicating the workflow code itself. One example might be -that we could instead run `SlabSimulation` on two different bulk polymers, then reuse the rest of -the recipe unchanged. We could also iterate over new weld temperatures pending results of `Tensile` runs, etc. +materials, force fields, etc. without replicating the workflow code itself. One example might be that we could instead run `SlabSimulation` on two different bulk polymers, then reuse the rest of the recipe unchanged. We could also iterate over new weld temperatures pending results of `Tensile` runs, etc. This flexibility and ease of iteration is the core design principle of flowerMD, and enables -both new and experienced researchers to more quickly begin the process of scientific inquiry via molecular dynamics. -We hope this flexible and modular design will be a boon to many future molecular simulation researchers. +both new and experienced researchers to more quickly begin the process of scientific inquiry +via molecular dynamics simulations. +We encourage molecular simulation practitioners of all levels of expertise to file issues +and submit pull requests to extend `flowerMD`'s utility. # Availability `flowerMD` is freely available under the GNU General Public License (version 3) From ef7c5f30a3d6a830c222b3bfe66f57eba7874dee Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 16 Oct 2023 15:42:11 +0000 Subject: [PATCH 48/54] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- paper/paper.md | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index e58f0e0e..cfd2daa4 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -47,13 +47,13 @@ needed for two reasons. First, they provide the information necessary for a simulation study to be reproduced, and second, they help lower the cognitive load associated with learning and performing simulations in general. Reproducible simulations benefit the research community by enabling studies -to be validated and extended. +to be validated and extended. Lowering the cognitive load of performing molecular simulations helps computational researchers of all levels of expertise reason about the logic -of a simulation study. This is particularly important for researchers new to -the discipline becuase developing the tools needed to perform experiments often +of a simulation study. This is particularly important for researchers new to +the discipline becuase developing the tools needed to perform experiments often involves: (a) gaining new software development skills and knowledge, and -(b) repeating work that others have already performed. +(b) repeating work that others have already performed. Recent advances in open-source tools have made the programmatic specification of @@ -63,7 +63,7 @@ molecular simulation components easier than ever Individually, each of these tools lower the cognitive load of one aspect of an overall workflow such as representing molecules, building initial structures, parameterizing and applying a forcefield, and running simulations. -However, stitching these pieces together to create a complete workflow presents +However, stitching these pieces together to create a complete workflow presents a need that we address in the present work. The computational researcher who follows best practices for accurate, @@ -77,8 +77,8 @@ the simulation protocols followed. As a result, this wrapper is likely unusable for the next project where one of the aforementioned choices changes, and the process of designing a workflow must begin again from scratch. -Software packages such as Radonpy [@radonpy_2022] exist that provide an automated -workflow for building molecules and bulk structures to calculating physical +Software packages such as Radonpy [@radonpy_2022] exist that provide an automated +workflow for building molecules and bulk structures to calculating physical properties of polymers. However, these tools may not be suitable for modeling complex experimental processes that extend beyond measuring material properties, such as simulating fusion welding of polymer interfaces @@ -86,10 +86,10 @@ simulating fusion welding of polymer interfaces [@fan_wetting_1995; @bamane_wetting_2021]. `flowerMD` is a Python package that consolidates and automates -end-to-end workflows for modeling such engineering processes with a focus on organic -molecules. Following the principals of Transparent, Reproducible, Usable by others, -and Extensible (TRUE) [@TRUE_2020] software design, the modular design of `flowerMD` -facilitates building and running workflows for specific materials science research +end-to-end workflows for modeling such engineering processes with a focus on organic +molecules. Following the principals of Transparent, Reproducible, Usable by others, +and Extensible (TRUE) [@TRUE_2020] software design, the modular design of `flowerMD` +facilitates building and running workflows for specific materials science research applications, while reducing the cognitive load and programming demands on the user's part. # Building Blocks @@ -99,8 +99,8 @@ The resultant recipes are agnostic to choices such as chemistry, model resolutio (e.g. atomistic vs. coarse grained) and forcefield selection. This is accomplished via three base classes: -• The `Molecule` class utilizes the mBuild [@mbuild_2016] and GMSO [@gmso] packages to initialize chemical structures from a variety of common input formats. This class provides -methods for building polymers and copolymer structures, and supports coarse-graining +• The `Molecule` class utilizes the mBuild [@mbuild_2016] and GMSO [@gmso] packages to initialize chemical structures from a variety of common input formats. This class provides +methods for building polymers and copolymer structures, and supports coarse-graining processes by leveraging SMARTS matching. • The `System` class serves as an intermediary between molecular initialization @@ -116,8 +116,8 @@ including common polymers, forcefields, and bulk system initialization algorithm # Recipes `flowerMD` offers the following two ready-to-go recipes to illustrate how the design creates -potential for expanding the library of open-source and version-controlled workflows. The example code included in this repository demonstrates how the modularity of `flowerMD` -allows use and re-use of workflows, using pre-built "recipe steps" (subclasses) included in +potential for expanding the library of open-source and version-controlled workflows. The example code included in this repository demonstrates how the modularity of `flowerMD` +allows use and re-use of workflows, using pre-built "recipe steps" (subclasses) included in the repository: `flowerMD.modules.welding.SlabSimulation`, `flowerMD.modules.welding.Interface`, `flowerMD.modules.welding.WeldSimulation`, and `flowerMD.library.simulations.Tensile`. @@ -133,9 +133,9 @@ type is agnostic to system and force field selection, enabling easy iteration wi materials, force fields, etc. without replicating the workflow code itself. One example might be that we could instead run `SlabSimulation` on two different bulk polymers, then reuse the rest of the recipe unchanged. We could also iterate over new weld temperatures pending results of `Tensile` runs, etc. This flexibility and ease of iteration is the core design principle of flowerMD, and enables -both new and experienced researchers to more quickly begin the process of scientific inquiry +both new and experienced researchers to more quickly begin the process of scientific inquiry via molecular dynamics simulations. -We encourage molecular simulation practitioners of all levels of expertise to file issues +We encourage molecular simulation practitioners of all levels of expertise to file issues and submit pull requests to extend `flowerMD`'s utility. # Availability From dfba8acbd1c6a5c6818d3f4dfe2729fdb9156891 Mon Sep 17 00:00:00 2001 From: marjanalbouye Date: Mon, 16 Oct 2023 09:42:52 -0600 Subject: [PATCH 49/54] add a few citations, edit gmso citation --- paper/paper.bib | 138 +++++++++++++++--------------------------------- 1 file changed, 42 insertions(+), 96 deletions(-) diff --git a/paper/paper.bib b/paper/paper.bib index 89ce8e35..cc5fe46c 100644 --- a/paper/paper.bib +++ b/paper/paper.bib @@ -110,86 +110,15 @@ @article{polyply_2022 date = {2022-01-10}, langid = {english}, } - -@article{gromacs_2013, - title = {{GROMACS} 4.5: a high-throughput and highly parallel open source molecular simulation toolkit}, - volume = {29}, - issn = {1367-4811, 1367-4803}, - url = {https://academic.oup.com/bioinformatics/article/29/7/845/253065}, - doi = {10.1093/bioinformatics/btt055}, - shorttitle = {{GROMACS} 4.5}, - pages = {845--854}, - number = {7}, - journaltitle = {Bioinformatics}, - author = {Pronk, Sander and Páll, Szilárd and Schulz, Roland and Larsson, Per and Bjelkmar, Pär and Apostolov, Rossen and Shirts, Michael R. and Smith, Jeremy C. and Kasson, Peter M. and Van Der Spoel, David and Hess, Berk and Lindahl, Erik}, - urldate = {2023-10-03}, - date = {2013-04-01}, - langid = {english}, -} - -@article{gromacs_2008, - title = {{GROMACS} 4: Algorithms for Highly Efficient, Load-Balanced, and Scalable Molecular Simulation}, - volume = {4}, - issn = {1549-9618, 1549-9626}, - url = {https://pubs.acs.org/doi/10.1021/ct700301q}, - doi = {10.1021/ct700301q}, - shorttitle = {{GROMACS} 4}, - pages = {435--447}, - number = {3}, - journaltitle = {Journal of Chemical Theory and Computation}, - shortjournal = {J. Chem. Theory Comput.}, - author = {Hess, Berk and Kutzner, Carsten and Van Der Spoel, David and Lindahl, Erik}, - urldate = {2023-10-03}, - date = {2008-03-01}, - langid = {english}, -} - -@article{gromacs_1995, - title = {{GROMACS}: A message-passing parallel molecular dynamics implementation}, - volume = {91}, - issn = {00104655}, - url = {https://linkinghub.elsevier.com/retrieve/pii/001046559500042E}, - doi = {10.1016/0010-4655(95)00042-E}, - shorttitle = {{GROMACS}}, - pages = {43--56}, - number = {1}, - journaltitle = {Computer Physics Communications}, - shortjournal = {Computer Physics Communications}, - author = {Berendsen, H.J.C. and Van Der Spoel, D. and Van Drunen, R.}, - urldate = {2023-10-03}, - date = {1995-09}, - langid = {english}, -} - -@article{gromacs_2015, - title = {{GROMACS}: High performance molecular simulations through multi-level parallelism from laptops to supercomputers}, - volume = {1-2}, - issn = {23527110}, - url = {https://linkinghub.elsevier.com/retrieve/pii/S2352711015000059}, - doi = {10.1016/j.softx.2015.06.001}, - shorttitle = {{GROMACS}}, - pages = {19--25}, - journaltitle = {{SoftwareX}}, - shortjournal = {{SoftwareX}}, - author = {Abraham, Mark James and Murtola, Teemu and Schulz, Roland and Páll, Szilárd and Smith, Jeremy C. and Hess, Berk and Lindahl, Erik}, - urldate = {2023-10-03}, - date = {2015-09}, - langid = {english}, -} - -@incollection{Szilárd_gromacs_2015, - title = {Tackling Exascale Software Challenges in Molecular Dynamics Simulations with {GROMACS}}, - volume = {8759}, - url = {http://arxiv.org/abs/1506.00716}, - pages = {3--27}, - author = {Szilárd, Páll and Abraham, Mark James and Kutzner, Carsten and Hess, Berk and Lindahl, Erik}, - urldate = {2023-10-03}, - date = {2015}, - langid = {english}, - doi = {10.1007/978-3-319-15976-8_1}, - eprinttype = {arxiv}, - eprint = {1506.00716 [cs]}, - keywords = {Computer Science - Computational Engineering, Finance, and Science, I.6.8, J.2}, +@article{eastman2017openmm, + title={OpenMM 7: Rapid development of high performance algorithms for molecular dynamics}, + author={Eastman, Peter and Swails, Jason and Chodera, John D and McGibbon, Robert T and Zhao, Yutong and Beauchamp, Kyle A and Wang, Lee-Ping and Simmonett, Andrew C and Harrigan, Matthew P and Stern, Chaya D and others}, + journal={PLoS computational biology}, + volume={13}, + number={7}, + pages={e1005659}, + year={2017}, + publisher={Public Library of Science San Francisco, CA USA} } @article{Santana-Bonilla_2023, @@ -207,22 +136,29 @@ @article{Santana-Bonilla_2023 date = {2023-06-26}, langid = {english}, } +@article{martin2018pyprism, + title={pyPRISM: a computational tool for liquid-state theory calculations of macromolecular materials}, + author={Martin, Tyler B and Gartner III, Thomas E and Jones, Ronald L and Snyder, Chad R and Jayaraman, Arthi}, + journal={Macromolecules}, + volume={51}, + number={8}, + pages={2906--2922}, + year={2018}, + publisher={ACS Publications} +} -@incollection{mbuild_2016, - location = {Singapore}, - title = {A Hierarchical, Component Based Approach to Screening Properties of Soft Matter}, - isbn = {978-981-10-1126-9 978-981-10-1128-3}, - url = {http://link.springer.com/10.1007/978-981-10-1128-3_5}, - pages = {79--92}, - booktitle = {Foundations of Molecular Modeling and Simulation}, - publisher = {Springer Singapore}, - author = {Klein, Christoph and Sallai, János and Jones, Trevor J. and Iacovella, Christopher R. and {McCabe}, Clare and Cummings, Peter T.}, - editor = {Snurr, Randall Q and Adjiman, Claire S. and Kofke, David A.}, - urldate = {2023-10-05}, - date = {2016}, - langid = {english}, - doi = {10.1007/978-981-10-1128-3_5}, - note = {Series Title: Molecular Modeling and Simulation}, +@Inbook{Klein2016mBuild, + author = "Klein, Christoph and Sallai, János and Jones, Trevor J. and Iacovella, Christopher R. and McCabe, Clare and Cummings, Peter T.", + editor = "Snurr, Randall Q and Adjiman, Claire S. and Kofke, David A.", + title = "A Hierarchical, Component Based Approach to Screening Properties of Soft Matter", + bookTitle = "Foundations of Molecular Modeling and Simulation: Select Papers from FOMMS 2015", + year = "2016", + publisher = "Springer Singapore", + address = "Singapore", + pages = "79--92", + isbn = "978-981-10-1128-3", + doi = "10.1007/978-981-10-1128-3_5", + url = "https://doi.org/10.1007/978-981-10-1128-3_5" } @article{lammps_2022, @@ -242,12 +178,21 @@ @article{lammps_2022 @software{gmso, author = {mosdef-hub, Vanderbilt University}, - title = {{GMSO}: General Molecular Simulation Object.}, + title = {{GMSO: General Molecular Simulation Object}}, url = {https://gmso.mosdef.org/en/stable/}, + version = {0.11.2}, year = {2023}, publisher = {GitHub}, } +@software{parmed, + author = {Swails, Jason and Hernandez, Carlos and Mobley, David L. and Nguyen, Hai and Wang, Lee-Ping and Janowski, Pawel}, + title = {{ParmED: Cross-program parameter and topology file editor and molecular mechanical simulator engine}}, + url = {https://github.com/ParmEd/ParmEd}, + version = {4.1.0}, + year = {2014}, + publisher = {GitHub}, +} @article{aggarwal_molecular_2020, title = {Molecular dynamics studies on the strength and ductility of symmetric thermally welded joints}, issn = {0965-0393, 1361-651X}, @@ -312,3 +257,4 @@ @article{bamane_wetting_2021 langid = {english}, file = {Bamane et al. - 2021 - Wetting Simulations of High-Performance Polymer Re.pdf:/home/marjan/Zotero/storage/JPFTYNU9/Bamane et al. - 2021 - Wetting Simulations of High-Performance Polymer Re.pdf:application/pdf}, } + From df0ee82be3152297ea88ba72dc7159a4e715b14a Mon Sep 17 00:00:00 2001 From: marjanalbouye Date: Mon, 16 Oct 2023 09:43:23 -0600 Subject: [PATCH 50/54] add parmed, openmm and pyPRISM citations --- paper/paper.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index d7d1d148..8e167f11 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -54,8 +54,8 @@ of computational tools needed to actually perform experiments simultaneously: This is a well recognized problem, and recent advances in well-documented open-source tools have made the programmatic specification of molecular simulation components easier than ever -[@hoomd_2019; @lammps_2022; @gromacs_2015; @mbuild_2016; @gmso; -@Santana-Bonilla_2023; @polyply_2022; @biosimspace_2019]. +[@hoomd_2019; @lammps_2022; @eastman2017openmm; @Klein2016mBuild; @gmso; @parmed; +@Santana-Bonilla_2023; @polyply_2022; @biosimspace_2019; @martin2018pyprism]. Individually, each of these tools lower the cognitive load of one aspect of an overall workflow such as representing molecules, building initial structures, parameterizing and applying a forcefield, and running simulations. @@ -95,7 +95,7 @@ The resultant recipes are agnostic to choices such as chemistry, model resolutio (e.g. atomistic vs. coarse grained) and forcefield selection. This is accomplished via three base classes: -• The `Molecule` class utilizes the mBuild [@mbuild_2016] and GMSO [@gmso] packages to initialize chemical +• The `Molecule` class utilizes the mBuild [@Klein2016mBuild] and GMSO [@gmso] packages to initialize chemical structures from a variety of input formats. This class provides methods for building polymers and copolymer structures, and supports a straightforward coarse-graining process by leveraging SMARTS matching. From 544ddaa5dbdedb15523d0cd6a26e103320292452 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 16 Oct 2023 15:46:53 +0000 Subject: [PATCH 51/54] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- paper/paper.bib | 1 - paper/paper.md | 2 +- 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/paper/paper.bib b/paper/paper.bib index cc5fe46c..b6b6f0d3 100644 --- a/paper/paper.bib +++ b/paper/paper.bib @@ -257,4 +257,3 @@ @article{bamane_wetting_2021 langid = {english}, file = {Bamane et al. - 2021 - Wetting Simulations of High-Performance Polymer Re.pdf:/home/marjan/Zotero/storage/JPFTYNU9/Bamane et al. - 2021 - Wetting Simulations of High-Performance Polymer Re.pdf:application/pdf}, } - diff --git a/paper/paper.md b/paper/paper.md index 8221842c..ddd8cb3f 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -58,7 +58,7 @@ involves: (a) gaining new software development skills and knowledge, and Recent advances in open-source tools have made the programmatic specification of molecular simulation components easier than ever -[@hoomd_2019; @lammps_2022; @eastman2017openmm; @Klein2016mBuild; @gmso; @parmed; +[@hoomd_2019; @lammps_2022; @eastman2017openmm; @Klein2016mBuild; @gmso; @parmed; @Santana-Bonilla_2023; @polyply_2022; @biosimspace_2019; @martin2018pyprism]. Individually, each of these tools lower the cognitive load of one aspect of an overall workflow such as representing molecules, building initial structures, From f4ceaa043bfe46cebcdf68e6eb080a53ed386bc0 Mon Sep 17 00:00:00 2001 From: marjanalbouye Date: Mon, 16 Oct 2023 09:56:59 -0600 Subject: [PATCH 52/54] update push path --- .github/workflows/draft-pdf.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/draft-pdf.yml b/.github/workflows/draft-pdf.yml index e0fd2d0d..9dae1d0c 100644 --- a/.github/workflows/draft-pdf.yml +++ b/.github/workflows/draft-pdf.yml @@ -3,7 +3,7 @@ on: # Action will run when any changes to these paths are pushed or pr'ed to master branches: [ joss ] paths: - - flowermd/** + - paper/** - .github/workflows/draft-pdf.yml pull_request: branches: [ joss ] From 3ea3259925c201a53f504fab8e03a5b053f1ec90 Mon Sep 17 00:00:00 2001 From: erjank Date: Mon, 16 Oct 2023 10:00:28 -0600 Subject: [PATCH 53/54] Added COI statement --- paper/paper.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/paper/paper.md b/paper/paper.md index ddd8cb3f..d4b42ad2 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -153,5 +153,10 @@ Administration (NASA) under the University Leadership Initiative program; grant number 80NSSC20M0165. This material is based upon work supported by the National Science Foundation under Grant Numbers: 1653954, 1835593, and 2118217. +No sponsor had any involvement in the development of `flowerMD`. + +# Conflict of Interest Statement +The authors declare the absence of any conflicts of interest: No author has any financial, +personal, professional, or other relationship that affect our objectivity toward this work. # References From 741f97d8f24cfe0ca93297669f669004b18be236 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 16 Oct 2023 16:02:43 +0000 Subject: [PATCH 54/54] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- paper/paper.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index d4b42ad2..1cdac499 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -153,10 +153,10 @@ Administration (NASA) under the University Leadership Initiative program; grant number 80NSSC20M0165. This material is based upon work supported by the National Science Foundation under Grant Numbers: 1653954, 1835593, and 2118217. -No sponsor had any involvement in the development of `flowerMD`. +No sponsor had any involvement in the development of `flowerMD`. # Conflict of Interest Statement -The authors declare the absence of any conflicts of interest: No author has any financial, +The authors declare the absence of any conflicts of interest: No author has any financial, personal, professional, or other relationship that affect our objectivity toward this work. # References