Edit tutorial contents

docs/src/assets/edgemodel.tex

@@ -0,0 +1,24 @@
+% \documentclass[tikz,convert={outfile=\jobname.svg}]{standalone}
+\documentclass[tikz,convert=pdf2svg]{standalone}
+%\usetikzlibrary{...}% tikz package already loaded by 'tikz' option
+\usetikzlibrary{arrows, arrows.meta}
+% \tikzset{
+%   >=stealth',
+% }
+\usepackage{amsmath,amssymb}
+\usepackage{tikz}
+\usepackage{xcolor}
+
+\begin{document}
+\begin{tikzpicture}
+  \node[draw, minimum height=1.5cm](n){
+    Edge Model
+  };
+  \draw[->](n.east)++(0,0.4)--++(1.0,0) node[right]{$y^{\mathrm e}_{\mathrm{src}}$}; \draw[->](n.east)++(0,-0.4)--++(1.0,0) node[right]{$y^{\mathrm e}_{\mathrm{dst}}$};
+
+  \draw[<-](n.west)++(0,0.4)--++(-1.0,0) node[left]{$y^{\mathrm v}_{i}=i^{\mathrm e}_{\mathrm{src}}$};
+  \draw[<-](n.west)++(0,-0.4)--++(-1.0,0) node[left]{$y^{\mathrm v}_{j}=i^{\mathrm e}_{\mathrm{dst}}$};
+
+  \node[text width=3.5cm, align=center, font=\scriptsize] at ([xshift=-2.7cm, yshift=-1.2cm]n) {mapping of adjecent node outputs as edge inputs};
+\end{tikzpicture}
+\end{document}

docs/src/assets/makelatexfigs

@@ -18,4 +18,6 @@ if ! command_exists pdf2svg; then
 fi
 
 latexmk -pdflua -shell-escape mathmodel.tex
+latexmk -pdflua -shell-escape edgemodel.tex
+latexmk -pdflua -shell-escape nodemodel.tex
 latexmk -C

docs/src/assets/nodemodel.tex

@@ -0,0 +1,34 @@
+% \documentclass[tikz,convert={outfile=\jobname.svg}]{standalone}
+\documentclass[tikz,convert=pdf2svg]{standalone}
+%\usetikzlibrary{...}% tikz package already loaded by 'tikz' option
+\usetikzlibrary{arrows, arrows.meta}
+% \tikzset{
+%   >=stealth',
+% }
+\usepackage{amsmath,amssymb}
+\usepackage{tikz}
+\usepackage{xcolor}
+
+\begin{document}
+\begin{tikzpicture}
+  \node[draw](n){
+    Node Model
+  };
+  \draw[->](n.east)--++(1.0,0) node[above, pos=.5]{$y^{\mathrm v}$};
+
+  % Draw the accumulator circle
+  \node[draw, circle] (acc) at ([xshift=-1.5cm]n.west) {$\mathrm{acc}$};
+
+  % Connect acc to the node
+  \draw[->] (acc) -- (n.west) node[pos=.5, above]{$i^{v}$};
+
+  % Add three arrows to acc with rectangular corners
+  \draw[<-] (acc) |- ++(-1.0,0.7) node[left](in){$y^e_i$};
+  \draw[<-] (acc) -- ++(-1.0,0) node[left]{$y^e_j$};
+  \draw[<-] (acc) |- ++(-1.0,-0.7) node[left]{$\ldots$};
+
+  % Add a label for the accumulation function
+  \node[text width=3cm, align=center, font=\scriptsize] at ([xshift=-.5cm, yshift=-1.2cm]acc) {accumulation of adjacent edge outputs};
+
+\end{tikzpicture}
+\end{document}

docs/src/data_structure.md

@@ -4,19 +4,17 @@ A [`Network`](@ref) contains a list of vertex and edge models along with a graph
 However, in tight numerical loops, it will never access these lists of models directly.
 Instead, the network maintains an internal representation that tracks all symbolic indices, defining the precise ordering of states and parameters in a flat array representation. To optimize performance, especially for heterogeneous networks, the network employs specialized data structures that batch identical models together.
 
