diff --git a/.gitignore b/.gitignore
index 7f2b6feb4f30aa8d9281b22cf2aab62b154f937e..0d12043e3fad17066cb9e79315155659be840df9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -8,8 +8,6 @@
 *.npy
 *.out
 *.pkl
-*.png
-*.png
 *.secrets.yaml
 *.so
 *.tar
diff --git a/.readthedocs.yaml b/.readthedocs.yaml
index a021856d44d200d16f7ce37638fe7e1811295630..0ad7ff203ae5d1e743a97d866737f2192dff995b 100644
--- a/.readthedocs.yaml
+++ b/.readthedocs.yaml
@@ -6,9 +6,8 @@
 version: 2
 
 # Build documentation in the docs/ directory with Sphinx
-sphinx:
-  configuration: docs/source/conf.py
-  fail_on_warning: false
+mkdocs:
+  configuration: mkdocs.yml
 
 # Optionally set the version of Python and requirements required to build your docs
 python:
@@ -17,5 +16,3 @@ python:
     - requirements: docs/requirements.txt
     - method: pip
       path: .
-      extra_requirements:
-        - docs
diff --git a/docs/Makefile b/docs/Makefile
deleted file mode 100644
index 001735861347262bcd124b5001c4951b4b2cae25..0000000000000000000000000000000000000000
--- a/docs/Makefile
+++ /dev/null
@@ -1,225 +0,0 @@
-# Makefile for Sphinx documentation
-#
-
-# You can set these variables from the command line.
-SPHINXOPTS    =
-SPHINXBUILD   = sphinx-build
-PAPER         =
-BUILDDIR      = build
-
-# Internal variables.
-PAPEROPT_a4     = -D latex_paper_size=a4
-PAPEROPT_letter = -D latex_paper_size=letter
-ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source
-# the i18n builder cannot share the environment and doctrees with the others
-I18NSPHINXOPTS  = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source
-
-.PHONY: help
-help:
-	@echo "Please use \`make <target>' where <target> is one of"
-	@echo "  html       to make standalone HTML files"
-	@echo "  dirhtml    to make HTML files named index.html in directories"
-	@echo "  singlehtml to make a single large HTML file"
-	@echo "  pickle     to make pickle files"
-	@echo "  json       to make JSON files"
-	@echo "  htmlhelp   to make HTML files and a HTML help project"
-	@echo "  qthelp     to make HTML files and a qthelp project"
-	@echo "  applehelp  to make an Apple Help Book"
-	@echo "  devhelp    to make HTML files and a Devhelp project"
-	@echo "  epub       to make an epub"
-	@echo "  epub3      to make an epub3"
-	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
-	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
-	@echo "  latexpdfja to make LaTeX files and run them through platex/dvipdfmx"
-	@echo "  text       to make text files"
-	@echo "  man        to make manual pages"
-	@echo "  texinfo    to make Texinfo files"
-	@echo "  info       to make Texinfo files and run them through makeinfo"
-	@echo "  gettext    to make PO message catalogs"
-	@echo "  changes    to make an overview of all changed/added/deprecated items"
-	@echo "  xml        to make Docutils-native XML files"
-	@echo "  pseudoxml  to make pseudoxml-XML files for display purposes"
-	@echo "  linkcheck  to check all external links for integrity"
-	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
-	@echo "  coverage   to run coverage check of the documentation (if enabled)"
-	@echo "  dummy      to check syntax errors of document sources"
-
-.PHONY: clean
-clean:
-	rm -rf $(BUILDDIR)/*
-
-.PHONY: html
-html:
-	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
-	@echo
-	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
-
-.PHONY: dirhtml
-dirhtml:
-	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
-	@echo
-	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
-
-.PHONY: singlehtml
-singlehtml:
-	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
-	@echo
-	@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
-
-.PHONY: pickle
-pickle:
-	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
-	@echo
-	@echo "Build finished; now you can process the pickle files."
-
-.PHONY: json
-json:
-	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
-	@echo
-	@echo "Build finished; now you can process the JSON files."
-
-.PHONY: htmlhelp
-htmlhelp:
-	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
-	@echo
-	@echo "Build finished; now you can run HTML Help Workshop with the" \
-	      ".hhp project file in $(BUILDDIR)/htmlhelp."
-
-.PHONY: qthelp
-qthelp:
-	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
-	@echo
-	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
-	      ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
-	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/EuropeanXFELOfflineCalibration.qhcp"
-	@echo "To view the help file:"
-	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/EuropeanXFELOfflineCalibration.qhc"
-
-.PHONY: applehelp
-applehelp:
-	$(SPHINXBUILD) -b applehelp $(ALLSPHINXOPTS) $(BUILDDIR)/applehelp
-	@echo
-	@echo "Build finished. The help book is in $(BUILDDIR)/applehelp."
-	@echo "N.B. You won't be able to view it unless you put it in" \
-	      "~/Library/Documentation/Help or install it in your application" \
-	      "bundle."
-
-.PHONY: devhelp
-devhelp:
-	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
-	@echo
-	@echo "Build finished."
-	@echo "To view the help file:"
-	@echo "# mkdir -p $$HOME/.local/share/devhelp/EuropeanXFELOfflineCalibration"
-	@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/EuropeanXFELOfflineCalibration"
-	@echo "# devhelp"
-
-.PHONY: epub
-epub:
-	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
-	@echo
-	@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
-
-.PHONY: epub3
-epub3:
-	$(SPHINXBUILD) -b epub3 $(ALLSPHINXOPTS) $(BUILDDIR)/epub3
-	@echo
-	@echo "Build finished. The epub3 file is in $(BUILDDIR)/epub3."
-
-.PHONY: latex
-latex:
-	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
-	@echo
-	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
-	@echo "Run \`make' in that directory to run these through (pdf)latex" \
-	      "(use \`make latexpdf' here to do that automatically)."
-
-.PHONY: latexpdf
-latexpdf:
-	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
-	@echo "Running LaTeX files through pdflatex..."
-	$(MAKE) -C $(BUILDDIR)/latex all-pdf
-	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
-
-.PHONY: latexpdfja
-latexpdfja:
-	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
-	@echo "Running LaTeX files through platex and dvipdfmx..."
-	$(MAKE) -C $(BUILDDIR)/latex all-pdf-ja
-	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
-
-.PHONY: text
-text:
-	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
-	@echo
-	@echo "Build finished. The text files are in $(BUILDDIR)/text."
-
-.PHONY: man
-man:
-	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
-	@echo
-	@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
-
-.PHONY: texinfo
-texinfo:
-	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
-	@echo
-	@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
-	@echo "Run \`make' in that directory to run these through makeinfo" \
-	      "(use \`make info' here to do that automatically)."
-
-.PHONY: info
-info:
-	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
-	@echo "Running Texinfo files through makeinfo..."
-	make -C $(BUILDDIR)/texinfo info
-	@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
-
-.PHONY: gettext
-gettext:
-	$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
-	@echo
-	@echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
-
-.PHONY: changes
-changes:
-	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
-	@echo
-	@echo "The overview file is in $(BUILDDIR)/changes."
-
-.PHONY: linkcheck
-linkcheck:
-	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
-	@echo
-	@echo "Link check complete; look for any errors in the above output " \
-	      "or in $(BUILDDIR)/linkcheck/output.txt."
-
-.PHONY: doctest
-doctest:
-	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
-	@echo "Testing of doctests in the sources finished, look at the " \
-	      "results in $(BUILDDIR)/doctest/output.txt."
-
-.PHONY: coverage
-coverage:
-	$(SPHINXBUILD) -b coverage $(ALLSPHINXOPTS) $(BUILDDIR)/coverage
-	@echo "Testing of coverage in the sources finished, look at the " \
-	      "results in $(BUILDDIR)/coverage/python.txt."
-
-.PHONY: xml
-xml:
-	$(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml
-	@echo
-	@echo "Build finished. The XML files are in $(BUILDDIR)/xml."
-
-.PHONY: pseudoxml
-pseudoxml:
-	$(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml
-	@echo
-	@echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml."
-
-.PHONY: dummy
-dummy:
-	$(SPHINXBUILD) -b dummy $(ALLSPHINXOPTS) $(BUILDDIR)/dummy
-	@echo
-	@echo "Build finished. Dummy builder generates no files."
diff --git a/docs/css/custom.css b/docs/css/custom.css
new file mode 100644
index 0000000000000000000000000000000000000000..93d66f9c0d3017e14cfb7983577493aeae5eb142
--- /dev/null
+++ b/docs/css/custom.css
@@ -0,0 +1,87 @@
+div.autodoc-docstring {
+    padding-left: 20px;
+    margin-bottom: 30px;
+    border-left: 5px solid rgba(230, 230, 230);
+  }
+  
+  div.autodoc-members {
+    padding-left: 20px;
+    margin-bottom: 15px;
+  }
+
+
+/* :root > * {
+  --md-primary-fg-color:       #152066;
+  --md-primary-fg-color--light:#3c3b72;
+  --md-primary-fg-color--dark: #000020;
+  --md-primary-bg-color:       #ffffff;
+  --md-primary-bg-color--light:#B2B2B2;
+  --md-footer-bg-color:        #000020;
+
+  --md-accent-fg-color:              #f39200;
+  --md-accent-fg-color--transparent: #f3920085;
+  --md-accent-bg-color:              #ffffff;
+  --md-accent-bg-color--light:       #ffffff;
+} */
+
+[data-md-color-scheme="light"] { 
+ 
+  /* // Default color shades  */
+  --md-primary-fg-color:       #152066;
+  --md-primary-fg-color--light:#3c3b72;
+  --md-primary-fg-color--dark: #000020;
+  --md-primary-bg-color:       #ffffff;
+  --md-primary-bg-color--light:#B2B2B2;
+  --md-footer-bg-color:        #000020;
+
+  --md-accent-fg-color:              #f39200;
+  --md-accent-fg-color--transparent: #f3920085;
+  --md-accent-bg-color:              #ffffff;
+  --md-accent-bg-color--light:       #ffffff;
+
+  --md-typeset-a-color: #2840dd;
+
+} 
+
+[data-md-color-scheme="slate"] { 
+ 
+  --md-primary-fg-color:       #f39200;
+  --md-primary-fg-color--light:#f3920085;
+  --md-primary-fg-color--dark: #da996f;
+  --md-primary-bg-color:       #ffffff;
+  --md-primary-bg-color--light:#B2B2B2;
+  --md-footer-bg-color:        #000020;
+
+  --md-accent-fg-color:              #fcda9d;
+  --md-accent-fg-color--transparent: #3c3b72;
+  --md-accent-bg-color:              #ffffff;
+  --md-accent-bg-color--light:       #ffffff;
+
+  /* // Default color shades  */
+  --md-default-fg-color:               hsla(0, 0%, 100%, 1); 
+  --md-default-fg-color--light:        hsla(0, 0%, 100%, 0.87); 
+  --md-default-fg-color--lighter:      hsla(0, 0%, 100%, 0.32); 
+  --md-default-fg-color--lightest:     hsla(0, 0%, 100%, 0.12); 
+  --md-default-bg-color:               hsla(232, 15%, 21%, 1); 
+  --md-default-bg-color--light:        hsla(232, 15%, 21%, 0.54); 
+  --md-default-bg-color--lighter:      hsla(232, 15%, 21%, 0.26); 
+  --md-default-bg-color--lightest:     hsla(232, 15%, 21%, 0.07); 
+ 
+  /* // Code color shades  */
+  --md-code-bg-color:                  hsla(232, 15%, 18%, 1); 
+  --md-code-fg-color:                  hsla(60, 30%, 96%, 1); 
+ 
+  /* // Text color shades  */
+  --md-text-color:                     var(--md-default-fg-color--light); 
+  --md-text-link-color:                var(--md-primary-fg-color); 
+ 
+  /* // Admonition color shades  */
+  --md-admonition-bg-color:            hsla(0, 0%, 100%, 0.025); 
+  --md-admonition-fg-color:            var(--md-default-fg-color); 
+ 
+  /* // Footer color shades  */
+  --md-footer-bg-color:                hsla(230, 9%, 13%, 0.87); 
+  --md-footer-bg-color--dark:          hsla(232, 15%, 10%, 1);
+
+  --md-typeset-a-color: #f39200;
+} 
\ No newline at end of file
diff --git a/docs/css/extra.css b/docs/css/extra.css
new file mode 100644
index 0000000000000000000000000000000000000000..804da13d45851df9b9a849f3381fab682f849099
--- /dev/null
+++ b/docs/css/extra.css
@@ -0,0 +1,4 @@
+
+code, .rst-content tt, .rst-content code {
+    white-space: pre;
+  }
\ No newline at end of file
diff --git a/docs/development/advanced.md b/docs/development/advanced.md
new file mode 100644
index 0000000000000000000000000000000000000000..5d59fb7a7760904461f36691907185491c059219
--- /dev/null
+++ b/docs/development/advanced.md
@@ -0,0 +1,137 @@
+# Advanced Topics
+
+!!! warning
+
+    The following tasks should only be carried out by trained staff.
+
+## Extending Correction Notebooks on User Request
+
+Internally, each automated correction run will trigger
+[calibrate_nbc.py] to be called anew on the respective
+notebook. This means that any changes to save to this notebook will be
+picked up for subsequent runs.
+
+This can be useful to add user requests while running. For this:
+
+1.  create a working copy of the notebook in question, and create a
+    commit of the production notebook to fall back to in case of
+    problems:
+
+    > `` ` git add production_notebook_NBC.py git commit -m "Known working version before edits" cp production_notebook_NBC.py production_notebook_TEST.py ``\`
+
+2.  add any feature there and *thoroughly* test them
+3.  when you are happy with the results, copy them over into the
+    production notebook and save.
+
+
+???+ warning
+
+    Live editing of correction notebooks is fully at your responsibility. Do
+    not do it if you are not 100% sure you know what you are doing.
+
+1.  If it fails, revert to the original state, ideally via git:
+
+        git checkout HEAD -- production_notebook_NBC.py
+
+2.  Any runs which did not correct do to failures of the live edit can
+    then be relaunched manually, assuming the correction notebook allows
+    run and overwrite parameters:
+
+        xfel-calibrate ...... --run XYZ,ZXY-YYS --overwrite
+
+Using a Parameter Generator Function
+------------------------------------
+
+By default, the parameters to be exposed to the command line are deduced
+from the first code cell of the notebook, after resolving the notebook
+itself from the detector and characterization type. For some
+applications it might be beneficial to define a context-specific
+parameter range within the same notebook, based on additional user
+input. This can be done via a parameter generation function which is
+defined in one of the code cell:
+
+    def extend_parms(detector_instance):
+        from iCalibrationDB import Conditions
+        import inspect
+        existing = set()
+        def extract_parms(cls):
+            args, varargs, varkw, defaults = inspect.getargspec(cls.__init__)
+            pList = []
+            for i, arg in enumerate(args[1:][::-1]):
+                if arg in existing:
+                    continue
+
+                existing.add(arg)
+
+                if i < len(defaults):
+                    default = defaults[::-1][i]
+                    if str(default).isdigit():
+                        pList.append("{} = {}".format(arg, default))
+                    elif default is None or default == "None":
+                        pList.append("{} = \"None\"".format(arg))
+                    else:
+                        pList.append("{} = \"{}\"".format(arg, default))
+                else:
+                    pList.append("{} = 0.  # required".format(arg))
+            return set(pList[::-1])  # mandatories first
+        dtype = "LPD" if "LPD" in detector_instance.upper() else "AGIPD"
+        all_conditions = set()
+        for c in dir(Conditions):
+            if c[:2] != "__":
+                condition = getattr(Conditions, c)
+                parms = extract_parms(getattr(condition, dtype))
+                [all_conditions.add(p) for p in parms]
+        return "\n".join(all_conditions)
+
+
+???+ note
+
+    Note how all imports are inlined, as the function is executed outside
+    the notebook context.
+
+
+In the example, the function generates a list of additional parameters
+depending on the [detector\_instance] given. Here,
+[detector\_instance] is defined in the first code cell the
+usual way. Any other parameters defined such, that have names matching
+those of the generator function signature are passed to this function.
+The function should then return a string containing additional code to
+be appended to the first code cell.
+
+To make use of this functionality, the parameter generator function
+needs to be configured in [notebooks.py], e.g. :
+
+    ...
+    "GENERIC": {
+        "DBTOH5": {
+            "notebook": "notebooks/generic/DB_Constants_to_HDF5_NBC.ipynb",
+            "concurrency": {"parameter": None,
+                            "default concurrency": None,
+                            "cluster cores": 32},
+            "extend parms": "extend_parms",
+        },
+    }
+    ...
+
+To generically query which parameters are defined in the first code
+cell, the code execution history feature of iPython can be used:
+
+    ip = get_ipython()
+    session = ip.history_manager.get_last_session_id()
+    first_cell = next(ip.history_manager.get_range(session, 1, 2, raw=True))
+    _, _, code = first_cell
+    code = code.split("\n")
+    parms = {}
+    for c in code:
+        n, v = c.split("=")
+        n = n.strip()
+        v = v.strip()
+        try:
+            parms[n] = float(v)
+        except:
+            parms[n] = str(v) if not isinstance(v, str) else v
+        if parms[n] == "None" or parms[n] == "'None'":
+            parms[n] = None
+
+This will create a dictionary [parms] which contains all
+parameters either as [float] or [str] values.
diff --git a/docs/development/configuration.md b/docs/development/configuration.md
new file mode 100644
index 0000000000000000000000000000000000000000..d053eaa8ebb08bb00bdd5956bb3526cfd69a6538
--- /dev/null
+++ b/docs/development/configuration.md
@@ -0,0 +1,98 @@
+# xfel-calibrate configration
+
+
+The European XFEL offline calibration is executed using the command line interface.
+By running `xfel-calibrate DETECTOR CALIBRATION --<configurations>` The notebook of the executed detector calibration is submitted on MAXWELL into [SLURM][slurm] nodes.
+
+The offline calibration CLI machinery consists of several configuration pieces that are necessary for the calibration process. These files contain the configuration information for the notebook to process and how to submit it on MAXWELL resources.
+
+    - `settings.py`: Consist of the tool's environment definitions.
+    - `notebooks.py`: The module where every calibration notebook is connected to a detector calibration for the CLI.
+
+## Settings
+
+The `settings.py` is a python configuration file, which configures the tool's environment.
+
+```py
+    # path into which temporary files from each run are placed
+    temp_path = "{}/temp/".format(os.getcwd())
+
+    # Path to use for calling Python. If the environment is correctly set, simply the command
+    python_path = "python"
+
+    # Path to store reports in
+    report_path = "{}/calibration_reports/".format(os.getcwd())
+
+    # Also try to output the report to an out_folder defined by the notebook
+    try_report_to_output = True
+
+    # the command to run this concurrently. It is prepended to the actual call
+    launcher_command = "sbatch -p exfel -t 24:00:00 --mem 500G --mail-type END --requeue --output {temp_path}/slurm-%j.out"
+```
+
+## Notebooks
+
+The notebooks.py module is responsible for configuring the connection between the notebooks and the command line. It achieves this by using a nested dictionary structure, with two levels of nesting. The first level contains a key for the detector being used, and the second level contains keys for the calibration types. The third level of the dictionary contains the names of the notebooks (notebook, pre-notebook, and dep-notebook) along with the relevant concurrency parameters. By organizing the configuration in this way, the notebooks.py module is able to provide a clear and flexible way of connecting the notebooks to the command line.
+
+
+!!! example "Example for `xfel-calibrate/notebooks.py`"
+
+    ```python
+    notebooks = {
+        "AGIPD": {
+            "DARK": {
+                "notebook":
+                    "notebooks/AGIPD/Characterize_AGIPD_Gain_Darks_NBC.ipynb",
+                "dep_notebooks": [
+                    "notebooks/generic/overallmodules_Darks_Summary_NBC.ipynb"],
+                "concurrency": {"parameter": "modules",
+                                "use function": "find_modules",
+                                "cluster cores": 8},
+            },
+            "PC": {
+                "notebook": "notebooks/AGIPD/Chracterize_AGIPD_Gain_PC_NBC.ipynb",
+                "concurrency": {"parameter": "modules",
+                                "default concurrency": 16,
+                                "cluster cores": 32},
+            },
+            "CORRECT": {
+                "pre_notebooks": ["notebooks/AGIPD/AGIPD_Retrieve_Constants_Precorrection.ipynb"],
+                "notebook": "notebooks/AGIPD/AGIPD_Correct_and_Verify.ipynb",
+                "dep_notebooks": [
+                    "notebooks/AGIPD/AGIPD_Correct_and_Verify_Summary_NBC.ipynb"],
+                "concurrency": {"parameter": "sequences",
+                                "use function": "balance_sequences",
+                                "default concurrency": [-1],
+                                "cluster cores": 16},
+            },
+            ...
+        }
+    }
+    ```
+
+As previously explained, the DARK and CORRECT nested dictionaries that correspond to different calibration types contain references to the notebooks that will be executed and specify the concurrency settings for the main calibration notebook.
+
+- `notebook`: The main calibration notebook and the notebook that will be affected with the concurrency configs.
+
+- `pre_notebooks`: These notebooks runs before the main notebook as the usually prepare some essential data for it before it runs over multiple [SLURM][slurm] nodes. e.g. retrieving constant file paths before processing.
+
+- `dep_notebooks`: These are the notebooks dependent on the processing of all [SLURM][slurm] nodes running the main notebook. e.g. running summary plots over the processed files.
+
+!!! tip
+
+    It is good practice to name command line enabled notebooks with an `_NBC` suffix as shown in the above example.
+
+- `concurrency` dictionary:
+
+    - `parameter`: The parameter name that will be used to distribute the processing of the notebook across multiple computing resources. The parameter should be of type list.
+    
+    - `use_function`: In case there is a need to use a function within the notebook that will affect the [SLURM][slurm] nodes used. A function can be used here, and it will be expected in the first notebook cell of the main notebook. e.g. [balance_sequences](../reference/xfel-calibrate/calibrate.md#balance_sequences)
+  
+    !!! Note
+
+        The function only needs to be defined, but not executed within the notebook context itself.
+
+  - `default concurrency`: The default concurrency to use if not defined by the user. e.g. `default_concurrency = 16` and `parameter` name modules of type ` lis(int)` leads to running 16 concurrent SLURM jobs with modules values 0 to 15, respectively for each node.  
+  - `cluster cores`: This is for notebooks using ipcluster, only. This is of the number of cores to use.
+
+[slurm]: https://slurm.schedmd.com/documentation.html
diff --git a/docs/development/contributing_to_gitlab.md b/docs/development/contributing_to_gitlab.md
new file mode 100644
index 0000000000000000000000000000000000000000..dae6d9986ceefbd07ea3369f99364f775b5a578c
--- /dev/null
+++ b/docs/development/contributing_to_gitlab.md
@@ -0,0 +1,36 @@
+# Contributing to GitLab
+
+- Branches prefixes:
+  - Feature: feat/
+  - Fix: fix/  
+  - Documentation: doc/ 
+  - Refactoring: refactor/
+
+- Short well-defined branch name.
+
+- Avoid multiple unrelated changes in one merge request.
+
+- Add common Abbreviations to the merge request name.
+  e.g. `DETECTOR` `CALIBRATION` >> `AGIPD` `DARK`
+
+- Add doc strings to all functions, comments to complicated SW lines, and fixed numbers. It is recommended to use Google style
+
+- WIP Merge requests are not yet finished by the author
+
+
+- Non-WIP MR is finished, and it's adding requested features during the review should be avoided.
+a) if a bug/change was fixed/done by the author during the review, one should point the reviewers to the new change.
+
+- Add a description to your Merge request: Summary, Test, Reviewers, .....
+
+- Connect the Merge request to any external documents and GitLab issues or MRs
+
+-  Add more than one reviewer per a merge request.
+
+- Merge requests can be merged only after receiving 2 approvals or LGTMs, and all discussions are resolved.
+
+- Delete source branch during merging to master.
+
+- Reviewers are free to add comments from importing libraries in alphabetical order to software design (A suggestion is very welcomed)
+
+- Notebooks should be added to branch/master without the cell's output.
\ No newline at end of file
diff --git a/docs/development/how_to_write_xfel_calibrate_notebook_NBC.ipynb b/docs/development/how_to_write_xfel_calibrate_notebook_NBC.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..62ae6c8ed5d5f3a307f295b163ff0cf57f01a0e6
--- /dev/null
+++ b/docs/development/how_to_write_xfel_calibrate_notebook_NBC.ipynb
@@ -0,0 +1,388 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# How to start writing a calibration notebook\n",
+    "\n",
+    "Author: European XFEL Detector Group, Version 0.1\n",
+    "\n",
+    "This is an example notebook to point to some common practices used in production notebooks.\n",
+    "This notebook is using ePix100 detector RAW data to apply offset and gain correction\n",
+    "\n",
+    "This is meant to be a starting point on how to write calibration notebooks that can run in production using\n",
+    "`xfel-calibrate` CLI. However, it is recommended to have a look on some production notebooks residing\n",
+    "in `/notebooks/` directory which can have more advanced practices that can help you during your notebook development."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# This first code cell must always contain the global notebook parameters.\n",
+    "# The parameters are parsed as input arguments for `xfel-calibration` command line interface.\n",
+    "# It is very important to have a comment for each parameter. The comments are not only helpful within the notebook,\n",
+    "# but they are used the as parameter description when `xfel-calibrate DETECTOR CALIBRATION --help` is used.\n",
+    "\n",
+    "in_folder = \"/gpfs/exfel/exp/CALLAB/202130/p900203/raw/\"  # directory to read data from, required\n",
+    "out_folder = \"/gpfs/exfel/exp/CALLAB/202130/p900203/scratch/how_write_xfel_calibrate_NBC\"  # directory to output to, required\n",
+    "# Adding `required` at the comment here forces the user to add the parameter through the command line,\n",
+    "# ignoring the default value and only using it as an indication of the expected type.\n",
+    "run = 9046  # runs to process, required\n",
+    "\n",
+    "# Parameters for accessing the raw data.\n",
+    "karabo_da = \"EPIX01\"  # Data aggregator names. For multi-modular detectors like AGIPD and LPD, this is a list.\n",
+    "# To access the correct data files and calibration constants. The karabo_id string is used as a detector identifier.\n",
+    "karabo_id = \"HED_IA1_EPX100-1\"  # Detector karabo_id name\n",
+    "\n",
+    "# Boolean parameter can be set to False from xfel-calibrate by adding `no-` at the beginning of the boolean parameter name.\n",
+    "gain_correction = True  # Proceed with gain correction.\n",
+    "\n",
+    "# Parameters for the calibration database.\n",
+    "creation_time = \"\"  # The timestamp to use with Calibration DB. Required Format: \"YYYY-MM-DD hh:mm:ss\" e.g. 2019-07-04 11:02:41\n",
+    "# It is preferred if operating conditions are read from RAW data instead of passed as an input argument.\n",
+    "bias_voltage = 200  # RAW data bias voltage.\n",
+    "in_vacuum = False  # Detector operated in vacuum\n",
+    "photon_energy = 8.048  # Photon energy used for gain calibration\n",
+    "fix_temperature = 290  # fixed temperature value in Kelvin.\n",
+    "\n",
+    "# Parameters affecting writing corrected data.\n",
+    "chunk_size_idim = 1  # H5 chunking size of output data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pathlib import Path\n",
+    "\n",
+    "# Write after the first python notebook cell. It is a good practice to import all needed libraries and modules.\n",
+    "# Same as we do in a normal python module.\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import numpy as np\n",
+    "\n",
+    "# To access data `extra_data` is used to read RAW/CORR data.\n",
+    "from extra_data import RunDirectory  # https://extra-data.readthedocs.io/en/latest/\n",
+    "\n",
+    "from extra_geom import Epix100Geometry  # https://extra-geom.readthedocs.io/en/latest/\n",
+    "\n",
+    "# For parallelization with a notebook it is suggested to use multiprocessing.\n",
+    "import multiprocessing  # or\n",
+    "import pasha as psh # https://github.com/European-XFEL/pasha\n",
+    "# This library uses multiprocessing and provide tight integration with extra_data\n",
+    "\n",
+    "# `cal_tools` directory consists of multiple useful functions that are used in many notebooks.\n",
+    "import cal_tools.restful_config as rest_cfg\n",
+    "# `calcat_interface` is the main module with functions to retrieve calibration constants from CALCAT.\n",
+    "from cal_tools.calcat_interface import EPIX100_CalibrationData\n",
+    "from cal_tools.epix100 import epix100lib\n",
+    "# `cal_tools.files` is recommended to write corrected data.\n",
+    "from cal_tools.files import DataFile\n",
+    "# An internal class to record computation time.\n",
+    "from cal_tools.step_timing import StepTimer\n",
+    "# `tools` consists for various number of functions to read files, wrappers for iCalibrationDB, etc ...\n",
+    "from cal_tools.tools import (\n",
+    "    calcat_creation_time,\n",
+    ")"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Prepare global variables.\n",
+    "\n",
+    "In the following cells it is a common practice to start assigning global variables,\n",
+    "like converting in_folder and out_folder to Path objects or initializing step_timer object."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The available source to correct for HED_IA1_EPX100-1 are ['HED_IA1_EPX100-1/DET/RECEIVER', 'HED_IA1_EPX100-1/DET/RECEIVER:daqOutput', 'HED_IA1_EPX100-1/DET/CONTROL']\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Convert main folders to Paths.\n",
+    "in_folder = Path(in_folder)\n",
+    "out_folder = Path(out_folder)\n",
+    "# This is only needed in case of running the notebook interactively. Otherwise, the machinery take care of this.\n",
+    "out_folder.mkdir(parents=True, exist_ok=True)\n",
+    "run_folder = in_folder / f\"r{run:04d}\"\n",
+    "\n",
+    "# Initiate the main Run data collection.\n",
+    "run_dc = RunDirectory(\n",
+    "    run_folder, include=\"*S00000*\").select(f\"*{karabo_id}*\", require_all=True)\n",
+    "\n",
+    "print(f\"The available source to correct for {karabo_id} are {list(run_dc.all_sources)}\")\n",
+    "\n",
+    "step_timer = StepTimer()"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Read operating conditions from RAW data.\n",
+    "\n",
+    "It is recommended to read the calibration constants' operating conditions directly from RAW data.\n",
+    "To avoid wrong given values from the notebook's input argument.\n",
+    "Unfortunately, there is the possibility that these conditions are not stored in RAW data\n",
+    "because the detector is in its early operation stages.\n",
+    "\n",
+    "\n",
+    "Below we give an example of reading the integration time of the data. There are multiple functions and similar class\n",
+    "as epix100Ctrl for other detectors that are used for the same purpose. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Read control data.\n",
+    "data_source = \"HED_IA1_EPX100-1/DET/RECEIVER:daqOutput\"\n",
+    "\n",
+    "ctrl_data = epix100lib.epix100Ctrl(\n",
+    "    run_dc=run_dc,\n",
+    "    instrument_src=data_source,\n",
+    "    ctrl_src=f\"{karabo_id}/DET/CONTROL\",\n",
+    "    )\n",
+    "\n",
+    "integration_time = ctrl_data.get_integration_time()"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Retrieve needed calibration constants\n",
+    "\n",
+    "Usually there is a cell when we retrieve calibration constants before correction\n",
+    "and sometimes before processing new calibration constants.\n",
+    "\n",
+    "In this example we use `EPIX100_CalibrationData` class to initialize an object with\n",
+    "the necessary operating conditions and creation time.\n",
+    "\n",
+    "Below the operating conditions values like integration_time and sensor_temperature are hard coded to specific value.\n",
+    "In production notebooks this is done differently."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Reading creation_date from input files metadata `INDEX/timestamp`\n",
+      "Using 2021-09-19T14:39:26.744069+00:00 as creation time\n",
+      "Retrieved calibrations for HED_IA1_EPX100-1: ['BadPixelsDarkEPix100', 'NoiseEPix100', 'OffsetEPix100', 'RelativeGainEPix100']\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Run creation time is important to get the correct calibration constant versions.\n",
+    "creation_time = calcat_creation_time(in_folder, run, creation_time)\n",
+    "print(f\"Using {creation_time.isoformat()} as creation time\")\n",
+    "\n",
+    "epix_cal = EPIX100_CalibrationData(\n",
+    "    detector_name=karabo_id,\n",
+    "    sensor_bias_voltage=bias_voltage,\n",
+    "    integration_time=integration_time,\n",
+    "    sensor_temperature=fix_temperature,\n",
+    "    in_vacuum=in_vacuum,\n",
+    "    source_energy=photon_energy,\n",
+    "    event_at=creation_time,\n",
+    "    client=rest_cfg.calibration_client(),\n",
+    ")\n",
+    "\n",
+    "const_data = epix_cal.ndarray_map()[karabo_da]\n",
+    "\n",
+    "print(f\"Retrieved calibrations for {karabo_id}: {list(const_data.keys())}\")"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Correcting Raw data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of trains to correct is 1000\n",
+      "Correcting data: 1.0 s\n"
+     ]
+    }
+   ],
+   "source": [
+    "data_key = \"data.image.pixels\"\n",
+    "raw_data = run_dc[data_source, data_key].ndarray()\n",
+    "dshape = raw_data.shape  # Raw input data shape.\n",
+    "\n",
+    "print(f\"Number of trains to correct is {len(run_dc.train_ids)}\")\n",
+    "\n",
+    "def correct_train(wid, index, d):\n",
+    "    \"\"\"Correct one train for ePix100 detector.\"\"\"\n",
+    "    d -= const_data[\"OffsetEPix100\"][..., 0]\n",
+    "    if gain_correction:\n",
+    "        d /= const_data[\"RelativeGainEPix100\"]\n",
+    "\n",
+    "step_timer.start()\n",
+    "context = psh.context.ThreadContext(num_workers=10)\n",
+    "corr_data = context.alloc(shape=dshape, dtype=np.float32)\n",
+    "\n",
+    "context.map(correct_train, raw_data.astype(np.float32))\n",
+    "step_timer.done_step('Correcting data')"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Writing corrected data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Writing corrected data: 1.2 s\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Storing data.\n",
+    "out_file = out_folder / \"CORR-R9046-EPIX01-S00000.h5\"\n",
+    "instrument_source = \"HED_IA1_EPX100-1/DET/RECEIVER:daqOutput\"\n",
+    "\n",
+    "image_counts = run_dc[instrument_source, \"data.image.pixels\"].data_counts(labelled=False)\n",
+    "\n",
+    "step_timer.start()\n",
+    "\n",
+    "with DataFile(out_file, \"w\") as ofile:\n",
+    "    # Create INDEX datasets.\n",
+    "    ofile.create_index(run_dc.train_ids, from_file=run_dc.files[0])\n",
+    "\n",
+    "    # Create METDATA datasets\n",
+    "    ofile.create_metadata(\n",
+    "        like=run_dc,\n",
+    "        sequence=run_dc.run_metadata()[\"sequenceNumber\"],\n",
+    "        instrument_channels=(f\"{instrument_source}/data\",)\n",
+    "    )\n",
+    "    # Create Instrument section to later add corrected datasets.\n",
+    "    outp_source = ofile.create_instrument_source(instrument_source)\n",
+    "\n",
+    "    # Create count/first datasets at INDEX source.\n",
+    "    outp_source.create_index(data=image_counts)\n",
+    "\n",
+    "    # Add main corrected `data.image.pixels` dataset and store corrected data.\n",
+    "    outp_source.create_key(\n",
+    "        \"data.image.pixels\", data=corr_data, chunks=((chunk_size_idim,) + dshape[1:]))\n",
+    "step_timer.done_step('Writing corrected data')"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Plotting results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1800x720 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "geom = Epix100Geometry.from_origin()\n",
+    "\n",
+    "fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, figsize=(25, 10))\n",
+    "\n",
+    "# Plotting mean data for RAW and CORRECTED across trains\n",
+    "geom.plot_data(np.mean(raw_data, axis=0), ax=ax1)\n",
+    "ax1.set_title(\"Mean RAW across trains\")\n",
+    "geom.plot_data(np.mean(corr_data, axis=0), ax=ax2)\n",
+    "ax2.set_title(\"Mean CORR across trains\")\n",
+    "\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.6"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "c0d889713c1e20a0073b9c190f32b7026a85a297464329a7346035602aed992c"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/development/how_to_write_xfel_calibrate_notebook_NBC.md b/docs/development/how_to_write_xfel_calibrate_notebook_NBC.md
new file mode 100644
index 0000000000000000000000000000000000000000..dd050d28cec558eea556468264d54a946912fcd5
--- /dev/null
+++ b/docs/development/how_to_write_xfel_calibrate_notebook_NBC.md
@@ -0,0 +1,255 @@
+# How to start writing a calibration notebook
+
+Author: European XFEL Detector Group, Version 0.1
+
+This is an example notebook to point to some common practices used in production notebooks.
+This notebook is using ePix100 detector RAW data to apply offset and gain correction
+
+This is meant to be a starting point on how to write calibration notebooks that can run in production using
+`xfel-calibrate` CLI. However, it is recommended to have a look on some production notebooks residing
+in `/notebooks/` directory which can have more advanced practices that can help you during your notebook development.
+
+
+```python
+# This first code cell must always contain the global notebook parameters.
+# The parameters are parsed as input arguments for `xfel-calibration` command line interface.
+# It is very important to have a comment for each parameter. The comments are not only helpful within the notebook,
+# but they are used the as parameter description when `xfel-calibrate DETECTOR CALIBRATION --help` is used.
+
+in_folder = "/gpfs/exfel/exp/CALLAB/202130/p900203/raw/"  # directory to read data from, required
+out_folder = "/gpfs/exfel/exp/CALLAB/202130/p900203/scratch/how_write_xfel_calibrate_NBC"  # directory to output to, required
+# Adding `required` at the comment here forces the user to add the parameter through the command line,
+# ignoring the default value and only using it as an indication of the expected type.
+run = 9046  # runs to process, required
+
+# Parameters for accessing the raw data.
+karabo_da = "EPIX01"  # Data aggregator names. For multi-modular detectors like AGIPD and LPD, this is a list.
+# To access the correct data files and calibration constants. The karabo_id string is used as a detector identifier.
+karabo_id = "HED_IA1_EPX100-1"  # Detector karabo_id name
+
+# Boolean parameter can be set to False from xfel-calibrate by adding `no-` at the beginning of the boolean parameter name.
+gain_correction = True  # Proceed with gain correction.
+
+# Parameters for the calibration database.
+creation_time = ""  # The timestamp to use with Calibration DB. Required Format: "YYYY-MM-DD hh:mm:ss" e.g. 2019-07-04 11:02:41
+# It is preferred if operating conditions are read from RAW data instead of passed as an input argument.
+bias_voltage = 200  # RAW data bias voltage.
+in_vacuum = False  # Detector operated in vacuum
+photon_energy = 8.048  # Photon energy used for gain calibration
+fix_temperature = 290  # fixed temperature value in Kelvin.
+
+# Parameters affecting writing corrected data.
+chunk_size_idim = 1  # H5 chunking size of output data
+```
+
+
+```python
+from pathlib import Path
+
+# Write after the first python notebook cell. It is a good practice to import all needed libraries and modules.
+# Same as we do in a normal python module.
+import matplotlib.pyplot as plt
+
+import numpy as np
+
+# To access data `extra_data` is used to read RAW/CORR data.
+from extra_data import RunDirectory  # https://extra-data.readthedocs.io/en/latest/
+
+from extra_geom import Epix100Geometry  # https://extra-geom.readthedocs.io/en/latest/
+
+# For parallelization with a notebook it is suggested to use multiprocessing.
+import multiprocessing  # or
+import pasha as psh # https://github.com/European-XFEL/pasha
+# This library uses multiprocessing and provide tight integration with extra_data
+
+# `cal_tools` directory consists of multiple useful functions that are used in many notebooks.
+import cal_tools.restful_config as rest_cfg
+# `calcat_interface` is the main module with functions to retrieve calibration constants from CALCAT.
+from cal_tools.calcat_interface import EPIX100_CalibrationData
+from cal_tools.epix100 import epix100lib
+# `cal_tools.files` is recommended to write corrected data.
+from cal_tools.files import DataFile
+# An internal class to record computation time.
+from cal_tools.step_timing import StepTimer
+# `tools` consists for various number of functions to read files, wrappers for iCalibrationDB, etc ...
+from cal_tools.tools import (
+    calcat_creation_time,
+)
+```
+
+## Prepare global variables.
+
+In the following cells it is a common practice to start assigning global variables,
+like converting in_folder and out_folder to Path objects or initializing step_timer object.
+
+
+```python
+# Convert main folders to Paths.
+in_folder = Path(in_folder)
+out_folder = Path(out_folder)
+# This is only needed in case of running the notebook interactively. Otherwise, the machinery take care of this.
+out_folder.mkdir(parents=True, exist_ok=True)
+run_folder = in_folder / f"r{run:04d}"
+
+# Initiate the main Run data collection.
+run_dc = RunDirectory(
+    run_folder, include="*S00000*").select(f"*{karabo_id}*", require_all=True)
+
+print(f"The available source to correct for {karabo_id} are {list(run_dc.all_sources)}")
+
+step_timer = StepTimer()
+```
+
+    The available source to correct for HED_IA1_EPX100-1 are ['HED_IA1_EPX100-1/DET/RECEIVER', 'HED_IA1_EPX100-1/DET/RECEIVER:daqOutput', 'HED_IA1_EPX100-1/DET/CONTROL']
+
+
+## Read operating conditions from RAW data.
+
+It is recommended to read the calibration constants' operating conditions directly from RAW data.
+To avoid wrong given values from the notebook's input argument.
+Unfortunately, there is the possibility that these conditions are not stored in RAW data
+because the detector is in its early operation stages.
+
+
+Below we give an example of reading the integration time of the data. There are multiple functions and similar class
+as epix100Ctrl for other detectors that are used for the same purpose. 
+
+
+```python
+# Read control data.
+data_source = "HED_IA1_EPX100-1/DET/RECEIVER:daqOutput"
+
+ctrl_data = epix100lib.epix100Ctrl(
+    run_dc=run_dc,
+    instrument_src=data_source,
+    ctrl_src=f"{karabo_id}/DET/CONTROL",
+    )
+
+integration_time = ctrl_data.get_integration_time()
+```
+
+## Retrieve needed calibration constants
+
+Usually there is a cell when we retrieve calibration constants before correction
+and sometimes before processing new calibration constants.
+
+In this example we use `EPIX100_CalibrationData` class to initialize an object with
+the necessary operating conditions and creation time.
+
+Below the operating conditions values like integration_time and sensor_temperature are hard coded to specific value.
+In production notebooks this is done differently.
+
+
+```python
+# Run creation time is important to get the correct calibration constant versions.
+creation_time = calcat_creation_time(in_folder, run, creation_time)
+print(f"Using {creation_time.isoformat()} as creation time")
+
+epix_cal = EPIX100_CalibrationData(
+    detector_name=karabo_id,
+    sensor_bias_voltage=bias_voltage,
+    integration_time=integration_time,
+    sensor_temperature=fix_temperature,
+    in_vacuum=in_vacuum,
+    source_energy=photon_energy,
+    event_at=creation_time,
+    client=rest_cfg.calibration_client(),
+)
+
+const_data = epix_cal.ndarray_map()[karabo_da]
+
+print(f"Retrieved calibrations for {karabo_id}: {list(const_data.keys())}")
+```
+
+    Reading creation_date from input files metadata `INDEX/timestamp`
+    Using 2021-09-19T14:39:26.744069+00:00 as creation time
+    Retrieved calibrations for HED_IA1_EPX100-1: ['BadPixelsDarkEPix100', 'NoiseEPix100', 'OffsetEPix100', 'RelativeGainEPix100']
+
+
+## Correcting Raw data
+
+
+```python
+data_key = "data.image.pixels"
+raw_data = run_dc[data_source, data_key].ndarray()
+dshape = raw_data.shape  # Raw input data shape.
+
+print(f"Number of trains to correct is {len(run_dc.train_ids)}")
+
+def correct_train(wid, index, d):
+    """Correct one train for ePix100 detector."""
+    d -= const_data["OffsetEPix100"][..., 0]
+    if gain_correction:
+        d /= const_data["RelativeGainEPix100"]
+
+step_timer.start()
+context = psh.context.ThreadContext(num_workers=10)
+corr_data = context.alloc(shape=dshape, dtype=np.float32)
+
+context.map(correct_train, raw_data.astype(np.float32))
+step_timer.done_step('Correcting data')
+```
+
+    Number of trains to correct is 1000
+    Correcting data: 1.0 s
+
+
+## Writing corrected data
+
+
+```python
+# Storing data.
+out_file = out_folder / "CORR-R9046-EPIX01-S00000.h5"
+instrument_source = "HED_IA1_EPX100-1/DET/RECEIVER:daqOutput"
+
+image_counts = run_dc[instrument_source, "data.image.pixels"].data_counts(labelled=False)
+
+step_timer.start()
+
+with DataFile(out_file, "w") as ofile:
+    # Create INDEX datasets.
+    ofile.create_index(run_dc.train_ids, from_file=run_dc.files[0])
+
+    # Create METDATA datasets
+    ofile.create_metadata(
+        like=run_dc,
+        sequence=run_dc.run_metadata()["sequenceNumber"],
+        instrument_channels=(f"{instrument_source}/data",)
+    )
+    # Create Instrument section to later add corrected datasets.
+    outp_source = ofile.create_instrument_source(instrument_source)
+
+    # Create count/first datasets at INDEX source.
+    outp_source.create_index(data=image_counts)
+
+    # Add main corrected `data.image.pixels` dataset and store corrected data.
+    outp_source.create_key(
+        "data.image.pixels", data=corr_data, chunks=((chunk_size_idim,) + dshape[1:]))
+step_timer.done_step('Writing corrected data')
+```
+
+    Writing corrected data: 1.2 s
+
+
+# Plotting results
+
+
+```python
+geom = Epix100Geometry.from_origin()
+
+fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, figsize=(25, 10))
+
+# Plotting mean data for RAW and CORRECTED across trains
+geom.plot_data(np.mean(raw_data, axis=0), ax=ax1)
+ax1.set_title("Mean RAW across trains")
+geom.plot_data(np.mean(corr_data, axis=0), ax=ax2)
+ax2.set_title("Mean CORR across trains")
+
+plt.show()
+```
+
+
+    
+![png](how_to_write_xfel_calibrate_notebook_NBC_files/how_to_write_xfel_calibrate_notebook_NBC_14_0.png)
+    
+
diff --git a/docs/development/how_to_write_xfel_calibrate_notebook_NBC_files/how_to_write_xfel_calibrate_notebook_NBC_14_0.png b/docs/development/how_to_write_xfel_calibrate_notebook_NBC_files/how_to_write_xfel_calibrate_notebook_NBC_14_0.png
new file mode 100644
index 0000000000000000000000000000000000000000..16bc34871e0f06b1eb2f828d7e30c717a49159be
Binary files /dev/null and b/docs/development/how_to_write_xfel_calibrate_notebook_NBC_files/how_to_write_xfel_calibrate_notebook_NBC_14_0.png differ
diff --git a/docs/development/installation.md b/docs/development/installation.md
new file mode 100644
index 0000000000000000000000000000000000000000..e4a4d098ea4616b22a53f149d4e76119fdb6cbc3
--- /dev/null
+++ b/docs/development/installation.md
@@ -0,0 +1,98 @@
+# Installation
+
+It's recommended to install the offline calibration (pycalibration)
+package on maxwell, using the anaconda/3 environment.
+
+The following instructions clone from the EuXFEL GitLab instance using
+SSH remote URLs, this assumes that you have set up SSH keys for use with
+GitLab already. If you have not then read the appendix section on [SSH
+Key Setup for GitLab](#ssh-key-setup-for-gitlab) for instructions on how
+to do this.
+
+## Installation using python virtual environment - recommended
+
+`pycalibration` uses Python 3.8. Currently, the default
+python installation on Maxwell is still Python 3.6.8, so Python 3.8
+needs to be loaded from a different location.
+
+One option is to use the Maxwell Spack installation, running `module
+load maxwell` will activate the test Spack instance from
+DESY, then you can use `module load
+python-3.8.6-gcc-10.2.0-622qtxd` to Python 3.8. Note that
+this Spack instance is currently a trial phase and may not be stable.
+
+Another option is to use `pyenv`, we provide a pyenv
+installation at `/gpfs/exfel/sw/calsoft/.pyenv` which we use
+to manage different versions of python. This can be activated with
+`source /gpfs/exfel/sw/calsoft/.pyenv/bin/activate`
+
+A quick setup would be:
+
+1.  `source /gpfs/exfel/sw/calsoft/.pyenv/bin/activate`
+2.  `git clone ssh://git@git.xfel.eu:10022/detectors/pycalibration.git && cd pycalibration` -
+    clone the offline calibration package from EuXFEL GitLab
+3.  `pyenv shell 3.8.11` - load required version of python
+4.  `python3 -m venv .venv` - create the virtual environment
+5.  `source .venv/bin/activate` - activate the virtual environment
+6.  `python3 -m pip install --upgrade pip` - upgrade version of pip
+7.  `python3 -m pip install .` - install the pycalibration package (add
+    `-e` flag for editable development installation)
+
+Copy/paste script:
+
+```bash
+source /gpfs/exfel/sw/calsoft/.pyenv/bin/activate
+git clone ssh://git@git.xfel.eu:10022/detectors/pycalibration.git
+cd pycalibration
+pyenv shell 3.8.11
+python3 -m venv .venv
+source .venv/bin/activate
+python3 -m pip install --upgrade pip
+python3 -m pip install .  # `-e` flag for editable install, e.g. `pip install -e .`
+```
+
+## Creating an ipython kernel for virtual environments
+
+To create an ipython kernel with pycalibration available you should (if
+using a venv) activate the virtual environment first, and then run:
+
+```bash
+python3 -m pip install ipykernel  # If not using a venv add `--user` flag
+python3 -m ipykernel install --user --name pycalibration --display-name "pycalibration"  # If not using a venv pick different name
+```
+
+This can be useful for Jupyter notebook tools as [max-jhub documentation](https://rtd.xfel.eu/docs/data-analysis-user-documentation/en/latest/jhub/)([max-jhub](https://max-jhub.desy.de/hub/login))
+
+## SSH Key Setup for GitLab
+
+It is highly recommended to setup SSH keys for access to GitLab as this
+simplifies the setup process for all of our internal software present on
+GitLab.
+
+To set up the keys:
+
+1.  Connect to Maxwell
+2.  Generate a new keypair with `ssh-keygen -o -a 100 -t ed25519`, you
+    can either leave this in the default location (`~/.ssh/id_ed25519`)
+    or place it into a separate directory to make management of keys
+    easier if you already have multiple ones. If you are using a
+    password for your keys please check this page to learn how to manage
+    them:
+    <https://docs.github.com/en/github/authenticating-to-github/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent#adding-your-ssh-key-to-the-ssh-agent>
+3.  Add the public key (`id_ed25519.pub`) to your account on GitLab:
+    <https://git.xfel.eu/gitlab/profile/keys>
+4.  Add the following to your `~/.ssh/config` file
+
+```bash
+# Special flags for gitlab over SSH
+Host git.xfel.eu
+    User git
+    Port 10022
+    ForwardX11 no
+    IdentityFile ~/.ssh/id_ed25519
+```
+
+Once this is done you can clone repositories you have access to from
+GitLab without having to enter your password each time. As
+`pycalibration` requirements are installed from SSH remote URLs having
+SSH keys set up is a requirement for installing pycalibration.
diff --git a/docs/development/testing_pipeline.md b/docs/development/testing_pipeline.md
new file mode 100644
index 0000000000000000000000000000000000000000..9fe8a8ce3bea8ffc1f658bc8d6c2553822732743
--- /dev/null
+++ b/docs/development/testing_pipeline.md
@@ -0,0 +1,91 @@
+# pyCalibration automated tests
+
+## Objective
+
+Test available detector calibrations against picked reference data
+to prove the software consistency and avoid sneaky bugs that
+affect the produced data quality.
+
+1. Test the successful processing for executing SLURM jobs.
+   1. xfel-calibrate CL runs successfully
+   2. SLURM jobs are executed on Maxwell
+   3. SLURM jobs are COMPLETED at the end.
+2. Test the availability of files in the out-folder
+   1. Validate the presence of a PDF report.
+   2. Validate the number of HDF5 files against the number of HDF5 files in the reference folder.
+3. Validate the numerical values of the processed data against the referenced data.
+
+These tests are meant to run on all detector calibrations before any release. As well as run it per branch on the selected detector/calibration that is affected by the branch's changes.
+
+## Current state
+
+- Tests are defined by a callab_test.py DICT.
+  ```py
+  {
+   "<test-name>(`<detector-calibration-operationMode>`)": {
+      "det-type": "<detectorType>",
+      "cal_type": "<calibrationType>",
+      "config": {
+         "in-folder": "<inFolderPath>",
+         "out-folder": "<outFolderPath>",
+         "run": "<runNumber>",
+         "karabo-id": "detector",
+
+         "<config-name>": "<config-value>",
+         ...: ...,
+      },
+      "reference-folder": "{}/{}/{}",
+   }
+   ...
+  }
+  ```
+
+- Test are triggered using GitLab manual trigger CI pipeline.
+
+After opening a merge request on GitLab the CI initiates the unit tests pipeline automatically. After these tests are finished, you get an option to trigger a manual test.
+
+![manual action](../static/tests/manual_action.png)
+
+Using this Gitlab feature you can run the tests with no configuration, this will result in running all the runs for the automated tests. This is usually good if the change is effecting all detectors and all calibration notebooks. Or before deploying new releases.
+
+Otherwise, you can configure the test to a specific `CALIBRATION` (DARK or CORRECT) or/and configure the list of detectors to run the tests for.
+
+![Put arguments](../static/tests/given_argument_example.png) 
+
+!!! warning
+
+It is not recommended to run multiple automated tests on more than a merge request at the same time. As these test are memory consuming and all tests run on the same test node.
+
+The GitLab test pipeline jobs progress report is used to collect useful information about the test result and the reason of failure for any of the tested calibration runs.
+
+- Tests are triggered using CLI locally:
+
+   ```bash
+   pytest tests/test_reference_runs/test_pre_deployment.py \
+   --release-test \
+   --reference-folder <reference-folder-path> \
+   --out-folder <out-folder-path>
+   ```
+
+  - Arguments:
+    - required arguments:
+      - release-test: this is needed to trigger the automated test. To avoid triggering this as a part of the Gitlab CI this boolean was created.
+      - reference-folder: Setting the reference folder path. The reference folder is expected to have exactly the same structure as the out-folder. Usually the reference folders are out-folder from previous successful tested releases.
+      - out-folder: The output folder paths for saving the test output files.
+        - The structure is `<detector>/<test-name>/[PDF, HDF5, YAML, SlurmOut, ...]`
+    - optional arguments:
+      - picked-test: this can be used to only run the tests for one <test-name> only.
+      - calibration: this can be used to pick only one calibration type to run the test for. [dark or correct]
+      - detector: this can be used to pick detectors to run the test for and skip the rest.
+      - no-numerical-validation: as the numerical validation is done by default. This argument can be used to skip it and stop at executing the calibration and making sure that the SLURM jobs were COMPLETED.
+      - validation-only: in case the test output and reference files were already available and only a validation check is needed. this argument can be used to only run the validation checks without executing any calibration jobs.
+
+- Below are the steps taken to fully test the calibration files:
+   1. Run `xfel-calibrate DET CAL ...`, this will result in Slurm calibration jobs.
+   2. Check the Slurm jobs state after they finish processing.
+   3. Confirm that there is a PDF available in the output folder.
+   4. Validate the HDF5 files.
+      1. Compare the MD5 checksum for the output and reference.
+      2. Find the datatsets/attributes that are different in both files.
+
+In case a test fails the whole test fails and the next test starts.
diff --git a/docs/development/workflow.md b/docs/development/workflow.md
new file mode 100644
index 0000000000000000000000000000000000000000..c804e3f75036e8b7d21f8c0af2b3b8fdb7b3289d
--- /dev/null
+++ b/docs/development/workflow.md
@@ -0,0 +1,228 @@
+# Development Workflow
+
+We welcome contributions to the pipeline if you have calibration notebooks or algorithms that you believe could be useful. In order to facilitate the development process, we have provided a section that outlines the key points to consider during the development of new features. This section is designed to assist you throughout the development and review process, and ensure that your contributions are consistent with the pipeline's requirements. We believe that these guidelines will be helpful in creating a seamless development process and result in high-quality contributions that benefit the pipeline. If you have any questions or concerns regarding the development process, please do not hesitate to reach out to us for assistance. We look forward to working with you to enhance the pipeline's capabilities.
+
+
+## Developing a notebook from scratch
+
+  Developing a notebook from scratch can be a challenging but rewarding process. Here are some key steps to consider:
+
+  1. Define the purpose
+
+    Start identifying what are you trying to solve and the task you want to perform with your notebook.
+
+      - Does the user need to execute the notebook interactively?
+      - Should it run the same way as the production notebooks? It is recommended that the notebook is executed in the same way as the production notebooks through xfel-calibrate CLI.
+
+    ??? Note "`xfel-calibrate` CLI is essential"
+
+        If `xfel-calibrate` CLI is essential, you need to follow the guidelines in where and how to write the variables in the first notebook cell and how to include it as one of the CLI calibration options to execute.
+
+    - Does the notebook need to generate a report at the end to display its results or can it run without any user interaction?
+
+    ??? Note "A report is needed"
+      
+        If a report is needed you should make sure to provide sufficient guidance and textual details using markdown cells and clear prints within the code. You should also structure the notebook cells into appropriate subsections.
+
+  2. Plan you work flow
+    Map out the steps your notebook will take. From data ingestion to analyzing results and visualization.
+
+    - What are the required data sources that the notebook needs to access or utilize? For example, GPFS or calibration database.
+    - Can the notebook's internal concurrency be optimized through the use of multiprocessing or is it necessary to employ host-level cluster computing with SLURM to achieve higher performance?
+
+    ??? Note "SLURM concurrency is needed"
+
+        If SLURM concurrency is needed, you need to identify the variable that the notebook will be replicated based on to split the processing.
+
+    - What visualization tools or techniques are necessary to provide an overview of the processing results generated by the notebook? Can you give examples of charts, graphs, or other visual aids that would be useful for understanding the output?
+
+  3. Write the code and include documentation
+
+    Begin coding your notebook based on your workflow plan. Use comments to explain code blocks and decisions.
+    - [PEP 8](https://peps.python.org/pep-0008/) styling code is highly recommended. It leads to code that is easier to read, understand, and maintain. Additionally, it is a widely accepted standard in the Python community, and following it make your code more accessible to other developers and improve collaboration.
+    - [Google style docstrings](https://google.github.io/styleguide/pyguide.html) is our recommended way of documenting the code. By providing clear and concise descriptions of your functions and methods, including input and output parameters, potential exceptions, and other important details, you make it easier for other developers to understand the code, and for the used mkdocs documentation to [reference it](SUMMARY.md).
+
+  4. Document the notebook and split into sections.
+
+    Enriching a notebook with documentation is an important step in creating a clear and easy-to-follow guide for others to use:
+
+    - Use Markdown cells to create titles and section headings: By using Markdown cells, you can create clear and descriptive headings for each section of your notebook. This makes it easier to navigate and understand the content of the notebook, but more importantly these are parsed while creating the PDF report using [sphinx][sphinx].
+    - Add detailed explanations to each section.
+    - Add comments to your code.
+
+  5. Test and refine
+    Test your notebook thoroughly to identify any issues. Refine your code and documentation as needed to ensure your notebook is accurate, efficient, and easy to use.
+
+  6. Share and collaborate
+
+    Share your notebook on [GitLab](https://git.xfel.eu/) to start seeking feedback and begin the reviewing process.
+
+
+## Write notebook to execute using xfel-calibrate
+
+To start developing a new notebook, you either create it in an existing detector directory or create a new directory for it with the new detector's name. Give it a suffix `_NBC` to denote that it is enabled for the tool chain.
+
+You should then start writing your code following these [guidelines](how_to_write_xfel_calibrate_notebook_NBC.ipynb)
+
+- First markdown cell goes for Title, author, and notebook description. This is automatically parsed in the report.
+- First code cell must have all parameter that will be exposed to `xfel-calibrate` CLI
+- Second code cell for importing all needed libraries and methods.
+- The following code cells and markdown cells are for data ingestion, data processing, and data visualization. Markdown cells are very important as it will be parsed as the main source of report text and documentation after the calibration notebook is executed. 
+
+## Exposing parameters to `xfel-calibrate`
+
+The European XFEL Offline Calibration toolkit automatically deduces
+command line arguments from Jupyter notebooks. It does this with an
+extended version of [nbparameterise][nbparameterise], originally written by Thomas
+Kluyver.
+
+Parameter deduction tries to parse all variables defined in the first
+code cell of a notebook. The following variable types are supported:
+
+* Numbers(INT or FLOAT)
+* Booleans
+* Strings
+* Lists of the above
+
+You should avoid having `import` statements in this cell. Line comments
+can be used to define the help text provided by the command line interface, and to signify if lists can be constructed from ranges and if parameters are
+required::
+
+    in_folder = ""  # directory to read data from, required
+    out_folder = ""  # directory to output to, required
+    metadata_folder = ""  # directory containing calibration metadata file when run by xfel-calibrate
+    run = [820, ]  # runs to use, required, range allowed
+    sequences = [0, 1, 2, 3, 4]  # sequences files to use, range allowed
+    modules = [0]  # modules to work on, required, range allowed
+
+    karabo_id = "MID_DET_AGIPD1M-1"  # Detector karabo_id name
+    karabo_da = [""]  # a list of data aggregators names, Default [-1] for selecting all data aggregators
+
+    skip-plots = False  # exit after writing corrected files and metadata
+
+The above are some examples of parameters from AGIPD correction notebook.
+
+- Here, `in_folder` and `out_folder` are set as `required` string values. 
+
+Values for required parameters have to be given when executing from the command line. 
+This means that any defaults given in the first cell of the code are ignored 
+(they are only used to derive the type of the parameter). 
+
+- `modules` and `sequences` are lists of integers, which from the command line could also be assigned using a range expression, 
+e.g. `5-10,12,13,18-21`, which would translate to `5,6,7,8,9,12,13,18,19,20`.
+
+!!! Warning
+    [nbparameterise][nbparameterise] can only parse the mentioned subset of variable types. An expression that evaluates to such a type will not be recognized. e.g. `a = list(range(3))` will not work!
+
+- `karabo_id` is a string value indicating the detector to be processed.
+- `karabo_da` is a list of strings to indicate the detector's modules to be processed. As `karabo_da` and `modules` 
+  are two different variables pointing to the same physical parameter. In the later notebook cells both parameters are synced 
+  before usage.
+
+- `skip-plots` is a boolean for skipping the notebook plots to save time and deliver the report as soon as the data are processed. 
+  to set `skip-plots` to False from the command line. `--no-skip-plots` is used.
+
+The table below provides a set of recommended parameter names to ensure consistency across all notebooks.
+
+
+| Parameter name    | To be used for                                                        | Special purpose            |
+| -----------       | --------------------------------------------------------------------- |----------------------------|
+| `in_folder`       | the input path data resides in, usually without a run number.         ||
+| `out_folder`      | path to write data out to, usually without a run number.              | reports can be placed here |
+| `metadata_folder` | directory path for calibration metadata file with local constants.    ||
+| `run(s)`          | which XFEL DAQ runs to use, often ranges are allowed.                 ||
+| `karabo_id`       | detector karabo name to access detector files and constants.          ||
+| `karabo_da`       | refers to detector's modules data aggregator names to process.        ||
+| `modules`         | refers to the detector's modules indices to process, ranges often ok. ||
+| `sequences`       | sequence files for the XFEL DAQ system, ranges are often ok.          ||
+| `local_output`    | write calibration constant from file, not database.                   ||
+| `db_output`       | write calibration constant from database, not file.                   |saves the database from unintentional constant |
+| `injections`      | developments or testing.                                              |                            |
+
+
+## External Libraries
+
+You may use a wide variety of libraries available in Python, but keep in mind that others wanting to run the tool will need to install these requirements as well. Therefore::
+
+  - It is generally advisable to avoid using specialized tools or libraries unless there is a compelling reason to do so. Instead, it is often better to use well-established and widely-accepted alternatives that are more likely to be familiar to other developers and easier to install and use. For example, when creating visualizations, it is recommended to use the popular and widely-used library, [matplotlib][matplotlib] for charts, graphs and other visualisation. Similarly, [numpy][numpy] is widely used when performing numerical processing tasks.
+
+  - When developing software, it is important to keep in mind the runtime and library requirements for your application. In particular, if you are using a library that performs its own parallelism, you will need to ensure that it can either set up this parallelism programmatically or do so automatically. If you need to start your application from the command line, there may be additional challenges to consider. 
+
+  - Reading out EXFEL RAW data is encouraged to be done using [extra_data][extra_data]. This tool is designed to facilitate efficient access to data structures stored in HDF5 format. By simplifying the process of accessing RAW or CORRECTED datasets, it allows users to quickly and easily select and filter the specific trains, cells, or pixels of interest. This can greatly reduce the complexity and time required for data analysis, and enables researchers to more effectively explore and analyze large datasets.
+
+## Writing out data
+
+If your notebook produces output data, consider writing data out as early as possible, such that it is available as soon as possible. Detailed plotting and inspection can be done later on in the notebook.
+
+Also use HDF5 via [h5py][h5py] as your output format. If you correct or calibrate input data, which adheres to the XFEL naming convention, you should maintain the convention in your output data. You should not touch any data that you do not actively work on and should assure that the `INDEX` and identifier entries are synchronized with respect to your output data. E.g. if you remove pulses from a train, the `INDEX/.../count` section should reflect this. [`cal_tools.files`](../reference/src/cal_tools/files.md) module helps you achieve this easily.
+
+
+## Plotting
+
+When creating plots, make sure that the plot is either self-explanatory or add markdown comments with adequate description. Do not add "free-floating" plots, always put them into a context. Make sure to label your axes.
+
+Also make sure the plots are readable on an A4-sized PDF page; this is the format the notebook will be rendered to for report outputs. Specifically, this means that figure sizes should not exceed approx 15x15 inches.
+
+The report will contain 150 dpi PNG images of your plots. If you need higher quality output of individual plot files you should save these separately, e.g. via `fig.savefig(...)` yourself.
+
+## xfel-calibrate execution
+
+The package utilizes tools such as [nbconvert](https://github.com/jupyter/nbconvert) and
+[nbparameterise][nbparameterise] to expose [Jupyter](http://jupyter.org/) notebooks to a command line interface. In the process reports are generated from these notebooks.
+
+The general interface is:
+
+    % xfel-calibrate DETECTOR TYPE
+
+where `DETECTOR` and `TYPE` specify the task to be performed.
+
+Additionally, it leverages the DESY/XFEL Maxwell cluster to run these jobs in parallel via [SLURM][slurm].
+
+Here is a list of [available_notebooks](../operation/available_notebooks.md).
+
+## Interaction with the calibration database
+
+During development, it is advised to work with local constant files first before injecting any calibration constants to the production database. After the notebook's algorithms arguments matured one can switch over to the test database and then production database.
+The reason for this is to avoid injecting wrong constants that can affect production calibration.
+And to avoid unnecessary intervention to disable wrong or unused injected calibration constants.
+
+Additionally, the [calibration database](../operation/calibration_database.md) is limited to XFEL networks, so independent development improves the workflow.
+
+
+## Testing
+
+The most important test is that your notebook completes flawlessly outside any special tool chain feature. After all, the tool chain will only replace parameters, and then launch a concurrent job and generate a report out of notebook. If it fails to run in the normal Jupyter notebook environment, it will certainly fail in the tool chain environment.
+
+Once you are satisfied with your current state of initial development, you can add it to the list of notebooks as mentioned in the [configuration](configuration.md#notebooks) section.
+
+Any changes you now make in the notebook will be automatically propagated to the command line.
+Specifically, you should verify that all arguments are parsed correctly, e.g. by calling::
+
+```bash
+  xfel-calibrate DETECTOR NOTEBOOK_TYPE --help
+```
+
+From then on, check include if parallel [SLURM][slurm] jobs are executed correctly and if a report is generated at the end.
+
+Finally, you should verify that the report contains the information you'd like to convey and is intelligible to people other than you.
+
+???+ note
+
+    You can run the `xfel-calibrate` command without starting a [SLURM][slurm] cluster job, giving you direct access to console output, by adding the `--no-cluster-job` option.
+
+## Documenting
+
+Most documentation should be done in the notebook itself. Any notebooks specified in the `notebook.py` file will automatically show up in the [Available Notebooks](../operation/available_notebooks.md) section of this documentation.
+
+
+[nbparameterise]: https://github.com/takluyver/nbparameterise
+[ipcluster]: https://ipyparallel.readthedocs.io/en/latest/
+[matplotlib]: https://matplotlib.org/
+[numpy]: http://www.numpy.org/
+[h5py]: https://www.h5py.org/
+[iCalibrationDB]: https://git.xfel.eu/detectors/cal_db_interactive
+[extra_data]: https://extra-data.readthedocs.io/en/latest/
+[extra-geom]: https://extra-geom.readthedocs.io/en/latest/
+[pasha]: https://github.com/European-XFEL/pasha
+[slurm]: https://slurm.schedmd.com/documentation.html
+[sphinx]: https://www.sphinx-doc.org/en/master/
\ No newline at end of file
diff --git a/docs/gen_ref_pages.py b/docs/gen_ref_pages.py
new file mode 100644
index 0000000000000000000000000000000000000000..e840afd59096f5b31966a7c777291d6ceafbcf7e
--- /dev/null
+++ b/docs/gen_ref_pages.py
@@ -0,0 +1,37 @@
+
+# https://mkdocstrings.github.io/recipes/
+
+from pathlib import Path
+
+import mkdocs_gen_files
+
+src = Path(__file__).parent.parent / "src"
+
+nav = mkdocs_gen_files.Nav()
+
+for path in sorted(src.rglob("*.py")):
+
+    module_path = path.relative_to(src).with_suffix("")
+    doc_path = path.relative_to(src).with_suffix(".md")
+    full_doc_path = Path("reference", doc_path)
+    parts = list(module_path.parts)
+
+    if parts[-1] in [
+        "notebooks", "settings",
+        "restful_config", "__main__",
+        "__init__", "listen_kafka",
+        "sqlite_view", "manual_launch"
+        "messages",
+    ]:
+        continue
+
+    nav[parts] = doc_path.as_posix() 
+
+    with mkdocs_gen_files.open(full_doc_path, "w") as fd:
+        ident = ".".join(parts)
+        fd.write(f"::: {ident}")
+
+    mkdocs_gen_files.set_edit_path(full_doc_path, path)
+
+with mkdocs_gen_files.open(f"reference/SUMMARY.md", "w") as nav_file:
+    nav_file.writelines(nav.build_literate_nav())
diff --git a/docs/includes/abbreviations.md b/docs/includes/abbreviations.md
new file mode 100644
index 0000000000000000000000000000000000000000..1407a15ef2a41d745c8fa89baadb22a35ea2acf0
--- /dev/null
+++ b/docs/includes/abbreviations.md
@@ -0,0 +1,6 @@
+*[PDU]: Physical Detector Unit is the name given for the hardware module.
+*[CC]: Calibration Constant
+*[CCV]: Calibration Constant Version
+*[CLI]: Command Line Interface
+*[myMDC]: Metadata Catalog
+*[CALCAT]: Calibration Catalog is the web interface for the calibration database.
\ No newline at end of file
diff --git a/docs/index.md b/docs/index.md
new file mode 100644
index 0000000000000000000000000000000000000000..2003c87f9245f8c06f4b82e921ba5960c2269fbe
--- /dev/null
+++ b/docs/index.md
@@ -0,0 +1,9 @@
+European XFEL Offline Calibration
+=================================
+
+The European XFEL Offline Calibration (pyCalibration) is a python package that consists of different services, responsible for applying most of the offline calibration and characterization for the detectors.
+
+
+- [Overview](overview.md) Offline calibration overview
+
+- [Installation](development/installation.md) How to install pycalibration
diff --git a/docs/operation/available_notebooks.md b/docs/operation/available_notebooks.md
new file mode 100644
index 0000000000000000000000000000000000000000..4b517c510d12fd97f60e0b92be4bf5ab7bcf9e34
--- /dev/null
+++ b/docs/operation/available_notebooks.md
@@ -0,0 +1,353 @@
+# Available Notebooks
+
+The following notebooks are currently integrated into European XFEL Offline Calibration tool chain.
+
+
+## AGIPD
+
+### [AGIPD Correction](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/AGIPD/AGIPD_Correct_and_Verify.ipynb)
+
+Offline Correction for AGIPD Detector
+
+
+### [AGIPD Characterize Dark Images](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/AGIPD/Characterize_AGIPD_Gain_Darks_NBC.ipynb)
+
+This notebook analyzes a set of dark images taken with AGIPD detector to deduce detector offsets (pedestal), noise, bad-pixel maps and thresholds. All four types of constants are evaluated per-pixel and per-memory cell. Data for the detector’s three gain stages needs to be present and separated into separate runs.
+
+The evaluated calibration constants are stored locally and injected in the calibration database.
+
+### [Characterize AGIPD Pulse Capacitor Data](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/AGIPD/Chracterize_AGIPD_Gain_PC_NBC.ipynb)
+
+
+The following code characterizes AGIPD gain via data take with the pulse capacitor source (PCS). The PCS allows scanning through the high and medium gains of AGIPD, by subsequently increasing the number of charge pulses from on-ASIC capacitor, thus increasing the charge a pixel sees
+in a given integration time.
+
+Because induced charge does not originate from X-rays on the sensor, the gains evaluated here will later need to be rescaled with gains deduced from X-ray data.
+
+PCS data is organized into multiple runs, as the on-ASIC current source cannot supply all pixels of a given module with charge at the same time.
+Hence, only certain pixel rows will have seen charge for a given image. These rows then first need to be combined into single module images again. This script uses new style of merging, which does not support old data format.
+
+We then use a K-means clustering algorithm to identify components in the
+resulting per-pixel data series, matching to three general regions:
+
+-  High gain slope
+-  Transition region, where gain switching occurs
+-  Medium gain slope.
+
+The same regions are present in the gain-bit data and are used to deduce the switching threshold.
+
+The resulting slopes are then fitted with a linear function and a combination of a linear and exponential decay function to determine the relative gains of the pixels with respect to the module. Additionally, we deduce masks for bad pixels form the data.
+
+### [Gain Characterization](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/AGIPD/Characterize_AGIPD_Gain_FlatFields_NBC.ipynb)
+
+This notebook is used to produce AGIPD Flat-Field constants.
+
+### [Histogramming of AGIPD FF data](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/AGIPD/AGIPD_FF_Histogramming.ipynb)
+
+??? warning "No description"
+
+    TODO: Add description for this notebook
+
+### [Combine Constants](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/AGIPD/AGIPD_Characterize_Gain_Combine_NBC.ipynb)
+
+This notebook combines constants from various evaluations
+
+-  Dark image analysis, yielding offset and noise
+-  Flat field analysis, yielding X-ray gain
+-  Pulse capacitor analysis, yielding medium gain stage slopes and
+   thresholds
+-  Charge injection analysis, yielding low gain stage slopes and thresholds into a single set of calibration constants.
+
+These constants do not include offset and noise as they need to be reevaluated more frequently.
+
+Additionally, a bad pixel mask for all gain stages is deduced from the input. The mask contains dedicated entries for all pixels and memory cells as well as all three gains stages.
+
+------------------------------------------------------------------------------
+
+## DSSC
+
+
+### [DSSC Offline Correction](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/DSSC/DSSC_Correct_and_Verify.ipynb)
+
+
+Offline Correction for DSSC Detector
+
+### [DSSC Characterize Dark Images](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/DSSC/Characterize_DSSC_Darks_NBC.ipynb)
+
+The following code analyzes a set of dark images taken with the DSSC detector to deduce detector offsets and noise. Data for the detector is presented in one run and don’t acquire multiple gain stages.
+
+The notebook explicitly does what `pyDetLib` provide in its offset calculation method for streaming data.
+
+----------------------------------------------------------------------------
+
+## EPIX100
+
+### [ePix100 Data Correction](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/ePix100/Correction_ePix100_NBC.ipynb)
+
+The following notebook provides data correction of images acquired with
+the ePix100 detector.
+
+The sequence of correction applied are: Offset –> Common Mode Noise –> Relative Gain –> Charge Sharing –> Absolute Gain.
+
+Offset, common mode and gain corrected data is saved to
+`/data/image/pixels` in the CORR files.
+
+If pattern classification is applied (charge sharing correction), this data will be saved to /data/image/pixels_classified, while the corresponding patterns will be saved to /data/image/patterns in the CORR files.
+
+### [ePix100 Dark Characterization](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/ePix100/Characterize_Darks_ePix100_NBC.ipynb)
+
+The following notebook provides dark image analysis and calibration constants of the ePix100 detector.
+
+Dark characterization evaluates offset and noise of the detector and gives information about bad pixels.
+
+Noise and bad pixels maps are calculated independently for each of the 4 ASICs of ePix100, since their noise behavior can be significantly different.
+
+Common mode correction can be applied to increase sensitivity to noise related bad pixels. Common mode correction is achieved by subtracting the median of all pixels that are read out at the same time along a row/column. This is done in an iterative process, by which a new bad pixels map is calculated and used to mask data as the common mode values
+across the rows/columns is updated.
+
+Resulting maps are saved as HDF5 files for a later use and injected to calibration DB.
+
+### references: 
+
+- [epix100 documentation](https://rtd.xfel.eu/docs/epix-documentation/en/latest/index.html)
+
+-----------------------------------------------------------------------------------------
+
+## GOTTHARD2
+
+### [Gotthard2 Offline Correction](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/Gotthard2/Correction_Gotthard2_NBC.ipynb)
+
+Offline Correction for Gotthard2 Detector.
+
+This notebook is able to correct 25um and 50um GH2 detectors using the same correction steps:
+- Convert 12bit raw data into 10bit, offset subtraction, then multiply with gain constant.
+
+| Correction | constants   | boolean to enable/disable   |
+|------------|-------------|-----------------------------|
+|   12bit to 10bit  | `LUTGotthard2` |  |
+|   Offset  | `OffsetGotthard2`|`offset_correction`|
+|   Relative gain  | `RelativeGainGotthard2` + `BadPixelsFFGotthard2` |`gain_correction`|
+
+Beside the corrected data, a mask is stored using the badpixels constant of the same parameter conditions and time.
+- `BadPixelsDarkGotthard2`
+- `BadPixelsFFGotthard2`, if relative gain correction is requested.
+
+The correction is done per sequence file. If all selected sequence files have no images to correct the notebook will fail.
+The same result would be reached in case the needed dark calibration constants were not retrieved for all modules and `offset_correction` is True.
+In case one of the gain constants were not retrieved `gain_correction` is switched to False and gain correction is disabled.
+
+### [Gotthard2 Dark Image Characterization](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/Gotthard2/Characterize_Darks_Gotthard2_NBC.ipynb)
+
+The following is a processing for the dark constants (`Offset`, `Noise`, and `BadPixelsDark`) maps using dark images taken with Gotthard2 detector (GH2 50um or 25um).
+All constants are evaluated per strip, per pulse, and per memory cell. The maps are calculated for each gain stage that is acquired in 3 separate runs.
+
+The three maps can be injected to the database and/or stored locally.
+
+------------------------------------------------------------------
+
+## JUNGFRAU
+
+### [Jungfrau Offline Correction](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/Jungfrau/Jungfrau_Gain_Correct_and_Verify_NBC.ipynb)
+
+Offline Correction for Jungfrau detector. For single and burst mode and for detector operated in adaptive or fixed gain.
+
+This notebook expects 4 different calibration constants. `Offset`, `BadPixelsDark`, `RelativeGain`, and `BadPixelsFF`. The raw data is by default offset subtracted then divided by the gain parameter. Both bad pixels parameters are stored as a masked array `data/mask` along with the corrected data (same data path as RAW `data/adc`).
+
+The notebook accounts for the raw gain values (0[00], 1[01], 3[11]) during correction. But the raw gain values are stored exactly the same in the corrected files.
+
+- Save reduced ROIs
+  This notebook supports writing reduce ROI data into the corrected files. For example FXE uses a spectrometer which sends a spectrum onto a set region of the detector. This can be selected and reduced to 1D array, along with a comparable background region. This reduced data can be read rather than the full images.
+
+- Correct strixel sensors.
+  This notebook is able to offline correct strixel JUNGFRAU as well. Using a cython function a the sensor is decoded and pixels are reordered for offline correction.
+  [Module details](https://redmine.xfel.eu/issues/126444):
+    * Only 4 ASICs instead of 8
+    * The pixels on the ASIC are still 75 um x 75 um
+    * The sensor instead has rectangular pixels: 25 um x 225 um, i.e. 1/3 of the pixel pitch along the x-axis and three times along the y-axis (to maintain the total number of pixel unchanged);
+    * The readout however is not 'aware' of these changes, so it treats it like a 'normal' JUNGFRAU module, hence the output must be re-shuffled (in the row and column dimensions) in order for the image to make sense.
+
+### [Jungfrau Dark Image Characterization](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/Jungfrau/Jungfrau_dark_analysis_all_gains_burst_mode_NBC.ipynb)
+
+Analyzes Jungfrau dark image data to deduce offset, noise and bad pixel maps from three dark runs of each gain. For data of single or burst mode and detector operated in adaptive or fixed gain.
+
+`Offset` and `Noise` calibration parameters are computed using mean and standard deviation across pixels per memory cells and gain, respectively.
+
+`BadPixelsDark` calibration parameter consists of pixels with wrong gain values, empty cell images (cells with 0 pixel values), pixels for offset and noise maps evaluated with values above bad pixel threshold sigmas, and infinite values in offset or noise maps.
+
+### [Jungfrau Dark Summary](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/Jungfrau/Jungfrau_darks_Summary_NBC.ipynb)
+
+Summary for process dark constants and a comparison with previously injected constants with the same conditions.
+
+### References: 
+
+- [Jungfrau documentation](https://rtd.xfel.eu/docs/jungfrau-detector-documentation/en/latest/jf_correction.html)
+
+--------------------------------------------------------------------------------------
+
+## LPD
+
+### [LPD Offline Correction](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/LPD/LPD_Correct_Fast.ipynb)
+
+Offline correction for LPD detector data.
+
+This notebook applies Offset correction then gain correction by default on LPD1M.
+Additionally, bad-pixels are masked and stored in a mask array along with the corrected data.
+
+The notebook expects 6 different constants. `Offset`, `RelativeGain`, `FFMap`, `GainAmpMap` and two badpixel maps (`BadPixelsDark` and `BadPixelsFF`)
+
+Offset –> RelativeGain * FFMap * GainAmpMap.
+
+
+### [LPD Offset, Noise and Dead Pixels Characterization](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/LPD/LPDChar_Darks_NBC.ipynb)
+
+This notebook process dark images to derive offset, noise and bad-pixel maps. All three types of constants are evaluated per-pixel and per-memory cell.
+
+The notebook will correctly handle veto settings, but note that if you veto cells you will not be able to use these offsets for runs with different veto settings - vetoed cells will have zero offset.
+
+The evaluated calibration constants are stored locally and injected in the calibration database.
+
+### [LPD Radial X-ray Gain Evaluation](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/LPD/LPD_FlatField_Radial_per_pixel_CI_NBC.ipynb)
+
+Taking proper flat field for LPD can be difficult, as air scattering will always be present. Additionally, the large detector mandates a large distance to the source, in order to reduce $1/r$ effects.
+
+Because of this a radial evaluation method is used, which assumes that pixels are the same radial distance $r$ should on average have the
+same signal $S(r)$.
+
+### [Injecting calibration constant data to the database](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/LPD/Inject_calibration_constants_from_h5files.ipynb)
+
+Reading h5files of calibration constants to inject them to the database.
+Used for LPD
+
+### [LPD Gain Characterization (Charge Injection)](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/LPD/Characterize_LPD_GAIN_CI_per_pixel_NBC.ipynb)
+
+The following code characterizes the gain of the LPD detector from charge injection data, i.e. data with charge injected into the amplifiers, bypassing the sensor. The data needs to fulfil the following requirements:
+
+- Each file should represent one scan point for one muddle, defined by
+   detector gain setting
+   and charge injections setting
+- Settings need to overlap at least one point for two neighboring
+   gain ranges
+- 100 samples or more per pixel and memory cell should be present for
+   each setting.
+
+The data is then analyzed by calculating the per-pixel, per memory cell mean of the samples for each setting. These means are then normalized to the median peak position of all means of the first module. Overlapping settings in neighboring gain ranges are used to deduce the slopes of the different gains with respect to the high gain setting.
+
+---------------------------------------------------------------------------------------
+
+## PNCCD
+
+### [pnCCD Data Correction](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/pnCCD/Correct_pnCCD_NBC.ipynb)
+
+The following notebook provides offset, common mode, relative gain, split events and pattern classification corrections of images acquired with the pnCCD. This notebook *does not* yet correct for charge transfer inefficiency.
+
+
+Offset –> Common Mode –> Gain Correction –> Split pattern classification
+
+The notebook stores the offset corrected data at `/data/pixels`, the common mode corrected data at `/data/pixels_cm`, the gain constant used is stored at `/data/gain`, the pattern classification has two arrays stored `/data/pixels_classified` and `/data/patterns`, and the bad pixels are masked and stored at `data/mask`.
+
+### [pnCCD Dark Characterization](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/pnCCD/Characterize_pnCCD_Dark_NBC.ipynb)
+
+This notebook provides dark image analysis of the pnCCD detector. Dark characterization evaluates offset and noise of the detector and gives information about bad pixels.
+
+On the first iteration, the offset and noise maps are generated. Initial bad pixels map is obtained based on the offset and initial noise maps. Edge pixels are also added to the bad pixels map.
+
+On the second iteration, the noise map is corrected for common mode. A second bad pixel map is generated based on the offset map and offset-and-common-mode-corrected noise map. Then, the hole in the center of the CCD is added to the second bad pixel map.
+
+On the third and final iteration, the pixels that show up on the above-mentioned bad pixels map are masked. Possible events due to cosmic rays are found and masked. The data are then again offset and common mode corrected and a new final noise and bad pixels maps are generated.
+
+These latter resulting maps together with the offset map are saved as HDF5 files to a local path for a later use. These dark constants are not automatically sent to the database.
+
+### [pnCCD Gain Characterization](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/pnCCD/Characterize_pnCCD_Gain.ipynb)
+
+The following notebook provides gain characterization for the pnCCD. It relies on EuXFEL offline corrected data. Prior to running this notebook, the expected applied corrections are:
+
+-  Offset correction
+-  Common mode correction
+-  Split pattern classification
+
+### pnCCD references: 
+
+- [pnCCD Manual](https://rtd.xfel.eu/docs/pnccd-analysis-manual/en/latest/dark.html)
+
+---------------------------------------------------------------------------------------
+
+## REMI
+
+### [Transformation parameters](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/REMI/REMI_Digitize_and_Transform.ipynb)
+
+??? warning "No description"
+
+      TODO: Add description for this notebook
+
+---------------------------------------------------------------------------------------
+
+## EPIX10K
+
+??? warning "Detector notebooks are outdated."
+
+   EPIX10K notebooks are outdated as the detector hasn't been used for years.
+
+### [ePIX10K Data Correction](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/ePix10K/Correction_ePix10K_NBC.ipynb)
+
+Offset correction of images acquired with the ePix10K detector.
+
+### [ePix10K Dark Characterization](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/ePix10K/Characterize_Darks_ePix10K_NBC.ipynb)
+
+Dark image analysis of the ePix10K detector.
+
+Dark characterization evaluates offset and noise of the detector and gives information about bad pixels. Resulting maps are saved as HDF5 files for a latter use and injected to the calibration DB.
+
+--------------------------------------------------------------------------------------
+
+## FASTCCD
+
+??? warning "Detector notebooks are outdated."
+
+      FastCCD notebooks are outdated as the detector hasn't been used for years.
+
+### [FastCCD Data Correction](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/FastCCD/CorrectionNotebook_NewDAQ_FastCCD_NBC.ipynb)
+
+The following notebook provides correction of images acquired with the FastCCD.
+
+### [FastCCD Dark Characterization](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/FastCCD/Characterize_Darks_NewDAQ_FastCCD_NBC_New_Common_Mode.ipynb)
+
+
+The following notebook provides dark image analysis of the FastCCD detector.
+
+Dark characterization evaluates offset and noise of the FastCCD
+detector, corrects the noise for Common Mode (CM), and defines bad pixels relative to offset and CM corrected noise. Bad pixels are then excluded and CM corrected noise is recalculated excluding the bad pixels. Resulting offset and CM corrected noise maps, as well as the bad pixel map are sent to the calibration database.
+
+-------------------------------------------------------------------------------------
+
+## GENERIC
+
+### [Constants from DB to HDF5](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/generic/DB_Constants_to_HDF5_NBC.ipynb)
+
+Currently, available instances are LPD1M1 and AGIPD1M1
+
+
+### [Overall modules darks summary](https://git.xfel.eu/calibration/pycalibration/-/blob/master/notebooks/generic/overallmodules_Darks_Summary_NBC.ipynb)
+
+Create a summary chapter for the processed dark calibration constants and a comparison with previous injected constants. Only for AGIPDs, DSSC1M, and LPD1M
+
+----------------------------------------------------------------------------------------
+
+## TUTORIAL
+
+### Tutorial Calculation
+
+
+A small example how to adapt a notebook to run with the offline
+calibration package “pycalibation”.
+
+The first cell contains all parameters that should be exposed to the command line.
+
+To run this notebook with different input parameters in parallel by submitting multiple SLURM jobs, for example for various random seed we can do the following:
+
+xfel-calibrate TUTORIAL TEST –random-seed 1,2,3,4
+
+or
+
+xfel-calibrate TUTORIAL TEST –random-seed 1-5
+
+will produce 4 processing jobs
diff --git a/docs/operation/calibration_configurations.md b/docs/operation/calibration_configurations.md
new file mode 100644
index 0000000000000000000000000000000000000000..0298de7a8a49c3b090a8021d5c9657c04f6374a5
--- /dev/null
+++ b/docs/operation/calibration_configurations.md
@@ -0,0 +1,289 @@
+# Calibration Configurations
+
+[Calibration configurations](https://git.xfel.eu/detectors/calibration_configurations) is a separate project that is used by the offline calibration webservice to input the needed arguments for the triggered calibrations (e.g. correct or dark) per proposal.
+
+These configurations are collected in YAML files. Each proposal can has it's own configuration, otherwise a default YAML file consists of the configurations for all calibrations, instruments, and detectors in case a proposal didn't have a dedicated YAML file.
+
+# Configuration project structure
+
+The default configuration is located in the *default.yaml* file on the top
+hierarchy level.
+
+The proposal specific configurations are optional (if none is found) the
+default is used, and are organized by facility cycles:
+
+```
+   --<CYCLE A>
+       |--<PROPOSAL 1>.yaml
+       |--<PROPOSAL 2>.yaml
+   --<CYCLE B>
+       |--<PROPOSAL 3>.yaml
+       |--<PROPOSAL 4>.yaml
+```
+
+Where cycles and proposals are identified by their numerical number, without
+any prefixes or suffixes.
+
+## Configuration file contents
+
+Each proposal YAML file (and the default) is structured in the following way
+
+``` YAML
+<CALIBRATION>:
+    <INSTRUMENT>:
+        <DETECTOR-IDENTIFIER>:
+            <cal-parameter-name>: <cal-parameter-value>
+            <cal-parameter-name>: <cal-parameter-value>
+        <DETECTOR-IDENTIFIER>:
+            <cal-parameter-name>: <cal-parameter-value>
+            <cal-parameter-name>: <cal-parameter-value>
+<data-mapping>:
+    <DETECTOR-IDENTIFIER>:
+        detector-type: <DET-TYPE>
+        karabo-da:
+            - <Aggregator-1>
+            - <Aggregator-2>
+            <xfel-calibrate-setting F>: XXX
+            <parameter-name>: <parameter-value>
+```
+
+Multiple instruments and detector types per YAML are possible. The `data-mapping` key must have all detectors added in any of the available calibrations (`<CALIBRATION>`). It consists of the parameter names and values that are used to access data and that are expected to be the same for all calibrations.
+
+
+Each calibration (e.g. dark or correct) can have the cal-parameter-names and cal-parameter-values that correlate to those expected in their calibration notebooks, with `_` replaced with `-`.
+
+<!-- The *inset* parameter is special, in that it is used to determine if files
+of that detector are present, by evaluating if the following expression in the
+raw input path returns a non-empty list:
+
+``` bash
+  
+    RAW-*<inset>*.h5
+```
+
+The inset paramter is not passed to xfel-calibrate. -->
+
+Below is an example for the AGIPD detector at SPB:
+
+``` YAML
+correct:
+  SPB:
+    SPB_DET_AGIPD1M-1:
+      adjust-mg-baseline: true
+      force-hg-if-below: true
+      force-mg-if-below: true
+      hg-hard-threshold: 1000
+      low-medium-gap: true
+      mg-hard-threshold: 1000
+      rel-gain: true
+dark:
+    SPB_DET_AGIPD1M-1:
+      thresholds-offset-hard:
+      - 0
+      - 0
+      thresholds-offset-hard-hg:
+      - 3500
+      - 6000
+      thresholds-offset-hard-lg:
+      - 6000
+      - 9000
+      thresholds-offset-hard-mg:
+      - 6000
+      - 9000
+data-mapping:
+  SPB_DET_AGIPD1M-1:
+    ctrl-source-template: '{}/MDL/FPGA_COMP'
+    detector-type: agipd
+    karabo-da:
+    - AGIPD00
+    - AGIPD01
+    - AGIPD02
+    - AGIPD03
+    - AGIPD04
+    - AGIPD05
+    - AGIPD06
+    - AGIPD07
+    - AGIPD08
+    - AGIPD09
+    - AGIPD10
+    - AGIPD11
+    - AGIPD12
+    - AGIPD13
+    - AGIPD14
+    - AGIPD15
+    karabo-id-control: SPB_IRU_AGIPD1M1
+    receiver-template: '{}CH0'
+```
+
+Note how Boolean flags are indicated by *<parameter>: true*.
+
+--------------------------------------------------------------
+
+## Updating configuration through the webservice (update_config)
+
+`update_config.py` is a python script that can be used to update the calibration configurations directly in the production environment without having access to the production node. Through command line interface the user can apply the desired modifications to the proposal YAML files at https://git.xfel.eu/detectors/calibration_configurations
+
+This script is expected to be available in a location which is easily accessed by any user to modify the configurations of specific proposal. Not all detectors or parameters can be modified through the script.
+
+
+### Changing the configuration:
+
+
+- SSH to maxwell node
+- run `module load anaconda3`
+
+At this moment you are ready to start interacting with the `update_config` script at: `/gpfs/exfel/sw/calsoft/update_config.py`
+
+The available detectors and parameters to modify for a proposal can be checked using `--help`. `python /gpfs/exfel/sw/calsoft/update_config.py --help`
+
+<div style="page-break-after: always;"></div>
+
+Below is the expected output. As it can be seen from the karabo-id argument, the only available detectors at the moment are: SPB_DET_AGIPD1M-1, MID_DET_AGIPD1M-, SQS_REMI_DLD6
+
+```bash
+usage: update_config.py [-h]
+                        [--karabo-id {SPB_DET_AGIPD1M-1,MID_DET_AGIPD1M-1,SQS_REMI_DLD6}]
+                        [--proposal PROPOSAL] [--cycle CYCLE]
+                        [--correct | --dark] [--apply]
+                        [--webservice-address WEBSERVICE_ADDRESS]
+                        [--instrument {CALLAB}]
+
+Request update of configuration
+
+optional arguments:
+  -h, --help                                        show this help message and
+                                                    exit
+  --apply                                           Apply and push the
+                                                    requested configuration
+                                                    update to the git.
+  --webservice-address WEBSERVICE_ADDRESS           The port of the webservice
+                                                    to update calibration
+                                                    configurations repository.
+  --instrument {CALLAB}                             This is only used for
+                                                    testing purposes.
+
+required arguments:
+  --karabo-id {SPB_DET_AGIPD1M-1,MID_DET_AGIPD1M-1,SQS_REMI_DLD6}
+  --proposal PROPOSAL                               The proposal number,
+                                                    without leading p, but
+                                                    with leading zeros.
+  --cycle CYCLE                                     The facility cycle.
+  --correct, -c
+  --dark, -d
+```
+
+<div style="page-break-after: always;"></div>
+
+To check the available parameters that can be modified one can run: `python /gpfs/exfel/sw/calsoft/update_config.py --karabo-id SPB_DET_AGIPD1M-1 --help`
+
+Below is a part of the output of the CL. As can be seen under the optional arguments are the exposed parameters by `update_config` for SPB_DET_AGIPD1M-1.
+
+```bash
+optional arguments:
+  -h, --help                                        show this help message and
+                                                    exit
+  --apply                                           Apply and push the
+                                                    requested configuration
+                                                    update to the git.
+  --webservice-address WEBSERVICE_ADDRESS           The port of the webservice
+                                                    to update calibration
+                                                    configurations repository.
+  --instrument {CALLAB}                             This is only used for
+                                                    testing purposes.
+  --force-hg-if-below FORCE_HG_IF_BELOW             TYPE: INT
+  --rel-gain REL_GAIN                               TYPE: BOOL
+  --no-rel-gain NO_REL_GAIN                         TYPE: BOOL
+  --xray-gain XRAY_GAIN                             TYPE: BOOL
+  --no-xray-gain NO_XRAY_GAIN                       TYPE: BOOL
+  --blc-noise BLC_NOISE                             TYPE: BOOL
+  --no-blc-noise NO_BLC_NOISE                       TYPE: BOOL
+  --blc-set-min BLC_SET_MIN                         TYPE: BOOL
+  --no-blc-set-min NO_BLC_SET_MIN                   TYPE: BOOL
+  --dont-zero-nans DONT_ZERO_NANS                   TYPE: BOOL
+  --no-dont-zero-nans NO_DONT_ZERO_NANS             TYPE: BOOL
+  --dont-zero-orange DONT_ZERO_ORANGE               TYPE: BOOL
+  --no-dont-zero-orange NO_DONT_ZERO_ORANGE         TYPE: BOOL
+  --max-pulses MAX_PULSES [MAX_PULSES ...]          Range list of maximum
+                                                    pulse indices (--max-
+                                                    pulses start end step). 3
+                                                    max input elements. TYPE:
+                                                    LIST
+  --use-litframe-finder USE_LITFRAME_FINDER         TYPE: STR
+  --litframe-device-id LITFRAME_DEVICE_ID           TYPE: STR
+  --energy-threshold ENERGY_THRESHOLD               TYPE: INT
+  --karabo-da KARABO-DA [KARABO-DA ...]             Choices: [AGIPD00 ...
+                                                    AGIPD15]. TYPE: LIST
+
+required arguments:
+  --karabo-id {SPB_DET_AGIPD1M-1,MID_DET_AGIPD1M-1,SQS_REMI_DLD6}
+  --proposal PROPOSAL                               The proposal number,
+                                                    without leading p, but
+                                                    with leading zeros.
+  --cycle CYCLE                                     The facility cycle.
+  --correct, -c
+  --dark, -d
+
+```
+
+Every exposed parameter has its type available beside the name.
+Note: The boolean parameters can not be set to false. For example to set `xray-gain` to false, one should set `no-xray-gain` to true.
+
+<div style="page-break-after: always;"></div>
+
+An example running the CL:
+
+`python /gpfs/exfel/sw/calsoft/update_config.py --cycle 202031 --proposal 900146 --karabo-id SPB_DET_AGIPD1M-1 --rel-gain true --no-xray-gain true --max-pulses 1 20 1`
+
+The output can be something like this:
+
+```bash
+--------------------------------------------------------
+THIS IS A DRY RUN ONLY, NO CHANGES ARE MADE
+
+---------------------------------------------------------
+# Sending the following update:
+correct:
+  SPB:
+    SPB_DET_AGIPD1M-1:
+      max-pulses:
+      - '1'
+      - '20'
+      - '1'
+      rel-gain: true
+      xray-gain: false
+
+---------------------------------------------------------
+# Configuration now in place is:
+correct:
+  SPB:
+    SPB_DET_AGIPD1M-1:
+      adjust-mg-baseline: false
+      blc-noise: true
+      blc-set-min: false
+      blc-stripes: false
+      cm-dark-fraction: 0.5
+      cm-dark-range:
+      - -50
+      - 30
+      cm-n-itr: 4
+      common-mode: false
+      force-hg-if-below: true
+      force-mg-if-below: true
+      hg-hard-threshold: 1000
+      low-medium-gap: false
+      max-pulses:
+      - '1'
+      - '20'
+      - '1'
+      mg-hard-threshold: 1000
+      rel-gain: true
+      xray-gain: false
+```
+
+As the output shows, this is a dry run only. That means that the changes are not applied. This is just a display of what the changes would look like.
+
+To run the changes and apply it to the calibration configurations, you should execute the same command with `--apply` argument. e.g.:
+
+`python /gpfs/exfel/sw/calsoft/update_config.py --cycle 202031 --proposal 900146 --karabo-id SPB_DET_AGIPD1M-1 --rel-gain true --no-xray-gain true --max-pulses 1 20 1 --apply`
+
+This should update the production with your changes. To validate the added changes into production, you can simply check the gitlab [calibration_configurations repository](https://git.xfel.eu/detectors/calibration_configurations) and look for the latest commit to master. This should have your applied changes.
diff --git a/docs/operation/calibration_database.md b/docs/operation/calibration_database.md
new file mode 100644
index 0000000000000000000000000000000000000000..1018dff86d67e75b6408d165bfa6f88f8f5ae7a4
--- /dev/null
+++ b/docs/operation/calibration_database.md
@@ -0,0 +1,132 @@
+# Calibration database
+
+This is the main database where all calibration constants are stored.
+The calibration database is based on CALCAT as the main web interface
+and the GPFS file system where all calibration constant files are
+stored.
+
+It is responsible for storing and managing all calibration detector constants. It maintains the history of calibration constants and manage different versions for the calibration database.
+
+The Calibration database is expected to be queried using:
+- Calibration constant name
+- Conditions
+- Detector module name
+## Calibration constant
+
+
+
+## CALCAT
+
+![image](../static/calcat/home_calcat.png)
+
+CALCAT can be accessed through <https://in.xfel.eu/calibration>. It
+consists of multiple definitions and metadata related to the stored
+calibration constants. the definitions for the available detector types
+(AGIPD, JUNGFRAU, ePix100, ...), the available instruments, the
+available detectors in all instrument, the mapping of each detector to
+it's connected physical detector units, and all calibration constants.
+
+All of these content ensure retrieving the correct calibration constant
+any point in time.
+
+Through CALCAT page one can check all stored calibration constants,
+where the files are stored, and their metadata. Additionally, there are
+different ways to edit various parameters like the detector to PDU
+mapping \<TODO: add a definition link\>, adding new calibrations, and
+new parameter conditions.
+
+In order to proceed with the relevant parts of CALCAT, it is critical to
+first establish clear definitions for the terms used in both CALCAT and
+pyCalibration within the context of the Calibration database.
+
+-   Calibrations: These are the types of calibration available that can
+    be applied to RAW data. For example Offset, Noise, and BadPixelsDark
+    are some calibrations available in CALCAT.
+-   Calibration Constants (CC): Calibration Constants are a list of
+    calibration constant versions with the same parameter conditions.
+    For example 3 Offsets injected in with 3 different creation time for
+    AGIPD and the same parameter conditions are in the same CC list.
+
+![image](../static/calcat/home_cc_calcat.png)
+
+-   Calibration Constant Version (CCV): CCVs are injected through time
+    into the database. Each CCV must have a list of parameter
+    conditions, an attached timestamp of when it was created, the
+    physical detector unit, the file path, and the dataset name to
+    access its data.
+
+![image](../static/calcat/home_ccv_calcat.png)
+
+-   Parameters conditions: The CC parameter conditions are decided by
+    detector experts because the CC\'s data would differ based on it.
+    Some examples are memory cells, integration time, and bias voltage.
+
+![image](../static/calcat/home_conditions_calcat.png)
+-   PDU: Physical detector unit is the physical name given by the manufacturer or detector experts to the detector module's hardware. This representation is very important to calibration, as it is only trace of the physical movement for the detector modules.
+
+![image](../static/calcat/home_pdu_calcat.png)
+
+-   Detector: A detector for CALCAT is based on a detector identifier
+    name, which was based on the Karabo ID give for detector karabo
+    devices. A detector can consist of one module like
+    HED_IA1_JF500K1, or multiple modules like MID_DET_AGIPD1M-1,
+    FXE_DET_LPD1M-1, and SPB_IRDA_JF4M.
+
+![image](../static/calcat/home_detectors_calcat.png)
+
+-   Reports: pyCalibration's PDF reports are the main data
+    visualization source for any calibration processing, either
+    correcting raw data or generating calibration constants. For CALCAT
+    the only relevant reports are the reports for generating new
+    calibration constants. The paths for these reports are one injected
+    metadata along with the calibration constant.
+
+![image](../static/calcat/home_reports_calcat.png)
+
+
+## Detector Mapping
+
+Detector mapping is the operation of associating physical detector units
+(modules) with its data sources (raw data, data aggregators and calibration
+constants files)
+
+<figure markdown>
+  ![AGIPD PDUs](../static/detector_mapping/AGIPD_modules_pic.png){ align=left width="500" }
+  <figcaption>AGIPD PDUs [AGIPD Nr. 315 = AGIPD_SIV1_AGIPDV11_M315]</figcaption>
+</figure>
+
+<figure markdown>
+  ![JUNGFRAU PDU](../static/detector_mapping/JUNGFRAU_PDU_pic.png){ align=left width="500" }
+  <figcaption>JUNGFRAU PDU [Jungfrau Nr. 035 = Jungfrau_M035]</figcaption>
+</figure>
+
+
+PDUs can be transferred between detectors and instruments or replaced. To correct raw data, the calibration pipeline produces calibration constants, which are specific to the module they were generated from. As a result, it's crucial to map the hardware to the corresponding software modules.
+
+As the detector is 
+
+
+### Modifying detector mapping
+
+The detector experts are the most up-to date with the PDU changes. They are able to update and track the PDU names to software module using CALCAT.
+
+Updating the mapping immediately after making any hardware modifications is crucial before acquiring RAW data for calibration. This is because during offline calibration, the timestamp of the acquired RAW data serves as a reference point to retrieve the correct mapping from the database.
+
+### History of Detector mapping
+
+![Screenshot from iCalibrationDB](../static/detector_mapping/icalibrationdb_agipd_det_mapping.png){ align=right width=200 height=350}
+
+
+In the beginning, detector mapping was designed to be hard coded in [iCalibrationDB](https://git.xfel.eu/detectors/cal_db_interactive). It is an interface package to [CalibrationDBRemote](https://git.xfel.eu/karaboDevices/calibrationDBRemote) and CALCAT.
+
+This screenshot shows the last updated hard coded physical detector units for AGIPD detector at SPB.
+
+The of course led with error-prone to not be updated in time after there were changes reported when PDUs where replaced or moved.
+
+## Database snapshot
+
+A database snapshot is a point-in-time copy of a database that provides a read-only, consistent view of the data as it existed at the time the snapshot was created. It's a static picture of the database and includes all the data that was in the database at the time of the snapshot's creation. Database snapshots are useful for performing data analysis or creating reports without interfering with ongoing database transactions. They can also be used for backup and recovery purposes or to provide a consistent view of the data for testing and development purposes.
+
+CALCAT snapshot feature is used for obtaining the correct detector mapping. This is done by using the RAW data timestamp (creation_time) as the snapshot timestamp.
+
+This is why it is crucial to update the detector mapping immediately after any hardware changes.
\ No newline at end of file
diff --git a/docs/operation/myMDC.md b/docs/operation/myMDC.md
new file mode 100644
index 0000000000000000000000000000000000000000..2a0470055aed8bc4f8ab95d034cf444b2098a332
--- /dev/null
+++ b/docs/operation/myMDC.md
@@ -0,0 +1,95 @@
+# Metadata Catalouge
+
+
+European XFEL Data Portal is provided by myMdC, allowing users to access the metadata of scientific data taken at the European XFEL facility. Datasets are linked to experiment proposals, annotated by data collection types, samples and are assigned DOIs to be referenced in publications. myMdC helps data management activities and allows users to find open and own proposals data based on the metadata.
+
+myMDC stands for Metadata Catalog. It arranges the facility's data into proposals. Each proposal consists of a number of acquired runs. Offline calibration only works with runs set to Good `Run Quality`, which means it was migrated from the online cluster to `gpfs`.
+
+Through myMDC users can request to correct migrated runs. Additionally, users can trigger dark calibration constants generation detector data.
+
+
+## Proposals
+
+Proposals are created for commissioning or user experiments. There can be a proposal per instrument. Every proposal has a number of team members who have access to interact with the proposal's runs.
+
+proposal's RAW data location can be found at: `/gpfs/exfel/exp/<instrument>/<cycle>/<proposal>/raw`
+
+## Runs
+
+Runs have multiple properties to modify through myMDC.
+
+The most relevant properties are:
+
+- Run Quality: Currently only migrated runs are allowed to be offline calibrated.
+- Run Types: A run type can be relevant in accepting a correction request or not. e.g. Correcting dark runs can be skipped on purpose.
+
+
+
+## Triggering offline correction
+
+![Trigger correction](../static/myMDC/correction.png)
+
+Through the `Runs` page, one can trigger offline correction with the right proposal access. This screenshot shows a sample from the `Runs` page for the test proposal 900203.
+
+The main important columns in the `Runs` page are:
+- Run number: The run number
+- Run type: This is an assigned type for the run.
+- Start date: The data when the run was acquired.
+- Run status: {TODO}
+- Data Assessment: If data was migrated or not.
+- Calibration: A symbol showing the calibration availability.
+
+??? Warning "Dark runs are skipped."
+
+    Dark runs are not calibrated. In case a manual request was done. The calibration status will be in error state. 
+
+
+![!Run correction status](../static/myMDC/run_9037_general_status.png){align=right width=240}  
+
+
+To check more details about a specific run like its ID, size, number of files, first and last train Ids, clicking on the run number will convert you the run page.
+
+This page is very useful in checking the correction status, as both `Calibrated Process data status` and `Calibration Pipeline auto Reply` keys are updated regularly by the calibration service until a correction is finished.
+
+For example if a run correction request failed. `Calibration Pipeline auto Reply` can have very useful information on the issue and ideally how to solve it.  
+
+---------------------------------------------------
+
+## Generating calibration constants
+
+![calibration constant generation](../static/myMDC/calibration_constants.png)
+
+
+Currently, only dark calibration constants generation can be triggered through myMDC. the below screenshot shows the `Calibration Constants` page for proposal 900203. As noted before the current available option is to request dark calibration. To go through:
+
+- Detector: First you need to select the desired detector from the available detectors of the proposal.
+- Detector Units: By default, all the detector's modules are selected. But you can deselect the undesired modules. e.g. if a module is known not to have data for this run.
+- Operation Mode: This can be left with the default value. It is meant to be used if there is a detector that should generate constants in different operation modes. But this is not used at the moment.
+- Run Number(s): At the end you need to include the number of dark runs to create the calibration constants. This can be one or more runs depending on the detector.
+- Description [optional]: You can optionally add a description for this particular dark constant request.
+
+
+### Calibration Constants requests
+
+![dark requests status](../static/myMDC/dark_different_requests.png)
+
+
+!!! Note
+
+    The screenshots are from a special test proposal, therefore there are multiple detectors from different instruments in the same proposal.
+
+As it can be seen in the screenshot, this section has the latest dark requests with their status, last update, PDF report link, CALCAT report link, and two blue buttons to clone the request for another submit and to check the dark request details, as can be seen in the below screenshot.
+
+### Dark runs' request details
+
+This page is very useful to check more details regarding the dark request. For example the report path, the output path, who triggered request and when, and the calibration pipeline feedback.
+
+![Dark request status success](../static/myMDC/dark_request_status_success.png){: style="height:280px"}
+![Dark request status error](../static/myMDC/dark_request_status_error.png){: style="height:280px"}
+
+
+
+The calibration pipeline feedback is crucial in case the dark request is in error state. As it can have helpful message over what was the cause of the failure.
+
+??? Note "Dark runs' request details doesn't auto-refresh."
+    This dark runs' request details page doesn't update automatically. Therefore, you need to close and reopen to see new updates.
\ No newline at end of file
diff --git a/docs/operation/webservice.md b/docs/operation/webservice.md
new file mode 100644
index 0000000000000000000000000000000000000000..be023c5f1142b8157b8a8f0a5e4303a37e5c5bac
--- /dev/null
+++ b/docs/operation/webservice.md
@@ -0,0 +1,32 @@
+# Calibration Webservice
+
+As the heart of the calibration data pipeline. The webservice receives requests from [myMDC](myMDC.md) to correct data or generate dark calibration constants.
+
+The webservice is a calibration service that is deployed on a Maxwell node as a part of pyCalibration's new releases.
+
+This service hanlde requests from myMDC via ZMQ interface to create the needed xfel-calibrate CL for the selected detector (i.e dark request), or for the available detectors in the RAW data (i.e correction request). The CL arguments are given from different configurations in the production environment, e.g. [calibration configuration](calibration_configurations.md)
+
+Beside forming and executing the CL for the corresponding detector and calibration, the webservice monitor the states for the calibration Slurm nodes to report periodically it's state to myMDC and to conclude the last state for the whole calibration request with a response that can help the user to reach the successfully calibration data or to have an indication on why the Slurm job was not completed at the end.
+
+
+## Job database
+
+The webservice uses SQLite database to store and keep track of the requests, executions, and calibration Slurm jobs.
+
+![job database](../static/webservice_job_db.png)
+
+As can be seen, there are three tables. Executions, Slurm jobs, Requests.
+
+## Handling dark request
+
+Users can generate calibration constants using [myMDC](myMDC.md#calibration-constants-requests). At the moment only dark calibration constants can be generated through myMDC and the webservice. Via ZMQ, the webservice start handling a dark request and update the [Job DB](#job-database) with the new request ID. Similar to the correction, the [configurations](calibration_configurations.md) are used for adding the needed configurations for xfel-calibrate CLI. The launch will not go through as long as the dark runs are migrated and it will either wait for the transfer to finish or timeout. The webservice is expected to reply to myMDC with the status for the dark request and send a successful message or an error message with the reason for the error.
+
+## Handling correction request
+
+Users can trigger offline calibration through [myMDC](myMDC.md#triggering-offline-correction). The webservice would handle this remote request via ZMQ and start with assigning this request into the [Job DB](#job-database). Next step would be reading configurations for the correction xfel-calibrate CLI and launch the correction after confirming that the RAW data is migrated, otherwise the correction waits until the transfer is complete. By default the corrections are disabled and skipped for dark run types. The webservice replies to [myMDC](myMDC.md) with a success message that the correction is launched or with an error message if the correction was not launched. 
+
+
+## job monitor
+
+The Job DB is regularly monitored by a dedicated service
+
diff --git a/docs/overview.md b/docs/overview.md
new file mode 100644
index 0000000000000000000000000000000000000000..319fa42962e325768ea7dbdca2a31a1f781876af
--- /dev/null
+++ b/docs/overview.md
@@ -0,0 +1,25 @@
+# Offline calibration overview
+
+TODO: HERE I PLAN TO GIVE DIAGRAMS OVER THE OFFLINE CALIBRATION SERVICES AND PIECES
+
+
+!!! quote
+
+    European XFEL aims to provide facility users with a fully corrected and calibrated dataset as the primary data product. - SRN 27.4, 35 (2014)
+
+![image](./static/xfel_calibrate_diagrams/overview_all_services.png)
+
+Offline calibration consists of multiple algorithms and processes to achieve this role. These steps can differ across detectors. Offline calibration process big amount of data, and it is essential to have the calibration pipeline compatible with RAW data format across time.
+
+pyCalibration is the main pipeline package for offline calibration at European XFEL. It utilizes MAXWELL HPC to run Jupyter notebooks concurrently using SLURM nodes to process `RAW` data. Before correcting detector `RAW` data, and after the detector experts characterize the detector
+
+The pieces we have are: 
+
+- [Calibration Database](operation/calibration_database.md) The calibration database (CALCAT)
+- [Metadata Catalog](operation/myMDC.md) myMDC for requesting run corrects and dark constants' generation.
+- [Calibration Notebooks](operation/available_notebooks.md) All available detector calibration notebooks
+- [xfel-calibrate](development/configuration.md) The machinery for running calibration notebooks using SLURM
+- [Calibration webservice](operation/webservice) The main entry for offline calibration pipeline in production
+
+
+
diff --git a/docs/reference/xfel-calibrate_cli_process_no_caldbremote.png b/docs/reference/xfel-calibrate_cli_process_no_caldbremote.png
new file mode 100644
index 0000000000000000000000000000000000000000..006b028d654dce0fd96ed33459250eb4d4dc94d6
Binary files /dev/null and b/docs/reference/xfel-calibrate_cli_process_no_caldbremote.png differ
diff --git a/docs/references/changelog.md b/docs/references/changelog.md
new file mode 100644
index 0000000000000000000000000000000000000000..e7cece2bdc49fc0083deb1c908b2f6ff43bb6250
--- /dev/null
+++ b/docs/references/changelog.md
@@ -0,0 +1,599 @@
+# Release Notes
+
+## 3.11.5
+- Update CalParrot==0.3 and EXtra-data==1.15.1 dependencies
+- [DSSC][Dark][Correct] No longer restrict memory cells to a multiple of 100s and add lower deviation for memory cells parameter conditions.
+- [Webservice] Catch errors on failure to launch dark processing
+- Add script to update dark run status in myMdC
+- [Epix100][Correct] Calcat error when no gain is retrieved
+- [REMI] Disable trailing trigger by default
+
+## 3.11.4
+- [Jungfrau][Correct] Force fixed gain for JF data in burst mode
+
+- [Jungfrau][Correct] Force replacement for gain value in Jungfrau correction
+- [DSSC] Allow 900 memory cells for DSSC darks to workaround appearance of cell 810
+
+- [Jungfrau][Dark] Reflect WRONG_GAIN_VALUE over a pixel in all gain for badpixels map
+- [AGIPD][Dark] Add timings
+- [Jungfrau][Correct] New A1256 JF Strixel
+
+- [webservice] Add JUNGF and PEP 8 on the line
+
+
+## 3.11.3
+- [AGIPD][LPD][DARK] Show table for bad pixels bitmaps
+- [AGIPD][CORRECT] Process all AGIPD trains if the PPU device is missing or if no trigger
+- [AGIPD][DARK] Sort dark runs
+- [AGIPD][DARK] Improvements for reading conditions by creating a new data class for multiple runs
+- [AGIPD][FF] Fixing FF summary performance plots
+
+- [Jungfrau] [Correct] Add thresholding for ROI projections
+- [Jungfrau][Correct][Dark] Fix manual edit for operating conditions
+- [Jungfrau][DARK] Validate and reorder dark runs before processing
+- [EPIX][FF] ePixFF characterization
+
+- [REMI] Add support for virtual trailing trigger
+
+- Fix manually submitting the confirmation
+
+- move some logs to DEBUG and extend the report sleep
+
+- Expose --blc-stripes to update_config.py and fix old parameter names
+
+## 3.11.2
+- Operational release for SPB to support configurable rounding thresholds.
+
+## 3.11.1
+- [AGIPD][CORRECT] Use calcat_interface and remove precorrection notebook
+- [EPIX100] Feat: Compliance with update to receiver device
+- [REMI] Various fixes and improvements for quad DLDs
+- [REMI] Fix missing re-allocation of trigger array with neither FEL nor PPL
+- [Tests] Fix: Accept uppercase calibration type
+- [Test] Find difference by default
+- Clearer error when xfel-calibrate would run no jobs
+- Detect cycle automatically in update_config script
+- Fix link to CalCat
+
+## 3.11.0
+
+- [AGIPD][Correct] Handle selecting multiple trains per PPU trigger
+- [AGIPD][Dark] Fix: Skip corrupted frame from dark processing
+- [LPD1M] Automatically decide whether to inject & use memory cell order
+- [LPD1M][Dark] Use EXtra-data to create darks from >1 sequence file
+- [LPD1M][Correct] Use parameter names instead of IDs to find constants
+- [LPD1M][Correct] Using CALCAT interface
+- [LPD1M][Correct] Fix: Constant type conversion
+- [LPD1M][Correct] Use the fragment file and remove the precorrection notebook
+- [LPD-Mini] Rework cell order condition to match LPD-1M again
+- [JUNGFRAU][pnCCD][ePix100] Feat: new method to display CCV metadata in reports
+- [JUNGFRAU][CORRECT] Add fragment file and remove precorrection notebook
+- [EPIX][DARK] Mark dead pixels as Bad Pixels
+- [EPIX][CORR] Optimize histograms and plots
+- [GH2][Correct] Move false warning and disable gain correction as printed.
+- [GH2][Correct] Remove the precorrection notebook and add fragment
+- [TIMEPIX] Add select parameters to update_config
+- [TIMEPIX] Fix types of notebook arguments
+- [xfel-calibrate] Fix: Break the line properly into latex when the next line starts with `_`
+- [Webservice] Don't mark jobs as finished just because they disappear from `squeue` output
+- [Webservice] Use status AW in myMdC if correction failed for some detectors in a run
+- Add a pytest to run a dict of CALLAB test runs before releases
+- Look up CCVs using parameter_name in place of parameter_id
+- Replace `max-exfl016` and `max-exfl017` into `max-exfl-cal001` and `max-exfl-cal002`, respectively.
+- Make metadata directory name match report filename
+- Add reorder_axes function
+
+## 3.10.3
+
+- [LPD][Correct] Harden against empty sequencee sets with train-on-demand
+- [JF][correct] Add missing gain mode parameter
+- [Timepix3] Add centroiding notebook
+
+## 3.10.2
+
+- [PNCCD][CORRECT] Fix: Skip error for missing gain
+- [PNCCD][CORRECT] Fix: Hack to wrong ctrl bias voltage values p002857
+
+- [LPD][Correct] Fix axis order for LPD-1M RelativeGain constant
+
+- [LPDMini][Dark] Add only number of available data trains into data_samples
+- [LPDMini][Dark] Fix first notebook cell to execute CL through the webservice
+- [LPDMini] Feat: Inject gain constants notebook
+
+- [Jungfrau] Workaround for `SPB_CFEL_JF1M` as the modules start with `09` not `01`
+
+- Fix update_config to work with non-AGIPD and add REMI
+
+## 3.10.1
+
+- [JUNGFRAU][CORRECT] Using calcat interface
+- [JUNGFRAU][CORRECT][DARK] Extend accepted detectors based on substrings of karabo_id
+
+- [LPD Mini][CORRECT][DARK] Initial work on LPD Mini notebooks
+- [PNCCD][CORRECT] Avoid raising a CalCat error while retrieving metadata for missing gain constant from DB
+
+## 3.10.0
+
+- [ePix100][Correct] Avoid including histogram calculator with empty array
+- [ePix100][Correct] Remove pre notebook
+
+- [pnCCD][Correct] Using calcat interface
+- [pnCCD][Correct] Record fragment file and remove pre correction notebook
+- [ePix100][pnCCD][Correct] Display creation time for retrieved constants
+
+- [AGIPD][Correct] error out only if all sources are empty
+- [AGIPD][Correct] exit notebook if no correction files are found for the selected sequence
+
+- [DSSC][DARK] Group all slow data to the same aggregator
+
+- [JUNGFRAU][Correct] Use DataCollection.from_paths for reading JF CORR files for plots
+- Support for saving metadata fragments & merging into calibration_metadata.yml
+
+- [REMI] Save pulse amplitudes during discrimination
+- [REMI] Make plots robust against no edges or no hits in data
+
+- [Webservice] Add script to check run in webservice DB
+- [Webservice] Fix database lock timeouts
+
+## 3.9.2
+
+- [AGIPD] Adding back overwrite parameter
+- [AGIPD] Another hotfix for experimenting DAQ filtering at SPB
+
+## 3.9.1
+
+- Hotfix version for 3.9.0
+- [AGIPD] LitFrameFinder bug fix for experimenting DAQ filtering at SPB
+
+## 3.9.0
+
+- [Gotthard2][CORRECT]CALCAT interface.
+- [ePix100][CORRECT]CALCAT interface.
+- [pnCCD][CORRECT]Use `DataFile` to store aligned corrected data.
+- [Gotthard2][CORRECT]Use `DataFile` to store aligned corrected data.
+- [ePix100][CORRECT]Use `DataFile` to store aligned corrected data.
+
+
+- [AGIPD][SlopesFF][CORRECT]Add the deviation for all possible memory cells and enable correction using
+these FF constants with more memory cells.
+  - https://git.xfel.eu/calibration/pycalibration/-/merge_requests/806
+  - https://git.xfel.eu/calibration/pycalibration/-/merge_requests/613
+- [AGIPD][CORRECT]Fix checking ccv_variant condition for AGIPD.
+- [DSSC][Dark]Remove unused instrument parameter from DSSC dark notebook
+- Update `nbparameterise` to 0.6.
+- Update `EXtra-redu` to version 0.0.7
+
+## 3.8.1
+
+- Hotfix version for 3.8.0 with
+- update extra_redu version
+
+## 3.8.0
+-----
+
+- [AGIPD][CORRECT] Clean up before AGIPD calcalt_interface changes
+- [AGIPD][FF] Styling modification for both FF notebooks:1st nb cell, and removing unneeded imports
+- [LPD] uses memory cell order as a condition for constants
+- [LPD] [Correct] Don't pass default snapshot_at=None to calibration_client
+- [LPD][JF][DataFile] Add parallel dataset compression
+- [JF] Replace strixel cython code by NumPy implementation
+- [EPIX100][CORRECT] Include gain and charge sharing to corrected data.
+- New CALCAT interface
+- Store CalCat requests/responses for reproducibility
+- Update to calibration_client 11.2.0
+
+## 3.7.6
+
+- [AGIPD][CORRECT] Fix common mode correction: array reshaping and hardcoded 256 trains per file.
+- [AGIPD][LFF] Improve lit frame selection
+- [AGIPD][CORRECT] Fix common mode correction
+  - Array reshaping.
+  - Hardcoded 256 trains per file.
+
+- [AGIPD][LFF] Improve lit frame selection:
+
+  - fix the misalignment of selection by trains.
+  - introduce super pattern selection.
+  - guess missed patterns for patterns that repeat with constant step.
+  - shows patterns that repeat with a constant step as one line in the report.
+
+
+## 3.7.5
+
+16-11-2022
+
+-   `JUNGFRAU` Fix index location for ROI instrument output
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/765>
+
+## 3.7.4
+
+
+15-11-2022
+
+-   `JUNGFRAU` Only emit a warning if all sequences of a job are empty
+-   `JUNGFRAU` Fix storing multiple ROIs for a single module
+-   `JUNGFRAU` Replicate a raw dataset in processed data for legacy analysis code
+
+## 3.7.3
+
+10-11-2022
+
+-   `DataFile` Add support for older INDEX and METADATA versions.
+-   `LPD` Fix histogram plotting if selected cell's data is identical
+    for trains.
+-   `JUNGFRAU` Avoid unclear error messages when the run has no
+    trains.
+-   `AGIPD` Change notebook-default setting of max-task-per-worker
+    to 1.
+-   `REMI` Allow pulse separation in REMI_DLD reconstruction to ignore FEL pulses.
+-   `webservice` Fix timestamps in the overview page.
+-   `webservice` Check run type more directly in myMdC response.
+
+## 3.7.2
+
+28-10-2022
+
+-   `JUNGFRAU` Add support for strixel sensors
+-   `JUNGFRAU` Shorter summary notebook for darks by default
+-   `JUNGFRAU` Always align corrected data properly
+-   `JUNGFRAU` Harden against 0 adc data in dark characterization
+-   `REMI` Add support for quad nodes and various pulse separation
+    improvements
+-   `AGIPD` Allow manual photon energy input for photonization and add
+    consistency plots
+-   Grant priority partitions for set-up time
+
+## 3.7.1
+
+14-10-2022
+
+-   `EPIX100` Add Common mode corrections to dark characterization
+-   `EPIX100` Use a single value for temperature
+-   `JUNGFRAU` Fix bad pixel masking
+-   `JUNGFRAU` Limit number of plotted trains to 500 during
+    corrections
+-   `AGIPD` Don't fail when there are no trains in sequence file
+-   `REMI` Use DataFile API and support asymmetric pump-probe patterns
+-   Skip corrections for runs which match specific types
+
+## 3.7.0
+
+07-09-2022
+
+-   `JUNGFRAU` Mask double sized pixels
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/689>
+-   `LPD` Storing retrieved calibration constants in
+    calibration_metadata.yml.
+-   Storing the running logs in the report folder path instead of a
+    [temp] folder wherever the processing ran from.
+-   Selecting partitions based on beam time dates.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/725>
+-   Creation time is not read from myMDC anymore.
+
+## 3.6.4
+
+20-08-2022
+
+-   `AGIPD` Significant improvements to AGIPG LitFrameFinder
+    implementation, including offline support.
+-   `AGIPD` Fix misalignment of data and gain/mask when common mode is
+    used with manual pulse slicing.
+
+## 3.6.3
+
+23-08-2022
+
+-   `AGIPD` litframe finder configs in update_config
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/723>
+
+## 3.6.2
+
+15-08-2022
+
+-   `EPIX100` - `JUNGFRAU` - `pnCCD` Retrieve constants precorrection
+    notebooks.
+-   `AGIPD` skip sanitization
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/654>
+-   `AGIPD` New PC notebook
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/604>
+-   `JUNGFRAU` Allow selecting ROIs to save 1D projections
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/699>
+
+## 3.6.1
+
+26-07-2022
+
+-   `GOTTHARD2` Correction and Dark notebooks.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/658>,
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/684>,
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/707>
+-   pin [xarray] to 2022.3.0
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/706>
+
+## 3.6.0
+
+20-07-2022
+
+-   `LPD` - `DARK` Save bad pixel dark data as uint32, not float64.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/698>
+-   `LPD` - `CORRECT` Add option to disable Oauth when using CalCat
+    proxy.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/681>
+-   `AGIPD` - `LPD` - `DSSC` - `DARK` Avoid printing errors for expected
+    missing constant files.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/664>
+-   `TESTS` Refactor and split [AGIPDCtrl] methods (old
+    and new RAW data versions.) and add unit tests
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/651>,
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/646>
+-   `webservice` Monitor SLURM jobs in a separate process.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/668>
+-   `webservice` Restructure the SLURM database to give more
+    meaningful success/failure information.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/683>
+-   `XFEL-CALIBRATE` Recreate environments on demand for
+    xfel-calibrate-repeat.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/660>
+-   Upgrade the Jupyter packages to the latest version.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/697/diffs>
+-   Update Extra-data to 1.12:
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/693>
+    -   [EXtra-data] Disable [_use_voview] to be able to
+        use [.files] or avoid using [.files]
+        <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/682>,
+        <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/688>
+
+## 3.5.5
+
+15-06-2022
+
+-   `AGIPD` - `CORRECT` Expose max tasks per pool worker.
+
+## 3.5.4
+
+13-06-2022
+
+-   `AGIPD` Convert bias_voltage parameter condition to integer in
+    cal_tools.
+-   `LPD` Fix correcting a single pulse.
+-   `LPD` VCXI require 4 modules.
+
+## 3.5.3
+
+19-05-2022
+
+-   `LPD` - `CORRECT` Optionally create virtual CXI files
+-   `LPD` - `CORRECT` Expose max-nodes parameter
+-   `AGIPD` Replace gain_choose_int by fused types
+-   Fix missing install of restful_config.yaml
+-   Fix use of xfel-calibrate --skip-report
+
+## 3.5.2
+
+16.05.2022
+
+-   `LPD` - `CORRECT` New correction notebook for `LPD`
+-   New [files] module to write European XFEL HDF5 corrected
+    data files.
+
+## 3.5.1
+
+05-04-2022
+
+-   Calibration Constant version's new [Variant] file
+    attribute. To indicate method of handling the constant post
+    retrieval.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/619>
+-   `Epix100` dark Badpixels Map.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/637>
+-   `skip-plots` flag to finish correction before plotting.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/635>
+-   First trainId's timestamp as RAW data creation_time, if there is
+    myMDC connection.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/630>
+-   `AGIPD` correction can correct one cellId without plotting errors.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/642>
+-   Fixed mode relative gain constants in `Jungfrau` can be retrieved.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/639>
+-   Only instrument source is selected to check number of trains to dark
+    process.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/636>
+-   `AGIPD` trains for dark processing is selected for each module
+    individually.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/653>
+-   Produce report after trying to correct `AGIPD` run with no images.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/641>
+-   `AGIPD`'s bias voltage for AGIPD1M is read from slow data.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/647>
+-   Removed psutil dependency.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/653>
+-   Update Pasha to 0.1.1
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/638>
+
+## 3.5.0
+
+01-03-2022
+
+-   Updating Correction and dark notebooks for `JUNGFRAU`:
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/518>
+-   Updating Correction and dark notebooks for `AGIPD`:
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/535>
+-   Updating Correction and dark notebooks for `PnCCD`:
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/559>
+-   Updating Correction and dark notebooks for `ePix100`:
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/500>
+    -   `EXtra-data` is integrated to read files in pycalibration for
+        `AGIPD`, `JUNGFRAU`, `ePix100`, and `PnCCD`. Dark and Correction
+        notebooks.
+    -   Pasha is now used for processing data for `JUNGFRAU`, `ePix100` and
+        `PnCCD`.
+    -   pyDetLib correction functions were removed (except for
+        common-mode correction).
+    -   [db-module] is useless now for `JUNGFRAU`, `ePix100`, and
+        `PnCCD`. Some parameters were updated in dark and correction
+        notebooks for the mentioned detectors.
+-   `gain_mode` and burst mode are now available for
+    `JUNGFRAU`.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/591>
+-   `JUNGFRAU` has now a new badpixel value,
+    `WRONG_GAIN_VALUE`.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/591>
+-   Pass through available for testing in-progress ORCA service.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests?scope=all&state=merged&search=orca>
+-   Non-calibrated RAW h5files are no longer copied.
+-   High priority partitions ([upex-high and
+    upex-middle]) are used for runs from ACTIVE and READY
+    proposals, only.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/628>
+-   Supporting to disable LPD Correction through the webservice.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/629>
+-   Compatibility for old DAQ files for REMI is added.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/607>
+-   server-overview refactors.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/593>
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/589>
+-   AGIPD correction notebook support AgipdLitFrameFinder device.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/603>
+-   Parsing code arguments in xfel-calibrate is refactored.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/575>
+-   skip-plots option for AGIPD.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/581>
+-   Native implementation for transposition of constants AGIPD.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/580>
+-   Trains for AGIPD can be selected for correction.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/574>
+-   Skip report flag in xfel-calibrate.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/579>
+-   Fix ReadTheDocs.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/448>
+-   Fix error reporting for re-injecting the same CCV.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/627>
+-   Fix AGIPD for legacy runs without `gain_mode`.
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/617>
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/626>
+-   Pinning markupsafe version 2.0.1
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/631>
+-   Pinning psutil 5.9.0
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/535>
+-   Updating Extra-data to 1.9.1
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/535>
+-   Updating h5py to 3.5.0
+    <https://git.xfel.eu/calibration/pycalibration/-/merge_requests/602>
+
+## 3.4.3
+
+20-10-2021
+
+-   Update pyDetLib tag.
+-   Add explicit dependencies on matplotlib, scipy.
+-   Remove outdated matplotlib rcParams setting.
+-   Update EXtra-geom to 1.6.
+-   Remove cluster_profile parameter from notebooks which don't use
+    it.
+-   Fix checking availability for the concurrency parameter.
+-   Fix launching work directly (not via Slurm).
+-   Fix `sphinx-rep` temp folder recreation, if sphinx-rep
+    already existed.
+-   Fix missing string conversion for slurm-scheduling argument.
+-   Fix title reports for multiple detectors per run folder.
+-   Append to .out files for preemptable finalize job.
+-   `AGIPD` `CORRECT` Reuse previously found constants.
+-   `AGIPD` Fix missing memory cell index in SlopesPC constant
+    sanitization.
+-   `AGIPD` Only use bad pixels from darks in
+    agipdutils.baseline_correct_via_stripes.
+-   `AGIPD` `DARK` Use function to get list of karabo_da from run
+    for making Slurm jobs.
+-   `EPIX100` - `CORRECT` Set absolute_gain to false if relative gain
+    was not retrieved.
+-   `JUNGFRAU` Fix running for multiple modules and flip logic for
+    do_relative_gain.
+-   `JUNGFRAU` Style changes for Dark and Correct notebooks.
+-   `REMI` Add notebook to reconstruct detector hits from raw data.
+-   `webservice` Check run migration status using MyMDC.
+-   Resolve \"Skip ZMQ tests if zmq connection for calibration DB not
+    available\".
+-   Reproducibility, step 1.
+
+## 3.4.2
+
+17-09-2021
+
+-   Remove driver=core from all notebook
+-   `webservice` Make use of Dynaconf for managing secrets.
+-   `webservice` Make use of dedicated slurm partitions.
+-   `webservice` Handle missing migration information (missing
+    user.status fattr).
+-   `webservice` Implement, raise, and catch, migration errors to send
+    mdc messages.
+-   `webservice` Simplify handling of user notebook paths.
+-   `webservice` Update princess to 0.4 (use Unix sockets).
+-   `webservice` Update MyMDC with begin and end times.
+-   `webservice` create output folder before copying slow data.
+-   `AGIPD` `CORRECT` read acq_rate from slow data.
+-   `AGIPD` - `CORRECT` Set default memory cells to 352.
+-   `AGIPD` `CORRECT` Set maximum pulses to correct based on file
+    content.
+-   `AGIPD` - `FF` Correctly label legends in figures.
+-   `AGIPD` - `FF` Add HIBEF AGIPD500K and fix some issue with
+    retrieval of conditions.
+-   `JUNGFRAU` Add Gain setting to Jungfrau notebooks.
+-   `JUNGFRAU` Fix max gain plot in LPD correct notebook
+-   `JUNGFRAU` `DARK` Clearer error message for Jungfrau Dark
+    notebooks no suitable files are found
+-   `LPD` `CORRECT` Fix max gain plot.
+-   `EPIX100` `CORRECT` Solve conflict between gain correction and
+    clustering
+
+## 3.4.1
+
+
+16-07-2021
+
+-   Update h5py to 3.3
+-   Stop execution on notebook errors
+-   `AGIPD` Add integration time as operating condition to all
+    notebooks
+-   `webservice` Add blocklist pattern when copying untouched files in
+    webservice.
+-   `webservice` Expose dark configurations in update_config.py
+-   Fix MetadataClient.get_proposal_runs arguments call.
+-   Fix Use snapshot for injecting constants for old PDU mappings
+-   Fix the old time-summary (creation time for retrieved constants)
+-   Update documentation notes on venv installation
+-   Ignore all .so files in gitignore
+
+## 3.4.0
+
+28-06-2021
+
+-   Update to Python 3.8.
+-   Bump numpy to 1.20.3 and remove fabio.
+-   remove PyQT dependency.
+-   Disable dark requests from serve overview.
+-   Update report upload parameter key.
+-   Override locale to always use UTF-8.
+-   Assorted cleanup of xfel-calibrate.
+-   Fix pre-commit.
+-   Use argparse only if name is main, call main with args dict.
+-   `webservice` Use full hostname for webservice overview.
+-   `webservice` Show clearer messages when running webservice in sim
+    mode.
+-   `webservice` Fix filename lineno and typos in webservice logs.
+-   `webservice` Fix creating an extra run folder in run output
+    folder.
+-   `AGIPD` Parallelize gain/mask compression for writing corrected
+    AGIPD files.
+-   `AGIPD` - `DARK` Fix processing empty sequence files.
+-   `AGIPD` - `PC` - `FF` Update notebooks with new CALCAT mapping.
+-   `AGIPD` - `JUNGFRAU` Use all available sequences for processing
+    darks for AGIPD and Jungfrau.
+-   `AGIPD` - `LPD` - `DSSC` Fix retrieve old constants for comparison
+    for modular detectors.
+-   `LPD` Fix data paths in LPD notebook.
+-   `REMI` Fix user notebook path for REMI correct notebook
+    provisionally.
+-   `EPIX100` - `CORRECT` Add Common mode correction.
+-   Fix plotting-related warnings.
+-   Test update config.
+-   Test get_from_db and send_to_db.
diff --git a/docs/references/faq.md b/docs/references/faq.md
new file mode 100644
index 0000000000000000000000000000000000000000..318b08dc2fed81834a28ff6b6f7934c316d1298c
--- /dev/null
+++ b/docs/references/faq.md
@@ -0,0 +1 @@
+# Frequently Asked Questions
diff --git a/docs/requirements.txt b/docs/requirements.txt
index b3c28f3e8f7a208d68e3583b9fad97982a28037f..249fc185348a246cc832746f1470a660493b5019 100644
--- a/docs/requirements.txt
+++ b/docs/requirements.txt
@@ -1 +1,10 @@
-iCalibrationDB @ git+https://xcalgitlab:${GITHUB_TOKEN}@git.xfel.eu/gitlab/detectors/cal_db_interactive.git@2.2.0
+mkdocs==1.4.2
+mkdocs-material==9.0.15
+mkdocstrings[python]==0.19
+mkdocs-glightbox
+mkdocs-section-index==0.3.5
+mkdocs-literate-nav==0.5.0
+mkdocs-redirects==1.2.0
+mkdocs-gen-files==0.4.0
+griffe==0.27.1
+jupyter
diff --git a/docs/source/_static/css/test_decorators.css b/docs/source/_static/css/test_decorators.css
deleted file mode 100644
index 01a6d7a484d171a57f775b728c685fd6a5ae6d20..0000000000000000000000000000000000000000
--- a/docs/source/_static/css/test_decorators.css
+++ /dev/null
@@ -1,62 +0,0 @@
-.header-passed {
-    display: inline-block;
-    width: 40px;
-    line-height: 40px;
-    border: 1px solid #196038;
-    text-align: center;
-    background-color: #91e0b4;
-    font-size: 200%;
-    font-weight: bold;
-    float: right;
-}
-
-.header-failed {
-    display: inline-block;
-    width: 40px;
-    line-height: 40px;
-    border: 1px solid #871b1b;
-    text-align: center;
-    background-color: #e09191;
-    font-size: 200%;
-    font-weight: bold;
-    float: right;
-}
-
-.header-skipped {
-    display: inline-block;
-    width: 40px;
-    line-height: 40px;
-    border: 1px solid #a59808;
-    text-align: center;
-    background-color: #f7ee8c;
-    font-size: 200%;
-    font-weight: bold;
-    float: right;
-}
-
-.passed {
-    display: inline-block;
-    width: 80px;
-    border: 1px solid #196038;
-    text-align: center;
-    background-color: #91e0b4;
-    font-weight: bold;
-}
-
-.failed {
-    display: inline-block;
-    width: 80px;
-    border: 1px solid #871b1b;
-    text-align: center;
-    background-color: #e09191;
-    font-weight: bold;
-}
-
-.skipped {
-    display: inline-block;
-    width: 80px;
-    border: 1px solid #a59808;
-    text-align: center;
-    background-color: #f7ee8c;
-    font-weight: bold;
-}
diff --git a/docs/source/advanced.rst b/docs/source/advanced.rst
deleted file mode 100644
index 07bfb1f9e846a36ee2271f4528a2b457381a0969..0000000000000000000000000000000000000000
--- a/docs/source/advanced.rst
+++ /dev/null
@@ -1,161 +0,0 @@
-.. _advanced_topics:
-
-Advanced Topics
-===============
-
-The following tasks should only be carried out by trained staff.
-
-Request dark characterization
------------------------------
-
-The script runs dark characterization notebook with default parameters via web service. The data needs to be transferred via the MDC, however, the web service will wait for any transfer to be completed. The detector is chosen automatically with respect to given instrument (`--instrument`). For AGIPD, LPD, Jungfrau runs for the three gain stages need to be given (`--run-high`, `--run-med`, `--run-low`). For FastCCD and ePIX only a single run needs to be given (`--run`).
-
-The complete list of parameters is::
-
-  -h, --help            show this help message and exit
-  --proposal PROPOSAL   The proposal number, without leading p, but with
-                        leading zeros
-  --instrument {SPB,MID,FXE,SCS,SQS,HED}
-                        The instrument
-  --cycle CYCLE         The facility cycle
-  --run-high RUN_HIGH   Run number of high gain data as an integer
-  --run-med RUN_MED     Run number of medium gain data as an integer
-  --run-low RUN_LOW     Run number of low gain data as an integer
-  --run RUN             Run number as an integer
-
-
-The path to data files is defined from script parameters. A typical data path, which can be found in the MDC is::
-
-/gpfs/exfel/exp/MID/201930/p900071/raw
-
-Where `MID` is an instrument name, `201930` is a cycle, `900071` is a proposal number.
-
-
-Extending Correction Notebooks on User Request
-----------------------------------------------
-
-Internally, each automated correction run will trigger `calibrate_nbc.py` to be called
-anew on the respective notebook. This means that any changes to save to this notebook
-will be picked up for subsequent runs.
-
-This can be useful to add user requests while running. For this:
-
-1. create a working copy of the notebook in question, and create a commit of the the
-   production notebook to fall back to in case of problems::
-
-   git add production_notebook_NBC.py
-   git commit -m "Known working version before edits"
-   cp production_notebook_NBC.py production_notebook_TEST.py
-
-2. add any feature there and *thouroughly* test them
-3. when you are happy with the results, copy them over into the production notebook and
-   save.
-
-.. warning::
-
-    Live editing of correction notebooks is fully at your responsiblity. Do not do it
-    if you are not 100% sure you know what you are doing.
-
-4. If it fails, revert back to the original state, ideally via git::
-
-       git checkout HEAD -- production_notebook_NBC.py
-
-5. Any runs which did not correct do to failures of the live edit can then be relaunched
-   manually, assuming the correction notebook allows run and overwrite paramters::
-
-       xfel-calibrate ...... --run XYZ,ZXY-YYS --overwrite
-
-
-Using a Parameter Generator Function
-------------------------------------
-
-By default, the parameters to be exposed to the command line are deduced from the
-first code cell of the notebook, after resolving the notebook itself from the
-detector and characterization type. For some applications it might be beneficial
-to define a context-specific parameter range within the same notebook, based on
-additional user input. This can be done via a parameter generation function which
-is defined in one of the code cell::
-
-    def extend_parms(detector_instance):
-        from iCalibrationDB import Conditions
-        import inspect
-        existing = set()
-        def extract_parms(cls):
-            args, varargs, varkw, defaults = inspect.getargspec(cls.__init__)
-            pList = []
-            for i, arg in enumerate(args[1:][::-1]):
-                if arg in existing:
-                    continue
-
-                existing.add(arg)
-
-                if i < len(defaults):
-                    default = defaults[::-1][i]
-                    if str(default).isdigit():
-                        pList.append("{} = {}".format(arg, default))
-                    elif default is None or default == "None":
-                        pList.append("{} = \"None\"".format(arg))
-                    else:
-                        pList.append("{} = \"{}\"".format(arg, default))
-                else:
-                    pList.append("{} = 0.  # required".format(arg))
-            return set(pList[::-1])  # mandatories first
-        dtype = "LPD" if "LPD" in detector_instance.upper() else "AGIPD"
-        all_conditions = set()
-        for c in dir(Conditions):
-            if c[:2] != "__":
-                condition = getattr(Conditions, c)
-                parms = extract_parms(getattr(condition, dtype))
-                [all_conditions.add(p) for p in parms]
-        return "\n".join(all_conditions)
-
-
-.. note::
-
-   Note how all imports are inlined, as the function is executed outside the
-   notebook context.
-
-In the example, the function generates a list of additional parameters depending
-on the `detector_instance` given. Here, `detector_instance` is defined in the first
-code cell the usual way. Any other parameters defined such, that have names matching
-those of the generator function signature are passed to this function. The function
-should then return a string containing additional code to be appended to the first
-code cell.
-
-To make use of this functionality, the parameter generator function needs to be
-configured in `notebooks.py`, e.g. ::
-
-    ...
-    "GENERIC": {
-        "DBTOH5": {
-            "notebook": "notebooks/generic/DB_Constants_to_HDF5_NBC.ipynb",
-            "concurrency": {"parameter": None,
-                            "default concurrency": None,
-                            "cluster cores": 32},
-            "extend parms": "extend_parms",
-        },
-    }
-    ...
-
-To generically query which parameters are defined in the first code cell, the
-code execution history feature of iPython can be used::
-
-    ip = get_ipython()
-    session = ip.history_manager.get_last_session_id()
-    first_cell = next(ip.history_manager.get_range(session, 1, 2, raw=True))
-    _, _, code = first_cell
-    code = code.split("\n")
-    parms = {}
-    for c in code:
-        n, v = c.split("=")
-        n = n.strip()
-        v = v.strip()
-        try:
-            parms[n] = float(v)
-        except:
-            parms[n] = str(v) if not isinstance(v, str) else v
-        if parms[n] == "None" or parms[n] == "'None'":
-            parms[n] = None
-
-This will create a dictionary `parms` which contains all parameters either
-as `float` or `str` values.
diff --git a/docs/source/cal_tools_algorithms.rst b/docs/source/cal_tools_algorithms.rst
deleted file mode 100644
index 3698e0ede66a9776d39f2498f1281df3781501ee..0000000000000000000000000000000000000000
--- a/docs/source/cal_tools_algorithms.rst
+++ /dev/null
@@ -1,22 +0,0 @@
-cal_tools
-=========
-
-.. module:: cal_tools.agipdlib
-
-.. class:: AgipdCorrections
-
-    .. attribute:: read_file
-
-    .. attribute:: write_file
-
-    .. attribute:: cm_correction
-
-    .. attribute:: mask_zero_std
-
-    .. attribute:: offset_correction
-
-    .. attribute:: baseline_correction
-
-    .. attribute:: gain_correction
-
-    .. attribute:: get_valid_image_idx
\ No newline at end of file
diff --git a/docs/source/calcat_interface.rst b/docs/source/calcat_interface.rst
deleted file mode 100644
index 60b9f1429e024d86149e8dd68e01f72f44be7d3f..0000000000000000000000000000000000000000
--- a/docs/source/calcat_interface.rst
+++ /dev/null
@@ -1,29 +0,0 @@
-CALCAT Interface
-================
-
-.. module:: cal_tools.calcat_interface
-
-.. class:: CalCatError
-
-.. class:: CalibrationData
-
-    .. attribute:: metadata
-
-    .. attribute:: ndarray
-
-    .. attribute:: ndarray_map
-
-.. class:: SplitConditionCalibrationData
-
-.. class:: LPD_CalibrationData
-
-.. class:: DSSC_CalibrationData
-
-.. class:: JUNGFRAU_CalibrationData
-
-.. class:: PNCCD_CalibrationData
-
-.. class:: EPIX100_CalibrationData
-
-.. class:: GOTTHARD2_CalibrationData
-
diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst
deleted file mode 100644
index 757d0afbb30b5731282e132ff74df7f69638dd37..0000000000000000000000000000000000000000
--- a/docs/source/changelog.rst
+++ /dev/null
@@ -1,307 +0,0 @@
-Release Notes
-=============
-
-3.7.5
------
-
-16-11-2022
-
-- [JUNGFRAU] Fix index location for ROI instrument output https://git.xfel.eu/detectors/pycalibration/-/merge_requests/765
-
-3.7.4
------
-
-15-11-2022
-
-- [Jungfrau] Only emit a warning if all sequences of a job are empty
-- [Jungfrau] Fix storing multiple ROIs for a single module
-- [Jungfrau] Replicate a raw dataset in processed data for legacy analysis code
-
-3.7.3
------
-
-10-11-2022
-
-- [DataFile] Add support for older INDEX and METADATA versions.
-- [LPD] Fix histogram plotting if selected cell's data is identical for trains.
-- [Jungfrau] Avoid unclear error messages when the run has no trains.
-- [AGIPD] Change notebook-default setting of max-task-per-worker to 1.
-- [REMI] Allow pulse separation in REMI/DLD reconstruction to ignore FEL pulses.
-- [webservice] Fix timestamps in the overview page.
-- [Webservice] Check run type more directly in myMdC response.
-
-3.7.2
------
-
-28-10-2022
-
-- [Jungfrau] Add support for strixel sensors
-- [Jungfrau] Shorter summary notebook for darks by default
-- [Jungfrau] Always align corrected data properly
-- [Jungfrau] Harden against 0 adc data in dark characterization
-- [REMI] Add support for quad nodes and various pulse separation improvements
-- [AGIPD] Allow manual photon energy input for photonization and add consistency plots
-- Grant priority partitions for set-up time
-
-3.7.1
------
-
-14-10-2022
-
-- [EPIX100] Add Common mode corrections to dark characterization
-- [EPIX100] Use a single value for temperature
-- [JUNGFRAU] Fix bad pixel masking
-- [JUNGFRAU] Limit number of plotted trains to 500 during corrections
-- [AGIPD] Don't fail when there are no trains in sequence file
-- [REMI] Use DataFile API and support asymmetric pump-probe patterns
-- Skip corrections for runs which match specific types
-
-3.7.0
------
-
-07-09-2022
-
-- [JUNGFRAU] Mask double sized pixels for Jungfrau https://git.xfel.eu/detectors/pycalibration/-/merge_requests/689
-- [LPD] Storing retrieved calibration constants in calibration_metadata.yml.
-- Storing the running logs in the report folder path instead of a `temp` folder wherever the processing ran from.
-- Selecting partitions based on beamtime dates. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/725
-- Creation time is not read from myMDC anymore.
-
-3.6.4
------
-
-20-08-2022
-
-- [AGIPD] Significant improvements to AGIPG LitFrameFinder implementation, including offline support.
-- [AGIPD] Fix misalignment of data and gain/mask when common mode is used with manual pulse slicing.
-
-3.6.3
------
-
-23-08-2022
-
-- [AGIPD] litframe finder configs in update_config https://git.xfel.eu/detectors/pycalibration/-/merge_requests/723
-
-3.6.2
------
-
-15-08-2022
-
-- [EPIX100][Jungfrau][pnCCD] Retrieve constants precorrection notebooks.
-- [AGIPD] skip sanitization https://git.xfel.eu/detectors/pycalibration/-/merge_requests/654
-- [AGIPD] New PC notebook https://git.xfel.eu/detectors/pycalibration/-/merge_requests/604
-- [JUNGFRAU] Allow selecting ROIs to save 1D projections  https://git.xfel.eu/detectors/pycalibration/-/merge_requests/699
-3.6.1
------
-
-26-07-2022
-
-- [GOTTHARD2] Correction and Dark notebooks. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/658, https://git.xfel.eu/detectors/pycalibration/-/merge_requests/684, https://git.xfel.eu/detectors/pycalibration/-/merge_requests/707
-- pin `xarray` to 2022.3.0 https://git.xfel.eu/detectors/pycalibration/-/merge_requests/706
-3.6.0
------
-
-20-07-2022
-
-- [LPD][Dark] Save LPD bad pixel dark data as uint32, not float64. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/698
-- [LPD][Correct] Add option to disable Oauth when using CalCat proxy. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/681
-- [AGIPD][LPD][DSSC][DARK] Avoid printing errors for expected missing constant files. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/664
-- [TESTs] Refactor and split `AGIPDCtrl` methods (old and new RAW data versions.) and add unit tests https://git.xfel.eu/detectors/pycalibration/-/merge_requests/651, https://git.xfel.eu/detectors/pycalibration/-/merge_requests/646
-- [Webservice] Monitor SLURM jobs in a separate process. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/668
-- [Webservice] Restructure the SLURM database to give more meaningful success/failure information. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/683
-- [XFEL-CALIBRATE] Recreate environments on demand for xfel-calibrate-repeat. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/660
-- Upgrade the Jupyter packages to the latest version. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/697/diffs
-- Update Extra-data to 1.12: https://git.xfel.eu/detectors/pycalibration/-/merge_requests/693
-  - [EXtra-data] Disable `_use_voview` to be able to use `.files` or avoid using `.files` https://git.xfel.eu/detectors/pycalibration/-/merge_requests/682, https://git.xfel.eu/detectors/pycalibration/-/merge_requests/688
-
-
-3.5.5
------
-
-15-06-2022
-
-- [AGIPD][CORRECT] Expose max tasks per pool worker.
-
-3.5.4
------
-
-13-06-2022
-
-- [AGIPD] Convert bias_voltage parameter condition to integer in cal_tools.
-- [LPD] Fix correcting a single pulse.
-- [LPD] VCXI require 4 modules.
-
-3.5.3
------
-
-19-05-2022
-
-- [LPD][CORRECT] Optionally create virtual CXI files
-- [LPD][CORRECT] Expose max-nodes parameter
-- [AGIPD] Replace gain_choose_int by fused types
-- Fix missing install of restful_config.yaml
-- Fix use of xfel-calibrate --skip-report
-
-3.5.2
------
-
-16.05.2022
-
-- [LPD][CORRECT] New correction notebook for LPD
-- New `files` module to write European XFEL HDF5 corrected data files.
-
-3.5.1
------
-
-05-04-2022
-
-- Calibration Constant version's new `Variant` file attribute. To indicate method of handling the constant post retrieval. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/619
-- Epix100 dark Badpixels Map. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/637
-- `skip-plots` flag to finish correction before plotting. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/635
-- First trainId's timestamp as RAW data creation_time, if there is myMDC connection. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/630
-- AGIPD correction can correct one cellId without plotting errors. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/642
-- Fixed mode relative gain constants in Jungfrau can be retrieved. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/639
-- Only instrument source is selected to check number of trains to dark process. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/636
-- AGIPD trains for dark processing is selected for each module individually. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/653
-- Produce report after trying to correct AGIPD run with no images. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/641
-- AGIPD's bias voltage for AGIPD1M is read from slow data. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/647
-- Removed psutil dependency. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/653
-- Update Pasha to 0.1.1 https://git.xfel.eu/detectors/pycalibration/-/merge_requests/638
-
-3.5.0
------
-
-01-03-2022
-
-- Updating Correction and dark notebooks for JUNGFRAU: https://git.xfel.eu/detectors/pycalibration/-/merge_requests/518
-- Updating Correction and dark notebooks for AGIPD: https://git.xfel.eu/detectors/pycalibration/-/merge_requests/535
-- Updating Correction and dark notebooks for PnCCD: https://git.xfel.eu/detectors/pycalibration/-/merge_requests/559
-- Updating Correction and dark notebooks for ePix100: https://git.xfel.eu/detectors/pycalibration/-/merge_requests/500
-
-  * EXtra-data is integrated to read files in pycalibration for AGIPD, JUNGFRAU, ePix100, and PnCCD. Dark and Correction notebooks.
-  * Pasha is now used for processing data for JUNGFRAU, ePix100 and PnCCD.
-  * pyDetLib correction functions were removed (except for common-mode correction).
-  * `db-module` is useless now for JUNGFRAU, ePix100 and PnCCD. Some parameters were updated in dark and correction notebooks for the mentioned detectors.
-
-- `gain_mode` and burst mode are now available for JUNGFRAU. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/591
-- JUNGFRAU has now a new badpixel value, `WRONG_GAIN_VALUE`. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/591
-- Pass through available for testing in-progress ORCA service. https://git.xfel.eu/detectors/pycalibration/-/merge_requests?scope=all&state=merged&search=orca
-- Non-calibrated RAW h5files are no longer copied.
-- High priority partitions (`upex-high`and `upex-middle`) are used for runs from ACTIVE and READY proposals, only. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/628
-- Supporting to disable LPD Correction through the webservice. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/629
-- Compatibility for old DAQ files for REMI is added. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/607
-- server-overview refactors. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/593 https://git.xfel.eu/detectors/pycalibration/-/merge_requests/589
-- AGIPD correction notebook support AgipdLitFrameFinder device. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/603
-- Parsing code arguments in xfel-calibrate is refactored. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/575
-- skip-plots option for AGIPD. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/581
-- Native implementation for transposition of constants AGIPD. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/580
-- Trains for AGIPD can be selected for correction. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/574
-- Skip report flag in xfel-calibrate. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/579
-- Fix ReadTheDocs. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/448
-- Fix error reporting for re-injecting the same CCV. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/627
-- Fix AGIPD for legacy runs without `gain_mode`. https://git.xfel.eu/detectors/pycalibration/-/merge_requests/617 https://git.xfel.eu/detectors/pycalibration/-/merge_requests/626
-- Pinning markupsafe version 2.0.1 https://git.xfel.eu/detectors/pycalibration/-/merge_requests/631
-- Pinning psutil 5.9.0 https://git.xfel.eu/detectors/pycalibration/-/merge_requests/535
-- Updating Extra-data to 1.9.1 https://git.xfel.eu/detectors/pycalibration/-/merge_requests/535
-- Updating h5py to 3.5.0 https://git.xfel.eu/detectors/pycalibration/-/merge_requests/602
-
-3.4.3
------
-
-20-10-2021
-
-- Update pyDetLib tag.
-- Add explicit dependencies on matplotlib, scipy.
-- Remove outdated matplotlib rcParams setting.
-- Update EXtra-geom to 1.6.
-- Remove cluster_profile parameter from notebooks which don't use it.
-- Fix checking availability for the concurrency parameter.
-- Fix launching work directly (not via Slurm).
-- Fix `sphinx-rep` temp folder recreation, if sphinx-rep already existed.
-- Fix missing string conversion for slurm-scheduling argument.
-- Fix title reports for multiple detectors per run folder.
-- Append to .out files for preemptable finalize job.
-- [AGIPD] [Correct] Reuse previously found constants.
-- [AGIPD] Fix missing memory cell index in SlopesPC constant sanitization.
-- [AGIPD] Only use bad pixels from darks in agipdutils.baseline_correct_via_stripes.
-- [AGIPD] [Dark] Use function to get list of karabo_da from run for making Slurm jobs.
-- [EPIX100][CORRECT] Set absolute_gain to false if relative gain was not retrieved.
-- [JUNGFRAU] Fix running for multiple modules and flip logic for do_relative_gain.
-- [JUNGFRAU] Style changes for Dark and Correct notebooks.
-- [REMI] Add notebook to reconstruct detector hits from raw data.
-- [webservice] Check run migration status using MyMDC.
-- Resolve "Skip ZMQ tests if zmq connection for calibration DB not available".
-- Reproducibility, step 1.
-
-3.4.2
------
-
-17-09-2021
-
-- Remove driver=core from all notebook
-- [webservice] Make use of Dynaconf for managing secrets.
-- [webservice] Make use of dedicated slurm partitions.
-- [webservice] Handle missing migration information (missing user.status fattr).
-- [webservice] Implement, raise, and catch, migration errors to send mdc messages.
-- [webservice] Simplify handling of user notebook paths.
-- [webservice] Update princess to 0.4 (use Unix sockets).
-- [webservice] Update MyMDC with begin and end times.
-- [webservice] create output folder before copying slow data.
-- [AGIPD] [CORRECT] read acq_rate from slow data.
-- [AGIPD][CORRECT] Set default memory cells to 352.
-- [AGIPD] [CORRECT] Set maximum pulses to correct based on file content.
-- [AGIPD] [FF] Correctly label legends in figures.
-- [AGIPD] [FF] Add HIBEF AGIPD500K and fix some issue with retrieval of conditions.
-- [Jungfrau] Add Gain setting to Jungfrau notebooks.
-- [Jungfrau] Fix max gain plot in LPD correct notebook
-- [JUNGFRAU] [DARK] Clearer error message for Jungfrau Dark notebooks no suitable files are found
-- [LPD] [CORRECT] Fix max gain plot.
-- [EPIX100] [CORRECT] Solve conflict between gain correction and clustering
-
-
-3.4.1
------
-
-16-07-2021
-
-- Update h5py to 3.3
-- Stop execution on notebook errors
-- [AGIPD] Add integration time as operating condition to all notebooks
-- [webservice] Add blocklist pattern when copying untouched files in webservice.
-- [webservice] Expose dark configurations in update_config.py
-- Fix MetadataClient.get_proposal_runs arguments call.
-- Fix Use snapshot for injecting constants for old PDU mappings
-- Fix the old time-summary (creation time for retrieved constants)
-- Update documentation notes on venv installation
-- Ignore all .so files in gitignore
-
-
-3.4.0
------
-
-28-06-2021
-
-- Update to Python 3.8.
-- Bump numpy to 1.20.3 and remove fabio.
-- remove PyQT dependency.
-- Disable dark requests from serve overview.
-- Update report upload parameter key.
-- Override locale to always use UTF-8.
-- Assorted cleanup of xfel-calibrate.
-- Fix pre-commit.
-- Use argparse only if name is main, call main with args dict.
-- [webservice] Use full hostname for webservice overview.
-- [webservice] Show clearer messages when running webservice in sim mode.
-- [webservice] Fix filename lineno and typos in webservice logs.
-- [webservice] Fix creating an extra run folder in run output folder.
-- [AGIPD] Parallelize gain/mask compression for writing corrected AGIPD files.
-- [AGIPD][DARK] Fix processing empty sequence files.
-- [AGIPD][PC][FF] Update notebooks with new CALCAT mapping.
-- [AGIPD][JUNGFRAU] Use all available sequences for processing darks for AGIPD and Jungfrau.
-- [AGIPD][LPD][DSSC] Fix retrieve old constants for comparison for modular detectors.
-- [LPD] Fix data paths in LPD notebook.
-- [REMI] Fix user notebook path for REMI correct notebook provisionally.
-- [EPIX][CORRECT] Add Common mode correction.
-- Fix plotting-related warnings.
-- Test update config.
-- Test get_from_db and send_to_db.
diff --git a/docs/source/conf.py b/docs/source/conf.py
deleted file mode 100644
index e4827618883ef2cf834e57a209eaf083ceb2b1eb..0000000000000000000000000000000000000000
--- a/docs/source/conf.py
+++ /dev/null
@@ -1,609 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-#
-# European XFEL Offline Calibration documentation build configuration file, created by
-# sphinx-quickstart on Sun Jun 10 17:32:30 2018.
-#
-# This file is execfile()d with the current directory set to its
-# containing dir.
-#
-# Note that not all possible configuration values are present in this
-# autogenerated file.
-#
-# All configuration values have a default; values that are commented out
-# serve to show the default.
-
-import glob
-
-# If extensions (or modules to document with autodoc) are in another directory,
-# add these directories to sys.path here. If the directory is relative to the
-# documentation root, use os.path.abspath to make it absolute, like shown here.
-#
-# import os
-# import sys
-# sys.path.insert(0, os.path.abspath('.'))
-import os
-import shutil
-import sys
-import textwrap
-from datetime import datetime
-from subprocess import Popen, check_output
-from textwrap import dedent, indent
-from uuid import uuid4
-
-import nbformat
-import tabulate
-from dateutil.parser import parse
-from lxml import etree
-from nbconvert import RSTExporter
-
-# generate the list of available notebooks
-from xfel_calibrate import notebooks
-
-# -- General configuration ------------------------------------------------
-
-# If your documentation needs a minimal Sphinx version, state it here.
-#
-# needs_sphinx = '1.0'
-
-# Add any Sphinx extension module names here, as strings. They can be
-# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
-# ones.
-extensions = [
-    'sphinx.ext.autodoc',
-    'sphinx.ext.intersphinx',
-    'sphinx.ext.todo',
-    'sphinx.ext.mathjax',
-    'sphinx.ext.ifconfig',
-    'sphinx.ext.viewcode',
-]
-
-sys.path.append(os.path.abspath("../pycalibration/"))
-p = Popen(["./makeAllDocs.sh"])
-p.communicate()
-
-# Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
-
-# The suffix(es) of source filenames.
-# You can specify multiple suffix as a list of string:
-#
-# source_suffix = ['.rst', '.md']
-source_suffix = '.rst'
-
-# The encoding of source files.
-#
-# source_encoding = 'utf-8-sig'
-
-# The master toctree document.
-master_doc = 'index'
-
-# General information about the project.
-project = 'European XFEL Offline Calibration'
-copyright = '2018, The European XFEL Detector Group'
-author = 'The European XFEL Detector Group'
-
-# The version info for the project you're documenting, acts as replacement for
-# |version| and |release|, also used in various other places throughout the
-# built documents.
-#
-# The short X.Y version.
-version = '1.0'
-# The full version, including alpha/beta/rc tags.
-release = '1.0'
-
-# The language for content autogenerated by Sphinx. Refer to documentation
-# for a list of supported languages.
-#
-# This is also used if you do content translation via gettext catalogs.
-# Usually you set "language" from the command line for these cases.
-language = None
-
-# There are two options for replacing |today|: either, you set today to some
-# non-false value, then it is used:
-#
-# today = ''
-#
-# Else, today_fmt is used as the format for a strftime call.
-#
-# today_fmt = '%B %d, %Y'
-
-# List of patterns, relative to source directory, that match files and
-# directories to ignore when looking for source files.
-# This patterns also effect to html_static_path and html_extra_path
-exclude_patterns = []
-
-# The reST default role (used for this markup: `text`) to use for all
-# documents.
-#
-# default_role = None
-
-# If true, '()' will be appended to :func: etc. cross-reference text.
-#
-# add_function_parentheses = True
-
-# If true, the current module name will be prepended to all description
-# unit titles (such as .. function::).
-#
-# add_module_names = True
-
-# If true, sectionauthor and moduleauthor directives will be shown in the
-# output. They are ignored by default.
-#
-# show_authors = False
-
-# The name of the Pygments (syntax highlighting) style to use.
-pygments_style = 'sphinx'
-
-# A list of ignored prefixes for module index sorting.
-# modindex_common_prefix = []
-
-# If true, keep warnings as "system message" paragraphs in the built documents.
-# keep_warnings = False
-
-# If true, `todo` and `todoList` produce output, else they produce nothing.
-todo_include_todos = True
-
-
-# -- Options for HTML output ----------------------------------------------
-
-# The theme to use for HTML and HTML Help pages.  See the documentation for
-# a list of builtin themes.
-#
-html_theme = 'sphinx_rtd_theme'
-
-# Theme options are theme-specific and customize the look and feel of a theme
-# further.  For a list of options available for each theme, see the
-# documentation.
-#
-# html_theme_options = {}
-
-# Add any paths that contain custom themes here, relative to this directory.
-# html_theme_path = []
-
-# The name for this set of Sphinx documents.
-# "<project> v<release> documentation" by default.
-#
-# html_title = 'European XFEL Offline Calibration v1.0'
-
-# A shorter title for the navigation bar.  Default is the same as html_title.
-#
-# html_short_title = None
-
-# The name of an image file (relative to this directory) to place at the top
-# of the sidebar.
-#
-# html_logo = None
-
-# The name of an image file (relative to this directory) to use as a favicon of
-# the docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
-# pixels large.
-#
-# html_favicon = None
-
-# Add any paths that contain custom static files (such as style sheets) here,
-# relative to this directory. They are copied after the builtin static files,
-# so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['_static']
-
-# Add any extra paths that contain custom files (such as robots.txt or
-# .htaccess) here, relative to this directory. These files are copied
-# directly to the root of the documentation.
-#
-# html_extra_path = []
-
-# If not None, a 'Last updated on:' timestamp is inserted at every page
-# bottom, using the given strftime format.
-# The empty string is equivalent to '%b %d, %Y'.
-#
-# html_last_updated_fmt = None
-
-# If true, SmartyPants will be used to convert quotes and dashes to
-# typographically correct entities.
-#
-# html_use_smartypants = True
-
-# Custom sidebar templates, maps document names to template names.
-#
-# html_sidebars = {}
-
-# Additional templates that should be rendered to pages, maps page names to
-# template names.
-#
-# html_additional_pages = {}
-
-# If false, no module index is generated.
-#
-# html_domain_indices = True
-
-# If false, no index is generated.
-#
-# html_use_index = True
-
-# If true, the index is split into individual pages for each letter.
-#
-# html_split_index = False
-
-# If true, links to the reST sources are added to the pages.
-#
-# html_show_sourcelink = True
-
-# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
-#
-# html_show_sphinx = True
-
-# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
-#
-# html_show_copyright = True
-
-# If true, an OpenSearch description file will be output, and all pages will
-# contain a <link> tag referring to it.  The value of this option must be the
-# base URL from which the finished HTML is served.
-#
-# html_use_opensearch = ''
-
-# This is the file name suffix for HTML files (e.g. ".xhtml").
-# html_file_suffix = None
-
-# Language to be used for generating the HTML full-text search index.
-# Sphinx supports the following languages:
-#   'da', 'de', 'en', 'es', 'fi', 'fr', 'h', 'it', 'ja'
-#   'nl', 'no', 'pt', 'ro', 'r', 'sv', 'tr', 'zh'
-#
-# html_search_language = 'en'
-
-# A dictionary with options for the search language support, empty by default.
-# 'ja' uses this config value.
-# 'zh' user can custom change `jieba` dictionary path.
-#
-# html_search_options = {'type': 'default'}
-
-# The name of a javascript file (relative to the configuration directory) that
-# implements a search results scorer. If empty, the default will be used.
-#
-# html_search_scorer = 'scorer.js'
-
-# Output file base name for HTML help builder.
-htmlhelp_basename = 'EuropeanXFELOfflineCalibrationdoc'
-
-# -- Options for LaTeX output ---------------------------------------------
-
-latex_elements = {
-     # The paper size ('letterpaper' or 'a4paper').
-     #
-     # 'papersize': 'letterpaper',
-
-     # The font size ('10pt', '11pt' or '12pt').
-     #
-     # 'pointsize': '10pt',
-
-     # Additional stuff for the LaTeX preamble.
-     #
-     # 'preamble': '',
-
-     # Latex figure (float) alignment
-     #
-     # 'figure_align': 'htbp',
-    'extraclassoptions': 'openany, oneside',
-}
-
-# Grouping the document tree into LaTeX files. List of tuples
-# (source start file, target name, title,
-#  author, documentclass [howto, manual, or own class]).
-latex_documents = [
-    (master_doc, 'EuropeanXFELOfflineCalibration.tex', 'European XFEL Offline Calibration Documentation',
-     'The European XFEL Detector Group', 'manual', True),
-]
-
-# The name of an image file (relative to this directory) to place at the top of
-# the title page.
-#
-# latex_logo = None
-
-# For "manual" documents, if this is true, then toplevel headings are parts,
-# not chapters.
-#
-# latex_use_parts = False
-
-# If true, show page references after internal links.
-#
-# latex_show_pagerefs = False
-
-# If true, show URL addresses after external links.
-#
-# latex_show_urls = False
-
-# Documents to append as an appendix to all manuals.
-#
-# latex_appendices = []
-
-# It false, will not define \strong, \code, 	itleref, \crossref ... but only
-# \sphinxstrong, ..., \sphinxtitleref, ... To help avoid clash with user added
-# packages.
-#
-# latex_keep_old_macro_names = True
-
-# If false, no module index is generated.
-#
-# latex_domain_indices = True
-
-
-# -- Options for manual page output ---------------------------------------
-
-# One entry per manual page. List of tuples
-# (source start file, name, description, authors, manual section).
-man_pages = [
-    (master_doc, 'europeanxfelofflinecalibration', 'European XFEL Offline Calibration Documentation',
-     [author], 1)
-]
-
-# If true, show URL addresses after external links.
-#
-# man_show_urls = False
-
-
-# -- Options for Texinfo output -------------------------------------------
-
-# Grouping the document tree into Texinfo files. List of tuples
-# (source start file, target name, title, author,
-#  dir menu entry, description, category)
-texinfo_documents = [
-    (master_doc, 'EuropeanXFELOfflineCalibration', 'European XFEL Offline Calibration Documentation',
-     author, 'EuropeanXFELOfflineCalibration', 'One line description of project.',
-     'Miscellaneous'),
-]
-
-# Documents to append as an appendix to all manuals.
-#
-# texinfo_appendices = []
-
-# If false, no module index is generated.
-#
-# texinfo_domain_indices = True
-
-# How to display URL addresses: 'footnote', 'no', or 'inline'.
-#
-# texinfo_show_urls = 'footnote'
-
-# If true, do not generate a @detailmenu in the "Top" node's menu.
-#
-# texinfo_no_detailmenu = False
-
-
-# Example configuration for intersphinx: refer to the Python standard library.
-intersphinx_mapping = {'https://docs.python.org/': None}
-
-
-
-# first install pandoc if necessary, this is mainly meant for the RTD builds
-try:
-    from nbconvert.utils.pandoc import check_pandoc_version
-    check_pandoc_version()
-    print("Pandoc was found!")
-except:
-    print("Installing Pandoc!")
-    from subprocess import check_call
-    pandoc_url = "https://github.com/jgm/pandoc/releases/download/2.2.1/pandoc-2.2.1-1-amd64.deb"
-    pandoc_pack = "pandoc-2.2.1-1-amd64.deb"
-    check_call(["wget", pandoc_url])
-    check_call(["dpkg", "-i", pandoc_pack])
-
-rst_exporter = RSTExporter()
-with open("available_notebooks.rst", "w") as f:
-    f.write(dedent("""
-            .. _available_notebooks:
-
-            Available Notebooks
-            ===================
-
-            The following notebooks are currently integrated into the European XFEL
-            Offline Calibration tool chain.
-
-
-            """))
-
-    for detector in sorted(notebooks.notebooks.keys()):
-        # Avoid having test notebooks in detector notebooks documentations. 
-        if "TEST" in detector.upper():
-            continue
-        values = notebooks.notebooks[detector]
-        f.write("{}\n".format(detector))
-        f.write("{}\n".format("-"*len(detector)))
-        f.write("\n")
-
-        for caltype in sorted(values.keys()):
-            data = values[caltype]
-            nbpath = os.path.abspath("{}/../../../{}".format(__file__, data["notebook"]))
-            with open(nbpath, "r") as nf:
-                nb = nbformat.read(nf, as_version=4)
-                def first_markdown_cell(nb):
-                    for cell in nb.cells:
-                        if cell.cell_type == 'markdown':
-                            return cell
-                mdcell = first_markdown_cell(nb)
-                nb.cells = [mdcell]  # we only want this single cell
-                body, _ = rst_exporter.from_notebook_node(nb)
-                adjusted = []
-                # adjust titles
-                for line in body.split("\n"):
-                    if line.startswith("=="):
-                        line = line.replace("=", "+")
-                    if line.startswith("--"):
-                        line = line.replace("-", "~")
-                    adjusted.append(line)
-                f.write("\n".join(adjusted))
-                f.write("\n")
-
-            f.write("To invoke this notebook and display help use:\n\n")
-            f.write(".. code-block:: bash\n\n")
-            f.write("    xfel-calibrate {} {} --help\n\n".format(detector, caltype))
-            f.write("The full parameter list of this notebook (with defaults is): \n\n")
-            f.write(".. code-block:: bash\n\n")
-            nb_help = ["xfel-calibrate", detector, caltype, "--help"]
-            output = check_output(nb_help).decode('utf8')
-            f.write(indent(output.replace("DETECTOR", detector).replace("TYPE", caltype), " "*4))
-            f.write("\n\n")
-# add test results
-test_artefact_dir = os.path.realpath("../../tests/legacy/artefacts")
-
-
-def xml_to_rst_report(xml, git_tag, reports=[]):
-    e = etree.fromstring(xml.encode())
-    rst = [""]
-    rst += ["Test execution for {test_name} on {ex_date}"]
-    test_name, ex_date = e.get("name").split("-")
-    ex_date = parse(ex_date)
-    rst[-1] = rst[-1].format(test_name=test_name, ex_date=ex_date)
-    rst += ["="*len(rst[-1])]
-    rst += [""]
-
-    num_tests = e.get("tests")
-    num_err = int(e.get("errors"))
-    num_fail = int(e.get("failures"))
-    num_skip = int(e.get("skipped"))
-
-    # create a summary header
-    if num_err + num_fail == 0:
-        rst += [":header-passed:`✓`"]
-    else:
-        rst += [":header-failed:`❌`"]
-
-    if num_skip > 0:
-        rst[-1] += ":header-skipped:`âš `"
-    rst += [""]
-
-    # give a summary
-    rst += [":Git tag: {git_tag}".format(git_tag=git_tag)]
-    rst += [":Tests: {num_tests}".format(num_tests=num_tests)]
-    rst += [":Errors: {num_err}".format(num_err=num_err)]
-    rst += [":Failures: {num_fail}".format(num_fail=num_fail)]
-    rst += [":Skipped: {num_skip}".format(num_skip=num_skip)]
-    rst += [":Duration: {duration}s".format(duration=e.get("time"))]
-    for rname, rpath in reports:
-        rst += [":Report: `{} <{}>`_".format(rname, rpath)]
-    rst += [""]
-
-    # now the details
-    rst += ["Detailed Results"]
-    rst += ["-"*len(rst[-1])]
-    rst += [""]
-
-    detailed_failures = []
-    rows = []
-    for child in e:
-        if child.tag != "testcase":
-            continue
-        name = child.get("name")
-        extime = child.get("time")
-        status = ":passed:`passed`"
-        msg = ""
-        etype = ""
-        if len(child):  # children are pressent so test failed or skipped
-            detail = child[0]
-            etype = detail.get("type")
-            msg = detail.get("message")
-            if etype == "skip":
-                status = ":skipped:`skipped`"
-            else:
-                status= ":failed:`failed`"
-                detailed_failures.append((name, detail.text))
-        msg = "\n".join(textwrap.wrap(msg, 20))
-        row = [status, name, etype, msg, extime ]
-        rows.append(row)
-
-    header = ["Result", "Test", "Error", "Message", "Duration (s)"]
-    tblrst =  tabulate.tabulate(rows, headers=header, tablefmt="rst")
-    rst += tblrst.split("\n")
-    rst += [""]
-
-    for test, report in detailed_failures:
-        rst += ["Failure report for: {}".format(test)]
-        rst += ["~"*len(rst[-1])]
-        rst += [""]
-        rst += [".. code-block:: python"]
-        rst += textwrap.indent(report, " "*4).split("\n")
-        rst += [""]
-
-    do_console = False
-    for child in e:
-        if child.tag == "system-out" and len(child.text.strip()):
-            do_console = True
-            break
-
-    if do_console:
-
-        # console output
-        rst += ["Console Output"]
-        rst += ["-"*len(rst[-1])]
-        rst += [""]
-
-        for child in e:
-            if child.tag != "system-out":
-                continue
-
-            rst += [".. code-block:: console"]
-            rst += textwrap.indent(child.text, " "*4).split("\n")
-
-
-    return "\n".join(rst)
-
-def sorted_dir(folder):
-    def getmtime(name):
-        path = os.path.join(folder, name)
-        return os.path.getmtime(path)
-
-    sort = sorted(os.listdir(folder), key=getmtime, reverse=True)
-    return [(s, datetime.fromtimestamp(getmtime(s))) for s in sort]
-
-header = """
-Test Results
-++++++++++++
-
-Results are organized by git commit, and sorted descending by date.
-
-Contents:
-
-.. toctree::
-   :maxdepth: 2
-
-
-"""
-if not os.path.exists("./test_rsts"):
-    os.makedirs("./test_rsts")
-with open("test_results.rst", "w") as f:
-    f.write(header)
-    for commit, modtime in sorted_dir(test_artefact_dir):
-        with open("./test_rsts/{}.rst".format(commit), "w") as fr:
-            rst = [".. include:: roles.rst"]
-            rst += [""]
-            rst += ["{} - {}".format(commit[:8], modtime)]
-            rst += ["+"*len(rst[-1])]
-            rst += [""]
-            fr.write("\n".join(rst))
-
-            # copy reports
-            pdfs = glob.glob("{}/{}/*/*.pdf".format(test_artefact_dir, commit))
-            if not os.path.exists("./_static/reports/{}".format(commit)):
-                os.makedirs("./_static/reports/{}".format(commit))
-            reports = {}
-            for pdf in pdfs:
-                ppath = "{}/{}.pdf".format(commit, uuid4())
-                shutil.copyfile(pdf, "./_static/reports/{}".format(ppath))
-                rloc = pdf.split("/")[-2]
-                rlist = reports.get(rloc, [])
-                rname = os.path.basename(pdf).split(".")[0]
-                rlist.append((rname, "../_static/reports/{}".format(ppath)))
-                reports[rloc] = rlist
-
-            xmls = glob.glob("{}/{}/*/TEST*.xml".format(test_artefact_dir, commit))
-            for xml in xmls:
-                rloc = xml.split("/")[-2]
-                with open(xml, "r") as xf:
-                    xs = xf.read()
-                    rst = xml_to_rst_report(xs, commit, reports=reports.get(rloc, []))
-                    fr.write(rst)
-            f.write("   test_rsts/{}\n".format(commit))
-
-
-def setup(app):
-    app.add_stylesheet('css/test_decorators.css')
diff --git a/docs/source/configuration.rst b/docs/source/configuration.rst
deleted file mode 100644
index 750cdb5475e0f45247ca863e3efe51abd40ae805..0000000000000000000000000000000000000000
--- a/docs/source/configuration.rst
+++ /dev/null
@@ -1,84 +0,0 @@
-.. _configuration:
-
-Configuration
-=============
-
-The European XFEL Offline Calibration is configured through `settings.py`
-and `notebooks.py` files. Both can be found in `xfel_calibrate` source directory. The `notebook.py` file exposes and configures the
-the notebooks by the `xfel-calibrate` command line interface.
-
-Settings
---------
-
-The `settings.py` is a python configuration file, which configures the tool's environment.::
-
-    # path into which temporary files from each run are placed
-    temp_path = "{}/temp/".format(os.getcwd())
-
-    # Path to use for calling Python. If the environment is correctly set, simply the command
-    python_path = "python"
-
-    # Path to store reports in
-    report_path = "{}/calibration_reports/".format(os.getcwd())
-
-    # Also try to output the report to an out_folder defined by the notebook
-    try_report_to_output = True
-
-    # the command to run this concurrently. It is prepended to the actual call
-    launcher_command = "sbatch -p exfel -t 24:00:00 --mem 500G --mail-type END --requeue --output {temp_path}/slurm-%j.out"
-
-A comment is given for the meaning of each configuration parameter.
-
-
-Notebooks
----------
-
-The `xfel-calibrate` tool exposes configured notebooks to the
-command line by automatically parsing the parameters given in the notebooks first cell.
-The configuration is given in the form of a python dictionary::
-
-    notebooks = {
-        "AGIPD": {
-            "DARK": {
-                "notebook": "AGIPD/Characterize_AGIPD_Gain_Darks_NBC.ipynb",
-                "concurrency": {"parameter": "modules",
-                                "default concurrency": 16,
-                                "cluster cores": 16},
-             },
-             "PC":   {
-                 "notebook": "AGIPD/Chracterize_AGIPD_Gain_PC_NBC.ipynb",
-                 "concurrency": "parameter": "modules",
-                                "default concurrency": 16,
-                                "cluster cores": 16},
-             },
-             "CORRECT":   {
-                 "notebook": "notebooks/AGIPD/AGIPD_Correct_and_Verify.ipynb",
-                 "concurrency": {"parameter": "sequences",
-                 "use function": "balance_sequences",
-                 "default concurrency": [-1],
-                 "cluster cores": 32},
-             ...
-         }
-     }
-
-The first key is the detector, e.g. AGIPD. The second key is the calibration type name, e.g. DARK or PC.
-A dictionary is expected for each calibration type with a notebook path and concurrency configuration.
-For the concurrency three values are expected. Key `parameter` with a value name of type list, which is defined in the first notebook cell.
-The key `default concurrency` to define the range of values for `parameter` in each concurrent notebook, if it is not defined by the user.
-e.g. `"default concurrency": 16` leads to running 16 concurrent jobs, each processing one module with values of [0,1,2,...,15].
-Finally, a hint for the number of `cluster cores` that is used if the notebook is using ipcluster parallelization, only.
-This value should be derived e.g. by profiling memory usage per core, run times, etc.
-
-.. note::
-
-    It is good practice to name command line enabled notebooks with an `_NBC` suffix as shown in
-    the above example.
-
-The AGIPD `CORRECT` notebook (last notebook in the example) makes use of a concurrency generating function
-by setting the `use function` parameter. This function must be defined in the first cell in the notebook
-its given arguments should be named as the first cell notebook parameters. It is expected to return a list of parameters
-to concurrently run notebooks. Above the used function is :func:`xfel_calibrate.calibrate.balance_sequences`.
-
-.. note::
-
-    The function only needs to be defined, but not executed within the notebook context itself.
diff --git a/docs/source/index.rst b/docs/source/index.rst
deleted file mode 100644
index d45ed2e41742d1ce243e635fa53508107edb789e..0000000000000000000000000000000000000000
--- a/docs/source/index.rst
+++ /dev/null
@@ -1,73 +0,0 @@
-.. European XFEL Offline Calibration documentation master file, created by
-   sphinx-quickstart on Sun Jun 10 17:32:30 2018.
-   You can adapt this file completely to your liking, but it should at least
-   contain the root `toctree` directive.
-
-European XFEL Offline Calibration
-=================================
-
-The European XFEL Offline Calibration (pyCalibration) is a python package that consists of
-different services, responsible for applying most of the offline calibration
-and characterization for the detectors.
-
-Running a calibration
----------------------
-
-It utilizes tools such as nbconvert_ and nbparameterise_
-to expose Jupyter_ notebooks to a command line interface.
-In the process reports are generated from these notebooks.
-
-The general interface is::
-
-    % xfel-calibrate DETECTOR TYPE
-
-where `DETECTOR` and `TYPE` specify the task to be performed.
-
-Additionally, it leverages the DESY/XFEL Maxwell cluster to run these jobs in parallel
-via SLURM_.
-
-Here is a list of :ref:`available_notebooks`. See the :ref:`advanced_topics` if you are looking
-for details on how to use as detector group staff.
-
-If you would like to integrate additional notebooks please see the :ref:`development_workflow`.
-
-.. _nbparameterise: https://github.com/takluyver/nbparameterise
-.. _nbconvert: https://github.com/jupyter/nbconvert
-.. _jupyter: http://jupyter.org/
-.. _SLURM: https://slurm.schedmd.com
-
-
-Documentation contents:
-
-.. toctree::
-   :maxdepth: 2
-
-   installation
-   configuration
-   workflow
-   available_notebooks
-   advanced
-   tutorial
-   _notebooks/index
-   testing
-
-.. toctree::
-   :caption: Reference
-   :maxdepth: 2
-
-   xfel_calibrate_conf
-   cal_tools_algorithms
-   calcat_interface
-
-.. toctree::
-   :caption: Development
-   :maxdepth: 2
-
-   changelog
-   architecture
-
-Indices and tables
-==================
-
-* :ref:`genindex`
-* :ref:`search`
\ No newline at end of file
diff --git a/docs/source/installation.rst b/docs/source/installation.rst
deleted file mode 100644
index 97d83ad8c40fa9c4b84a30125a671689173ab6e3..0000000000000000000000000000000000000000
--- a/docs/source/installation.rst
+++ /dev/null
@@ -1,100 +0,0 @@
-.. _installation:
-
-************
-Installation
-************
-
-It's recommended to install the offline calibration (pycalibration) package on
-maxwell, using the anaconda/3 environment.
-
-The following instructions clone from the EuXFEL GitLab instance using SSH
-remote URLs, this assumes that you have set up SSH keys for use with GitLab
-already. If you have not then read the appendix section on `SSH Key Setup for
-GitLab`_ for instructions on how to do this .
-
-
-Installation using python virtual environment - recommended
-===========================================================
-
-`pycalibration` uses the same version of Python as Karabo, which in June 2021
-updated to use Python 3.8. Currently the default python installation on Maxwell
-is still Python 3.6.8, so Python 3.8 needs to be loaded from a different
-location.
-
-One option is to use the Maxwell Spack installation, running `module load
-maxwell` will activate the test Spack instance from DESY, then you can use
-`module load python-3.8.6-gcc-10.2.0-622qtxd` to Python 3.8. Note that this Spack
-instance is currently a trial phase and may not be stable.
-
-Another option is to use `pyenv`, we provide a pyenv installation at
-`/gpfs/exfel/sw/calsoft/.pyenv` which we use to manage different versions of
-python. This can be activated with ``source /gpfs/exfel/sw/calsoft/.pyenv/bin/activate``
-
-A quick setup would be:
-
-1. ``source /gpfs/exfel/sw/calsoft/.pyenv/bin/activate``
-2. ``git clone ssh://git@git.xfel.eu:10022/detectors/pycalibration.git && cd pycalibration`` - clone the offline calibration package from EuXFEL GitLab
-3. ``pyenv shell 3.8.11`` - load required version of python
-4. ``python3 -m venv .venv`` - create the virtual environment
-5. ``source .venv/bin/activate`` - activate the virtual environment
-6. ``python3 -m pip install --upgrade pip`` - upgrade version of pip
-7. ``python3 -m pip install .`` - install the pycalibration package (add ``-e`` flag for editable development installation)
-
-Copy/paste script:
-
-.. code:: bash
-
-  source /gpfs/exfel/sw/calsoft/.pyenv/bin/activate
-  git clone ssh://git@git.xfel.eu:10022/detectors/pycalibration.git
-  cd pycalibration
-  pyenv shell 3.8.11
-  python3 -m venv .venv
-  source .venv/bin/activate
-  python3 -m pip install --upgrade pip
-  python3 -m pip install .  # `-e` flag for editable install, e.g. `pip install -e .`
-
-
-Creating an ipython kernel for virtual environments
-===================================================
-
-To create an ipython kernel with pycalibration available you should (if using a
-venv) activate the virtual environment first, and then run:
-
-.. code:: bash
-
-  python3 -m pip install ipykernel  # If not using a venv add `--user` flag
-  python3 -m ipykernel install --user --name pycalibration --display-name "pycalibration"  # If not using a venv pick different name
-
-This can be useful for Jupyter notebook tools as https://max-jhub.desy.de/hub/login
-
-
-SSH Key Setup for GitLab
-========================
-
-It is highly recommended to set up SSH keys for access to GitLab as this
-simplifies the setup process for all of our internal software present on GitLab.
-
-To set up the keys:
-
-1. Connect to Maxwell
-2. Generate a new keypair with ``ssh-keygen -o -a 100 -t ed25519``, you can
-   either leave this in the default location (``~/.ssh/id_ed25519``) or place it
-   into a separate directory to make management of keys easier if you already
-   have multiple ones. If you are using a password for your keys please check
-   this page to learn how to manage them: https://docs.github.com/en/github/authenticating-to-github/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent#adding-your-ssh-key-to-the-ssh-agent
-3. Add the public key (``id_ed25519.pub``) to your account on GitLab: https://git.xfel.eu/gitlab/profile/keys
-4. Add the following to your ``~/.ssh/config`` file
-
-.. code::
-
-  # Special flags for gitlab over SSH
-  Host git.xfel.eu
-      User git
-      Port 10022
-      ForwardX11 no
-      IdentityFile ~/.ssh/id_ed25519
-
-Once this is done you can clone repositories you have access to from GitLab
-without having to enter your password each time. As ``pycalibration``
-requirements are installed from SSH remote URLs having SSH keys set up is a
-requirement for installing pycalibration.
diff --git a/docs/source/makeAllDocs.sh b/docs/source/makeAllDocs.sh
deleted file mode 100755
index a54263b5de157ad92301f687860a6512486c182f..0000000000000000000000000000000000000000
--- a/docs/source/makeAllDocs.sh
+++ /dev/null
@@ -1,37 +0,0 @@
-#!/bin/bash
-
-# first convert notebooks to rst files
-# the list of notebooks to convert:
-
-notebooks=(calversion)
-
-mkdir _notebooks
-cd _notebooks
-
-echo "Tutorial Example"> index.rst
-echo "================">> index.rst
-echo "" >> index.rst
-echo "Tutorial Notebook:" >> index.rst
-echo "" >> index.rst
-echo ".. toctree::" >> index.rst
-echo "   :maxdepth: 5" >> index.rst
-echo "   :titlesonly:" >> index.rst
-echo "" >> index.rst
-
-for nb in ${notebooks[*]}
-do
-     jupyter nbconvert --to rst ../../../notebooks/Tutorial/${nb}.ipynb --output-dir=./
-     ##fix code blocks
-     sed -i.bak 's/code::/code-block::/g' ${nb}.rst
-     sed -i.bak 's/ipython3/python/g' ${nb}.rst
-     sed -i.bak 's/raw:: latex/math::/g' ${nb}.rst
-     sed -i.bak 's/``/`/g' ${nb}.rst
-     mv ${nb}.rst ${nb}.rst.end
-     echo ".. _${nb}:" > ${nb}.rst
-     cat ${nb}.rst.end >> ${nb}.rst
-     rm ${nb}.rst.end
-     echo "   ${nb}" >> index.rst
-done
-rm *.bak
-
-#cd .. rm api/* sphinx-apidoc -o ./api/ -E ../../iCalibrationDB/
diff --git a/docs/source/test_rsts/roles.rst b/docs/source/test_rsts/roles.rst
deleted file mode 100644
index d153c86059f561e86c47fcdd864a2972373b38f7..0000000000000000000000000000000000000000
--- a/docs/source/test_rsts/roles.rst
+++ /dev/null
@@ -1,6 +0,0 @@
-.. role:: header-passed
-.. role:: header-skipped
-.. role:: header-failed
-.. role:: passed
-.. role:: skipped
-.. role:: failed
diff --git a/docs/source/testing.rst b/docs/source/testing.rst
deleted file mode 100644
index 4f9ad478f3a3ec19e7da29e789bd90059f69ec53..0000000000000000000000000000000000000000
--- a/docs/source/testing.rst
+++ /dev/null
@@ -1,116 +0,0 @@
-Reproducibility
-***************
-
-The `test` directory contains tests which can ensure that updates to
-notebooks and libraries do not result in unintended changes to
-notebook output. This assures consistency of correction results
-for subsequent versions.
-
-.. note::
-
-    Tests can be quite resource intensive, and thus should be run
-    on a dedicated cluster node, allocated using `salloc`.
-
-Running Tests
-+++++++++++++
-
-Before you run tests, commit your changes, so that the test
-run can be assigned to that commit::
-
-    git add ...
-    git commit -m "Added test section to docs"
-
-To run all tests, navigate to the test directory and execute::
-
-    python -m unittest discover
-
-This will usually entail executing a notebook under test via SLURM
-first, then checking its output against the last commited artefacts
-of that test type.
-
-If individual tests are run, e.g. for debugging, additional options
-exist to skip tests, or notebook execution::
-
-   python test_XXX.py --help
-
-where `test_XXX.py` is the test name, will give you a list of options
-available for that test.
-
-If all tests pass, you can commit and push your updates. If you have
-failures, either check your changes, or if changes are intended,
-generate new artefacts.
-
-.. note::
-
-    Running tests will generate entries for test reports in the
-    artefacts directory under the most recent commit.
-    Reviewers should check that such updates are present in the
-    list of changed files.
-
-
-Generating new Artefacts
-++++++++++++++++++++++++
-
-If an update intents to change output, the tests can be used to
-generate new artefacts against which subsequent tests will then run.
-
-First, commit your changes which you want to produce new artefacts
-for::
-
-    git add ...
-    git commit -m "AGIPD corrections handle baseline shift"
-
-Contrary to running tests alone, new artefacts need to be generated
-for each affected test individually::
-
-    python test_XXX.py --generate
-
-replacing `test_XXX.py` with the test you'd like to run. This
-will execute the notebook, create artefact entries in the artefact
-dir, and after that will check for consistency by executing the test against
-these artefacts. This last part is important: the test should not
-fail on its own input. If it does, something is very likely wrong!
-
-After artefacts are created and tests using these have passed,
-commit the new artefacts and create a merge request for your branch::
-
-    git add tests/artefacts/
-    git commit -m "Added new artefacts for changes related to baseline shifts"
-
-Please also add comments in the MR description on why artefacts have
-changed.
-
-.. note::
-
-    Reviewers should always evaluate if the changes in test artefacts are
-    appropriate, intended and acceptable.
-
-Test Reports
-++++++++++++
-
-Test reports are automatically generated when building documentation
-from all xml report files found in sub-directories of the artefact
-directory.
-
-.. note::
-
-    Please make sure not to commit any additional files into the
-    `test_rsts subfolder` of this documentation. Also, do not commit
-    `test_results.rst`. It is autogenerated.
-
-Test Data
-+++++++++
-
-In order to perform described test a detector data as well as calibration constants are required. Detector data for use in testing as well as calibration constants can be found in::
-
-    /gpfs/exfel/exp/XMPL/201750/p700001/raw/
-
-Tests should be configured to output into a common location::
-
-    /gpfs/exfel/exp/XMPL/201750/p700001/scratch/
-
-Repositories of calibration constants used in testing can be found at::
-
-    /gpfs/exfel/exp/XMPL/201750/p700001/usr
-
-.. include:: test_results.rst
diff --git a/docs/source/tutorial.rst b/docs/source/tutorial.rst
deleted file mode 100644
index 450b00464705cdd887f27264bcd3da05a533cadd..0000000000000000000000000000000000000000
--- a/docs/source/tutorial.rst
+++ /dev/null
@@ -1,59 +0,0 @@
-.. _tutorial:
-
-Tutorial
-========
-
-The goal of this tutorial is to demonstrate the functionality of the offline calibration tool-chain. The main functionality offered by this package is the possibility to run a notebook on the shell with input parameters for the configuration. Extending that concept the package also takes care of starting the necessary jobs on the maxwell cluster, which can be more than one if the notebook makes use of ipyparallel. Finally the pycalibration package will generate a report containing all markup and result cells of the notebook.
-
-The Tutorial consist of this documentation and two very simple notebooks:
-
-1. notebooks/Tutorial/startversion.ipynb
-
-   A simple notebook with no knowledge of the requirements of the offline calibration.
-
-2. notebooks/Tutorial/calversion.ipynb
-
-   Outcome of adapting the startversion notebook to be able to be run with the offline
-   calibration tool-chain.
-
-To have a look at those notebooks start from a shell with the karabo environment::
-
-  jupyter-notebook
-
-This will open a jupyter kernel running in your browser where you can then open the notebooks in the folder notebooks/Tutorial. If you in addition also start on another shell the ipcluster as instructed in the calversion.ipynb notebook::
-
-  ipcluster start --n=4 --profile=tutorial
-
-you can step through the cells and run them.
-If you run this notebook using the xfel-calibrate command as explained at the end of this tutorial you do not need to start the cluster yourself, it will be done by the framework.
-
-
-Create your own notebook
-------------------------
-
-1. Create a new notebook or re-arrange an existing following the guidelines of this documentation
-
-2. Register you notebook by adding an entry to xfel_calibrate/notebooks.py following
-   the structure given by the existing notebooks.
-
-   Note: Use all capital letters for DETECTOR and TYPE.
-
-3. Load/register the new notebook by updating the installation::
-
-     pip install -e .
-
-
-Running the notebook
---------------------
-
-1. Make sure output folders you want to use exist
-2. To run your notebook::
-
-     xfel-calibrate Tutorial TEST
-
-   You can see your job in the queue with::
-
-     squeue --me
-
-3. Look at the generated report in the chosen output folder.
-4. More information on the job run on the cluster can be found in the temp folder.
diff --git a/docs/source/workflow.rst b/docs/source/workflow.rst
deleted file mode 100644
index 95ab78463ee362a3bdcba2f0d31067b69e143a48..0000000000000000000000000000000000000000
--- a/docs/source/workflow.rst
+++ /dev/null
@@ -1,284 +0,0 @@
-.. _development_workflow:
-
-Development Workflow
-====================
-
-The following walkthrough will guide you through a possible workflow
-when developing new notebooks for offline calibration.
-
-Fresh Start
------------
-
-If you are starting a blank notebook from scratch you should first
-think about a few preconsiderations:
-
-* Will the notebook perform a headless task, or will it also be
-  an important interface for evaluating the results in form of a
-  report.
-* Do you need to run concurrently? Is concurrency handled internally,
-  e.g. by use of ipcluster, or also on a host level, using cluster
-  computing via slurm.
-
-In case you plan on using the notebook as a report tool, you should make
-sure to provide sufficient guidance and textual details using e.g. markdown
-cells in the notebook. You should also structure it into appropriate
-subsections.
-
-If you plan on running concurrently on the cluster, identify which variable
-should be mapped to concurrent runs. For autofilling it an integer list is
-needed.
-
-Once you've clarified the above points, you should create a new notebook,
-either in an existing detector folder, or if for a yet not integrated
-detector, into a new folder with the detector's name. Give it a suffix
-`_NBC` to denote that it is enabled for the tool chain.
-
-You should then start writing your code following the guidelines
-below.
-
-
-From Existing Notebook
-----------------------
-
-Copy your existing notebook into the appropriate detector directory,
-or create a new one if the detector does not exist yet. Give the copy
-a suffix `_NBC` to denote that it is enabled for the tool chain.
-
-You should then start restructuring your code following the guidelines
-below.
-
-Title and Author Information
-----------------------------
-
-Especially for report generation the notebook should have a proper title
-author and version. These should be given in a leading markdown cell in
-the form::
-
-    # My Fancy Calculation #
-
-    Author: Jane Doe, Version 0.1
-
-    A description of the notebook.
-
-Information in the format will allow automatic parsing of author and version.
-
-
-Exposing Parameters to the Command Line
----------------------------------------
-
-The European XFEL Offline Calibration toolkit automatically deduces
-command line arguments for Jupyter notebooks. It does this with an
-extended version of nbparameterise_, originally written by Thomas
-Kluyver.
-
-Parameter deduction tries to parse all variables defined in the first
-code cell of a notebook. The following variable types are supported:
-
-* numbers: ints and floats
-* Booleans
-* strings
-* lists of any of the above
-
-You should avoid having `import` statements in this cell. Line comments
-can be used to define the help text provided by the command line interface,
-and to signify if lists can be constructed from ranges and if paramters are
-required::
-
-    in_folder = '/gpfs/exfel/exp/SPB/201830/p900019/raw' # path to input data, required
-    modules = [0] # modules to work on, required, range allowed
-    out_folder = "/gpfs/exfel/exp/SPB/201830/p900019/proc/calibration0618/FF" # path to output to, required
-    runs = [820,] # runs to use, required, range allowed
-    sequences = [0,1,2,3,4] # sequences files to use, range allowed
-    cluster_profile = "noDB" # The ipcluster profile to use
-    local_output = False # output constants locally
-
-Here, `in_folder` and `out_folder` are required string values. Values for required parameters have to be given when executing from the command line. This means that any defaults given in the first cell of the code are ignored (they are only used to derive the type of the parameter). `Modules` is a list, which from the command line could also be assigned using a range expression, e.g. `5-10,12,13,18-21`, which would translate to `5,6,7,8,9,12,13,18,19,20`. It is also a required parameter. The parameter `local_output` is a Boolean. The corresponding argument given in the command line will change this parameter from `false` to `True`. There is no way to change this parameter from `True` to `False` from the command line.
-
-The `cluster_profile` parameter is a bit special, in that the tool kit expects exactly this
-name to provide the profile name for an ipcluster_ being run. Hence you use `ipcluster`
-for parallelisation, define your profile name in this variable.
-
-The excerpt above is from a flat field characterization notebook for AGIPD. The code would lead
-to the following parameters being exposed via the command line::
-
-    % xfel-calibrate AGIPD FF --help
-    usage: xfel-calibrate.py [-h] --in-folder str [--modules str [str ...]]
-                            --out-folder str --runs str [str ...]
-                            [--sequences str [str ...]] [--cluster-profile str]
-                            [--local-output] [--db-output] [--bias-voltage int]
-                            [--cal-db-interface str] [--mem-cells int]
-                            [--interlaced] [--fit-hook] [--rawversion int]
-                            [--instrument str] [--photon-energy float]
-                            [--offset-store str] [--high-res-badpix-3d]
-                            [--db-input] [--deviation-threshold float]
-                            DETECTOR TYPE
-
-    Main entry point for offline calibration
-
-    positional arguments:
-      DETECTOR              The detector to calibrate
-      TYPE                  Type of calibration: LPD,AGIPD
-
-    optional arguments:
-      -h, --help            show this help message and exit
-      --no-cluster-job      Do not run as a cluster job
-      --report-to str       Filename (and optionally path) for output report
-      --modules str [str ...]
-                            modules to work on, required, range allowed.
-                            Default: [0]
-      --sequences str [str ...]
-                            sequences files to use, range allowed.
-                            Default: [0, 1, 2, 3, 4]
-      --cluster-profile str
-                            The ipcluster profile to use. Default: noDB2
-
-      --local-output        output constants locally. Default: False
-
-    ...
-
-
-.. note::
-
-    nbparameterise_ can only parse the mentioned subset of variable types. An expression
-    that evaluates to such a type will note be recognized: e.g. `a = list(range(3))` will
-    not work!
-
-The following table contains a list of suggested names for certain parameters, allowing
-to stay consistent amongst all notebooks.
-
-
-================ =============================================================== ==========================
-Parameter name   To be used for                                                  Special purpose
----------------- --------------------------------------------------------------- --------------------------
-in_folder        the input path data resides in, usually without a run number
-out_folder       path to write data out to, usually without a run number         reports can be placed here
-run(s)           which XFEL DAQ runs to use, often ranges are allowed
-modules          refers to the modules of a segmented detector, ranges often ok.
-sequences        sequence files for the XFEL DAQ system, ranges are often ok.
-cluster_profile  name of the cluster profile for ipcluster                       fixed name
-local_input      read calibration constant from file, not database
-local_output     write calibration constant from file, not database
-db_input         read calibration constant from database, not file
-db_output        write calibration constant from database, not file
-cal_db_interface the calibration database host in form of "tcp://host:port"
-================ =============================================================== ==========================
-
-
-Best Coding Practices
----------------------
-
-In principle there a not restrictions other than that parameters that are exposed to the
-command line need to be defined in the first code cell of the notebook.
-
-However, a few guidelines should be observed to make notebook useful for display as
-reports and usage by others.
-
-External Libraries
-~~~~~~~~~~~~~~~~~~
-
-You may use a wide variety of libraries available in Python, but keep in mind that others
-wanting to run the tool will need to install these requirements as well. Thus,
-
-* Do not use a specialized tool if an accepted alternative exists. Plots e.g. should usually
-  be created using matplotlib_ and numerical processing should be done in numpy_.
-
-* Keep runtime and library requirements in mind. A library doing its own parallelism either
-  needs to programmatically be able to set this up, or automatically do so. If you need to
-  start something from the command line first, things might be tricky as you will likely
-  need to run this via `POpen` commands with appropriate environment variable.
-
-* Reading out RAW data should be done using extra_data_. It helps in accessing the HDF5 data
-  structures efficiently. It reduces the complexity of accessing the RAW or CORRECTED datasets,
-  and it provides different methods to select and filter the trains, cells, or pixels of interest.
-
-Writing out data
-~~~~~~~~~~~~~~~~
-
-If your notebook produces output data, consider writing data out as early as possible,
-such that it is available as soon as possible. Detailed plotting and inspection can
-be done later on in the notebook.
-
-Also use HDF5 via h5py_ as your output format. If you correct or calibrate
-input data, which adheres to the XFEL naming convention, you should maintain the convention
-in your output data. You should not touch any data that you do not actively work on and
-should assure that the `INDEX` and identifier entries are synchronized with respect to
-your output data. E.g. if you remove pulses from a train, the `INDEX/.../count` section
-should reflect this.
-
-
-Plotting
-~~~~~~~~
-
-When creating plots, make sure that the plot is either self-explanatory or add markdown
-comments with adequate description. Do not add "free-floating" plots, always put them into
-a context. Make sure to label your axes.
-
-Also make sure the plots are readable on an A4-sized PDF page; this is the format the notebook
-will be rendered to for report outputs. Specifically, this means that figure sizes should not
-exceed approx 15x15 inches.
-
-The report will contain 150 dpi png images of your plots. If you need higher quality output
-of individual plot files you should save these separately, e.g. via `fig.savefig(...)` yourself.
-
-
-Calibration Database Interaction
---------------------------------
-
-Tasks which require calibration constants or produce such should do this by interacting with
-the European XFEL calibration database.
-
-In terms of development workflow it is usually easier to work with file-based I/O first and
-only switch over to the database after the algorithmic part of the notebook has matured.
-Reasons for this include:
-
-* for developing against the database new constants will have to be integrated therein first
-* if the parameters a constant depends on change a lot during early development these
-  updates will always have to be propagated to the database manually
-* database access is limited to the XFEL networks, making offline development more difficult.
-
-Once a stable point is reached, database access can be enabled according to the iCalibrationDB_
-documentation.
-
-
-Testing
--------
-
-The most important test is that your notebook completes flawlessly outside any special
-tool chain feature. After all, the tool chain will only replace parameters, and then
-launch a concurrent job and generate a report out of notebook. If it fails to run in the
-normal Jupyter notebook environment, it will certainly fail in the tool chain environment.
-
-Once you are satisfied with your current state of initial development, you can add it
-to the list of notebooks as mentioned in the :ref:`configuration` section.
-
-Any changes you now make in the notebook will be automatically propagated to the command line.
-Specifically, you should verify that all arguments are parsed correctly, e.g. by calling::
-
-    xfel-calibrate DETECTOR NOTEBOOK_TYPE --help
-
-From then on, check include if parallel slurm jobs are executed correctly and if a report
-is generated at the end.
-
-Finally, you should verify that the report contains the information you'd like to convey and
-is intelligible to people other than you.
-
-.. note::
-
-    You can run the `xfel-calibrate` command without starting a SLURM cluster job, giving
-    you direct access to console output, by adding the `--no-cluster-job` option.
-
-Documenting
------------
-
-Most documentation should be done in the notebook itself. Any notebooks specified in the
-`notebook.py` file will automatically show up in the :ref:`available_notebooks` section of this
-documentation.
-
-
-.. _nbparameterise: https://github.com/takluyver/nbparameterise
-.. _ipcluster: https://ipyparallel.readthedocs.io/en/latest/
-.. _matplotlib: https://matplotlib.org/
-.. _numpy: http://www.numpy.org/
-.. _h5py: https://www.h5py.org/
-.. _iCalibrationDB: https://git.xfel.eu/detectors/cal_db_interactive
-.. _extra_data: https://extra-data.readthedocs.io/en/latest/
\ No newline at end of file
diff --git a/docs/source/xfel_calibrate_conf.rst b/docs/source/xfel_calibrate_conf.rst
deleted file mode 100644
index 4fed8d2650a0ab6a4713ac853392890976d8bc39..0000000000000000000000000000000000000000
--- a/docs/source/xfel_calibrate_conf.rst
+++ /dev/null
@@ -1,6 +0,0 @@
-xfel_calibrate
-==============
-
-.. module:: xfel_calibrate.calibrate
-
-.. autofunction:: balance_sequences
diff --git a/docs/static/calcat/CC_multiple_CCVs_calcat.png b/docs/static/calcat/CC_multiple_CCVs_calcat.png
new file mode 100644
index 0000000000000000000000000000000000000000..03029432378e9d0f3e66dc6ee9e677dbfcd57cde
Binary files /dev/null and b/docs/static/calcat/CC_multiple_CCVs_calcat.png differ
diff --git a/docs/static/calcat/home_calcat.png b/docs/static/calcat/home_calcat.png
new file mode 100644
index 0000000000000000000000000000000000000000..b90501b10a51adeda7809468c33f1f8919292fd3
Binary files /dev/null and b/docs/static/calcat/home_calcat.png differ
diff --git a/docs/static/calcat/home_cc_calcat.png b/docs/static/calcat/home_cc_calcat.png
new file mode 100644
index 0000000000000000000000000000000000000000..da4481822d93a2944ba96db923925319f72f9c45
Binary files /dev/null and b/docs/static/calcat/home_cc_calcat.png differ
diff --git a/docs/static/calcat/home_ccv_calcat.png b/docs/static/calcat/home_ccv_calcat.png
new file mode 100644
index 0000000000000000000000000000000000000000..1d4f28f79d56e69e4b8b86155a158d356d76184b
Binary files /dev/null and b/docs/static/calcat/home_ccv_calcat.png differ
diff --git a/docs/static/calcat/home_conditions_calcat.png b/docs/static/calcat/home_conditions_calcat.png
new file mode 100644
index 0000000000000000000000000000000000000000..fd8486cf3af96b07aa5360e9b50aa2b6177b035e
Binary files /dev/null and b/docs/static/calcat/home_conditions_calcat.png differ
diff --git a/docs/static/calcat/home_detectors_calcat.png b/docs/static/calcat/home_detectors_calcat.png
new file mode 100644
index 0000000000000000000000000000000000000000..a92f792e30a78ee9391ad1b27216fa16e2ea4dc5
Binary files /dev/null and b/docs/static/calcat/home_detectors_calcat.png differ
diff --git a/docs/static/calcat/home_pdu_calcat.png b/docs/static/calcat/home_pdu_calcat.png
new file mode 100644
index 0000000000000000000000000000000000000000..dcd28e589025bdc2f358b1440aabb2760f28e7f9
Binary files /dev/null and b/docs/static/calcat/home_pdu_calcat.png differ
diff --git a/docs/static/calcat/home_reports_calcat.png b/docs/static/calcat/home_reports_calcat.png
new file mode 100644
index 0000000000000000000000000000000000000000..8018001ac81cca5f80627f2f5e5207d085c9fdde
Binary files /dev/null and b/docs/static/calcat/home_reports_calcat.png differ
diff --git a/docs/static/detector_mapping/AGIPD_modules_pic.png b/docs/static/detector_mapping/AGIPD_modules_pic.png
new file mode 100644
index 0000000000000000000000000000000000000000..521d5186cc3d54f199d5ffcfa3995715044b6802
Binary files /dev/null and b/docs/static/detector_mapping/AGIPD_modules_pic.png differ
diff --git a/docs/static/detector_mapping/JUNGFRAU_PDU_pic.png b/docs/static/detector_mapping/JUNGFRAU_PDU_pic.png
new file mode 100644
index 0000000000000000000000000000000000000000..71c3dea6e92d404b54d19f4bc75f67faf0099c8d
Binary files /dev/null and b/docs/static/detector_mapping/JUNGFRAU_PDU_pic.png differ
diff --git a/docs/static/detector_mapping/icalibrationdb_agipd_det_mapping.png b/docs/static/detector_mapping/icalibrationdb_agipd_det_mapping.png
new file mode 100644
index 0000000000000000000000000000000000000000..5d66d89970ea3743e10970529ab66e62b3fdaff9
Binary files /dev/null and b/docs/static/detector_mapping/icalibrationdb_agipd_det_mapping.png differ
diff --git a/docs/static/how_to_write_xfel_calibrate_notebook_NBC_14_0.png b/docs/static/how_to_write_xfel_calibrate_notebook_NBC_14_0.png
new file mode 100644
index 0000000000000000000000000000000000000000..16bc34871e0f06b1eb2f828d7e30c717a49159be
Binary files /dev/null and b/docs/static/how_to_write_xfel_calibrate_notebook_NBC_14_0.png differ
diff --git a/docs/static/myMDC/calibration_constants.png b/docs/static/myMDC/calibration_constants.png
new file mode 100644
index 0000000000000000000000000000000000000000..2fc6af22d56584806546cbb0d2220c7429873a27
Binary files /dev/null and b/docs/static/myMDC/calibration_constants.png differ
diff --git a/docs/static/myMDC/correction.png b/docs/static/myMDC/correction.png
new file mode 100644
index 0000000000000000000000000000000000000000..79f9d218264efca4b3176896138ca5efea532faa
Binary files /dev/null and b/docs/static/myMDC/correction.png differ
diff --git a/docs/static/myMDC/dark_different_requests.png b/docs/static/myMDC/dark_different_requests.png
new file mode 100644
index 0000000000000000000000000000000000000000..d97d6abdb4be3d281facb3f0a0edc2f74e458500
Binary files /dev/null and b/docs/static/myMDC/dark_different_requests.png differ
diff --git a/docs/static/myMDC/dark_request_status_error.png b/docs/static/myMDC/dark_request_status_error.png
new file mode 100644
index 0000000000000000000000000000000000000000..51ae362d3bebaf1b05aadf11aade3bd50c6a5514
Binary files /dev/null and b/docs/static/myMDC/dark_request_status_error.png differ
diff --git a/docs/static/myMDC/dark_request_status_success.png b/docs/static/myMDC/dark_request_status_success.png
new file mode 100644
index 0000000000000000000000000000000000000000..bc5fbf98b448287a2b9ca4c685e4ca6c5c168514
Binary files /dev/null and b/docs/static/myMDC/dark_request_status_success.png differ
diff --git a/docs/static/myMDC/run_9037_general_status.png b/docs/static/myMDC/run_9037_general_status.png
new file mode 100644
index 0000000000000000000000000000000000000000..aed206519097fa782105688b73f570e487c30384
Binary files /dev/null and b/docs/static/myMDC/run_9037_general_status.png differ
diff --git a/docs/static/tests/given_argument_example.png b/docs/static/tests/given_argument_example.png
new file mode 100644
index 0000000000000000000000000000000000000000..cfcf7ea865ac313bfcad27e5ce5610821dd56d1f
Binary files /dev/null and b/docs/static/tests/given_argument_example.png differ
diff --git a/docs/static/tests/manual_action.png b/docs/static/tests/manual_action.png
new file mode 100644
index 0000000000000000000000000000000000000000..7c37a56f012ed5a0f267407fa1657f5605f180e8
Binary files /dev/null and b/docs/static/tests/manual_action.png differ
diff --git a/docs/static/webservice_job_db.png b/docs/static/webservice_job_db.png
new file mode 100644
index 0000000000000000000000000000000000000000..1cfe96cec9bc9d6638eba254bfaee9d7df78e3d4
Binary files /dev/null and b/docs/static/webservice_job_db.png differ
diff --git a/docs/static/xfel_calibrate_diagrams/overview_all_services.png b/docs/static/xfel_calibrate_diagrams/overview_all_services.png
new file mode 100644
index 0000000000000000000000000000000000000000..2edf85cc3ac5fd763de10d437126f3e3af438f4f
Binary files /dev/null and b/docs/static/xfel_calibrate_diagrams/overview_all_services.png differ
diff --git a/docs/static/xfel_calibrate_diagrams/xfel-calibrate_cli_process.png b/docs/static/xfel_calibrate_diagrams/xfel-calibrate_cli_process.png
new file mode 100644
index 0000000000000000000000000000000000000000..5071878aa6e5aac2904f3e89d9d8d41f2b20778d
Binary files /dev/null and b/docs/static/xfel_calibrate_diagrams/xfel-calibrate_cli_process.png differ
diff --git a/mkdocs.yml b/mkdocs.yml
new file mode 100644
index 0000000000000000000000000000000000000000..080b5b97af474025167ca5cd7f6a3fd4bdfa9c98
--- /dev/null
+++ b/mkdocs.yml
@@ -0,0 +1,107 @@
+site_name: EuXFEL Offline calibration
+
+theme:
+  name: "material"
+  features:
+    - navigation.tabs
+    - navigation.tabs.sticky
+    - navigation.sections
+    - navigation.top
+    - navigation.instant
+    - navigation.tracking
+    - search.suggest
+    - search.highlight
+    - content.tabs.link
+    - content.code.annotation
+    - content.code.copy
+    - navigation.indexes
+    - content.tooltips
+    - toc.follow
+  language: en
+  palette:
+    - scheme: light
+      toggle:
+        icon: material/lightbulb
+        name: Switch to dark mode
+    - scheme: slate
+      toggle:
+        icon: material/lightbulb-outline
+        name: Switch to light mode
+
+markdown_extensions:
+  - abbr
+  - pymdownx.highlight:
+      linenums_style: pymdownx-inline
+      anchor_linenums: true
+  - pymdownx.superfences      
+  - pymdownx.inlinehilite
+  - pymdownx.snippets:
+      auto_append:
+        - docs/includes/abbreviations.md
+  - pymdownx.tasklist
+  - pymdownx.arithmatex:
+      generic: true
+  - pymdownx.tabbed:
+      alternate_style: true 
+  - pymdownx.details
+  - pymdownx.mark
+  - pymdownx.emoji:
+  - attr_list
+  - def_list
+  - footnotes
+  - md_in_html
+  - toc:
+      permalink: "%"
+      permalink: True
+  - admonition
+  - tables
+  - codehilite
+
+extra_css:
+  - css/extra.css
+  - css/custom.css
+
+plugins:
+  - glightbox
+  - search
+  - autorefs
+  - gen-files:
+      scripts:
+        - docs/gen_ref_pages.py
+  - literate-nav:
+      nav_file: SUMMARY.md
+  - section-index
+  - mkdocstrings:
+      handlers:
+        python:
+          import:
+          - https://docs.python-requests.org/en/master/objects.inv
+          # paths: [src/cal_tools]
+          docstring_style: "sphinx"
+          docstring_section_style: "list"
+
+repo_url: https://git.xfel.eu/calibration/pycalibration
+
+
+nav:
+    - index.md
+    - Operation:
+      - CALCAT: operation/calibration_database.md
+      - myMDC: operation/myMDC.md
+      - Available Calibration notebooks: operation/available_notebooks.md
+      - Calibration webservice:
+        - The webservice: operation/webservice.md
+        - Calibration Configuration: operation/calibration_configurations.md
+    - Development:
+      - Installation: development/installation.md
+      - Workflow: development/workflow.md
+      - How to write a notebook: development/how_to_write_xfel_calibrate_notebook_NBC.md
+      - Configuration: development/configuration.md
+      - Automated tests: development/testing_pipeline.md
+    - Code Reference: reference/
+    - Reference:
+      - FAQ: references/faq.md
+      - Changelog: references/changelog.md
+
+copyright: |
+  &copy; 2018 <a href="https://www.xfel.eu/"  target="_blank" rel="noopener">European XFEL</a>
\ No newline at end of file
diff --git a/src/__init__.py b/src/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/cal_tools/epix100/epix100lib.py b/src/cal_tools/epix100/epix100lib.py
index d2c71e1b912b5fe5137131f21b4ad38f3298edff..6b5e85c52d55843ea023ac8c055bbe2ea669a6af 100644
--- a/src/cal_tools/epix100/epix100lib.py
+++ b/src/cal_tools/epix100/epix100lib.py
@@ -17,11 +17,16 @@ class epix100Ctrl():
         self.ctrl_src = ctrl_src
         self.instrument_src = instrument_src
 
-    def get_integration_time(self):
+    def get_integration_time(self) -> float:
+        """Get Integration time for ePix100 from /CTRL/
+
+        Returns:
+            Integration time: integration time value.
+        """
         return self.run_dc[
             self.ctrl_src, 'expTime.value'].as_single_value(reduce_by='first')
 
-    def get_temprature(self):
+    def get_temprature(self) -> float:
         """Get temperature value from CONTROL.
         atol is degree variation tolerance.
         """
@@ -43,4 +48,4 @@ class epix100Ctrl():
         else:
             return self.run_dc[
                 self.instrument_src.split(':daqOutput')[0], 'slowdata.backTemp.value'].as_single_value(
-                reduce_by='mean', atol=1)
\ No newline at end of file
+                reduce_by='mean', atol=1)
diff --git a/src/cal_tools/gotthard2/gotthard2lib.py b/src/cal_tools/gotthard2/gotthard2lib.py
index 2d4ae564b2b634bb3728d601a8e4a5a33e45ccb1..2405ddf08a1cd2c9099890009850adca9b5f3381 100644
--- a/src/cal_tools/gotthard2/gotthard2lib.py
+++ b/src/cal_tools/gotthard2/gotthard2lib.py
@@ -15,17 +15,21 @@ class Gotthard2Ctrl():
         self.ctrl_src = ctrl_src
 
     def get_bias_voltage(self):
+        """Get bias voltage for gotthard2."""
         return self.run_dc[self.ctrl_src, "highVoltageMax"].as_single_value()
 
     def get_exposure_time(self):
+        """Get exposure time for gotthard2."""
         return round(
             self.run_dc[self.ctrl_src, "exposureTime"].as_single_value(), 4)
 
     def get_exposure_period(self):
+        """Get exposure period for gotthard2."""
         return round(
             self.run_dc[self.ctrl_src, "exposurePeriod"].as_single_value(), 4)
 
     def get_acquisition_rate(self):
+        """Get acquisition rate for gotthard2."""
         try:
             return float(
                 self.run_dc.get_run_value(self.ctrl_src, "acquisitionRate"))
@@ -33,6 +37,7 @@ class Gotthard2Ctrl():
             pass
 
     def get_single_photon(self):
+        """Get single photon for gotthard2."""
         if "singlePhoton.value" in self.run_dc.keys_for_source(self.ctrl_src):
             return bool(
                 self.run_dc[self.ctrl_src, "singlePhoton"].as_single_value())