Merge pull request #93 from ChrisRackauckas/fix-formatting

Apply JuliaFormatter to fix code formatting

Author: ChrisRackauckas

docs/make.jl

@@ -6,13 +6,13 @@ cp("./docs/Project.toml", "./docs/src/assets/Project.toml", force = true)
 include("pages.jl")
 
 makedocs(sitename = "NbodySimulator.jl",
-         authors = "Chris Rackauckas",
-         modules = [NBodySimulator],
-         clean = true, doctest = false, linkcheck = true,
-         warnonly = [:docs_block, :missing_docs],
-         format = Documenter.HTML(assets = ["assets/favicon.ico"],
-                                  canonical = "https://docs.sciml.ai/NBodySimulator/stable/"),
-         pages = pages)
+    authors = "Chris Rackauckas",
+    modules = [NBodySimulator],
+    clean = true, doctest = false, linkcheck = true,
+    warnonly = [:docs_block, :missing_docs],
+    format = Documenter.HTML(assets = ["assets/favicon.ico"],
+        canonical = "https://docs.sciml.ai/NBodySimulator/stable/"),
+    pages = pages)
 
 deploydocs(repo = "github.com/SciML/NBodySimulator.jl.git";
-           push_preview = true)
+    push_preview = true)

docs/pages.jl

@@ -3,5 +3,5 @@
 pages = [
     "Home" => "index.md",
     "examples.md",
-    "nbodysimulator.md",
+    "nbodysimulator.md"
 ]

docs/src/index.md

@@ -85,8 +85,8 @@ The Lennard-Jones potential is used in molecular dynamics simulations to approxi
 
 ```julia
 system = PotentialNBodySystem(bodies,
-                              Dict(:gravitational => g_parameters,
-                                   :electrostatic => el_potential))
+    Dict(:gravitational => g_parameters,
+        :electrostatic => el_potential))
 ```
 
 ### Custom Potential
@@ -108,7 +108,7 @@ Next, the acceleration function for the potential is required. The custom potent
 ```julia
 import NBodySimulator.get_accelerating_function
 function get_accelerating_function(p::CustomPotentialParameters,
-                                   simulation::NBodySimulation)
+        simulation::NBodySimulation)
     ms = get_masses(simulation.system)
     (dv, u, v, t, i) -> begin
         custom_accel = SVector(0.0, 0.0, p.a)
@@ -165,10 +165,14 @@ And, finally, we can animate our solution, showing two equal bodies rotating on
 using Plots
 animate(sim_result, "path_to_animated_particles.gif")
 ```
