Added documentation for most modules

Only Spinors and Dirac are missing.

docs/make.jl

@@ -9,6 +9,10 @@ makedocs(sitename="LatticeGPU", modules=[LatticeGPU], doctest=true,
              "LatticeGPU.jl" => "index.md", 
              "Space-time" => "space.md",
              "Groups and algebras" => "groups.md",
-             "Fields" => "fields.md"
+             "Fields" => "fields.md",
+             "Yang-Mills" => "ym.md",
+             "Gradient flow" => "flow.md",
+             "Schrödinger Functional" => "sf.md",
+             "Input Output" => "io.md"
              ], 
          repo = "https://igit.ific.uv.es/alramos/latticegpu.jl")

docs/src/fields.md

@@ -10,10 +10,11 @@ gauge fields `SU3`, for scalar fields `Float64`). We have:
   direction.
 - `N` scalar fields: `N` elemental types at each spacetime point.
 
-For all these fields the spacetime point are ordered in memory
-according to the point-in-block and block indices (see
-[`SpaceParm`](@ref)). An execption is the [`scalar_field_point`](@ref)
-fields. 
+Fields can have **naturaL indexing**, where the memory layout follows
+the point-in-block and block indices (see
+[`SpaceParm`](@ref)). Fields can also have **lexicographic indexing**,
+where points are labelled by a D-dimensional index (see [`scalar_field_point`](@ref)).
+
 
 ## Initialization
 

docs/src/flow.md

@@ -0,0 +1,47 @@
+# Gradient flow
+
+The gradient flow equations can be integrated in two different ways:
+1. Using a fixed step-size integrator. In this approach one fixes the
+   step size $\epsilon$ and the links are evolved from
+   $V_\mu(t)$ to $V_\mu(t +\epsilon)$ using some integration
+   scheme. 
+1. Using an adaptive step-size integrator. In this approach one fixes
+   the tolerance $h$ and the links are evolved for a time $t_{\rm
+   end}$ (i.e. from $V_\mu(t)$ to $V_\mu(t +t_{\rm end})$)
+   with the condition that the maximum error while advancing is not
+   larger than $h$.
+   
+In general adaptive step size integrators are much more efficient, but
+one loses the possibility to measure flow quantities at the
+intermediate times $\epsilon, 2\epsilon, 3\epsilon,...$. Adaptive
+step size integrators are ideal for finite size scaling studies, while
+a mix of both integrators is the most efficient approach in scale
+setting applications. 
+
+## Integration schemes
+
+```@docs
+FlowIntr
+wfl_euler
+zfl_euler
+wfl_rk2
+zfl_rk2
+wfl_rk3
+zfl_rk3
+```
+
+## Integrating the flow equations
+
+```@docs
+flw
+flw_adapt
+```
+
+## Observables
+
+```@docs
+Eoft_plaq
+Eoft_clover
+Qtop
+```
+

docs/src/groups.md

@@ -153,6 +153,10 @@ projalg
 ## Generic `Algebra` methods
 
 ```@docs
+dot
+norm
+norm2
+normalize
 exp
 expm
 alg2mat

docs/src/io.md

@@ -0,0 +1,14 @@
+
+# Input/Output
+
+## Configurations
+
+Routines to read/write and import gauge configurations.
+```@docs
+read_cnfg
+save_cnfg
+import_bsfqcd
+import_lex64
+import_cern64
+```
+

docs/src/sf.md

@@ -0,0 +1,9 @@
+# Schödinger Functional
+
+Specific SF observables and routines
+
+```@docs
+setbndfield
+sfcoupling
+```
+

docs/src/space.md

@@ -3,7 +3,10 @@
 
 D-dimensional lattice points are labeled by two ordered integer
 numbers: the point-in-block index ($$b$$ in the figure below) and the
-block index ($$r$$ in the figure below). The routines [`up`](@ref) and
+block index ($$r$$ in the figure below). This is called **natural
+indexing**, in contrast with the **lexicographic indexing**  where points on
+the lattice are represented by a D-dimensional `CartesianIndex`.
+The routines [`up`](@ref) and
 [`dw`](@ref) allow you to displace to the neighboring points of the
 lattice. 
 ![D dimensional lattice points are labeled by its

docs/src/ym.md

@@ -0,0 +1,59 @@
+
+# Simulating Yang-Mills on the lattice 
+
+```@docs
+GaugeParm
+YMworkspace
+ztwist
+```
+
+## Gauge actions and forces
+
+Routines to compute the gauge action.
+```@docs
+gauge_action
+```
+
+Routines to compute the force derived from gauge actions. 
+
+```@docs
+force_gauge
+```
+
+### Force field refresh
+
+Algebra fields with **natural indexing** can be randomized.
+```@docs
+randomize!
+```
+
+
+## Basic observables
+
+Some basic observable.
+```@docs
+plaquette
+```
+
+## HMC simulations
+
+### Integrating the EOM
+
+```@docs
+IntrScheme
+leapfrog
+omf2
+omf4
+MD!
+```
+
+### HMC algorithm
+
+```@docs
+hamiltonian
+HMC!
+```
+
+
+
+