diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6918ae0daca738de58ac149df974adcd1ad7cac3..2a5733c324dfb45a09ef71694346876dce3574d9 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -152,6 +152,10 @@ if (DOXYGEN_FOUND)
 	set(MODELS_OUT ${CMAKE_CURRENT_BINARY_DIR}/doc/modelspage.md)
 	configure_file(${MODELS_IN} ${MODELS_OUT} @ONLY)
 
+	set(README_IN ${CMAKE_CURRENT_SOURCE_DIR}/doc/readme.md.in)
+	set(README_OUT ${CMAKE_CURRENT_BINARY_DIR}/doc/readme.md)
+	configure_file(${README_IN} ${README_OUT} @ONLY)
+
 	message("Doxygen build started")
 
 	add_custom_target(doc
diff --git a/README.md b/README.md
index 15b89a0cbf9d381a4b274b30443d3ea2039210d8..b91313a85a60ec5e89236496e48de6011eca350b 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,3 @@
-[comment]: \page README Readme
-
 # eisgenerator
 
 eisgenerator is a shared library (libeisgenerator.so) and CLI application that allows one to generate [EIS](https://de.wikipedia.org/wiki/Impedanzspektroskopie) spectra with high performance.
diff --git a/doc/CompiledExecution.pdf b/doc/CompiledExecution.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..46e54fdf097ec008b36106fda3a69fe0d495bdbb
Binary files /dev/null and b/doc/CompiledExecution.pdf differ
diff --git a/doc/DirectExecution.pdf b/doc/DirectExecution.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..90cbcf04126a6e912de468b74f68a36a9e808465
Binary files /dev/null and b/doc/DirectExecution.pdf differ
diff --git a/doc/TorchExecution.pdf b/doc/TorchExecution.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..2363cdd4d58f4e80cc4619e17fb73c3c2f5340db
Binary files /dev/null and b/doc/TorchExecution.pdf differ
diff --git a/doc/_r-c_r.pdf b/doc/_r-c_r.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..39a2f6618285c735fef9a4bc1e02265ec9eb2494
Binary files /dev/null and b/doc/_r-c_r.pdf differ
diff --git a/doc/libeisgenerator.doxygen.in b/doc/libeisgenerator.doxygen.in
index a2e801a6fe5822c08b6f7528231ad39b2323e8f4..a10f84466c578b8ba8c912f43902c12a53594354 100644
--- a/doc/libeisgenerator.doxygen.in
+++ b/doc/libeisgenerator.doxygen.in
@@ -259,7 +259,7 @@ ALIASES                =
 # members will be omitted, etc.
 # The default value is: NO.
 
-OPTIMIZE_OUTPUT_FOR_C  = YES
+OPTIMIZE_OUTPUT_FOR_C  = NO
 
 # Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or
 # Python sources only. Doxygen will then generate output that is more tailored
@@ -864,7 +864,7 @@ WARN_LOGFILE           =
 # spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
 # Note: If this tag is empty the current directory is searched.
 
-INPUT                  = @CMAKE_CURRENT_SOURCE_DIR@/eisgenerator @CMAKE_CURRENT_BINARY_DIR@/doc/mainpage.md @CMAKE_CURRENT_BINARY_DIR@/doc/modelspage.md @CMAKE_CURRENT_SOURCE_DIR@/README.md
+INPUT                  = @CMAKE_CURRENT_SOURCE_DIR@/eisgenerator @CMAKE_CURRENT_BINARY_DIR@/doc/mainpage.md @CMAKE_CURRENT_BINARY_DIR@/doc/modelspage.md @CMAKE_CURRENT_SOURCE_DIR@/README.md @CMAKE_CURRENT_BINARY_DIR@/doc/readme.md
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
diff --git a/doc/mainpage.md.in b/doc/mainpage.md.in
index 1f306cd0ea0dfe97852a024a8c67e6be181d5589..8e3d70a4b947efcc592ebc0189820b14357bae91 100644
--- a/doc/mainpage.md.in
+++ b/doc/mainpage.md.in
@@ -25,6 +25,7 @@ lib@PROJECT_NAME@ incorporates three execution models to choose from depending o
 Upon invocation of eis::Model::Model the model string is parsed into a tree of objects. In the default tree execution the model parameters and frequencies are passed down the tree with the help of the virtual function tables of the the objects in question (black arrows). The results are then passed up the tree (blue arrows), see figure below:
 
 \image html DirectExecution.svg width=80%
+\image latex DirectExecution.pdf width=\textwidth/2
 
 This execution model has the advantage of very low latency at the expense of throughput. It is most optimal if few impedances are to be calculated.
 This execution model will be chosen by default.
@@ -32,20 +33,22 @@ This execution model is always chosen by the single data point eis::Model::execu
 
 ### Compiled execution
 
-In compiled execution eis::Model::compile generates a c++ function containing an implementation of of the equivalent circuit. This code is then compiled by GCC and loaded and cached by lib@PROJECT_NAME@. Subsequent calls to eis::Model::compile will then use the cached object.
-Once a model has been compiled any subsequent use of the execute family of methods will us the compiled object instead of tree execution.
+In compiled execution eis::Model::compile generates a c++ function containing an implementation of the equivalent circuit. This code is then compiled by GCC and loaded and cached by lib@PROJECT_NAME@. Subsequent calls to eis::Model::compile will then use the cached object.
+Once a model has been compiled any, subsequent use of the execute family of methods will use the compiled object instead of tree execution.
 This results in a speedup of greater than 10x from the reduction in virtual function call overhead and the usage of auto-vectorization.
 
 \image html CompiledExecution.svg width=80%
+\image latex CompiledExecution.pdf width=\textwidth/2
 
 This execution model is the most performant option when evaluation of many impedances is desired and execution is to be performed on a CPU.
 This execution model is only available on UNIX and UNIX-like platforms providing [dlopen()](https://man7.org/linux/man-pages/man3/dlopen.3.html) and [fork()](https://www.man7.org/linux/man-pages/man2/fork.2.html).
 
 ### TorchScript execution
 
-The final execution model generates a [TorchScript](https://pytorch.org/docs/stable/jit.html) for the equivalent circuit which can be compiled using [torch::jit::compile](https://pytorch.org/cppdocs/api/function_namespacetorch_1_1jit_1a8660dc13a6b82336aadac667e6dccba1.html) into a graph of torch/rocBLAS/cuBLAS GPU kernels for GPU execution. This provides the highest possible performance. Due to the high latency associated with executing GPU kernels this methods should only be expected to outperform compiled execution if 10^8 or more data points are required and only performs well when a large batch of data points is required at a time. This version is also highly advantageous when calculating impedance spectra as part of a larger system requiring GPU execution as in this case expensive device->host->device copies are avoided. Though torch autograd this version also provides atomatic derivatives making it useful where integration into machine-learning backward passes is required. Due to deficiencies in the windows port of Torch this version massively underperforms on Microsoft Windows and another platform should be used.
+The final execution model generates a [TorchScript](https://pytorch.org/docs/stable/jit.html) for the equivalent circuit which can be compiled using [torch::jit::compile](https://pytorch.org/cppdocs/api/function_namespacetorch_1_1jit_1a8660dc13a6b82336aadac667e6dccba1.html) into a graph of torch/rocBLAS/cuBLAS GPU kernels for GPU execution. This provides the highest possible performance. Due to the high latency associated with executing GPU kernels this method should only be expected to outperform compiled execution if a total of 10^8 or more data points are required and only performs well when a large batch of these data points is required at a time. This version is also highly advantageous when calculating impedance spectra as part of a larger system requiring GPU execution as in this case expensive device->host->device copies are avoided. Though torch autograd this version also provides atomatic derivatives making it useful where integration into machine-learning backward passes is required. Due to deficiencies in the windows port of Torch this version massively underperforms on Microsoft Windows and another platform should be used. Due to MiOpen not being available on Microsoft Windows this method is unable to perform GPU execution on this platform on AMD hardware, the CPU fallback used in this case is slower than tree execution.
 
 \image html TorchExecution.svg width=80%
+\image latex TorchExecution.pdf width=\textwidth/2
 
 -----------------------------------------------------------
 
diff --git a/doc/modelspage.md.in b/doc/modelspage.md.in
index 23b4c7c2fca1641aa186628b2ac1d4c319e956be..5e2dc2012c509f6a84d60d0f804dcacca038174b 100644
--- a/doc/modelspage.md.in
+++ b/doc/modelspage.md.in
@@ -1,6 +1,6 @@
 \page modelpage Model Format
 
-The model format of @PROJECT_NAME@ encodes any series/ parallel combination of implemented impedances
+The model format of @PROJECT_NAME@ encodes any series/ parallel combination of implemented impedances.
 
 Currently @PROJECT_NAME@ supports the following elements which each have a number of parameters:
 * c: cap
@@ -9,13 +9,15 @@ Currently @PROJECT_NAME@ supports the following elements which each have a numbe
 	* one parameter: resistance {R}
 * l: inductor
 	* one parameter: inductance {L}
-* w: warburg element (infinite), one parameters {A}
+* w: warburg element (infinite)
 	* one parameter: Warburg coefficient {A}
 * p: constant phase element
 	* two parameters: {Q, alpha}
 * t: finite approximation of a transition line
 	* three parameters: capacitance, resistance, approximation order {C, R, n}
 
+Element identifiers are case insensitive.
+
 ## Combinations
 
 Combinations of these elements are achieved by writing them against each other for a parallel combination, or with a '-' in between for serial combinations:
@@ -23,28 +25,32 @@ Combinations of these elements are achieved by writing them against each other f
 "r-c" is thus a serial combination of a resistor and a capacitance:
 | r-c |
 | :---- |
-| \image html r-c.svg width=300px |
+| \image html r-c.svg width=300px; |
+| \image latex r-c.pdf width=\textwidth/2 |
 
 While "cr" is a parallel combination of a resistor and a capacitance:
 | rc |
 | :---- |
-| \image html rc.svg width=300px |
+| \image html rc.svg width=300px  |
+| \image latex rc.pdf width=\textwidth/2|
 
 While "r-cr" is a parallel combination of a resistor and a capacitance in series with another resistance, not that the implicit parallel operator has operator precedence:
 | r-cr |
 | :---- |
 | \image html r-rc.svg width=300px |
+| \image latex r-rc.pdf width=\textwidth/2|
 
-Brackets ( and ) are also support and modify the order of operations as one would expect "(r-c)r" is a series combination of a resistor and a capacitance in parallel with another resistance:
+Brackets '(' and ')' are also supported and modify the order of operations as one would expect. Thus "(r-c)r" is a series combination of a resistor and a capacitance in parallel with another resistance:
 | (r-c)r |
 | :---- |
 | \image html _r-c_r.svg width=300px |
+| \image latex _r-c_r.pdf width=\textwidth/2|
 
 ## Parameters
 
-To pass circuit element parameters to @PROJECT_NAME@ a format embedded into the strings is preferred. Parameters are passed by adding them in braces behind the element thus "r{100}-c{3e-6}r{1e4}" is a 100 Ohm resistor in series with a 3 Microfarad capacitance that is in parallel with  a 3 kOhm resistance.
+To pass circuit element parameters to @PROJECT_NAME@ a format embedded into the strings is preferred. Parameters are passed by adding them in braces behind the element thus "r{100}-c{3e-6}r{1e4}" is a 100 Ohm resistor in series with a 3 microfarad capacitance that is in parallel with  a 3 kOhm resistance.
 
-When a element takes multiple parameters, those are separated by a ',' like so: r{5e4}-p{1e-5, 0.8}
+When an element takes multiple parameters, those are separated by a ',' like so: r{5e4}p{1e-5, 0.8}
 
 Ranges are also supported, here ~ is used as a separator between the start and the end of a range, thus r{1~1e3} is a resistor with a value in a linear range between 1 and 1000 Ohms. By adding a trailing 'L' the range can be marked as distributed logarithmic in base 10, thus  r{1~1e3L} is such a logarithmic range.
 
diff --git a/doc/r-c.pdf b/doc/r-c.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..92f678ba4a70ed65a991faf16aeb9bb5ee1b709a
Binary files /dev/null and b/doc/r-c.pdf differ
diff --git a/doc/r-rc.pdf b/doc/r-rc.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..c73d640fa284cdf75e42d08d6cdad358fa6e1fb3
Binary files /dev/null and b/doc/r-rc.pdf differ
diff --git a/doc/rc.pdf b/doc/rc.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..82ad38038195f5d9a3342e24cfa2f9298aa45f01
Binary files /dev/null and b/doc/rc.pdf differ
diff --git a/doc/readme.md.in b/doc/readme.md.in
new file mode 100644
index 0000000000000000000000000000000000000000..2da6f9406eef0df392e800082dfa892f42880bf1
--- /dev/null
+++ b/doc/readme.md.in
@@ -0,0 +1,3 @@
+\page README Readme
+
+\include{doc} @CMAKE_CURRENT_SOURCE_DIR@/README.md
diff --git a/eisgenerator/basicmath.h b/eisgenerator/basicmath.h
index b21aab8517477d5202a6cc01e97716dcb64df236..8527fac5234cd23f4ddea81f6ea1983dc1d90817 100644
--- a/eisgenerator/basicmath.h
+++ b/eisgenerator/basicmath.h
@@ -25,123 +25,124 @@
 namespace eis
 {
 	/**
-	Various math functions performed on eisgenerator types
+	* Various math functions performed on eisgenerator types
 	* @defgroup MATH Math
 	* @{
 	*/
 
 	/**
-	* @brief Calculates the element wise absolute gradient at the given point of the data given
+	* @brief Calculates the element wise absolute gradient at the given point of the data given.
 	*
-	* @param data the data to calculate the gradient on
-	* @param index the position in the data to calculate the gradient at
-	* @return the element wise absolute gradient abs(re(grad(a)))+abs(im(grad(a)))i
+	* @param data The data to calculate the gradient on.
+	* @param index The position in the data to calculate the gradient at.
+	* @return The element wise absolute gradient abs(re(grad(a)))+abs(im(grad(a)))i.
 	*/
 	std::complex<fvalue> absGrad(const std::vector<eis::DataPoint>& data, size_t index);
 
 	/**
-	* @brief Calculates derivative at the given point of the data given
+	* @brief Calculates derivative at the given point of the data given.
 	*
-	* @param data the data to calculate the gradient on
-	* @param index the position in the data to calculate the gradient at
-	* @return the derivative
+	* @param data The data to calculate the gradient on.
+	* @param index The position in the data to calculate the gradient at.
+	* @return The derivative.
 	*/
 	fvalue grad(const std::vector<fvalue>& data, const std::vector<fvalue>& omega, size_t index);
 
 	/**
-	* @brief Calculates the gradient at the given point of the data given
+	* @brief Calculates the gradient at the given point of the data given.
 	*
-	* @param data the data to calculate the gradient on
-	* @param index the position in the data to calculate the gradient at
-	* @return the gradient
+	* @param data The data to calculate the gradient on.
+	* @param index The position in the data to calculate the gradient at.
+	* @return The gradient.
 	*/
 	std::complex<fvalue> grad(const std::vector<eis::DataPoint>& data, size_t index);
 
 	/**
-	* @brief Calculates the mean of the given data
+	* @brief Calculates the mean of the given data.
 	*
-	* @param data the data to calculate the mean of
-	* @return the mean
+	* @param data The data to calculate the mean of.
+	* @return The mean
 	*/
 	fvalue mean(const std::vector<fvalue>& data);
 
 	/**
-	* @brief Calculates the mean of the given data
+	* @brief Calculates the mean of the given data.
 	*
-	* @param data the data to calculate the mean of
-	* @return the mean
+	* @param data The data to calculate the mean of.
+	* @return The mean
 	*/
 	std::complex<fvalue> mean(const std::vector<eis::DataPoint>& data);
 
 	/**
-	* @brief Calculates the median of the given data
+	* @brief Calculates the median of the given data.
 	*
-	* @param data the data to calculate the median of
-	* @return the median
+	* @param data The data to calculate the median of.
+	* @return The median.
 	*/
 	fvalue median(std::vector<fvalue> data);
 
 	/**
-	* @brief Calculates the median of the given data
+	* @brief Calculates the median of the given data.
 	*
-	* @param data the data to calculate the median of
-	* @return the median
+	* @param data The data to calculate the median of.
+	* @return The median.
 	*/
 	std::complex<fvalue> median(const std::vector<eis::DataPoint>& data);
 
 	/**
-	* @brief Resamples the data to the given amount of points
+	* @brief Resamples the data to the given amount of points.
 	*
-	* @param data data to resample
-	* @param outputSize size to resample to
-	* @return the resampled data
+	* @param data Data to resample.
+	* @param outputSize Size to resample to.
+	* @return The resampled data.
 	*/
 	std::vector<eis::DataPoint> rescale(const std::vector<eis::DataPoint>& data, size_t outputSize);
 
 	/**
-	* @brief Calculates the Pearson correlation between the imaginary and the real part of the data
+	* @brief Calculates the Pearson correlation between the imaginary and the real part of the data.
 	*
-	* @param data data to calculate the Pearson correlation on
-	* @return the Pearson correlation coefficient
+	* @param data Data to calculate the Pearson correlation on.
+	* @return the Pearson correlation coefficient.
 	*/
 	fvalue pearsonCorrelation(const std::vector<eis::DataPoint>& data);
 
 	/**
-	* @brief Calculates the variance of the distance of the data from a centroid in the nyquist plane
+	* @brief Calculates the variance of the distance of the data from a centroid in the nyquist plane.
 	*
-	* @param data the data to calculate on
-	* @param centroid the centroid to use, if nullptr is passed here, the mean of the data will be used as the centroid
-	* @return the Pearson correlation coefficient
+	* @param data The data to calculate on.
+	* @param centroid The centroid to use, if nullptr is passed here, the mean of the data will be used as the centroid.
+	* @return The Pearson correlation coefficient.
 	*/
 	fvalue nyquistAreaVariance(const std::vector<eis::DataPoint>& data, eis::DataPoint* centroid = nullptr);
 
 	/**
-	* @brief Finds the maximum distance between subsequent points in the data in the nyquist plane
+	* @brief Finds the maximum distance between subsequent points in the data in the nyquist plane.
 	*
-	* @param data the data to use
-	* @return the largest distance
+	* @param data The data to use.
+	* @return The largest distance.
 	*/
 	fvalue maximumNyquistJump(const std::vector<eis::DataPoint>& data);
 
 	/**
-	* @brief Adds white noise to the data
+	* @brief Adds white noise to the data.
 	*
-	* @param data the data to add noise to
-	* @param amplitude the amplitude of the noise
-	* @param relative if true the amplitude will be taken as relative to the magnitude of the data, otherwise it will be taken as an absolute value
+	* @param data The data to add noise to.
+	* @param amplitude The amplitude of the noise.
+	* @param relative If true, the amplitude will be taken as relative to the magnitude of the data, otherwise it will be taken as an absolute value.
 	*/
 	void noise(std::vector<eis::DataPoint>& data, double amplitude, bool relative);
 
 	/**
-	* @brief Removes duplicate data points form the data
-	* duplicates are detected by checking the value of omega for sameness using fvalueEq with the default ulp
+	* @brief Removes duplicate data points form the data.
+	*
+	* Duplicates are detected by checking the value of omega for sameness using fvalueEq with the default ulp.
 	*
 	* @param data the data to remove duplicates from
 	*/
 	void removeDuplicates(std::vector<eis::DataPoint>& data);
 
 	/**
-	* @brief Checks two fvalues for equality
+	* @brief Checks two fvalues for equality.
 	*
 	* Equality is considered given when the values are within ulp epsilons at the magnitude of the sum of operands.
 	*
@@ -152,15 +153,15 @@ namespace eis
 	bool fvalueEq(fvalue a, fvalue b, unsigned int ulp = 4);
 
 	/**
-	* @brief this function resamples, extrapolates and interpolates to fit the data given to the frequencies also given
+	* @brief This function resamples, extrapolates and interpolates to fit the data given to the frequencies also given.
 	*
 	* Data is resampled to the target size, interpolation for data points is performed using linear interpolation
 	* extrapolation is performed using linear or base 10 logarithmic extrapolation.
 	*
-	* @param omegas the frequencies to resample the data to
-	* @param data the data to resample
-	* @param linearExtrapolation true if linear extrapolation is to be performed, otherwise base 10 logarithmic extrapolation is used
-	* @return the resampled data
+	* @param omegas The frequencies to resample the data to.
+	* @param data The data to resample.
+	* @param linearExtrapolation true if linear extrapolation is to be performed, otherwise base 10 logarithmic extrapolation is used.
+	* @return The resampled data.
 	*/
 	std::vector<eis::DataPoint> fitToFrequencies(std::vector<fvalue> omegas,
 	                                             const std::vector<eis::DataPoint>& data,
diff --git a/eisgenerator/eistype.h b/eisgenerator/eistype.h
index 020eef1a9cca110d102f3808b04fd03ea1a1992a..63f227c02204f2dd9fac593c7ea8e485138a18e8 100644
--- a/eisgenerator/eistype.h
+++ b/eisgenerator/eistype.h
@@ -92,9 +92,9 @@ public:
 		return *this;
 	}
 	/**
-	* @brief calculates the absolute value of the complex impedance
+	* @brief Calculates the absolute value of the complex impedance.
 	*
-	* @return absolute value of the complex impedance
+	* @return The absolute value of the complex impedance.
 	*/
 	fvalue complexVectorLength() const
 	{
@@ -116,10 +116,11 @@ public:
 	bool log = false; /**< True if the elements in the range are to be spaced in log10 increments*/
 
 	/**
-	* @brief calculates the distance between elements in the range
-	* will calculate the log10 of the distance if the range is logarithmic
+	* @brief Calculates the distance between elements in the range.
 	*
-	* @return the distance between steps of this range
+	* Will calculate the log10 of the distance if the range is logarithmic.
+	*
+	* @return The linear or log distance between steps of this range.
 	*/
 	fvalue stepSize() const
 	{
@@ -129,9 +130,9 @@ public:
 	}
 
 	/**
-	* @brief calculates the value of the current step
+	* @brief Calculates the value of the current step.
 	*
-	* @return the value of the current step
+	* @return The value of the current step.
 	*/
 	fvalue stepValue() const
 	{
@@ -139,9 +140,9 @@ public:
 	}
 
 	/**
-	* @brief calculates the mean of the start and the end values
+	* @brief Calculates the mean of the start and the end values.
 	*
-	* @return the mean of the start and the end values
+	* @return The mean of the start and the end values.
 	*/
 	fvalue center() const
 	{
@@ -149,9 +150,9 @@ public:
 	}
 
 	/**
-	* @brief calculates the value at the given index
+	* @brief Calculates the value at the given index.
 	*
-	* @return the value at the given index
+	* @return The value at the given index.
 	*/
 	fvalue at(size_t index) const
 	{
@@ -185,47 +186,48 @@ public:
 	Range() = default;
 
 	/**
-	* @brief prints the range to stdout via eis::Log
+	* @brief Prints the range to stdout via eis::Log.
 	*
-	* @param level the eis::Log::Level to print at
+	* @param level The eis::Log::Level to print at.
 	*/
 	void print(int level) const;
 
 	/**
-	* @brief gets a machine parseable string encoding this range
+	* @brief Gets a machine parseable string encoding this range.
 	*
-	* @return the string
+	* @return The string.
 	*/
 	std::string getString() const;
 
 	/**
-	* @brief checks if the values of this range are sane
-	* this checks for some common errors like having a end < being
+	* @brief Checks if the values of this range are sane/
+	*
+	* This checks for some common errors like having a end < being.
 	*
-	* @return true if sane, false if not
+	* @return true if sane, false if not.
 	*/
 	bool isSane() const;
 
 	/**
-	* @brief this function constructs a vector that contains all elements of this range
+	* @brief This function constructs a vector that contains all elements of this range.
 	*
-	* @return the vector with the elements of this range
+	* @return The vector with the elements of this range.
 	*/
 	std::vector<fvalue> getRangeVector() const;
 
 	/**
-	* @brief this function creates a range from the parseable string
+	* @brief This function creates a range from the parseable string.
 	*
-	* @throw std::invalid_argument when the string syntax is incorrect
-	* @return the range that was parsed from the string
+	* @throw std::invalid_argument when the string syntax is incorrect.
+	* @return The range that was parsed from the string.
 	*/
 	[[nodiscard]] static Range fromString(std::string str, size_t count);
 
 	/**
-	* @brief this function creates a vector ranges from the parseable parameter array string
+	* @brief This function creates a vector ranges from the parseable parameter array string.
 	*
 	* @throw std::invalid_argument when the string syntax is incorrect
-	* @return the vector of ranges that was parsed from the string
+	* @return The vector of ranges that was parsed from the string.
 	*/
 	[[nodiscard]] static std::vector<Range> rangesFromParamString(const std::string& paramStr, size_t count);
 };
@@ -271,193 +273,204 @@ public:
 
 public:
 	/**
-	* @brief Constructs a EisSpectra
+	* @brief Constructs an EisSpectra.
 	*
-	* @param data vector of the data points of the spectra
-	* @param model model description string for this spectra
-	* @param header a free-form text that will be included in any save of this spectra
-	* @param labels an optional vector of giving the values of the inputs of the model to get this spectra
-	* @param labelNames an optional vector of names describing every input of the model
+	* @param data Vector of the data points of the spectra.
+	* @param model Model description string for this spectra.
+	* @param header A free-form text that will be included in any save of this spectra.
+	* @param labels An optional vector of giving the values of the inputs of the model to get this spectra.
+	* @param labelNames An optional vector of names describing every input of the model.
 	*/
 	EisSpectra(const std::vector<DataPoint>& data, const std::string& model, const std::string& header,
 			   std::vector<double> labels = std::vector<double>(),
 			   std::vector<std::string> labelNames = std::vector<std::string>());
 
 	/**
-	* @brief Constructs a EisSpectra
-	* this function differs from the above only in the datatype of the label
-	*
-	* @param data vector of the data points of the spectra
-	* @param model model description string for this spectra
-	* @param header a free-form text that will be included in any save of this spectra
-	* @param labels an optional vector of giving the values of the inputs of the model to get this spectra
-	* @param labelNames an optional vector of names describing every input of the model
+	* @brief Constructs an EisSpectra.
+	*
+	* This function differs from the above only in the datatype of the label.
+	*
+	* @param data Vector of the data points of the spectra.
+	* @param model Model description string for this spectra.
+	* @param header A free-form text that will be included in any save of this spectra.
+	* @param labels An optional vector of giving the values of the inputs of the model to get this spectra.
+	* @param labelNames An optional vector of names describing every input of the model.
 	*/
 	EisSpectra(const std::vector<DataPoint>& data, const std::string& model, const std::string& header,
 			   std::vector<float> labels, std::vector<std::string> labelNames = std::vector<std::string>());
 
 	/**
-	* @brief Constructs a EisSpectra
-	* this function differs from the above only in the datatype of the label
-	*
-	* @param data vector of the data points of the spectra
-	* @param model model description string for this spectra
-	* @param header a free-from text that will be included in any save of this spectra
-	* @param labels an optional vector of giving the values of the inputs of the model to get this spectra
-	* @param labelNames an optional vector of names describing every input of the model
+	* @brief Constructs an EisSpectra.
+	*
+	* This function differs from the above only in the datatype of the label.
+	*
+	* @param data Vector of the data points of the spectra.
+	* @param model Model description string for this spectra.
+	* @param header A free-from text that will be included in any save of this spectra.
+	* @param labels An optional vector of giving the values of the inputs of the model to get this spectra.
+	* @param labelNames An optional vector of names describing every input of the model.
 	*/
 	EisSpectra(const std::vector<DataPoint>& data, const std::string& model, const std::string& header,
 			   std::vector<size_t> labels, std::vector<std::string> labelNames = std::vector<std::string>());
 
 	/**
-	* @brief Constructs a EisSpectra
-	* this function differs from the above only in the datatype of the label
-	*
-	* @param data vector of the data points of the spectra
-	* @param model model description string for this spectra
-	* @param header a free-form text that will be included in any save of this spectra
-	* @param label a value corresponding to all inputs of the model
-	* @param maxLabel the number of inputs of the model
+	* @brief Constructs an EisSpectra.
+	*
+	* This function differs from the above only in the datatype of the label.
+	*
+	* @param data Vector of the data points of the spectra.
+	* @param model Model description string for this spectra.
+	* @param header A free-form text that will be included in any save of this spectra.
+	* @param label A value corresponding to all inputs of the model.
+	* @param maxLabel The number of inputs of the model.
 	*/
 	EisSpectra(const std::vector<DataPoint>& data, const std::string& model, const std::string& header,
 			   size_t label, size_t maxLabel, std::vector<std::string> labelNames = std::vector<std::string>());
 
 	/**
-	* @brief Constructs a EisSpectra by loading a EIS file from disk
+	* @brief Constructs a EisSpectra by loading an EIS file from disk.
 	*
 	* @throw eis::file_error if there is an error loading the file
-	* @param path the path to the file
+	* @param path The path to the file.
 	*/
 	EisSpectra(const std::filesystem::path& path){*this = loadFromDisk(path);}
 
 	EisSpectra(){}
 
 	/**
-	* @brief Constructs a EisSpectra by loading a EIS file from disk
+	* @brief Constructs a EisSpectra by loading a EIS file from disk.
+	*
+	* This function has the attribute [[nodiscard]]
 	*
 	* @throw eis::file_error if there is an error loading the file
-	* @param path the path to the file
-	* @return the EisSpectra
+	* @param path The path to the file.
+	* @return The EisSpectra parsed from the file.
 	*/
 	[[nodiscard]] static EisSpectra loadFromDisk(const std::filesystem::path& path);
 
 	/**
-	* @brief Constructs a EisSpectra by loading a EIS file from a stream
+	* @brief Constructs a EisSpectra by loading a EIS file from a stream.
+	*
+	* This function has the attribute [[nodiscard]]
 	*
 	* @throw eis::file_error if there is an error loading the file
-	* @param stream the stream that contains the EIS file
-	* @return the EisSpectra
+	* @param stream The stream that contains the EIS file.
+	* @return The EisSpectra parsed from the stream.
 	*/
 	[[nodiscard]] static EisSpectra loadFromStream(std::istream& stream);
 
 	/**
-	* @brief Constructs a EisSpectra by loading a EIS file from a stream
+	* @brief Sets all input values up to a maximum given by maxLabel to the value given by label.
 	*
-	* @param stream the stream that contains the EIS file
-	* @return the EisSpectra
+	* @param label The value to apply to all inputs.
+	* @param maxLabel The maximum number of values to set.
 	*/
 	void setLabel(size_t label, size_t maxLabel);
 
 	/**
-	* @brief Gets the input value of this model, where it is a single value
+	* @brief Gets the input value of this model, where it is a single value.
 	*
-	* @return the input value
+	* @return The input value,
 	*/
 	size_t getLabel();
 
 	/**
-	* @brief Sets the input values of this model
+	* @brief Sets the input values of this model.
 	*
-	* @param label the input values
+	* @param label The input values.
 	*/
 	void setSzLabels(std::vector<size_t> label);
 
 	/**
-	* @brief Sets the input values of this model
+	* @brief Sets the input values of this model.
 	*
-	* @param label the input values
+	* @param label The input values.
 	*/
 	void setLabels(const std::vector<double>& labelsIn);
 
 	/**
-	* @brief Sets the input values of this model
+	* @brief Sets the input values of this model.
 	*
-	* @param label the input values
+	* @param label The input values.
 	*/
 	void setLabels(const std::vector<float>& labelsIn);
 
 	/**
-	* @brief Sets the input values of this model
+	* @brief Sets the input values of this model.
 	*
-	* @param label the input values
+	* @param label The input values.
 	*/
 	std::vector<size_t> getSzLabels() const;
 
 	/**
-	* @brief Returns true if there are multiple inputs, false otherwise
+	* @brief Returns true if there are multiple inputs, false otherwise.
 	*
-	* @return true if there are multiple inputs, false otherwise
+	* @return true if there are multiple inputs, false otherwise.
 	*/
 	bool isMulticlass();
 
 	/**
-	* @brief Returns the inputs as a vector
+	* @brief Returns the inputs as a vector.
 	*
-	* @return the inputs as a vector
+	* @return The inputs as a vector.
 	*/
 	std::vector<fvalue> getFvalueLabels();
 
 	/**
-	* @brief Saves the spectra to disk
+	* @brief Saves the spectra to disk.
 	*
-	* @param path a path to the file on disk where the spectra shall be saved
-	* @return true on success, false on failure
+	* @param path A path to the file on disk where the spectra shall be saved.
+	* @return true on success, false on failure.
 	*/
 	bool saveToDisk(const std::filesystem::path& path) const;
 
 	/**
-	 * @brief Saves the spectra in the given stream
+	 * @brief Saves the spectra in the given stream.
 	 *
-	 * @param stream a std::ostream into which the spectra will be saved
+	 * @param stream A std::ostream into which the spectra will be saved.
 	 */
 	void saveToStream(std::ostream& stream) const;
 };
 
 /**
- * @brief deprecated function use eis::EisSpectra::saveToDisk instead
+ * @brief Deprecated function use eis::EisSpectra::saveToDisk instead.
  */
 [[deprecated]] bool saveToDisk(const EisSpectra& data, const std::filesystem::path& path);
 
 /**
- * @brief deprecated function use eis::EisSpectra::loadFromDisk instead
+ * @brief Deprecated function use eis::EisSpectra::loadFromDisk instead.
  */
 [[deprecated]] [[nodiscard]] EisSpectra loadFromDisk(const std::filesystem::path& path);
 
 /**
-* @brief Returns the a vector of DataPoints as a pair of valarrays
+* @brief Returns the a vector of DataPoints as a pair of valarrays.
 *
-* @return a pair of valarrays first the real part and second the imaginary part
+* @return A pair of valarrays first the real part and second the imaginary part.
 */
 std::pair<std::valarray<fvalue>, std::valarray<fvalue>> eisToValarrays(const std::vector<eis::DataPoint>& b);
 
 /**
-* @brief Returns the mean l2 element wise distance of he given spectra
+* @brief Returns the mean l2 element wise distance of he given spectra.
+*
+* This function will be moved to the math API in the future.
 *
-* @param a the first set of points
-* @param b the second set of points, must be the same length as a
-* @return the mean l2 distance
+* @param a The first set of points.
+* @param b The second set of points, must be the same length as a.
+* @return The mean l2 distance.
 */
 fvalue eisDistance(const std::vector<eis::DataPoint>& a, const std::vector<eis::DataPoint>& b);
 
 
 /**
-* @brief Returns the mean distance of the points in a to the linearly interpolated nyquist curve of b
+* @brief Returns the mean distance of the points in a to the linearly interpolated nyquist curve of b.
+*
+* This function will be moved to the math API in the future.
 *
-* This implementation is quite slow
+* This implementation is quite slow.
 *
-* @param a the first set of points
-* @param b the second set of points
-* @return the mean nyquist distance
+* @param a The first set of points.
+* @param b The second set of points.
+* @return The mean nyquist distance.
 */
 fvalue eisNyquistDistance(const std::vector<eis::DataPoint>& a, const std::vector<eis::DataPoint>& b);
 
diff --git a/eisgenerator/log.h b/eisgenerator/log.h
index 940a601fd3f028fa4cd9effbba683836cef4873c..0da45947cc07ea98ffedf783fdcb42d49ab1ee89 100644
--- a/eisgenerator/log.h
+++ b/eisgenerator/log.h
@@ -25,16 +25,22 @@
 namespace eis
 {
 
+/**
+* Various math functions performed on eisgenerator types
+* @defgroup LOG Log
+* @{
+*/
+
 class Log 
 {
 public:
 	
 	enum Level
 	{
-		DEBUG,
-		INFO,
-		WARN,
-		ERROR
+		DEBUG, /**< Messages useful for debugging */
+		INFO,  /**< Messages of intrest to the user incl. progress */
+		WARN,  /**< Non fatal errors or problems affecting performance or numeric precision  */
+		ERROR  /**< Fatal errors  */
 	};
 
 private:
@@ -46,11 +52,23 @@ private:
 	
 public:
 
-	static bool headers;
-	static Level level;
+	static bool headers; /**< If true output will be prefixed with a header detailing the origin of the message */
+	static Level level;  /**< Minimum Level required for output to be printed */
 
 	Log() {}
-	Log(Level type, bool endlineI = true);
+	/**
+	* @brief Constructor
+	*
+	* This Constructor is to be used like a global stream. Thus if logging is desired
+	* the user of this api shal use Log(DEBUG)<<"This is a debugging meesage";
+	* Using this constructor to create a lvalue has some negative side effects such
+	* as: Possibly holding a global lock for the lifetime of the object and potenttaly
+	* unintuative newline behavior.
+	*
+	* @param type The Level to use for this message.
+	* @param endline If true an UNIX newline '\n' will be emmited when the oject is destroyed
+	*/
+	Log(Level type, bool endline = true);
 	~Log();
 	
 	template<class T> Log &operator<<(const T &msg) 
@@ -64,4 +82,6 @@ public:
 	}
 };
 
+/** @} */
+
 }
diff --git a/eisgenerator/model.h b/eisgenerator/model.h
index e9fde883abd2ff9b876295198418c9eecaf8c5e1..f4f4541dafcd25bb5650ffc2b9cec96c7ae06aad 100644
--- a/eisgenerator/model.h
+++ b/eisgenerator/model.h
@@ -41,7 +41,7 @@ struct CompiledObject;
 */
 
 /**
-* @brief The main class of eisgenerator representing a equivalent circuit model
+* @brief The main class of eisgenerator representing a equivalent circuit model.
 */
 class Model
 {
@@ -69,10 +69,10 @@ public:
 	/**
 	* @brief Constructor
 	*
-	* @throws parse_errror
-	* @param str the model string to create a model object for
-	* @param paramSweepCount optionally the number of sweep point to use for parameter sweeps
-	* @param defaultToRange optionally a bool that if true, circuit elements not given in str are defaulted to a range instead of a fixed value
+	* @throws parse_errror If the model string or its parameters include invalid syntax.
+	* @param str The model string to create a model object for.
+	* @param paramSweepCount Optionally the number of sweep point to use for parameter sweeps.
+	* @param defaultToRange Optionally a bool that if true, circuit elements not given in str are defaulted to a range instead of a fixed value.
 	*/
 	Model(const std::string& str, size_t paramSweepCount = 100, bool defaultToRange = true);
 	Model(const Model& in);
@@ -80,121 +80,129 @@ public:
 	~Model();
 
 	/**
-	* @brief Adjusts the sweep count so that the total of spectra that need to be generated in the parameter sweep is close to the given value
+	* @brief Adjusts the sweep count so that the total of spectra that need to be generated in the parameter sweep is close to the given value.
 	*
-	* @param totalCount the total number of spectra to target
-	* @return the number of spectra that will be generated by a parameter sweep after calling this function, should be close to, but may not be exactly totalCount
+	* @param totalCount The total number of spectra to target.
+	* @return The number of spectra that will be generated by a parameter sweep after calling this function, should be close to, but may not be exactly, totalCount.
 	*/
 	size_t setParamSweepCountClosestTotal(size_t totalCount);
 
 	/**
-	* @brief Gets the impedance at the given frequency
-	* this method calls resolveSteps
+	* @brief Gets the impedance at the given frequency.
 	*
-	* @param omega the frequency in rad/s to calculate the impedance at
-	* @param index an optional index to the parameter sweep step at which to calculate the impedance
-	* @return a DataPoint struct containing the result
+	* This method calls resolveSteps.
+	*
+	* @param omega The frequency in rad/s to calculate the impedance at.
+	* @param index An optional index to the parameter sweep step at which to calculate the impedance.
+	* @return A DataPoint struct containing the result.
 	*/
 	DataPoint execute(fvalue omaga, size_t index = 0);
 
 	/**
-	* @brief Executes a frequency sweep along the given range
-	* this method calls resolveSteps
+	* @brief Executes a frequency sweep along the given range.
+	*
+	* This method calls resolveSteps.
 	*
-	* @param omega the range along which to execute a frequency sweep
-	* @param index an optional index to the parameter sweep step at which to calculate the impedance
-	* @return a vector of DataPoint structs containing the impedance at every frequency in the sweep
+	* @param omega The range along which to execute a frequency sweep.
+	* @param index An optional index to the parameter sweep step at which to calculate the impedance.
+	* @return A vector of DataPoint structs containing the impedance at every frequency in the sweep.
 	*/
 	std::vector<DataPoint> executeSweep(const Range& omega, size_t index = 0);
 
 	/**
-	* @brief Executes a frequency sweep with the given omega values
+	* @brief Executes a frequency sweep with the given omega values.
 	*
-	* @param omega a vector of frequencies in rad/s to calculate the impedance at
-	* @param index an optional index to the parameter sweep step at which to calculate the impedance
-	* @return a vector of DataPoint structs containing the impedance at every frequency in the sweep
+	* @param omega A vector of frequencies in rad/s to calculate the impedance at.
+	* @param index An optional index to the parameter sweep step at which to calculate the impedance.
+	* @return A vector of DataPoint structs containing the impedance at every frequency in the sweep.
 	*/
 	std::vector<DataPoint> executeSweep(const std::vector<fvalue>& omega, size_t index = 0);
 
 	/**
-	* @brief Executes a frequency sweep with the given omega values for each parameter combination in the applied parameter sweep
-	* this method calls resolveSteps
+	* @brief Executes a frequency sweep with the given omega values for each parameter combination in the applied parameter sweep.
+	*
+	* This method calls resolveSteps.
 	*
-	* @param omega the range along which to execute a frequency sweep
-	* @return a vector of vectors of DataPoint structs containing the impedance at every frequency in the sweep with every parameter combination
+	* @param omega The range along which to execute a frequency sweep.
+	* @return A vector of vectors of DataPoint structs containing the impedance at every frequency in the sweep with every parameter combination.
 	*/
 	std::vector<std::vector<DataPoint>> executeAllSweeps(const Range& omega);
 
 	/**
-	* @brief Returns the model string corresponding to this model object, without embedded parameters
+	* @brief Returns the model string corresponding to this model object, without embedded parameters.
 	*
-	* @return the model string corresponding to this model object, without embedded parameters
+	* @return The model string corresponding to this model object, without embedded parameters.
 	*/
 	std::string getModelStr() const;
 
 	/**
 	* @brief Returns the model string corresponding to this model object, with embedded parameters
-	* this method calls resolveSteps
 	*
-	* @param index the parameter sweep index for which to embed the parameters
-	* @return the model string corresponding to this model object, with embedded parameters
+	* This method calls resolveSteps.
+	*
+	* @param index The parameter sweep index for which to embed the parameters.
+	* @return The model string corresponding to this model object, with embedded parameters.
 	*/
 	std::string getModelStrWithParam(size_t index);
 
 	/**
-	* @brief Returns the model string corresponding to this model object, with embedded parameters
-	* the parameter sweep index of the last call to resolveSteps or 0 is used
+	* @brief Returns the model string corresponding to this model object, with embedded parameters.
+	*
+	* Yhe parameter sweep index of the last call to resolveSteps or 0 is used.
 	*
 	* @return the model string corresponding to this model object, with embedded parameters
 	*/
 	std::string getModelStrWithParam() const;
 
 	/**
-	* @brief Returns a unique id that is unique for this circuit, but not for this object specifically
-
-	* @return the uid
+	* @brief Returns a unique id.
+	*
+	* This id is only unique for the given circuit description string, not for this object as sutch.
+	*
+	* @return The uid.
 	*/
 	size_t getUuid();
 
 	/**
-	* @brief Returns a vector of pointers to the circuit elements in this model
-	* the pointers can only be assumed to be valid until the next member call to this model object
+	* @brief Returns a vector of pointers to the circuit elements in this model.
+	*
+	* The pointers can only be assumed to be valid until the next non-const member call to this model object.
 	*
-	* @param model for internal use only
-	* @return a vector of the circuit elements in the model
+	* @param model For internal use only.
+	* @return A vector of the circuit elements in the model.
 	*/
 	std::vector<Componant*> getFlatComponants(Componant *model = nullptr);
 
 	/**
-	* @brief gets the values of the parameters of the circuit elements at the current parameter sweep step
+	* @brief Gets the values of the parameters of the circuit elements at the current parameter sweep step.
 	*
-	* @return the values of the parameters of the circuit elements at the current parameter sweep step
+	* @return The values of the parameters of the circuit elements at the current parameter sweep step.
 	*/
 	std::vector<fvalue> getFlatParameters();
 
 	/**
-	* @brief gets the ranges of the parameters of the circuit elements
+	* @brief Gets the ranges of the parameters of the circuit elements.
 	*
-	* @return the ranges of the parameters of the circuit elements
+	* @return The ranges of the parameters of the circuit elements.
 	*/
 	std::vector<Range> getFlatParameterRanges();
 
 	/**
-	* @brief gets the default ranges of the parameters of each type of circuit element used in the model
+	* @brief Gets the default ranges of the parameters of each type of circuit element used in the model.
 	*
-	* @return the default ranges of the parameters of each type of circuit element used in the model
+	* @return The default ranges of the parameters of each type of circuit element used in the model.
 	*/
 	std::vector<Range> getDefaultParameters();
 
 	/**
-	* @brief gets the total number of parameters used by all the circuit elements in this model
+	* @brief Gets the total number of parameters used by all the circuit elements in this model.
 	*
-	* @return the total number of parameters
+	* @return The total number of parameters.
 	*/
 	size_t getParameterCount();
 
 	/**
-	* @brief this function compiles the model into native vectorized code for faster execution
+	* @brief This function compiles the model into native vectorized code for faster execution.
 	*
 	* This function compiles a shared-object for this model that is then loaded by eisgenerator to
 	* speed up execution of this model by a factor of 10 or more by employing vectorization and avoiding
@@ -206,81 +214,82 @@ public:
 	* This function is only implemented on UNIX, on other platforms this function will always return false.
 	* This function also requires that GCC be available in PATH.
 	*
-	* @return true if compile was successful, false otherwise
+	* @return true if compile was successful, false otherwise.
 	*/
 	bool compile();
 
 	/**
-	* @brief this member determines if the model is in a state ready to execute
+	* @brief This member determines if the model is in a state ready to execute.
 	*
-	* @return true if the model is ready for the execute* family of methods
+	* @return True if the model is ready for the execute family of methods.
 	*/
 	bool isReady();
 
 	/**
-	* @brief this member resolves the parameters of all circuit elements at the given parameter sweep step
+	* @brief This member resolves the parameters of all circuit elements at the given parameter sweep step.
 	*
-	* @param index the index to the sweep step to resolve to
+	* @param index The index to the sweep step to resolve to.
 	*/
 	void resolveSteps(int64_t index);
 
 	/**
-	* @brief gets the total number of parameter sweep steps for the applied sweep
+	* @brief Gets the total number of parameter sweep steps for the applied sweep.
 	*
-	* @return the total number of parameter sweep steps for the applied sweep
+	* @return The total number of parameter sweep steps for the applied sweep.
 	*/
 	size_t getRequiredStepsForSweeps();
 
 	/**
-	* @brief checks if the model is a sweep (i.e. has at least one parameter with a range)
+	* @brief Checks if the model is a sweep (i.e. has at least one parameter with a range).
 	*
-	* @return true if the model contains a parameter sweep, false otherwise
+	* @return True if the model contains a parameter sweep, false otherwise.
 	*/
 	bool isParamSweep();
 
 	/**
-	* @brief compiles this model into efficient c++ code corresponding to the circuit of this model
+	* @brief Compiles this model into efficient c++ code corresponding to the circuit of this model.
 	*
-	* @return the code or an empty string if compilation was unsuccessfully
+	* @return The code or an empty string if compilation was unsuccessfully.
 	*/
 	std::string getCode();
 
 	/**
-	* @brief compiles this model into TorchScript
-	* to be compiled by torch::jit::compile
+	* @brief Compiles this model into TorchScript
+	*
+	* Can be compiled to GPU kernel executeing bytecode by torch::jit::compile.
 	*
-	* @return the TorchScript code or an empty string if compilation was unsuccessful
+	* @return Yhe TorchScript code or an empty string if compilation was unsuccessful.
 	*/
 	std::string getTorchScript();
 
 	/**
-	* @brief Gets the function name in the code for this model
+	* @brief Gets the function name in the code for this model.
 	*
-	* @return the function name in the code for this model
+	* @return The function name in the code for this model.
 	*/
 	std::string getCompiledFunctionName();
 
 	/**
-	* @brief Gets the function name in the code returned by getTorchScript and getCode for this model
+	* @brief Gets the function name in the code returned by getTorchScript and getCode for this model.
 	*
-	* @return the function name in the code for this model
+	* @return The function name in the code for this model.
 	*/
 	std::vector<size_t> getRecommendedParamIndices(eis::Range omegaRange, double distance, bool threaded = false);
 };
 
 /**
  *  @example simple.cpp
- *  A simple example in how to use eisgenerator
+ *  A simple example in how to use eisgenerator.
  */
 
 /**
  *  @example compileing.cpp
- *  An example on how to use the eisgenerator compiled execution model
+ *  An example on how to use the eisgenerator compiled execution model.
  */
 
 /**
  *  @example torchscript.cpp
- *  An example on how to use the eisgenerator torch execution model
+ *  An example on how to use the eisgenerator torch execution model.
  */
 
 /** @} */
diff --git a/eisgenerator/normalize.h b/eisgenerator/normalize.h
index 497ca057eed2e999594cda0771555e8975916411..e1a52813bc367c80de76d4afdf8a9ecf7a24e831 100644
--- a/eisgenerator/normalize.h
+++ b/eisgenerator/normalize.h
@@ -30,35 +30,36 @@ namespace eis
 {
 
 /**
-Functions for normalization of spectra data
+* Functions for normalization of spectra data
 * @defgroup NORM Normalization
 * @{
 */
 
 /**
-* @brief Normalizes the data to [0,1]
+* @brief Normalizes the data to [0,1].
 *
-* @param data the data to normalize
+* @param data The data to normalize.
 */
 void normalize(std::vector<eis::DataPoint>& data);
 
 /**
-* @brief Reduces the data by removing "uninteresting"  regions
-* Uninteresting regions are determined by taking the first and second derivative and removing the areas where these change very little
+* @brief Reduces the data by removing "uninteresting"  regions.
 *
-* @param data the data to reduce
-* @return the reduced data
+* Uninteresting regions are determined by taking the first and second derivative and removing the areas where these change very little.
+*
+* @param data The data to reduce.
+* @return The reduced data.
 */
 std::vector<eis::DataPoint> reduceRegion(const std::vector<eis::DataPoint>& data, fvalue gradThreshFactor = 0.01, bool useSecondDeiv = false);
 
 /**
-* @brief Removes INF and NAN from the dataset by interpolating from neighboring points
+* @brief Removes INF and NAN from the dataset by interpolating from neighboring points.
 *
-* This function is not available when this library is compiled with fast math enabled
+* The universe implodes when function is used while this library is compiled with -ffast-math enabled.
 *
-* As a side effect, this function caps spikes to +-INF to +-10 maximally
+* As a side effect, this function caps spikes to +-INF to +-10 maximally.
 *
-* @param data the data to remove INF and NAN from
+* @param data The data to remove INF and NAN from.
 */
 void eraseSingularites(std::vector<eis::DataPoint>& data);
 
diff --git a/eisgenerator/translators.h b/eisgenerator/translators.h
index 464d98f492c44e27968b9b32f26f83db6a97c541..6c7d03f9a2bff2deb120e24b5775ced51b59857c 100644
--- a/eisgenerator/translators.h
+++ b/eisgenerator/translators.h
@@ -34,10 +34,10 @@ namespace eis
 */
 
 /**
-* @brief Translates a model string for RHD instruments RelaxIS to the format used by eisgenerator
+* @brief Translates a model string for RHD instruments RelaxIS to the format used by eisgenerator,
 *
-* @throws parse_errror
-* @param in the RelaxIS model string
+* @throws parse_errror if the given string contains syntax errors
+* @param in The RelaxIS model string.
 * @param params an optional vector of the parameters of the circuit elements
 * @return the eisgenerator model string
 */
@@ -49,58 +49,58 @@ std::string relaxisToEis(const std::string& in, const std::vector<double>& param
 * Note that any parameters embedded into the eisgenerator model string will be striped and
 * not included in the RelaxIS model.
 *
-* @throws parse_errror
-* @param in the eisgenerator model string
-* @return the RelaxIS model string
+* @throws parse_errror if the given string contains syntax errors
+* @param in The eisgenerator model string.
+* @return The RelaxIS model string.
 */
 std::string eisToRelaxis(const std::string& in);
 
 /**
 * @brief Translates a Boukamp Circuit Description Code (CDC) string into the format used by this library
 *
-* @throws parse_errror
-* @param in the CDC string
-* @return the eisgenerator model string
+* @throws parse_errror if the given string contains syntax errors
+* @param in The CDC string.
+* @return The eisgenerator model string.
 */
 std::string cdcToEis(std::string in);
 
 /**
-* @brief Translates a string for this library a Boukamp Circuit Description Code (CDC)
+* @brief Translates a string for this library a Boukamp Circuit Description Code (CDC).
 *
 * Note that any parameters embedded into the eisgenerator model string will be striped and
 * not included in the CDC.
 *
-* @throws parse_errror
-* @param in the eisgenerator model string
-* @return the CDC string
+* @throws parse_errror if the given string contains syntax errors
+* @param in The eisgenerator model string.
+* @return The CDC string.
 */
 std::string eisToCdc(const std::string& in);
 
 /**
-* @brief Translates a model description string as used by the MADAP library into the format used by this library
+* @brief Translates a model description string as used by the MADAP library into the format used by this library.
 
-* @param in a model description string as used by the MADAP library
-* @param parameters optionally a string containing the parameters of the model in MADAP parameter format
-* @return the eisgenerator model string optionally including embedded parameters
+* @param in A model description string as used by the MADAP library.
+* @param parameters Optionally a string containing the parameters of the model in MADAP parameter format.
+* @return The eisgenerator model string optionally including embedded parameters.
 */
 std::string madapToEis(const std::string& in, const std::string& parameters = "");
 
 /**
-* @brief Translates a string for this library a into the format used by the MADAP library
+* @brief Translates a string for this library a into the format used by the MADAP library.
 *
 * Note that any parameters embedded into the eisgenerator model string will be striped and
 * not included in the MADAP string.
 *
-* @throws parse_errror
-* @param in the eisgenerator model string
-* @return the MADAP string
+* @throws parse_errror If the given string contains syntax errors.
+* @param in The eisgenerator model string.
+* @return The MADAP string.
 */
 std::string eisToMadap(std::string in);
 
 /**
-* @brief Given a eisgenerator model description string, this function will purge all the embedded parameters
+* @brief Given a eisgenerator model description string, this function will purge all the embedded parameters.
 *
-* @param in an eisgenerator model string
+* @param in An eisgenerator model string.
 */
 void purgeEisParamBrackets(std::string& in);