TOC update

README.md

 1. [ RBComb Simulation Framework. ](#RSF)
 2. [ Classes. ](#Classes)
    - [ Vec2. ](#vec2)
+   - [ Diagonalizer. ](#diagonalizer)
+   - [ Drum. ](#drum)
+   - [ Force. ](#force)
+   - [ Driver. ](#driver)
+   - [ Coupler. ](#coupler)
+   - [ LatticeGenerator. ](#latticegenerator)
+     - [ Neighbour Ordering Convention. ](#noc)
+     - [ Inexistent Neighbour Convention. ](#inc)
+   - [ MatrixElementCalculator. ](#mec)
+   - [ Rk4Stepper ](#rk4s)
 
 
 
@@ -55,6 +65,7 @@ where it improves legibility. Consult the source files for more information.
      - `[]` with `std::size_t`
      - `<<` with `std::ostream`
 
+<a name="diagonalizer"></a>
 ### Type `Diagonalizer` (diagonalizer.hpp), class to diagonalize symmetric Matrices
 1. Member functions
    - `std::vector<double> ev(std::vector<double> mat, size_t N)`
@@ -66,6 +77,7 @@ where it improves legibility. Consult the source files for more information.
 2. Further developments
    - Only finding eigenvectors and -values in a certain range may be added later on
 
+<a name="drum"></a>
 ### Template Type `Drum` (drum.hpp), represents a single drum top resonator
 1. Template arguments
    - `value_t`: Scalar type
@@ -101,6 +113,7 @@ this class is `delete`'d. It should be constructed from an object of type `param
 Abstract interfaces for `params_t` and `vars_t` could be added, but they would
 be trivial.
 
+<a name="force"></a>
 ### Interface template type `Force` (force.hpp), force functional
 1. Template arguments
    - `value_t`: Scalar type
@@ -121,6 +134,7 @@ access members `get_parameters()` and `get_variables()`. The `time` argument of
 functional exists to fit special cases as well. The file `include/force_simple.hpp`
 showcases how a real force functional could be written.
 
+<a name="driver"></a>
 ### Interface template type `Driver` (driver.hpp), calculate drive of drums
 1. Template arguments
    - `value_t`: Scalar type
@@ -150,6 +164,7 @@ The functional should return the current drive on the drum with index passed as
 
 An example implementation of a `Driver` is shown in `include/driver_simple.hpp`.
 
+<a name="coupler"></a>
 ### Interface template type `Coupler` (coupler.hpp), calculate couplings between drums
 1. Template arguments
    - `value_t`: Scalar type
@@ -179,6 +194,7 @@ The functional should return the current coupling between the two drums with ind
 
 An example implementation of a `Coupler` is shown in `include/coupler_simple.hpp`.
 
+<a name="latticegenerator"></a>
 ### Interface template type `LatticeGenerator` (lattice_generator.hpp), generates drum lattices
 1. Template arguments
    - `value_t`: Scalar type
@@ -206,6 +222,7 @@ differently.
    - `params_t`
      - Existence of `position` member
 
+<a name="noc"></a>
 #### Neighbour ordering convention
 An important note is the __convention of neighbour ordering__. Each drum has neighbours 0 thru 3.
 For drums in different sublattices, these neighbours are:
@@ -224,6 +241,7 @@ are assumed to respect the above convention. Note that with this convention,
 neighbours see each other as the same neighbour index (the i-th neighbour of j
   sees j as its i-th neighbour). __Never violate this convention__.
 
+<a name="inc"></a>
 #### Inexistent neighbour convention
 Another __convention__ concerns __inexistent neighbours__. For that purpose, this class should append
 an auxiliary drum to the end of the drum vector. If neighbour i of a drum does not exist
@@ -232,6 +250,7 @@ auxiliary drum, i.e. it will show an index `drum_vec.size()`. All couplings of t
 drum are to be kept at 0. This condition can then be applied in force calculation to avoid branching,
 if one uses the couplings of the neighbours instead of the considered drum.
 
+<a name="mec"></a>
 ### Interface template `MatrixElementCalculator` (matrix_element_calculator.hpp), calculates matrix elements
 1. Template arguments
    - `value_t`: Scalar type
@@ -264,6 +283,7 @@ the individual functions correctly to accomodate the correct neighbours.
      - `get_parameters()`
      - `get_variables()`
 
+<a name="rk4s"></a>
 ### Template Type `Rk4Stepper` (rk4_stepper.hpp), performs timesteps using rk4 scheme
 1. Template arguments
    - `value_t`: Scalar type