-This disconnect between the explicit lists and the internal data structures
-can be confusing.
+This disconnect between the explicit lists and the internal data structures can be confusing.
 
 ## Flat Parameter and State Arrays
 
-The vertex and edge models may contain metadata, such as initial values for states and parameters.
-Crucially, this metadata is **only** for building and initialization of the
-simulation.
+The vertex and edge models may contain metadata, such as the initial values for states and parameters.
+Crucially, this metadata is **only** for the building and initialization of the simulation.
 During actual simulation, the state and parameters are handled as **flat arrays**, i.e., plain `Vector{Float64}` objects.
 
 [`NWState`](@ref) and [`NWParameter`](@ref) serve as wrappers around flat arrays and the [`Network`](@ref) objects, allowing you to inspect and modify those flat arrays by addressing vertices and edges directly.
 
-A typical workflow is:
+A typical workflow is the following:
 
 1. Set default values in the models using the metadata (see [Metadata](@ref)).
 2. Create a network (see [Network Construction](@ref)).
@@ -44,26 +42,26 @@ You can access the models using `getindex`/`[]` with `VIndex` or `EIndex`:
 ```@example data_structure
 v1 === nw[VIndex(1)]
 ```
-This can be important when changing metadata of components. i.e., both lines below are equivalent:
+This can be important when changing the metadata of components. i.e., both lines below are equivalent:
 ```@example data_structure
 set_position!(v1, (1,0))
 set_position!(nw[VIndex(1)], (1,0))
 nothing #hide
 ```
 
 !!! note "Aliasing of component models"
-    Since components are not copied, multiple entries in vertex and edge lists might point to the same instance of a model. 
+    Since components are not copied, multiple entries in the vertex and edge lists might point to the same instance of a model. 
     ```@example data_structure
     nw = Network(complete_graph(3), [v1,v2,v1], e)
     v1 === nw[VIndex(1)] === nw[VIndex(3)]
     ```
     Consequently, metadata set for one model might affect another model.
     This behavior can be beneficial for performance reasons.
-    To force copying of components, use the `dealias` keyword:
+    To force the copying of components, use the `dealias` keyword:
     ```@example data_structure
     nw = Network(complete_graph(3), [v1,v2,v1], e; dealias=true)
     nw[VIndex(1)] === nw[VIndex(3)] # neither of them === v1
     ```
 
-## Extracting `Network`-object from Containers
-`NetworkDynamics.jl` provides a [`extract_nw`](@ref) function, to get a reference to the wrapped `Network` object from different containers, such as solution objects or integrator objects.
+## Extracting a `Network`-object from Containers
+`NetworkDynamics.jl` provides a [`extract_nw`](@ref) function, to get a reference to the wrapped `Network` object from different containers, such as solution objects or [integrator objects](@extref DiffEq.integrator). 

docs/src/index.md

@@ -1,12 +1,23 @@
 # NetworkDynamics
 
-A package for working with dynamical systems on complex networks. NetworkDynamics.jl provides an interface between [Graphs.jl](https://github.com/JuliaGraphs/Graphs.jl) and [DifferentialEquations.jl](https://github.com/SciML/DifferentialEquations.jl).
-It allows for high performant simulation of dynamic networks by describing the local dynamics on the edges and vertices of the graph.
-
-The behavior of a node or an edge can be described by algebraic equations, by differential algebraic equation (DAEs) in mass matrix form or by ordinary differential equations (ODE). 
-
-The central construction is the function [`Network`](@ref) that receives functions describing the local dynamics on the edges and nodes of
-a graph `g` as inputs, and returns a composite function compatible with the
+*NetworkDynamics.jl* is a package to simulate dynamical systems within complex networks. It provides an interface 
+between the [Graphs.jl](https://github.com/JuliaGraphs/Graphs.jl) and the 
+[DifferentialEquations.jl](https://github.com/SciML/DifferentialEquations.jl) packages and faciliates the simulation of 
+highly efficient dynamic networks by describing the local dynamics on the edges and vertices of the graph.
+
+!!! note
+    Complex network systems are composed by the entities that comprise them (the nodes) and the relationships that connect
+    each entity with one another (the edges). The graphical depictions of such networks are called graphs. The simplest
+    network (which can be seen in Figure 1) is composed of two entities (so two nodes) who are only connected to each other.
+    This connection between the two is the edge of the system. Complex networks are composed of multiple nodes and edges,
+    with most nodes connected to multiple other nodes with multiple edges *(@Hans: can you created the graph of such a
+    network and place in here?)*
+
+The behavior of a node or an edge can be described through the use of a) algebraic equations, b) differential algebraic 
+equation (DAEs) in mass matrix form or c) ordinary differential equations (ODE). 
+
+The core of the package is the function [`Network`](@ref). It accepts the functions describing the local dynamics on the
+edges and nodes of the graph `g` as inputs, and returns a composite function compatible with the 
 DifferentialEquations.jl calling syntax.
 
 ```julia
@@ -15,26 +26,48 @@ nd(dx, x, p, t)
 ```
 
 Main features:
