documentation update

ChangeLog.md

@@ -2,6 +2,10 @@
 
 ### Changes in progress
 
+*
+
+### version 0.6.2
+
 * Implement cell division in both vertex and Voronoi models
 * Major bug fix in "quadratic" vertex model force computations
 

INSTALLATION.md

@@ -12,42 +12,26 @@ CUDA-8.0. The code has been tested with CUDA versions as early as 6.5, and uses
 3.5 devices and higher. It ought to work on lower compute capability devices; compile without the
 "-arch=sm_35" flag to run on them.
 
-The SPV branch uses the CGAL library; this dependency can be removed, if necessary, by monkeying
+The Voronoi model branch uses the CGAL library; this dependency can be removed, if necessary, by monkeying
 with the code to run "fullTriangulation()" rather than "globalTriangulationCGAL()" in the relevant
 spots. This is highly discouraged, and the code may be much less stable as a result. In any event,
 CGAL-4.9 was used, which in turn requires up to date versions of the gmp and mpfr libraries.
 The code was developed and tested against gmp-6.1.2 and mpfr-3.1.5.
 
-The database class uses the netCDF-4 C++  library (tested on version 4.1.3).The dependency on netCDF
+The default database class uses the netCDF-4 C++  library (tested on version 4.1.3).The dependency on netCDF
 can be removed by (1) not including any "Database" class, and (2) commenting out everything after the
 = sign in the LIB_NETCDF entry of the makefile
 
 The calculation of the dynamical matrix makes use of Eigen3.3.3
 
 Documentation is maintained via doxygen, but is not required for compilation of the executables.
 
-The makefile system is scheduled to be replaced, and will soon change to require cmake.
-
 # Sample programs
 
-The included makefile compiles four programs: avmGPU, spvGPU, spvMSD, and Minimize.out. The first two generate timing
-information, and the "Timing.sh" script shows an example of how to quickly call these programs for a
+This repository comes with sample main cpp files that can be compiled into executables in both the root directory
+and in examples/. Please see the [examples](@ref code) documentation for details on each.
 range of parameters.
 