+
 ![Chaotic behavior of the Lorenz system](https://user-images.githubusercontent.com/16945627/39958539-d2cf779c-561d-11e8-96a8-ffc3a595be8b.gif)
+
 ### Electrostatic Interaction
+
 Interaction between charged particles obeys Coulomb's law. The movement of such bodies can be simulated using `ChargedParticle` and `ChargedParticles` structures.
 The following example shows how to model two oppositely charged particles. If one body is more massive than another, it will be possible to observe the rotation of the light body around the heavy one without adjusting their positions in space. The constructor for the `ChargedParticles` system requires bodies and Coulomb's constant `k` to be passed as arguments.
+
 ```julia
 r = 100.0 # m
 q1 = 1e-3 # C
@@ -183,9 +187,12 @@ system = ChargedParticles([p1, p2], k)
 simulation = NBodySimulation(system, (0.0, t))
 sim_result = run_simulation(simulation)
 ```
+
 ### Magnetic Interaction
+
 An N-body system consisting of `MagneticParticle`s can be used for the simulation of interacting magnetic dipoles, though such dipoles cannot rotate in space. Such a model can represent single domain particles interacting under the influence of a strong external magnetic field.
 To create a magnetic particle, one specifies its location in space, velocity, and the vector of its magnetic moment. The following code shows how we can construct an iron particle:
+
 ```julia
 iron_dencity = 7800 # kg/m^3
 magnetization_saturation = 1.2e6 # A/m
@@ -195,27 +202,35 @@ v = SVector(0.0, 0.0, 0.0) # m/s
 magnetic_moment = SVector(0.0, 0.0, magnetization_saturation * mass / iron_dencity) # A*m^2
 p1 = MagneticParticle(r, v, mass, magnetic_moment)
 ```
+
 For the second particle, we will use a shorter form:
+
 ```julia
 p2 = MagneticParticle(SVector(0.005, 0.0, 0.0), SVector(0.0, 0.0, 0.0), 5e-6,
-                      SVector(0.0, 0.0, 0.00077))
+    SVector(0.0, 0.0, 0.00077))
 ```
+
 To calculate magnetic interactions properly, one should also specify the value for the constant μ0/4π or its substitute. Having created parameters for the magnetostatic potential, one can now instantiate a system of particles that should interact magnetically. For that purpose, we use `PotentialNBodySystem` and pass particles and potential parameters as arguments.
+
 ```julia
 parameters = MagnetostaticParameters(μ_4π)
 system = PotentialNBodySystem([p1, p2], Dict(:magnetic => parameters))
 simulation = NBodySimulation(system, (t1, t2))
 sim_result = run_simulation(simulation, VelocityVerlet(), dt = τ)
 ```
+
 ## Molecular Dynamics (MD)
+
 NBodySimulator allows one to conduct molecular dynamic simulations for the Lennard-Jones liquids, the SPC/Fw model of water, and other molecular systems thanks to implementations of basic interaction potentials between atoms and molecules:
+
   - Lennard-Jones
   - electrostatic and magnetostatic
   - harmonic bonds
   - harmonic valence angle generated by pairs of bonds
-The comprehensive examples of liquid argon and water simulations can be found in the `examples` folder.
-Here only the basic principles of the molecular dynamics simulations using NBodySimulator are presented using liquid argon as a classical MD system for beginners.
-First, one needs to define the parameters of the simulation:
+    The comprehensive examples of liquid argon and water simulations can be found in the `examples` folder.
+    Here only the basic principles of the molecular dynamics simulations using NBodySimulator are presented using liquid argon as a classical MD system for beginners.
+    First, one needs to define the parameters of the simulation:
+
 ```julia
 T = 120.0 # °K
 T0 = 90.0 # °K
@@ -233,110 +248,156 @@ bodies = generate_bodies_in_cell_nodes(N, m, v_dev, L)
 t1 = 0.0
 t2 = 2000τ
 ```
+
 Liquid argon consists of neutral molecules, so the Lennard-Jones potential runs their interaction:
+
 ```julia
 parameters = LennardJonesParameters(ϵ, σ, R)
 lj_system = PotentialNBodySystem(bodies, Dict(:lennard_jones => parameters));
 ```
+
 Then, a thermostat and boundary conditions should be selected and instantiated:
+
 ```julia
 thermostat = NoseHooverThermostat(T0, 200τ)
 pbc = CubicPeriodicBoundaryConditions(L)
 simulation = NBodySimulation(lj_system, (t1, t2), pbc, thermostat, kb);
 result = run_simulation(simulation, VelocityVerlet(), dt = τ)
 ```
+
 It is recommended to use `CubicPeriodicBoundaryConditions` since cubic boxes are among the most popular boundary conditions in MD. There are different variants of the `NBodySimulation` constructor for MD:
+
 ```julia
 simulation = NBodySimulation(lj_system, (t1, t2));
 simulation = NBodySimulation(lj_system, (t1, t2), pbc);
 simulation = NBodySimulation(lj_system, (t1, t2), pbc, thermostat);
 simulation = NBodySimulation(lj_system, (t1, t2), pbc, thermostat, kb);
 ```
+
 The default boundary conditions are `InfiniteBox` without any limits, the default thermostat is `NullThermostat` (which does no thermostating), and the default Boltzmann constant `kb` equals its value in SI, i.e., 1.38e-23 J/K.
+
 ## Water Simulations
+
 In NBodySImulator the [SPC/Fw water model](http://www.sklogwiki.org/SklogWiki/index.php/SPC/Fw_model_of_water) is implemented. For using this model, one has to specify parameters of the Lennard-Jones potential between the oxygen atoms of water molecules, parameters of the electrostatic potential for the corresponding interactions between atoms of different molecules, and parameters for harmonic potentials representing bonds between atoms and the valence angle made from bonds between hydrogen atoms and the oxygen atom.
+
 ```julia
 bodies = generate_bodies_in_cell_nodes(N, mH2O, v, L)
 jl_parameters = LennardJonesParameters(ϵOO, σOO, R)
 e_parameters = ElectrostaticParameters(k, Rel)
 spc_parameters = SPCFwParameters(rOH, ∠HOH, k_bond, k_angle)
 water = WaterSPCFw(bodies, mH, mO, qH, qO, jl_parameters, e_parameters, spc_parameters);
 ```
+
 For each water molecule here, `rOH` is the equilibrium distance between a hydrogen atom and the oxygen atom, `∠HOH` denotes the equilibrium angle made of those two bonds, `k_bond` and `k_angle` are the elastic coefficients for the corresponding harmonic potentials.
 Further, one can pass the water system into the `NBodySimulation` constructor as a usual system of N-bodies.
+
 ```julia
 simulation = NBodySimulation(water, (t1, t2), pbc, kb);
 ```
+
 ## Thermostats
+
 Usually, during the simulation, a system is required to be at a particular temperature. NBodySimulator contains several thermostats for that purpose. Here the thermostating of liquid argon is presented, for thermostating of water, one can refer to [this post](https://mikhail-vaganov.github.io/gsoc-2018-blog/2018/08/06/thermostating.html).
+
 ### [Andersen Thermostat](http://www.sklogwiki.org/SklogWiki/index.php/Andersen_thermostat)
+
 ```julia
 τ = 0.5e-3 # timestep of integration and simulation
 T0 = 90
 ν = 0.05 / τ
 thermostat = AndersenThermostat(90, ν)
 ```
+
 ![andersen thermostating](https://user-images.githubusercontent.com/16945627/44002487-cd99653a-9e5c-11e8-8481-78945a930d94.png)
-### [Berendsen Thermostat](https://www2.mpip-mainz.mpg.de/~andrienk/journal_club/thermostats.pdf)
+
+### [Berendsen Thermostat](https://www2.mpip-mainz.mpg.de/%7Eandrienk/journal_club/thermostats.pdf)
+
 ```julia
 τB = 2000τ
 thermostat = BerendsenThermostat(90, τB)
 ```
+
 ![berendsen thermostating](https://user-images.githubusercontent.com/16945627/44002495-f07e164a-9e5c-11e8-8db7-16c09a7631cd.png)
+
 ### [Nosé–Hoover Thermostat](http://www.sklogwiki.org/SklogWiki/index.php/Nos%C3%A9-Hoover_thermostat)
+
 ```julia
 τNH = 200τ
 thermostat = NoseHooverThermostat(T0, 200τ)
 ```
+
 ![nose-hoover thermostating](https://user-images.githubusercontent.com/16945627/44002501-ffc1aea0-9e5c-11e8-857b-9e3c83197336.png)
+
 ### Langevin Thermostat
+
 ```julia
 γ = 10.0
 thermostat = LangevinThermostat(90, γ)
 ```
+
 ![langevin thermostating](https://user-images.githubusercontent.com/16945627/44002505-0683c6b0-9e5d-11e8-8647-5b15b98eb0fa.png)
+
 ## Analyzing the Results of the Simulation
+
 Once the simulation is completed, one can analyze the result and obtain some useful characteristics of the system.
 The function `run_simulation` returns a structure containing the initial parameters of the simulation and the solution of the differential equation (DE) required for the description of the corresponding system of particles. There are different functions that help to interpret the solution of DEs into physical quantities.
 One of the main characteristics of a system during molecular dynamics simulations is its thermodynamic temperature. The value of the temperature at a particular time `t` can be obtained by calling this function:
+
 ```julia
 T = temperature(result, t)
 ```
+
 ### [Radial distribution functions](https://en.wikipedia.org/wiki/Radial_distribution_function)
+
 The RDF is another popular and essential characteristic of molecules or similar systems of particles. It shows the reciprocal location of particles averaged by the time of simulation.
+
 ```julia
 (rs, grf) = rdf(result)
 ```
+
 The dependence of `grf` on `rs` shows the radial distribution of particles at different distances from an average particle in a system.
 Here, the radial distribution function for the classic system of liquid argon is presented:
 ![rdf for liquid argon](https://user-images.githubusercontent.com/16945627/43990348-843b164c-9d74-11e8-8d9e-daaff142c0b7.png)
+
 ### Mean Squared Displacement (MSD)
+
 The MSD characteristic can be used to estimate the shift of particles from their initial positions.
+
 ```julia
 (ts, dr2) = msd(result)
 ```
+
 For a standard liquid argon system, the displacement grows with time:
 ![rdf for liquid argon](https://user-images.githubusercontent.com/16945627/43990362-9a67c0aa-9d74-11e8-9512-08840294d411.png)
+
 ### Energy Functions
+
 Energy is a highly important physical characteristic of a system. The module provides four functions to obtain it, though the `total_energy` function just sums potential and kinetic energy:
+
 ```julia
 e_init = initial_energy(simulation)
 e_kin = kinetic_energy(result, t)
 e_pot = potential_energy(result, t)
 e_tot = total_energy(result, t)
 ```
+
 ## Plotting Images
+
 Using the tools of NBodySimulator, one can export the results of a simulation into a [Protein Database File](https://en.wikipedia.org/wiki/Protein_Data_Bank_(file_format)). [VMD](http://www.ks.uiuc.edu/Research/vmd/) is a well-known tool for visualizing molecular dynamics, which can read data from PDB files.
+
 ```julia
 save_to_pdb(result, "path_to_a_new_pdb_file.pdb")
 ```
+
 In the future, it will be possible to export results via the FileIO interface and its `save` function.
 Using Plots.jl, one can draw the positions of particles at any time of simulation or create an animation of moving particles, molecules of water:
+
 ```julia
 using Plots
 plot(result)
 animate(result, "path_to_file.gif")
 ```
+
 Makie.jl also has a recipe for plotting the results of N-body simulations. The [example](https://github.com/MakieOrg/Makie.jl/blob/master/ReferenceTests/src/tests/recipes.jl) is presented in the documentation.
 
 ## Contributing
@@ -356,40 +417,51 @@ Makie.jl also has a recipe for plotting the results of N-body simulations. The [
       + See also [SciML Community page](https://sciml.ai/community/)
 
 ## Reproducibility
+
 ```@raw html
 <details><summary>The documentation of this SciML package was built using these direct dependencies,</summary>
 ```
+
 ```@example
 using Pkg # hide
 Pkg.status() # hide
 ```
+
 ```@raw html
 </details>
 ```
+
 ```@raw html
 <details><summary>and using this machine and Julia version.</summary>
 ```
+
 ```@example
 using InteractiveUtils # hide
 versioninfo() # hide
 ```
+
 ```@raw html
 </details>
 ```
+
 ```@raw html
 <details><summary>A more complete overview of all dependencies and their versions is also provided.</summary>
 ```
+
 ```@example
 using Pkg # hide
 Pkg.status(; mode = PKGMODE_MANIFEST) # hide
 ```
+
 ```@raw html
 </details>
 ```
+
 ```@raw html
 You can also download the 
 <a href="
 ```
+
 ```@eval
 using TOML
 using Markdown

examples/liquid_argon.jl

@@ -22,7 +22,7 @@ function generate_random_directions(n::Int)
     directions = [@SVector [
                       sin(theta[i]) .* cos(phi[i]),
                       sin(theta[i]) .* sin(phi[i]),
-                      cos(theta[i]),
+                      cos(theta[i])
                   ] for i in 1:n]
 end
 

examples/liquid_argon_reduced.jl

@@ -27,7 +27,7 @@ bodies = generate_bodies_in_cell_nodes(N, _m, _v, _L)
 parameters = LennardJonesParameters(_ϵ, _σ, _R)
 lj_system = PotentialNBodySystem(bodies, Dict(:lennard_jones => parameters));
 simulation = NBodySimulation(lj_system, (_t1, _t2), CubicPeriodicBoundaryConditions(_L),
-                             _ϵ / T);
+    _ϵ / T);
 #result = run_simulation(simulation, Tsit5())
 result = @time run_simulation(simulation, VelocityVerlet(), dt = _τ)