-- Clear separation of local dynamics and topology: you can easily change topology of your system or switching out dynamical components.
-- High performance when working with heterogeneous models (which means heaving different local dynamics in different parts of your network).
-- [Symbolic Indexing](@ref) into solutions and states: NetworkDynamics keeps track of the states of the individual subsystems.
-- Different execution schemes: NetworkDynamics exploits the known inter-dependencies between components to auto parallelize execution, even on GPUs!
-- Equation based models: use [ModelingToolkit.jl](https://docs.sciml.ai/ModelingToolkit/dev/) to define local dynamics, use `NetworkDynamics.jl` to combine them into large networks!
+- Clear separation of local dynamics and topology: you can easily change the topology of your system or switch out 
+- dynamic components.
+- High performance when working with heterogeneous models: you can have different local dynamics in different parts of 
+- your network.
+- [Symbolic Indexing](@ref) into solutions and states: NetworkDynamics keeps track of the states of each individual 
+- subsystem.
+- Diverse execution schemes: NetworkDynamics exploits the known inter-dependencies between components to auto 
+- parallelize execution, even on GPUs!
+- Equation based models: you can model local dynamics using 
+- [ModelingToolkit.jl](https://docs.sciml.ai/ModelingToolkit/dev/) and them combine them into larger networks by using 
+- `NetworkDynamics.jl`!
+
 
 ## Where to begin?
-Check out the [Mathematical Model](@ref) to understand the underlying modelling ideas of NetworkDynamics followed by the page on [Network Construction](@ref) to learn how to implement you own models.
+To learn how to implement your own models and understand the underlying modelling ideas of NetworkDynamics you should 
+first read the [Mathematical Model](@ref) section, followed by section [Network Construction](@ref).
 
 If you prefer to look at some concrete code first check out the [Getting Started](@ref) tutorial!
 
 
 ## Installation
 
-Installation is straightforward with Julia's package manager.
+Install Julia:
+-   https://julialang.org/install/
+-   Find your OS and follow the instructions for the installation
 
+Install NetworkDynamics.jl with Julia's package manager:
 ```julia-repl
 (v1.11) pkg> add NetworkDynamics
 ```
 
+Next you need to install the Julia package Revise:
+```julia-repl
+import Pkg; Pkg.add("Revise")
+```
+
+Last you need to install the Julia package LiveServer:
+```julia-repl
+import Pkg; Pkg.add("LiveServer")
+```
+
+
 
 ## Reproducibility
 
@@ -78,7 +111,8 @@ Pkg.status(; mode = PKGMODE_MANIFEST) # hide
 ```
 
 ## Funding
-Development of this project was in part funded by the *German Federal Ministry for Economic Affairs and Climate Action* as part of the *OpPoDyn*-Project (Project ID 01258425/1, 2024-2027).
+Development of this project was in part funded by the *German Federal Ministry for Economic Affairs and Climate Action* 
+as part of the *OpPoDyn*-Project (Project ID 01258425/1, 2024-2027).
 
 ```@raw html
 <img src="assets/bmwk_logo_en.svg" width="300"/>