-The third program, spvMSD, uses netCDF to save positional data (log spaced) for a simulation
-of monodisperse cells in the SPV model (as compiled the .nc file will be saved to the current directory).
-The file also contains a command line argument that allows for the system to be run under Brownian dynamics
-rather than as a non-equilibrium active matter model. In any event, analyzing the saved positional data, for
-instance by computing the mean squared displacement, can be used to confirm the correct operation of the
-program. The included "Msd.sh" script will generate some data that can be analyzed and directly compared
-with Fig. 1 of Bi et al. (Phys. Rev. X 6, 021011 (2016)), which is the cannonical reference for the SPV model.
-
-The fourth program, Minimize.out, shows how to use the included FIRE minimizer to do simple energy minimization.
-
-The fifth program, DynamicalMatrix.out, shows how to use the Eigen interface to compute the dynamical matrix of
-Voronoi systems (with quadratic perimeter terms) and extract the eigenvalues/eignevectors. This code is rather
-specialized, and not as general as one would ultimately like to see.
-
 # Mac OS X Instructions
 
 The following instructions for compiling cellGPU on Mac OSX  were contributed by Gonca Erdemci-Tandogan (https://goncaerdemci.wordpress.com/).

LICENSE.md

@@ -51,7 +51,7 @@ application with a different version of Burkardt's LGPL source code. As such Cel
 under a non-(L)GPL license. Credit for this library, of course, goes to John Burkardt:
 https://people.sc.fsu.edu/~jburkardt/cpp_src/hilbert_curve/hilbert_curve.html
 
-(3) eigenMatrixInterface.h/.cpp interface with, indeed, the Eigen library. Eigen is Free Software,
+(3) eigenMatrixInterface.h/.cpp interfaces with, indeed, the Eigen library. Eigen is Free Software,
 available from eigen.tuxfamily.org/. It is licensed under the MPL2. See https://www.mozilla.org/en-US/MPL/2.0/ for more details.
 
 (4) Finally, the cellGPU logo was made by using the ``Lincoln Experiments'' project,

README.md

@@ -12,7 +12,7 @@ http://www.sciencedirect.com/science/article/pii/S0010465517301832
 
 Information on installing the project and contributing to it is contained in the relevant
 markdown files in the base directory and in the doc/markdown directory. Documentation of the
-code is maintained via Doxygen, and all of the links in this readme function only in the Doxygen
+code is maintained via Doxygen, and all of the links in this readme only function in the Doxygen
 documentation (link above, or compile it by going to the "/doc" directory and typing "doxygen Doxyfile"
 
 A very rough outline of some of the main classes and the basic operating flow of the primary branches

doc/Doxyfile

@@ -38,7 +38,7 @@ PROJECT_NAME           = "CellGPU"
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = "0.6.0"
+PROJECT_NUMBER         = "0.6.2"
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

doc/cellGPUdocumentation

@@ -38,7 +38,7 @@ PROJECT_NAME           = "CellGPU"
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = "0.6.1"
+PROJECT_NUMBER         = "0.6.2"
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

doc/markdown/BasicInformation.md

@@ -30,7 +30,7 @@ and finding all points in the circumcircle of the point and any two consecutive
 
 * DelaunayMD -- A core engine that operates as described below in ''Basic idea.'' Can move particles
 and update their underlying Delaunay triangulation
-* SPV2D -- A child class of DelaunayMD that calculates forces according to the 2D SPV model.
+* Voronoi2D -- A child class of DelaunayMD that calculates forces according to the 2D Voronoi model.
 * AVM2D -- A child of Simple2DActiveCell that calculates forces for a simple 2D ("active") vertex model
 where the topology changes via a simple rule for T1 transitions
 
@@ -50,7 +50,7 @@ Gaussian noise, simulating an overdamped langevin equation at some temperature
 * EnergyMinimizerFIRE -- provides an interface to a FIRE minimizer that is modeled on the simpleEquationOfMotion
 class.
 
-## Basic idea of SPV hybrid operation
+## Basic idea of Voronoi model hybrid operation
 
 The following describes the basic operation of the DelaunayMD class
 * (1) CPU STEP: If necessary (ie. after initialization, or after a timestep where a lot of neighbors
@@ -71,7 +71,7 @@ the cycle of (2)-(5) can repeat.
 ## Basic idea of AVM GPU-only operation
 
 The following describes the basic operation of the active-vertex model class included. It is much
-simpler than the SPV branch!
+simpler than the Voronoi branch!
 * (1) CPU STEP: Initialize a domain of cells in some way. Currently a CGAL triangulation of a random
 point set is used.
 * (2) GPU STEP: Compute the geometry of the cells, taking into account possible self-intersections

doc/markdown/CITATIONS.md

@@ -2,7 +2,7 @@
 
 If you use cellGPU for a publication or project, please site the main cellGPU paper:
 
-(1) "cellGPU: massively parallel simulations of dynamic vertex models" https://arxiv.org/abs/1702.02939
+(1) "cellGPU: massively parallel simulations of dynamic vertex models" Daniel M. Sussman; Computer Physics Communications, volume 219, pages 400-406, (2017)
 
 Additional citation to consider:
 

doc/markdown/CONTRIBUTING.md

@@ -1,7 +1,7 @@
 # Contributing to cellGPU {#contrib}
 
 Contributions are welcomed via pull requests on the repository homepage! Before beginning work and
-submitting a pull request, please contact the lead developer (currently Daniel M. Sussman) to see
+submitting a pull request, please contact the lead developer (currently Daniel Sussman) to see
 if your intended feature is under development by anyone else at the moment and to make sure your plans
 match up well with the existing code base.
 
@@ -66,9 +66,10 @@ Every class, member, function, etc., should be documented with doxygen comments.
 ## Directory structure
 
 This repository currently follows a simple structure. The main executables, activeVertex.cpp and
-voronoi.cpp are in the base directory and can be used to reproduce timing information. Header files
-are in inc/, source files are in src/, and object files get put in obj/ and obj/cuobj (which are
-.gitignored). A super-explicit makefile is used.
+voronoi.cpp are in the base directory and can be used to reproduce timing information. Other example files are in examples/
+headers and .cu/.cpp files are in inc/ and src/ directories, respectively, with a subdirectory
+structure for updaters, models, utilities, and database creators. Object files get compiled in the obj/ directory.
+.gitignored). A simple makefile is used to compile everything and all cpp files in the root directory.
 
 ### Optimizations
 

doc/markdown/EXAMPLES.md

@@ -13,16 +13,16 @@ reproduce the timing information in the cellGPU paper.
 
 # voronoi.cpp
 
-The same thing, but for running the 2D SPV model
+The same thing, but for running the 2D Voronoi model
 
 # minimize.cpp
 
-Provides an example of using the FIRE minimizer to minimize either a 2D SPV or AVM system.
+Provides an example of using the FIRE minimizer to minimize either a 2D Voronoi or AVM system.
 
 # runMakeDatabase.cpp
 
 Provides an example of using the NetCDF database class to write snapshots of a simulation of the 2D
-SPV model, using either active cell or overdamped Brownian dynamics
+Voronoi model, using either active cell or overdamped Brownian dynamics
 
 # cellDivision.cpp
 

src/models/voronoiModelBase.cpp

@@ -919,7 +919,6 @@ Trigger a cell division event, which involves some laborious re-indexing of vari
 This version uses a heavy-handed approach, hitting the cell positions with a full, global retriangulation
 (rather than just updating the targeted cell and its neighbor with the local topology repair routines).
 If a simulation is needed where the cell division rate is very rapid, this should be improved.
-
 The idea of the division is that a targeted cell will divide normal to an axis specified by the
 angle, theta, passed to the function. The final state cell positions are placed along the axis at a
 distance away from the initial cell position set by a multiplicative factor (<1) of the in-routine determined