In general, I think this book could serve as a good guide for starters to get familiar with molecular dynamics conceptions and LAMMPS, a powerful MD simulation software, along with its source command.What I like about this book:This book provides C++ source codes with detailed explanations, and explains how the source code works when LAMMPS commands are deployed. The authors also explained the hierarchy of LAMMPS source code. With all the screenshots and examples, this book is quite straightforward to understand, and is very helpful to students to understand how to program the formulas into code, especially for those who does not have much coding experience. You could get some hand-on experience by following the illustrations, even if you have never used C++ before.What I feel uncertain about this book:Given that readers of this book may be students who major in STEM programs and are likely to be pursuing advanced degrees in this field, the physics seems to be quite simple for readers. It would be better if there are more examples with complicated situations (multi-body potential, for instance).

This book is an excellent guide for beginner developers that wish to learn how to modify LAMMPS and is also a good reference for more experienced developers. The explanations are thorough and there are many examples.

Highly recommend for MD LAMMPS users to understand each and every line of program, physics behind and enhance the lammps calculation capabilities according to need.

It is an extremely helpful book for everybody who wants to implement new things in the LAMMPS code

This book is a bit of an odd-ball, but not in a negative sense. While there are good books that focus extensively on molecular dynamics theory that in addition sometimes provide small snippets of example code, this book is the first that I know of that dedicates itself, in detail, to how the internals of such an engine work and on how to modify it to your own needs. Because of its design, LAMMPS is especially well-suited for modifications and extensions by end users, so it is an obvious choice for this book.One down-side of this is that LAMMPS is always changing, sometimes quite extensively, so some parts of the book are likely to become out-dated at some point. For this reason, the authors choose to focus on the “stable” version of LAMMPS from March 3, 2020. Still, a lot of the skills obtained by going through this book should transfer well to later versions even if some of the details have changed, and for changes that occurred during the writing of this book the authors provide notes detailing the changes.It starts with a small chapter on the basics of molecular dynamics (MD) simulations where very briefly some concepts that appear in LAMMPS are explained, but for extensive treatment of the details the authors defer to the classical books by Computer Simulation of Liquids by Allen and Tildesley and Understanding Molecular Simulation by Frenkel and Smit. In short, they explain forces arising from a potential, updating positions and velocities with the velocity Verlet scheme and briefly explain rotational motion.They then discuss periodic boundary conditions and neighbor lists, which is pretty standard, but also explain the distributed memory parallelization through spatial decomposition.The second chapter of the first section is where the focus on LAMMPS really takes of. The authors introduce LAMMPS' scripting language, the structure of the source code and the hierarchy of the various classes. Most importantly, it highlights a selection of the special member functions that a lot of the LAMMPS classes (“styles”) possess that are called at specific steps of the time integration loop. These functions are important because virtually all LAMMPS functionality makes use of these functions to ensure that everything happens at the correct time.For some reason the chapter does not go into the compilation process itself, that is deferred to an appendix where it is explained in great detail. Perhaps this is done because the exact way to compile is subject to more change than the source code hierarchy itself.Chapter 4 explains how one can access various internal data structures that hold positions, velocities, forces, atom IDs, atom types, etc. It also explains how global and local atom IDs work, which is good because this can be a bit unintuitive for the uninitiated. Neighbor lists are discussed next, which are a requirement for calculating forces efficiently but are also very useful for any type of computation that requires information about which atoms are in proximity of the others, a prime being the computation of the radial distribution function.The various unit systems in LAMMPS are also explained, which is important because LAMMPS supports various unit systems (SI, Lennard-Jones, “metal”) whose reference units make sense for the system under consideration. For example, for simulations involving metals, energy expressed in electronvolts (eV) makes more sense than kcal/mol which is customary for biophysical simulations.This chapter lastly focuses on how the LAMMPS engine reads and parses input scripts, which is essential to know because all extensions to LAMMPS have to be invoked through the scripting language, and hence some parsing of these commands is required.At Chapters 5 to 8 we really dive deep into the inner workings of LAMMPS, and the authors explore in detail how pair styles (LAMMPS terminology for pairwise forces), compute styles (styles that compute physical quantities not necessarily related to the dynamics of the atoms themselves) and fix styles work.Fixes are classes that modify atom positions, velocities, forces, etc. to somehow modify the dynamics of the system. For example, the simple velocity Verlet time integrator is implemented as a fix, as is the Langevin thermostat, the SHAKE constraint algorithm, walls, etc. While at a first glance it seems somewhat strange to decouple time integration from the conceptual velocity Verlet loop of (update position –> calculate new forces –> update velocity), setting it up this way allows one to use a lot of different fixes together to create new functionality.The authors do a good job of thoroughly studying the pair styles, including memory allocation, initial setup, parsing of the lines from the input script and the actual force and energy computation. In particular, it is good that the authors refer back to the initial chapter because some of the internals in LAMMPS might be counter-intuitive at first (like the fact that the internal “fpair” variable has units of force per distance).While computes are conceptually similar or perhaps simpler than pair styles, one complication they have over pair styles is dealing with the distributed memory parallelization. A pair style only has to compute local forces and LAMMPS takes care of the proper communication between processors, but computes require some additional synchronization between processors by the programmer. Do not be intimidated though, often a couple of MPI_Allreduce suffice, and the authors walk you through it for compute styles for the total kinetic energy, collective interaction energies and forces between specified groups of atoms, the radial distribution function, and the heat flux. For more involved MPI-related information there is a dedicated appendix.Chapter 7 focuses on a handful of fix styles in increasing degrees of complexity, making sure to explain along the way the flag that indicates which member functions of the fixes need calling, starting from a fix that simply adds an external force to atoms to culminating in a time integration method for rigid bodies.In chapters 5 to 7, some of the styles explored made use of supporting classes, which are explored in more detail here.Section 3 gets to the heart of this book: Explaining how to modify LAMMPS to add new functionality. The examples they use are fairly simple so that one does not get lost into the details of what is being implemented and instead can focus on how it is implemented. The described methods naturally generalize to more complex functionality. The authors also go into detail about sanity checks to verify the implemented modifications. They describe in detail various custom fixes and pair styles to add custom forces, potentials and thermostats, such that they touch upon various kinds of different functionality. The selection the authors made should provide good starting points for most custom pair styles and/or fixes, so that one does not have to start from scratch.I think the book definitely achieves its goal of providing a very thorough description on how LAMMPS works and how to modify it to suit your own needs. While for small modifications it might be overkill, it will definitely help the reader form a much better understanding of how LAMMPS works and how to do things properly than by just copying a similar style and modifying it.I do have some criticisms not directly related to the content but that do detriment the quality of the book somewhat:The type-setting of equations is a little shoddy, with some stand-alone formulas having different font sizes.The code snippets and even some tables are screenshots which means that in the e-book, the text is not highlightable or selectable.Still, I would recommend the book to anyone that is serious about diving into LAMMPS to implement their own features.Full disclosure: I got a free ebook copy of this book from the publisher for review.