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/.gitlab-ci.yml b/.gitlab-ci.yml
index 8d218c5fa97e742f6b317fe7269ec38ab6446c1f..4af4e454c89b175318fe91112ff0cfd5286f974e 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -55,7 +55,6 @@ pytest:
 automated_test:
   variables:
     OUTPUT: $CI_MERGE_REQUEST_SOURCE_BRANCH_NAME
-    REFERENCE: reference_folder
     DETECTORS: all
     CALIBRATION: all
   stage: automated_test
@@ -65,10 +64,10 @@ automated_test:
   <<: *before_script
   script:
     - export LANG=C  # Hopefully detect anything relying on locale
-    - python3 -m pip install ".[automated_test]"
+    - python3 -m pip install ".[test]"
     - echo "Running automated test. This can take sometime to finish depending on the test data."
-    - echo "Given variables are REFERENCE=$REFERENCE, OUTPUT=$OUTPUT, DETECTOR=$DETECTORS, CALIBRATION=$CALIBRATION"
-    - python3 -m pytest ./tests/test_reference_runs --color yes --verbose --release-test --reference-folder /gpfs/exfel/data/scratch/xcaltst/test/$REFERENCE --out-folder /gpfs/exfel/data/scratch/xcaltst/test/$OUTPUT  --detectors $DETECTORS --calibration $CALIBRATION  --find-difference
+    - echo "Given variables are REFERENCE=$REFERENCE, OUTPUT=$OUTPUT, DETECTORS=$DETECTORS, CALIBRATION=$CALIBRATION"
+    - python3 -m pytest ./tests/test_reference_runs --color yes --verbose --release-test --reference-folder /gpfs/exfel/d/cal_tst/reference_folder --out-folder /gpfs/exfel/data/scratch/xcaltst/test/$OUTPUT  --detectors $DETECTORS --calibration $CALIBRATION
   timeout: 24 hours
 
 cython-editable-install-test:
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/notebooks/AGIPD/AGIPD_Correct_and_Verify.ipynb b/notebooks/AGIPD/AGIPD_Correct_and_Verify.ipynb
index 925d9b077ab2dc8309b28ab909089e8ffbbb151f..c4431088e4a5e693f9e89cd3464c8183471240b5 100644
--- a/notebooks/AGIPD/AGIPD_Correct_and_Verify.ipynb
+++ b/notebooks/AGIPD/AGIPD_Correct_and_Verify.ipynb
@@ -62,6 +62,7 @@
     "noisy_adc_threshold = 0.25 # threshold to mask complete adc\n",
     "ff_gain = 7.2 # conversion gain for absolute FlatField constants, while applying xray_gain\n",
     "photon_energy = -1.0 # photon energy in keV, non-positive value for XGM autodetection\n",
+    "rounding_threshold = 0.5 # the fraction to round to down, 0.5 for standard rounding rule\n",
     "\n",
     "# Correction Booleans\n",
     "only_offset = False # Apply only Offset correction. if False, Offset is applied by Default. if True, Offset is only applied.\n",
@@ -88,6 +89,7 @@
     "# Optional auxiliary devices\n",
     "use_ppu_device = ''  # Device ID for a pulse picker device to only process picked trains, empty string to disable\n",
     "ppu_train_offset = 0  # When using the pulse picker, offset between the PPU's sequence start and actually picked train\n",
+    "require_ppu_trigger = False  # Optional protection against running without PPU or without triggering trains.\n",
     "\n",
     "use_litframe_finder = 'off' # Process only illuminated frames: 'off' - disable, 'device' - use online device data, 'offline' - use offline algorithm, 'auto' - choose online/offline source automatically (default)\n",
     "litframe_device_id = '' # Device ID for a lit frame finder device, empty string to auto detection\n",
@@ -303,10 +305,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "if use_ppu_device:\n",
-    "    # Obtain trains to process if using a pulse picker device.\n",
+    "if use_ppu_device and use_ppu_device in dc.control_sources:\n",
+    "    # Obtain trains to process if using a pulse picker device and it's present.\n",
     "\n",
-    "    # Will throw an uncaught exception if the device is wrong.\n",
     "    seq_start = dc[use_ppu_device, 'trainTrigger.sequenceStart.value'].ndarray()\n",
     "\n",
     "    # The trains picked are the unique values of trainTrigger.sequenceStart\n",
@@ -320,18 +321,33 @@
     "        ].select_trains(by_id[[train_id]]).ndarray()[0]\n",
     "        train_ids.extend(list(range(train_id, train_id + n_trains)))\n",
     "\n",
-    "    print(f'PPU device {use_ppu_device} triggered for {len(train_ids)} train(s)')\n",
+    "    if train_ids:\n",
+    "        print(f'PPU device {use_ppu_device} triggered for {len(train_ids)} train(s)')\n",
+    "    elif require_ppu_trigger:\n",
+    "        raise RuntimeError(f'PPU device {use_ppu_device} not triggered but required, aborting!')\n",
+    "    else:\n",
+    "        print(f'PPU device {use_ppu_device} not triggered, processing all valid trains')\n",
+    "        train_ids = None\n",
+    "        \n",
+    "elif use_ppu_device:\n",
+    "    # PPU configured but not present.\n",
+    "    \n",
+    "    if require_ppu_trigger:\n",
+    "        raise RuntimeError(f'PPU device {use_ppu_device} required but not found, aborting!')\n",
+    "    else:\n",
+    "        print(f'PPU device {use_ppu_device} configured but not found, processing all valid trains')\n",
+    "        train_ids = None\n",
     "\n",
     "elif train_ids != [-1]:\n",
     "    # Specific trains passed by parameter, convert to ndarray.\n",
     "    train_ids = np.array(train_ids)\n",
     "    \n",
     "    print(f'Processing up to {len(train_ids)} manually selected train(s)')\n",
+    "\n",
     "else:\n",
-    "    # Process all trains.\n",
-    "    train_ids = None\n",
-    "    \n",
-    "    print(f'Processing all valid trains')"
+    "    # No PPU configured.\n",
+    "    print(f'Processing all valid trains')\n",
+    "    train_ids = None"
    ]
   },
   {
@@ -512,7 +528,11 @@
     "        warning('Neither explicit photon energy nor XGM device configured, photon rounding disabled!')\n",
     "        round_photons = False\n",
     "elif round_photons:\n",
-    "    print(f'Photon energy for rounding: {photon_energy:.3f} keV')"
+    "    print(f'Photon energy for rounding: {photon_energy:.3f} keV')\n",
+    "\n",
+    "if round_photons and (rounding_threshold <= .0 or 1. <= rounding_threshold):\n",
+    "    warning('Round threshould is out of (0, 1) range. Use standard 0.5 value.')\n",
+    "    rounding_threshold = 0.5"
    ]
   },
   {
@@ -543,6 +563,7 @@
     "agipd_corr.noisy_adc_threshold = noisy_adc_threshold\n",
     "agipd_corr.ff_gain = ff_gain\n",
     "agipd_corr.photon_energy = photon_energy\n",
+    "agipd_corr.rounding_threshold = rounding_threshold\n",
     "\n",
     "agipd_corr.compress_fields = compress_fields\n",
     "if recast_image_data:\n",
@@ -550,13 +571,27 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Retrieving constants"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_constants_and_update_metadata(cal_data, main_metadata, constants):\n",
+    "    try:\n",
+    "        metadata = cal_data.metadata(constants)\n",
+    "        for key, value in metadata.items():\n",
+    "            main_metadata.setdefault(key, {}).update(value)\n",
+    "    except CalCatError as e:  # TODO: replace when API errors are improved.\n",
+    "        warning(f\"CalCatError: {e}\")"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -584,24 +619,21 @@
     "dark_constants = [\"Offset\", \"Noise\", \"BadPixelsDark\"]\n",
     "if not gain_mode:  # Adaptive gain\n",
     "    dark_constants.append(\"ThresholdsDark\")\n",
-    "gain_constants = []\n",
+    "\n",
+    "agipd_metadata = agipd_cal.metadata(dark_constants)\n",
+    "\n",
+    "agipd_cal.gain_mode = None  # gain_mode is not used for gain constants\n",
+    "pc_constants, ff_constants = [], []\n",
     "if any(agipd_corr.pc_bools):\n",
-    "    gain_constants += [\"SlopesPC\", \"BadPixelsPC\"]\n",
+    "    pc_constants = [\"SlopesPC\", \"BadPixelsPC\"]\n",
+    "    get_constants_and_update_metadata(\n",
+    "        agipd_cal, agipd_metadata, pc_constants)\n",
+    "\n",
     "if agipd_corr.corr_bools.get('xray_corr'):\n",
-    "    gain_constants += agipd_cal.illuminated_calibrations\n",
+    "    ff_constants = list(agipd_cal.illuminated_calibrations)\n",
+    "    get_constants_and_update_metadata(\n",
+    "        agipd_cal, agipd_metadata, ff_constants)\n",
     "\n",
-    "# First retrieve dark constants\n",
-    "agipd_metadata = agipd_cal.metadata(dark_constants)\n",
-    "if gain_constants:\n",
-    "    # Then retrieve gain constants without\n",
-    "    # using the `gain_mode` condition.\n",
-    "    agipd_cal.gain_mode = None\n",
-    "    try:\n",
-    "        illum_metadata = agipd_cal.metadata(gain_constants)\n",
-    "        for key, value in illum_metadata.items():\n",
-    "            agipd_metadata.setdefault(key, {}).update(value)\n",
-    "    except CalCatError as e:  # TODO: replace when API errors are improved.\n",
-    "        warning(f\"CalCatError: {e}\")\n",
     "step_timer.done_step(\"Constants were retrieved in\")\n",
     "\n",
     "print(\"Preparing constants (\"\n",
@@ -631,10 +663,10 @@
     "        warning(f\"Offset constant is not available to correct {da}.\")\n",
     "        # Remove module from files to process.\n",
     "        del mapped_files[module_index_to_qm(mod)]\n",
-    "        karabo_da.drop(da)\n",
-    "        modules.drop(mod)\n",
+    "        karabo_da.remove(da)\n",
+    "        modules.remove(mod)\n",
     "\n",
-    "    warn_missing_constants = set(dark_constants + gain_constants)\n",
+    "    warn_missing_constants = set(dark_constants + pc_constants + ff_constants)\n",
     "    warn_missing_constants -= error_missing_constants\n",
     "    warn_missing_constants -= set(calibrations)\n",
     "    if warn_missing_constants:\n",
diff --git a/notebooks/AGIPD/Characterize_AGIPD_Gain_Darks_NBC.ipynb b/notebooks/AGIPD/Characterize_AGIPD_Gain_Darks_NBC.ipynb
index 0d113f7b398cfe4ef62d7207f0515edc7cde3f30..76987d79519ae0f2642d001ec22fd94b05d5c8d3 100644
--- a/notebooks/AGIPD/Characterize_AGIPD_Gain_Darks_NBC.ipynb
+++ b/notebooks/AGIPD/Characterize_AGIPD_Gain_Darks_NBC.ipynb
@@ -40,6 +40,7 @@
     "cal_db_timeout = 3000000 # timeout on caldb requests\"\n",
     "local_output = True # output constants locally\n",
     "db_output = False # output constants to database\n",
+    "sort_runs = True  # Sort the selected dark runs. This flag is added for old data (e.g. 900174 r0011).\n",
     "\n",
     "mem_cells = 0 # number of memory cells used, set to 0 to automatically infer\n",
     "bias_voltage = 0 # bias voltage, set to 0 to use stored value in slow data.\n",
@@ -50,7 +51,7 @@
     "interlaced = False # assume interlaced data format, for data prior to Dec. 2017\n",
     "\n",
     "thresholds_offset_sigma = 3. # offset sigma thresholds for offset deduced bad pixels\n",
-    "thresholds_offset_hard = [0, 0]  # For setting the same threshold offset for the 3 gains. Left for backcompatability. Default [0, 0] to take the following parameters.\n",
+    "thresholds_offset_hard = [0, 0]  # For setting the same threshold offset for the 3 gains. Left for backward compatibility. Default [0, 0] to take the following parameters.\n",
     "thresholds_offset_hard_hg = [3000, 7000]  # High-gain thresholds in absolute ADU terms for offset deduced bad pixels\n",
     "thresholds_offset_hard_mg = [6000, 10000]  # Medium-gain thresholds in absolute ADU terms for offset deduced bad pixels\n",
     "thresholds_offset_hard_lg = [6000, 10000]  # Low-gain thresholds in absolute ADU terms for offset deduced bad pixels\n",
@@ -59,14 +60,14 @@
     "thresholds_offset_hard_lg_fixed = [3500, 6500]  # Same as thresholds_offset_hard_lg, but for fixed gain operation\n",
     "\n",
     "thresholds_noise_sigma = 5. # noise sigma thresholds for offset deduced bad pixels\n",
-    "thresholds_noise_hard = [0, 0] # For setting the same threshold noise for the 3 gains. Left for backcompatability. Default [0, 0] to take the following parameters.\n",
+    "thresholds_noise_hard = [0, 0] # For setting the same threshold noise for the 3 gains. Left for backward compatibility. Default [0, 0] to take the following parameters.\n",
     "thresholds_noise_hard_hg = [4, 20] # High-gain thresholds in absolute ADU terms for offset deduced bad pixels\n",
     "thresholds_noise_hard_mg = [4, 20] # Medium-gain thresholds in absolute ADU terms for offset deduced bad pixels\n",
     "thresholds_noise_hard_lg = [4, 20] # Low-gain thresholds in absolute ADU terms for offset deduced bad pixels\n",
     "\n",
     "thresholds_gain_sigma = 5.  # Gain separation sigma threshold\n",
-    "max_trains = 550  # Maximum number of trains to use for processing dark. Set to 0 to process all available trains. 550 added for ~500GB nodes to temporarely avoid memory issues.\n",
-    "min_trains = 1  # Miniumum number of trains for processing dark. If run folder has less than minimum trains, processing is stopped.\n",
+    "max_trains = 550  # Maximum number of trains to use for processing dark. Set to 0 to process all available trains. 550 added for ~500GB nodes to temporarily avoid memory issues.\n",
+    "min_trains = 1  # Minimum number of trains for processing dark. If run folder has less than minimum trains, processing is stopped.\n",
     "high_res_badpix_3d = False # set this to True if you need high-resolution 3d bad pixel plots. ~7mins extra time for 64 memory cells\n",
     "\n",
     "# This is used if modules is not specified:\n",
@@ -95,9 +96,8 @@
     "from collections import OrderedDict\n",
     "from datetime import timedelta\n",
     "from pathlib import Path\n",
-    "from typing import List, Tuple\n",
+    "from typing import Tuple\n",
     "\n",
-    "import dateutil.parser\n",
     "import matplotlib\n",
     "import numpy as np\n",
     "import pasha as psh\n",
@@ -110,8 +110,9 @@
     "\n",
     "import iCalibrationDB\n",
     "import matplotlib.pyplot as plt\n",
-    "from cal_tools.agipdlib import AgipdCtrl\n",
-    "from cal_tools.enums import AgipdGainMode, BadPixels\n",
+    "from cal_tools import step_timing\n",
+    "from cal_tools.agipdlib import AgipdCtrlRuns\n",
+    "from cal_tools.enums import BadPixels\n",
     "from cal_tools.plotting import (\n",
     "    create_constant_overview,\n",
     "    plot_badpix_3d,\n",
@@ -124,7 +125,6 @@
     "    get_pdu_from_db,\n",
     "    get_random_db_interface,\n",
     "    get_report,\n",
-    "    map_gain_stages,\n",
     "    module_index_to_qm,\n",
     "    run_prop_seq_from_path,\n",
     "    save_const_to_h5,\n",
@@ -143,27 +143,10 @@
     "# insert control device if format string (does nothing otherwise)\n",
     "ctrl_src = ctrl_source_template.format(karabo_id_control)\n",
     "\n",
-    "runs_dict = OrderedDict()\n",
     "run_numbers = [run_high, run_med, run_low]\n",
     "\n",
-    "for gain_idx, (run_name, run_number) in enumerate(zip([\"high\", \"med\", \"low\"], run_numbers)):\n",
-    "    runs_dict[run_name] = {\n",
-    "        \"number\": run_number,\n",
-    "        \"gain\": gain_idx,\n",
-    "        \"dc\": RunDirectory(f'{in_folder}/r{run_number:04d}/')\n",
-    "    }\n",
-    "\n",
-    "creation_time=None\n",
-    "if use_dir_creation_date:\n",
-    "    creation_time = get_dir_creation_date(in_folder, run_high)\n",
-    "\n",
-    "print(f\"Using {creation_time} as creation time of constant.\")\n",
-    "\n",
     "run, prop, seq = run_prop_seq_from_path(in_folder)\n",
     "\n",
-    "# Read report path and create file location tuple to add with the injection\n",
-    "file_loc = f\"proposal:{prop} runs:{run_low} {run_med} {run_high}\"\n",
-    "\n",
     "report = get_report(metadata_folder)\n",
     "cal_db_interface = get_random_db_interface(cal_db_interface)\n",
     "print(f'Calibration database interface: {cal_db_interface}')\n",
@@ -194,7 +177,9 @@
     "\n",
     "print(f\"Detector in use is {karabo_id}\")\n",
     "print(f\"Instrument {instrument}\")\n",
-    "print(f\"Detector instance {dinstance}\")"
+    "print(f\"Detector instance {dinstance}\")\n",
+    "\n",
+    "step_timer = step_timing.StepTimer()"
    ]
   },
   {
@@ -203,45 +188,47 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "step_timer.start()\n",
+    "\n",
     "# Create out_folder if it doesn't exist.\n",
     "Path(out_folder).mkdir(parents=True, exist_ok=True)\n",
     "\n",
     "mod_image_size = []\n",
-    "for run_dict in runs_dict.values():\n",
+    "for run in run_numbers:\n",
     "    missing_modules = []  # modules with no images within a run.\n",
     "    n_trains_list = []   # list of the number of trains for each module within a run.\n",
     "    # This is important in case of no slurm parallelization over modules is done.\n",
     "    # (e.g. running notebook interactively)\n",
     "    for m in modules:\n",
     "        # validate that there are trains for the selected modules and run.\n",
-    "        dc = run_dict[\"dc\"].select(\n",
+    "        dc = RunDirectory(f'{in_folder}/r{run:04d}/').select(\n",
     "            instrument_src.format(m), \"*\", require_all=True)\n",
     "        n_trains = len(dc.train_ids)\n",
     "\n",
     "        if n_trains == 0:\n",
-    "            print(f\"WARNING: No images for module AGIPD{m:02d}, run {run_dict['number']}.\")\n",
+    "            print(f\"WARNING: No images for module AGIPD{m:02d}, run {run}.\")\n",
     "            missing_modules.append(m)\n",
     "        # Raise a warning if the module has less trains than expected.\n",
     "        elif n_trains < min_trains:\n",
-    "            print(f\"WARNING: AGIPD{m:02d}, run {run_dict['number']} \"\n",
+    "            print(f\"WARNING: AGIPD{m:02d}, run {run} \"\n",
     "                  f\"has trains less than minimum trains: {min_trains}.\")\n",
     "        else:\n",
     "            print(f\"Processing {max_trains if max_trains < n_trains else n_trains} \"\n",
-    "                  f\"for AGIPD{m:02d}, run {run_dict['number']} \")\n",
+    "                  f\"for AGIPD{m:02d}, run {run} \")\n",
     "\n",
     "        n_trains_list.append(n_trains)\n",
     "        mod_image_size.append(np.product(dc[instrument_src.format(m), \"image.data\"].shape) * 2  / 1e9)\n",
     "\n",
     "    if max(n_trains_list) == 0:\n",
-    "        raise ValueError(f\"No images to process for run: {run_dict['number']}\")\n",
+    "        raise ValueError(f\"No images to process for run: {run}\")\n",
     "    elif max(n_trains_list) < min_trains:\n",
-    "        raise ValueError(f\"{run_dict['number']} has less than minimum trains: {min_trains}\")\n",
+    "        raise ValueError(f\"{run} has less than minimum trains: {min_trains}\")\n",
     "\n",
     "# Update modules and karabo_da lists based on available modules to processes.\n",
     "modules = [m for m in modules if m not in missing_modules]\n",
     "karabo_da = create_karabo_da_list(modules)\n",
-    "\n",
-    "print(f\"Will process data of ({sum(mod_image_size):.02f} GB).\")"
+    "print(f\"Will process data of ({sum(mod_image_size):.02f} GB).\")\n",
+    "step_timer.done_step(\"Checking the data size and availability.\")"
    ]
   },
   {
@@ -257,73 +244,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "def read_run_conditions(runs_dict: dict):\n",
-    "    agipd_cond = AgipdCtrl(\n",
-    "        run_dc=runs_dict[\"dc\"],\n",
-    "        image_src=instrument_src_mod,\n",
-    "        ctrl_src=ctrl_src,\n",
-    "    )\n",
-    "    cond_dict[\"runs\"].append(runs_dict[\"number\"])\n",
-    "    if acq_rate == 0:\n",
-    "        cond_dict[\"acq_rate\"].append(agipd_cond.get_acq_rate())\n",
-    "    if mem_cells == 0:\n",
-    "        cond_dict[\"mem_cells\"].append(agipd_cond.get_num_cells())\n",
-    "    if gain_setting == -1:    \n",
-    "        cond_dict[\"gain_setting\"].append(\n",
-    "            agipd_cond.get_gain_setting(creation_time))\n",
-    "    if bias_voltage == 0.:\n",
-    "        cond_dict[\"bias_voltage\"].append(\n",
-    "            agipd_cond.get_bias_voltage(karabo_id_control))\n",
-    "    if integration_time == -1:\n",
-    "        cond_dict[\"integration_time\"].append(\n",
-    "            agipd_cond.get_integration_time())\n",
-    "    if gain_mode == -1:\n",
-    "        cond_dict[\"gain_mode\"].append(agipd_cond.get_gain_mode())\n",
-    "    else:\n",
-    "        cond_dict[\"gain_mode\"].append(AgipdGainMode(gain_mode))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def validate_gain_modes(gain_modes: List[AgipdGainMode]):\n",
-    "    # Validate that gain modes are not a mix of adaptive and fixed gain.\n",
-    "    if all(\n",
-    "        gm == AgipdGainMode.ADAPTIVE_GAIN for gm in gain_modes\n",
-    "    ):\n",
-    "        fixed_gain_mode = False\n",
-    "    # Some runs are adaptive by mistake.\n",
-    "    elif any(\n",
-    "        gm == AgipdGainMode.ADAPTIVE_GAIN for gm in gain_modes\n",
-    "    ):\n",
-    "        raise ValueError(\n",
-    "            f\"ERROR: Given runs {run_numbers}\"\n",
-    "            \" have a mix of ADAPTIVE and FIXED gain modes: \"\n",
-    "            f\"{gain_modes}.\"\n",
-    "    )\n",
-    "    elif list(gain_modes) == [\n",
-    "        AgipdGainMode.FIXED_HIGH_GAIN,\n",
-    "        AgipdGainMode.FIXED_MEDIUM_GAIN,\n",
-    "        AgipdGainMode.FIXED_LOW_GAIN\n",
-    "    ]:\n",
-    "        fixed_gain_mode = True\n",
-    "    else:\n",
-    "        raise ValueError(\n",
-    "        \"ERROR: Wrong arrangment of given dark runs. \"\n",
-    "        f\"Given runs' gain_modes are {gain_modes} for runs: {run_numbers}.\"\n",
-    "    )\n",
-    "    return fixed_gain_mode"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
+    "step_timer.start()\n",
+    "\n",
     "# Read slow data from 1st channel only.\n",
     "# Read all modules in one notebook and validate the conditions across detectors?\n",
     "# Currently slurm jobs run per one module.\n",
@@ -331,39 +253,42 @@
     "# TODO: what if first module is not available. Maybe only channel 2 available\n",
     "instrument_src_mod = instrument_src.format(modules[0])\n",
     "\n",
-    "cond_dict = dict()\n",
-    "fixed_gain_mode = None\n",
-    "\n",
-    "with multiprocessing.Manager() as manager:\n",
-    "    cond_dict[\"runs\"] = manager.list()\n",
-    "    cond_dict[\"acq_rate\"] = manager.list()\n",
-    "    cond_dict[\"mem_cells\"] = manager.list()\n",
-    "    cond_dict[\"gain_setting\"] = manager.list()\n",
-    "    cond_dict[\"gain_mode\"] = manager.list()\n",
-    "    cond_dict[\"bias_voltage\"] = manager.list()\n",
-    "    cond_dict[\"integration_time\"] = manager.list()\n",
-    "\n",
-    "    with multiprocessing.Pool(processes=len(modules)) as pool:\n",
-    "        pool.starmap(read_run_conditions, zip(runs_dict.values()))\n",
-    "\n",
-    "    for cond, vlist in cond_dict.items():\n",
-    "        if cond == \"runs\":\n",
-    "            continue\n",
-    "        elif cond == \"gain_mode\":\n",
-    "            fixed_gain_mode = validate_gain_modes(cond_dict[\"gain_mode\"])\n",
-    "        elif not all(x == vlist[0] for x in vlist):\n",
-    "            # TODO: raise ERROR??\n",
-    "            print(\n",
-    "                f\"WARNING: {cond} is not the same for the runs \"\n",
-    "                f\"{cond_dict['runs']} with values\"\n",
-    "                f\" of {cond_dict[cond]}, respectively.\"\n",
-    "            )\n",
-    "    if cond_dict[\"acq_rate\"]: acq_rate = cond_dict[\"acq_rate\"][0]\n",
-    "    if cond_dict[\"mem_cells\"]: mem_cells = cond_dict[\"mem_cells\"][0]\n",
-    "    if cond_dict[\"gain_setting\"]: gain_setting = cond_dict[\"gain_setting\"][0]\n",
-    "    if cond_dict[\"gain_mode\"]: gain_mode = list(cond_dict[\"gain_mode\"])\n",
-    "    if cond_dict[\"bias_voltage\"]: bias_voltage = cond_dict[\"bias_voltage\"][0]\n",
-    "    if cond_dict[\"integration_time\"]: integration_time = cond_dict[\"integration_time\"][0]"
+    "agipd_ctrl_dark = AgipdCtrlRuns(\n",
+    "    raw_folder=in_folder,\n",
+    "    runs=run_numbers,\n",
+    "    image_src=instrument_src_mod,\n",
+    "    ctrl_src=ctrl_src,\n",
+    "    sort_dark_runs_enabled=sort_runs\n",
+    ")\n",
+    "# Update run_numbers list in case it was sorted.\n",
+    "run_numbers = agipd_ctrl_dark.runs\n",
+    "\n",
+    "creation_time = None\n",
+    "if use_dir_creation_date:\n",
+    "    creation_time = get_dir_creation_date(in_folder, run_numbers[0])\n",
+    "\n",
+    "print(f\"Using {creation_time} as creation time of constant.\")\n",
+    "\n",
+    "if mem_cells == 0:\n",
+    "    mem_cells = agipd_ctrl_dark.get_memory_cells()\n",
+    "\n",
+    "if acq_rate == 0:\n",
+    "    acq_rate = agipd_ctrl_dark.get_acq_rate()\n",
+    "\n",
+    "if bias_voltage == 0:\n",
+    "    bias_voltage = agipd_ctrl_dark.get_bias_voltage(karabo_id_control)\n",
+    "\n",
+    "fixed_gain_mode = False\n",
+    "if gain_mode == -1:\n",
+    "    gain_mode = agipd_ctrl_dark.gain_modes\n",
+    "    fixed_gain_mode = agipd_ctrl_dark.fixed_gain_mode()\n",
+    "\n",
+    "if gain_setting == -1:\n",
+    "    gain_setting = agipd_ctrl_dark.get_gain_setting()\n",
+    "\n",
+    "if integration_time == -1:\n",
+    "    integration_time = agipd_ctrl_dark.get_integration_time()\n",
+    "step_timer.done_step(f\"Read operating conditions.\")"
    ]
   },
   {
@@ -462,16 +387,16 @@
     "print(f\"Will use {parallel_num_procs} processes with {parallel_num_threads} threads each\")\n",
     "\n",
     "def characterize_module(\n",
-    "    channel: int, runs_dict: dict,\n",
+    "    channel: int, gain_run: Tuple[int, int],\n",
     ") -> Tuple[int, int, np.array, np.array, np.array, np.array, np.array]:\n",
     "\n",
+    "    gain_index, run = gain_run\n",
     "    # Select the corresponding module channel.\n",
     "    instrument_src_mod = instrument_src.format(channel)\n",
     "\n",
-    "    run_dc = runs_dict[\"dc\"].select(instrument_src_mod, require_all=True)\n",
+    "    run_dc = RunDirectory(f'{in_folder}/r{run:04d}/').select(instrument_src_mod, require_all=True)\n",
     "    if max_trains != 0:\n",
     "        run_dc = run_dc.select_trains(np.s_[:max_trains])\n",
-    "    gain_index = runs_dict[\"gain\"]\n",
     "\n",
     "    # Read module's image and cellId data.\n",
     "    im = run_dc[instrument_src_mod, \"image.data\"].ndarray()\n",
@@ -552,18 +477,22 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "step_timer.start()\n",
+    "\n",
     "with multiprocessing.Pool(processes=parallel_num_procs) as pool:\n",
     "    results = pool.starmap(\n",
-    "        characterize_module, itertools.product(modules, list(runs_dict.values())))\n",
+    "        characterize_module, itertools.product(modules, list(enumerate(run_numbers))))\n",
+    "\n",
+    "step_timer.done_step(\"Processing dark from the 3 runs.\")\n",
     "\n",
     "# mapped values for processing 2 modules example:\n",
-    "# [\n",
-    "#     0, {\"gain\": 0, \"run_number\": <run-high>, \"dc\": <high-dc>},\n",
-    "#     0, {\"gain\": 1, \"run_number\": <run-med>, \"dc\": <med-dc>},\n",
-    "#     0, {\"gain\": 2, \"run_number\": <run-low>, \"dc\": <low-dc>},\n",
-    "#     1, {\"gain\": 0, \"run_number\": <run-high>, \"dc\": <high-dc>},\n",
-    "#     1, {\"gain\": 1, \"run_number\": <run-med>, \"dc\": <med-dc>},\n",
-    "#     1, {\"gain\": 2, \"run_number\": <run-low>, \"dc\": <low-dc>},\n",
+    "# [(0, (0, 9013))\n",
+    "#     0, (0, run-high),\n",
+    "#     0, (1, run-med),\n",
+    "#     0, (2, run-low),\n",
+    "#     1, (0, run-high),\n",
+    "#     1, (1, run-med),\n",
+    "#     1, (2, run-low),,\n",
     "# ]"
    ]
   },
@@ -714,7 +643,11 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "step_timer.start()\n",
+    "\n",
     "md = None\n",
+    "# Location of source data, injected with the constants\n",
+    "file_loc = f\"proposal:{prop} runs:{' '.join([str(r) for r in reversed(run_numbers)])}\"\n",
     "\n",
     "for qm in res:\n",
     "    db_module = qm_dict[qm][\"db_module\"]\n",
@@ -736,7 +669,9 @@
     "print(f\"• memory_cells: {mem_cells}\\n• bias_voltage: {bias_voltage}\\n\"\n",
     "      f\"• acquisition_rate: {acq_rate}\\n• gain_setting: {gain_setting}\\n\"\n",
     "      f\"• gain_mode: {fixed_gain_mode}\\n• integration_time: {integration_time}\\n\"\n",
-    "      f\"• creation_time: {md.calibration_constant_version.begin_at if md is not None else creation_time}\\n\")"
+    "      f\"• creation_time: {md.calibration_constant_version.begin_at if md is not None else creation_time}\\n\")\\\n",
+    "\n",
+    "step_timer.done_step(\"Inject calibration constants to the database.\")"
    ]
   },
   {
@@ -757,6 +692,11 @@
     "\n",
     "\n",
     "def retrieve_old_constant(qm, const):\n",
+    "\n",
+    "    import time\n",
+    "\n",
+    "    st = time.time()\n",
+    "\n",
     "    dconst = getattr(iCalibrationDB.Constants.AGIPD, const)()\n",
     "\n",
     "    data, mdata = get_from_db(\n",
@@ -783,15 +723,15 @@
     "            mdata.calibration_constant_version.filename\n",
     "        )\n",
     "        h5path = mdata.calibration_constant_version.h5path\n",
-    "\n",
-    "    return data, timestamp, filepath, h5path\n",
+    "    \n",
+    "    return data, timestamp, filepath, h5path, time.time() - st\n",
     "\n",
     "\n",
     "old_retrieval_pool = multiprocessing.Pool()\n",
     "old_retrieval_res = old_retrieval_pool.starmap_async(\n",
     "    retrieve_old_constant, qm_x_const\n",
     ")\n",
-    "old_retrieval_pool.close()"
+    "old_retrieval_pool.close()\n"
    ]
   },
   {
@@ -830,6 +770,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "step_timer.start()\n",
+    "\n",
     "cell = 3\n",
     "gain = 0\n",
     "show_overview(res, cell, gain, infix=\"{}-{}-{}\".format(*run_numbers))"
@@ -868,7 +810,9 @@
    "source": [
     "cell = 3\n",
     "gain = 2\n",
-    "show_overview(res, cell, gain, infix=\"{}-{}-{}\".format(*run_numbers))"
+    "show_overview(res, cell, gain, infix=\"{}-{}-{}\".format(*run_numbers))\n",
+    "\n",
+    "step_timer.done_step(\"Single-Cell Overviews.\")"
    ]
   },
   {
@@ -924,6 +868,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "step_timer.start()\n",
+    "\n",
     "create_constant_overview(offset_g, \"Offset (ADU)\", mem_cells, 4000, 8000,\n",
     "                         badpixels=[badpix_g, np.nan])"
    ]
@@ -956,7 +902,9 @@
     "                             badpixels=[bp_thresh, np.nan],\n",
     "                             gmap=['HG-MG Threshold', 'MG-LG Threshold', 'High gain', 'Medium gain', 'low gain'],\n",
     "                             marker=['d','d','','','']\n",
-    "                             )"
+    "                             )\n",
+    "\n",
+    "step_timer.done_step(\"Aggregate values, and per Cell behaviour.\")"
    ]
   },
   {
@@ -991,13 +939,16 @@
     "old_mdata = {}\n",
     "old_retrieval_res.wait()\n",
     "\n",
-    "for (qm, const), (data, timestamp, filepath, h5path) in zip(qm_x_const, old_retrieval_res.get()):\n",
+    "timings = []\n",
+    "for (qm, const), (data, timestamp, filepath, h5path, timing) in zip(qm_x_const, old_retrieval_res.get()):\n",
     "    old_const.setdefault(qm, {})[const] = data\n",
     "    old_mdata.setdefault(qm, {})[const] = {\n",
     "        \"timestamp\": timestamp,\n",
     "        \"filepath\": filepath,\n",
     "        \"h5path\": h5path\n",
-    "    }"
+    "    }\n",
+    "    timings.append(timing)\n",
+    "print(f\"Retrieving old constant took around {np.asarray(timings).mean():.01f} s\")"
    ]
   },
   {
@@ -1029,9 +980,17 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "step_timer.start()\n",
+    "\n",
     "table = []\n",
     "gain_names = ['High', 'Medium', 'Low']\n",
-    "bits = [BadPixels.NOISE_OUT_OF_THRESHOLD, BadPixels.OFFSET_OUT_OF_THRESHOLD, BadPixels.OFFSET_NOISE_EVAL_ERROR, BadPixels.GAIN_THRESHOLDING_ERROR]\n",
+    "bits = [\n",
+    "    BadPixels.NOISE_OUT_OF_THRESHOLD,\n",
+    "    BadPixels.OFFSET_OUT_OF_THRESHOLD,\n",
+    "    BadPixels.OFFSET_NOISE_EVAL_ERROR,\n",
+    "    BadPixels.GAIN_THRESHOLDING_ERROR,\n",
+    "]\n",
+    "\n",
     "for qm in badpix_g.keys():\n",
     "    for gain in range(3):\n",
     "        l_data = []\n",
@@ -1077,7 +1036,9 @@
     "if len(table)>0:\n",
     "    md = display(Latex(tabulate.tabulate(table, tablefmt='latex',\n",
     "                                         headers=[\"Pixel type\", \"Threshold\",\n",
-    "                                                  \"New constant\", \"Old constant\"])))"
+    "                                                  \"New constant\", \"Old constant\"])))\n",
+    "\n",
+    "step_timer.done_step(\"Create badpixels table.\")"
    ]
   },
   {
@@ -1086,6 +1047,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "step_timer.start()\n",
+    "\n",
     "header = ['Parameter',\n",
     "          \"New constant\", \"Old constant \",\n",
     "          \"New constant\", \"Old constant \",\n",
@@ -1157,7 +1120,9 @@
     "\n",
     "for (const, qm), table in zip(constants_x_qms, tables):\n",
     "    display(Markdown(f\"### {qm}: {const} [ADU], good pixels only\"))\n",
-    "    display(Latex(tabulate.tabulate(table, tablefmt='latex', headers=header)))"
+    "    display(Latex(tabulate.tabulate(table, tablefmt='latex', headers=header)))\n",
+    "\n",
+    "step_timer.done_step(\"Computing comparison tables.\")"
    ]
   }
  ],
diff --git a/notebooks/AGIPD/Characterize_AGIPD_Gain_FlatFields_Summary.ipynb b/notebooks/AGIPD/Characterize_AGIPD_Gain_FlatFields_Summary.ipynb
index e5705d14886ebc5234f282b9a887bead70205329..fca571903e01ac972a3a4a4c1f03c44ead950819 100644
--- a/notebooks/AGIPD/Characterize_AGIPD_Gain_FlatFields_Summary.ipynb
+++ b/notebooks/AGIPD/Characterize_AGIPD_Gain_FlatFields_Summary.ipynb
@@ -19,12 +19,12 @@
     "metadata_folder = \"\"  # Directory containing calibration_metadata.yml when run by xfel-calibrate\n",
     "hist_file_template = \"hists_m{:02d}_sum.h5\"\n",
     "proc_folder = \"\" # Path to corrected image data used to create histograms and validation plots\n",
-    "raw_folder = \"/gpfs/exfel/exp/MID/202030/p900137/raw\"  # folder of raw data. This is used to save information of source data of generated constants, required\n",
-    "run = 449 # runs of image data used to create histograms\n",
+    "raw_folder = \"\"  # folder of raw data. This is used to save information of source data of generated constants, required\n",
+    "run = 38 # runs of image data used to create histograms\n",
     "\n",
-    "karabo_id = \"MID_DET_AGIPD1M-1\" # karabo karabo_id\n",
+    "karabo_id = \"SPB_DET_AGIPD1M-1\" # karabo karabo_id\n",
     "ctrl_source_template = '{}/MDL/FPGA_COMP' # path to control information\n",
-    "karabo_id_control = \"MID_EXP_AGIPD1M1\" # karabo-id for control device\n",
+    "karabo_id_control = \"SPB_IRU_AGIPD1M1\" # karabo-id for control device\n",
     "\n",
     "use_dir_creation_date = True # use the creation data of the input dir for database queries\n",
     "cal_db_interface = \"tcp://max-exfl-cal001:8015#8045\" # the database interface to use\n",
@@ -39,7 +39,7 @@
     "d0_lim = [10, 70] # hard limits for d0 value (distance between noise and first peak)\n",
     "gain_lim = [0.80, 1.2] # Threshold on gain in relative number. Contribute to BadPixel bit \"Gain_deviation\"\n",
     "\n",
-    "cell_range = [1,5] # range of cell to be considered, [0,0] for all\n",
+    "cell_range = [0,352] # range of cell to be considered, [0,0] for all\n",
     "pixel_range = [0,0,512,128] # range of pixels x1,y1,x2,y2 to consider [0,0,512,128] for all\n",
     "n_peaks_fit = 4 # Number of gaussian peaks to fit including noise peak\n",
     "\n",
@@ -561,17 +561,16 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "def get_trains_data(run_folder, source, include, tid=None):\n",
+    "def get_trains_data(run_data, source, include, tid=None):\n",
     "    \"\"\"\n",
     "    Load single train for all module\n",
     "    \n",
-    "    :param run_folder: Path to folder with data\n",
+    "    :param run_data: Corrcted data to be loaded from\n",
     "    :param source: Data source to be loaded\n",
     "    :param include: Inset of file name to be considered \n",
     "    :param tid: Train Id to be loaded. First train is considered if None is given\n",
     "    \n",
     "    \"\"\"\n",
-    "    run_data = RunDirectory(run_folder, include)\n",
     "    if tid:\n",
     "        tid, data = run_data.select('*/DET/*', source).train_from_id(tid)\n",
     "        return tid, stack_detector_data(data, source, modules=nmods)\n",
@@ -580,9 +579,9 @@
     "            return tid, stack_detector_data(data, source, modules=nmods)\n",
     "    return None, None\n",
     "\n",
-    "\n",
     "include = '*S00000*'\n",
-    "tid, orig = get_trains_data(f'{proc_folder}/r{run:04d}/', 'image.data', include)\n",
+    "run_data = RunDirectory(f'{proc_folder}/r{run:04d}/', include)\n",
+    "tid, orig = get_trains_data(run_data, 'image.data', include)\n",
     "orig = orig[cell_range[0]:cell_range[1], ...]"
    ]
   },
@@ -594,10 +593,19 @@
    "source": [
     "# FIXME: mask bad pixels from median\n",
     "# mask = const_data['BadPixelsFF']\n",
-    "\n",
     "corrections = const_data['slopesFF'] # (16,shape[0],512,128) shape[0]= cell_range[1]-cell_range[0] /\n",
     "corrections = np.moveaxis(corrections, 1, 0) # (shape[0],16,512,128)\n",
     "rel_corr = corrections/np.nanmedian(corrections)\n",
+    "\n",
+    "# this is needed if LitFrame is enabled in DAQ to avoid shape mismatch \n",
+    "# and correction of the right cells\n",
+    "if np.diff(cell_range)[0] == mem_cells:\n",
+    "    sel = run_data.select(f'{karabo_id}/DET/0CH0:xtdf', 'image.cellId')\n",
+    "    _, cell = sel.train_from_index(0)\n",
+    "    stacked_cells = stack_detector_data(cell, 'image.cellId')[:, 0]\n",
+    "    \n",
+    "    rel_corr = rel_corr[stacked_cells[0]:stacked_cells[-1]+1]\n",
+    "\n",
     "corrected = orig / rel_corr"
    ]
   },
@@ -817,6 +825,23 @@
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
    "version": "3.8.11"
+  },
+  "latex_envs": {
+   "LaTeX_envs_menu_present": true,
+   "autocomplete": true,
+   "bibliofile": "biblio.bib",
+   "cite_by": "apalike",
+   "current_citInitial": 1,
+   "eqLabelWithNumbers": true,
+   "eqNumInitial": 1,
+   "hotkeys": {
+    "equation": "Ctrl-E",
+    "itemize": "Ctrl-I"
+   },
+   "labels_anchors": false,
+   "latex_user_defs": false,
+   "report_style_numbering": false,
+   "user_envs_cfg": false
   }
  },
  "nbformat": 4,
diff --git a/notebooks/AGIPD/Chracterize_AGIPD_Gain_PC_NBC.ipynb b/notebooks/AGIPD/Chracterize_AGIPD_Gain_PC_NBC.ipynb
index 672e8e9bc089a6abf787658d52d2e70e3624c006..4185ab714d4a91cf10990ac4be728f1ab1d0e5a7 100644
--- a/notebooks/AGIPD/Chracterize_AGIPD_Gain_PC_NBC.ipynb
+++ b/notebooks/AGIPD/Chracterize_AGIPD_Gain_PC_NBC.ipynb
@@ -36,7 +36,6 @@
     "out_folder = \"/gpfs/exfel/data/scratch/jsztuk/test/pc\" # path to output to, required\n",
     "metadata_folder = \"\"  # Directory containing calibration_metadata.yml when run by xfel-calibrate\n",
     "runs = [92, 93, 94, 95, 96, 97, 98, 99] # runs to use, required, range allowed\n",
-    "n_sequences = 5 # number of sequence files, starting for 0 to evaluate\n",
     "\n",
     "modules = [-1] # modules to work on, required, range allowed\n",
     "karabo_da = [\"all\"]\n",
@@ -47,9 +46,11 @@
     "instrument_source_template = '{}/DET/{}:xtdf'  # path in the HDF5 file to images\n",
     "receiver_template = \"{}CH0\" # inset for receiver devices\n",
     "\n",
-    "use_dir_creation_date = True\n",
-    "delta_time = 0 # offset to the creation time (e.g. useful in case we want to force the system to use diff. dark constants)\n",
+    "creation_time = \"\" # To overwrite the measured creation_time. Required Format: YYYY-MM-DD HR:MN:SC e.g. \"2022-06-28 13:00:00\"\n",
+    "creation_date_offset = \"00:00:00\" # add an offset to creation date, e.g. to get different constants\n",
+    "cal_db_timeout = 3000000 # timeout on caldb requests\"\n",
     "cal_db_interface = \"tcp://max-exfl-cal001:8019\"  # the database interface to use\n",
+    "\n",
     "local_output = True # output constants locally\n",
     "db_output = False # output constants to database\n",
     "\n",
@@ -62,6 +63,7 @@
     "\n",
     "fit_hook = False # fit a hook function to medium gain slope --> run without hook\n",
     "high_res_badpix_3d = False # set this to True if you need high-resolution 3d bad pixel plots. Runtime: ~ 1h\n",
+    "save_plots = False # set to True if you desire saving plots to output folder\n",
     "\n",
     "hg_range = [30,210]#[0,-150] # range for linear fit. If upper edge is negative use clustering result (bound_hg - 20)\n",
     "mg_range = [-277,600]#[-350,600] # range for linear fit. If lower edge is negative use clustering result (bound_mg + 20)\n",
@@ -80,10 +82,10 @@
     "import warnings\n",
     "from datetime import datetime, timedelta\n",
     "from functools import partial\n",
+    "from dateutil import parser\n",
     "\n",
     "warnings.filterwarnings('ignore')\n",
     "\n",
-    "import dateutil.parser\n",
     "import h5py\n",
     "import matplotlib\n",
     "import numpy as np\n",
@@ -91,7 +93,7 @@
     "\n",
     "import matplotlib.pyplot as plt\n",
     "from matplotlib import gridspec\n",
-    "from matplotlib.colors import LogNorm, PowerNorm\n",
+    "from matplotlib.colors import LogNorm\n",
     "import matplotlib.patches as patches\n",
     "from mpl_toolkits.axes_grid1 import AxesGrid\n",
     "\n",
@@ -102,19 +104,14 @@
     "\n",
     "from cal_tools.agipdlib import AgipdCtrl\n",
     "from cal_tools.enums import BadPixels\n",
-    "from cal_tools.plotting import plot_badpix_3d, show_overview\n",
+    "from cal_tools.plotting import plot_badpix_3d\n",
     "from cal_tools.tools import (\n",
-    "    gain_map_files,\n",
+    "    calcat_creation_time,\n",
     "    get_constant_from_db_and_time,\n",
     "    get_dir_creation_date,\n",
-    "    get_notebook_name,\n",
-    "    get_pdu_from_db,\n",
-    "    get_report,\n",
     "    module_index_to_qm,\n",
-    "    parse_runs,\n",
-    "    send_to_db,\n",
     ")\n",
-    "from iCalibrationDB import Conditions, ConstantMetaData, Constants, Detectors, Versions\n",
+    "from iCalibrationDB import Conditions, Constants\n",
     "\n",
     "# make sure a cluster is running with ipcluster start --n=32, give it a while to start\n",
     "view = Client(profile=cluster_profile)[:]\n",
@@ -182,11 +179,12 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Define creation time\n",
-    "creation_time = None\n",
-    "if use_dir_creation_date:\n",
-    "    creation_time = get_dir_creation_date(in_folder, first_run)\n",
-    "    creation_time = creation_time + timedelta(hours=delta_time)\n",
+    "# Evaluate creation time\n",
+    "creation_time = calcat_creation_time(in_folder, runs[0], creation_time)\n",
+    "offset = parser.parse(creation_date_offset)\n",
+    "delta = timedelta(hours=offset.hour, minutes=offset.minute, seconds=offset.second)\n",
+    "creation_time += delta\n",
+    "print(f\"Creation time: {creation_time}\\n\")\n",
     "\n",
     "# Read AGIPD parameter conditions.\n",
     "if acq_rate < 0.:\n",
@@ -886,10 +884,10 @@
     "        fig1.show()\n",
     "        fig2.show()\n",
     "        fig3.show()\n",
-    "\n",
-    "        fig1.savefig(\"{}/module_{}_{}_pixel_plot.png\".format(out_folder, mod, roi))\n",
-    "        fig2.savefig(\"{}/module_{}_{}_pixel_plot_gain.png\".format(out_folder, mod, roi))\n",
-    "        fig3.savefig(\"{}/module_{}_{}_pixel_plot_fits.png\".format(out_folder, mod, roi))"
+    "        if save_plots:\n",
+    "            fig1.savefig(\"{}/module_{}_{}_pixel_plot.png\".format(out_folder, mod, roi))\n",
+    "            fig2.savefig(\"{}/module_{}_{}_pixel_plot_gain.png\".format(out_folder, mod, roi))\n",
+    "            fig3.savefig(\"{}/module_{}_{}_pixel_plot_fits.png\".format(out_folder, mod, roi))"
    ]
   },
   {
@@ -1415,35 +1413,6 @@
     "    mask[bad_fits_med]  |= BadPixels.CI_EVAL_ERROR.value\n"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def slope_dict_to_arr(d):\n",
-    "    key_to_index = {\n",
-    "        \"ml\": 0,\n",
-    "        \"bl\": 1,\n",
-    "        \"devl\": 2,\n",
-    "        \"mh\": 3,\n",
-    "        \"bh\": 4,\n",
-    "        \"oh\": 5,\n",
-    "        \"ch\": 6,\n",
-    "        \"ah\": 7,\n",
-    "        \"devh\": 8,\n",
-    "        \"tresh\": 9,\n",
-    "    }\n",
-    "\n",
-    "    arr = np.zeros([11]+list(d[\"ml\"].shape), np.float32)\n",
-    "    for key, item in d.items():\n",
-    "        if key not in key_to_index:\n",
-    "            continue\n",
-    "        arr[key_to_index[key],...] = item\n",
-    "        \n",
-    "    return arr"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -1461,65 +1430,6 @@
     "    store_file.close()"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Read report path and create file location tuple to add with the injection\n",
-    "proposal = list(filter(None, in_folder.strip('/').split('/')))[-2]\n",
-    "file_loc = proposal + ' ' + ' '.join(list(map(str,runs)))\n",
-    "\n",
-    "report = get_report(metadata_folder)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "md = None\n",
-    "\n",
-    "# set the operating condition\n",
-    "condition = Conditions.Dark.AGIPD(memory_cells=mem_cells, \n",
-    "                                  bias_voltage=bias_voltage,\n",
-    "                                  acquisition_rate=acq_rate, \n",
-    "                                  gain_setting=gain_setting,\n",
-    "                                  integration_time=integration_time)\n",
-    "\n",
-    "db_modules = get_pdu_from_db(karabo_id, karabo_da, Constants.AGIPD.SlopesPC(),\n",
-    "                             condition, cal_db_interface,\n",
-    "                             snapshot_at=creation_time)\n",
-    "\n",
-    "for pdu, (qm, r) in zip(db_modules, fres.items()):\n",
-    "    for const in [\"SlopesPC\", \"BadPixelsPC\"]:\n",
-    "\n",
-    "        dbconst = getattr(Constants.AGIPD, const)()\n",
-    "\n",
-    "        if const == \"SlopesPC\":\n",
-    "            dbconst.data = slope_dict_to_arr(r)\n",
-    "        else:\n",
-    "            dbconst.data = bad_pixels[qm]\n",
-    "\n",
-    "        if db_output:\n",
-    "            md = send_to_db(pdu, karabo_id, dbconst, condition,\n",
-    "                            file_loc, report, cal_db_interface,\n",
-    "                            creation_time=creation_time,\n",
-    "                           variant=1)\n",
-    "        # TODO: check if this can replace other written function of this notebook.\n",
-    "        #if local_output:\n",
-    "        #    md = save_const_to_h5(pdu, karabo_id, dconst, condition, dconst.data, \n",
-    "        #                          file_loc, report, creation_time, out_folder)\n",
-    "\n",
-    "print(\"Constants parameter conditions are:\\n\")\n",
-    "print(f\"• memory_cells: {mem_cells}\\n• bias_voltage: {bias_voltage}\\n\"\n",
-    "      f\"• acquisition_rate: {acq_rate}\\n• gain_setting: {gain_setting}\\n\"\n",
-    "      f\"• integration_time: {integration_time}\\n\"\n",
-    "      f\"• creation_time: {md.calibration_constant_version.begin_at if md is not None else creation_time}\\n\")"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -1944,13 +1854,6 @@
     "    ax.set_xlabel(\"PC scan point (#)\")\n",
     "    ax.grid(lw=1.5)"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
diff --git a/notebooks/AGIPD/Chracterize_AGIPD_Gain_PC_Summary.ipynb b/notebooks/AGIPD/Chracterize_AGIPD_Gain_PC_Summary.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..a690dc0c5662465ea645e4ba44859736cb6ba42a
--- /dev/null
+++ b/notebooks/AGIPD/Chracterize_AGIPD_Gain_PC_Summary.ipynb
@@ -0,0 +1,740 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Pulse Capacitor Characterisation Summary\n",
+    "\n",
+    "This notebook is used as a dependency notebook for a pulse capacitor characterisation to provide summary for all modules of the AGIPD."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "in_folder = \"/gpfs/exfel/d/raw/SPB/202331/p900376/\" # path to input data, required\n",
+    "out_folder = \"/gpfs/exfel/exp/SPB/202331/p900376/usr/PC/agipd12/202cells0.5MHz_gs0_20clk/\" # path to output to, required\n",
+    "metadata_folder = \"\"  # Directory containing calibration_metadata.yml when run by xfel-calibrate\n",
+    "runs = [] # runs to use, required, range allowed\n",
+    "\n",
+    "karabo_id_control = \"SPB_IRU_AGIPD1M1\"  # karabo-id for the control device e.g. \"MID_EXP_AGIPD1M1\", or \"SPB_IRU_AGIPD1M1\"\n",
+    "karabo_id = \"SPB_DET_AGIPD1M-1\"\n",
+    "ctrl_source_template = '{}/MDL/FPGA_COMP' # path to control information\n",
+    "\n",
+    "creation_time = \"\" # To overwrite the measured creation_time. Required Format: YYYY-MM-DD HR:MN:SC e.g. \"2022-06-28 13:00:00\"\n",
+    "creation_date_offset = \"00:00:00\" # add an offset to creation date, e.g. to get different constants\n",
+    "cal_db_timeout = 3000000 # timeout on caldb requests\"\n",
+    "cal_db_interface = \"tcp://max-exfl-cal001:8015#8045\"\n",
+    "db_output = False\n",
+    "\n",
+    "bias_voltage = -1  # detector bias voltage, negative values for auto-detection.\n",
+    "mem_cells = -1  # number of memory cells used, negative values for auto-detection.\n",
+    "acq_rate = -1.  # the detector acquisition rate, negative values for auto-detection.\n",
+    "gain_setting = -1  # gain setting can have value 0 or 1, negative values for auto-detection.\n",
+    "integration_time = -1  # integration time, negative values for auto-detection."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import warnings\n",
+    "warnings.filterwarnings('ignore')\n",
+    "\n",
+    "import os\n",
+    "from dateutil import parser\n",
+    "from datetime import timedelta\n",
+    "\n",
+    "import h5py\n",
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib.gridspec as gridspec\n",
+    "import matplotlib.cm as cm\n",
+    "import numpy as np\n",
+    "import tabulate\n",
+    "import multiprocessing\n",
+    "\n",
+    "from cal_tools.agipdlib import AgipdCtrl\n",
+    "from cal_tools.ana_tools import get_range\n",
+    "from cal_tools.tools import (\n",
+    "    calcat_creation_time,\n",
+    "    module_index_to_qm,\n",
+    "    get_from_db,\n",
+    "    get_pdu_from_db,\n",
+    "    get_report,\n",
+    "    send_to_db\n",
+    ")\n",
+    "\n",
+    "from extra_data import RunDirectory\n",
+    "from extra_geom import AGIPD_1MGeometry, AGIPD_500K2GGeometry\n",
+    "from IPython.display import Latex, display\n",
+    "from XFELDetAna.plotting.simpleplot import simplePlot\n",
+    "\n",
+    "from iCalibrationDB import Conditions, Constants\n",
+    "\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Evaluate creation time\n",
+    "creation_time = calcat_creation_time(in_folder, runs[0], creation_time)\n",
+    "offset = parser.parse(creation_date_offset)\n",
+    "delta = timedelta(hours=offset.hour, minutes=offset.minute, seconds=offset.second)\n",
+    "creation_time += delta\n",
+    "print(f\"Creation time: {creation_time}\\n\")\n",
+    "\n",
+    "# Get operation conditions\n",
+    "ctrl_source = ctrl_source_template.format(karabo_id_control)\n",
+    "run_folder = f'{in_folder}/r{runs[0]:04d}/'\n",
+    "raw_dc = RunDirectory(run_folder)\n",
+    "\n",
+    "# Read operating conditions from AGIPD00 files\n",
+    "instrument_src_mod = [\n",
+    "    s for s in list(raw_dc.all_sources) if \"0CH\" in s][0]\n",
+    "ctrl_src = [\n",
+    "    s for s in list(raw_dc.all_sources) if ctrl_source in s][0]\n",
+    "\n",
+    "agipd_cond = AgipdCtrl(\n",
+    "    run_dc=raw_dc,\n",
+    "    image_src=instrument_src_mod,\n",
+    "    ctrl_src=ctrl_src,\n",
+    "    raise_error=False,  # to be able to process very old data without mosetting value\n",
+    ")\n",
+    "if mem_cells == -1:\n",
+    "    mem_cells = agipd_cond.get_num_cells()\n",
+    "if mem_cells is None:\n",
+    "    raise ValueError(f\"No raw images found in {run_folder}\")\n",
+    "if acq_rate == -1.:\n",
+    "    acq_rate = agipd_cond.get_acq_rate()\n",
+    "if gain_setting == -1:\n",
+    "    gain_setting = agipd_cond.get_gain_setting(creation_time)\n",
+    "if bias_voltage == -1:\n",
+    "    bias_voltage = agipd_cond.get_bias_voltage(karabo_id_control)\n",
+    "if integration_time == -1:\n",
+    "    integration_time = agipd_cond.get_integration_time()\n",
+    "\n",
+    "# Evaluate detector instance for mapping\n",
+    "instrument = karabo_id.split(\"_\")[0]\n",
+    "if instrument == \"HED\":\n",
+    "    nmods = 8\n",
+    "else:\n",
+    "    nmods = 16\n",
+    "\n",
+    "print(f\"Using {creation_time} as creation time\\n\")\n",
+    "print(f\"Operating conditions are:\\n• Bias voltage: {bias_voltage}\\n• Memory cells: {mem_cells}\\n\"\n",
+    "      f\"• Acquisition rate: {acq_rate}\\n• Gain setting: {gain_setting}\\n• Integration time: {integration_time}\\n\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "# ml - high gain slope\n",
+    "# bl - high gain intercept\n",
+    "# devl - absolute relative deviation from linearity for high gain\n",
+    "# mh - medium gain slope\n",
+    "# bh - medium gain intercept\n",
+    "# oh, ch, ah - parameters of hook function fit to medium gain (only if requested)\n",
+    "# devh - absolute relative deviation from linearity for linear part of medium gain\n",
+    "\n",
+    "keys = ['ml', 'bl', 'mh', 'bh', 'BadPixelsPC']\n",
+    "keys_file = [\"ml\", \"bl\", \"devl\", \"mh\", \"bh\", \"oh\", \"ch\", \"ah\", \"devh\"]\n",
+    "    \n",
+    "fit_data = {}\n",
+    "bad_pixels = {}\n",
+    "modules = []\n",
+    "karabo_da = []\n",
+    "\n",
+    "for mod in range(nmods):\n",
+    "    qm = module_index_to_qm(mod)\n",
+    "    fit_data[mod] = {}\n",
+    "    constants_file = f'{out_folder}/agipd_pc_store_{\"_\".join([str(run) for run in runs])}_{mod}_{mod}.h5'\n",
+    "    \n",
+    "    if os.path.exists(constants_file):\n",
+    "        print(f'Trying to find: {constants_file}')\n",
+    "        print(f'Data available for module {qm}\\n')\n",
+    "        with h5py.File(constants_file, 'r') as hf:\n",
+    "            bad_pixels[mod] = hf[f'/{qm}/BadPixelsPC/0/data'][()]\n",
+    "            for key in keys_file:\n",
+    "                fit_data[mod][key]= hf[f'/{qm}/{key}/0/data'][()]\n",
+    "        \n",
+    "        modules.append(mod)\n",
+    "        karabo_da.append(f\"AGIPD{mod:02d}\")\n",
+    "    else:\n",
+    "        print(f\"No fit data available for module {qm}\\n\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def slope_dict_to_arr(d):\n",
+    "    key_to_index = {\n",
+    "                    \"ml\": 0,\n",
+    "                    \"bl\": 1,\n",
+    "                    \"devl\": 2,\n",
+    "                    \"mh\": 3,\n",
+    "                    \"bh\": 4,\n",
+    "                    \"oh\": 5,\n",
+    "                    \"ch\": 6,\n",
+    "                    \"ah\": 7,\n",
+    "                    \"devh\": 8,\n",
+    "                    \"tresh\": 9\n",
+    "    }\n",
+    "\n",
+    "    arr = np.zeros([11]+list(d[\"ml\"].shape), np.float32)\n",
+    "    for key, item in d.items():\n",
+    "        if key not in key_to_index:\n",
+    "            continue\n",
+    "        arr[key_to_index[key],...] = item\n",
+    "        \n",
+    "    return arr"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# set the operating condition\n",
+    "condition = Conditions.Dark.AGIPD(memory_cells=mem_cells, \n",
+    "                                  bias_voltage=bias_voltage,\n",
+    "                                  acquisition_rate=acq_rate, \n",
+    "                                  gain_setting=gain_setting,\n",
+    "                                  integration_time=integration_time)\n",
+    "\n",
+    "db_modules = get_pdu_from_db(karabo_id, karabo_da, Constants.AGIPD.SlopesPC(),\n",
+    "                             condition, cal_db_interface,\n",
+    "                             snapshot_at=creation_time)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "proposal = list(filter(None, in_folder.strip('/').split('/')))[-2]\n",
+    "file_loc = proposal + ' ' + ' '.join(list(map(str,runs)))\n",
+    "\n",
+    "report = get_report(metadata_folder)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "md = None\n",
+    "\n",
+    "if db_output:\n",
+    "    for mod, pdu in zip(modules, db_modules):\n",
+    "        for const in [\"SlopesPC\", \"BadPixelsPC\"]:\n",
+    "\n",
+    "            dbconst = getattr(Constants.AGIPD, const)()\n",
+    "\n",
+    "            if const == \"SlopesPC\":\n",
+    "                dbconst.data = slope_dict_to_arr(fit_data[mod])\n",
+    "            else:\n",
+    "                dbconst.data = bad_pixels[mod]\n",
+    "\n",
+    "\n",
+    "            md = send_to_db(pdu, karabo_id, dbconst, condition,\n",
+    "                            file_loc, report, cal_db_interface,\n",
+    "                            creation_time=creation_time,\n",
+    "                           variant=1)\n",
+    "\n",
+    "    print(\"Constants injected with the following conditions:\\n\")\n",
+    "    print(f\"• memory_cells: {mem_cells}\\n• bias_voltage: {bias_voltage}\\n\"\n",
+    "          f\"• acquisition_rate: {acq_rate}\\n• gain_setting: {gain_setting}\\n\"\n",
+    "          f\"• integration_time: {integration_time}\\n\"\n",
+    "          f\"• creation_time: {md.calibration_constant_version.begin_at if md is not None else creation_time}\\n\")\n",
+    "else:\n",
+    "    print('Injection to DB not requested.')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Remove keys which won't be used for comparison plots and add BP to the rest of data \n",
+    "for mod in modules:\n",
+    "    fit_data[mod]['BadPixelsPC'] = bad_pixels[mod]\n",
+    "    \n",
+    "    for key in keys_file:\n",
+    "        if key not in keys:\n",
+    "            del fit_data[mod][key]\n",
+    "            \n",
+    "    for key in keys:\n",
+    "        fit_data[mod][key] = fit_data[mod][key].swapaxes(1,2) "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def retrieve_old_PC(mod):\n",
+    "    dconst = getattr(Constants.AGIPD, 'SlopesPC')()\n",
+    "    old_PC = get_from_db(karabo_id=karabo_id,\n",
+    "            karabo_da=karabo_da[mod],\n",
+    "            constant=dconst,\n",
+    "            condition=condition,\n",
+    "            empty_constant=None,\n",
+    "            cal_db_interface=cal_db_interface,\n",
+    "            creation_time=creation_time-timedelta(seconds=1) if creation_time else None,\n",
+    "            strategy=\"pdu_prior_in_time\",\n",
+    "            verbosity=1,\n",
+    "            timeout=cal_db_timeout)\n",
+    "    return old_PC\n",
+    "\n",
+    "with multiprocessing.Pool(processes=len(modules)) as pool:\n",
+    "    old_PC_consts = pool.map(retrieve_old_PC, range(len(modules)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create the arrays that will be used for figures.\n",
+    "# Each array correponds to the data for all processed modules.\n",
+    "\n",
+    "pixel_range = [0,0,512,128]\n",
+    "const_data = {}\n",
+    "old_const = {}\n",
+    "const_order = [0, 1, 3, 4]\n",
+    "\n",
+    "for (key, c) in zip(keys, const_order):\n",
+    "    const_data[key] = np.full((nmods, mem_cells, 512, 128), np.nan)\n",
+    "    old_const[key] = np.full((nmods, mem_cells, 512, 128), np.nan)\n",
+    "    for cnt, i in enumerate(modules):\n",
+    "        if key in fit_data[i]:\n",
+    "            const_data[key][i,:,pixel_range[0]:pixel_range[2],\n",
+    "                               pixel_range[1]:pixel_range[3]] = fit_data[i][key]\n",
+    "            if old_PC_consts[0][0]:\n",
+    "                old_const[key][i,:,pixel_range[0]:pixel_range[2],\n",
+    "                               pixel_range[1]:pixel_range[3]] = old_PC_consts[cnt][0][c].swapaxes(1,2)\n",
+    "\n",
+    "const_data['BadPixelsPC'] = np.full((nmods, mem_cells, 512, 128), np.nan)\n",
+    "for i in modules:\n",
+    "    const_data['BadPixelsPC'][i,:,pixel_range[0]:pixel_range[2],\n",
+    "                              pixel_range[1]:pixel_range[3]] = fit_data[i]['BadPixelsPC']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Define AGIPD geometry\n",
+    "if instrument == \"HED\":\n",
+    "    geom = AGIPD_500K2GGeometry.from_origin()\n",
+    "else:\n",
+    "    geom = AGIPD_1MGeometry.from_quad_positions(quad_pos=[\n",
+    "        (-525, 625),\n",
+    "        (-550, -10),\n",
+    "        (520, -160),\n",
+    "        (542.5, 475),\n",
+    "    ])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Summary across pixels ##\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "gain_data = {'HG': {},\n",
+    "             'MG': {},\n",
+    "             'BP': {}\n",
+    "            }\n",
+    "\n",
+    "old_gain_data = {'HG': {},\n",
+    "                 'MG': {}\n",
+    "                }\n",
+    "      \n",
+    "for key in ['ml', 'bl']:\n",
+    "    gain_data['HG'][key] = const_data[key]\n",
+    "    old_gain_data['HG'][key] = old_const[key]\n",
+    "for key in ['mh', 'bh']:\n",
+    "    gain_data['MG'][key] = const_data[key]\n",
+    "    old_gain_data['MG'][key] = old_const[key]\n",
+    "gain_data['BP']['BadPixelsPC'] = const_data['BadPixelsPC']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_definition(data, g, key):\n",
+    "    titel = ['Difference to previous', 'Percentage difference']\n",
+    "    gs = gridspec.GridSpec(1, 2)\n",
+    "    fig = plt.figure(figsize=(15, 7))\n",
+    "    plt.suptitle(f'{g}', fontsize=16)\n",
+    "    \n",
+    "    for pos in range(0,2):\n",
+    "        vmin, vmax = get_range(data[pos], 2)\n",
+    "        vmax = max(vmax, abs(vmin))\n",
+    "        ax = fig.add_subplot(gs[0, pos])\n",
+    "        ticks = [-1, 0, 1] if np.isnan(vmin) else [vmin, (vmin+vmax)/2, vmax]\n",
+    "        geom.plot_data_fast(data[pos],\n",
+    "                                vmin=vmin, vmax=vmax, ax=ax, cmap=\"RdBu\", figsize=(13,7),\n",
+    "                                colorbar={'shrink': 1,\n",
+    "                                          'pad': 0.04,\n",
+    "                                          'fraction': 0.1,\n",
+    "                                          \n",
+    "                                         })\n",
+    "        colorbar = ax.images[0].colorbar\n",
+    "        colorbar.ax.set_yticklabels([\"{:.1f}\".format(tk) for tk in colorbar.get_ticks()])\n",
+    "        if pos == 1:\n",
+    "            colorbar.set_label('%')\n",
+    "        ax.set_title(f\"{titel[pos]}: {key}\", fontsize=14)\n",
+    "        ax.set_xlabel(\"Columns\", fontsize=13)\n",
+    "        ax.set_ylabel(\"Rows\", fontsize=13)\n",
+    "\n",
+    "def plot_diff_consts(old_const, new_const, g, ratio=False):\n",
+    "    if ratio:\n",
+    "        old_data = old_const['HG']['ml'] / old_const['MG']['mh']\n",
+    "        new_data = new_const['HG']['ml'] / new_const['MG']['mh']\n",
+    "        data1 = np.nanmean((new_data - old_data), axis=1)\n",
+    "        data2 = np.nanmean((new_data - old_data)/old_data*100, axis=1)\n",
+    "        data = [data1, data2]\n",
+    "        key ='Slopes ratio HG/MG'\n",
+    "        plot_definition(data, g, key)\n",
+    "    else:\n",
+    "        for i, key in enumerate(old_const[g].keys()):\n",
+    "            data1 = np.nanmean((new_const[g][key] - old_const[g][key]), axis=1)\n",
+    "            data2 = np.nanmean((new_const[g][key] - old_const[g][key])/old_const[g][key]*100, axis=1)\n",
+    "            data = [data1, data2]\n",
+    "            plot_definition(data, g, key)\n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "for gain in old_gain_data.keys():\n",
+    "    plot_diff_consts(old_gain_data, gain_data, gain)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plot_diff_consts(old_gain_data, gain_data, 'Ratio HG/MG', ratio=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "g_label = ['High gain', 'Medium gain', 'Bad pixels PC']\n",
+    "for idx, g in enumerate(gain_data.keys()):\n",
+    "    gs = gridspec.GridSpec(1, 2)\n",
+    "    fig = plt.figure(figsize=(15, 7))\n",
+    "    plt.suptitle(f'{g_label[idx]}', fontsize=16)\n",
+    "    \n",
+    "    for i, key in enumerate(gain_data[g].keys()):\n",
+    "        if key is 'BadPixelsPC':\n",
+    "            data = np.nanmean(gain_data[g][key]>0, axis=1)\n",
+    "            vmin, vmax = (0,1)\n",
+    "            ax = fig.add_subplot(gs[0, :])\n",
+    "            ticks = [0, 0.5, 1]\n",
+    "            \n",
+    "        else:\n",
+    "            data = np.nanmean(gain_data[g][key], axis=1)\n",
+    "            vmin, vmax = get_range(data, 5)\n",
+    "            ax = fig.add_subplot(gs[0, i])\n",
+    "        geom.plot_data_fast(data,\n",
+    "                                vmin=vmin, vmax=vmax, ax=ax, cmap=\"jet\", figsize=(13,7),\n",
+    "                                colorbar={'shrink': 1,\n",
+    "                                          'pad': 0.04,\n",
+    "                                          'fraction': 0.1,\n",
+    "                                          \n",
+    "                                         })\n",
+    "        colorbar = ax.images[0].colorbar\n",
+    "        ax.set_title(key, fontsize=14)\n",
+    "        ax.set_xlabel('Columns', fontsize=13)\n",
+    "        ax.set_ylabel('Rows', fontsize=13)\n",
+    "        \n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Summary across cells ##\n",
+    "\n",
+    "Good pixels only."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ratio = gain_data['HG']['ml'] / gain_data['MG']['mh']\n",
+    "\n",
+    "fig = plt.figure(figsize=(7, 7))\n",
+    "ax = fig.add_subplot(111)\n",
+    "data = np.nanmean(ratio, axis=1)\n",
+    "vmin, vmax = get_range(data, 5)\n",
+    "ax = geom.plot_data_fast(data,\n",
+    "                                vmin=vmin, vmax=vmax, ax=ax, cmap=\"jet\", figsize=(6,7),\n",
+    "                                colorbar={'shrink': 1,\n",
+    "                                          'pad': 0.04,\n",
+    "                                          'fraction': 0.1\n",
+    "                                         })\n",
+    "colorbar = ax.images[0].colorbar\n",
+    "colorbar.set_label('HG slope / MG slope', fontsize=13)\n",
+    "ax.set_title('High/Medium Gain Slope Ratio', fontsize=14)\n",
+    "ax.set_xlabel('Columns', fontsize=13)\n",
+    "ax.set_ylabel('Rows', fontsize=13)\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "for idx, g in enumerate(gain_data.keys()):\n",
+    "    \n",
+    "    for key in gain_data[g].keys():\n",
+    "        data = np.copy(gain_data[g][key])\n",
+    "        if key=='BadPixelsPC':\n",
+    "            data = data>0\n",
+    "        else:\n",
+    "            data[gain_data['BP']['BadPixelsPC']>0] = np.nan\n",
+    "\n",
+    "        d = []\n",
+    "        for i in range(nmods):\n",
+    "            d.append({'x': np.arange(data[i].shape[0]),\n",
+    "                      'y': np.nanmean(data[i], axis=(1,2)),\n",
+    "                      'drawstyle': 'steps-pre',\n",
+    "                      'label': f'{i}',\n",
+    "                      'linewidth': 2,\n",
+    "                      'linestyle': '--' if i>7 else '-'\n",
+    "                      })\n",
+    "\n",
+    "        fig = plt.figure(figsize=(12, 6))\n",
+    "        plt.suptitle(f'{g_label[idx]} - {key}', fontsize=16)\n",
+    "        ax = fig.add_subplot(111)\n",
+    "\n",
+    "        _ = simplePlot(d, xrange=(-12, 510),\n",
+    "                            x_label='Memory Cell ID',\n",
+    "                            y_label=key,\n",
+    "                            use_axis=ax,\n",
+    "                            legend='top-left-frame-ncol8',)\n",
+    "        ylim = ax.get_ylim()\n",
+    "        ax.set_ylim(ylim[0], ylim[1] + np.abs(ylim[1]-ylim[0])*0.2)\n",
+    "        ax.grid()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "d = []\n",
+    "for i in range(nmods):\n",
+    "    d.append({'x': np.arange(ratio[i].shape[0]),\n",
+    "              'y': np.nanmean(ratio[i], axis=(1,2)),\n",
+    "              'drawstyle': 'steps-pre',\n",
+    "              'label': f'{i}',\n",
+    "              'linewidth': 2,\n",
+    "              'linestyle': '--' if i>7 else '-'\n",
+    "              })\n",
+    "\n",
+    "fig = plt.figure(figsize=(12, 6))\n",
+    "plt.suptitle('High/Medium Gain Slope Ratio', fontsize=16)\n",
+    "ax = fig.add_subplot(111)\n",
+    "\n",
+    "_ = simplePlot(d, xrange=(-12, 510),\n",
+    "                    x_label='Memory Cell ID',\n",
+    "                    y_label='Gain ratio ml/mh',\n",
+    "                    use_axis=ax,\n",
+    "                    legend='top-left-frame-ncol8',)\n",
+    "ylim = ax.get_ylim()\n",
+    "ax.set_ylim(ylim[0], ylim[1] + np.abs(ylim[1]-ylim[0])*0.2)\n",
+    "ax.grid()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "table = []\n",
+    "ratio_old = old_gain_data['HG']['ml'] / old_gain_data['MG']['mh']\n",
+    "for mod in modules:\n",
+    "        \n",
+    "    table.append((mod,\n",
+    "                  f\"{np.nanmean(ratio[mod]):0.1f} +- {np.nanstd(ratio[mod]):0.2f}\",\n",
+    "                  f\"{np.nanmean(ratio_old[mod]):0.1f} +- {np.nanstd(ratio_old[mod]):0.2f}\",\n",
+    "                  f\"{np.nanmean(gain_data['BP']['BadPixelsPC'][mod]>0)*100:0.1f} ({np.nansum(gain_data['BP']['BadPixelsPC'][mod]>0)})\"\n",
+    "                ))\n",
+    "\n",
+    "all_HM = []\n",
+    "all_HM_old = []\n",
+    "for mod in modules:\n",
+    "    all_HM.extend(ratio[mod])\n",
+    "    all_HM_old.extend(ratio_old[mod])\n",
+    "all_HM = np.array(all_HM)\n",
+    "all_HM_old = np.array(all_HM_old)\n",
+    "\n",
+    "all_MSK = np.array([list(msk) for msk in gain_data['BP']['BadPixelsPC']])\n",
+    "\n",
+    "table.append(('overall',\n",
+    "              f\"{np.nanmean(all_HM):0.1f} +- {np.nanstd(all_HM):0.2f}\",\n",
+    "              f\"{np.nanmean(all_HM_old):0.1f} +- {np.nanstd(all_HM_old):0.2f}\",\n",
+    "              f\"{np.nanmean(all_MSK>0)*100:0.1f} ({np.nansum(all_MSK>0)})\"\n",
+    "            ))\n",
+    "\n",
+    "md = display(Latex(tabulate.tabulate(table, tablefmt='latex',\n",
+    "                                     headers=[\"Module\", \n",
+    "                                              \"HG/MG Ratio\",\n",
+    "                                              \"Previous HG/MG Ratio\",\n",
+    "                                              \"Bad pixels [%(Count)]\"])))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Summary high-medium gain ratio (good pixels only) + histograms"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "colors = cm.rainbow(np.linspace(0, 1, nmods))\n",
+    "\n",
+    "gs = gridspec.GridSpec(1, 2)\n",
+    "fig = plt.figure(figsize=(17, 8))\n",
+    "\n",
+    "\n",
+    "ratio[gain_data['BP']['BadPixelsPC'] > 0] = np.nan\n",
+    "data = np.nanmean(ratio, axis=1)\n",
+    "vmin, vmax = get_range(data, 5)\n",
+    "ax = fig.add_subplot(gs[0, 0])\n",
+    "geom.plot_data_fast(data,\n",
+    "                        vmin=vmin, vmax=vmax, ax=ax, cmap=\"jet\", figsize=(12.5,7),\n",
+    "                        colorbar={'shrink': 1,\n",
+    "                                  'pad': 0.04,\n",
+    "                                  'fraction': 0.1\n",
+    "                                 })\n",
+    "colorbar = ax.images[0].colorbar\n",
+    "colorbar.set_label('HG/MG', fontsize=12)\n",
+    "ax.set_xlabel('Columns', fontsize=12)\n",
+    "ax.set_ylabel('Rows', fontsize=12)\n",
+    "\n",
+    "ax = fig.add_subplot(gs[0,1])\n",
+    "for mod in modules:\n",
+    "    h, e = np.histogram(ratio[mod].flatten(), bins=100, range=(vmin, vmax))\n",
+    "    ax.plot(e[:-1], h, color=colors[mod],linewidth=2, label=f'{mod}', alpha=0.8)\n",
+    "    ax.set_xlabel('High/Medium Gain Ratio', fontsize=13)\n",
+    "    ax.set_ylabel('Counts', fontsize=13)\n",
+    "    plt.ticklabel_format(axis='y', style='sci', scilimits=(0,0))\n",
+    "ax.grid()\n",
+    "ax.legend()\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "pycalibration",
+   "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.8.11"
+  },
+  "latex_envs": {
+   "LaTeX_envs_menu_present": true,
+   "autocomplete": true,
+   "bibliofile": "biblio.bib",
+   "cite_by": "apalike",
+   "current_citInitial": 1,
+   "eqLabelWithNumbers": true,
+   "eqNumInitial": 1,
+   "hotkeys": {
+    "equation": "Ctrl-E",
+    "itemize": "Ctrl-I"
+   },
+   "labels_anchors": false,
+   "latex_user_defs": false,
+   "report_style_numbering": false,
+   "user_envs_cfg": false
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/notebooks/DSSC/Characterize_DSSC_Darks_NBC.ipynb b/notebooks/DSSC/Characterize_DSSC_Darks_NBC.ipynb
index 9abbcd225d4bf38d8017ad314364819a5795a85a..b4e01c190dd99c40c08943d02181e7e5c47d36d6 100644
--- a/notebooks/DSSC/Characterize_DSSC_Darks_NBC.ipynb
+++ b/notebooks/DSSC/Characterize_DSSC_Darks_NBC.ipynb
@@ -210,18 +210,7 @@
     "    import h5py\n",
     "    import numpy as np\n",
     "    from cal_tools.enums import BadPixels\n",
-    " \n",
-    "    def get_num_cells(fname, h5path):\n",
-    "        with h5py.File(fname, \"r\") as f:\n",
-    "\n",
-    "            cells = f[f\"{h5path}/cellId\"][()]\n",
-    "            if cells == []:\n",
-    "                return\n",
-    "            maxcell = np.max(cells)\n",
-    "            options = [100, 200, 400, 500, 600, 700, 800]\n",
-    "            dists = np.array([(o-maxcell) for o in options])\n",
-    "            dists[dists<0] = 10000 # assure to always go higher\n",
-    "            return options[np.argmin(dists)]\n",
+    "    from cal_tools.dssclib import get_num_cells\n",
     "    \n",
     "    filename, channel = inp\n",
     "    \n",
@@ -491,11 +480,15 @@
     "                                             acquisition_rate=opfreq, \n",
     "                                             target_gain=targetgain,\n",
     "                                             encoded_gain=encodedgain)\n",
-    "            \n",
+    "            for parm in condition.parameters:\n",
+    "                if parm.name == \"Memory cells\":\n",
+    "                    parm.lower_deviation = max_cells\n",
+    "                    parm.upper_deviation = 0\n",
+    "\n",
     "            if db_output:\n",
     "                md = send_to_db(db_module, karabo_id, dconst, condition, file_loc, report,\n",
     "                                cal_db_interface, creation_time=creation_time, timeout=cal_db_timeout)\n",
-    "                \n",
+    "\n",
     "            if local_output and dont_use_pulseIds: # Don't save constant localy two times.\n",
     "                md = save_const_to_h5(db_module, karabo_id, dconst, condition,\n",
     "                                      dconst.data, file_loc, report,\n",
diff --git a/notebooks/DSSC/DSSC_Correct_and_Verify.ipynb b/notebooks/DSSC/DSSC_Correct_and_Verify.ipynb
index 55978ac1ec6dcbd6dadf38671db8e338904ed0e6..88277c1449194bf6fdfd58d24d43e604879f92ea 100644
--- a/notebooks/DSSC/DSSC_Correct_and_Verify.ipynb
+++ b/notebooks/DSSC/DSSC_Correct_and_Verify.ipynb
@@ -238,7 +238,11 @@
     "\n",
     "    import h5py\n",
     "    import numpy as np\n",
-    "    from cal_tools.dssclib import get_dssc_ctrl_data, get_pulseid_checksum\n",
+    "    from cal_tools.dssclib import (\n",
+    "        get_dssc_ctrl_data,\n",
+    "        get_num_cells,\n",
+    "        get_pulseid_checksum,\n",
+    "    )\n",
     "    from cal_tools.enums import BadPixels\n",
     "    from cal_tools.tools import get_constant_from_db_and_time\n",
     "    from iCalibrationDB import (\n",
@@ -267,15 +271,6 @@
     "    pulse_edges = None\n",
     "    err = None\n",
     "    offset_not_found = False\n",
-    "    def get_num_cells(fname, h5path):\n",
-    "        with h5py.File(fname, \"r\") as f:\n",
-    "\n",
-    "            cells = f[f\"{h5path}/cellId\"][()]\n",
-    "            maxcell = np.max(cells)\n",
-    "            options = [100, 200, 400, 500, 600, 700, 800]\n",
-    "            dists = np.array([(o-maxcell) for o in options])\n",
-    "            dists[dists<0] = 10000 # assure to always go higher\n",
-    "            return options[np.argmin(dists)]\n",
     "        \n",
     "    if mem_cells == 0:\n",
     "        mem_cells = get_num_cells(filename, h5path)\n",
diff --git a/notebooks/Gotthard2/Characterize_Darks_Gotthard2_NBC.ipynb b/notebooks/Gotthard2/Characterize_Darks_Gotthard2_NBC.ipynb
index ee6e5c160964ce530ecc99fae80ff6b7ea362039..fda112e5d0e08a1edafe0023adab63a805b8f710 100644
--- a/notebooks/Gotthard2/Characterize_Darks_Gotthard2_NBC.ipynb
+++ b/notebooks/Gotthard2/Characterize_Darks_Gotthard2_NBC.ipynb
@@ -9,10 +9,10 @@
     "\n",
     "Author: European XFEL Detector Group, Version: 1.0\n",
     "\n",
-    "The following is a processing for offset, noise, and Badpixels maps using dark images taken with Gotthard2 detector.\n",
+    "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).\n",
     "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.\n",
     "\n",
-    "The three maps (calibration constants) can be injected to the database and stored locally."
+    "The three maps are of shape (stripes, cells, gains): (1280, 2, 3). They can be injected to the database (`db_output`) and/or stored locally (`local_output`)."
    ]
   },
   {
@@ -24,6 +24,7 @@
    "source": [
     "in_folder = \"/gpfs/exfel/exp/FXE/202231/p900298/raw\"  # the folder to read data from, required\n",
     "out_folder =  \"/gpfs/exfel/data/scratch/ahmedk/test/gotthard2/darks\"  # the folder to output to, required\n",
+    "metadata_folder = ''  # Directory containing calibration_metadata.yml when run by xfel-calibrate\n",
     "run_high = 7  # run number for G0 dark run, required\n",
     "run_med = 8  # run number for G1 dark run, required\n",
     "run_low = 9  # run number for G2 dark run, required\n",
@@ -33,15 +34,13 @@
     "karabo_da = [\"GH201\"]  # data aggregators\n",
     "receiver_template = \"RECEIVER\"  # receiver template used to read INSTRUMENT keys.\n",
     "control_template = \"CONTROL\"  # control template used to read CONTROL keys.\n",
-    "instrument_source_template = '{}/DET/{}:daqOutput'  # template for source name (filled with karabo_id & receiver_id). e.g. 'SPB_IRDA_JF4M/DET/JNGFR01:daqOutput'  # noqa\n",
     "ctrl_source_template = '{}/DET/{}'  # template for control source name (filled with karabo_id_control)\n",
     "karabo_id_control = \"\"  # Control karabo ID. Set to empty string to use the karabo-id\n",
     "\n",
     "# Parameters for the calibration database.\n",
-    "use_dir_creation_date = True\n",
     "cal_db_interface = \"tcp://max-exfl-cal001:8020\"  # calibration DB interface to use\n",
     "cal_db_timeout = 300000  # timeout on caldb requests\n",
-    "overwrite_creation_time = \"\"  # To overwrite the measured creation_time. Required Format: YYYY-MM-DD HR:MN:SC.00 e.g. \"2022-06-28 13:00:00.00\"\n",
+    "creation_time = \"\"  # To overwrite the measured creation_time. Required Format: YYYY-MM-DD HR:MN:SC e.g. \"2022-06-28 13:00:00\"\n",
     "db_output = False  # Output constants to the calibration database\n",
     "local_output = True  # Output constants locally\n",
     "\n",
@@ -68,7 +67,6 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import datetime\n",
     "import numpy as np\n",
     "import matplotlib.pyplot as plt\n",
     "import pasha as psh\n",
@@ -76,17 +74,20 @@
     "from extra_data import RunDirectory\n",
     "from pathlib import Path\n",
     "\n",
+    "import yaml\n",
+    "from cal_tools.calcat_interface import CalCatApi\n",
     "from cal_tools.enums import BadPixels\n",
     "from cal_tools.gotthard2 import gotthard2algs, gotthard2lib\n",
     "from cal_tools.step_timing import StepTimer\n",
+    "from cal_tools.restful_config import calibration_client\n",
     "from cal_tools.tools import (\n",
-    "    get_dir_creation_date,\n",
+    "    calcat_creation_time,\n",
     "    get_constant_from_db_and_time,\n",
-    "    get_pdu_from_db,\n",
     "    get_report,\n",
     "    save_const_to_h5,\n",
     "    send_to_db,\n",
     ")\n",
+    "\n",
     "from iCalibrationDB import Conditions, Constants\n",
     "\n",
     "%matplotlib inline"
@@ -102,33 +103,34 @@
     "run_nums = [run_high, run_med, run_low]\n",
     "in_folder = Path(in_folder)\n",
     "out_folder = Path(out_folder)\n",
-    "out_folder.mkdir(exist_ok=True)\n",
-    "\n",
-    "print(f\"Process modules: {karabo_da}\")\n",
+    "out_folder.mkdir(parents=True, exist_ok=True)\n",
     "\n",
-    "run_dc = RunDirectory(in_folder / f\"r{run_high:04d}\")\n",
-    "file_loc = f\"proposal:{run_dc.run_metadata()['proposalNumber']} runs:{run_high} {run_med} {run_low}\"  # noqa\n",
-    "\n",
-    "instrument_src = instrument_source_template.format(karabo_id, receiver_template)\n",
     "ctrl_src = ctrl_source_template.format(karabo_id_control, control_template)\n",
     "\n",
     "# Read report path to associate it later with injected constants.\n",
-    "report = get_report(out_folder)\n",
-    "\n",
-    "\n",
-    "if overwrite_creation_time:\n",
-    "    creation_time = datetime.datetime.strptime(\n",
-    "        overwrite_creation_time, \"%Y-%m-%d %H:%M:%S.%f\"\n",
-    "    )\n",
-    "elif use_dir_creation_date:\n",
-    "    creation_time = get_dir_creation_date(in_folder, run_high)\n",
-    "    print(f\"Using {creation_time.isoformat()} as creation time\")\n",
+    "report = get_report(metadata_folder)\n",
     "\n",
+    "# Run's creation time:\n",
+    "creation_time = calcat_creation_time(in_folder, run_high, creation_time)\n",
+    "print(f\"Creation time: {creation_time}\")\n",
     "\n",
     "if not karabo_id_control:\n",
     "    karabo_id_control = karabo_id"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c176a86f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "run_dc = RunDirectory(in_folder / f\"r{run_high:04d}\")\n",
+    "file_loc = f\"proposal:{run_dc.run_metadata()['proposalNumber']} runs:{run_high} {run_med} {run_low}\"  # noqa\n",
+    "\n",
+    "receivers = sorted(list(run_dc.select(f'{karabo_id}/DET/{receiver_template}*').all_sources))"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -193,7 +195,33 @@
     "single_photon = conditions[\"single_photon\"].pop()\n",
     "print(\"Single photon: \", single_photon)\n",
     "acquisition_rate = conditions[\"acquisition_rate\"].pop()\n",
-    "print(\"Acquisition rate: \", acquisition_rate)"
+    "print(\"Acquisition rate: \", acquisition_rate)\n",
+    "\n",
+    "gh2_detector = g2ctrl.get_det_type()\n",
+    "print(f\"Processing {gh2_detector} Gotthard2.\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f64bc150-cfcd-4f98-83f9-a982fdacedd7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "calcat = CalCatApi(client=calibration_client())\n",
+    "detector_id = calcat.detector(karabo_id)['id']\n",
+    "pdus_by_da = calcat.physical_detector_units(detector_id, pdu_snapshot_at=creation_time)\n",
+    "da_to_pdu = {da: p['physical_name'] for (da, p) in pdus_by_da.items()}\n",
+    "\n",
+    "if karabo_da != [\"\"]:\n",
+    "    # Filter DA connected to detector in CALCAT\n",
+    "    karabo_da = [da for da in karabo_da if da in da_to_pdu]\n",
+    "    # Exclude non selected DA from processing.\n",
+    "    da_to_pdu = {da: da_to_pdu[da] for da in karabo_da}\n",
+    "else:\n",
+    "    karabo_da = sorted(da_to_pdu.keys())\n",
+    "\n",
+    "print(f\"Processing {karabo_da}\")"
    ]
   },
   {
@@ -204,9 +232,7 @@
    "outputs": [],
    "source": [
     "def specify_trains_to_process(\n",
-    "    img_key_data: \"extra_data.KeyData\",  # noqa\n",
-    "    max_trains: int = 0,\n",
-    "    min_trains: int = 0,\n",
+    "    img_key_data: \"extra_data.KeyData\",\n",
     "):\n",
     "    \"\"\"Specify total number of trains to process.\n",
     "    Based on given min_trains and max_trains, if given.\n",
@@ -214,11 +240,11 @@
     "    Print number of trains to process and number of empty trains.\n",
     "    Raise ValueError if specified trains are less than min_trains.\n",
     "    \"\"\"\n",
-    "    # Specifies total number of trains to proccess.\n",
+    "    # Specifies total number of trains to process.\n",
     "    n_trains = img_key_data.shape[0]\n",
     "    all_trains = len(img_key_data.train_ids)\n",
     "    print(\n",
-    "        f\"{mod} has {all_trains - n_trains} \"\n",
+    "        f\"{receiver} has {all_trains - n_trains} \"\n",
     "        f\"trains with empty frames out of {all_trains} trains\"\n",
     "    )\n",
     "\n",
@@ -250,15 +276,6 @@
     "    exposure_period=exposure_period,\n",
     "    acquisition_rate=acquisition_rate,\n",
     "    single_photon=single_photon,\n",
-    ")\n",
-    "\n",
-    "db_modules = get_pdu_from_db(\n",
-    "    karabo_id=karabo_id,\n",
-    "    karabo_da=karabo_da,\n",
-    "    constant=Constants.Gotthard2.LUT(),\n",
-    "    condition=condition,\n",
-    "    cal_db_interface=cal_db_interface,\n",
-    "    snapshot_at=creation_time,\n",
     ")"
    ]
   },
@@ -272,7 +289,7 @@
     "def convert_train(wid, index, tid, d):\n",
     "    \"\"\"Convert a Gotthard2 train from 12bit to 10bit.\"\"\"\n",
     "    gotthard2algs.convert_to_10bit(\n",
-    "        d[instr_mod_src][\"data.adc\"], lut, data_10bit[index, ...]\n",
+    "        d[receiver][\"data.adc\"], lut, data_10bit[index, ...]\n",
     "    )"
    ]
   },
@@ -293,7 +310,7 @@
     "    np.uint16\n",
     ")\n",
     "empty_lut = np.stack(1280 * [np.stack([empty_lut] * 2)], axis=0)\n",
-    "for mod in karabo_da:\n",
+    "for mod, receiver in zip(karabo_da, receivers):\n",
     "\n",
     "    # Retrieve LUT constant\n",
     "    lut, time = get_constant_from_db_and_time(\n",
@@ -308,10 +325,7 @@
     "        print_once=False,\n",
     "    )\n",
     "    print(f\"Retrieved LUT constant with creation-time {time}\")\n",
-    "    # Path to pixels ADC values\n",
-    "    instr_mod_src = instrument_src.format(int(mod[-2:]))\n",
     "\n",
-    "    # TODO: Validate the final shape to store constants.\n",
     "    cshape = (1280, 2, 3)\n",
     "\n",
     "    offset_map[mod] = context.alloc(shape=cshape, dtype=np.float32)\n",
@@ -320,10 +334,10 @@
     "\n",
     "    for run_num, [gain, run_dc] in run_dcs_dict.items():\n",
     "        step_timer.start()\n",
-    "        n_trains = specify_trains_to_process(run_dc[instr_mod_src, \"data.adc\"])\n",
+    "        n_trains = specify_trains_to_process(run_dc[receiver, \"data.adc\"])\n",
     "\n",
     "        # Select requested number of trains to process.\n",
-    "        dc = run_dc.select(instr_mod_src, require_all=True).select_trains(\n",
+    "        dc = run_dc.select(receiver, require_all=True).select_trains(\n",
     "            np.s_[:n_trains]\n",
     "        )\n",
     "\n",
@@ -332,7 +346,7 @@
     "        step_timer.start()\n",
     "        # Convert 12bit data to 10bit\n",
     "        data_10bit = context.alloc(\n",
-    "            shape=dc[instr_mod_src, \"data.adc\"].shape, dtype=np.float32\n",
+    "            shape=dc[receiver, \"data.adc\"].shape, dtype=np.float32\n",
     "        )\n",
     "        context.map(convert_train, dc)\n",
     "        step_timer.done_step(\"convert to 10bit\")\n",
@@ -360,7 +374,7 @@
     "        context.map(offset_noise_cell, (even_data, odd_data))\n",
     "\n",
     "        # Split even and odd gain data.\n",
-    "        data_gain = dc[instr_mod_src, \"data.gain\"].ndarray()\n",
+    "        data_gain = dc[receiver, \"data.gain\"].ndarray()\n",
     "        even_gain = data_gain[:, 20::2, :]\n",
     "        odd_gain = data_gain[:, 21::2, :]\n",
     "        raw_g = 3 if gain == 2 else gain\n",
@@ -423,7 +437,7 @@
     "step_timer.start()\n",
     "g_name = [\"G0\", \"G1\", \"G2\"]\n",
     "\n",
-    "for mod, pdu in zip(karabo_da, db_modules):\n",
+    "for mod, pdu in da_to_pdu.items():\n",
     "    display(Markdown(f\"### Badpixels for module {mod}:\"))\n",
     "\n",
     "    badpixels_map[mod][\n",
@@ -436,19 +450,19 @@
     "    badpixels_map[mod][\n",
     "        ~np.isfinite(noise_map[mod])\n",
     "    ] |= BadPixels.OFFSET_NOISE_EVAL_ERROR.value\n",
-    "\n",
-    "    for cell in [0, 1]:\n",
-    "        fig, ax = plt.subplots(figsize=(10, 5))\n",
-    "        for g_idx in [0, 1, 2]:\n",
-    "            ax.plot(badpixels_map[mod][:, cell, g_idx], label=f\"G{g_idx} Bad pixel map\")\n",
-    "        ax.set_xticks(np.arange(0, 1281, 80))\n",
-    "        ax.set_xlabel(\"Stripes #\")\n",
-    "        ax.set_xlabel(\"BadPixels\")\n",
-    "        ax.set_title(f\"Cell {cell} - Module {mod} ({pdu})\")\n",
-    "        ax.set_ylim([0, 5])\n",
-    "        ax.legend()\n",
-    "        pass\n",
-    "step_timer.done_step(f\"Creating bad pixels constant and plotting it.\")"
+    "    if not local_output:\n",
+    "        for cell in [0, 1]:\n",
+    "            fig, ax = plt.subplots(figsize=(10, 5))\n",
+    "            for g_idx in [0, 1, 2]:\n",
+    "                ax.plot(badpixels_map[mod][:, cell, g_idx], label=f\"G{g_idx} Bad pixel map\")\n",
+    "            ax.set_xticks(np.arange(0, 1281, 80))\n",
+    "            ax.set_xlabel(\"Stripes #\")\n",
+    "            ax.set_xlabel(\"BadPixels\")\n",
+    "            ax.set_title(f\"BadPixels map - Cell {cell} - Module {mod} ({pdu})\")\n",
+    "            ax.set_ylim([0, 5])\n",
+    "            ax.legend()\n",
+    "            plt.show()\n",
+    "step_timer.done_step(f\"Creating bad pixels constant.\")"
    ]
   },
   {
@@ -458,18 +472,21 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "for mod, pdu in zip(karabo_da, db_modules):\n",
+    "if not local_output:\n",
     "    for cons, cname in zip([offset_map, noise_map], [\"Offset\", \"Noise\"]):\n",
-    "        for cell in [0, 1]:\n",
-    "            fig, ax = plt.subplots(figsize=(10, 5))\n",
-    "            for g_idx in [0, 1, 2]:\n",
-    "                ax.plot(cons[mod][:, cell, g_idx], label=f\"G{g_idx} {cname} map\")\n",
-    "\n",
-    "            ax.set_xlabel(\"Stripes #\")\n",
-    "            ax.set_xlabel(cname)\n",
-    "            ax.set_title(f\"{cname} map - Cell {cell} - Module {mod} ({pdu})\")\n",
-    "            ax.legend()\n",
-    "            pass"
+    "        for mod, pdu in da_to_pdu.items():\n",
+    "            display(Markdown(f\"### {cname} for module {mod}:\"))\n",
+    "\n",
+    "            for cell in [0, 1]:\n",
+    "                fig, ax = plt.subplots(figsize=(10, 5))\n",
+    "                for g_idx in [0, 1, 2]:\n",
+    "                    ax.plot(cons[mod][:, cell, g_idx], label=f\"G{g_idx} {cname} map\")\n",
+    "\n",
+    "                ax.set_xlabel(\"Stripes #\")\n",
+    "                ax.set_xlabel(cname)\n",
+    "                ax.set_title(f\"{cname} map - Cell {cell} - Module {mod} ({pdu})\")\n",
+    "                ax.legend()\n",
+    "                plt.show()"
    ]
   },
   {
@@ -480,7 +497,7 @@
    "outputs": [],
    "source": [
     "step_timer.start()\n",
-    "for mod, db_mod in zip(karabo_da, db_modules):\n",
+    "for mod, db_mod in da_to_pdu.items():\n",
     "    constants = {\n",
     "        \"Offset\": offset_map[mod],\n",
     "        \"Noise\": noise_map[mod],\n",
@@ -531,6 +548,26 @@
     ")\n",
     "step_timer.done_step(\"Injecting constants.\")"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "98ca9486",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# TODO: store old constants for comparison.\n",
+    "for mod, pdu in da_to_pdu.items():\n",
+    "    mod_file = mod.replace(\"/\", \"-\")\n",
+    "    with open(f\"{metadata_folder or out_folder}/module_metadata_{mod_file}.yml\", \"w\") as fd:\n",
+    "        yaml.safe_dump(\n",
+    "            {\n",
+    "                \"module\": mod,\n",
+    "                \"pdu\": pdu,\n",
+    "            },\n",
+    "            fd,\n",
+    "        )"
+   ]
   }
  ],
  "metadata": {
diff --git a/notebooks/Gotthard2/Correction_Gotthard2_NBC.ipynb b/notebooks/Gotthard2/Correction_Gotthard2_NBC.ipynb
index 134e7e0bb729e7faf6c1509ea6d65c46156709d2..aff16f80037d928e20ea830865d763ffa636d065 100644
--- a/notebooks/Gotthard2/Correction_Gotthard2_NBC.ipynb
+++ b/notebooks/Gotthard2/Correction_Gotthard2_NBC.ipynb
@@ -5,11 +5,42 @@
    "id": "bed7bd15-21d9-4735-82c1-c27c1a5e3346",
    "metadata": {},
    "source": [
-    "# Gotthard2 Offline Correction #\n",
+    "# Gotthard2 Offline Correction\n",
     "\n",
     "Author: European XFEL Detector Group, Version: 1.0\n",
     "\n",
-    "Offline Calibration for the Gothard2 Detector"
+    "Offline Correction for Gotthard2 Detector.\n",
+    "\n",
+    "This notebook is able to correct 25um and 50um GH2 detectors using the same correction steps:\n",
+    "- Convert 12bit raw data into 10bit, offset subtraction, then multiply with gain constant.\n",
+    "\n",
+    "| Correction | constants   | boolean to enable/disable   |\n",
+    "|------------|-------------|-----------------------------|\n",
+    "|   12bit to 10bit  | `LUTGotthard2` |  |\n",
+    "|   Offset  | `OffsetGotthard2`|`offset_correction`|\n",
+    "|   Relative gain  | `RelativeGainGotthard2` + `BadPixelsFFGotthard2` |`gain_correction`|\n",
+    "\n",
+    "Beside the corrected data, a mask is stored using the badpixels constant of the same parameter conditions and time.\n",
+    "- `BadPixelsDarkGotthard2`\n",
+    "- `BadPixelsFFGotthard2`, if relative gain correction is requested.\n",
+    "\n",
+    "The correction is done per sequence file. If all selected sequence files have no images to correct the notebook will fail.\n",
+    "The same result would be reached in case the needed dark calibration constants were not retrieved for all modules and `offset_correction` is True.\n",
+    "In case one of the gain constants were not retrieved `gain_correction` is switched to False and gain correction is disabled.\n",
+    "\n",
+    "The `data` datasets stored in the RECEIVER source along with the corrected image (`adc`) and `mask` are:\n",
+    "\n",
+    "  - `gain`\n",
+    "\n",
+    "  - `bunchId`\n",
+    "\n",
+    "  - `memoryCell`\n",
+    "\n",
+    "  - `frameNumber`\n",
+    "\n",
+    "  - `timestamp`\n",
+    "\n",
+    "  - `trainId`"
    ]
   },
   {
@@ -19,21 +50,21 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "in_folder = \"/gpfs/exfel/exp/FXE/202221/p003225/raw\"  # the folder to read data from, required\n",
+    "in_folder = \"/gpfs/exfel/exp/DETLAB/202330/p900326/raw\"  # the folder to read data from, required\n",
     "out_folder = \"/gpfs/exfel/data/scratch/ahmedk/test/gotthard2\"  # the folder to output to, required\n",
     "metadata_folder = \"\"  # Directory containing calibration_metadata.yml when run by xfel-calibrate\n",
-    "run = 50  # run to process, required\n",
+    "run = 20  # run to process, required\n",
     "sequences = [-1]  # sequences to correct, set to [-1] for all, range allowed\n",
     "sequences_per_node = 1  # number of sequence files per node if notebook executed through xfel-calibrate, set to 0 to not run SLURM parallel\n",
     "\n",
     "# Parameters used to access raw data.\n",
-    "karabo_id = \"FXE_XAD_G2XES\"  # karabo prefix of Gotthard-II devices\n",
-    "karabo_da = [\"GH201\"]  # data aggregators\n",
+    "karabo_id = \"DETLAB_25UM_GH2\"  # karabo prefix of Gotthard-II devices\n",
+    "karabo_da = [\"\"]  # data aggregators\n",
     "receiver_template = \"RECEIVER\"  # receiver template used to read INSTRUMENT keys.\n",
     "control_template = \"CONTROL\"  # control template used to read CONTROL keys.\n",
-    "instrument_source_template = \"{}/DET/{}:daqOutput\"  # template for source name (filled with karabo_id & receiver_id). e.g. 'SPB_IRDA_JF4M/DET/JNGFR01:daqOutput'\n",
     "ctrl_source_template = \"{}/DET/{}\"  # template for control source name (filled with karabo_id_control)\n",
     "karabo_id_control = \"\"  # Control karabo ID. Set to empty string to use the karabo-id\n",
+    "corr_data_source = \"{}/CORR/{}:daqOutput\"  # Correction data source. filled with karabo_id and correction receiver\n",
     "\n",
     "# Parameters for calibration database.\n",
     "cal_db_interface = \"tcp://max-exfl-cal001:8016#8025\"  # the database interface to use.\n",
@@ -89,6 +120,7 @@
     "from cal_tools.tools import (\n",
     "    calcat_creation_time,\n",
     "    write_constants_fragment,\n",
+    "    map_seq_files,\n",
     ")\n",
     "from XFELDetAna.plotting.heatmap import heatmapPlot\n",
     "\n",
@@ -112,44 +144,13 @@
     "if not karabo_id_control:\n",
     "    karabo_id_control = karabo_id\n",
     "\n",
-    "instrument_src = instrument_source_template.format(karabo_id, receiver_template)\n",
     "ctrl_src = ctrl_source_template.format(karabo_id_control, control_template)\n",
     "\n",
-    "print(f\"Process modules: {karabo_da} for run {run}\")\n",
-    "\n",
     "# Run's creation time:\n",
     "creation_time = calcat_creation_time(in_folder, run, creation_time)\n",
     "print(f\"Creation time: {creation_time}\")"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "b5eb816e-b5f2-44ce-9907-0273d82341b6",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Select only sequence files to process for the selected detector.\n",
-    "if sequences == [-1]:\n",
-    "    possible_patterns = list(f\"*{mod}*.h5\" for mod in karabo_da)\n",
-    "else:\n",
-    "    possible_patterns = list(\n",
-    "        f\"*{mod}-S{s:05d}.h5\" for mod in karabo_da for s in sequences\n",
-    "    )\n",
-    "\n",
-    "run_folder = Path(in_folder / f\"r{run:04d}\")\n",
-    "seq_files = [\n",
-    "    f for f in run_folder.glob(\"*.h5\") if any(f.match(p) for p in possible_patterns)\n",
-    "]\n",
-    "\n",
-    "seq_files = sorted(seq_files)\n",
-    "\n",
-    "if not seq_files:\n",
-    "    raise IndexError(\"No sequence files available for the selected sequences.\")\n",
-    "\n",
-    "print(f\"Processing a total of {len(seq_files)} sequence files\")"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -167,8 +168,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Read slow data\n",
     "run_dc = RunDirectory(run_folder)\n",
+    "\n",
+    "# Read slow data\n",
     "g2ctrl = gotthard2lib.Gotthard2Ctrl(run_dc=run_dc, ctrl_src=ctrl_src)\n",
     "\n",
     "if bias_voltage == -1:\n",
@@ -182,32 +184,24 @@
     "if single_photon == -1:\n",
     "    single_photon = g2ctrl.get_single_photon()\n",
     "\n",
+    "gh2_detector = g2ctrl.get_det_type()\n",
+    "\n",
     "print(\"Bias Voltage:\", bias_voltage)\n",
     "print(\"Exposure Time:\", exposure_time)\n",
     "print(\"Exposure Period:\", exposure_period)\n",
     "print(\"Acquisition Rate:\", acquisition_rate)\n",
-    "print(\"Single Photon:\", single_photon)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "8c852392-bb19-4c40-b2ce-3b787538a92d",
-   "metadata": {},
-   "source": [
-    "### Retrieving calibration constants"
+    "print(\"Single Photon:\", single_photon)\n",
+    "print(f\"Processing {gh2_detector} Gotthard2.\")"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "5717d722",
+   "id": "21a8953a-8c76-475e-8f4f-b201cc25c159",
    "metadata": {},
    "outputs": [],
    "source": [
-    "da_to_pdu = {}\n",
-    "# Used for old FXE (p003225) runs before adding Gotthard2 to CALCAT\n",
-    "const_data = dict()\n",
-    "\n",
+    "# GH2 calibration data object.\n",
     "g2_cal = GOTTHARD2_CalibrationData(\n",
     "    detector_name=karabo_id,\n",
     "    sensor_bias_voltage=bias_voltage,\n",
@@ -218,16 +212,53 @@
     "    event_at=creation_time,\n",
     "    client=rest_cfg.calibration_client(),\n",
     ")\n",
+    "\n",
+    "da_to_pdu = None\n",
     "# Keep as long as it is essential to correct\n",
     "# RAW data (FXE p003225) before the data mapping was added to CALCAT.\n",
     "try:  # in case local constants are used with old RAW data. This can be removed in the future.\n",
-    "    for mod_info in g2_cal.physical_detector_units.values():\n",
-    "        da_to_pdu[mod_info[\"karabo_da\"]] = mod_info[\"physical_name\"]\n",
-    "    db_modules = [da_to_pdu[da] for da in karabo_da]\n",
+    "    da_to_pdu = g2_cal.mod_to_pdu\n",
     "except CalCatError as e:\n",
     "    print(e)\n",
     "    db_modules = [None] * len(karabo_da)\n",
     "\n",
+    "if da_to_pdu:\n",
+    "    if karabo_da == [\"\"]:\n",
+    "        karabo_da = sorted(da_to_pdu.keys())\n",
+    "    else:\n",
+    "        # Exclude non selected DA from processing.\n",
+    "        karabo_da = [da for da in karabo_da if da in da_to_pdu]\n",
+    "\n",
+    "    db_modules = [da_to_pdu[da] for da in karabo_da]\n",
+    "\n",
+    "print(f\"Process modules: {db_modules} for run {run}\")\n",
+    "\n",
+    "# Create the correction receiver name.\n",
+    "receivers = sorted(list(run_dc.select(f'{karabo_id}/DET/{receiver_template}*').all_sources))\n",
+    "if gh2_detector == \"25um\":  # For 25um use virtual karabo_das for CALCAT data mapping.\n",
+    "    corr_receiver = receivers[0].split(\"/\")[-1].split(\":\")[0][:-2]\n",
+    "else:\n",
+    "    corr_receiver = receivers[0].split(\"/\")[-1].split(\":\")[0]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8c852392-bb19-4c40-b2ce-3b787538a92d",
+   "metadata": {},
+   "source": [
+    "### Retrieving calibration constants"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5717d722",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Used for old FXE (p003225) runs before adding Gotthard2 to CALCAT\n",
+    "const_data = dict()\n",
+    "\n",
     "if constants_file:\n",
     "    for mod in karabo_da:\n",
     "        const_data[mod] = dict()\n",
@@ -243,6 +274,8 @@
     "        constant_names += [\"RelativeGainGotthard2\", \"BadPixelsFFGotthard2\"]\n",
     "\n",
     "    g2_metadata = g2_cal.metadata(calibrations=constant_names)\n",
+    "    # Display retrieved calibration constants timestamps\n",
+    "    g2_cal.display_markdown_retrieved_constants(metadata=g2_metadata)\n",
     "\n",
     "    # Validate the constants availability and raise/warn correspondingly.\n",
     "    for mod, calibrations in g2_metadata.items():\n",
@@ -283,24 +316,48 @@
     "\n",
     "# Prepare constant arrays.\n",
     "if not constants_file:\n",
-    "    # Create the mask array.\n",
-    "    bpix = const_data[mod].get(\"BadPixelsDarkGotthard2\")\n",
-    "    if bpix is None:\n",
-    "        bpix = np.zeros((1280, 2, 3), dtype=np.uint32)\n",
-    "    if const_data[mod].get(\"BadPixelsFFGotthard2\") is not None:\n",
-    "        bpix |= const_data[mod][\"BadPixelsFFGotthard2\"]\n",
-    "    const_data[mod][\"Mask\"] = bpix\n",
-    "\n",
-    "    # Prepare empty arrays for missing constants.\n",
-    "    if const_data[mod].get(\"OffsetGotthard2\") is None:\n",
-    "        const_data[mod][\"OffsetGotthard2\"] = np.zeros(\n",
-    "            (1280, 2, 3), dtype=np.float32)\n",
-    "\n",
-    "    if const_data[mod].get(\"RelativeGainGotthard2\") is None:\n",
-    "        const_data[mod][\"RelativeGainGotthard2\"] = np.ones(\n",
-    "            (1280, 2, 3), dtype=np.float32)\n",
-    "    const_data[mod][\"RelativeGainGotthard2\"] = const_data[mod][\"RelativeGainGotthard2\"].astype(  # noqa\n",
-    "        np.float32, copy=False)  # Old gain constants are not float32."
+    "    for mod in karabo_da:\n",
+    "        # Create the mask array.\n",
+    "        bpix = const_data[mod].get(\"BadPixelsDarkGotthard2\")\n",
+    "        if bpix is None:\n",
+    "            bpix = np.zeros((1280, 2, 3), dtype=np.uint32)\n",
+    "        if const_data[mod].get(\"BadPixelsFFGotthard2\") is not None:\n",
+    "            bpix |= const_data[mod][\"BadPixelsFFGotthard2\"]\n",
+    "        const_data[mod][\"Mask\"] = bpix\n",
+    "\n",
+    "        # Prepare empty arrays for missing constants.\n",
+    "        if const_data[mod].get(\"OffsetGotthard2\") is None:\n",
+    "            const_data[mod][\"OffsetGotthard2\"] = np.zeros(\n",
+    "                (1280, 2, 3), dtype=np.float32)\n",
+    "\n",
+    "        if const_data[mod].get(\"RelativeGainGotthard2\") is None:\n",
+    "            const_data[mod][\"RelativeGainGotthard2\"] = np.ones(\n",
+    "                (1280, 2, 3), dtype=np.float32)\n",
+    "        const_data[mod][\"RelativeGainGotthard2\"] = const_data[mod][\"RelativeGainGotthard2\"].astype(  # noqa\n",
+    "            np.float32, copy=False)  # Old gain constants are not float32."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2c7dd0bb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "file_da = list({kda.split('/')[0] for kda in karabo_da})\n",
+    "mapped_files, total_files = map_seq_files(\n",
+    "    run_folder,\n",
+    "    file_da,\n",
+    "    sequences,\n",
+    ")\n",
+    "# This notebook doesn't account for processing more\n",
+    "# than one file data aggregator.\n",
+    "seq_files = mapped_files[file_da[0]]\n",
+    "\n",
+    "if not len(seq_files):\n",
+    "    raise IndexError(\n",
+    "        \"No sequence files available to correct for the selected sequences and karabo_da.\")\n",
+    "print(f\"Processing a total of {total_files} sequence files\")"
    ]
   },
   {
@@ -327,7 +384,7 @@
     "        data_corr[index, ...],\n",
     "        mask[index, ...],\n",
     "        g,\n",
-    "        const_data[mod][\"OffsetGotthard2\"],\n",
+    "        const_data[mod][\"OffsetGotthard2\"].astype(np.float32),  # PSI map is in f8\n",
     "        const_data[mod][\"RelativeGainGotthard2\"],  \n",
     "        const_data[mod][\"Mask\"],\n",
     "        apply_offset=offset_correction,\n",
@@ -342,22 +399,31 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "for mod in karabo_da:\n",
-    "    # This is used in case receiver template consists of\n",
-    "    # karabo data aggregator index. e.g. detector at DETLAB\n",
-    "    instr_mod_src = instrument_src.format(mod[-2:])\n",
-    "    data_path = \"INSTRUMENT/\" + instr_mod_src + \"/data\"\n",
-    "    for raw_file in seq_files:\n",
-    "        step_timer.start()\n",
+    "corr_data_source = corr_data_source.format(karabo_id, corr_receiver)\n",
+    "\n",
+    "for raw_file in seq_files:\n",
     "\n",
-    "        dc = H5File(raw_file)\n",
-    "        out_file = out_folder / raw_file.name.replace(\"RAW\", \"CORR\")\n",
+    "    out_file = out_folder / raw_file.name.replace(\"RAW\", \"CORR\")\n",
+    "    # Select module INSTRUMENT sources and deselect empty trains.\n",
+    "    dc = H5File(raw_file).select(receivers, require_all=True)\n",
     "\n",
-    "        # Select module INSTRUMENT source and deselect empty trains.\n",
-    "        dc = dc.select(instr_mod_src, require_all=True)\n",
-    "        data = dc[instr_mod_src, \"data.adc\"].ndarray()\n",
-    "        gain = dc[instr_mod_src, \"data.gain\"].ndarray()\n",
-    "        step_timer.done_step(\"preparing raw data\")\n",
+    "    n_trains = len(dc.train_ids)\n",
+    "\n",
+    "    # Initialize GH2 data and gain arrays to store in corrected files.\n",
+    "    if gh2_detector == \"25um\":\n",
+    "        data_stored = np.zeros((dc[receivers[0], \"data.adc\"].shape[:2] + (1280 * 2,)), dtype=np.float32)\n",
+    "        gain_stored = np.zeros((dc[receivers[0], \"data.adc\"].shape[:2] + (1280 * 2,)), dtype=np.uint8)\n",
+    "    else:\n",
+    "        data_stored = None\n",
+    "        gain_stored = None\n",
+    "\n",
+    "    for i, (receiver, mod) in enumerate(zip(receivers, karabo_da)):\n",
+    "        step_timer.start()\n",
+    "        print(f\"Correcting {receiver} for {raw_file}\")\n",
+    "\n",
+    "        data = dc[receiver, \"data.adc\"].ndarray()\n",
+    "        gain = dc[receiver, \"data.gain\"].ndarray()\n",
+    "        step_timer.done_step(\"Preparing raw data\")\n",
     "        dshape = data.shape\n",
     "\n",
     "        step_timer.start()\n",
@@ -366,7 +432,7 @@
     "        data_corr = context.alloc(shape=dshape, dtype=np.float32)\n",
     "        mask = context.alloc(shape=dshape, dtype=np.uint32)\n",
     "        context.map(correct_train, data)\n",
-    "        step_timer.done_step(\"Correcting one sequence file\")\n",
+    "        step_timer.done_step(f\"Correcting one receiver in one sequence file\")\n",
     "\n",
     "        step_timer.start()\n",
     "\n",
@@ -375,47 +441,54 @@
     "        data_corr[np.isinf(data_corr)] = np.nan\n",
     "\n",
     "        # Create CORR files and add corrected data sections.\n",
-    "        image_counts = dc[instrument_src, \"data.adc\"].data_counts(labelled=False)\n",
-    "\n",
-    "        with DataFile(out_file, \"w\") as ofile:\n",
-    "            # Create INDEX datasets.\n",
-    "            ofile.create_index(dc.train_ids, from_file=dc.files[0])\n",
-    "            # Create METDATA datasets\n",
-    "            ofile.create_metadata(\n",
-    "                like=dc,\n",
-    "                sequence=dc.run_metadata()[\"sequenceNumber\"],\n",
-    "                instrument_channels=(f\"{instrument_src}/data\",)\n",
-    "            )\n",
+    "        image_counts = dc[receiver, \"data.adc\"].data_counts(labelled=False)\n",
+    "\n",
+    "        if gh2_detector == \"25um\":\n",
+    "            data_stored[..., i::2] = data_corr.copy()\n",
+    "            gain_stored[..., i::2] = gain.copy()\n",
+    "        else:  # \"50um\"\n",
+    "            data_stored = data_corr\n",
+    "            gain_stored = gain\n",
+    "\n",
+    "    with DataFile(out_file, \"w\") as ofile:\n",
+    "        # Create INDEX datasets.\n",
+    "        ofile.create_index(dc.train_ids, from_file=dc.files[0])\n",
+    "        ofile.create_metadata(\n",
+    "            like=dc,\n",
+    "            sequence=dc.run_metadata()[\"sequenceNumber\"],\n",
+    "            instrument_channels=(f\"{corr_data_source}/data\",)\n",
+    "        )\n",
     "\n",
-    "            # Create Instrument section to later add corrected datasets.\n",
-    "            outp_source = ofile.create_instrument_source(instrument_src)\n",
+    "        # Create Instrument section to later add corrected datasets.\n",
+    "        outp_source = ofile.create_instrument_source(corr_data_source)\n",
     "\n",
-    "            # Create count/first datasets at INDEX source.\n",
-    "            outp_source.create_index(data=image_counts)\n",
+    "        # Create count/first datasets at INDEX source.\n",
+    "        outp_source.create_index(data=image_counts)\n",
     "\n",
-    "            # Store uncorrected trainId in the corrected file.\n",
-    "            outp_source.create_key(\n",
-    "                    f\"data.trainId\", data=dc.train_ids,\n",
-    "                    chunks=min(50, len(dc.train_ids))\n",
-    "                )\n",
-    "\n",
-    "            # Create datasets with the available corrected data\n",
-    "            for field_name, field_data in {\n",
-    "                \"adc\": data_corr,\n",
-    "                \"gain\": gain,\n",
-    "            }.items():\n",
-    "                outp_source.create_key(\n",
-    "                    f\"data.{field_name}\", data=field_data,\n",
-    "                    chunks=((chunks_data,) + data_corr.shape[1:])\n",
+    "        # Store uncorrected trainId in the corrected file.\n",
+    "        outp_source.create_key(\n",
+    "                f\"data.trainId\", data=dc.train_ids,\n",
+    "                chunks=min(50, len(dc.train_ids))\n",
     "            )\n",
     "\n",
-    "            for field in [\"bunchId\", \"memoryCell\", \"frameNumber\", \"timestamp\"]:\n",
+    "        # Create datasets with the available corrected data\n",
+    "        for field_name, field_data in {\n",
+    "            \"adc\": data_stored,\n",
+    "            \"gain\": gain_stored,\n",
+    "        }.items():\n",
+    "            outp_source.create_key(\n",
+    "                f\"data.{field_name}\", data=field_data,\n",
+    "                chunks=((chunks_data,) + data_corr.shape[1:])\n",
+    "        )\n",
+    "\n",
+    "        # For GH2 25um, the data of the second receiver is\n",
+    "        # stored in the corrected file.\n",
+    "        for field in [\"bunchId\", \"memoryCell\", \"frameNumber\", \"timestamp\"]:\n",
     "                outp_source.create_key(\n",
-    "                    f\"data.{field}\", data=dc[instr_mod_src, f\"data.{field}\"].ndarray(),\n",
+    "                    f\"data.{field}\", data=dc[receiver, f\"data.{field}\"].ndarray(),\n",
     "                    chunks=(chunks_data, data_corr.shape[1])\n",
     "            )\n",
-    "            outp_source.create_compressed_key(f\"data.mask\", data=mask)\n",
-    "\n",
+    "        outp_source.create_compressed_key(f\"data.mask\", data=mask)\n",
     "        step_timer.done_step(\"Storing data\")"
    ]
   },
@@ -454,16 +527,25 @@
     "mod_dcs = {}\n",
     "first_seq_raw = seq_files[0]\n",
     "first_seq_corr = out_folder / first_seq_raw.name.replace(\"RAW\", \"CORR\")\n",
-    "for mod in karabo_da:\n",
-    "    mod_dcs[mod] = {}\n",
-    "    with H5File(first_seq_corr) as out_dc:\n",
-    "        tid, mod_dcs[mod][\"train_corr_data\"] = next(\n",
-    "            out_dc[instr_mod_src, \"data.adc\"].trains()\n",
-    "        )\n",
+    "mod_dcs[corr_data_source] = {}\n",
+    "with H5File(first_seq_corr) as out_dc:\n",
+    "    tid, mod_dcs[corr_data_source][\"train_corr_data\"] = next(\n",
+    "        out_dc[corr_data_source, \"data.adc\"].trains()\n",
+    "    )\n",
+    "\n",
+    "if gh2_detector == \"25um\":\n",
+    "    mod_dcs[corr_data_source][\"train_raw_data\"] = np.zeros((data_corr.shape[1], 1280 * 2), dtype=np.float32)\n",
+    "    mod_dcs[corr_data_source][\"train_raw_gain\"] = np.zeros((data_corr.shape[1], 1280 * 2), dtype=np.uint8)\n",
+    "\n",
+    "for i, rec_mod in enumerate(receivers):\n",
     "    with H5File(first_seq_raw) as in_dc:\n",
-    "        train_dict = in_dc.train_from_id(tid)[1][instr_mod_src]\n",
-    "        mod_dcs[mod][\"train_raw_data\"] = train_dict[\"data.adc\"]\n",
-    "        mod_dcs[mod][\"train_raw_gain\"] = train_dict[\"data.gain\"]"
+    "        train_dict = in_dc.train_from_id(tid)[1][rec_mod]\n",
+    "        if gh2_detector == \"25um\":\n",
+    "            mod_dcs[corr_data_source][\"train_raw_data\"][..., i::2] = train_dict[\"data.adc\"]\n",
+    "            mod_dcs[corr_data_source][\"train_raw_gain\"][..., i::2] = train_dict[\"data.gain\"]\n",
+    "        else:\n",
+    "            mod_dcs[corr_data_source][\"train_raw_data\"] = train_dict[\"data.adc\"]\n",
+    "            mod_dcs[corr_data_source][\"train_raw_gain\"] = train_dict[\"data.gain\"]"
    ]
   },
   {
@@ -476,28 +558,32 @@
     "display(Markdown(\"### Mean RAW and CORRECTED across pulses for one train:\"))\n",
     "display(Markdown(f\"Train: {tid}\"))\n",
     "\n",
+    "if gh2_detector == \"50um\":\n",
+    "    title = f\"{{}} data for {karabo_da} ({db_modules})\"\n",
+    "else:\n",
+    "    title = f\"Interleaved {{}} data for {karabo_da} ({db_modules})\"\n",
+    "\n",
     "step_timer.start()\n",
-    "for mod, pdu in zip(karabo_da, db_modules):\n",
-    "\n",
-    "    fig, ax = plt.subplots(figsize=(20, 10))\n",
-    "    raw_data = mod_dcs[mod][\"train_raw_data\"]\n",
-    "    im = ax.plot(np.mean(raw_data, axis=0))\n",
-    "    ax.set_title(f\"RAW module {mod} ({pdu})\")\n",
-    "    ax.set_xlabel(\"Strip #\", size=20)\n",
-    "    ax.set_ylabel(\"12-bit ADC output\", size=20)\n",
-    "    plt.xticks(fontsize=20)\n",
-    "    plt.yticks(fontsize=20)\n",
-    "    pass\n",
     "\n",
-    "    fig, ax = plt.subplots(figsize=(20, 10))\n",
-    "    corr_data = mod_dcs[mod][\"train_corr_data\"]\n",
-    "    im = ax.plot(np.mean(corr_data, axis=0))\n",
-    "    ax.set_title(f\"CORRECTED module {mod} ({pdu})\")\n",
-    "    ax.set_xlabel(\"Strip #\", size=20)\n",
-    "    ax.set_ylabel(\"10-bit KeV. output\", size=20)\n",
-    "    plt.xticks(fontsize=20)\n",
-    "    plt.yticks(fontsize=20)\n",
-    "    pass\n",
+    "fig, ax = plt.subplots(figsize=(15, 15))\n",
+    "raw_data = mod_dcs[corr_data_source][\"train_raw_data\"]\n",
+    "im = ax.plot(np.mean(raw_data, axis=0))\n",
+    "ax.set_title(title.format(\"RAW\"), fontsize=20)\n",
+    "ax.set_xlabel(\"Strip #\", size=20)\n",
+    "ax.set_ylabel(\"12-bit ADC output\", size=20)\n",
+    "plt.xticks(fontsize=20)\n",
+    "plt.yticks(fontsize=20)\n",
+    "pass\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(15, 15))\n",
+    "corr_data = mod_dcs[corr_data_source][\"train_corr_data\"]\n",
+    "im = ax.plot(np.mean(corr_data, axis=0))\n",
+    "ax.set_title(title.format(\"CORRECTED\"), fontsize=20)\n",
+    "ax.set_xlabel(\"Strip #\", size=20)\n",
+    "ax.set_ylabel(\"10-bit KeV. output\", size=20)\n",
+    "plt.xticks(fontsize=20)\n",
+    "plt.yticks(fontsize=20)\n",
+    "pass\n",
     "step_timer.done_step(\"Plotting mean data\")"
    ]
   },
@@ -511,21 +597,21 @@
     "display(Markdown(f\"### RAW and CORRECTED strips across pulses for train {tid}\"))\n",
     "\n",
     "step_timer.start()\n",
-    "for mod, pdu in zip(karabo_da, db_modules):\n",
-    "    for plt_data, dname in zip(\n",
-    "        [\"train_raw_data\", \"train_corr_data\"], [\"RAW\", \"CORRECTED\"]\n",
-    "    ):\n",
-    "        fig, ax = plt.subplots(figsize=(15, 20))\n",
-    "        plt.rcParams.update({\"font.size\": 20})\n",
-    "\n",
-    "        heatmapPlot(\n",
-    "            mod_dcs[mod][plt_data],\n",
-    "            y_label=\"Pulses\",\n",
-    "            x_label=\"Strips\",\n",
-    "            title=f\"{dname} module {mod} ({pdu})\",\n",
-    "            use_axis=ax,\n",
-    "        )\n",
-    "        pass\n",
+    "for plt_data, dname in zip(\n",
+    "    [\"train_raw_data\", \"train_corr_data\"], [\"RAW\", \"CORRECTED\"]\n",
+    "):\n",
+    "    fig, ax = plt.subplots(figsize=(15, 15))\n",
+    "    plt.rcParams.update({\"font.size\": 20})\n",
+    "\n",
+    "    heatmapPlot(\n",
+    "        mod_dcs[corr_data_source][plt_data],\n",
+    "        y_label=\"Pulses\",\n",
+    "        x_label=\"Strips\",\n",
+    "        title=title.format(dname),\n",
+    "        use_axis=ax,\n",
+    "        cb_pad=0.8,\n",
+    "    )\n",
+    "    pass\n",
     "step_timer.done_step(\"Plotting RAW and CORRECTED data for one train\")"
    ]
   },
@@ -569,43 +655,42 @@
    "source": [
     "display(Markdown(\"### RAW and CORRECTED even/odd pulses for one train:\"))\n",
     "display(Markdown(f\"Train: {tid}\"))\n",
-    "for mod, pdu in zip(karabo_da, db_modules):\n",
-    "    fig, ax = plt.subplots(figsize=(20, 20))\n",
-    "    raw_data = mod_dcs[mod][\"train_raw_data\"]\n",
-    "    corr_data = mod_dcs[mod][\"train_corr_data\"]\n",
-    "\n",
-    "    ax.plot(raw_data[odd_pulse], label=f\"Odd Pulse {odd_pulse}\")\n",
-    "    if even_pulse:\n",
-    "        ax.plot(raw_data[even_pulse], label=f\"Even Pulse {even_pulse}\")\n",
-    "\n",
-    "    ax.set_title(f\"RAW module {mod} ({pdu})\")\n",
-    "    ax.set_xlabel(\"Strip #\", size=20)\n",
-    "    ax.set_ylabel(\"12-bit ADC RAW\", size=20)\n",
-    "    plt.xticks(fontsize=20)\n",
-    "    plt.yticks(fontsize=20)\n",
-    "    ax.legend()\n",
-    "    pass\n",
-    "\n",
-    "    fig, ax = plt.subplots(figsize=(20, 20))\n",
-    "    ax.plot(corr_data[odd_pulse], label=f\"Odd Pulse {odd_pulse}\")\n",
-    "    if even_pulse:\n",
-    "        ax.plot(corr_data[even_pulse], label=f\"Even Pulse {even_pulse}\")\n",
-    "    ax.set_title(f\"CORRECTED module {mod} ({pdu})\")\n",
-    "    ax.set_xlabel(\"Strip #\", size=20)\n",
-    "    ax.set_ylabel(\"10-bit KeV CORRECTED\", size=20)\n",
-    "    plt.xticks(fontsize=20)\n",
-    "    plt.yticks(fontsize=20)\n",
-    "    ax.legend()\n",
-    "    pass\n",
+    "fig, ax = plt.subplots(figsize=(15, 15))\n",
+    "raw_data = mod_dcs[corr_data_source][\"train_raw_data\"]\n",
+    "corr_data = mod_dcs[corr_data_source][\"train_corr_data\"]\n",
+    "\n",
+    "ax.plot(raw_data[odd_pulse], label=f\"Odd Pulse {odd_pulse}\")\n",
+    "if even_pulse:\n",
+    "    ax.plot(raw_data[even_pulse], label=f\"Even Pulse {even_pulse}\")\n",
+    "\n",
+    "ax.set_title(title.format(\"RAW\"), fontsize=20)\n",
+    "ax.set_xlabel(\"Strip #\", size=20)\n",
+    "ax.set_ylabel(\"12-bit ADC RAW\", size=20)\n",
+    "plt.xticks(fontsize=20)\n",
+    "plt.yticks(fontsize=20)\n",
+    "ax.legend()\n",
+    "pass\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(15, 15))\n",
+    "ax.plot(corr_data[odd_pulse], label=f\"Odd Pulse {odd_pulse}\")\n",
+    "if even_pulse:\n",
+    "    ax.plot(corr_data[even_pulse], label=f\"Even Pulse {even_pulse}\")\n",
+    "ax.set_title(title.format(\"CORRECTED\"), fontsize=20)\n",
+    "ax.set_xlabel(\"Strip #\", size=20)\n",
+    "ax.set_ylabel(\"10-bit KeV CORRECTED\", size=20)\n",
+    "plt.xticks(fontsize=20)\n",
+    "plt.yticks(fontsize=20)\n",
+    "ax.legend()\n",
+    "pass\n",
     "step_timer.done_step(\"Plotting RAW and CORRECTED odd/even pulses.\")"
    ]
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "cal4_venv",
+   "display_name": ".cal_venv",
    "language": "python",
-   "name": "cal4_venv"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -618,11 +703,6 @@
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
    "version": "3.8.11"
-  },
-  "vscode": {
-   "interpreter": {
-    "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1"
-   }
   }
  },
  "nbformat": 4,
diff --git a/notebooks/Gotthard2/Summary_Darks_Gotthard2_NBC.ipynb b/notebooks/Gotthard2/Summary_Darks_Gotthard2_NBC.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..756097845270727db4d08b130225d0f7ec89eb62
--- /dev/null
+++ b/notebooks/Gotthard2/Summary_Darks_Gotthard2_NBC.ipynb
@@ -0,0 +1,204 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Gotthard2 Dark Summary\n",
+    "\n",
+    "Author: European XFEL Detector Department, Version: 1.0\n",
+    "\n",
+    "Summary for process dark constants and a comparison with previously injected constants with the same conditions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "in_folder = \"/gpfs/exfel/exp/DETLAB/202330/p900326/raw\"  # the folder to read data from, required\n",
+    "out_folder = \"/gpfs/exfel/data/scratch/ahmedk/test/gotthard2\"  # path to output to, required\n",
+    "metadata_folder = \"\"  # Directory containing calibration_metadata.yml when run by xfel-calibrate.\n",
+    "run_high = 20  # run number for G0 dark run, required\n",
+    "run_med = 21  # run number for G1 dark run, required\n",
+    "run_low = 22  # run number for G2 dark run, required\n",
+    "\n",
+    "# Parameters used to access raw data.\n",
+    "karabo_id = \"DETLAB_25UM_GH2\"  # detector identifier.\n",
+    "karabo_da = [\"DA01/1\", \"DA01/2\"]  # list of data aggregators, which corresponds to different JF modules. This is only needed for the detectors of one module.\n",
+    "control_template = \"CONTROL\"  # control template used to read CONTROL keys.\n",
+    "ctrl_source_template = '{}/DET/{}'  # template for control source name (filled with karabo_id_control)\n",
+    "karabo_id_control = \"\"  # Control karabo ID. Set to empty string to use the karabo-id\n",
+    "\n",
+    "# Parameters to be used for injecting dark calibration constants.\n",
+    "local_output = True  # Boolean indicating that local constants were stored in the out_folder\n",
+    "\n",
+    "# Skip the whole notebook if local_output is false in the preceding notebooks.\n",
+    "if not local_output:\n",
+    "    print('No local constants saved. Skipping summary plots')\n",
+    "    import sys\n",
+    "    sys.exit(0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import warnings\n",
+    "from pathlib import Path\n",
+    "\n",
+    "warnings.filterwarnings('ignore')\n",
+    "\n",
+    "import h5py\n",
+    "import matplotlib\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import yaml\n",
+    "from extra_data import RunDirectory\n",
+    "from IPython.display import Markdown, display\n",
+    "\n",
+    "from cal_tools.gotthard2 import gotthard2lib\n",
+    "\n",
+    "matplotlib.use(\"agg\")\n",
+    "%matplotlib inline\n",
+    "\n",
+    "from cal_tools.tools import CalibrationMetadata"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "out_folder = Path(out_folder)\n",
+    "metadata = CalibrationMetadata(metadata_folder or out_folder)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if not karabo_id_control:\n",
+    "    karabo_id_control = karabo_id\n",
+    "g2ctrl = gotthard2lib.Gotthard2Ctrl(\n",
+    "    run_dc=RunDirectory(Path(in_folder) / f\"r{run_high:04d}\"),\n",
+    "    ctrl_src=ctrl_source_template.format(karabo_id_control, control_template))\n",
+    "gh2_detector = g2ctrl.get_det_type()\n",
+    "print(f\"Processing {gh2_detector} Gotthard2.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mod_mapping = dict()\n",
+    "for fn in Path(metadata_folder or out_folder).glob(\"module_metadata_*.yml\"):\n",
+    "    with fn.open(\"r\") as fd:\n",
+    "        fdict = yaml.safe_load(fd)\n",
+    "        mod_mapping[fdict[\"module\"].replace(\"-\", \"/\")] = fdict[\"pdu\"]\n",
+    "\n",
+    "mod_mapping = dict(sorted(mod_mapping.items(), key=lambda item: item[0]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt_map = dict()\n",
+    "dark_constants = [\"Offset\", \"Noise\", \"BadPixelsDark\"]\n",
+    "if gh2_detector == \"25um\":\n",
+    "    for cname in dark_constants:\n",
+    "        plt_map[cname] = np.zeros(\n",
+    "            (1280 * 2, 2, 3),\n",
+    "            dtype=np.uint32 if cname == \"BadPixelsDark\" else np.float32\n",
+    "        )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for cname in dark_constants:\n",
+    "\n",
+    "    for i, (mod, pdu) in enumerate(mod_mapping.items()):\n",
+    "        module = mod.replace(\"-\", \"/\")\n",
+    "\n",
+    "        with h5py.File(out_folder / f\"const_{cname}_{pdu}.h5\", 'r') as f:\n",
+    "            if gh2_detector == \"25um\":\n",
+    "                plt_map[cname][i::2] = f[\"data\"][()]\n",
+    "            else:\n",
+    "                plt_map[cname] = f[\"data\"][()]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if gh2_detector == \"50um\":\n",
+    "    title = (\n",
+    "        f\"{{}} data for \"\n",
+    "        f\"{[f'{mod}({pdu})' for mod, pdu in mod_mapping.items()]}\"\n",
+    "    )\n",
+    "else:\n",
+    "    title = (\n",
+    "        f\"Interleaved {{}} data for \"\n",
+    "        f\"{[f'{mod}({pdu})' for mod, pdu in mod_mapping.items()]}\"\n",
+    "    )\n",
+    "\n",
+    "for cname in dark_constants:\n",
+    "    display(Markdown(f\"### {cname}\"))\n",
+    "\n",
+    "    for cell in [0, 1]:\n",
+    "        fig, ax = plt.subplots(figsize=(10, 5))\n",
+    "        for g_idx in [0, 1, 2]:\n",
+    "            ax.plot(plt_map[cname][:, cell, g_idx], label=f\"G{g_idx} {cname} map\")\n",
+    "        ax.set_xticks(\n",
+    "            np.arange(0, plt_map[cname].shape[0]+1, plt_map[cname].shape[0]//16)\n",
+    "        )\n",
+    "        ax.set_xlabel(\"Stripes #\", fontsize=15)\n",
+    "        ax.set_ylabel(\"ADU\", fontsize=15)\n",
+    "        ax.set_title(title.format(f\"{cname} map - Cell {cell}\"), fontsize=15)\n",
+    "        if cname == \"BadPixelsDark\":\n",
+    "            ax.set_ylim([0, 5])\n",
+    "        ax.legend()\n",
+    "        plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".cal3_venv",
+   "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.8.11"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/notebooks/Jungfrau/Jungfrau_Gain_Correct_and_Verify_NBC.ipynb b/notebooks/Jungfrau/Jungfrau_Gain_Correct_and_Verify_NBC.ipynb
index e644dfcaa740911cc98a2c1aaf3d887e469caf9d..2cbf2883903625f971734edb684e66e5c8011853 100644
--- a/notebooks/Jungfrau/Jungfrau_Gain_Correct_and_Verify_NBC.ipynb
+++ b/notebooks/Jungfrau/Jungfrau_Gain_Correct_and_Verify_NBC.ipynb
@@ -17,16 +17,16 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "in_folder = \"/gpfs/exfel/exp/SPB/202130/p900204/raw\"  # the folder to read data from, required\n",
-    "out_folder =  \"/gpfs/exfel/data/scratch/ahmedk/test/remove\"  # the folder to output to, required\n",
-    "run = 91  # run to process, required\n",
+    "in_folder = \"/gpfs/exfel/exp/HED/202331/p900360/raw\"  # the folder to read data from, required\n",
+    "out_folder =  \"/gpfs/exfel/data/scratch/ahmedk/test/remove/jungfrau\"  # the folder to output to, required\n",
+    "run = 20  # run to process, required\n",
     "metadata_folder = \"\"  # Directory containing calibration_metadata.yml when run by xfel-calibrate\n",
     "sequences = [-1]  # sequences to correct, set to [-1] for all, range allowed\n",
     "sequences_per_node = 1  # number of sequence files per cluster node if run as slurm job, set to 0 to not run SLURM parallel\n",
     "\n",
     "# Parameters used to access raw data.\n",
-    "karabo_id = \"SPB_IRDA_JF4M\"  # karabo prefix of Jungfrau devices\n",
-    "karabo_da = ['JNGFR01', 'JNGFR02', 'JNGFR03', 'JNGFR04', 'JNGFR05', 'JNGFR06', 'JNGFR07', 'JNGFR08']  # data aggregators\n",
+    "karabo_id = \"HED_IA1_JF500K4\"  # karabo prefix of Jungfrau devices\n",
+    "karabo_da = ['JNGFR04']  # data aggregators\n",
     "receiver_template = \"JNGFR{:02d}\"  # Detector receiver template for accessing raw data files. e.g. \"JNGFR{:02d}\"\n",
     "instrument_source_template = '{}/DET/{}:daqOutput'  # template for source name (filled with karabo_id & receiver_id). e.g. 'SPB_IRDA_JF4M/DET/JNGFR01:daqOutput'\n",
     "ctrl_source_template = '{}/DET/CONTROL'  # template for control source name (filled with karabo_id_control)\n",
@@ -39,19 +39,20 @@
     "\n",
     "# Parameters affecting corrected data.\n",
     "relative_gain = True  # do relative gain correction.\n",
-    "strixel_sensor = False  # reordering for strixel detector layout.\n",
+    "strixel_sensor = \"\"  # reordering for strixel detector layout. Possible strixels to choose from are A0123 and A1256.\n",
     "strixel_double_norm = 2.0  # normalization to use for double-size pixels, only applied for strixel sensors.\n",
     "limit_trains = 0  # ONLY FOR TESTING. process only first N trains, Use 0 to process all.\n",
     "chunks_ids = 32  # HDF chunk size for memoryCell and frameNumber.\n",
     "chunks_data = 1  # HDF chunk size for pixel data in number of frames.\n",
+    "wrong_gain_pixels = [-1]  # List of 5 values (e.g. [4, 0, 255, 896, 1024]) defining the module number (4 for JNGFR04). And using the indexes of the FEM row [pixel_x_0:pixel_x_1] and column [pixel_y_0:pixel_y_1]. Set to -1 to not pick pixels for gain replacement.\n",
+    "replace_wrong_gain_value = 0  # Force gain value into the chosen gain [0, 1, or 2] for pixels specified in `wrong_gain_pixels`. This has no effect if wrong_gain_pixels = [-1]\n",
     "\n",
     "# Parameters for retrieving calibration constants\n",
-    "manual_slow_data = False  # if true, use manually entered bias_voltage, integration_time, gain_setting, and gain_mode values\n",
-    "integration_time = 4.96  # integration time in us, will be overwritten by value in file\n",
-    "gain_setting = 0  # 0 for dynamic gain, 1 for dynamic HG0, will be overwritten by value in file\n",
-    "gain_mode = 0  # 0 for runs with dynamic gain setting, 1 for fixgain. It will be overwritten by value in file, if manual_slow_data is set to True.\n",
+    "integration_time = -1  # integration time in us. set to -1 to overwrite by value in file.\n",
+    "gain_setting = -1  # 0 for dynamic gain, 1 for dynamic HG0. set to -1 to overwrite by value in file.\n",
+    "gain_mode = -1  # 0 for runs with dynamic gain setting, 1 for fixed gain. Set to -1 to overwrite by value in file.\n",
     "mem_cells = -1  # Set mem_cells to -1 to automatically use the value stored in RAW data.\n",
-    "bias_voltage = 180  # will be overwritten by value in file\n",
+    "bias_voltage = -1  # Bias Voltage. Set to -1 to overwrite by value in file.\n",
     "\n",
     "# Parameters for plotting\n",
     "skip_plots = False  # exit after writing corrected files\n",
@@ -60,6 +61,8 @@
     "\n",
     "# Parameters for ROI selection and reduction\n",
     "roi_definitions = [-1]  # List with groups of 6 values defining ROIs, e.g. [3, 120, 180, 200, 550, -2] for module 3 (JNGFR03), slice 120:180, 200:550, average along axis -2 (slow scan, or -1 for fast scan)\n",
+    "roi_threshold = 2.  # Corrected pixels below the threshold will be excluded from ROI projections. Set to -1 to include all pixels.\n",
+    "\n",
     "\n",
     "def balance_sequences(in_folder, run, sequences, sequences_per_node, karabo_da):\n",
     "    from xfel_calibrate.calibrate import balance_sequences as bs\n",
@@ -84,17 +87,16 @@
     "import numpy as np\n",
     "import pasha as psh\n",
     "import tabulate\n",
-    "from IPython.display import Latex, Markdown, display\n",
     "from extra_data import DataCollection, H5File, RunDirectory, by_id, components\n",
+    "from IPython.display import Latex, Markdown, display\n",
     "from matplotlib.colors import LogNorm\n",
     "\n",
     "import cal_tools.restful_config as rest_cfg\n",
     "from cal_tools.calcat_interface import JUNGFRAU_CalibrationData\n",
-    "from cal_tools.jungfraulib import JungfrauCtrl\n",
     "from cal_tools.enums import BadPixels\n",
-    "from cal_tools.jungfraulib import JungfrauCtrl\n",
-    "from cal_tools.plotting import init_jungfrau_geom\n",
     "from cal_tools.files import DataFile\n",
+    "from cal_tools.jungfrau.jungfraulib import JungfrauCtrl\n",
+    "from cal_tools.plotting import init_jungfrau_geom\n",
     "from cal_tools.step_timing import StepTimer\n",
     "from cal_tools.tools import (\n",
     "    calcat_creation_time,\n",
@@ -153,23 +155,109 @@
     "    memory_cells, sc_start = ctrl_data.get_memory_cells()\n",
     "\n",
     "    mem_cells_name = \"single cell\" if memory_cells == 1 else \"burst\"\n",
+    "    print(f\"Number of memory cells are {memory_cells}\")\n",
     "    print(f\"Run is in {mem_cells_name} mode.\\nStorage cell start: {sc_start:02d}\")\n",
     "else:\n",
     "    memory_cells = mem_cells\n",
     "    mem_cells_name = \"single cell\" if memory_cells == 1 else \"burst\"\n",
     "    print(f\"Run is in manually set to {mem_cells_name} mode. With {memory_cells} memory cells\")\n",
     "\n",
-    "if not manual_slow_data:\n",
+    "if integration_time < 0:\n",
     "    integration_time = ctrl_data.get_integration_time()\n",
+    "    print(f\"Integration time is {integration_time} us\")\n",
+    "else:\n",
+    "    print(f\"Integration time is manually set to {integration_time} us\")\n",
+    "\n",
+    "if bias_voltage < 0:\n",
     "    bias_voltage = ctrl_data.get_bias_voltage()\n",
+    "    print(f\"Bias voltage is {bias_voltage} V\")\n",
+    "else:\n",
+    "    print(f\"Bias voltage is manually set to {bias_voltage} V.\")\n",
+    "\n",
+    "if gain_setting < 0:\n",
     "    gain_setting = ctrl_data.get_gain_setting()\n",
+    "    print(f\"Gain setting is {gain_setting} (run settings: {ctrl_data.run_settings})\")\n",
+    "else:\n",
+    "    print(f\"Gain setting is manually set to {gain_setting}.\")\n",
+    "\n",
+    "force_fixed_gain_constants_flag = False\n",
+    "if gain_mode < 0:\n",
     "    gain_mode = ctrl_data.get_gain_mode()\n",
+    "    print(f\"Gain mode is {gain_mode} ({ctrl_data.run_mode})\")\n",
+    "    # JF corrections in burst mode are only supported when no gain switching occurs.\n",
+    "    # Always retrieve fixed gain constant for burst mode.\n",
+    "    if gain_mode == 0 and memory_cells > 1:\n",
+    "        print(\"By default fixed gain constant will be retrieved for burst mode data,\"\n",
+    "            \" even for dynamic gain data.\")\n",
+    "        force_fixed_gain_constants_flag = True\n",
+    "else:\n",
+    "    print(f\"Gain mode is manually set to {gain_mode}.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def jungfrau_cal_mdata(gm):\n",
+    "    jf_cal = JUNGFRAU_CalibrationData(\n",
+    "        detector_name=karabo_id,\n",
+    "        sensor_bias_voltage=bias_voltage,\n",
+    "        event_at=creation_time,\n",
+    "        modules=karabo_da,\n",
+    "        memory_cells=memory_cells,\n",
+    "        integration_time=integration_time,\n",
+    "        gain_setting=gain_setting,\n",
+    "        gain_mode=gm,\n",
+    "        client=rest_cfg.calibration_client(),\n",
+    "    )\n",
+    "\n",
+    "    constant_names = [\"Offset10Hz\", \"BadPixelsDark10Hz\"]\n",
+    "    if relative_gain:\n",
+    "        constant_names += [\"BadPixelsFF10Hz\", \"RelativeGain10Hz\"]\n",
+    "    jf_metadata = jf_cal.metadata(calibrations=constant_names) \n",
+    "    # Display retrieved calibration constants timestamps\n",
+    "    jf_cal.display_markdown_retrieved_constants(metadata=jf_metadata)\n",
+    "    return jf_cal, jf_metadata\n",
+    "\n",
+    "def force_fixed_gain_constants():\n",
+    "    \"\"\"JF corrections in burst mode are only supported when\n",
+    "    no gain switching occurs. Always retrieve fixed gain\n",
+    "    constant for burst mode.\n",
+    "    https://git.xfel.eu/calibration/planning/-/issues/196\n",
+    "\n",
+    "    Returns:\n",
+    "        dict: The metadata with the jungfrau retrieved constants.\n",
+    "            {mod: {cname: ccv_metadata}}\n",
+    "    \"\"\"\n",
+    "    from datetime import datetime\n",
     "\n",
-    "print(f\"Integration time is {integration_time} us\")\n",
-    "print(f\"Gain setting is {gain_setting} (run settings: {ctrl_data.run_settings})\")\n",
-    "print(f\"Gain mode is {gain_mode} ({ctrl_data.run_mode})\")\n",
-    "print(f\"Bias voltage is {bias_voltage} V\")\n",
-    "print(f\"Number of memory cells are {memory_cells}\")"
+    "    from cal_tools.calcat_interface import CalCatError\n",
+    "\n",
+    "    try:\n",
+    "        jf_cal, jf_metadata = jungfrau_cal_mdata(gm=1)\n",
+    "    except CalCatError as e:\n",
+    "        warning(\n",
+    "            \"No fixed gain constants found. \"\n",
+    "            \"Looking for dynamic gain constant. \"\n",
+    "            f\"(CalCatError: {e}.\")\n",
+    "\n",
+    "    jf_cal, jf_metadata = jungfrau_cal_mdata(gm=0)\n",
+    "\n",
+    "    for mod, ccvs in jf_metadata.items():\n",
+    "        offset = ccvs.get(\"Offset10Hz\")\n",
+    "        if not offset:  # This module wont be corrected later after validating constants.\n",
+    "            continue\n",
+    "        time_difference = creation_time - datetime.fromisoformat(offset[\"begin_validity_at\"])\n",
+    "        if abs(time_difference.days) > 3:\n",
+    "            warning(\n",
+    "                f\"No dynamic gain constant retrieved for {mod} with at least\"\n",
+    "                \" 3 days time difference with the RAW data creation date.\"\n",
+    "                \" Please make sure there are available constants.\")\n",
+    "            jf_metadata[mod].pop(\"Offset10Hz\")\n",
+    "\n",
+    "    return jf_cal, jf_metadata"
    ]
   },
   {
@@ -182,32 +270,15 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "scrolled": true
+   },
    "outputs": [],
    "source": [
-    "jf_cal = JUNGFRAU_CalibrationData(\n",
-    "    detector_name=karabo_id,\n",
-    "    sensor_bias_voltage=bias_voltage,\n",
-    "    event_at=creation_time,\n",
-    "    modules=karabo_da,\n",
-    "    memory_cells=memory_cells,\n",
-    "    integration_time=integration_time,\n",
-    "    gain_setting=gain_setting,\n",
-    "    gain_mode=gain_mode,\n",
-    "    client=rest_cfg.calibration_client(),\n",
-    ")\n",
-    "\n",
-    "da_to_pdu = {}\n",
-    "for mod_info in jf_cal.physical_detector_units.values():\n",
-    "    da_to_pdu[mod_info[\"karabo_da\"]] = mod_info[\"physical_name\"]\n",
-    "\n",
-    "constant_names = [\"Offset10Hz\", \"BadPixelsDark10Hz\"]\n",
-    "if relative_gain:\n",
-    "    constant_names += [\"BadPixelsFF10Hz\", \"RelativeGain10Hz\"]\n",
-    "\n",
-    "jf_metadata = jf_cal.metadata(calibrations=constant_names)\n",
-    "# Display retrieved calibration constants timestamps\n",
-    "jf_cal.display_markdown_retrieved_constants(metadata=jf_metadata)"
+    "if force_fixed_gain_constants_flag:\n",
+    "    jf_cal, jf_metadata = force_fixed_gain_constants()\n",
+    "else:\n",
+    "    jf_cal, jf_metadata = jungfrau_cal_mdata(gain_mode)"
    ]
   },
   {
@@ -251,7 +322,12 @@
     "\n",
     "# load constants arrays after storing fragment YAML file\n",
     "# and validating constants availability.\n",
-    "const_data = jf_cal.ndarray_map(metadata=jf_metadata)"
+    "const_data = jf_cal.ndarray_map(metadata=jf_metadata)\n",
+    "\n",
+    "# For plotting\n",
+    "da_to_pdu = {}\n",
+    "for mod_info in jf_cal.physical_detector_units.values():\n",
+    "    da_to_pdu[mod_info[\"karabo_da\"]] = mod_info[\"physical_name\"]"
    ]
   },
   {
@@ -359,8 +435,13 @@
    "outputs": [],
    "source": [
     "if strixel_sensor:\n",
-    "    from cal_tools.jfstrixel import STRIXEL_SHAPE as strixel_frame_shape, double_pixel_indices, to_strixel\n",
-    "    Ydouble, Xdouble = double_pixel_indices()\n",
+    "    from cal_tools.jungfrau.jfstrixel import get_strixel_parameters, to_strixel\n",
+    "    strx_params = get_strixel_parameters(strixel_sensor)\n",
+    "\n",
+    "    strixel_shape = strx_params[\"frame_shape\"]\n",
+    "    Ydouble = strx_params.get(\"ydouble\", slice(None))\n",
+    "    Xdouble = strx_params.get(\"xdouble\", slice(None))\n",
+    "\n",
     "    print('Strixel sensor transformation enabled')"
    ]
   },
@@ -377,7 +458,7 @@
     "    \n",
     "    # Copy gain over first to keep it at the original 3 for low gain.\n",
     "    if strixel_sensor:\n",
-    "        to_strixel(g, out=gain_corr[index, ...])\n",
+    "        to_strixel(g, out=gain_corr[index, ...], kind=strixel_sensor)\n",
     "    else:\n",
     "        gain_corr[index, ...] = g\n",
     "\n",
@@ -385,6 +466,18 @@
     "    # Change low gain to 2 for indexing purposes.\n",
     "    g[g==3] = 2\n",
     "\n",
+    "    # A fix for a module hardware problem (e.g. Jungfrau_M302)\n",
+    "    # of chip being stuck on the wrong gain bit.\n",
+    "    if (\n",
+    "        wrong_gain_pixels[0] > -1 and\n",
+    "        wrong_gain_pixels[0] == int(local_karabo_da[-2:])\n",
+    "    ):\n",
+    "        x1 = wrong_gain_pixels[1]\n",
+    "        x2 = wrong_gain_pixels[2]\n",
+    "        y1 = wrong_gain_pixels[3]\n",
+    "        y2 = wrong_gain_pixels[4]\n",
+    "        g[:, x1:x2, y1:y2] = replace_wrong_gain_value\n",
+    "\n",
     "    # Select memory cells\n",
     "    if memory_cells > 1:\n",
     "        \"\"\"\n",
@@ -422,9 +515,9 @@
     "    msk = np.choose(g, np.moveaxis(mask_cell, -1, 0))\n",
     "\n",
     "    if strixel_sensor:\n",
-    "        to_strixel(d, out=data_corr[index, ...])\n",
+    "        to_strixel(d, out=data_corr[index, ...], kind=strixel_sensor)\n",
     "        data_corr[index, :, Ydouble, Xdouble] /= strixel_double_norm\n",
-    "        to_strixel(msk, out=mask_corr[index, ...])\n",
+    "        to_strixel(msk, out=mask_corr[index, ...], kind=strixel_sensor)\n",
     "    else:\n",
     "        data_corr[index, ...] = d\n",
     "        mask_corr[index, ...] = msk"
@@ -463,8 +556,12 @@
     "        roi_module, a1, a2, b1, b2, mean_axis = roi_definitions[i*6 : (i+1)*6]\n",
     "        if roi_module == module_no:\n",
     "            rois_defined += 1\n",
+    "            # Set pixels below the threshold to 0 (but still used in the averaging)\n",
+    "            roi_data = data_corr[..., a1:a2, b1:b2]\n",
+    "            if roi_threshold > -1:\n",
+    "                roi_data = roi_data * (roi_data > roi_threshold)\n",
     "            # Apply the mask and average remaining pixels to 1D\n",
-    "            roi_data = data_corr[..., a1:a2, b1:b2].mean(\n",
+    "            roi_data = roi_data.mean(\n",
     "                axis=mean_axis, where=(mask_corr[..., a1:a2, b1:b2] == 0)\n",
     "            )\n",
     "\n",
@@ -474,6 +571,7 @@
     "            # Add roi run control datasets.\n",
     "            ctrl_source.create_run_key(f'roi{rois_defined}.region', np.array([[a1, a2, b1, b2]]))\n",
     "            ctrl_source.create_run_key(f'roi{rois_defined}.reduce_axis', np.array([mean_axis]))\n",
+    "            ctrl_source.create_run_key(f'roi{rois_defined}.threshold', np.array([roi_threshold], dtype=np.float32))\n",
     "    \n",
     "    if rois_defined:\n",
     "        # Copy the index for the new source\n",
@@ -543,7 +641,7 @@
     "        \n",
     "        # Determine total output shape.\n",
     "        if strixel_sensor:\n",
-    "            oshape = (*ishape[:-2], *strixel_frame_shape)\n",
+    "            oshape = (*ishape[:-2], *strixel_shape)\n",
     "        else:\n",
     "            oshape = ishape\n",
     "\n",
@@ -772,6 +870,12 @@
     "    vmin=_corrected_vmin, vmax=_corrected_vmax, cmap=\"jet\"\n",
     ")\n",
     "\n",
+    "if strixel_sensor:\n",
+    "    if strixel_sensor == \"A1256\":\n",
+    "        aspect = 1/3\n",
+    "    else:  # A0123\n",
+    "        aspect = 10\n",
+    "\n",
     "if not strixel_sensor:\n",
     "    geom.plot_data_fast(\n",
     "        corrected_mean,\n",
@@ -780,8 +884,9 @@
     "        **mean_plot_kwargs\n",
     "    )\n",
     "else:\n",
-    "    ax.imshow(corrected_mean.squeeze(), aspect=10, **mean_plot_kwargs)\n",
-    "    \n",
+    "    corr = ax.imshow(corrected_mean.squeeze(), aspect=aspect, **mean_plot_kwargs)\n",
+    "    plt.colorbar(corr)\n",
+    "\n",
     "ax.set_title(f'{karabo_id} - Mean CORRECTED', size=18)\n",
     "\n",
     "plt.show()"
@@ -807,7 +912,8 @@
     "        **mean_plot_kwargs\n",
     "    )\n",
     "else:\n",
-    "    ax.imshow(corrected_mean.squeeze(), aspect=10, **mean_plot_kwargs)\n",
+    "    corr = ax.imshow(corrected_masked_mean.squeeze(), aspect=aspect, **mean_plot_kwargs)\n",
+    "    plt.colorbar(corr)\n",
     "\n",
     "ax.set_title(f'{karabo_id} - Mean CORRECTED with mask', size=18)\n",
     "\n",
@@ -838,7 +944,8 @@
     "        **single_plot_kwargs\n",
     "    )\n",
     "else:\n",
-    "    ax.imshow(corrected_train.squeeze(), aspect=10, **single_plot_kwargs)\n",
+    "    corr = ax.imshow(corrected_train.squeeze(), aspect=aspect, **single_plot_kwargs)\n",
+    "    plt.colorbar(corr)\n",
     "\n",
     "ax.set_title(f\"{karabo_id} - CORRECTED train: {tid}\", size=18)\n",
     "\n",
@@ -1008,7 +1115,9 @@
     "        colorbar={'shrink': 1, 'pad': 0.01},\n",
     "    )\n",
     "else:\n",
-    "    ax.imshow(np.log2(mask_train).squeeze(), vmin=0, vmax=32, cmap='jet', aspect=10)\n",
+    "    mask = ax.imshow(\n",
+    "        mask_train.squeeze(), vmin=0, vmax=32, cmap='jet', aspect=aspect)\n",
+    "    plt.colorbar(mask)\n",
     "\n",
     "plt.show()"
    ]
@@ -1016,9 +1125,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "cal2_venv",
+   "display_name": "Offline Cal",
    "language": "python",
-   "name": "cal2_venv"
+   "name": "offline-cal"
   },
   "language_info": {
    "codemirror_mode": {
@@ -1030,7 +1139,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.11"
+   "version": "3.8.10"
   }
  },
  "nbformat": 4,
diff --git a/notebooks/Jungfrau/Jungfrau_dark_analysis_all_gains_burst_mode_NBC.ipynb b/notebooks/Jungfrau/Jungfrau_dark_analysis_all_gains_burst_mode_NBC.ipynb
index e8315d3d3cfef1668f67b87d5bd71e46a9957c2c..5b4a4640028a4bada1d6729196e24d3b47959121 100644
--- a/notebooks/Jungfrau/Jungfrau_dark_analysis_all_gains_burst_mode_NBC.ipynb
+++ b/notebooks/Jungfrau/Jungfrau_dark_analysis_all_gains_burst_mode_NBC.ipynb
@@ -49,11 +49,11 @@
     "time_limits = 0.025  # to find calibration constants later on, the integration time is allowed to vary by 0.5 us\n",
     "\n",
     "# Parameters to be used for injecting dark calibration constants.\n",
-    "integration_time = 1000 # integration time in us, will be overwritten by value in file\n",
-    "gain_setting = 0  # 0 for dynamic, forceswitchg1, forceswitchg2, 1 for dynamichg0, fixgain1, fixgain2. Will be overwritten by value in file\n",
-    "gain_mode = 0  # 1 if medium and low runs are  fixgain1 and fixgain2, otherwise 0. It will be overwritten by value in file, if manual_slow_data\n",
-    "bias_voltage = 90  # sensor bias voltage in V, will be overwritten by value in file\n",
-    "memory_cells = 16  # number of memory cells\n",
+    "integration_time = -1  # Integration time in us. Set to -1 to overwrite by value in file.\n",
+    "gain_setting = -1  # 0 for dynamic, forceswitchg1, forceswitchg2, 1 for dynamichg0, fixgain1, fixgain2. Set to overwrite by value in file.\n",
+    "gain_mode = -1  # 1 if medium and low runs are  fixgain1 and fixgain2, otherwise 0. Set to -1 to overwrite by value in file.\n",
+    "bias_voltage = -1  # sensor bias voltage in V, will be overwritten by value in file\n",
+    "memory_cells = -1  # Number of memory cells.\n",
     "\n",
     "# Parameters used for plotting\n",
     "detailed_report = False\n",
@@ -90,7 +90,8 @@
     "\n",
     "from XFELDetAna.plotting.heatmap import heatmapPlot\n",
     "from XFELDetAna.plotting.histogram import histPlot\n",
-    "from cal_tools import jungfraulib, step_timing\n",
+    "from cal_tools import step_timing\n",
+    "from cal_tools.jungfrau import jungfraulib\n",
     "from cal_tools.enums import BadPixels, JungfrauGainMode\n",
     "from cal_tools.tools import (\n",
     "    get_dir_creation_date,\n",
@@ -167,22 +168,39 @@
     "\n",
     "ctrl_src = ctrl_source_template.format(karabo_id_control)\n",
     "\n",
+    "run_nums = jungfraulib.sort_runs_by_gain(\n",
+    "    raw_folder=in_folder,\n",
+    "    runs=run_nums,\n",
+    "    ctrl_src=ctrl_src,\n",
+    "    )\n",
+    "_gain_mode = None\n",
     "for gain, run_n in enumerate(run_nums):\n",
     "    run_dc = RunDirectory(f\"{in_folder}/r{run_n:04d}/\")\n",
     "    gain_runs[run_n] = [gain, run_dc]\n",
     "    ctrl_data = jungfraulib.JungfrauCtrl(run_dc, ctrl_src)\n",
     "    # Read control data for the high gain run only.\n",
-    "    if run_n == run_high:\n",
+    "    if gain == 0:\n",
     "\n",
     "        run_mcells, sc_start = ctrl_data.get_memory_cells()\n",
     "\n",
-    "        if not manual_slow_data:\n",
+    "        if integration_time < 0:\n",
     "            integration_time = ctrl_data.get_integration_time()\n",
+    "            print(f\"Integration time is {integration_time} us.\")\n",
+    "        else:\n",
+    "            print(f\"Integration time is manually set to {integration_time} us.\")\n",
+    "\n",
+    "        if bias_voltage < 0:\n",
     "            bias_voltage = ctrl_data.get_bias_voltage()\n",
+    "            print(f\"Bias voltage is {bias_voltage} V.\")\n",
+    "        else:\n",
+    "            print(f\"Bias voltage is manually set to {bias_voltage} V.\")\n",
+    "\n",
+    "        if gain_setting < 0:\n",
     "            gain_setting = ctrl_data.get_gain_setting()\n",
     "            print(f\"Gain setting is {gain_setting} ({ctrl_data.run_settings})\")\n",
-    "            print(f\"Integration time is {integration_time} us\")\n",
-    "            print(f\"Bias voltage is {bias_voltage} V\")\n",
+    "        else:\n",
+    "            print(f\"Gain setting is manually set to {gain_setting}.\")\n",
+    "\n",
     "        if run_mcells == 1:\n",
     "            memory_cells = 1\n",
     "            print('Dark runs in single cell mode, '\n",
@@ -191,25 +209,17 @@
     "            memory_cells = 16\n",
     "            print('Dark runs in burst mode, '\n",
     "                  f'storage cell start: {sc_start:02d}')\n",
-    "    else:\n",
-    "        gain_mode = ctrl_data.get_gain_mode()\n",
+    "    else:  # medium and low gain\n",
+    "        _gain_mode = ctrl_data.get_gain_mode()\n",
     "        med_low_settings.append(ctrl_data.run_mode)\n",
     "\n",
-    "# A transperent workaround for old raw data with wrong/missing medium and low settings\n",
-    "if med_low_settings == [None, None]:\n",
-    "    warning(\"run.settings is not stored in the data to read. \"\n",
-    "            f\"Hence assuming gain_mode = {gain_mode} for adaptive old data.\")\n",
-    "elif med_low_settings == [\"dynamicgain\", \"forceswitchg1\"]:\n",
-    "    warning(f\"run.settings for medium and low gain runs are wrong {med_low_settings}. \"\n",
-    "            f\"This is an expected bug for old raw data. Setting gain_mode to {gain_mode}.\")\n",
-    "# Validate that low_med_settings is not a mix of adaptive and fixed settings.\n",
-    "elif not (sorted(med_low_settings) in [fixed_settings, dynamic_settings, old_fixed_settings]):  # noqa\n",
-    "    raise ValueError(\n",
-    "        \"Medium and low run settings are not as expected. \"\n",
-    "        f\"Either {dynamic_settings}, {fixed_settings}, or {old_fixed_settings} are expected.\\n\"\n",
-    "        f\"Got {sorted(med_low_settings)} for both runs, respectively.\")\n",
-    "\n",
-    "print(f\"Gain mode is {gain_mode} ({med_low_settings})\")\n",
+    "# TODO: consider updating this cell into something similar to agipdlib.AgipdCtrlsRuns()\n",
+    "if gain_mode < 0:\n",
+    "    gain_mode = _gain_mode\n",
+    "    print(f\"Gain mode is {gain_mode} ({med_low_settings})\")\n",
+    "else:\n",
+    "    print(f\"Gain mode is manually set to {gain_mode}.\")\n",
+    "\n",
     "\n",
     "step_timer.done_step(f'Reading control data.')"
    ]
@@ -220,6 +230,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "step_timer.start()\n",
     "# set the operating condition\n",
     "condition = Conditions.Dark.jungfrau(\n",
     "    memory_cells=memory_cells,\n",
@@ -235,7 +246,8 @@
     "    constant=Constants.jungfrau.Offset(),\n",
     "    condition=condition,\n",
     "    cal_db_interface=cal_db_interface,\n",
-    "    snapshot_at=creation_time)"
+    "    snapshot_at=creation_time)\n",
+    "step_timer.done_step('Set conditions and get PDU names from CalCat.')"
    ]
   },
   {
@@ -245,6 +257,7 @@
    "outputs": [],
    "source": [
     "# Start retrieving existing constants for comparison\n",
+    "step_timer.start()\n",
     "mod_x_const = [(mod, const) for const in [\"Offset\", \"Noise\", \"BadPixelsDark\"] for mod in karabo_da]\n",
     "\n",
     "from cal_tools.tools import get_from_db\n",
@@ -285,7 +298,8 @@
     "old_retrieval_res = old_retrieval_pool.starmap_async(\n",
     "    retrieve_old_constant, mod_x_const\n",
     ")\n",
-    "old_retrieval_pool.close()"
+    "old_retrieval_pool.close()\n",
+    "step_timer.done_step('Retrieved old dark constants for comparison.')"
    ]
   },
   {
@@ -341,15 +355,23 @@
     "\n",
     "    print(f\"\\n- Instrument data path for {mod} is {instrument_src}.\")\n",
     "\n",
+    "    # (1024, 512, 1 or 16, 3)\n",
     "    offset_map[mod] = context.alloc(\n",
     "        shape=(sensor_size+(memory_cells, 3)), fill=0, dtype=np.float32)\n",
     "    noise_map[mod] = context.alloc(like=offset_map[mod], fill=0)\n",
-    "    bad_pixels_map[mod] = context.alloc(like=offset_map[mod], dtype=np.uint32, fill=0)\n",
+    "    bad_pixels_map[mod] = context.alloc(shape=offset_map[mod].shape, dtype=np.uint32, fill=0)\n",
     "\n",
     "    for run_n, [gain, run_dc] in gain_runs.items():\n",
     "\n",
     "        def process_cell(worker_id, array_index, cell_number):\n",
     "            cell_slice_idx = acelltable == cell_number\n",
+    "            if cell_slice_idx.sum() == 0:\n",
+    "                # This cell is not in the data (or it's deliberated excluded)\n",
+    "                bad_pixels_map[mod][..., cell_number, gain] = BadPixels.NO_DARK_DATA.value\n",
+    "                offset_map[mod][..., cell_number, gain] = np.nan\n",
+    "                noise_map[mod][..., cell_number, gain] = np.nan\n",
+    "                return\n",
+    "\n",
     "            thiscell = images[..., cell_slice_idx]  # [1024, 512, n_trains]\n",
     "\n",
     "            # Identify cells/trains with images of 0 pixels.\n",
@@ -363,6 +385,7 @@
     "            noise_map[mod][..., cell_number, gain] = np.std(  # [1024, 512]\n",
     "                thiscell, axis=2, dtype=np.float32)\n",
     "            del thiscell\n",
+    "\n",
     "            # Check if there are wrong bad gain values.\n",
     "            # 1. Exclude empty images.\n",
     "            # 2. Indicate pixels with wrong gain value for any train for each cell.\n",
@@ -372,8 +395,8 @@
     "                axis=2, dtype=np.float32\n",
     "            )\n",
     "\n",
-    "            # [1024, 512]\n",
-    "            bad_pixels_map[mod][..., cell_number, gain][gain_avg != raw_g] |= BadPixels.WRONG_GAIN_VALUE.value\n",
+    "            # Assign WRONG_GAIN_VALUE for a pixel in a badpixel map for all gains.\n",
+    "            bad_pixels_map[mod][:, :,cell_number][gain_avg != raw_g] |= BadPixels.WRONG_GAIN_VALUE.value\n",
     "\n",
     "        print(f\"Gain stage {gain}, run {run_n}\")\n",
     "\n",
@@ -410,7 +433,12 @@
     "            acelltable -= sc_start\n",
     "        # Only for dynamic medium and low gain runs [forceswitchg1, forceswitchg2] in burst mode.\n",
     "\n",
-    "        if gain_mode == 0 and gain > 0 and memory_cells == 16:\n",
+    "        if (\n",
+    "            gain_mode == 0 and  # dynamic gain mode\n",
+    "            gain > 0 and  # Medium and low runs\n",
+    "            memory_cells == 16 and  # Burst mode\n",
+    "            acelltable.shape[0] == 2  # forceswitchg1 and forceswitchg2 acquired with the MDL device.\n",
+    "        ):\n",
     "            # 255 similar to the receiver which uses the 255\n",
     "            # value to indicate a cell without an image.\n",
     "            # image shape for forceswitchg1 and forceswitchg2 = (1024, 512, 2, trains)\n",
@@ -419,10 +447,16 @@
     "\n",
     "        # Calculate offset and noise maps\n",
     "        context.map(process_cell, range(memory_cells))\n",
+    "        \n",
+    "        cells_missing = (bad_pixels_map[mod][0, 0, :, gain] & BadPixels.NO_DARK_DATA) > 0\n",
+    "        if np.any(cells_missing):\n",
+    "            print(f\"No dark data in gain stage {gain} found for cells\", np.nonzero(cells_missing)[0])\n",
+    "\n",
     "        del images\n",
     "        del acelltable\n",
     "        del gain_vals\n",
-    "    step_timer.done_step(f'Creating Offset and noise constants for a module.')"
+    "\n",
+    "    step_timer.done_step('Creating Offset and noise constants for a module.')"
    ]
   },
   {
@@ -501,7 +535,7 @@
     "                ax_n0.set_xlabel(\n",
     "                    f'RMS noise {g_name[g_idx]} ' + unit, fontsize=15)\n",
     "                plt.show()\n",
-    "    step_timer.done_step(f'Plotting offset and noise maps.')"
+    "    step_timer.done_step('Plotting offset and noise maps.')"
    ]
   },
   {
@@ -535,6 +569,7 @@
     "print_bp_entry(BadPixels.OFFSET_OUT_OF_THRESHOLD)\n",
     "print_bp_entry(BadPixels.NOISE_OUT_OF_THRESHOLD)\n",
     "print_bp_entry(BadPixels.OFFSET_NOISE_EVAL_ERROR)\n",
+    "print_bp_entry(BadPixels.NO_DARK_DATA)\n",
     "print_bp_entry(BadPixels.WRONG_GAIN_VALUE)\n",
     "\n",
     "def eval_bpidx(d):\n",
@@ -583,7 +618,7 @@
     "                    aspect=1.,\n",
     "                    vmin=0, vmax=5,\n",
     "                    title=f'G{g_idx} Bad pixel map - Cell {cell:02d} - Module {mod} ({pdu})')\n",
-    "step_timer.done_step(f'Creating bad pixels constant')"
+    "step_timer.done_step('Creating bad pixels constant')"
    ]
   },
   {
@@ -715,9 +750,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Offline Cal",
    "language": "python",
-   "name": "python3"
+   "name": "offline-cal"
   },
   "language_info": {
    "codemirror_mode": {
@@ -729,7 +764,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.12"
+   "version": "3.8.10"
   }
  },
  "nbformat": 4,
diff --git a/notebooks/REMI/REMI_Digitize_and_Transform.ipynb b/notebooks/REMI/REMI_Digitize_and_Transform.ipynb
index f1653cf4e660c7202e1198b083d8072dce592553..5dae80017da0519cea7136740ac5334546911389 100644
--- a/notebooks/REMI/REMI_Digitize_and_Transform.ipynb
+++ b/notebooks/REMI/REMI_Digitize_and_Transform.ipynb
@@ -13,12 +13,6 @@
     "\n",
     "calib_config_path = '/gpfs/exfel/exp/SQS/202101/p002535/usr/config_board2+4.yaml'  # Path to correction and transform configuration\n",
     "\n",
-    "# These parameters are required by xfel-calibrate but ignored in this notebook.\n",
-    "cycle = ''  # Proposal cycle, currently not used.\n",
-    "cal_db_timeout = 0  # Calibration DB timeout, currently not used.\n",
-    "cal_db_interface = 'foo'  # Calibration DB interface, currently not used.\n",
-    "karabo_da = 'bar'  # Karabo data aggregator name, currently not used\n",
-    "\n",
     "# Output parameters.\n",
     "karabo_id = 'SQS_REMI_DLD6'  # Karabo device ID root for virtual output device.\n",
     "proposal = ''  # Proposal, leave empty for auto detection based on in_folder\n",
@@ -26,11 +20,6 @@
     "out_seq_len = 5000  # Number of trains per sequence file in output.\n",
     "det_device_id = '{karabo_id}/DET/{det_name}'  # Karabo device ID for virtual output device.\n",
     "det_output_key = 'output'  # Pipeline name for fast data output.\n",
-    "save_raw_triggers = True  # Whether to save trigger position in files.\n",
-    "save_raw_edges = True  # Whether to save digitized edge positions in files.\n",
-    "save_raw_amplitudes = True  # Whether to save analog pulse amplitudes in files.\n",
-    "save_rec_signals = True  # Whether to save reconstructed signals (u1-w2, mcp) in files.\n",
-    "save_rec_hits = True  # Whether to save reoncstructed hits (x,y,t,m) in files.\n",
     "chunks_triggers = [500]  # HDF chunk size for triggers.\n",
     "chunks_edges = [500, 7, 50]  # HDF chunk size for edges.\n",
     "chunks_amplitudes = [500, 7, 50]  # HDF chunk size for amplitudes.\n",
@@ -46,6 +35,7 @@
     "ppt_source = 'SQS_RR_UTC/TSYS/TIMESERVER:outputBunchPattern'\n",
     "ignore_fel = False  # Ignore any FEL entries in the PPT.\n",
     "ignore_ppl = False  # Ignore any PPL entries in the PPT.\n",
+    "trailing_trigger = False  # Add a trigger after all regular pulses with the remaining trace.\n",
     "ppl_offset = 0  # In units of the PPT.\n",
     "laser_ppt_mask = -1  # Bit mask for used laser, negative to auto-detect from instrument. \n",
     "instrument_sase = 3  # Which SASE we're running at for PPT decoding.\n",
@@ -64,7 +54,19 @@
     "mp_find_triggers = 0.5  # Parallelization for finding triggers.\n",
     "mp_find_edges = 0.5  # Parallelization for digitizing analog signal.\n",
     "mt_avg_trace = 2  # Parallelization for trace averaging.\n",
-    "mp_rec_hits = 1.0  # Parallelization for hit reconstruction."
+    "mp_rec_hits = 1.0  # Parallelization for hit reconstruction.\n",
+    "\n",
+    "# DEPRECATED AND IGNORED\n",
+    "# Left for compatibility with webservice or legacy configuration.\n",
+    "cycle = ''  # Proposal cycle, passed by webservice but not used.\n",
+    "karabo_da = 'bar'  # Karabo data aggregator name, passed by webservice but not used\n",
+    "cal_db_timeout = 0  # Calibration DB timeout, passed by webservice but not used.\n",
+    "cal_db_interface = 'foo'  # Calibration DB interface, passed by webservice but not used.\n",
+    "save_raw_triggers = True  # Whether to save trigger position in files, ignored and always enabled.\n",
+    "save_raw_edges = True  # Whether to save digitized edge positions in files, ignored and always enabled.\n",
+    "save_raw_amplitudes = True  # Whether to save analog pulse amplitudes in files, ignored and always enabled.\n",
+    "save_rec_signals = True  # Whether to save reconstructed signals (u1-w2, mcp) in files, ignored and always enabled.\n",
+    "save_rec_hits = True  # Whether to save reoncstructed hits (x,y,t,m) in files, ignored and always enabled."
    ]
   },
   {
@@ -81,13 +83,17 @@
     "import numpy as np\n",
     "import matplotlib.pyplot as plt\n",
     "from matplotlib.colors import LogNorm\n",
+    "from matplotlib.patches import Circle\n",
     "from threadpoolctl import threadpool_limits\n",
     "\n",
+    "import tabulate\n",
+    "from IPython.display import Latex, Markdown, display\n",
+    "\n",
     "import h5py\n",
     "\n",
     "import pasha as psh\n",
     "from euxfel_bunch_pattern import indices_at_sase, indices_at_laser\n",
-    "from extra_data import RunDirectory\n",
+    "from extra_data import RunDirectory, by_id\n",
     "from extra_remi import Analysis, trigger_dt\n",
     "from extra_remi.util import timing\n",
     "from extra_remi.rd_resort import signal_dt, hit_dt\n",
@@ -131,9 +137,26 @@
     "\n",
     "remi = Analysis(calib_config_path, use_hex=not quad_anode)\n",
     "\n",
+    "# Collect required sources and keys required.\n",
+    "sourcekeys = set()\n",
+    "for det_name in remi['detector'].keys():\n",
+    "    sourcekeys |= remi.get_detector_sourcekeys(det_name)\n",
+    "        \n",
+    "if not reconstruct_ppt:\n",
+    "    sourcekeys.add((ppt_source, 'data.bunchPatternTable'))\n",
+    "\n",
     "with timing('open_run'):\n",
-    "    dc = remi.prepare_dc(RunDirectory(Path(in_folder) / f'r{run:04d}', inc_suspect_trains=True),\n",
-    "                         require_ppt=not reconstruct_ppt)"
+    "    # Initial opening of input data.\n",
+    "    base_dc = RunDirectory(Path(in_folder) / f'r{run:04d}', inc_suspect_trains=True)\n",
+    "    \n",
+    "with timing('select_data'):\n",
+    "    # Filter down to those trains with data for all required sources.\n",
+    "    filter_run = base_dc.select(sourcekeys, require_all=True)\n",
+    "\n",
+    "# Re-select entire data collection to the trains with data.\n",
+    "dc = base_dc.select_trains(by_id[filter_run.train_ids])\n",
+    "base_dc = None\n",
+    "filter_run = None"
    ]
   },
   {
@@ -143,21 +166,110 @@
     "# Transformation parameters"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Additional parameters through the user-side configuration file for analog channels and detector settings. Parameters that are deprecated and ignored, but present in the file, are excluded."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "def print_leaf(leaf, indent=0):\n",
+    "def print_leaf(leaf, indent=0, ignored_keys={}):\n",
     "    for key, value in leaf.items():\n",
+    "        if key in ignored_keys:\n",
+    "            continue\n",
+    "        \n",
     "        if isinstance(value, dict):\n",
     "            print(indent * 4 * ' ' + key)\n",
-    "            print_leaf(value, indent=indent+1)\n",
+    "            print_leaf(value, indent=indent+1, ignored_keys=ignored_keys)\n",
     "        else:\n",
     "            print(indent * 4 * ' ' + f'{key}: {value}')\n",
-    "        \n",
-    "print_leaf(remi.tree)"
+    "\n",
+    "print(calib_config_path.resolve())\n",
+    "print_leaf(remi.tree, ignored_keys={'instrument', 'trigger'})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "discr_table = []\n",
+    "\n",
+    "if quad_anode:\n",
+    "    signals = ['u1', 'u2', 'v1', 'v2', 'mcp']\n",
+    "    wire_angles = [np.pi*(3/4), np.pi*(1/4)]\n",
+    "else:\n",
+    "    signals = ['u1', 'u2', 'v1', 'v2', 'w1', 'w2', 'mcp']\n",
+    "    wire_angles = [np.pi*(3/4), np.pi*(3/4+1/3), np.pi*(3/4+2/3)]\n",
+    "    \n",
+    "N = 15\n",
+    "shifts = np.linspace(-0.4, 0.4, N)\n",
+    "\n",
+    "for det_name, cur_det in remi['detector'].items():\n",
+    "    fig = plt.figure(num=f'wiring_{det_name}', figsize=(9, 5))\n",
+    "    fig.text(0.5, 1.0, det_name, ha='center', va='top', size='xx-large')\n",
+    "    ax = fig.add_axes([0.0, 0.0, 1.0, 1.0])\n",
+    "    ax.set_axis_off()\n",
+    "\n",
+    "    ax.add_patch(Circle((0,0), 1, ec='black', fc='none', lw=2))\n",
+    "    ax.set_xlim(-1.5*(9/5), 1.5*(9/5))\n",
+    "    ax.set_ylim(-1.5, 1.5)\n",
+    "\n",
+    "    _, params = remi.get_discriminator(cur_det['channels'])\n",
+    "    discr_header = params[0].keys()\n",
+    "\n",
+    "    for channel_idx in range(len(signals)):\n",
+    "        index = cur_det['indices'].index(channel_idx)\n",
+    "        discr_table.append((det_name, signals[channel_idx],\n",
+    "                            cur_det['channels'][index],\n",
+    "                            remi['digitizer']['discriminator'],\n",
+    "                            *params[index].values()))\n",
+    "\n",
+    "    for j, start_angle in enumerate(wire_angles):\n",
+    "        x1 = np.cos(start_angle+np.pi/4)\n",
+    "        x2 = np.cos(start_angle+5*np.pi/4)\n",
+    "\n",
+    "        y1 = np.sin(start_angle+np.pi/4)\n",
+    "        y2 = np.sin(start_angle+5*np.pi/4)\n",
+    "\n",
+    "        channel = cur_det['channels'][cur_det['indices'].index(2*j)]\n",
+    "        ax.text(x1*1.2, y1*1.2, f'{signals[2*j]}\\n{channel}',\n",
+    "                c=f'C{j}', fontsize='xx-large', va='center', ha='center')\n",
+    "\n",
+    "        channel = cur_det['channels'][cur_det['indices'].index(2*j+1)]\n",
+    "        ax.text(x2*1.2, y2*1.2, f'{signals[2*j+1]}\\n{channel}',\n",
+    "                c=f'C{j}', fontsize='xx-large', va='center', ha='center')\n",
+    "\n",
+    "        for k, shift in enumerate(shifts):\n",
+    "            x1 = np.cos(start_angle+np.pi/4+shifts[k])\n",
+    "            x2 = np.cos(start_angle+5*np.pi/4+shifts[N-k-1])\n",
+    "\n",
+    "            y1 = np.sin(start_angle+np.pi/4+shifts[k])\n",
+    "            y2 = np.sin(start_angle+5*np.pi/4+shifts[N-k-1])\n",
+    "\n",
+    "            ax.plot([x1, x2], [y1, y2], c=f'C{j}')\n",
+    "\n",
+    "    mcp_angle = np.pi/6\n",
+    "    channel = cur_det['channels'][cur_det['indices'].index(6)]\n",
+    "    ax.text(1.4*np.cos(mcp_angle), 1.2*np.sin(mcp_angle), f'mcp\\n{channel}',\n",
+    "            c='k', fontsize='xx-large', va='center', ha='center')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "display(Latex(tabulate.tabulate(\n",
+    "    discr_table, tablefmt='latex', headers=['', '', '', 'discriminator', *discr_header])))"
    ]
   },
   {
@@ -244,7 +356,7 @@
     "    \n",
     "    ppt_data = FakeKeyDataFunctor(fake_ppt, dc.train_ids)\n",
     "    \n",
-    "    fig, ax = plt.subplots(num=99, figsize=(9, 6), clear=True, ncols=1, nrows=1)\n",
+    "    fig, ax = plt.subplots(num='reconstructed_ppt_triggers', figsize=(9, 6), clear=True, ncols=1, nrows=1)\n",
     "\n",
     "    ax.set_title('Edge trigger signal')\n",
     "    ax.plot(trigger_trace, lw=1, label=f'Mean {trigger_edge_channel} trace')\n",
@@ -256,7 +368,8 @@
     "    ax.legend()\n",
     "    \n",
     "else:\n",
-    "    ppt_data = dc[ppt_source, 'data.bunchPatternTable']"
+    "    ppt_data = dc[ppt_source, 'data.bunchPatternTable']\n",
+    "    print(f'Pulse pattern entries for {(ppt_data.data_counts() > 0).sum()} trains')"
    ]
   },
   {
@@ -316,6 +429,11 @@
     "\n",
     "    # Fill any missing values with the highest.\n",
     "    pulse_counts[has_ppt == False] = pulse_counts.max()\n",
+    "    \n",
+    "    if trailing_trigger:\n",
+    "        # Add a single count to every train for trailing trigger.\n",
+    "        warning('Trailing trigger active, all pulse counts are one higher than expected')\n",
+    "        pulse_counts += 1\n",
     "\n",
     "    # Compute offsets based on pulse counts.\n",
     "    pulse_offsets = np.zeros_like(pulse_counts)\n",
@@ -333,7 +451,7 @@
    },
    "outputs": [],
    "source": [
-    "fig, ax = plt.subplots(num=1, ncols=1, nrows=1, figsize=(9, 4), clear=True)\n",
+    "fig, ax = plt.subplots(num='pulse_counts', ncols=1, nrows=1, figsize=(9, 4), clear=True)\n",
     "\n",
     "ax.set_title('Pulse count')\n",
     "ax.plot(dc.train_ids, pulse_counts, lw=1)\n",
@@ -348,9 +466,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Find triggers\n",
-    "\n",
-    "The trigger defines the boundary of a pulse on the digitizer trace, which is stored per train."
+    "### Find triggers"
    ]
   },
   {
@@ -375,98 +491,84 @@
     "\n",
     "clock_factor = remi['digitizer']['clock_factor']\n",
     "\n",
+    "min_trace_len = min([\n",
+    "    dc[src, key].entry_shape[0] for det_name in remi['detector'].keys()\n",
+    "    for src, key in remi.get_detector_sourcekeys(det_name)\n",
+    "])\n",
+    "\n",
     "def trigger_by_ppt(worker_id, index, train_id, ppt):\n",
     "    all_pos, fel_pos, ppl_pos = get_pulse_positions(ppt, instrument_sase, laser_ppt_mask, ppl_offset)\n",
     "    num_pulses = len(all_pos)\n",
     "    \n",
-    "    if num_pulses == 0:\n",
-    "        return\n",
-    "    elif len(ppl_pos) == 0 and ppl_offset < 0:\n",
-    "        # No PPL pulses, but a negative offset is configured. This will cause\n",
-    "        # first_pulse_offset to start early and most likely miss pulses at the\n",
-    "        # end, so we correct by adding the ppl_offset to relative positions\n",
-    "        # when computing trace positions.\n",
-    "        pos_corr = abs(ppl_offset)\n",
-    "    else:\n",
-    "        pos_corr = 0\n",
-    "        \n",
+    "    if num_pulses > 0:\n",
+    "        if len(ppl_pos) == 0 and ppl_offset < 0:\n",
+    "            # No PPL pulses, but a negative offset is configured. This will cause\n",
+    "            # first_pulse_offset to start early and most likely miss pulses at the\n",
+    "            # end, so we correct by adding the ppl_offset to relative positions\n",
+    "            # when computing trace positions.\n",
+    "            pos_corr = abs(ppl_offset)\n",
+    "        else:\n",
+    "            pos_corr = 0\n",
     "\n",
-    "    rel_pos = all_pos - all_pos[0]\n",
+    "        rel_pos = all_pos - all_pos[0]\n",
     "\n",
-    "    if num_pulses > 1:\n",
-    "        pulse_len = np.unique(rel_pos[1:] - rel_pos[:-1]).min()\n",
-    "    elif num_pulses == 1:\n",
-    "        pulse_len = single_pulse_length\n",
+    "        if num_pulses > 1:\n",
+    "            pulse_len = np.unique(rel_pos[1:] - rel_pos[:-1]).min()\n",
+    "        elif num_pulses == 1:\n",
+    "            pulse_len = single_pulse_length\n",
     "\n",
-    "    start_frac = first_pulse_offset + (rel_pos + pos_corr) * 2 * clock_factor\n",
-    "    start_int = start_frac.astype(int)\n",
+    "        start_frac = first_pulse_offset + (rel_pos + pos_corr) * 2 * clock_factor\n",
+    "        start_int = start_frac.astype(int)\n",
     "\n",
-    "    pulse_offset = pulse_offsets[index]\n",
-    "    pulse_count = pulse_counts[index]\n",
+    "        train_triggers = triggers[pulse_offsets[index]:int(pulse_offsets[index]+num_pulses)]\n",
+    "        train_triggers['start'] = start_int + pulse_start_offset\n",
+    "        train_triggers['stop'] = start_int + int(pulse_len * 2 * clock_factor) - 1 + pulse_end_offset\n",
+    "        train_triggers['offset'] = start_frac - start_int\n",
+    "        train_triggers['pulse'] = all_pos.astype(np.int16)\n",
+    "        train_triggers['fel'] = [pos in fel_pos for pos in all_pos]\n",
+    "        train_triggers['ppl'] = [pos in ppl_pos for pos in all_pos]\n",
     "        \n",
-    "    train_triggers = triggers[pulse_offset:pulse_offset+pulse_count]\n",
-    "    train_triggers['start'] = start_int + pulse_start_offset\n",
-    "    train_triggers['stop'] = start_int + int(pulse_len * 2 * clock_factor) - 1 + pulse_end_offset\n",
-    "    train_triggers['offset'] = start_frac - start_int\n",
-    "    train_triggers['pulse'] = all_pos.astype(np.int16)\n",
-    "    train_triggers['fel'] = [pos in fel_pos for pos in all_pos]\n",
-    "    train_triggers['ppl'] = [pos in ppl_pos for pos in all_pos]\n",
-    "\n",
-    "    \n",
-    "if ignore_fel and ignore_ppl:\n",
-    "    # Both FEL and PPL are ignored, use virtual full train triggers.\n",
-    "    print('WARNING: Both FEL and PPL pulses are ignored, '\n",
-    "          'virtual trigger is inserted covering the entire train')\n",
-    "    \n",
-    "    # Overwrite global pulse statistics computed before,\n",
-    "    num_pulses = len(dc.train_ids)\n",
-    "    triggers = np.empty(num_pulses, dtype=trigger_dt)\n",
-    "    \n",
-    "    pulse_counts[:] = 1\n",
-    "    pulse_counts = pulse_counts.astype(np.int32)\n",
-    "    pulse_offsets = np.arange(len(pulse_counts)).astype(np.int32)\n",
-    "\n",
-    "    # Obtain minimal trace length.\n",
-    "    min_trace_len = min([\n",
-    "        dc[src, key].entry_shape[0]\n",
-    "        for det_name in remi['detector'].keys()\n",
-    "        for src, key in remi.get_detector_sourcekeys(det_name)\n",
-    "    ])\n",
-    "\n",
-    "    triggers['start'] = first_pulse_offset\n",
-    "    triggers['stop'] = min_trace_len\n",
-    "    triggers['offset'] = 0.0\n",
-    "    triggers['pulse'] = -1\n",
-    "    triggers['fel'] = False\n",
-    "    triggers['ppl'] = False    \n",
-    "    \n",
-    "else:\n",
-    "    with timing('find_triggers'):\n",
-    "        psh.map(trigger_by_ppt, ppt_data)\n",
+    "        last_sample = train_triggers['stop'].max()\n",
+    "        \n",
+    "    else:\n",
+    "        last_sample = first_pulse_offset\n",
+    "        \n",
+    "    if trailing_trigger:\n",
+    "        # Add trailing trigger if required.\n",
+    "        trigger = triggers[int(pulse_offsets[index]+pulse_counts[index]-1)]\n",
+    "        trigger['start'] = last_sample\n",
+    "        trigger['stop'] = min_trace_len\n",
+    "        trigger['offset'] = 0.0\n",
+    "        trigger['pulse'] = -1\n",
+    "        trigger['fel'] = False\n",
+    "        trigger['ppl'] = False\n",
+    "\n",
+    "with timing('find_triggers'):\n",
+    "    psh.map(trigger_by_ppt, ppt_data)\n",
     "    \n",
-    "    if (np.unique(triggers['pulse'][1:] - triggers['pulse'][:-1]) > 0).sum() > 1:\n",
-    "        # There is more than one delta between pulse entries across all pulses. This is not\n",
-    "        # necessarily a problem, as the pattern could simply have changed in between trains\n",
-    "        # with each train being split properly.\n",
-    "        # If there's more than one delta in a single train, this likely points to a mismatch\n",
-    "        # of FEL and PPL repetition rate. This is most likely not intended.\n",
-    "\n",
-    "        one = np.uint64(1)  # Because np.uint64 + int = np.float64\n",
-    "        pulse_deltas = set()\n",
-    "\n",
-    "        for pulse_id, (offset, count) in enumerate(zip(pulse_offsets, pulse_counts)):\n",
-    "            deltas = triggers['pulse'][offset+one:offset+count] - triggers['pulse'][offset:offset+count-one]\n",
-    "\n",
-    "            if len(np.unique(deltas)) > 1:\n",
-    "                for delta in deltas:\n",
-    "                    pulse_deltas.add(delta)\n",
-    "\n",
-    "        if len(pulse_deltas) > 1:\n",
-    "            delta_str = ', '.join([str(x) for x in sorted(pulse_deltas)])\n",
-    "            warning(f'Different pulse lengths (PPT: {delta_str}) encountered within single trains, '\n",
-    "                    f'separated pulse spectra may split up signals!')\n",
-    "        else:\n",
-    "            warning('Different pulse lengths encountered across trains, separation may be unstable!')"
+    "if (np.unique(triggers['pulse'][1:] - triggers['pulse'][:-1]) > 0).sum() > 1:\n",
+    "    # There is more than one delta between pulse entries across all pulses. This is not\n",
+    "    # necessarily a problem, as the pattern could simply have changed in between trains\n",
+    "    # with each train being split properly.\n",
+    "    # If there's more than one delta in a single train, this likely points to a mismatch\n",
+    "    # of FEL and PPL repetition rate. This is most likely not intended.\n",
+    "\n",
+    "    one = np.uint64(1)  # Because np.uint64 + int = np.float64\n",
+    "    pulse_deltas = set()\n",
+    "\n",
+    "    for pulse_id, (offset, count) in enumerate(zip(\n",
+    "        pulse_offsets, pulse_counts - one if trailing_trigger else pulse_counts\n",
+    "    )):\n",
+    "        deltas = triggers['pulse'][offset+one:offset+count] - triggers['pulse'][offset:offset+count-one]\n",
+    "\n",
+    "        if len(np.unique(deltas)) > 1:\n",
+    "            for delta in deltas:\n",
+    "                pulse_deltas.add(delta)\n",
+    "\n",
+    "    if len(pulse_deltas) > 1:\n",
+    "        delta_str = ', '.join([str(x) for x in sorted(pulse_deltas)])\n",
+    "        warning(f'Different pulse lengths (PPT: {delta_str}) encountered within single trains, '\n",
+    "                f'separated pulse spectra may split up signals!')"
    ]
   },
   {
@@ -475,7 +577,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "fig, (lx, rx) = plt.subplots(num=2, ncols=2, nrows=1, figsize=(9, 4), clear=True,\n",
+    "fig, (lx, rx) = plt.subplots(num='trigger_positions', ncols=2, nrows=1, figsize=(9, 4), clear=True,\n",
     "                             gridspec_kw=dict(top=0.75))\n",
     "\n",
     "# Display ~400 pulses or 10 trains, whatever is lower\n",
@@ -520,6 +622,13 @@
     "pass"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The trigger defines the boundary of each pulse on the digitizer trace acquired by train. The starting position in samples of each found trigger is shown for the first few trains in detail on the left and all trains on the right."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -547,7 +656,7 @@
     "\n",
     "det_data = {}\n",
     "\n",
-    "for i, (det_name, det) in enumerate(remi['detector'].items()):\n",
+    "for det_name, det in remi['detector'].items():\n",
     "    det_sourcekeys = remi.get_detector_sourcekeys(det_name)\n",
     "    det_get_traces = remi.get_traces_getter(det_name)\n",
     "    trace_len = dc[next(iter(det_sourcekeys))].entry_shape[0]\n",
@@ -565,7 +674,8 @@
     "        source_name = remi['digitizer']['source']\n",
     "        bl_start, bl_stop, _ = remi.get_baseline_limits(trace_len)\n",
     "        bl_sym = remi['digitizer']['baseline_symmetry']\n",
-    "        time_cal = remi.get_time_calibration()\n",
+    "        \n",
+    "        time_cal = 1e9 / (2 * remi['digitizer']['clock_factor'] * (1.3e9 / 288))\n",
     "        \n",
     "        traces_corr = np.empty((7, trace_len), dtype=np.float64)\n",
     "        baselines = np.empty(bl_sym, dtype=np.float64)\n",
@@ -596,6 +706,9 @@
     "            ):\n",
     "                discr_func(trace[trigger_slice], edges=channel_edges,\n",
     "                           amplitudes=channel_amplitudes, **channel_params)\n",
+    "\n",
+    "            if np.isfinite(pulse_edges).sum(axis=1).max() == det['max_hits']:\n",
+    "                warning(f'Maximum number of edges reached in train {train_id}, pulse: {trigger[\"pulse\"]}')\n",
     "            \n",
     "    with timing(f'find_edges, {det_name}'):\n",
     "        psh.map(find_edges, dc.select(det_sourcekeys))\n",
@@ -603,15 +716,18 @@
     "    if not np.isfinite(edges).any():\n",
     "        warning(f'No edges found for {det_name}')\n",
     "    \n",
-    "    fig, (ux, bx) = plt.subplots(num=110+i, ncols=1, nrows=2, figsize=(9.5, 8), clear=True,\n",
+    "    fig, (ux, bx) = plt.subplots(num=f'digitize_result_{det_name}', ncols=1, nrows=2, figsize=(9.5, 8), clear=True,\n",
     "                                 gridspec_kw=dict(left=0.1, right=0.98, top=0.98, bottom=0.1, hspace=0.25))\n",
     "    \n",
     "    fig.text(0.02, 0.98, det_name.upper(), rotation=90, ha='left', va='top', size='x-large')\n",
+    "    \n",
+    "    max_num = 0\n",
     "\n",
     "    for edge_idx, edge_name in enumerate(['u1', 'u2', 'v1', 'v2', 'w1', 'w2', 'mcp']):\n",
-    "        ux.hist(finite_flattened_slice(amplitudes, np.s_[:, edge_idx, :]),\n",
-    "                bins=1000, range=(0, 2048), histtype='step', lw=1,\n",
-    "                color=f'C{edge_idx}' if edge_idx < 6 else 'k', label=edge_name)\n",
+    "        n, _, _ = ux.hist(finite_flattened_slice(amplitudes, np.s_[:, edge_idx, :]),\n",
+    "                          bins=1000, range=(0, 4096), histtype='step', lw=1,\n",
+    "                          color=f'C{edge_idx}' if edge_idx < 6 else 'k', label=edge_name)\n",
+    "        max_num = max(max_num, n.max())\n",
     "        \n",
     "        cur_edges = finite_flattened_slice(edges, np.s_[:, edge_idx, :])\n",
     "        bx.hist(cur_edges - np.floor(cur_edges), bins=500, range=(0, 1), histtype='step',\n",
@@ -621,8 +737,12 @@
     "    ux.set_title('Pulse height distributions')\n",
     "    ux.set_xlabel('Pulse height')\n",
     "    ux.set_yscale('log')\n",
-    "    ux.set_xlim(0, 2048)\n",
-    "    ux.set_ylim(10, 1.5*ux.get_xlim()[1])\n",
+    "    ux.set_xlim(0, 4096)\n",
+    "    ux.set_ylim(10, 1.5*max(max_num, 10))\n",
+    "    \n",
+    "    if remi['digitizer']['discriminator'] == 'cfd':\n",
+    "        ux.text(1024, 12.5, 'No pulse height feedback for constant fraction discrimination',\n",
+    "                ha='center', va='center')\n",
     "    \n",
     "    bx.set_title('Fractional edge distributions')\n",
     "    bx.set_xlabel('Edge positions - ⌊edge positions⌋')\n",
@@ -642,6 +762,17 @@
     "    }"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The analog signal is digitized into discrete edges using a fast timing discriminator. The result of this operation is available in files in the `raw.triggers` dataset.\n",
+    "\n",
+    "The pulse height distribution is an integral view about the chosen digitization thresholds. For more detail, please refer to the spectral pulse height distributions further below.\n",
+    "\n",
+    "The fractional edge distribution visualizes the interpolated component of edge positions, i.e. between discrete digitizer samples. This should in general be flat, in particular a convex shape indicates poor interpolation due to too fast rise times."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -655,8 +786,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "for i, det_name in enumerate(remi['detector'].keys()):\n",
-    "    fig, axs = plt.subplots(num=10+i, nrows=7, figsize=(9.5, 8), clear=True,\n",
+    "for det_name in remi['detector'].keys():\n",
+    "    fig, axs = plt.subplots(num=f'global_average_{det_name}', nrows=7, figsize=(9.5, 8), clear=True,\n",
     "                            gridspec_kw=dict(left=0.1, right=0.98, top=0.98, bottom=0.1))\n",
     "    fig.text(0.02, 0.98, det_name.upper(), rotation=90, ha='left', va='top', size='x-large')\n",
     "\n",
@@ -682,10 +813,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "for i, det_name in enumerate(remi['detector'].keys()):\n",
+    "for det_name in remi['detector'].keys():\n",
     "    edges = det_data[det_name]['edges']\n",
     "    \n",
-    "    fig = plt.figure(num=100+i, figsize=(9.5, 8))\n",
+    "    fig = plt.figure(num=f'edge_samples_{det_name}', figsize=(9.5, 8))\n",
     "    grid = fig.add_gridspec(ncols=2, nrows=4, left=0.1, right=0.98, top=0.98, bottom=0.1)\n",
     "\n",
     "    fig.text(0.02, 0.98, det_name.upper(), rotation=90, ha='left', va='top', size='x-large')\n",
@@ -746,10 +877,11 @@
    },
    "outputs": [],
    "source": [
-    "for i, det_name in enumerate(remi['detector'].keys()):\n",
-    "    fig = plt.figure(num=20+i, figsize=(9.5, 6))\n",
+    "for det_name in remi['detector'].keys():\n",
+    "    fig = plt.figure(num=f'digitized_spectra_{det_name}', figsize=(9.5, 6))\n",
     "    \n",
     "    edges = det_data[det_name]['edges']\n",
+    "    amplitudes = det_data[det_name]['amplitudes']\n",
     "    \n",
     "    min_edge = np.nanmin(edges)\n",
     "    max_edge = np.nanmax(edges)\n",
@@ -809,6 +941,63 @@
     "pass"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Spectral pulse height distributions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for det_name in remi['detector'].keys():\n",
+    "    fig = plt.figure(num=f'spectral_pulse_heights_{det_name}', figsize=(9.5, 12.0))\n",
+    "    grid = fig.add_gridspec(ncols=2, nrows=4, left=0.08, right=0.98, top=0.95, hspace=0.3)\n",
+    "    fig.text(0.02, 0.98, det_name.upper(), rotation=90, ha='left', va='top', size='x-large')\n",
+    "    \n",
+    "    edges = det_data[det_name]['edges']\n",
+    "    amplitudes = det_data[det_name]['amplitudes']\n",
+    "    \n",
+    "    min_edge = np.nanmin(edges)\n",
+    "    max_edge = np.nanmax(edges)\n",
+    "    \n",
+    "    max_amplitude = np.nanmax(amplitudes)\n",
+    "\n",
+    "    for edge_idx, edge_name in enumerate(['u1', 'u2', 'v1', 'v2', 'w1', 'w2', 'mcp']):\n",
+    "        if edge_idx < 6:\n",
+    "            row = 1 + edge_idx // 2\n",
+    "            col = edge_idx % 2\n",
+    "            tof_bins = int((max_edge - min_edge) // 20)\n",
+    "        else:\n",
+    "            row = 0\n",
+    "            col = np.s_[:]\n",
+    "            tof_bins = int((max_edge - min_edge) // 10)\n",
+    "\n",
+    "        ax = fig.add_subplot(grid[row, col])\n",
+    "        ax.set_title(f'Spectral pulse amplitudes: {edge_name}')\n",
+    "\n",
+    "        flat_edges = finite_flattened_slice(edges, np.s_[:, edge_idx, :])\n",
+    "        flat_amplitudes = finite_flattened_slice(amplitudes, np.s_[:, edge_idx, :])\n",
+    "        ax.hist2d(flat_edges, flat_amplitudes,\n",
+    "                  bins=[tof_bins, 512], norm=LogNorm(),\n",
+    "                  range=[[min_edge, max_edge], [0, max_amplitude]])\n",
+    "        \n",
+    "        if edge_idx == 6:\n",
+    "            ax.set_ylabel('Pulse height')\n",
+    "    pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "A more detailed view into the distribution of pulse heights as a function of TOF, e.g. to indicate whether the spectrometer transmission may depend on the kinetic energy and/or (in the case of ions) mass."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -824,7 +1013,7 @@
    },
    "outputs": [],
    "source": [
-    "for i, det_name in enumerate(remi['detector'].keys()):\n",
+    "for det_name in remi['detector'].keys():\n",
     "    edges = det_data[det_name]['edges']\n",
     "    \n",
     "    sort = remi.get_dld_sorter(det_name)\n",
@@ -840,7 +1029,8 @@
     "    \n",
     "    signals, sums = remi.get_signals_and_sums(edges, indices=sort.channel_indices, sum_shifts=sum_shifts,\n",
     "                                              mask=is_valid)\n",
-    "    fig = plot_detector_diagnostics(signals=signals, sums=sums, fig_num=30+i, im_scale=1.5,\n",
+    "    fig = plot_detector_diagnostics(signals=signals, sums=sums,\n",
+    "                                    fig_num=f'diagnostics_{det_name}', im_scale=1.5,\n",
     "                                    sum_range=max(sort.uncorrected_time_sum_half_widths),\n",
     "                                    sorter=sort)\n",
     "    fig.text(0.02, 0.98, det_name.upper() + ' before corrections', rotation=90, ha='left', va='top', size='x-large')\n",
@@ -851,13 +1041,27 @@
     "        sums = np.full((n_masked, 3), np.nan, dtype=np.float64)\n",
     "\n",
     "        sort.correct(edges[is_valid], signals, sums)\n",
-    "        fig = plot_detector_diagnostics(signals=signals, sums=sums, fig_num=40+i, im_scale=1.5,\n",
+    "        fig = plot_detector_diagnostics(signals=signals, sums=sums,\n",
+    "                                        fig_num=f'corr_diagnostics_{det_name}', im_scale=1.5,\n",
     "                                        sum_range=max(sort.uncorrected_time_sum_half_widths),\n",
     "                                        sorter=sort)\n",
     "        fig.text(0.02, 0.98, det_name.upper() + ' after corrections', rotation=90, ha='left', va='top', size='x-large')\n",
     "pass"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Overview of initial detector signal correlations before actual hit reconstruction takes place. Only the firsts edge on each channel occuring for each trigger is included, if their times are compatible with a rough time sum window.\n",
+    "\n",
+    "* The top row contains the spectrum of time differences on each wire in temporal coordinates on the left and spatial coordinates on the right (according to configured scale factors).\n",
+    "* The middle row depicts time sums, first integrated and then as a function of time difference. The time sum should generally be somewhat constant, a spectrum-like appearance indicates wire ends have been swapped entirely.\n",
+    "* [HEX-only] The bottom row shows the detector image for each combination of wires based on this limited dataset. There should be no deformations or rotations in any of the wire pairs, else likely channels are misassigned.\n",
+    "\n",
+    "The plot occurs twice if signal-level corrections for time sum or position are enabled."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -901,7 +1105,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "fig, ax = plt.subplots(num=50+i, figsize=(9.5, 4), ncols=1, clear=True,\n",
+    "fig, ax = plt.subplots(num='hit_count_per_trigger', figsize=(9.5, 4), ncols=1, clear=True,\n",
     "                       gridspec_kw=dict(top=0.92, right=0.98, left=0.05, bottom=0.12))\n",
     "    \n",
     "max_num_hits = 0.0\n",
@@ -933,7 +1137,7 @@
     "\n",
     "* `0`: All six anode signals and the corresponding MCP signal were found.\n",
     "* `4`: One signal on layer `u` is missing, all other signals for this event were found.\n",
-    "* `18`: Only one anode signal on each layer was found and the MCP signal is missing. There is no way to check whether this combination of signals is actually valid.\n",
+    "* `18`: Only one anode signal on each layer was found and the MCP signal is missing. There is no way to check whether this combination of signals is actually valid based on the detector data alone.\n",
     "\n",
     "| Method | `u+v+w +mcp` |\n",
     "| - | - |\n",
@@ -970,10 +1174,10 @@
    },
    "outputs": [],
    "source": [
-    "for i, det_name in enumerate(remi['detector'].keys()):\n",
+    "for det_name in remi['detector'].keys():\n",
     "    hits = det_data[det_name]['hits']\n",
     "    \n",
-    "    fig, ax = plt.subplots(num=60+i, figsize=(9.5, 5), ncols=1, clear=True,\n",
+    "    fig, ax = plt.subplots(num=f'reconstruction_methods_{det_name}', figsize=(9.5, 5), ncols=1, clear=True,\n",
     "                           gridspec_kw=dict(left=0.08, right=0.91, top=0.8))\n",
     "    \n",
     "    fig.text(0.02, 0.98, det_name.upper(), rotation=90, ha='left', va='top', size='x-large')\n",
@@ -1049,38 +1253,45 @@
    },
    "outputs": [],
    "source": [
-    "for i, det_name in enumerate(remi['detector'].keys()):\n",
+    "for det_name in remi['detector'].keys():\n",
     "    flat_hits = det_data[det_name]['hits'].reshape(-1)\n",
     "    flat_hits = flat_hits[np.isfinite(flat_hits[:]['x'])]\n",
     "    flat_hits = flat_hits[flat_hits['m'] <= 10]\n",
-    "    \n",
-    "    fig = plt.figure(num=70+i, figsize=(9, 13.5))\n",
+    "\n",
+    "    fig = plt.figure(num=f'detector_results_{det_name}', figsize=(9, 10.5))\n",
     "    \n",
     "    fig.text(0.02, 0.98, det_name.upper(), rotation=90, ha='left', va='top', size='x-large')\n",
     "    fig.text(0.02, 0.02, det_name.upper(), rotation=90, ha='left', va='bottom', size='x-large')\n",
     "    \n",
-    "    imp = fig.add_axes([0.1 + 0.25/2, 0.56, 0.6, 0.4])\n",
-    "    txp = fig.add_axes([0.1, 0.28, 0.85, 0.22])\n",
-    "    typ = fig.add_axes([0.1, 0.04, 0.85, 0.22])\n",
+    "    imp = fig.add_axes([0.1 + 0.25/2, 0.56, 0.5, 0.45])\n",
+    "    txp = fig.add_axes([0.1, 0.27, 0.85, 0.23])\n",
+    "    typ = fig.add_axes([0.1, 0.02, 0.85, 0.23])\n",
     "    \n",
     "    if flat_hits.size == 0:\n",
     "        warning(f'No hits found for {det_name}')\n",
     "        continue\n",
     "    \n",
-    "    im_radius = remi['detector'][det_name]['mcp_radius']*1.1\n",
+    "    mcp_radius = remi['detector'][det_name]['mcp_radius']\n",
+    "    im_radius = mcp_radius * 1.1\n",
     "    \n",
     "    imp.hist2d(flat_hits['x'], flat_hits['y'], bins=(256, 256),\n",
     "               range=[[-im_radius, im_radius], [-im_radius, im_radius]], norm=LogNorm())\n",
+    "    imp.add_patch(Circle(\n",
+    "        (0, 0), mcp_radius,\n",
+    "        linestyle='dashed', edgecolor='red', facecolor='none', linewidth=1))\n",
     "    imp.xaxis.set_label_position('top')\n",
     "    imp.set_xlabel('X / mm')\n",
     "    imp.set_ylabel('Y / mm')\n",
     "    imp.tick_params(right=True, labelright=True, top=True, labeltop=True)\n",
     "    imp.grid()\n",
     "    \n",
+    "    text_pos = 1.05*mcp_radius*np.sin(np.pi/4)\n",
+    "    imp.text(text_pos, text_pos, 'MCP', c='red', ha='left', va='bottom')\n",
+    "    \n",
     "    min_tof = flat_hits['t'].min()\n",
     "    max_tof = flat_hits['t'].max()\n",
     "    \n",
-    "    num_tof_bins = int((max_tof - min_tof) // 5)\n",
+    "    num_tof_bins = min(int((max_tof - min_tof) // 10), 500)\n",
     "    \n",
     "    if num_tof_bins == 0:\n",
     "        warning(f'All TOFs limited to single bin for {det_name}')\n",
@@ -1088,7 +1299,7 @@
     "\n",
     "    for ax, dim_label in zip([txp, typ], ['x', 'y']):\n",
     "        ax.hist2d(flat_hits['t'], flat_hits[dim_label], bins=(num_tof_bins, 256),\n",
-    "                   range=[[min_tof, max_tof], [-im_radius, im_radius]], norm=LogNorm())\n",
+    "                  range=[[min_tof, max_tof], [-im_radius, im_radius]], norm=LogNorm())\n",
     "        ax.set_ylabel(f'{dim_label.upper()} / mm')\n",
     "        \n",
     "    typ.set_xlabel('Time-of-flight / ns')\n",
@@ -1120,17 +1331,10 @@
     "\n",
     "control_sources = [det_device_id.format(karabo_id=karabo_id, det_name=det_name.upper())\n",
     "                   for det_name in remi['detector']]\n",
-    "\n",
-    "channels = []\n",
-    "if save_raw_triggers or save_raw_edges:\n",
-    "    channels.append('raw')\n",
-    "if save_rec_signals or save_rec_hits:\n",
-    "    channels.append('rec')\n",
-    "    \n",
     "instrument_channels = [\n",
     "    f'{device_id}:{det_output_key}/{channel}'\n",
     "    for device_id in control_sources\n",
-    "    for channel in channels\n",
+    "    for channel in ['raw', 'rec']\n",
     "]"
    ]
   },
@@ -1152,7 +1356,10 @@
     "    with DataFile.from_details(out_folder, out_aggregator, run, seq_id) as outp:\n",
     "        outp.create_metadata(like=dc, proposal=proposal, run=run, sequence=seq_id,\n",
     "                             control_sources=control_sources, instrument_channels=instrument_channels)\n",
-    "        outp.create_index(seq_train_ids)\n",
+    "        outp.create_index(\n",
+    "            seq_train_ids, \n",
+    "            timestamps=dc.select_trains(by_id[seq_train_ids]).train_timestamps().astype(np.uint64)\n",
+    "        )\n",
     "        \n",
     "        for det_name in remi['detector']:\n",
     "            cur_device_id = det_device_id.format(karabo_id=karabo_id, det_name=det_name.upper())\n",
@@ -1167,38 +1374,33 @@
     "            \n",
     "            cur_data = det_data[det_name]\n",
     "            \n",
-    "            if save_raw_triggers:\n",
-    "                cur_fast_data.create_key('raw.triggers', triggers[pulse_mask],\n",
-    "                                         maxshape=(None,) + triggers.shape[1:],\n",
-    "                                         chunks=tuple(chunks_triggers), **dataset_kwargs)\n",
+    "            cur_fast_data.create_key('raw.triggers', triggers[pulse_mask],\n",
+    "                                     maxshape=(None,) + triggers.shape[1:],\n",
+    "                                     chunks=tuple(chunks_triggers), **dataset_kwargs)\n",
     "                \n",
-    "            if save_raw_edges:\n",
-    "                cur_fast_data.create_key('raw.edges', cur_data['edges'][pulse_mask],\n",
-    "                                         maxshape=(None,) + cur_data['edges'].shape[1:],\n",
-    "                                         chunks=tuple(chunks_edges if chunks_edges[-1] <= cur_max_hits\n",
-    "                                                      else chunks_edges[:-1] + [cur_max_hits]),\n",
-    "                                         **dataset_kwargs)\n",
+    "            cur_fast_data.create_key('raw.edges', cur_data['edges'][pulse_mask],\n",
+    "                                     maxshape=(None,) + cur_data['edges'].shape[1:],\n",
+    "                                     chunks=tuple(chunks_edges if chunks_edges[-1] <= cur_max_hits\n",
+    "                                                 else chunks_edges[:-1] + [cur_max_hits]),\n",
+    "                                     **dataset_kwargs)\n",
     "                \n",
-    "            if save_raw_amplitudes:\n",
-    "                cur_fast_data.create_key('raw.amplitudes', cur_data['amplitudes'][pulse_mask],\n",
-    "                                         maxshape=(None,) + cur_data['amplitudes'].shape[1:],\n",
-    "                                         chunks=tuple(chunks_amplitudes if chunks_amplitudes[-1] <= cur_max_hits\n",
-    "                                                      else chunks_amplitudes[:-1] + [cur_max_hits]),\n",
-    "                                         **dataset_kwargs)\n",
+    "            cur_fast_data.create_key('raw.amplitudes', cur_data['amplitudes'][pulse_mask],\n",
+    "                                     maxshape=(None,) + cur_data['amplitudes'].shape[1:],\n",
+    "                                     chunks=tuple(chunks_amplitudes if chunks_amplitudes[-1] <= cur_max_hits\n",
+    "                                                 else chunks_amplitudes[:-1] + [cur_max_hits]),\n",
+    "                                     **dataset_kwargs)\n",
     "                \n",
-    "            if save_rec_signals:\n",
-    "                cur_fast_data.create_key('rec.signals', cur_data['signals'][pulse_mask],\n",
-    "                                         maxshape=(None,) + cur_data['signals'].shape[1:],\n",
-    "                                         chunks=tuple(chunks_signals if chunks_signals[-1] <= cur_max_hits\n",
-    "                                                      else chunks_signals[:-1] + [cur_max_hits]),\n",
-    "                                         **dataset_kwargs)\n",
+    "            cur_fast_data.create_key('rec.signals', cur_data['signals'][pulse_mask],\n",
+    "                                     maxshape=(None,) + cur_data['signals'].shape[1:],\n",
+    "                                     chunks=tuple(chunks_signals if chunks_signals[-1] <= cur_max_hits\n",
+    "                                                  else chunks_signals[:-1] + [cur_max_hits]),\n",
+    "                                     **dataset_kwargs)\n",
     "                \n",
-    "            if save_rec_hits:\n",
-    "                cur_fast_data.create_key('rec.hits', cur_data['hits'][pulse_mask],\n",
-    "                                         maxshape=(None,) + hits.shape[1:],\n",
-    "                                         chunks=tuple(chunks_hits if chunks_hits[-1] <= cur_max_hits\n",
-    "                                                      else chunks_hits[:-1] + [cur_max_hits]),\n",
-    "                                         **dataset_kwargs)\n",
+    "            cur_fast_data.create_key('rec.hits', cur_data['hits'][pulse_mask],\n",
+    "                                     maxshape=(None,) + hits.shape[1:],\n",
+    "                                     chunks=tuple(chunks_hits if chunks_hits[-1] <= cur_max_hits\n",
+    "                                                  else chunks_hits[:-1] + [cur_max_hits]),\n",
+    "                                     **dataset_kwargs)\n",
     "                \n",
     "            cur_fast_data.create_index(raw=pulse_counts[train_mask], rec=pulse_counts[train_mask])\n",
     "        \n",
diff --git a/notebooks/ePix100/Characterize_FlatFields_ePix100_NBC.ipynb b/notebooks/ePix100/Characterize_FlatFields_ePix100_NBC.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..948ec45f46349254e5cbe7084843dcd62dfc1935
--- /dev/null
+++ b/notebooks/ePix100/Characterize_FlatFields_ePix100_NBC.ipynb
@@ -0,0 +1,1411 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "826b869a",
+   "metadata": {},
+   "source": [
+    "#  ePix100 Flat Field Characterization\n",
+    "\n",
+    "Author: European XFEL Detector Group, Version 1.0\n",
+    "\n",
+    "Generate gain maps from flat-field runs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7439b810",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "in_folder = '/gpfs/exfel/exp/MID/202231/p900310/raw' # input folder, required\n",
+    "out_folder = '' # output folder, required\n",
+    "metadata_folder = ''  # Directory containing calibration_metadata.yml when run by xfel-calibrate\n",
+    "run = 29 # which run to read data from, required\n",
+    "\n",
+    "# Parameters for accessing the raw data.\n",
+    "karabo_id = \"MID_EXP_EPIX-2\"  # karabo ID\n",
+    "karabo_da = \"EPIX02\"  # data aggregator\n",
+    "receiver_template = \"RECEIVER\" # detector receiver template for accessing raw data files\n",
+    "instrument_source_template = '{}/DET/{}:daqOutput' # instrument detector data source in h5files\n",
+    "\n",
+    "# Fit parameters\n",
+    "peak_fitting = 'gauss' # method to find the peak position per pixel: 'median' or 'gauss'\n",
+    "N_sigma_interval = 5   # sigma interval to find singles peak in each per pixel \n",
+    "peak_energy = 8.048    # [keV] Cu K$\\alpha$1\n",
+    "\n",
+    "# ADU range\n",
+    "ADU_range = [-50,500] # expected range that encloses the raw signal from the FF run \n",
+    "\n",
+    "# Cluster calculators (given in N times sigma noise)\n",
+    "split_evt_primary_threshold = 7   # Split event primary threshold \n",
+    "split_evt_secondary_threshold = 3  # Split event secondary threshold\n",
+    "split_evt_mip_threshold = 1000     # Threshold for rejection of MIP events (e.g, cosmic-rays)\n",
+    "\n",
+    "# Parameters for the calibration database.\n",
+    "cal_db_interface = \"tcp://max-exfl-cal001:8020\" # calibration DB interface to use\n",
+    "cal_db_timeout = 300000 # timeout on caldb requests\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",
+    "db_output = False # Output constants to the calibration database\n",
+    "local_output = True # Output constants locally\n",
+    "\n",
+    "# Conditions used for injected calibration constants.\n",
+    "bias_voltage = 200 # Bias voltage\n",
+    "in_vacuum = False # Detector operated in vacuum\n",
+    "fix_integration_time = -1 # Integration time. Set to -1 to read from .h5 file\n",
+    "fix_temperature = -1 # Fixed temperature in Kelvin. Set to -1 to read from .h5 file\n",
+    "temp_limits = 5 # Limit for parameter Operational temperature\n",
+    "\n",
+    "# Parameters used during selecting raw data trains.\n",
+    "min_trains = 1 # Minimum number of trains that should be available. Default 1.\n",
+    "max_trains = 0 # Maximum number of trains to use for processing. Set to 0 to use all available trains."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "43791d97",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import warnings\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "from matplotlib.colors import LogNorm\n",
+    "import numpy as np\n",
+    "import pasha as psh\n",
+    "from extra_data import RunDirectory\n",
+    "from pathlib import Path\n",
+    "from prettytable import PrettyTable\n",
+    "from scipy.optimize import curve_fit\n",
+    "\n",
+    "import XFELDetAna.xfelprofiler as xprof\n",
+    "from XFELDetAna import xfelpyanatools as xana\n",
+    "from XFELDetAna import xfelpycaltools as xcal\n",
+    "from XFELDetAna.plotting.util import prettyPlotting\n",
+    "\n",
+    "from cal_tools.enums import BadPixels\n",
+    "from cal_tools.step_timing import StepTimer\n",
+    "from cal_tools.epix100 import epix100lib\n",
+    "from cal_tools.tools import (\n",
+    "    calcat_creation_time,\n",
+    "    get_pdu_from_db,\n",
+    "    get_constant_from_db,\n",
+    "    get_report,\n",
+    "    save_const_to_h5,\n",
+    "    send_to_db,\n",
+    ")\n",
+    "from iCalibrationDB import Conditions, Constants"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4f4d9f62",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline\n",
+    "\n",
+    "warnings.filterwarnings('ignore')\n",
+    "\n",
+    "prettyPlotting = True\n",
+    "\n",
+    "profiler = xprof.Profiler()\n",
+    "profiler.disable()\n",
+    "\n",
+    "step_timer = StepTimer()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6571ae1c",
+   "metadata": {},
+   "source": [
+    "## Load Data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9c93190b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "instrument_src = instrument_source_template.format(karabo_id, receiver_template)\n",
+    "\n",
+    "# Run directory\n",
+    "proposal = list(filter(None, in_folder.strip('/').split('/')))[-2]\n",
+    "file_loc = f'proposal:{proposal} runs:{run}'\n",
+    "report = get_report(metadata_folder)\n",
+    "\n",
+    "ped_dir = Path(in_folder) / f'r{run:04d}'\n",
+    "run_dc = RunDirectory(ped_dir)\n",
+    "\n",
+    "print(f\"Run is: {run}\")\n",
+    "print(f\"Instrument H5File source: {instrument_src}\")\n",
+    "\n",
+    "creation_time = calcat_creation_time(in_folder, run, creation_time)\n",
+    "print(f\"Using {creation_time.isoformat()} as creation time\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "08d6fef2",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "-"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Path to pixels ADC values\n",
+    "pixels_src = (instrument_src, \"data.image.pixels\")\n",
+    "\n",
+    "# Specify the total number of images to process\n",
+    "n_trains = run_dc.get_data_counts(*pixels_src).shape[0]\n",
+    "\n",
+    "# Modify n_trains to process based on the given maximum and minimum number of trains.\n",
+    "if max_trains:\n",
+    "    n_trains = min(max_trains, n_trains)\n",
+    "    \n",
+    "if n_trains < min_trains:\n",
+    "    raise ValueError(\n",
+    "        f\"Less than {min_trains} trains are available in RAW data.\"\n",
+    "         \" Not enough data to process flat fields.\")\n",
+    "\n",
+    "all_trains = len(run_dc.select(instrument_src).train_ids)\n",
+    "if n_trains != all_trains:\n",
+    "    print(f\"Warning: {all_trains - n_trains} trains with empty data.\")\n",
+    "\n",
+    "print(f'Images to analyze: {n_trains}')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9fdf1715",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Read sensor size\n",
+    "sensor_size = run_dc[instrument_src, 'data.image.dims'].as_single_value(reduce_by='first') # (x=768, y=708) expected\n",
+    "sensor_size = sensor_size[sensor_size != 1].tolist()  # data.image.dims for old data is [768, 708, 1]\n",
+    "assert sensor_size == [768,708], 'Unexpected sensor dimensions.' \n",
+    "\n",
+    "ctrl_data = epix100lib.epix100Ctrl(\n",
+    "    run_dc=run_dc,\n",
+    "    instrument_src=instrument_src,\n",
+    "    ctrl_src=f\"{karabo_id}/DET/CONTROL\",\n",
+    "    )\n",
+    "# Read integration time\n",
+    "if fix_integration_time == -1:\n",
+    "    integration_time = ctrl_data.get_integration_time()\n",
+    "    integration_time_str_add = ''\n",
+    "else:\n",
+    "    integration_time = fix_integration_time\n",
+    "    integration_time_str_add = '(manual input)'\n",
+    "    \n",
+    "# Read temperature    \n",
+    "if fix_temperature == -1:\n",
+    "    temperature = ctrl_data.get_temprature()\n",
+    "    temperature_k = temperature + 273.15\n",
+    "    temp_str_add = ''\n",
+    "else:\n",
+    "    temperature_k = fix_temperature\n",
+    "    temperature = fix_temperature - 273.15\n",
+    "    temp_str_add = '(manual input)'\n",
+    "    \n",
+    "# Print operating conditions\n",
+    "print(f\"Bias voltage: {bias_voltage} V\")\n",
+    "print(f\"Detector integration time: {integration_time} \\u03BCs {integration_time_str_add}\")\n",
+    "print(f\"Mean temperature: {temperature:0.2f}\\u00B0C / {temperature_k:0.2f} K {temp_str_add}\")\n",
+    "print(f\"Operated in vacuum: {in_vacuum}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a4dd3d8d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "step_timer = StepTimer()\n",
+    "step_timer.start()\n",
+    "\n",
+    "# Read data\n",
+    "data_dc = run_dc.select(*pixels_src, require_all=True).select_trains(np.s_[:n_trains])\n",
+    "dshape = data_dc[pixels_src].shape\n",
+    "\n",
+    "step_timer.done_step('Flat-fields loaded. Elapsed Time')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7920cb0b",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "## Retrieve Necessary Calibration Constants"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "593964be",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "const_data = dict()\n",
+    "constants = ['Offset', 'Noise', 'BadPixelsDark']\n",
+    "\n",
+    "condition =  Conditions.Dark.ePix100(bias_voltage=bias_voltage,\n",
+    "                                     integration_time=integration_time,\n",
+    "                                     temperature=temperature_k,\n",
+    "                                     in_vacuum=in_vacuum)\n",
+    "\n",
+    "for cname in constants:        \n",
+    "    const_data[cname] = get_constant_from_db(\n",
+    "        karabo_id=karabo_id,\n",
+    "        karabo_da=karabo_da,\n",
+    "        constant=getattr(Constants.ePix100, cname)(),\n",
+    "        condition=condition,\n",
+    "        empty_constant=None,\n",
+    "        cal_db_interface=cal_db_interface,\n",
+    "        creation_time=creation_time,\n",
+    "        timeout=cal_db_timeout\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ea05e961",
+   "metadata": {},
+   "source": [
+    "## Instantiate calculators"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f05e8297",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "block_size = [sensor_size[0]//2, sensor_size[1]//2]\n",
+    "noiseSigma = 5\n",
+    "\n",
+    "cmCorrection_block = xcal.CommonModeCorrection(\n",
+    "    sensor_size,\n",
+    "    block_size,\n",
+    "    'block',\n",
+    "    noiseMap=const_data['Noise'].swapaxes(0,1),\n",
+    "    noiseSigma=noiseSigma,\n",
+    "    parallel=False)\n",
+    "cmCorrection_col = xcal.CommonModeCorrection(\n",
+    "    sensor_size,\n",
+    "    block_size,\n",
+    "    'col',\n",
+    "    noiseMap=const_data['Noise'].swapaxes(0,1),\n",
+    "    noiseSigma=noiseSigma,\n",
+    "    parallel=False)\n",
+    "cmCorrection_row = xcal.CommonModeCorrection(\n",
+    "    sensor_size,\n",
+    "    block_size,\n",
+    "    'row',\n",
+    "    noiseMap=const_data['Noise'].swapaxes(0,1),\n",
+    "    noiseSigma=noiseSigma,\n",
+    "    parallel=False)\n",
+    "  \n",
+    "patternClassifier = xcal.PatternClassifier(\n",
+    "    shape=sensor_size,\n",
+    "    noisemap=const_data['Noise'].swapaxes(0,1),\n",
+    "    primaryThreshold=split_evt_primary_threshold,\n",
+    "    secondaryThreshold=split_evt_secondary_threshold,\n",
+    "    upperThreshold=split_evt_mip_threshold,\n",
+    "    blockSize=block_size,\n",
+    "    setPixelMask = const_data['BadPixelsDark'].flatten(),\n",
+    "    parallel=False\n",
+    ")\n",
+    "\n",
+    "patternSelector = xcal.PatternSelector(\n",
+    "    sensor_size, \n",
+    "    selectionList = [100, 101], # singles patterns\n",
+    "    blockSize=block_size, \n",
+    "    parallel=False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8977c9ff",
+   "metadata": {},
+   "source": [
+    "## Correct data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "de145b05",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bin_min = ADU_range[0]\n",
+    "bin_max = ADU_range[1]\n",
+    "bin_width = 1\n",
+    "\n",
+    "bins = np.arange(bin_min,bin_max,bin_width)\n",
+    "hist = {'O': 0,'CM': 0,'CS': 0, 'S': 0}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1765d3f8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def correct_train(worker_id, index, train_id, dc):\n",
+    "\n",
+    "    d = dc[pixels_src[0]][pixels_src[1]].astype(np.float32)\n",
+    "\n",
+    "    # Offset correction\n",
+    "    d -= const_data['Offset'].squeeze()\n",
+    "    hist['O'] += np.histogram(d.flatten(),bins=bins)[0]\n",
+    "     \n",
+    "    # Common Mode correction\n",
+    "    d = d.swapaxes(0,-1)\n",
+    "    d = cmCorrection_block.correct(d)\n",
+    "    d = cmCorrection_col.correct(d)\n",
+    "    d = cmCorrection_row.correct(d)\n",
+    "    d = d.swapaxes(0,-1)\n",
+    "    hist['CM'] += np.histogram(d.flatten(),bins=bins)[0]\n",
+    "    \n",
+    "    # Charge Sharing correction\n",
+    "    d = d.swapaxes(0,-1)\n",
+    "    d, patterns = patternClassifier.classify(d)\n",
+    "    sing,fs = patternSelector.select(d,patterns)\n",
+    "    d = d.swapaxes(0,-1)\n",
+    "    hist['CS'] += np.histogram(d[d>0].flatten(),bins=bins)[0]\n",
+    "    hist['S'] += np.histogram(sing[sing>0].flatten(),bins=bins)[0]\n",
+    "    \n",
+    "    data_corr[index+prev_chunk] = d\n",
+    "    data_singles[index+prev_chunk] = sing.swapaxes(0,-1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7c4dcd5b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "step_timer.start()\n",
+    "\n",
+    "chunk_size = 1000\n",
+    "\n",
+    "psh.set_default_context('threads', num_workers=35) # num_workers=35 was found to be optimal\n",
+    "data_corr = psh.alloc(shape=dshape, dtype=np.float32)\n",
+    "data_singles = psh.alloc(shape=dshape, dtype=int)\n",
+    "\n",
+    "chunk = 0\n",
+    "while chunk < dshape[0]-1:\n",
+    "    \n",
+    "    prev_chunk = chunk\n",
+    "    chunk+=chunk_size\n",
+    "    if chunk > dshape[0]: # last chunk may have different size\n",
+    "        chunk = dshape[0]-1\n",
+    "        \n",
+    "    psh.map(correct_train, data_dc.select_trains(np.arange(prev_chunk,chunk)))\n",
+    "        \n",
+    "    print(f'Corrected trains: {chunk} ({round(chunk/dshape[0]*100)}%)',end='\\r')\n",
+    "\n",
+    "step_timer.done_step('Corrected data. Elapsed Time')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "923a5ac4",
+   "metadata": {},
+   "source": [
+    "## Plot histograms"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c43ae1dd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bins_c = bins[:-1]+np.diff(bins)[0]/2 # center of bins\n",
+    "\n",
+    "plt.figure(figsize=(12,8))\n",
+    "plt.plot(bins_c,hist['O'], label='Offset corrected')\n",
+    "plt.plot(bins_c,hist['CM'], label='Common Mode corrected')\n",
+    "plt.plot(bins_c,hist['CS'], label='Charge Sharing corrected')\n",
+    "plt.plot(bins_c,hist['S'], label='Singles')\n",
+    "plt.xlim(ADU_range)\n",
+    "plt.yscale('log')\n",
+    "plt.xlabel('ADU',fontsize=12)\n",
+    "plt.title(f'{karabo_id} | {proposal} - r{run}', fontsize=14)\n",
+    "plt.legend(fontsize=12);\n",
+    "plt.grid(ls=':')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "46d9fe80",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(f'Primary threshold: {split_evt_primary_threshold}')\n",
+    "print(f'Secondary threshold: {split_evt_secondary_threshold}')\n",
+    "\n",
+    "patternStats = patternClassifier.getPatternStats()\n",
+    "\n",
+    "n_singles = np.sum(patternStats['singles'])\n",
+    "n_doubles = np.sum(patternStats['doubles'])\n",
+    "n_triples = np.sum(patternStats['triples'])\n",
+    "n_quads = np.sum(patternStats['quads'])\n",
+    "n_clusters = np.sum(patternStats['clusters'])\n",
+    "known_patterns = np.sum((n_singles, n_doubles, n_triples, n_quads))\n",
+    "\n",
+    "t1,t2 = PrettyTable(),PrettyTable()\n",
+    "t1.field_names = ['Photon Hits', 'Frequency']\n",
+    "t1.add_row(['Big Clusters', f'{n_clusters/(known_patterns+n_clusters)*100: .2f} %'])\n",
+    "t1.add_row(['Listed Patterns', f'{known_patterns/(known_patterns+n_clusters)*100: .2f} %'])\n",
+    "\n",
+    "print(t1)\n",
+    "\n",
+    "t2.field_names = ['Listed Patterns', 'Frequency']\n",
+    "t2.add_row(['Singles', f'{n_singles/known_patterns*100: .2f} %'])\n",
+    "t2.add_row(['Doubles', f'{n_doubles/known_patterns*100: .2f} %'])\n",
+    "t2.add_row(['Triples', f'{n_triples/known_patterns*100: .2f} %'])\n",
+    "t2.add_row(['Quadruplets', f'{n_quads/known_patterns*100: .2f} %'])\n",
+    "\n",
+    "print(t2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7739d666",
+   "metadata": {},
+   "source": [
+    "## Flat-Field Statistics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ed100e6a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Definition of gaussian function for fitting\n",
+    "def gauss(x, *p):\n",
+    "    A, mu, sigma = p\n",
+    "    return A*np.exp(-(x-mu)**2/(2.*sigma**2))\n",
+    "\n",
+    "# rough initial estimate of fit parameters\n",
+    "fit_estimates = [np.max(hist['S']),           # amplitude\n",
+    "                 bins[np.argmax(hist['S'])],  # centroid\n",
+    "                 10]                          # sigma"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a649666b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "coeff, _ = curve_fit(gauss, bins_c, hist['S'], p0=fit_estimates)\n",
+    "singles_mu = coeff[1]\n",
+    "singles_sig = abs(coeff[2])\n",
+    "ROI = np.round([singles_mu-N_sigma_interval*singles_sig, # region of interest to find first photopeak per pixel\n",
+    "                singles_mu+N_sigma_interval*singles_sig]).astype(int)\n",
+    "y_fit = gauss(bins_c, *coeff)\n",
+    "\n",
+    "plt.figure(figsize=(9,6))\n",
+    "plt.plot(bins_c,hist['S'],'k',label = 'singles')\n",
+    "plt.plot(bins_c,y_fit,'g--',label = 'gauss fit') \n",
+    "plt.ylim(1,max(hist['S'])*1.5);\n",
+    "plt.xlim(ADU_range)\n",
+    "plt.vlines(coeff[1],0,plt.gca().get_ylim()[1],color='g',ls=':')\n",
+    "\n",
+    "plt.axvspan(ROI[0],\n",
+    "            ROI[1],\n",
+    "            alpha = .2,\n",
+    "            color = 'green',\n",
+    "            label = f'\\u03BC ± {N_sigma_interval}\\u03c3')\n",
+    "\n",
+    "plt.legend(fontsize=12);\n",
+    "plt.xlabel('ADU',fontsize=12)\n",
+    "plt.yscale('log')\n",
+    "plt.grid(ls=':')\n",
+    "plt.show()\n",
+    "\n",
+    "print('--------------------')\n",
+    "print('Fit parameters:')\n",
+    "print(f'  centroid = {np.round(singles_mu,3)}')\n",
+    "print(f'     sigma = {np.round(singles_sig,3)}')\n",
+    "print('---------------------')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d4bba07d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Calculate singles per pixel\n",
+    "step_timer.start()\n",
+    "\n",
+    "singles_per_pixel = np.empty(np.flip(sensor_size))\n",
+    "\n",
+    "for py in range(0,int(sensor_size[1])):\n",
+    "    for px in range(0,int(sensor_size[0])):\n",
+    "        singles_per_pixel[py,px] = np.sum((data_singles[:,py,px]>=ROI[0]) & (data_singles[:,py,px]<ROI[1]))\n",
+    "\n",
+    "step_timer.done_step('Calculated singles per pixel. Elapsed Time')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c5986694",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "mask_bins = np.unique(singles_per_pixel,return_counts=True)[1] > np.max(np.unique(singles_per_pixel,return_counts=True)[1])*.01\n",
+    "last_bin = np.max(np.unique(singles_per_pixel)[mask_bins]) # xlim on bin that has less than 1% of max counts\n",
+    "\n",
+    "# Plot singles distribution\n",
+    "fig = xana.heatmapPlot(\n",
+    "    singles_per_pixel,\n",
+    "    lut_label='# singles',\n",
+    "    x_label='Column',\n",
+    "    y_label='Row',\n",
+    "    vmax = last_bin\n",
+    ")\n",
+    "fig.suptitle(f'Singles Distribution', x=.48, y=.9, fontsize=14)\n",
+    "fig.set_size_inches(h=10, w=10);\n",
+    "\n",
+    "plt.figure(figsize=(7,5))\n",
+    "plt.hist(singles_per_pixel.flatten(),bins=np.arange(0,last_bin,1),\n",
+    "         align = 'left',\n",
+    "         histtype = 'bar',\n",
+    "         edgecolor='black', \n",
+    "         linewidth=1.2)\n",
+    "plt.xlabel('Singles per pixel',fontsize=12)\n",
+    "plt.grid(ls='--',axis='y',color='b',alpha=.5)\n",
+    "plt.show()\n",
+    "\n",
+    "print(f'Average number of singles per pixel: {np.round(np.sum(data_singles>0)/np.prod(sensor_size),2)}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3d58fc82",
+   "metadata": {},
+   "source": [
+    "## Plot random sample pixels "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "62b2650e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "N_sample_pixels = 16\n",
+    "\n",
+    "# Plot some random pixels, avoiding bad ones\n",
+    "np.random.seed(0)\n",
+    "sample_pixels = np.transpose([np.random.randint(0, sensor_size[0], N_sample_pixels),\n",
+    "                              np.random.randint(0, sensor_size[1], N_sample_pixels)])\n",
+    "while np.sum(const_data['BadPixelsDark'][sample_pixels[:,1],sample_pixels[:,0]]):\n",
+    "    sample_pixels = np.transpose([np.random.randint(0, sensor_size[0], N_sample_pixels),\n",
+    "                                  np.random.randint(0, sensor_size[1], N_sample_pixels)])\n",
+    "\n",
+    "fig = plt.figure(figsize=(20,20))\n",
+    "roi_bins = np.arange(ROI[0], ROI[1])\n",
+    "it_counter = 0\n",
+    "for px,py in sample_pixels:\n",
+    "    it_counter+=1    \n",
+    "    \n",
+    "    plt.subplot(int(np.sqrt(N_sample_pixels)),int(np.sqrt(N_sample_pixels)),it_counter)\n",
+    "    \n",
+    "    h,ADU = np.histogram(data_singles[:,py,px],bins=roi_bins)\n",
+    "    ADU_c = ADU[:-1] + np.diff(ADU)[0]/2 # center of bins\n",
+    "    \n",
+    "    p1 = plt.plot([],[],' ',label = f'({px},{py})')\n",
+    "    p2 = plt.scatter(ADU_c[h>0], h[h>0],marker = 'x',c = 'k', label = 'singles')\n",
+    "\n",
+    "    mdn = np.median(ADU_c[h>0])\n",
+    "    if ~np.isnan(mdn):\n",
+    "        p3 = plt.plot([mdn, mdn],[0,plt.gca().get_ylim()[1]],color='g', label = f'median={int(mdn)}')\n",
+    "    else:\n",
+    "        p3 = plt.plot([],[],' ', label = 'empty')\n",
+    "        \n",
+    "    try:\n",
+    "        coeff, _ = curve_fit(gauss, ADU_c, h, p0=[0, np.median(ADU_c[h>0]), singles_sig]) \n",
+    "        y_fit = gauss(ADU_c, *coeff)\n",
+    "        p4 = plt.plot(ADU_c, y_fit, label = f'fit: \\u03BC={int(np.round(coeff[1]))}')\n",
+    "\n",
+    "    except (RuntimeError, ValueError):\n",
+    "        p4 = plt.plot([],[],' ', label = 'fit error')\n",
+    "    \n",
+    "    plt.grid(ls=':')\n",
+    "    plt.xlabel('ADU')\n",
+    "    plt.xlim(ROI)\n",
+    "    plt.ylim(bottom=0)\n",
+    "    plt.legend()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a968c8df",
+   "metadata": {},
+   "source": [
+    "## Fit single photon peaks per pixel"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "49d52f2b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "step_timer.start()\n",
+    "peak_map = np.zeros(np.flip(sensor_size))[...,np.newaxis]\n",
+    "\n",
+    "for py in range(0,int(sensor_size[1])):\n",
+    "    for px in range(0,int(sensor_size[0])):            \n",
+    "        h,ADU = np.histogram(data_singles[:,py,px],bins=np.arange(ROI[0],ROI[1]))\n",
+    "        ADU_c = ADU[:-1] + np.diff(ADU)[0]/2 # center of bins\n",
+    "        \n",
+    "        if np.sum(h):\n",
+    "            if peak_fitting=='median':\n",
+    "                peak_map[py,px] = np.median(ADU_c[h>0])\n",
+    "            elif peak_fitting=='gauss':\n",
+    "                try:\n",
+    "                    coeff, _ = curve_fit(gauss, ADU_c, h, p0=[0, np.median(ADU_c[h>0]), singles_sig]) \n",
+    "                    peak_map[py,px] = coeff[1]\n",
+    "                except RuntimeError:\n",
+    "                    pass         # Failed fits remain 0 \n",
+    "        else:\n",
+    "            peak_map[py,px] = -1 # Assign -1 to empty pixels\n",
+    "\n",
+    "peak_map[np.isnan(peak_map)] = 0 # Failed fits can throw no expection but return nan coeffs\n",
+    "step_timer.done_step(f'Calculated relative gain map using {peak_fitting} fit. Elapsed Time')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8891bcd4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.figure(figsize=(7,5))\n",
+    "plt.hist(peak_map.flatten(),bins=np.arange(ROI[0],ROI[1]),\n",
+    "         histtype = 'bar',\n",
+    "         edgecolor='black',\n",
+    "         alpha = .5,\n",
+    "         linewidth=1.2);\n",
+    "\n",
+    "h,ADU = np.histogram(peak_map.flatten(),bins=np.arange(ROI[0],ROI[1]))\n",
+    "ADU_c = ADU[:-1] + np.diff(ADU)[0]/2 # center of bins\n",
+    "\n",
+    "coeff, _ = curve_fit(gauss, ADU_c, h, p0=[h.max()/2, singles_mu, singles_sig])\n",
+    "BP_fit_threshold = [coeff[1]-N_sigma_interval*abs(coeff[2]),\n",
+    "                    coeff[1]+N_sigma_interval*abs(coeff[2])]\n",
+    "y_fit = gauss(ADU_c, *coeff)\n",
+    "plt.plot(ADU_c,y_fit, label = f'fit: \\u03BC={int(np.round(coeff[1]))}')\n",
+    "plt.vlines(coeff[1],0,plt.gca().get_ylim()[1],color='orange',ls=':')\n",
+    "plt.axvspan(BP_fit_threshold[0],\n",
+    "            BP_fit_threshold[1],\n",
+    "            alpha = .3,\n",
+    "            color = 'orange',\n",
+    "            label = f'\\u03BC ± {N_sigma_interval}\\u03c3')\n",
+    "\n",
+    "plt.grid(ls=':')\n",
+    "plt.xlim(np.array(BP_fit_threshold)*[.9,1.1])\n",
+    "plt.xlabel('Peak position [ADU]',fontsize=12);\n",
+    "plt.legend(fontsize=12)\n",
+    "plt.title(f'{karabo_id} | {proposal} - r{run}', fontsize=12)\n",
+    "plt.ylim((1, coeff[0]*1.2))\n",
+    "plt.show()\n",
+    "\n",
+    "print('--------------------')\n",
+    "print('Fit parameters:')\n",
+    "print(f'  centroid = {np.round(coeff[1],3)}')\n",
+    "print(f'     sigma = {np.round(abs(coeff[2]),3)}')\n",
+    "print('---------------------')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e17b27ef",
+   "metadata": {},
+   "source": [
+    "## Flat-Field Bad Pixels"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0816af0f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "const_data['BadPixelsFF'] = np.zeros(np.flip(sensor_size))[...,np.newaxis]\n",
+    "\n",
+    "# Empty Pixels\n",
+    "const_data['BadPixelsFF'][peak_map==-1] = BadPixels.FF_NO_ENTRIES.value\n",
+    "\n",
+    "# Failed Fits\n",
+    "const_data['BadPixelsFF'][peak_map==0] = BadPixels.FF_GAIN_EVAL_ERROR.value\n",
+    "\n",
+    "# Gain out of range\n",
+    "const_data['BadPixelsFF'][(peak_map!=0) & (peak_map!=-1) & ((peak_map<BP_fit_threshold[0]) | (peak_map>BP_fit_threshold[1]))] = BadPixels.FF_GAIN_DEVIATION.value\n",
+    "\n",
+    "# Plot Bad Pixels Map\n",
+    "fig = xana.heatmapPlot(\n",
+    "    np.nan_to_num(np.log2(const_data['BadPixelsFF'].squeeze())+1, neginf=np.nan),\n",
+    "    cb_label='Bad pixel bit',\n",
+    "    x_label='Column',\n",
+    "    y_label='Row',\n",
+    ")\n",
+    "fig.suptitle(f'FF Bad Pixels Map({karabo_id} | {proposal} - r{run})', x=.5, y=.9, fontsize=16)\n",
+    "fig.set_size_inches(h=12, w=12)\n",
+    "\n",
+    "t = PrettyTable()\n",
+    "t.title = 'Flat-Field Bad Pixel Analysis'\n",
+    "t.field_names = ['Bit', 'Value', 'Type       ', 'Counts', '%']\n",
+    "t.align['Type       '] = 'r'\n",
+    "\n",
+    "for BP_type in [BadPixels.FF_GAIN_DEVIATION, BadPixels.FF_GAIN_EVAL_ERROR, BadPixels.FF_NO_ENTRIES]:\n",
+    "    t.add_row([BP_type.bit_length(),\n",
+    "               BP_type.value,\n",
+    "               BP_type.name,\n",
+    "               np.sum(const_data['BadPixelsFF']==BP_type.value),\n",
+    "               np.round(100*np.sum(const_data['BadPixelsFF']==BP_type.value)/np.prod(sensor_size),2)\n",
+    "              ])\n",
+    "t.add_row(['-','-',\n",
+    "           'Total',\n",
+    "           np.sum(const_data['BadPixelsFF']>0),\n",
+    "           np.round(100*np.sum(const_data['BadPixelsFF']>0)/np.prod(sensor_size),2)\n",
+    "          ])\n",
+    "print(t)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e97610e2",
+   "metadata": {},
+   "source": [
+    "## Relative Gain Map"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1ea03d36",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Replace FF bad pixels with mean peak value\n",
+    "peak_map[const_data['BadPixelsFF']>0] = np.nanmean(peak_map[const_data['BadPixelsFF']==0])\n",
+    "\n",
+    "# Calculate relative gain\n",
+    "rel_gain_map = 1/(peak_map.squeeze()/np.mean(peak_map))\n",
+    "\n",
+    "fig = xana.heatmapPlot(\n",
+    "    rel_gain_map,\n",
+    "    cb_label='Relative gain',\n",
+    "    x_label='Column',\n",
+    "    y_label='Row',\n",
+    "    vmin=np.floor(np.min(rel_gain_map)/.2)*.2, # force cb limits to be multiples of 0.2 \n",
+    "    vmax=np.ceil(np.max(rel_gain_map)/.2)*.2\n",
+    ")\n",
+    "fig.suptitle(f'Relative Gain Map ({karabo_id} | {proposal} - r{run})', x=.48, y=.9, fontsize=16)\n",
+    "fig.set_size_inches(h=12, w=12)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c2870edc",
+   "metadata": {},
+   "source": [
+    "## Absolute Gain Conversion Constant"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "282ad58a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "step_timer.start()\n",
+    "\n",
+    "# Correct data with calculated gain map\n",
+    "data_gain_corrected = data_corr*rel_gain_map\n",
+    "\n",
+    "h,ADU = np.histogram(data_gain_corrected.flatten(),\n",
+    "                     bins=np.arange(BP_fit_threshold[0],BP_fit_threshold[1]).astype(int))\n",
+    "ADU_c = ADU[:-1] + np.diff(ADU)[0]/2 # center of bins\n",
+    "\n",
+    "coeff, _ = curve_fit(gauss, ADU_c, h, p0=[h.max()/2, singles_mu, singles_sig])\n",
+    "y_fit = gauss(ADU_c, *coeff)\n",
+    "\n",
+    "gain_conv_const = coeff[1] / peak_energy\n",
+    "\n",
+    "abs_gain_map = rel_gain_map / gain_conv_const\n",
+    "\n",
+    "step_timer.done_step('Calculated Gain Conversion Constant. Elapsed Time')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3a0daabf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.figure(figsize=(7,5))\n",
+    "\n",
+    "plt.scatter(ADU_c/gain_conv_const, h, color='k', marker='x', label='Gain Corrected')\n",
+    "plt.plot(ADU_c/gain_conv_const, y_fit, color='orange', label = f'fit: \\u03BC={(np.round(coeff[1],2))} ADU');\n",
+    "\n",
+    "plt.ylim(bottom=0)\n",
+    "plt.legend()\n",
+    "plt.grid(ls=':')\n",
+    "\n",
+    "plt.plot([peak_energy, peak_energy],[0,plt.gca().get_ylim()[1]],color='orange', ls = '--')\n",
+    "\n",
+    "ax1 = plt.gca()\n",
+    "ax2 = ax1.twiny()\n",
+    "ax2.set_xticks(ax1.get_xticks())\n",
+    "ax2.set_xbound(ax1.get_xbound())\n",
+    "ax2.set_xticklabels((ax1.get_xticks()*gain_conv_const).astype(int))\n",
+    "ax2.set_xlabel('ADU',fontsize=12)\n",
+    "ax1.set_xlabel('keV',fontsize=12)\n",
+    "\n",
+    "ax1.xaxis.label.set_color('red')\n",
+    "ax1.tick_params(axis='x', colors='red')\n",
+    "ax2.xaxis.label.set_color('blue')\n",
+    "ax2.tick_params(axis='x', colors='blue')\n",
+    "\n",
+    "plt.suptitle(f'Absolute Gain Conversion ({karabo_id} | {proposal} - r{run})',y =1.02,fontsize = 12)\n",
+    "plt.show()\n",
+    "\n",
+    "print(f'Gain conversion constant: {np.round(gain_conv_const,4)} ADU/keV')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c93fb9ac",
+   "metadata": {},
+   "source": [
+    "## Gain Map Validation\n",
+    "\n",
+    "Validation tests:\n",
+    "1. Inspect correlation between calculated gain map and gain map loaded from DB\n",
+    "2. Perform gain correction of current FF with calculated gain map and DB gain map and compare energy resolution and linearity"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8792ff72",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Retrieve DB RelativeGain Map\n",
+    "illum_condition_db = Conditions.Illuminated.ePix100(\n",
+    "    bias_voltage=bias_voltage,\n",
+    "    integration_time=integration_time,\n",
+    "    temperature=temperature_k,\n",
+    "    in_vacuum=in_vacuum,\n",
+    "    photon_energy=peak_energy\n",
+    ")\n",
+    "\n",
+    "db_gain_map = get_constant_from_db(\n",
+    "    karabo_id=karabo_id,\n",
+    "    karabo_da=karabo_da,\n",
+    "    constant=getattr(Constants.ePix100, 'RelativeGain')(),\n",
+    "    condition=illum_condition_db,\n",
+    "    empty_constant=None,\n",
+    "    cal_db_interface=cal_db_interface,\n",
+    "    creation_time=creation_time,\n",
+    "    timeout=cal_db_timeout\n",
+    ")\n",
+    "\n",
+    "if db_gain_map is None:\n",
+    "    print('Waring: No previous RelativeGain map was found for this detector conditions.')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1150be55",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if db_gain_map is not None:\n",
+    "    \n",
+    "    # Calculate gain conversion constant of DB gain map\n",
+    "    gain_conv_const_db = 1/np.median(db_gain_map[const_data['BadPixelsDark'].squeeze()>0])\n",
+    "    \n",
+    "    # Correlate new and DB gain maps\n",
+    "    plt.figure(figsize=(7,7))\n",
+    "\n",
+    "    plt.hist2d(db_gain_map.flatten(),\n",
+    "               abs_gain_map.flatten(),\n",
+    "               bins = 200,\n",
+    "               norm=LogNorm(),\n",
+    "              );\n",
+    "    plt.xlabel('DB noise map',fontsize=12)\n",
+    "    plt.ylabel('New noise map',fontsize=12)\n",
+    "\n",
+    "    plt.xlim(np.min([db_gain_map,abs_gain_map]),np.max([db_gain_map,abs_gain_map]))\n",
+    "    plt.ylim(np.min([db_gain_map,abs_gain_map]),np.max([db_gain_map,abs_gain_map]))\n",
+    "    plt.grid(ls=':')\n",
+    "\n",
+    "    rel_change = np.mean(abs(abs_gain_map-db_gain_map)/abs_gain_map)\n",
+    "    print(f'Average relative change of new gain map: {np.round(rel_change*100,3)} %')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e55aa651",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def correct_validation_train(worker_id, index, train_id, dc):\n",
+    "\n",
+    "    d = dc[pixels_src[0]][pixels_src[1]].astype(np.float32)\n",
+    "\n",
+    "    # Offset correction\n",
+    "    d -= const_data['Offset'].squeeze()\n",
+    "\n",
+    "    # Common Mode correction\n",
+    "    d = d.swapaxes(0,-1)\n",
+    "    d = cmCorrection_block.correct(d)\n",
+    "    d = cmCorrection_col.correct(d)\n",
+    "    d = cmCorrection_row.correct(d)\n",
+    "    d = d.swapaxes(0,-1)\n",
+    "\n",
+    "    # Relative Gain correction\n",
+    "    d_new_map = d*rel_gain_map\n",
+    "    if db_gain_map is not None:\n",
+    "        d_db_map  = d*db_gain_map*gain_conv_const_db\n",
+    "\n",
+    "    # Charge Sharing correction\n",
+    "    d, patterns = patternClassifier.classify(d.swapaxes(0,-1))\n",
+    "    FF_data[index] = d.swapaxes(0,-1) # no gain correction\n",
+    "    \n",
+    "    d_new_map, patterns = patternClassifier.classify(d_new_map.swapaxes(0,-1))\n",
+    "    FF_data_new_map[index] = d_new_map.swapaxes(0,-1) # gain correction with new gain map\n",
+    "    \n",
+    "    if db_gain_map is not None:\n",
+    "        d_db_map, patterns = patternClassifier.classify(d_db_map.swapaxes(0,-1))\n",
+    "        FF_data_db_map[index] = d_db_map.swapaxes(0,-1) # gain correction with DB gain map"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a1319015",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Correct validation trains\n",
+    "step_timer.start()\n",
+    "\n",
+    "N_validation_trains = 1000\n",
+    "\n",
+    "FF_data = psh.alloc(shape=(N_validation_trains,dshape[1],dshape[2]), dtype=np.float32)\n",
+    "FF_data_new_map = psh.alloc(shape=(N_validation_trains,dshape[1],dshape[2]), dtype=np.float32)\n",
+    "if db_gain_map is not None:\n",
+    "    FF_data_db_map = psh.alloc(shape=(N_validation_trains,dshape[1],dshape[2]), dtype=np.float32)\n",
+    "\n",
+    "psh.map(correct_validation_train, data_dc.select_trains(np.s_[:N_validation_trains]))\n",
+    "\n",
+    "step_timer.done_step('Corrected evaluation data. Elapsed Time')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "20f9faa5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Calculate histograms\n",
+    "bins_FF = np.arange(-50,800)\n",
+    "FF_hist_CS = np.histogram(FF_data[FF_data>0].flatten(),bins=bins_FF)[0]\n",
+    "\n",
+    "bins_keV_new = bins_FF/gain_conv_const\n",
+    "FF_hist_GC_new_map = np.histogram(FF_data_new_map/gain_conv_const,bins=bins_keV_new)[0]\n",
+    "\n",
+    "plt.figure(figsize=(12,8))\n",
+    "bins_ADU = bins_FF[:-1] + np.diff(bins_FF)[0]/2 # center of bins\n",
+    "bins_keV_new = bins_keV_new[:-1] + np.diff(bins_keV_new)[0]/2 # center of bins\n",
+    "plt.plot(bins_ADU,FF_hist_CS, color='black', label='Before gain correction')\n",
+    "plt.plot(bins_keV_new*gain_conv_const, FF_hist_GC_new_map, color='b', label='Gain correction with new map')\n",
+    "\n",
+    "if db_gain_map is not None:\n",
+    "    bins_keV_db = bins_FF/gain_conv_const_db\n",
+    "    FF_hist_GC_db_map = np.histogram(FF_data_db_map/gain_conv_const_db,bins=bins_keV_db)[0]\n",
+    "    bins_keV_db = bins_keV_db[:-1] + np.diff(bins_keV_db)[0]/2 # center of bins\n",
+    "    plt.plot(bins_keV_db*gain_conv_const_db, FF_hist_GC_db_map, color='r', label='Gain correction with DB map')\n",
+    "\n",
+    "plt.yscale('log')\n",
+    "plt.xlim(1,bins_FF[-1]+1)\n",
+    "\n",
+    "plt.xlabel('ADU',fontsize=12)\n",
+    "plt.legend(fontsize=12)\n",
+    "plt.title(f'{karabo_id} | {proposal} - r{run}', fontsize=14)\n",
+    "plt.grid(ls=':')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c35bddec",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "N_peaks = 4\n",
+    "sigma_tol = 2 # sigma tolerance to show in gauss fit\n",
+    "\n",
+    "# Ignore split events below primary energy threshold\n",
+    "E_cut = np.mean(const_data['Noise'])*split_evt_primary_threshold/gain_conv_const\n",
+    "\n",
+    "too_many_peaks = True\n",
+    "while too_many_peaks: # Iterate backwards on number of peaks until no exception is thrown\n",
+    "    try:\n",
+    "        FF_hist_AGC_new = FF_hist_GC_new_map/gain_conv_const\n",
+    "        if db_gain_map is not None:\n",
+    "            FF_hist_AGC_db = FF_hist_GC_db_map/gain_conv_const_db\n",
+    "        else:\n",
+    "            FF_hist_AGC_db=None\n",
+    "            bins_keV_db=None\n",
+    "\n",
+    "        E_res,rel_dev,abs_dev = [],[],[]\n",
+    "        colors = ['blue','red']\n",
+    "\n",
+    "        for FF_hist_AGC,bins_keV,leg in zip([FF_hist_AGC_new,FF_hist_AGC_db],[bins_keV_new,bins_keV_db],['new','DB']):\n",
+    "\n",
+    "            if FF_hist_AGC is None:\n",
+    "                continue\n",
+    "\n",
+    "            FF_hist_AGC = FF_hist_AGC[bins_keV>E_cut]\n",
+    "            FF_hist_AGC[0]=0\n",
+    "\n",
+    "            bins_keV = bins_keV[bins_keV>E_cut]\n",
+    "            c = colors[0]\n",
+    "            colors.pop(0)\n",
+    "\n",
+    "            fig = plt.figure(figsize=(12,6))\n",
+    "            plt.suptitle('Correction with '+leg+' gain map',fontsize = 15)\n",
+    "\n",
+    "            plt.fill(bins_keV,FF_hist_AGC, color='k',alpha=.2,label='Corrected data')\n",
+    "            plt.title(f'{karabo_id} | {proposal} - r{run}', fontsize=14)\n",
+    "\n",
+    "            ylim_top = plt.gca().get_ylim()[1]\n",
+    "\n",
+    "            ROI_shift = 0\n",
+    "            for p in range(1,N_peaks+1):\n",
+    "\n",
+    "                peak_ROI = np.array([p*peak_energy-peak_energy/2, p*peak_energy+peak_energy/2]) + ROI_shift\n",
+    "                xx = (bins_keV>peak_ROI[0]) & (bins_keV<peak_ROI[1])\n",
+    "\n",
+    "                coeff, _ = curve_fit(gauss, bins_keV[xx], FF_hist_AGC[xx], p0=[FF_hist_AGC[xx].max(), p*peak_energy, 1])\n",
+    "                y_fit = gauss(bins_keV[xx], *coeff)\n",
+    "\n",
+    "                xx_sigma_lim = (bins_keV>coeff[1]-abs(coeff[2])*sigma_tol) & (bins_keV<coeff[1]+abs(coeff[2])*sigma_tol)\n",
+    "\n",
+    "                plt.vlines(p*peak_energy,0,ylim_top,ls='-',color='grey',label=f'expected peaks')\n",
+    "                plt.fill_between(bins_keV[xx_sigma_lim],\n",
+    "                                 FF_hist_AGC[xx_sigma_lim],\n",
+    "                                 color='orange',\n",
+    "                                 alpha=.5,\n",
+    "                                 label=f'\\u03BC ± {sigma_tol}\\u03c3')\n",
+    "                plt.plot(bins_keV[xx],y_fit,color=c)\n",
+    "                plt.vlines(coeff[1],0,ylim_top,ls='--',color=c,label=f'peak {p}: {coeff[1]:,.2f} keV')\n",
+    "\n",
+    "                ROI_shift = coeff[1] - p*peak_energy   \n",
+    "\n",
+    "                E_res.append(abs(2*np.sqrt(2*np.log(2))*coeff[2]/coeff[1])*100)\n",
+    "                abs_dev.append(coeff[1]-peak_energy*p)\n",
+    "                rel_dev.append(abs(abs_dev[-1])/(peak_energy*p)*100)\n",
+    "\n",
+    "            plt.yscale('log')    \n",
+    "            plt.xlabel('keV',fontsize=12)\n",
+    "            plt.xlim(left=0)\n",
+    "            plt.ylim(.1,ylim_top)\n",
+    "\n",
+    "            # Remove repeated entries from legend\n",
+    "            handles, labels = plt.gca().get_legend_handles_labels()\n",
+    "            by_label = dict(zip(labels, handles))\n",
+    "            plt.legend(by_label.values(), by_label.keys())\n",
+    "            plt.grid(ls=':')\n",
+    "\n",
+    "            t = PrettyTable()\n",
+    "            t.field_names = ['Peak','Energy Resolution','Rel. Deviation','Abs. Deviation']\n",
+    "            t.title = f'{leg} gain map'\n",
+    "            for p in range(-N_peaks,0):\n",
+    "                t.add_row([f'#{p+N_peaks+1}: {peak_energy*(p+N_peaks+1):,.3f} keV',\n",
+    "                            f'{E_res[p]:,.2f} %', \n",
+    "                            f'{rel_dev[p]:,.2f} %',\n",
+    "                            f'{abs_dev[p]:,.2f} keV'])        \n",
+    "            print(t)\n",
+    "            \n",
+    "            too_many_peaks = False\n",
+    "            plt.show()\n",
+    "\n",
+    "    # throw exception if fit fails due to wrong estimate of number of peaks\n",
+    "    except RuntimeError: \n",
+    "        N_peaks -= 1\n",
+    "        plt.close(fig) # delete plots if exception was found due to wrong number of peaks"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "205f27b9",
+   "metadata": {},
+   "source": [
+    "## Linearity Analysis"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d6cf1264",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "peaks = np.arange(1,N_peaks+1)\n",
+    "plt.figure(figsize=(15,6))\n",
+    "plt.subplot(1,2,1)\n",
+    "plt.plot(peaks,[peak_energy*p for p in peaks], '-', c='k', label='expected')\n",
+    "plt.plot(peaks,[peak_energy*p for p in peaks]+np.array(abs_dev[:N_peaks]), 'o', c='b')\n",
+    "fit_coeffs= np.polyfit(peaks,[peak_energy*p for p in peaks]+np.array(abs_dev[:N_peaks]),1)\n",
+    "\n",
+    "plt.plot(peaks,fit_coeffs[0]*peaks+fit_coeffs[1], '--', c='b', label='New gain map')\n",
+    "str_theo  = f'$a_1$={peak_energy :,.4f}, $a_0$=0'\n",
+    "str_new = f'$a_1$={fit_coeffs[0]:,.4f}, $a_0$={fit_coeffs[1]:,.4f}'\n",
+    "plt.annotate(s=str_theo,xy=(.36,.94),xycoords='axes fraction',fontsize=11,bbox=dict(facecolor='k',alpha=.2,pad=1))\n",
+    "plt.annotate(s=str_new ,xy=(.36,.88),xycoords='axes fraction',fontsize=11,bbox=dict(facecolor='b',alpha=.2,pad=1))\n",
+    "\n",
+    "xx = np.arange(1,100,.1) # in photons\n",
+    "y_fit_new = fit_coeffs[0]*xx+fit_coeffs[1] # extrapolation for 100 photons\n",
+    "\n",
+    "plt.xticks(peaks)\n",
+    "plt.title(f'Linearity ({karabo_id} | {proposal} - r{run})')\n",
+    "plt.xlabel('# Photons')\n",
+    "plt.ylabel('Energy (keV)')\n",
+    "plt.legend(fontsize=12)\n",
+    "plt.grid(ls=':')\n",
+    "\n",
+    "plt.subplot(1,2,2)\n",
+    "dev_new = (y_fit_new-(peak_energy*xx))/(peak_energy*xx)*100\n",
+    "plt.plot(xx*peak_energy,dev_new,c='b', label='New gain map')\n",
+    "plt.xscale('log')\n",
+    "plt.xlim(right=100)\n",
+    "plt.xlabel('Energy (keV)')\n",
+    "plt.ylabel('Linearity Deviation (%)')\n",
+    "plt.title(f'Linearity extrapolation ({karabo_id} | {proposal} - r{run})')\n",
+    "plt.grid(ls=':',which='both')\n",
+    "\n",
+    "if db_gain_map is not None:\n",
+    "    plt.subplot(1,2,1)\n",
+    "    \n",
+    "    db_fit = np.polyfit(peaks,[peak_energy*p for p in peaks]+np.array(abs_dev[N_peaks:]),1)\n",
+    "    plt.plot(peaks,[peak_energy*p for p in peaks]+np.array(abs_dev[N_peaks:]), 'o', c='r')\n",
+    "    plt.plot(peaks,db_fit[0]*peaks+db_fit[1], '--', c='r', label='DB gain map')\n",
+    "    \n",
+    "    str_db  = f'$a_1$={db_fit[0] :,.4f}, $a_0$={db_fit[1] :,.4f}'\n",
+    "    y_fit_db = db_fit[0]*xx+db_fit[1] # extrapolation for 100 photons\n",
+    "    plt.annotate(s=str_db  ,xy=(.36,.82),xycoords='axes fraction',fontsize=11,bbox=dict(facecolor='r',alpha=.2,pad=1))\n",
+    "\n",
+    "    plt.subplot(1,2,2)\n",
+    "    dev_db = (y_fit_db-(peak_energy*xx))/(peak_energy*xx)*100\n",
+    "    plt.plot(xx*peak_energy,dev_db,c='r', label='DB gain map')\n",
+    "    plt.legend(fontsize=12)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "441e426a",
+   "metadata": {},
+   "source": [
+    "## Energy Resolution Analysis"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "feb7a5bf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def power_function(x,*p):\n",
+    "    a,b,c = p\n",
+    "    return a*x**b + c\n",
+    "# rough initial estimate of fit parameters\n",
+    "fit_estimates = [20,-.5,0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "25b3f89a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Linearity of the visualized peaks\n",
+    "plt.figure(figsize=(8,6))\n",
+    "\n",
+    "xx = np.arange(0,50,.1)\n",
+    "if db_gain_map is not None:\n",
+    "    plt.plot(peaks*peak_energy,E_res[N_peaks:], 'o', c='r', label='DB gain map')\n",
+    "    coeff,_ = curve_fit(power_function,peaks*peak_energy,E_res[N_peaks:],p0=fit_estimates)\n",
+    "    power_fit = power_function(xx,*coeff)\n",
+    "    plt.plot(xx,power_fit, '--', c='r')\n",
+    "\n",
+    "plt.plot(peaks*peak_energy,E_res[:N_peaks], 'o', c='b', label='New gain map')\n",
+    "coeff,_ = curve_fit(power_function,peaks*peak_energy,E_res[:N_peaks],p0=fit_estimates)\n",
+    "power_fit = power_function(xx,*coeff)\n",
+    "plt.plot(xx,power_fit, '--', c='b')\n",
+    "\n",
+    "plt.title(f'Energy Resolution ({karabo_id} | {proposal} - r{run})')\n",
+    "plt.xlabel('Energy (keV)')\n",
+    "plt.ylabel('Energy Resolution (%)')\n",
+    "plt.legend(fontsize=12)\n",
+    "plt.xlim(1,np.ceil(xx[-1]))\n",
+    "plt.ylim(0,30)\n",
+    "plt.grid(ls=':')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f85f601d",
+   "metadata": {},
+   "source": [
+    "## Calibration Constants DB\n",
+    "Send the flat-field constants (RelativeGain and BadPixelsIlluminated) to the database and/or save them locally."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b898799f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Save constants to DB\n",
+    "\n",
+    "md = None\n",
+    "\n",
+    "constant_maps = {'RelativeGain': abs_gain_map,\n",
+    "                 'BadPixelsIlluminated': const_data['BadPixelsFF']\n",
+    "                } \n",
+    "\n",
+    "for const_name in constant_maps.keys():\n",
+    "    const = getattr(Constants.ePix100, const_name)()\n",
+    "    const.data = constant_maps[const_name].data\n",
+    "\n",
+    "    for parm in illum_condition_db.parameters:\n",
+    "        if parm.name == \"Sensor Temperature\":\n",
+    "            parm.lower_deviation = temp_limits\n",
+    "            parm.upper_deviation = temp_limits\n",
+    "\n",
+    "    # Get physical detector unit\n",
+    "    db_module = get_pdu_from_db(\n",
+    "        karabo_id=karabo_id,\n",
+    "        karabo_da=karabo_da,\n",
+    "        constant=const,\n",
+    "        condition=illum_condition_db,\n",
+    "        cal_db_interface=cal_db_interface,\n",
+    "        snapshot_at=creation_time)[0]\n",
+    "\n",
+    "    # Inject or save calibration constants\n",
+    "    if db_output:\n",
+    "        md = send_to_db(\n",
+    "            db_module=db_module,\n",
+    "            karabo_id=karabo_id,\n",
+    "            constant=const,\n",
+    "            condition=illum_condition_db,\n",
+    "            file_loc=file_loc,\n",
+    "            report_path=report,\n",
+    "            cal_db_interface=cal_db_interface,\n",
+    "            creation_time=creation_time,\n",
+    "            timeout=cal_db_timeout\n",
+    "        )\n",
+    "\n",
+    "    if local_output:\n",
+    "        Path(out_folder).mkdir(parents=True, exist_ok=True)\n",
+    "        md = save_const_to_h5(\n",
+    "            db_module=db_module,\n",
+    "            karabo_id=karabo_id,\n",
+    "            constant=const,\n",
+    "            condition=illum_condition_db,\n",
+    "            data=const.data,\n",
+    "            file_loc=file_loc,\n",
+    "            report=report,\n",
+    "            creation_time=creation_time,\n",
+    "            out_folder=out_folder\n",
+    "        )\n",
+    "        print(f\"Calibration constant {const_name} is stored locally at {out_folder} \\n\")\n",
+    "\n",
+    "print(\"Constants parameter conditions are:\\n\"\n",
+    "      f\"• Bias voltage: {bias_voltage}\\n\"\n",
+    "      f\"• Integration time: {integration_time}\\n\"\n",
+    "      f\"• Temperature: {temperature_k}\\n\"\n",
+    "      f\"• Source Energy: {peak_energy}\\n\"      \n",
+    "      f\"• In Vacuum: {in_vacuum}\\n\"\n",
+    "      f\"• Creation time: {md.calibration_constant_version.begin_at if md is not None else creation_time}\\n\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "cal_venv",
+   "language": "python",
+   "name": "cal_venv"
+  },
+  "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.8.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/notebooks/ePix100/Correction_ePix100_NBC.ipynb b/notebooks/ePix100/Correction_ePix100_NBC.ipynb
index 89fa139226537207b3b447893c3a26c57333ccb5..b7db6722739c7d81852329e296cacf48005a8221 100644
--- a/notebooks/ePix100/Correction_ePix100_NBC.ipynb
+++ b/notebooks/ePix100/Correction_ePix100_NBC.ipynb
@@ -98,10 +98,9 @@
     "\n",
     "import cal_tools.restful_config as rest_cfg\n",
     "from XFELDetAna import xfelpycaltools as xcal\n",
-    "from cal_tools.calcat_interface import EPIX100_CalibrationData\n",
+    "from cal_tools.calcat_interface import EPIX100_CalibrationData, CalCatError\n",
     "from cal_tools.epix100 import epix100lib\n",
     "from cal_tools.files import DataFile\n",
-    "from cal_tools.restful_config import restful_config\n",
     "from cal_tools.tools import (\n",
     "    calcat_creation_time,\n",
     "    write_constants_fragment,\n",
@@ -269,10 +268,6 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "constant_names = [\"OffsetEPix100\", \"NoiseEPix100\"]\n",
-    "if relative_gain:\n",
-    "    constant_names += [\"RelativeGainEPix100\"]\n",
-    "\n",
     "epix_cal = EPIX100_CalibrationData(\n",
     "    detector_name=karabo_id,\n",
     "    sensor_bias_voltage=bias_voltage,\n",
@@ -283,7 +278,17 @@
     "    event_at=creation_time,\n",
     "    client=rest_cfg.calibration_client(),\n",
     ")\n",
-    "const_metadata = epix_cal.metadata(calibrations=constant_names)\n",
+    "\n",
+    "const_metadata = epix_cal.metadata(calibrations=epix_cal.dark_calibrations)\n",
+    "\n",
+    "if relative_gain:\n",
+    "    try:\n",
+    "        metadata = epix_cal.metadata(epix_cal.illuminated_calibrations)\n",
+    "        for key, value in metadata.items():\n",
+    "            const_metadata.setdefault(key, {}).update(value)\n",
+    "    except CalCatError as e:\n",
+    "        warning(f\"CalCatError: {e}\")\n",
+    "\n",
     "# Display retrieved calibration constants timestamps\n",
     "epix_cal.display_markdown_retrieved_constants(metadata=const_metadata)\n",
     "# Load the constant data from files\n",
diff --git a/notebooks/generic/overallmodules_Darks_Summary_NBC.ipynb b/notebooks/generic/overallmodules_Darks_Summary_NBC.ipynb
index 0b5f1c966a23d46ac014612c967240be4e314c05..bb68d84433a6e013908334397faa75f1600ac49f 100644
--- a/notebooks/generic/overallmodules_Darks_Summary_NBC.ipynb
+++ b/notebooks/generic/overallmodules_Darks_Summary_NBC.ipynb
@@ -30,16 +30,11 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import copy\n",
-    "import os\n",
     "import warnings\n",
-    "from collections import OrderedDict\n",
     "from pathlib import Path\n",
     "\n",
     "warnings.filterwarnings('ignore')\n",
     "\n",
-    "import glob\n",
-    "\n",
     "import h5py\n",
     "import matplotlib\n",
     "import numpy as np\n",
@@ -54,12 +49,24 @@
     "%matplotlib inline\n",
     "import extra_geom\n",
     "import tabulate\n",
+    "from cal_tools import step_timing\n",
     "from cal_tools.ana_tools import get_range\n",
+    "from cal_tools.enums import BadPixels\n",
     "from cal_tools.plotting import show_processed_modules\n",
     "from cal_tools.tools import CalibrationMetadata, module_index_to_qm\n",
     "from XFELDetAna.plotting.simpleplot import simplePlot"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def bp_entry(bp):\n",
+    "    return [f\"{bp.name:<30s}\", f\"{bp.value:032b}\", f\"{int(bp.value)}\"]"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -79,21 +86,34 @@
     "    # This list needs to be in that order as later Adaptive or fixed gain is\n",
     "    # decided based on the condition for the Offset constant.\n",
     "    expected_constants = ['Offset', 'Noise', 'ThresholdsDark', 'BadPixelsDark']\n",
+    "\n",
+    "    table = []\n",
+    "    badpixels = [\n",
+    "        BadPixels.OFFSET_OUT_OF_THRESHOLD,\n",
+    "        BadPixels.NOISE_OUT_OF_THRESHOLD,\n",
+    "        BadPixels.OFFSET_NOISE_EVAL_ERROR,\n",
+    "        BadPixels.GAIN_THRESHOLDING_ERROR,\n",
+    "    ]\n",
+    "    for bp in badpixels:\n",
+    "        table.append(bp_entry(bp))\n",
+    "\n",
     "    display(Markdown(\"\"\"\n",
-    "    \n",
     "# Summary of AGIPD dark characterization #\n",
     "\n",
-    "The following report shows a set of dark images taken with the AGIPD detector to deduce detector offsets, noise, bad-pixel maps and thresholding. All four types of constants are evaluated per-pixel and per-memory cell.\n",
-    "\n",
+    "The following report shows a set of dark images taken with the AGIPD detector to deduce detector offsets, \n",
+    "noise, bad-pixel maps and thresholding. All four types of constants are evaluated per-pixel and per-memory cell.\n",
     "\n",
-    "**The offset** ($O$) is defined as the median ($M$) of the dark signal ($Ds$) over trains ($t$) for a given pixel ($x,y$) and memory cell ($c$). \n",
+    "**The offset** ($O$) is defined as the median ($M$) of the dark signal ($Ds$) over trains ($t$) for a given pixel \n",
+    "($x,y$) and memory cell ($c$). \n",
     "\n",
     "**The noise** $N$ is the standard deviation $\\sigma$ of the dark signal.\n",
     "\n",
     "$$ O_{x,y,c} = M(Ds)_{t} ,\\,\\,\\,\\,\\,\\, N_{x,y,c} = \\sigma(Ds)_{t}$$\n",
     "\n",
-    "**The bad pixel** mask is encoded as a bit mask.\n",
+    "**The bad pixel** mask is encoded as a bit mask.\"\"\"))\n",
     "\n",
+    "    display(Latex(tabulate.tabulate(table, tablefmt='latex', headers=[\"Name\", \"bit value\", \"integer value\"])))\n",
+    "    display(Markdown(\"\"\"\n",
     "**\"OFFSET_OUT_OF_THRESHOLD\":**\n",
     "\n",
     "Offset outside of bounds:\n",
@@ -120,7 +140,7 @@
     "\n",
     "Values: $\\mathrm{thresholds\\_offset\\_sigma}$, $\\mathrm{thresholds\\_offset\\_hard}$, $\\mathrm{thresholds\\_noise\\_sigma}$, $\\mathrm{thresholds\\_noise\\_hard}$ are given as parameters.\n",
     "\n",
-    "\"**\\\"GAIN_THRESHOLDING_ERROR\\\":**\n",
+    "**\"GAIN_THRESHOLDING_ERROR\":**\n",
     "\n",
     "Bad gain separated pixels with sigma separation less than gain_separation_sigma_threshold\n",
     "\n",
@@ -128,11 +148,20 @@
     "$$ Bad\\_separation = sigma\\_separation < \\mathrm{gain\\_separation\\_sigma\\_threshold} $$\n",
     "\n",
     "\"\"\"))\n",
+    "\n",
     "    \n",
     "elif \"LPD\" in karabo_id:\n",
     "    dinstance = \"LPD1M1\"\n",
     "    nmods = 16\n",
     "    expected_constants = ['Offset', 'Noise', 'BadPixelsDark']\n",
+    "    table = []\n",
+    "    badpixels = [\n",
+    "        BadPixels.OFFSET_OUT_OF_THRESHOLD,\n",
+    "        BadPixels.NOISE_OUT_OF_THRESHOLD,\n",
+    "        BadPixels.OFFSET_NOISE_EVAL_ERROR,\n",
+    "    ]\n",
+    "    for bp in badpixels:\n",
+    "        table.append(bp_entry(bp))\n",
     "    display(Markdown(\"\"\"\n",
     "    \n",
     "# Summary of LPD dark characterization #\n",
@@ -145,7 +174,9 @@
     "\n",
     "$$ O_{x,y,c} = M(Ds)_{t} ,\\,\\,\\,\\,\\,\\, N_{x,y,c} = \\sigma(Ds)_{t}$$\n",
     "\n",
-    "**The bad pixel** mask is encoded as a bit mask.\n",
+    "**The bad pixel** mask is encoded as a bit mask.\"\"\"))\n",
+    "    display(Latex(tabulate.tabulate(table, tablefmt='latex', headers=[\"Name\", \"bit value\", \"integer value\"])))\n",
+    "    display(Markdown(\"\"\"\n",
     "\n",
     "**\"OFFSET_OUT_OF_THRESHOLD\":**\n",
     "\n",
@@ -190,6 +221,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "step_timer = step_timing.StepTimer()\n",
     "out_folder = Path(out_folder)\n",
     "metadata = CalibrationMetadata(metadata_folder or out_folder)\n",
     "mod_mapping = metadata.setdefault(\"modules-mapping\", {})\n",
@@ -241,6 +273,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "step_timer.start()\n",
     "# Get shape, dtype, and number of files for each constant.\n",
     "# Also build lists of the files involved, to be loaded in parallel in a later cell.\n",
     "const_shape_and_dtype = {}\n",
@@ -288,7 +321,8 @@
     "prev_const = {\n",
     "    cname: psh.alloc((nmods_found,) + module_const_shape, dtype=dt, fill=0)\n",
     "    for cname, (module_const_shape, dt) in const_shape_and_dtype.items()\n",
-    "}"
+    "}\n",
+    "step_timer.done_step(\"Preparing arrays for old and new constants.\")"
    ]
   },
   {
@@ -297,6 +331,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "step_timer.start()\n",
     "# Load the constant data in parallel\n",
     "found_module_nums = sorted(found_module_nums)\n",
     "mod_names = [module_index_to_qm(n) for n in found_module_nums]\n",
@@ -319,7 +354,8 @@
     "        f[h5path]['data'].read_direct(prev_const[cname][mod_ix])\n",
     "\n",
     "psh.map(load_piece_prev, pieces_to_load_prev)\n",
-    "print(f\"Loaded previous constant data from {len(pieces_to_load_prev)} files\")"
+    "print(f\"Loaded previous constant data from {len(pieces_to_load_prev)} files\")\n",
+    "step_timer.done_step(\"Loading constants data.\")"
    ]
   },
   {
@@ -433,6 +469,8 @@
    },
    "outputs": [],
    "source": [
+    "step_timer.start()\n",
+    "\n",
     "gainstages = 1\n",
     "\n",
     "for const_name, const in constants.items():\n",
@@ -483,7 +521,8 @@
     "\n",
     "        plot_const_and_delta(stacked_const, stacked_delta, const_name, glabel)\n",
     "\n",
-    "        plt.show()"
+    "        plt.show()\n",
+    "step_timer.done_step(\"Plotting constants and relative differences.\")"
    ]
   },
   {
@@ -495,6 +534,7 @@
    "outputs": [],
    "source": [
     "# Loop over modules and constants\n",
+    "step_timer.start()\n",
     "for const_name, const in constants.items():\n",
     "    if const_name == 'BadPixelsDark':\n",
     "        continue  # Displayed separately below\n",
@@ -579,7 +619,8 @@
     "                            legend='outside-top-ncol6-frame', legend_size='18%',\n",
     "                            legend_pad=0.00)\n",
     "\n",
-    "        plt.show()"
+    "        plt.show()\n",
+    "step_timer.done_step(\"Plotting summary across modules.\")"
    ]
   },
   {
@@ -589,6 +630,7 @@
    "outputs": [],
    "source": [
     "if 'BadPixelsDark' in constants:\n",
+    "    step_timer.start()\n",
     "    display(Markdown(f'### Summary across Modules - BadPixelsDark'))\n",
     "\n",
     "    bad_px_dark = constants['BadPixelsDark']\n",
@@ -626,7 +668,8 @@
     "                            legend='outside-top-ncol6-frame', legend_size='18%',\n",
     "                            legend_pad=0.00)\n",
     "\n",
-    "        plt.show()"
+    "        plt.show()\n",
+    "    step_timer.done_step(\"Summary across modules for BadPixels.\")"
    ]
   },
   {
@@ -657,6 +700,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "step_timer.start()\n",
     "head = ['Module', 'High gain', 'Medium gain', 'Low gain']\n",
     "head_th = ['Module', 'HG_MG threshold', 'MG_LG threshold']\n",
     "for const_name, const in constants.items():\n",
@@ -702,7 +746,8 @@
     "    display(Markdown(label))\n",
     "    header = head_th if const_name == 'ThresholdsDark' else head\n",
     "    md = display(Latex(tabulate.tabulate(\n",
-    "        table, tablefmt='latex', headers=header)))"
+    "        table, tablefmt='latex', headers=header)))\n",
+    "step_timer.done_step(\"Summary tables across modules.\")"
    ]
   },
   {
@@ -712,7 +757,8 @@
    "outputs": [],
    "source": [
     "# Bad pixels summary table\n",
-    "if 'BadPixelsDark' in constants:    \n",
+    "if 'BadPixelsDark' in constants:\n",
+    "    step_timer.start()\n",
     "    bad_px_dark = constants['BadPixelsDark']\n",
     "\n",
     "    table = []\n",
@@ -736,7 +782,8 @@
     "\n",
     "    display(Markdown(label))\n",
     "    md = display(Latex(tabulate.tabulate(\n",
-    "        table, tablefmt='latex', headers=head)))"
+    "        table, tablefmt='latex', headers=head)))\n",
+    "    step_timer.done_step(\"Summary table across modules for BadPixels.\")"
    ]
   }
  ],
diff --git a/setup.py b/setup.py
index 65168fc2b4f89c8dbd4a39850c3b653fe6443369..fdc0a8883c42c71407a4474a6a4673a5bb5be8e6 100644
--- a/setup.py
+++ b/setup.py
@@ -63,7 +63,7 @@ install_requires = [
         "docutils==0.17.1",
         "dynaconf==3.1.4",
         "env_cache==0.1",
-        "extra_data==1.12.0",
+        "extra_data==1.15.1",
         "extra_geom==1.10.0",
         "gitpython==3.1.0",
         "h5py==3.5.0",
@@ -110,7 +110,7 @@ if "readthedocs.org" not in sys.executable:
     install_requires += [
         "iCalibrationDB @ git+ssh://git@git.xfel.eu:10022/detectors/cal_db_interactive.git@2.4.2",  # noqa
         "XFELDetectorAnalysis @ git+ssh://git@git.xfel.eu:10022/karaboDevices/pyDetLib.git@2.7.0",  # noqa
-        "CalParrot @ git+ssh://git@git.xfel.eu:10022/calibration/calparrot.git@0.2",  # noqa
+        "CalParrot @ git+ssh://git@git.xfel.eu:10022/calibration/calparrot.git@0.3",  # noqa
     ]
 
 setup(
@@ -153,16 +153,7 @@ setup(
         ],
         "test": [
             "coverage",
-            "nbval",
-            "pytest-asyncio",
-            "pytest-cov",
-            "pytest-subprocess",
-            "pytest>=5.4.0",
-            "testpath",
-            "unittest-xml-reporting==3.0.2",
-        ],
-        "automated_test": [
-            "coverage",
+            "deepdiff==6.7.1",
             "nbval",
             "pytest-asyncio",
             "pytest-cov",
diff --git a/src/__init__.py b/src/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/cal_tools/agipdlib.py b/src/cal_tools/agipdlib.py
index 60e245ab4527bee12e8e890512fb508b4330565d..1b87470d3e7222a9d0dfcd5fff8ff428dc8940fc 100644
--- a/src/cal_tools/agipdlib.py
+++ b/src/cal_tools/agipdlib.py
@@ -1,7 +1,9 @@
 import os
 import posixpath
 import zlib
+from dataclasses import dataclass, field
 from datetime import datetime
+from logging import warning
 from multiprocessing import Manager
 from multiprocessing.pool import ThreadPool
 from typing import List, Optional
@@ -10,45 +12,40 @@ import h5py
 import numpy as np
 import sharedmem
 from dateutil import parser
-from extra_data import DataCollection, H5File, by_id, components
+from extra_data import DataCollection, H5File, RunDirectory, by_id
 
 from cal_tools import agipdalgs as calgs
 from cal_tools.agipdutils import (
     baseline_correct_via_noise,
     baseline_correct_via_stripe,
+    cast_array_inplace,
     correct_baseline_via_hist,
     correct_baseline_via_hist_asic,
     make_noisy_adc_mask,
     match_asic_borders,
     melt_snowy_pixels,
-    cast_array_inplace
 )
 from cal_tools.enums import AgipdGainMode, BadPixels, SnowResolution
 from cal_tools.h5_copy_except import h5_copy_except_paths
 
 
+@dataclass
 class AgipdCtrl:
-    def __init__(
-        self,
-        run_dc: DataCollection,
-        image_src: str,
-        ctrl_src: str,
-        raise_error: bool = True,
-    ):
-        """ Initialize AgipdCondition class to read
-        all required AGIPD parameters.
-
-        :param run_dc: Run data collection with expected sources
-        to read needed parameters.
-        :param image_src: H5 source for image data.
-        :param ctrl_src: H5 source for control (slow) data.
-        :param raise_error: Boolean to raise errors for missing
-        sources and keys.
-        """
-        self.run_dc = run_dc
-        self.image_src = image_src
-        self.ctrl_src = ctrl_src
-        self.raise_error = raise_error
+    """Access AGIPD control parameters from a single run.
+
+    Args:
+        run_dc (DataCollection): Run data collection with expected sources
+            to read needed parameters.
+        image_src (str): H5 source for image data.
+        ctrl_src (str): H5 source for control (slow) data.
+        raise_error (bool): Boolean to raise errors for missing
+            sources and keys.
+        run: (int, optional): Run number.
+    """
+    run_dc: DataCollection
+    image_src: str
+    ctrl_src: str
+    raise_error: bool = False
 
     def _get_num_cells_ctrl(self) -> Optional[int]:
         """Get number of cells from CONTROL source."""
@@ -296,6 +293,171 @@ class AgipdCtrl:
         return 12
 
 
+@dataclass
+class AgipdCtrlRuns:
+    """Get AGIPD control parameters across several runs,
+    e.g. 3 runs for darks.
+
+    Args:
+        raw_folder (str): The RAW folder path.
+        runs (list): The list of runs to read the operating conditions.
+        image_src (str): H5 source for image data.
+        ctrl_src (str): H5 source for control (slow) data.
+    """
+    raw_folder: str
+    runs: List[int]
+    image_src: str
+    ctrl_src: str
+    sort_dark_runs_enabled: bool = False
+
+    adaptive_gain_modes = [AgipdGainMode.ADAPTIVE_GAIN] * 3
+    fixed_gain_modes = [
+        AgipdGainMode.FIXED_HIGH_GAIN,
+        AgipdGainMode.FIXED_MEDIUM_GAIN,
+        AgipdGainMode.FIXED_LOW_GAIN,
+    ]
+
+    def __post_init__(self):
+        # validate that all runs belong to the same
+        self.run_ctrls = [
+            AgipdCtrl(
+                run_dc=RunDirectory(f"{self.raw_folder}/r{r:04d}"),
+                image_src=self.image_src,
+                ctrl_src=self.ctrl_src,
+                ) for r in self.runs]
+        self.gain_modes = self.get_gain_modes()
+        if self.sort_dark_runs_enabled:
+            self.sort_dark_runs()
+
+    def _validate_same_value(self, name, values):
+            if len(set(values)) != 1:
+                # Should we raise an error and stop processing?
+                warning(
+                    f"{name} is not the same for all runs {self.runs}"
+                    f" with values of {values}, respectively.")
+
+    def sort_dark_runs(self):
+        """Order dark runs based on run patterns for Adaptive mode
+        or gain modes for Fixed mode.
+        """
+        assert len(self.runs) == 3, f"AGIPD dark runs are expected to be 3. {len(self.runs)} runs are given."  # noqa
+        # Expected patterns:
+        # XRay: 0, DarkHG: 1, DarkMG: 2, DarkLG: 3, PC: 4 and CS: 5.
+        sort_by = None
+        sort_values = []
+        if self.gain_modes == self.adaptive_gain_modes:  # Adaptive gain # sort by patterns
+            # Patterns -> DarkHG: 1, DarkMG: 2, DarkLG: 3
+            if "AGIPD1M" in self.ctrl_src:
+                sort_by = "patternTypeIndex"
+            elif "AGIPD500K" in self.ctrl_src:
+                sort_by = "expTypeIndex"
+
+            for c in self.run_ctrls:
+                sort_values.append(
+                    c.run_dc[self.ctrl_src, sort_by].as_single_value())
+
+        # Check if a mix of adaptive and fixed gain runs.
+        elif any(gm == AgipdGainMode.ADAPTIVE_GAIN for gm in self.gain_modes):
+            raise ValueError(
+                f"Given runs {self.runs} have a mix of ADAPTIVE and "
+                f"FIXED gain modes: {self.gain_modes}.")
+        else:  # Fixed gain: Patterns is X-Ray: 0 for all runs.
+            sort_by = "gainModeIndex"
+            sort_values = [int(gm) for gm in self.gain_modes]
+
+        zipped_lists = zip(sort_values, self.runs, self.run_ctrls)
+
+        # Sort the lists based on the patterns
+        sorted_zipped_lists = sorted(zipped_lists, key=lambda item: item[0])
+        _, sorted_runs, sorted_run_ctrls = zip(*sorted_zipped_lists)
+        if sorted_runs != self.runs:
+            Warning("Given dark runs are unsorted. Runs will be sorted from"
+                    f" {self.runs} with {sort_by}:"
+                    f" {sort_values} to {sorted_runs}.")
+            # Update run_ctrls and runs order
+            self.runs = list(sorted_runs)
+            self.run_ctrls = list(sorted_run_ctrls)
+            self.gain_modes = self.get_gain_modes()
+
+    def fixed_gain_mode(self):
+        """Check if runs are in fixed gain mode.
+
+        Raises:
+            ValueError: Unexpected gain modes for the dark runs
+
+        Returns:
+            bool: runs are in fixed gain mode.
+        """
+        if self.gain_modes == self.adaptive_gain_modes:
+            return False
+        elif self.gain_modes == self.fixed_gain_modes:
+            return True
+        else:
+            raise ValueError(f"Unexpected runs' gain modes: {self.gain_modes}")
+
+    def get_gain_modes(self):
+        """Get runs' gain modes.
+        Returns:
+            list: `AgipdGainMode`s
+        """
+        return [c.get_gain_mode() for c in self.run_ctrls]
+
+    def get_integration_time(self):
+        """
+        Returns:
+            float: Integration time
+        """
+        integration_times = [c.get_integration_time() for c in self.run_ctrls]
+        self._validate_same_value("Integration Time", integration_times)
+        return integration_times[0]
+
+    def get_bias_voltage(self, karabo_id_control: str = None):
+        """
+        Args:
+            karabo_id_control (str):
+                Karabo ID for control device.
+
+        Returns:
+            int: Bias voltage.
+        """
+        bias_voltages = [
+            c.get_bias_voltage(karabo_id_control) for c in self.run_ctrls]
+        self._validate_same_value("Bias Voltage", bias_voltages)
+        return bias_voltages[0]
+
+    def get_memory_cells(self):
+        """
+        Returns:
+            int: number of memory cells.
+        """
+        memory_cells = [c.get_num_cells() for c in self.run_ctrls]
+        self._validate_same_value("Memory cells", memory_cells)
+        return memory_cells[0]
+
+    def get_gain_setting(self, creation_time: Optional[datetime] = None):
+        """
+        Args:
+            creation_time (Optional[datetime], optional):
+                Creation time for the runs.
+
+        Returns:
+            float: Gain Setting
+        """
+        gain_settings = [
+            c.get_gain_setting(creation_time) for c in self.run_ctrls]
+        self._validate_same_value("Gain Setting", gain_settings)
+        return gain_settings[0]
+
+    def get_acq_rate(self):
+        """
+        Returns:
+            float: Acquisition rate
+        """
+        acquisition_rates = [c.get_acq_rate() for c in self.run_ctrls]
+        self._validate_same_value("acquisition_rate", acquisition_rates)
+        return acquisition_rates[0]
+
+
 class CellSelection:
     """Selection of detector memory cells (abstract class)"""
     row_size = 32
@@ -424,6 +586,7 @@ class AgipdCorrections:
         self.noisy_adc_threshold = 0.25
         self.ff_gain = 1
         self.photon_energy = 9.2
+        self.rounding_threshold = 0.5
 
         # Output parameters
         self.compress_fields = ['gain', 'mask']
@@ -519,50 +682,45 @@ class AgipdCorrections:
         valid_train_ids = im_dc.train_ids
         # Get a count of images in each train
         nimg_in_trains = im_dc[agipd_base, "image.trainId"].data_counts(False)
-        nimg_in_trains = nimg_in_trains.astype(int)
+        nimg_in_trains = nimg_in_trains.astype(np.int64)
 
         # store valid trains in shared memory
         n_valid_trains = len(valid_train_ids)
         data_dict["n_valid_trains"][0] = n_valid_trains
         data_dict["valid_trains"][:n_valid_trains] = valid_train_ids
 
-        if "AGIPD500K" in agipd_base:
-            agipd_comp = components.AGIPD500K(im_dc)
-        else:
-            agipd_comp = components.AGIPD1M(im_dc)
-
-        kw = {
-            "unstack_pulses": False,
-        }
-
         # get selection for the images in this file
         cm = (self.cell_sel.CM_NONE if apply_sel_pulses
               else self.cell_sel.CM_PRESEL)
 
-        cellid = np.squeeze(im_dc[agipd_base, "image.cellId"].ndarray())
+        agipd_src = im_dc[agipd_base]
+
+        cellid = agipd_src["image.cellId"].ndarray()[:, 0]
 
         img_selected, nimg_in_trains = self.cell_sel.get_cells_on_trains(
             np.array(valid_train_ids), nimg_in_trains, cellid, cm=cm)
-        data_dict["nimg_in_trains"][:n_valid_trains] = nimg_in_trains
 
-        frm_ix = np.flatnonzero(img_selected)
+        data_dict["nimg_in_trains"][:n_valid_trains] = nimg_in_trains
         data_dict["cm_presel"][0] = (cm == self.cell_sel.CM_PRESEL)
-        n_img = len(frm_ix)
+
+        n_img = img_selected.sum()
+        if img_selected.all():
+            # All frames selected - use slice to skip unnecessary copy
+            frm_ix = np.s_[:]
+        else:
+            frm_ix = np.flatnonzero(img_selected)
 
         # read raw data
-        # [n_modules, n_imgs, 2, x, y]
-        raw_data = agipd_comp.get_array("image.data", **kw)[0]
+        # [n_imgs, 2, x, y]
+        raw_data = agipd_src['image.data'].ndarray()
 
         # store in shmem only selected images
         data_dict['nImg'][0] = n_img
         data_dict['data'][:n_img] = raw_data[frm_ix, 0]
         data_dict['rawgain'][:n_img] = raw_data[frm_ix, 1]
-        data_dict['cellId'][:n_img] = agipd_comp.get_array(
-            "image.cellId", **kw)[0, frm_ix]
-        data_dict['pulseId'][:n_img] = agipd_comp.get_array(
-            "image.pulseId", **kw)[0, frm_ix]
-        data_dict['trainId'][:n_img] = agipd_comp.get_array(
-            "image.trainId", **kw)[0, frm_ix]
+        data_dict['cellId'][:n_img] = cellid[frm_ix]
+        data_dict['pulseId'][:n_img] = agipd_src['image.pulseId'].ndarray()[frm_ix, 0]
+        data_dict['trainId'][:n_img] = agipd_src['image.trainId'].ndarray()[frm_ix, 0]
 
         return n_img
 
@@ -929,13 +1087,19 @@ class AgipdCorrections:
             data_hist_preround, _ = np.histogram(data, bins=self.hist_bins_preround)
 
             data /= self.photon_energy
-            np.round(data, out=data)
 
-            # This could also be done before and its mask inverted for
-            # rounding, but the performance difference is negligible.
-            bidx = data < 0
-            data[bidx] = 0
+            # keep the noise peak symmetrical so that
+            # the expected value of zero remains unshifted
+            bidx = data < -self.rounding_threshold
             msk[bidx] |= BadPixels.VALUE_OUT_OF_RANGE
+
+            np.subtract(data, self.rounding_threshold - 0.5, out=data, where=~bidx)
+            np.round(data, out=data)
+
+            # the interval of the noise peak may be greater than one,
+            # which is why some of the noise values may be negative after rounding,
+            # but should be not masked
+            data[data < 0.0] = 0.0
             del bidx
 
             data_hist_postround, _ = np.histogram(data * self.photon_energy,
diff --git a/src/cal_tools/calcat_interface.py b/src/cal_tools/calcat_interface.py
index db67afc900f82e1949dd2ef9ce37d76502a4eda4..b6fae338496ad62a1ddf33c3c6d768dcc1c8796e 100644
--- a/src/cal_tools/calcat_interface.py
+++ b/src/cal_tools/calcat_interface.py
@@ -1361,7 +1361,8 @@ class GOTTHARD2_CalibrationData(CalibrationData):
     """Calibration data for the Gotthard II detector."""
 
     calibrations = {
-        "LUTGotthard2" "OffsetGotthard2",
+        "LUTGotthard2",
+        "OffsetGotthard2",
         "NoiseGotthard2",
         "BadPixelsDarkGotthard2",
         "RelativeGainGotthard2",
diff --git a/src/cal_tools/dssclib.py b/src/cal_tools/dssclib.py
index 59ca874d2c896224418347577f2a991789fb00b4..a17ec3648524c7449e3e20cae44c4348965bbcc8 100644
--- a/src/cal_tools/dssclib.py
+++ b/src/cal_tools/dssclib.py
@@ -9,6 +9,16 @@ import h5py
 import numpy as np
 
 
+def get_num_cells(fname, h5path):
+
+    with h5py.File(fname, "r") as f:
+        cells = f[f"{h5path}/cellId"][()]
+        if cells == []:
+            return
+        maxcell = np.max(cells)
+        return maxcell+1
+
+
 def get_pulseid_checksum(fname, h5path, h5path_idx):
     """generates hash value from pulse pattern (veto defined)."""
     with h5py.File(fname, "r") as infile:
diff --git a/src/cal_tools/enums.py b/src/cal_tools/enums.py
index eeebf151d8582255a1f66ce77a3c58c303590a7b..94c8dccea76265290f317aecf4f88eb473b90612 100644
--- a/src/cal_tools/enums.py
+++ b/src/cal_tools/enums.py
@@ -48,7 +48,6 @@ class AgipdGainMode(IntEnum):
 
 class JungfrauSettings(Enum):
     """Jungfrau run gain settings."""
-    # old setting, new setting, new mode
     GAIN_0 = "gain0"
     HIGH_GAIN_0 = "highgain0"
 
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/files.py b/src/cal_tools/files.py
index 8decff781ace9cb7bcdbddf590f9478de1eeb87f..91766f0662f436cfa975eb566478c091c7d73071 100644
--- a/src/cal_tools/files.py
+++ b/src/cal_tools/files.py
@@ -1,5 +1,5 @@
 
-from datetime import datetime
+from datetime import datetime, timezone
 from itertools import chain
 from numbers import Integral
 from pathlib import Path
@@ -311,10 +311,14 @@ class DataFile(h5py.File):
                 sequence = self.__sequence
 
         if creation_date is None:
-            creation_date = datetime.now()
+            creation_date = datetime.fromtimestamp(0, tz=timezone.utc)
+        elif creation_date is True:
+            creation_date = datetime.now(timezone.utc)
 
         if update_date is None:
             update_date = creation_date
+        elif update_date is True:
+            update_date = datetime.now(timezone.utc)
 
         md_group = self.require_group('METADATA')
         md_group.create_dataset(
diff --git a/src/cal_tools/gotthard2/gotthard2lib.py b/src/cal_tools/gotthard2/gotthard2lib.py
index 2d4ae564b2b634bb3728d601a8e4a5a33e45ccb1..cd37535e4c69cad1f1cd0ebb5f3f1bed4f3280bd 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,18 @@ 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())
+
+    def get_det_type(self):
+        """GH2 rxHostname is a vector of bytes objects.
+        GH2 25um has two host names unlike 50um which has one.
+
+        Returns:
+            str: return if its a 25um or 50um detector.
+        """
+
+        hostname = self.run_dc.get_run_value(self.ctrl_src, "rxHostname")
+        return "25um" if hostname[1].decode("utf-8") else "50um"
diff --git a/src/cal_tools/jfstrixel.py b/src/cal_tools/jfstrixel.py
deleted file mode 100644
index 189b036f6cddf4aaa8ba802e908a999afb6cdfe3..0000000000000000000000000000000000000000
--- a/src/cal_tools/jfstrixel.py
+++ /dev/null
@@ -1,161 +0,0 @@
-
-import numpy as np
-
-
-REGULAR_SHAPE = (512, 1024)
-STRIXEL_SHAPE = (86, 3090)
-
-
-def _normal_indices():
-    """Build normal size pixel indices."""
-    
-    # Normal pixels
-    yin = np.arange(256)
-    xin = np.arange(1024)
-
-    Yin, Xin = np.meshgrid(yin, xin)
-    Yout, Xout = np.meshgrid(yin // 3, (xin // 256 * 774) + (xin % 256) * 3)
-    Xout += (yin % 3).astype(int)[None, :]
-    
-    return Yout, Xout, Yin, Xin
-
-
-def _gap_indices(in_gap_offset=0, out_gap_offset=0,
-                 xout_factor=+1, yout_offset=0):
-    """Build one half of double size gap pixel indices."""
-    
-    igap = np.arange(3)
-    yin = np.arange(256)
-
-    Yin, Xin = np.meshgrid(yin, igap * 256 + 255 + in_gap_offset)
-    Yout, Xout = np.meshgrid(yin // 6 * 2, igap * 774 + 765 + out_gap_offset)
-    Xout += xout_factor * (yin % 6).astype(int)[None, :]
-    Yout += yout_offset
-    
-    return Yout, Xout, Yin, Xin
-
-
-def transformation_indices2d():
-    """Build 2D strixel transformation index arrays."""
-    
-    # Each of this index sets contains four 2D index arrays
-    # Yout, Xout, Yin, Xin from different parts constituting the full
-    # strixel frame. They are each concatenated across these parts into
-    # four final index arrays to be used for translating between the
-    # regular frame and the strixel frame.
-    index_sets = [
-        _normal_indices(),
-        
-        # Left gap
-        _gap_indices(0, 0, +1, 0), _gap_indices(0, 0, +1, 1),
-        
-        # Right gap
-        _gap_indices(1, 11, -1, 0), _gap_indices(1, 11, -1, 1)
-    ]
-    
-    # Yout, Xout, Yin, Xin
-    # Casting to int64 improves indexing performance by up to 30%.
-    return [np.concatenate(index_set).astype(np.int64)
-            for index_set in zip(*index_sets)]
-
-
-def transformation_indices1d():
-    """Build 1D strixel transformation index arrays.
-    
-    Internally this function reduces the 2D index arrays to a single
-    dimension to operate on raveled data arrays. This improves the
-    transformation performance substantially by up to 3x.
-    """
-
-    Yout, Xout, Yin, Xin = transformation_indices2d()
-     
-    regular_pixel_idx = np.arange(np.prod(REGULAR_SHAPE), dtype=np.uint32) \
-        .reshape(REGULAR_SHAPE)
-    strixel_pixel_idx = np.empty(STRIXEL_SHAPE, dtype=np.int64)
-    strixel_pixel_idx.fill(-1)
-    strixel_pixel_idx[Yout, Xout] = regular_pixel_idx[Yin, Xin]
-
-    Iout = np.where(strixel_pixel_idx.ravel() != -1)[0].astype(np.int64)
-    Iin = strixel_pixel_idx.ravel()[Iout].astype(np.int64)
-    
-    return Iout, Iin
-
-
-def double_pixel_indices():
-    """Build index arrays for double-size pixels.
-
-    In raw data, the entire columns 255, 256, 511, 512, 767 and 768
-    are double-size pixels. After strixelation, these end up in columns
-    765-776, 1539-1550 and 2313-2324 on rows 0-85 or 0-83, with a set
-    of four columns with 86 rows followed by a set of 84 and 86 again.
-
-    This function builds the index arrays for double pixels after
-    strixelation.
-
-    Returns: 
-        (ndarray, ndarray) 2D index arrays for double pixel Y and X.
-    """
-
-    Ydouble = []
-    Xdouble = []
-
-    for double_col in [765, 1539, 2313]:
-        for col in range(double_col, double_col+12):
-            for row in range(84 if ((col-double_col) // 4) == 1 else 86):
-                Ydouble.append(row)
-                Xdouble.append(col)
-
-    return np.array(Ydouble), np.array(Xdouble)
-
-
-def to_strixel(data, out=None):
-    """Transform from regular to strixel geometry.
-
-    Only the last two axes are considered for transformation, input data
-    may have any number of additional axes in front.
-    
-    Args:
-        data (array_like): Data in regular geometry.
-        out (array_like, optional): Buffer for transformed output, a new
-            one is allocated if omitted. Must match all non-frame axes
-            of input data and able to hold strixel frame.
-
-    Returns:
-        (array_like) Data in strixel geometry.
-    """
-
-    if out is None:
-        out = np.zeros((*data.shape[:-2], *STRIXEL_SHAPE), dtype=data.dtype)
-
-    out.reshape(*out.shape[:-2], -1)[..., Iout] = data.reshape(
-        *data.shape[:-2], -1)[..., Iin]
-
-    return out
-
-
-def from_strixel(data, out=None):
-    """Transform from strixel to regular geometry.
-
-    Only the last two axes are considered for transformation, input data
-    may have any number of additional axes in front.
-
-    Args:
-        data (array_like): Data in strixel geometry.
-        out (array_like, optional): Buffer for transformed output, a new
-            one is allocated if omitted. Must match all non-frame axes
-            of input data and able to hold regular frame.
-
-    Returns:
-        (array_like): Data in regular geometry.
-    """
-
-    if out is None:
-        out = np.zeros((*data.shape[:-2], *REGULAR_SHAPE), dtype=data.dtype)
-
-    out.reshape(*out.shape[:-2], -1)[..., Iin] = data.reshape(
-        *data.shape[:-2], -1)[..., Iout]
-
-    return out
-
-
-Iout, Iin = transformation_indices1d()
diff --git a/src/cal_tools/jungfrau/__init__.py b/src/cal_tools/jungfrau/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/cal_tools/jungfrau/jfstrixel.py b/src/cal_tools/jungfrau/jfstrixel.py
new file mode 100644
index 0000000000000000000000000000000000000000..b388e5063430295174da65bbdee4a53476073796
--- /dev/null
+++ b/src/cal_tools/jungfrau/jfstrixel.py
@@ -0,0 +1,120 @@
+
+from functools import lru_cache
+from pathlib import Path
+
+import numpy as np
+
+REGULAR_SHAPE = (512, 1024)
+DIR_PATH = package_directory = Path(__file__).resolve().parent
+
+
+@lru_cache
+def get_strixel_parameters(kind):
+    """Returns a dictionary of strixel parameters stored in .npz file
+    based on the given kind.
+
+    Args:
+        kind (str): Specifies the type of strixel parameters to retrieve.
+            There is two possible values: "A0123" or "A1256"
+    Returns:
+        (dict): Dictionary contating the strixel parameters.
+    """
+    strx_parameters = {}
+
+    if kind == "A0123":
+        file_path = DIR_PATH / "strixel_cols_A0123-lut_mask.npz"
+    elif kind == "A1256":
+        file_path = DIR_PATH / "strixel_rows_A1256-lut_mask.npz"
+
+    with np.load(file_path) as data:
+        for k in data.files:
+            strx_parameters[k] = data[k]
+
+    return strx_parameters
+
+
+def store_double_pixel_indices():
+    """Build index arrays for double-size pixels.
+
+    In raw data for A0123 strixel detector,
+    the entire columns 255, 256, 511, 512, 767 and 768
+    are double-size pixels. After strixelation, these end up in columns
+    765-776, 1539-1550 and 2313-2324 on rows 0-85 or 0-83, with a set
+    of four columns with 86 rows followed by a set of 84 and 86 again.
+
+    This function builds the index arrays for double pixels after
+    strixelation and stores it in the available A0123 .npz file.
+    """
+
+    ydouble = []
+    xdouble = []
+    file_path = DIR_PATH / "strixel_cols_A0123-lut_mask.npz"
+
+    with np.load(file_path) as data:
+        for double_col in [765, 1539, 2313]:
+            for col in range(double_col, double_col+12):
+                for row in range(84 if ((col-double_col) // 4) == 1 else 86):
+                    ydouble.append(row)
+                    xdouble.append(col)
+        np.savez(file_path, **data, ydouble=ydouble, xdouble=xdouble)
+
+
+def to_strixel(data, out=None, kind="A0123"):
+    """Transform from regular to strixel geometry.
+
+    Only the last two axes are considered for transformation, input data
+    may have any number of additional axes in front.
+
+    Args:
+        data (array_like): Data in regular geometry.
+        out (array_like, optional): Buffer for transformed output, a new
+            one is allocated if omitted. Must match all non-frame axes
+            of input data and able to hold strixel frame.
+
+    Returns:
+        (array_like) Data in strixel geometry.
+    """
+
+    if kind is None:
+        return data
+
+    strx = get_strixel_parameters(kind)
+
+    if out is None:
+        out = np.zeros(
+            (*data.shape[:-2], *strx["frame_shape"]), dtype=data.dtype)
+
+    out.reshape(*out.shape[:-2], -1)[..., ~strx["mask"]] = data.reshape(
+        *data.shape[:-2], -1)[..., strx["lut"]]
+
+    return out
+
+
+def from_strixel(data, out=None, kind="A0123"):
+    """Transform from strixel to regular geometry.
+
+    Only the last two axes are considered for transformation, input data
+    may have any number of additional axes in front.
+
+    Args:
+        data (array_like): Data in strixel geometry.
+        out (array_like, optional): Buffer for transformed output, a new
+            one is allocated if omitted. Must match all non-frame axes
+            of input data and able to hold regular frame.
+
+    Returns:
+        (array_like): Data in regular geometry.
+    """
+
+    if kind is None:
+        return data
+
+    strx = get_strixel_parameters(kind)
+
+    if out is None:
+        out = np.zeros((*data.shape[:-2], *REGULAR_SHAPE), dtype=data.dtype)
+
+    out.reshape(*out.shape[:-2], -1)[..., strx["lut"]] = data.reshape(
+        *data.shape[:-2], -1)[..., strx["mask"]]
+
+    return out
diff --git a/src/cal_tools/jungfraulib.py b/src/cal_tools/jungfrau/jungfraulib.py
similarity index 52%
rename from src/cal_tools/jungfraulib.py
rename to src/cal_tools/jungfrau/jungfraulib.py
index fdfdb0bd571099514de806dbbcc69674e4cdf63e..bb1fcbcfa14439eb965d84cae47785a09725ffb0 100644
--- a/src/cal_tools/jungfraulib.py
+++ b/src/cal_tools/jungfrau/jungfraulib.py
@@ -1,8 +1,10 @@
-from typing import Optional, Tuple
+from logging import warning
+from typing import Tuple
 
 import extra_data
 
-from cal_tools.enums import JungfrauGainMode, JungfrauSettings
+from cal_tools.enums import JungfrauGainMode as JGM
+from cal_tools.enums import JungfrauSettings
 
 
 def _old_settings_to_new(settings: str, index: int) -> str:
@@ -98,22 +100,112 @@ class JungfrauCtrl():
         else:  # JungfrauSettings.GAIN_0
             return 0
 
-    def get_gain_mode(self) -> int:
-        """Get gain mode value. Fixed `1` or Adaptive `1`.
-        - `0` if run_mode = dynamic, forceswitchg1, forceswitchg2, or None.
-        - `1` if run_mode = fixg1 or fixg2.
-        """
+    def get_gain_mode_str(self):
         # Check if run_mode is of an old settings to convert
         # into new mode value.
-        if self.run_mode in [m.value for m in JungfrauGainMode]:
-            mode = self.run_mode
+        if self.run_mode in [m.value for m in JGM]:
+            return self.run_mode
         else:
-            mode = _old_settings_to_new(self.run_mode, 1)
-        
-        if mode in [
-            JungfrauGainMode.FIX_GAIN_1.value,
-            JungfrauGainMode.FIX_GAIN_2.value,
-        ]:
+            return _old_settings_to_new(self.run_mode, 1)
+
+    def get_gain_mode(self) -> int:
+        """Get gain mode value. Fixed `1` or Adaptive `0`.
+        Returns:
+            (int): gain mode parameter condition
+        """
+        gm_enum = self.get_gain_mode_str()
+
+        if gm_enum in [JGM.FIX_GAIN_1.value, JGM.FIX_GAIN_2.value]:
             return 1
-        else:  # DYNAMIC, FORCE_SWITCH_G1, or FORCE_SWITCH_G2
+        else:  # DYNAMIC, FORCE_SWITCH_G1, FORCE_SWITCH_G2 or None
             return 0
+
+
+MODES_ORDER = {
+    JGM.DYNAMIC.value: 0,
+    JGM.FORCE_SWITCH_HG1.value: 1,
+    JGM.FORCE_SWITCH_HG2.value: 2,
+    JGM.FIX_GAIN_1.value: 3,
+    JGM.FIX_GAIN_2.value: 4,
+}
+EXPECTED_RUN_ORDER = [
+    [  # Adaptive operation mode pattern
+        JGM.DYNAMIC.value,
+        JGM.FORCE_SWITCH_HG1.value,
+        JGM.FORCE_SWITCH_HG2.value
+    ],
+    [  # Fixed operation mode pattern
+        JGM.DYNAMIC.value,
+        JGM.FIX_GAIN_1.value,
+        JGM.FIX_GAIN_2.value
+    ],
+]
+
+
+def sort_runs_by_gain(
+    raw_folder,
+    runs,
+    ctrl_src,
+    modes_order=MODES_ORDER,
+    expected_run_order=EXPECTED_RUN_ORDER
+):
+    """Validate the 3 dark runs given for Jungfrau.
+
+    Args:
+        raw_folder (str): RAW folder for the validated dark runs.
+        runs (list): [High run, Medium run, Low run].
+        ctrl_src (str): Control source path for slow data.
+        modes_order (dict): Gain modes order to sort the runs by.
+        expected_run_order (list):Expected dark runs order to process.
+    Raises:
+        ValueError: Wrong given dark runs
+    """
+    assert len(runs) == 3, "Wrong number of runs. expected a list of 3 runs."
+
+    run_gm_mapping = dict()
+    for run in runs:
+        ctrl_data = JungfrauCtrl(
+            extra_data.RunDirectory(f"{raw_folder}/r{run:04d}/"),
+            ctrl_src)
+        gm = ctrl_data.get_gain_mode_str()
+        run_gm_mapping[run] = gm
+
+    # 1st legacy case before having run.settings in data.
+    if all(value is None for value in run_gm_mapping.values()):
+        warning("run.settings is not stored in the data "
+                f"to read. Hence assuming gain_mode = {gm}"
+                " for adaptive old data.")
+        return runs
+
+    run_gm_mapping = dict(sorted(
+        run_gm_mapping.items(),
+        key=lambda item: modes_order[item[1]]
+        ))
+    if list(run_gm_mapping.keys()) != runs:
+        warning("Given dark runs are unsorted. "
+                f"Runs will be sorted from {runs} of gain modes "
+                f"{list(run_gm_mapping.values())} to "
+                f"{list(run_gm_mapping.keys())}")
+
+    runs = list(run_gm_mapping.keys())
+    modes = list(run_gm_mapping.values())
+
+    legacy_adaptive = [
+        JGM.DYNAMIC.value,
+        JGM.DYNAMIC.value,
+        JGM.FORCE_SWITCH_HG1.value
+    ]
+
+    # 2nd legacy case with CTRL/MDL bug resulting in wrong run settings.
+    if modes == legacy_adaptive:
+        warning(f"run.settings for medium and low gain runs"
+                f" are wrong {modes[1:]}. This is an expected "
+                f"bug for old raw data. "
+                "Assuming this is an adaptive gain runs.")
+    elif not modes in expected_run_order:
+        raise ValueError("Wrong dark runs are given. "
+                         f"The given three runs are {runs} with "
+                         f"wrong gain modes {modes}."
+                         "Please verify the selected 3 dark runs to process.")
+
+    return runs
diff --git a/src/cal_tools/jungfrau/strixel_cols_A0123-lut_mask.npz b/src/cal_tools/jungfrau/strixel_cols_A0123-lut_mask.npz
new file mode 100644
index 0000000000000000000000000000000000000000..fcf08e279709b7a8a64c858fdd932d3c7738c172
Binary files /dev/null and b/src/cal_tools/jungfrau/strixel_cols_A0123-lut_mask.npz differ
diff --git a/src/cal_tools/jungfrau/strixel_rows_A1256-lut_mask.npz b/src/cal_tools/jungfrau/strixel_rows_A1256-lut_mask.npz
new file mode 100644
index 0000000000000000000000000000000000000000..bb501916261559afae102ed188b071d524ed18c1
Binary files /dev/null and b/src/cal_tools/jungfrau/strixel_rows_A1256-lut_mask.npz differ
diff --git a/src/xfel_calibrate/calibrate.py b/src/xfel_calibrate/calibrate.py
index 5590e4c34f5f6c9c10d3700260adfb3c3e1ea2f2..8ffcc29aa14a3763ca110b56298c908b62ada903 100755
--- a/src/xfel_calibrate/calibrate.py
+++ b/src/xfel_calibrate/calibrate.py
@@ -112,6 +112,11 @@ def balance_sequences(in_folder: str, run: int, sequences: List[int],
     elif not isinstance(karabo_da, list):
         raise TypeError("Balance sequences expects `karabo_da` as a string or list.")
 
+    # data-mapping for LPD mini and GH2 25um uses karabo-da names like
+    # LPDMINI00/2 or DA01/2 to identify individual modules. The /2 is not
+    # part of the file name
+    karabo_da = list({kda.split('/')[0] for kda in karabo_da})
+
     in_path = Path(in_folder, f"r{run:04d}")
 
     # TODO: remove ["-1"] after karabo_da refactor
diff --git a/src/xfel_calibrate/notebooks.py b/src/xfel_calibrate/notebooks.py
index fe33e0f9e7e6b26b23b298bf9579917ce445b5e2..dd5f57d223717b0cb1ae06f3cca1f6242e3fd52b 100644
--- a/src/xfel_calibrate/notebooks.py
+++ b/src/xfel_calibrate/notebooks.py
@@ -14,6 +14,8 @@ notebooks = {
         },
         "PC": {
             "notebook": "notebooks/AGIPD/Chracterize_AGIPD_Gain_PC_NBC.ipynb",
+            "dep_notebooks": [
+                "notebooks/AGIPD/Chracterize_AGIPD_Gain_PC_Summary.ipynb"],
             "concurrency": {"parameter": "modules",
                             "default concurrency": 16,
                             "cluster cores": 32},
@@ -228,6 +230,8 @@ notebooks = {
         "DARK": {
             "notebook":
                 "notebooks/Gotthard2/Characterize_Darks_Gotthard2_NBC.ipynb",
+            "dep_notebooks": [
+                "notebooks/Gotthard2/Summary_Darks_Gotthard2_NBC.ipynb"],
             "concurrency": {"parameter": "karabo_da",
                             "default concurrency": list(range(2)),
                             "cluster cores": 4},
@@ -248,6 +252,12 @@ notebooks = {
                             "use function": "balance_sequences",
                             "cluster cores": 4},
         },
+        "FF": {
+            "notebook": "notebooks/ePix100/Characterize_FlatFields_ePix100_NBC.ipynb",
+            "concurrency": {"parameter": None,
+                            "default concurrency": None,
+                            "cluster cores": 4},
+        },
     },
     "EPIX10K": {
         "DARK": {
diff --git a/tests/test_agipdlib.py b/tests/test_agipdlib.py
index ad1a92f42f956d291adebedbfb6df61a929d4e32..89ef4054df964fb3fc4b8a44f32b267dd66ac702 100644
--- a/tests/test_agipdlib.py
+++ b/tests/test_agipdlib.py
@@ -1,11 +1,14 @@
 from datetime import datetime
 
+import pytest
 from extra_data import RunDirectory
 
-from cal_tools.agipdlib import AgipdCtrl
+from cal_tools.agipdlib import AgipdCtrl, AgipdCtrlRuns
+from cal_tools.enums import AgipdGainMode
 
 SPB_AGIPD_INST_SRC = 'SPB_DET_AGIPD1M-1/DET/0CH0:xtdf'
-CTRL_SRC = 'SPB_IRU_AGIPD1M1/MDL/FPGA_COMP'
+SPB_AGIPD_KARABO_CTRL_ID = 'SPB_IRU_AGIPD1M1'
+CTRL_SRC = f'{SPB_AGIPD_KARABO_CTRL_ID}/MDL/FPGA_COMP'
 
 
 def test_get_acq_rate_ctrl(mock_agipd1m_run):
@@ -136,8 +139,8 @@ def test_get_bias_voltage(
     # Read bias voltage for HED_DET_AGIPD500K from slow data.
     agipd_ctrl = AgipdCtrl(
         run_dc=RunDirectory(mock_agipd500k_run),
-        image_src=SPB_AGIPD_INST_SRC,
-        ctrl_src=CTRL_SRC)
+        image_src=None,
+        ctrl_src=None)
     bias_voltage = agipd_ctrl.get_bias_voltage(
         karabo_id_control="HED_EXP_AGIPD500K2G")
 
@@ -198,3 +201,128 @@ def test_get_gain_mode(mock_agipd1m_run):
     gain_mode = agipd_ctrl.get_gain_mode()
     assert isinstance(gain_mode, int)
     assert gain_mode == 0
+
+
+"""Testing `AgipdCtrlRuns`"""
+
+TEST_RAW_FOLDER = "/gpfs/exfel/exp/CALLAB/202130/p900203/raw/"
+SPB_FIXED_RUNS = [9011, 9012, 9013]
+SPB_ADAPTIVE_RUNS = [9015, 9016, 9017]
+
+FIXED_CTRL_RUNS = AgipdCtrlRuns(
+    raw_folder=TEST_RAW_FOLDER,
+    runs=SPB_FIXED_RUNS,
+    image_src=SPB_AGIPD_INST_SRC,
+    ctrl_src=CTRL_SRC,
+)
+ADAPTIVE_CTRL_RUNS = AgipdCtrlRuns(
+    raw_folder=TEST_RAW_FOLDER,
+    runs=SPB_ADAPTIVE_RUNS,
+    image_src=SPB_AGIPD_INST_SRC,
+    ctrl_src=CTRL_SRC,
+)
+
+
+@pytest.mark.requires_gpfs
+def test_get_memory_cells_runs():
+    assert FIXED_CTRL_RUNS.get_memory_cells() == 352
+
+    assert ADAPTIVE_CTRL_RUNS.get_memory_cells() == 352
+
+
+@pytest.mark.requires_gpfs
+def test_get_bias_voltage_runs():
+    assert FIXED_CTRL_RUNS.get_bias_voltage(SPB_AGIPD_KARABO_CTRL_ID) == 300
+
+    assert ADAPTIVE_CTRL_RUNS.get_bias_voltage(SPB_AGIPD_KARABO_CTRL_ID) == 300
+
+
+@pytest.mark.requires_gpfs
+def test_get_integration_time_runs():
+    assert FIXED_CTRL_RUNS.get_integration_time() == 12
+
+    assert ADAPTIVE_CTRL_RUNS.get_integration_time() == 20
+
+
+@pytest.mark.requires_gpfs
+def test_get_acquisition_rate_runs():
+    assert FIXED_CTRL_RUNS.get_acq_rate() == 1.1
+
+    assert ADAPTIVE_CTRL_RUNS.get_acq_rate() == 1.1
+
+
+@pytest.mark.requires_gpfs
+def test_get_gain_setting_runs():
+    assert FIXED_CTRL_RUNS.get_gain_setting() == 0
+
+    assert ADAPTIVE_CTRL_RUNS.get_gain_setting() == 0
+
+
+@pytest.mark.requires_gpfs
+def test_get_gain_mode_runs():
+    assert FIXED_CTRL_RUNS.get_gain_modes() == [
+        AgipdGainMode.FIXED_HIGH_GAIN,
+        AgipdGainMode.FIXED_MEDIUM_GAIN,
+        AgipdGainMode.FIXED_LOW_GAIN
+    ]
+
+    assert ADAPTIVE_CTRL_RUNS.get_gain_modes() == [
+        AgipdGainMode.ADAPTIVE_GAIN]*3
+
+
+@pytest.mark.requires_gpfs
+def test_fixed_gain_mode():
+    assert FIXED_CTRL_RUNS.fixed_gain_mode()
+
+    assert not ADAPTIVE_CTRL_RUNS.fixed_gain_mode()
+
+
+@pytest.mark.requires_gpfs
+def test_raise_fixed_gain_mode():
+    adaptive_fixed_ctrls = AgipdCtrlRuns(
+        raw_folder=TEST_RAW_FOLDER,
+        runs=[9011, 9016, 9017],
+        image_src=SPB_AGIPD_INST_SRC,
+        ctrl_src=CTRL_SRC,
+    )
+    with pytest.raises(ValueError):
+        adaptive_fixed_ctrls.fixed_gain_mode()
+
+
+@pytest.mark.requires_gpfs
+@pytest.mark.parametrize(
+    "runs,expected",
+    [
+        ([9013, 9011, 9012], [9011, 9012, 9013]),
+        ([9017, 9016, 9015], [9015, 9016, 9017]),
+    ],
+)
+def test_sort_dark_runs(runs, expected):
+    runs_ctrls = AgipdCtrlRuns(
+        raw_folder=TEST_RAW_FOLDER,
+        runs=runs,
+        image_src=SPB_AGIPD_INST_SRC,
+        ctrl_src=CTRL_SRC,
+    )
+    runs_ctrls.sort_dark_runs()
+    assert runs_ctrls.runs == expected
+
+
+def test_raise_sort_dark_runs():
+    with pytest.raises(ValueError):
+        adaptive_fixed_ctrls = AgipdCtrlRuns(
+            raw_folder=TEST_RAW_FOLDER,
+            runs=[9011, 9016, 9017],
+            image_src=SPB_AGIPD_INST_SRC,
+            ctrl_src=CTRL_SRC,
+            sort_dark_runs_enabled=True
+        )
+
+    adaptive_fixed_ctrls = AgipdCtrlRuns(
+        raw_folder=TEST_RAW_FOLDER,
+        runs=[9011, 9016, 9017],
+        image_src=SPB_AGIPD_INST_SRC,
+        ctrl_src=CTRL_SRC,
+    )
+    with pytest.raises(ValueError):
+        adaptive_fixed_ctrls.sort_dark_runs()
diff --git a/tests/test_jungfraulib.py b/tests/test_jungfraulib.py
index eb7580ad72beaf422871516340648c754b59eaa1..00a3ae5b9f2e4761360733d95f62e308da08016e 100644
--- a/tests/test_jungfraulib.py
+++ b/tests/test_jungfraulib.py
@@ -1,7 +1,7 @@
 import pytest
 from extra_data import RunDirectory
 
-from cal_tools.jungfraulib import JungfrauCtrl
+from cal_tools.jungfrau.jungfraulib import JungfrauCtrl, sort_runs_by_gain
 
 # TODO: replace with mocked RAW data as in tests/test_agipdlib.py
 JF = JungfrauCtrl(
@@ -45,3 +45,22 @@ def test_get_gain_setting(settings, result):
 def test_get_gain_mode(mode, result):
     JF.run_mode = mode
     assert JF.get_gain_mode() == result
+
+@pytest.mark.parametrize(
+    'original_runs,sorted_runs',
+    [
+        ([9035, 9036, 9037], [9035, 9036, 9037]),
+        ([9035, 9037, 9036], [9035, 9036, 9037]),
+        ([9033, 9032, 9031], [9031, 9032, 9033]),
+        ([9033, 9031, 9032], [9031, 9032, 9033]),
+    ]
+)
+# TODO: missing fixed gain dark runs for JUNGFRAU from test proposal.
+# TODO: missing fixed and adaptive runs after the JF control updated.
+def test_sort_runs_by_gain(original_runs, sorted_runs):
+    raw_folder = "/gpfs/exfel/exp/CALLAB/202130/p900203/raw"
+    validated_runs = sort_runs_by_gain(
+        raw_folder=raw_folder,
+        runs=original_runs,
+        ctrl_src="FXE_XAD_JF1M/DET/CONTROL")
+    assert validated_runs == sorted_runs
diff --git a/tests/test_reference_runs/callab_tests.py b/tests/test_reference_runs/callab_tests.py
index e24e48639fd52a2caeba9c09ef0686cc589f898a..b566e8598b2d492f124829e5b24100cd6b7e8181 100644
--- a/tests/test_reference_runs/callab_tests.py
+++ b/tests/test_reference_runs/callab_tests.py
@@ -13,6 +13,7 @@ automated_test_config = {
             "slurm-mem": "750",
             "sequences": "0",
             "rel-gain": True,
+            "xray-gain": True,
             "n-cores-files": 2,
             "ctrl-source-template": "{}/MDL/FPGA_COMP",
         },
@@ -25,9 +26,10 @@ automated_test_config = {
             "out-folder": "{}/{}/{}",
             # "/gpfs/exfel/exp/SPB/202131/p900215/raw"
             "in-folder": "/gpfs/exfel/exp/CALLAB/202130/p900203/raw",
-            "run-high": "9011",  # Original run: "91"
+            # Unsorted dark runs
+            "run-high": "9013",  # Original run "93"
             "run-med": "9012",  # Original run: "92"
-            "run-low": "9013",  # Original run "93"
+            "run-low": "9011",  # Original run: "91"
             "karabo-id-control": "SPB_IRU_AGIPD1M1",
             "karabo-id": "SPB_DET_AGIPD1M-1",
             "ctrl-source-template": "{}/MDL/FPGA_COMP",
@@ -40,6 +42,7 @@ automated_test_config = {
         "config": {
             "blc-stripes": True,
             "rel-gain": True,
+            "xray-gain": True,
             "out-folder": "{}/{}/{}",
             # "/gpfs/exfel/exp/SPB/202131/p900215/raw"
             "in-folder": "/gpfs/exfel/exp/CALLAB/202130/p900203/raw",
@@ -75,6 +78,7 @@ automated_test_config = {
         "config": {
             "blc-stripes": True,
             "rel-gain": True,
+            "xray-gain": True,
             "out-folder": "{}/{}/{}",
             # "/gpfs/exfel/exp/MID/202121/p002929/raw"
             "in-folder": "/gpfs/exfel/exp/CALLAB/202130/p900203/raw",
@@ -94,6 +98,7 @@ automated_test_config = {
         "config": {
             "blc-stripes": True,
             "rel-gain": True,
+            "xray-gain": True,
             "out-folder": "{}/{}/{}",
             # "/gpfs/exfel/exp/MID/202121/p002929/raw"
             "in-folder": "/gpfs/exfel/exp/CALLAB/202130/p900203/raw",
@@ -116,6 +121,7 @@ automated_test_config = {
         "config": {
             "blc-stripes": True,
             "rel-gain": True,
+            "xray-gain": True,
             "out-folder": "{}/{}/{}",
             # "/gpfs/exfel/exp/MID/202121/p002929/raw"
             "in-folder": "/gpfs/exfel/exp/CALLAB/202130/p900203/raw",
@@ -153,6 +159,7 @@ automated_test_config = {
         "config": {
             "blc-stripes": True,
             "rel-gain": True,
+            "xray-gain": True,
             "out-folder": "{}/{}/{}",
             # "/gpfs/exfel/exp/HED/202131/p900228/raw"
             "in-folder": "/gpfs/exfel/exp/CALLAB/202130/p900203/raw",
@@ -173,9 +180,10 @@ automated_test_config = {
             "out-folder": "{}/{}/{}",
             # "/gpfs/exfel/exp/HED/202131/p900228/raw"
             "in-folder": "/gpfs/exfel/exp/CALLAB/202130/p900203/raw",
+            # Unsorted dark runs
             "run-high": "9023", # Original run: "25",
-            "run-med": "9024",  # Original run: "26",
-            "run-low": "9025",  # Original run: "27",
+            "run-med": "9025",  # Original run: "27",
+            "run-low": "9024",  # Original run: "26",
             "karabo-id-control": "HED_EXP_AGIPD500K2G",
             "karabo-id": "HED_DET_AGIPD500K2G",
             "ctrl-source-template": "{}/MDL/FPGA_COMP",
@@ -240,6 +248,7 @@ automated_test_config = {
             "sequences": "0,1",
             "karabo-id-control": "",
             "karabo-id": "FXE_XAD_JF1M",
+            "gain-mode": 0,
             "karabo-da": ["JNGFR01", "JNGFR02"],
         },
         "reference-folder": "{}/{}/{}",
@@ -317,10 +326,11 @@ automated_test_config = {
         "cal_type": "DARK",
         "config": {
             "out-folder": "{}/{}/{}",
+            # /gpfs/exfel/exp/SPB/202130/p900204/raw
             "in-folder": "/gpfs/exfel/exp/CALLAB/202130/p900203/raw",
-            "run-high": "9004",
-            "run-med": "9005",
-            "run-low": "9006",
+            "run-high": "9004",  # 88
+            "run-med": "9005",  # 89
+            "run-low": "9006",  # 90
             "karabo-id-control": "",
             "karabo-id": "SPB_IRDA_JF4M",
             "karabo-da": [
@@ -379,9 +389,10 @@ automated_test_config = {
             "out-folder": "{}/{}/{}",
             # "/gpfs/exfel/exp/HED/202102/p002656/raw"
             "in-folder": "/gpfs/exfel/exp/CALLAB/202130/p900203/raw",
-            "run-high": "9039",  # Original run: "219",
-            "run-med": "9040",  # Original run: "220",
-            "run-low": "9041",  # Original run: "221",
+            # The 3 runs are arranged in a wrong way on purpose.
+            "run-high": "9040",  # Original run: "219",
+            "run-med": "9041",  # Original run: "220",
+            "run-low": "9039",  # Original run: "221",
             "karabo-id": "HED_IA1_JF500K2",
             "karabo-da": "JNGFR02",
         },
@@ -473,21 +484,21 @@ automated_test_config = {
         },
         "reference-folder": "{}/{}/{}",
     },
-    # "MID_EXP_EPIX-1-CORRECT": {
-    #     "det_type": "EPIX100",
-    #     "cal_type": "CORRECT",
-    #     "config": {
-    #         "out-folder": "{}/{}/{}",
-    #         # Original proposal 2936
-    #         "in-folder": "/gpfs/exfel/exp/CALLAB/202130/p900203/raw",
-    #         "run": "9042",  # Original run: "160"
-    #         "karabo-id": "MID_EXP_EPIX-1",
-    #         "karabo-da": "EPIX01",
-    #         "sequences": "1,2,3",
-    #         "fix-temperature": 290,
-    #     },
-    #     "reference-folder": "{}/{}/{}",
-    # },
+    "MID_EXP_EPIX-1-CORRECT": {
+        "det_type": "EPIX100",
+        "cal_type": "CORRECT",
+        "config": {
+            "out-folder": "{}/{}/{}",
+            # Original proposal 2936
+            "in-folder": "/gpfs/exfel/exp/CALLAB/202130/p900203/raw",
+            "run": "9042",  # Original run: "160"
+            "karabo-id": "MID_EXP_EPIX-1",
+            "karabo-da": "EPIX01",
+            "sequences": "1,2,3",
+            "fix-temperature": 290,
+        },
+        "reference-folder": "{}/{}/{}",
+    },
     "HED_IA1_EPX100-1-CORRECT": {
         "det_type": "EPIX100",
         "cal_type": "CORRECT",
@@ -508,8 +519,9 @@ automated_test_config = {
         "cal_type": "DARK",
         "config": {
             "out-folder": "{}/{}/{}",
+            # Original proposal: 2655
             "in-folder": "/gpfs/exfel/exp/CALLAB/202130/p900203/raw",
-            "run": "9045",  # Original run: 224 proposal 2655
+            "run": "9045",  # Original run: 224
             "karabo-id": "MID_EXP_EPIX-2",
             "karabo-da": "EPIX02",
         },
@@ -580,11 +592,7 @@ automated_test_config = {
             "run": "9028",  # Original run: "1723",
             "karabo-id": "SCS_DET_DSSC1M-1",
             "slow-data-path": "SCS_CDIDET_DSSC/FPGA/PPT_Q",
-            "slow-data-aggregators":
-                - 1
-                - 2
-                - 3
-                - 4
+            "slow-data-aggregators": [1, 2, 3, 4]
         },
         "reference-folder": "{}/{}/{}",
     },
@@ -598,6 +606,38 @@ automated_test_config = {
             "run": "9028",  # Original run: "1723",
             "karabo-id": "SCS_DET_DSSC1M-1",
             "slow-data-path": "SCS_CDIDET_DSSC/FPGA/PPT_Q",
+            "slow-data-aggregators": [1, 2, 3, 4]
+        },
+        "reference-folder": "{}/{}/{}",
+    },
+    "SQS_DET_DSSC1M-1-DARK": {
+        "det_type": "DSSC",
+        "cal_type": "DARK",
+        "config": {
+            "out-folder": "{}/{}/{}",
+            # "/gpfs/exfel/exp/SQS/202131/p900210/raw"
+            "in-folder": "/gpfs/exfel/exp/CALLAB/202130/p900203/raw",
+            "run": "9029",  # Original run: "437",
+            "karabo-id": "SQS_DET_DSSC1M-1",
+            "slow-data-path": "SQS_NQS_DSSC/FPGA/PPT_Q",
+            "slow-data-aggregators":
+                - 1
+                - 2
+                - 3
+                - 4
+        },
+        "reference-folder": "{}/{}/{}",
+    },
+    "SQS_DET_DSSC1M-1-CORRECT": {
+        "det_type": "DSSC",
+        "cal_type": "CORRECT",
+        "config": {
+            "out-folder": "{}/{}/{}",
+            # "/gpfs/exfel/exp/SQS/202131/p900210/raw"
+            "in-folder": "/gpfs/exfel/exp/CALLAB/202130/p900203/raw",
+            "run": "9029",  # Original run: "437",
+            "karabo-id": "SQS_DET_DSSC1M-1",
+            "slow-data-path": "SQS_NQS_DSSC/FPGA/PPT_Q",
         },
         "reference-folder": "{}/{}/{}",
     },
diff --git a/tests/test_reference_runs/conftest.py b/tests/test_reference_runs/conftest.py
index ce3b9745888821e5e75fe4c6ef02e76a35047c56..c2c50991ea1806d3454a79a8169bc1f324cef2ec 100644
--- a/tests/test_reference_runs/conftest.py
+++ b/tests/test_reference_runs/conftest.py
@@ -38,15 +38,6 @@ def pytest_addoption(parser):
               "apply validation test on numerical data only."),
     )
 
-    parser.addoption(
-        "--find-difference",
-        action="store_true",
-        default=False,
-        help=(
-            "In case of non numerical validation of h5file. "
-            "Find the different attribute and fail on the first one."),
-    )
-
     parser.addoption(
         "--use-slurm",
         action="store_true",
@@ -80,8 +71,6 @@ def release_test_config(request):
         "--no-numerical-validation")
     validate_only = request.config.getoption(
         "--validation-only")
-    find_difference = request.config.getoption(
-        "--find-difference")
     use_slurm = request.config.getoption(
         "--use-slurm")
     picked_test = request.config.getoption("--picked-test")
@@ -90,8 +79,7 @@ def release_test_config(request):
     return (
         detectors, calibration, picked_test,
         skip_numerical_validation, validate_only,
-        find_difference, use_slurm, reference_folder,
-        out_folder,
+        use_slurm, reference_folder, out_folder,
     )
 
 
diff --git a/tests/test_reference_runs/test_pre_deployment.py b/tests/test_reference_runs/test_pre_deployment.py
index 7a4f36e74191ba90380f76439b8a6893b70a1ff8..344be0cac01c157fbb88179fcd46c89df60aa959 100644
--- a/tests/test_reference_runs/test_pre_deployment.py
+++ b/tests/test_reference_runs/test_pre_deployment.py
@@ -1,11 +1,10 @@
-import hashlib
 import io
 import logging
 import multiprocessing
 import pathlib
-import tempfile
 import time
 from contextlib import redirect_stdout
+from dataclasses import dataclass
 from datetime import datetime
 from functools import partial
 from subprocess import PIPE, run
@@ -14,6 +13,8 @@ from typing import Any, Dict, List, Tuple
 import h5py
 import numpy as np
 import pytest
+import yaml
+from deepdiff import DeepDiff
 
 import xfel_calibrate.calibrate as calibrate
 
@@ -22,253 +23,122 @@ from .callab_tests import automated_test_config
 LOGGER = logging.getLogger(__name__)
 
 
-def file_md5(
-    tested_file: str,
-    block_size: int = 2 ** 20,
-) -> bytes:
-    """Generating MD5 checksum for a file.
+@dataclass
+class ComparisonResult:
+    filename: str
+    new_dsets: list
+    missing_dsets: list
+    changed_dsets: list
 
-    Args:
-        tested_file: File to be tested.
-        block_size (_type_, optional): Block size for reading the file.
-            Defaults to 2**20.
-    """
-    f = open(tested_file, "rb")
-    md5 = hashlib.md5()
-    while True:
-        data = f.read(block_size)
-        if not data:
-            break
-        md5.update(data)
-    f.close()
-    return md5.digest()
-
-
-def collect_attrs(groups, datasets, objects, exclude_attrs, name, node):
-    """Collect h5 attrs in groups, datasets, and objects lists."""
-    if node.name not in exclude_attrs:
-        if isinstance(node, h5py.Group):
-            groups.append(name)
-        elif isinstance(node, h5py.Dataset):
-            if node.dtype == 'object':
-                objects.append(name)
-            else:
-                datasets.append(name)
+    def found_differences(self):
+        return bool(self.new_dsets or self.missing_dsets or self.changed_dsets)
 
+    def show(self):
+        if not self.found_differences():
+            print(f"{self.filename} - ✓ no changes")
+            return
 
-def compare_datasets(
-    file1,
-    file2,
-    datasets: list
-):
-    """Compare the values of datasets in two h5 files."""
-    h5_diff = []
-    for d in datasets:
-        try:
-            if not np.allclose(file1[d][()], file2[d][()], equal_nan=True):
-                h5_diff.append(d)
-        except ValueError as e:
-            LOGGER.error(f"ValueError: {e}, {d}")
-            h5_diff.append(d)
-        except AttributeError as e:
-            LOGGER.error(f"AttributeError: {e}, {d}")
-            h5_diff.append(d)
-    return h5_diff
-
-
-def compare_objects(
-    file1,
-    file2,
-    objects: list
-):
-    """Compare the objects in two h5 files."""
-    h5_diff = []
-    for d in objects:
-        try:
-            if isinstance(file1[d][()], bytes):
-                if (
-                    file1[d][()].decode('utf-8') != file2[d][()].decode('utf-8')  # noqa
-                ):
-                    h5_diff.append(d)
-            elif (
-                file1[d][()].dtype != file1[d][()].dtype and
-                not file1[d][()] != file2[d][()]
-            ):  # pnccd files has only list of bytes
-                h5_diff.append(d)
-        except ValueError as e:
-            LOGGER.error(f"ValueError: {e}, {d}")
-            h5_diff.append(d)
-        except AttributeError as e:
-            LOGGER.error(f"AttributeError: {e}, {d}, "
-                         f"{file1[d][()].decode('utf-8')}")
-            h5_diff.append(d)
-    return h5_diff
-
-
-def find_differences(
-    test_file,
-    reference_file,
-    exclude_attrs,
-):
-    """
-    Find difference in groups, datasets, and objects between two h5files.
-    Args:
-        file1: first h5 file.
-        file2: second h5 file.
-    """
+        print(self.filename)
+        for ds in self.new_dsets:
+            print(f"  + NEW: {ds}")
+        for ds in self.missing_dsets:
+            print(f"  - MISSING: {ds}")
+        for ds, detail in self.changed_dsets:
+            print(f"  ~ CHANGED: {ds} ({detail})")
+
+
+def gather_dsets(f: h5py.File):
+    res = set()
+
+    def visitor(name, obj):
+        if isinstance(obj, h5py.Dataset):
+            res.add(name)
+
+    f.visititems(visitor)
+    return res
+
+
+def iter_sized_chunks(ds: h5py.Dataset, chunk_size: int):
+    """Make slices of the dataset along the first axis
+
+    Aims for block_size bytes per block"""
+    if ds.ndim == 0:  # Scalar
+        yield ()
+        return
+
+    chunk_l = min(chunk_size // (ds.dtype.itemsize * np.prod(ds.shape[1:])), 1)
+    for start in range(0, ds.shape[0], chunk_l):
+        yield slice(start, start + chunk_l)
 
-    groups_f1 = []
-    datasets_f1 = []
-    objects_f1 = []
-
-    groups_f2 = []
-    datasets_f2 = []
-    objects_f2 = []
-
-    with h5py.File(test_file, 'r') as file1, h5py.File(reference_file, 'r') as file2:  # noqa
-
-        # Fill groups, datasets, and objects list
-        # to compare both h5files' attrs.
-        file1.visititems(
-            partial(
-                collect_attrs,
-                groups_f1,
-                datasets_f1,
-                objects_f1,
-                exclude_attrs,
-                ))
-        file2.visititems(
-            partial(
-                collect_attrs,
-                groups_f2,
-                datasets_f2,
-                objects_f2,
-                exclude_attrs,
-                ))
 
-        start_time = time.perf_counter()
-        # Compare groups, datasets, and objects to have the same content.
-        assert set(groups_f1) == set(groups_f2), f"{test_file} and {reference_file} consists of different groups."  # noqa
-        assert set(datasets_f1) == set(datasets_f2), f"{test_file} and {reference_file} consists of different datasets."  # noqa
-        assert set(objects_f1) == set(objects_f2), f"{test_file} and {reference_file} consists of different datasets."  # noqa
-        duration = time.perf_counter() - start_time
-        LOGGER.info("Elapsed time comparing groups, "
-                    f"datasets, and objects: {duration} seconds")
-        LOGGER.info("Groups, datasets, and objects have the same content.")
-
-        # Compare datasets and objects.
-        start_time = time.perf_counter()
-        h5_diff_datasets = compare_datasets(file1, file2, datasets_f1)
-        duration = time.perf_counter() - start_time
-        LOGGER.info(f"Elapsed time comparing datasets: {duration} seconds")
-        start_time = time.perf_counter()
-        h5_diff_objects = compare_objects(file1, file2, objects_f1)
-        LOGGER.info(f"Elapsed time comparing objects: {duration} seconds")
-
-        assert not h5_diff_datasets, f"{[d for d in h5_diff_datasets]} datasets contain different values for {test_file} and {reference_file}"  # noqa
-        LOGGER.info("Datasets are validated.")
-        assert not h5_diff_objects, f"{[d for d in h5_diff_objects]} objects contain different values for {test_file} and {reference_file}"  # noqa
-        LOGGER.info("Objects are validated.")
-
-
-def validate_files(
+def validate_file(
     ref_folder: pathlib.PosixPath,
     out_folder: pathlib.PosixPath,
-    exclude_attrs: list,
-    test_file: pathlib.PosixPath,
-) -> Tuple[bool, pathlib.PosixPath]:
-    """Validate file similarities. Create temporary files to exclude
-    h5 attributes known to be different. e.g `report` for constants.
-    If both files are not identical, the function is able to loop over
-    both files and find and fail on the difference.
-
-    Args:
-        ref_folder: The reference folder for validating the files
-        out_folder: The output folder for the test constant files.
-        test_file: The output file to be validated.
-        exclude_attrs: A list of datasets, groups to exclude
-          from validated files.
-    Returns:
-        result: validation result for metadata.
-        test_file: The validated file.
-    """
-    import h5py
-    start_validating = time.perf_counter()
-
-    def exclude_sources(source_file, dest, excluded_sources):
-        # Open the source file in read-only mode
-        with h5py.File(source_file, 'r') as source:
-
-            # Recursively visit all objects in the source file
-            def visit_func(name, obj):
-                # Check if the object should be excluded
-                if name in excluded_sources:
-                    return
-
-                # Check if the object is a dataset
-                if isinstance(obj, h5py.Dataset):
-                    # Create a new dataset in the destination
-                    # file and copy the data
-                    dest.create_dataset(name, data=obj[()])
-
-            # Visit all objects in the source file and
-            # copy them to the destination file
-            source.visititems(visit_func)
-
-    with tempfile.NamedTemporaryFile(
-        dir=out_folder,
-        suffix=".tmp",
-        prefix="cal_",
-        delete=True,
-        ) as out_tf, tempfile.NamedTemporaryFile(
-            dir=out_folder,
-            suffix=".tmp",
-            prefix="cal_",
-            delete=True,
-            ) as ref_tf:
-
-        # Create in-memory HDF5 files for validation
-        with h5py.File(out_tf.name, 'a') as hp1, h5py.File(ref_tf.name, 'a') as hp2:  # noqa
-
-            start_time = time.perf_counter()
-            # Copy h5 files for validation and exclude selected attrs.
-            exclude_sources(test_file, hp1, exclude_attrs)
-
-            duration = time.perf_counter() - start_time
-            LOGGER.info(f"Elapsed time copying {test_file}: "
-                        f"{duration} seconds")
-
-            start_time = time.perf_counter()
-            exclude_sources(ref_folder / test_file.name, hp2, exclude_attrs)
-
-            duration = time.perf_counter() - start_time
-            LOGGER.info(f"Elapsed time copying {ref_folder / test_file.name}: "
-                        f"{duration} seconds")
-
-            start_time = time.perf_counter()
-            result = file_md5(out_tf.name) == file_md5(ref_tf.name)
-            LOGGER.info(f"MD5 validation for {test_file}: {duration} seconds")
-    duration = time.perf_counter() - start_validating
-    return result, test_file
+    exclude_dsets: set,
+    test_file: str,
+) -> ComparisonResult:
+    ref_file = ref_folder / test_file
+    out_file = out_folder / test_file
+    with h5py.File(ref_file) as fref, h5py.File(out_file) as fout:
+        ref_dsets = gather_dsets(fref)
+        out_dsets = gather_dsets(fout)
+        changed = []
+        for dsname in sorted((ref_dsets & out_dsets) - exclude_dsets):
+            ref_ds = fref[dsname]
+            out_ds = fout[dsname]
+            if out_ds.shape != ref_ds.shape:
+                changed.append((
+                    dsname, f"Shape: {ref_ds.shape} -> {out_ds.shape}"
+                ))
+            elif out_ds.dtype != ref_ds.dtype:
+                changed.append((
+                    dsname, f"Dtype: {ref_ds.dtype} -> {out_ds.dtype}"
+                ))
+            else:
+                floaty = np.issubdtype(ref_ds.dtype, np.floating) \
+                        or np.issubdtype(ref_ds.dtype, np.complexfloating)
+
+                # Compare data incrementally rather than loading it all at once;
+                # read in blocks of ~64 MB (arbitrary limit) along first axis.
+                for chunk_slice in iter_sized_chunks(ref_ds, 64 * 1024 * 1024):
+                    ref_chunk = ref_ds[chunk_slice]
+                    out_chunk = out_ds[chunk_slice]
+                    if floaty:
+                        eq = np.allclose(ref_chunk, out_chunk, equal_nan=True)
+                    else:
+                        eq = np.array_equal(ref_chunk, out_chunk)
+                    if not eq:
+                        # If just 1 entry, show the values
+                        if ref_ds.size == 1:
+                            r, o = np.squeeze(ref_chunk), np.squeeze(out_chunk)
+                            changed.append((dsname, f"Value: {r} -> {o}"))
+                        else:
+                            changed.append((dsname, "Data changed"))
+                        break
+
+    return ComparisonResult(
+        test_file,
+        new_dsets=sorted(out_dsets - ref_dsets),
+        missing_dsets=sorted(ref_dsets - out_dsets),
+        changed_dsets=changed,
+    )
 
 
 def parse_config(
-    cmd: List[str],
-    config: Dict[str, Any],
-    out_folder: str
+        cmd: List[str], config: Dict[str, Any], out_folder: str
 ) -> List[str]:
     """Convert a dictionary to a list of arguments.
 
-       Values that are not strings will be cast.
-       Lists will be converted to several strings following their `--key`
-       flag.
-       Booleans will be converted to a `--key` flag, where `key` is the
-       dictionary key.
+    Values that are not strings will be cast.
+    Lists will be converted to several strings following their `--key`
+    flag.
+    Booleans will be converted to a `--key` flag, where `key` is the
+    dictionary key.
     """
 
     for key, value in config.items():
-        if ' ' in key or (isinstance(value, str) and ' ' in value):
-            raise ValueError('Spaces are not allowed', key, value)
+        if " " in key or (isinstance(value, str) and " " in value):
+            raise ValueError("Spaces are not allowed", key, value)
 
         if isinstance(value, list):
             cmd.append(f"--{key}")
@@ -286,11 +156,9 @@ def parse_config(
 
 
 def validate_hdf5_files(
-    test_key: str,
     out_folder: pathlib.Path,
     reference_folder: pathlib.Path,
     cal_type: str,
-    find_difference: bool
 ):
     """Apply HDF5 data validation.
 
@@ -298,62 +166,51 @@ def validate_hdf5_files(
         test_key (str): The test name.
         out_folder (pathlib.Path): The OUT folder for the tested data.
         reference_folder (pathlib.Path): The Reference folder for
-          the reference data to validate against
+            the reference data to validate against
         cal_type (str): The type of calibration processing.
-          e.g. dark or correct.
-        find_difference (bool): A flag indicating a need to find the
-          difference between two files if tested data was
-          not identical to the reference data.
+            e.g. dark or correct.
     """
-    # 3rd Check number of produced h5 files.
-    h5files = list(out_folder.glob("*.h5"))
-    expected_h5files = list(reference_folder.glob("*.h5"))
-    assert len(h5files) == len(expected_h5files), f"{test_key} failure, number of files are not as expected."  # noqa
-    LOGGER.info(f"{test_key}'s calibration h5files numbers are as expected.")
+    print("\n--- Compare HDF5 files  ----")
+    print("REF:", reference_folder)
+    print("NEW:", out_folder)
+    ok = True
+
+    result_h5files = {p.name for p in out_folder.glob("*.h5")}
+    ref_h5files = {p.name for p in reference_folder.glob("*.h5")}
+    missing_files = ref_h5files - result_h5files
+    if missing_files:
+        print("Files missing from result (*.h5):", ", ".join(missing_files))
+        ok = False
+    new_files = result_h5files - ref_h5files
+    if new_files:
+        print("New files in result (*.h5):", ", ".join(new_files))
+        ok = False
+
+    files_to_check = sorted(result_h5files & ref_h5files)
 
-    non_valid_files = []
     # Hard coded datasets to exclude from numerical validation.
     # These datasets are know to be updated everytime.
     if cal_type.lower() == "correct":
-        exclude_attrs = ["METADATA/creationDate", "METADATA/updateDate"]
+        exclude_attrs = {"METADATA/creationDate", "METADATA/updateDate"}
     else:
-        exclude_attrs = ["report"]
+        exclude_attrs = {"report"}
 
-    # 4th check that test and reference h5files are identical.
-    _validate_files = partial(
-        validate_files,
+    _validate_file = partial(
+        validate_file,
         reference_folder,
         out_folder,
         exclude_attrs,
     )
-    with multiprocessing.pool.ThreadPool(processes=8) as executor:
-        result = executor.map(_validate_files, h5files)
-
-    # Collect non-valid files, if any, to display them in the error message.
-    for valid, file in result:
-        if not valid:
-            non_valid_files.append(file)
-
-    if len(non_valid_files) > 0:
-        if find_difference:
-            LOGGER.error(f"Found non valid files: {non_valid_files}. "
-                         f"Checking differences for {non_valid_files[0]}")
-            find_differences(
-                non_valid_files[0],
-                reference_folder / non_valid_files[0].name,
-                exclude_attrs
-                )
-            LOGGER.info(f"No difference found for {non_valid_files[0]}")
-        else:
-            assert len(non_valid_files) == 0, f"{test_key} failure, while validating metadata for {non_valid_files}"  # noqa
-            LOGGER.info(f"{test_key}'s calibration h5files"
-                        " are validated successfully.")
+    with multiprocessing.Pool(processes=8) as pool:
+        for comparison in pool.imap(_validate_file, files_to_check):
+            comparison.show()
+            if comparison.found_differences():
+                ok = False
 
+    return ok
 
-def slurm_watcher(
-    test_key: str,
-    std_out: str
-):
+
+def slurm_watcher(test_key: str, std_out: str):
     """
     Watch for submitted slurm jobs and wait for them to finish.
     After they finish apply first test and check
@@ -380,21 +237,31 @@ def slurm_watcher(
         res = run(cmd, stdout=PIPE)
         states = res.stdout.decode().split("\n")[2:-1]
 
-        if not any(s.strip() in [
-            "COMPLETING",
-            "RUNNING",
-            "CONFIGURING",
-            "PENDING",
-        ] for s in states):
+        if not any(
+            s.strip()
+            in [
+                "COMPLETING",
+                "RUNNING",
+                "CONFIGURING",
+                "PENDING",
+            ]
+            for s in states
+        ):
             slurm_watcher = False
         else:
             time.sleep(2)
 
     # 1st check that all jobs were COMPLETED without errors.
     states = res.stdout.decode().split("\n")[2:-1]
-    assert all(s.strip() == "COMPLETED" for s in states), f"{test_key} failure, calibration jobs were not completed. {jobids}: {states}"  # noqa
+    assert all(
+        s.strip() == "COMPLETED" for s in states
+    ), f"{test_key} failure, calibration jobs were not completed. {jobids}: {states}"  # noqa
     LOGGER.info(f"{test_key}'s jobs were COMPLETED")
-    time.sleep(1.0)
+
+
+def load_yaml(file_path):
+    with open(file_path, 'r') as file:
+        return yaml.safe_load(file)
 
 
 @pytest.mark.manual_run
@@ -404,10 +271,9 @@ def slurm_watcher(
     ids=list(automated_test_config.keys()),
 )
 def test_xfel_calibrate(
-    test_key: str, val_dict: dict,
-    release_test_config: Tuple[bool, bool, bool, bool]
+        test_key: str, val_dict: dict, release_test_config: Tuple
 ):
-    """ Test xfel calibrate detectors and calibrations written
+    """Test xfel calibrate detectors and calibrations written
     in the given callab_test YAML file.
     Args:
         test_key : Key for the xfel-calibrate test.
@@ -417,9 +283,14 @@ def test_xfel_calibrate(
     """
 
     (
-        detectors, calibration, picked_test,
-        skip_numerical_validation, only_validate, find_difference,
-        use_slurm, reference_dir_base, out_dir_base,
+        detectors,
+        calibration,
+        picked_test,
+        skip_numerical_validation,
+        only_validate,
+        use_slurm,
+        reference_dir_base,
+        out_dir_base,
     ) = release_test_config
 
     cal_type = val_dict["cal_type"]
@@ -427,10 +298,9 @@ def test_xfel_calibrate(
 
     if not picked_test:
         # Skip non-selected detectors
-        if (
-            detectors != ["all"] and
-            det_type.lower() not in [d.lower() for d in detectors]
-        ):
+        if detectors != ["all"] and det_type.lower() not in [
+            d.lower() for d in detectors
+        ]:
             pytest.skip()
 
         # Skip non-selected calibration
@@ -445,32 +315,34 @@ def test_xfel_calibrate(
     cal_conf = val_dict["config"]
 
     out_folder = pathlib.Path(cal_conf["out-folder"].format(
-        out_dir_base, cal_conf["karabo-id"], test_key))
-    reference_folder = pathlib.Path(val_dict["reference-folder"].format(
-        reference_dir_base, cal_conf["karabo-id"], test_key))
-
-    report_name = (
-        out_folder /
-        f"{test_key}_{datetime.now().strftime('%y%m%d_%H%M%S')}")
+        out_dir_base, cal_conf["karabo-id"], test_key
+    ))
+    reference_folder = pathlib.Path(
+        val_dict["reference-folder"].format(
+            reference_dir_base, cal_conf["karabo-id"], test_key
+        )
+    )
 
+    report_name = out_folder / f"{test_key}_{datetime.now():%y%m%d_%H%M%S}"
     cal_conf["report-to"] = str(report_name)
 
-    cmd = parse_config(cmd, cal_conf, out_folder)
+    cmd = parse_config(cmd, cal_conf, str(out_folder))
 
     if only_validate:
-        validate_hdf5_files(
-            test_key,
-            out_folder,
-            reference_folder,
-            cal_type,
-            find_difference,
-            )
+        assert validate_hdf5_files(
+            out_folder,  reference_folder, cal_type
+        ), "HDF5 files changed - see details above"
         return
 
     if not use_slurm:  # e.g. for Gitlab CI.
         cmd += ["--no-cluster-job"]
 
-    cmd += ["--slurm-name", test_key, "--cal-db-interface", "tcp://max-exfl-cal001:8015#8045"]
+    cmd += [
+        "--slurm-name",
+        test_key,
+        "--cal-db-interface",
+        "tcp://max-exfl-cal001:8015#8045",
+    ]
     f = io.StringIO()
     LOGGER.info(f"Submitting CL: {cmd}")
     with redirect_stdout(f):
@@ -483,17 +355,32 @@ def test_xfel_calibrate(
         # confirm that all jobs succeeded.
         assert errors == 0
 
+    time_to_wait = 5
+    time_counter = 0
     # 2nd check for report availability.
     report_file = out_folder / f"{report_name}.pdf"
-    assert report_file.exists(), f"{test_key} failure, report doesn't exists."
+    while not report_file.exists():
+        time.sleep(1)
+        time_counter += 1
+        if time_counter > time_to_wait:
+            assert False, f"{test_key} failure, report doesn't exists."
     LOGGER.info("Report found.")
 
+    if cal_type.lower() == "correct":
+        # For corrections validate calibration constants
+        metadata_file = f"calibration_metadata_{cal_conf['karabo-id']}.yml"
+        # Load the relevant section from both files
+        ccvs_test = load_yaml(
+            out_folder / metadata_file).get("retrieved-constants", {})
+        ccvs_reference = load_yaml(
+            reference_folder / metadata_file).get("retrieved-constants", {})
+        ccvs_diff = DeepDiff(ccvs_test, ccvs_reference, ignore_order=True)
+        assert ccvs_diff == {}, "Found difference in the metadata for the retrieved Constants."  # noqa
+        LOGGER.info("Retrieved CCVs validated.")
+
     # Stop tests at this point, if desired.
     if not skip_numerical_validation:
-        validate_hdf5_files(
-            test_key,
-            out_folder,
-            reference_folder,
-            cal_type,
-            find_difference,
-        )
+        assert validate_hdf5_files(
+            out_folder,  reference_folder, cal_type
+        ), "HDF5 files changed - see details above"
+        LOGGER.info("H5 Files validated.")
diff --git a/tests/test_update_config.py b/tests/test_update_config.py
index ac8e6a0263407492ccd4234f6140c68ca41bdffc..910af2e70c95f468e6918e0fc8d004359018b80a 100644
--- a/tests/test_update_config.py
+++ b/tests/test_update_config.py
@@ -92,8 +92,9 @@ EXPECTED_CONF = [
         'xray-gain': {'type': bool},
         'blc-noise': {'type': bool},
         'blc-set-min': {'type': bool},
-        'dont-zero-nans': {'type': bool},
-        'dont-zero-orange': {'type': bool},
+        'blc-stripes': {'type': bool},
+        'zero-nans': {'type': bool},
+        'zero-orange': {'type': bool},
         'max-pulses': {'type': list,
                        'msg': 'Range list of maximum pulse indices '
                               '(--max-pulses start end step). '
@@ -106,8 +107,9 @@ EXPECTED_CONF = [
         'no-xray-gain': {'type': bool},
         'no-blc-noise': {'type': bool},
         'no-blc-set-min': {'type': bool},
-        'no-dont-zero-nans': {'type': bool},
-        'no-dont-zero-orange': {'type': bool}
+        'no-blc-stripes': {'type': bool},
+        'no-zero-nans': {'type': bool},
+        'no-zero-orange': {'type': bool}
     },
     {
         'karabo-da': {
@@ -137,15 +139,17 @@ args_1 = {
     "xray_gain": None,
     "blc_noise": None,
     "blc_set_min": None,
-    "dont_zero_nans": None,
-    "dont_zero_orange": None,
+    "blc_stripes": None,
+    "zero_nans": None,
+    "zero_orange": None,
     "max_pulses": None,
     "no_rel_gain": None,
     "no_xray_gain": None,
     "no_blc_noise": None,
     "no_blc_set_min": None,
-    "no_dont_zero_nans": None,
-    "no_dont_zero_orange": None,
+    "no_blc_stripes": None,
+    "no_zero_nans": None,
+    "no_zero_orange": None,
     "karabo_da": None,
 }
 
diff --git a/webservice/manual_launch.py b/webservice/manual_launch.py
index 18078b1ca390a0d61b724a51f2ae5a9e33b467a5..a5a53aa9f93ee8322231de145627923741b607b5 100644
--- a/webservice/manual_launch.py
+++ b/webservice/manual_launch.py
@@ -18,7 +18,7 @@ from rich.progress import (
     TextColumn,
     TimeElapsedColumn,
 )
-from rich.prompt import Prompt
+from rich.prompt import Confirm
 
 parser = argparse.ArgumentParser(
     description="Manually submit calibration jobs.",
@@ -82,14 +82,17 @@ def get_bearer_token() -> str:
         return BEARER["access_token"]
 
     with Client() as client:
-        response = client.post(
-            f"{config['metadata-client']['token-url']}",
-            data={
-                "grant_type": "client_credentials",
-                "client_id": config["metadata-client"]["user-id"],
-                "client_secret": config["metadata-client"]["user-secret"],
-            },
-        )
+        data = {
+            "grant_type": "client_credentials",
+            "client_id": config["metadata-client"]["user-id"],
+            "client_secret": config["metadata-client"]["user-secret"],
+        }
+
+        # With a real user the scope must be set to public
+        if not str(config["metadata-client"]["user-email"]).endswith("example.com"):
+            data["scope"] = "public"
+
+        response = client.post(f"{config['metadata-client']['token-url']}", data=data)
 
     data = response.json()
 
@@ -192,9 +195,9 @@ def main(
     if not really:
         print("[yellow]`--really` flag missing, not submitting jobs")
 
-    if not noconfirm and not Prompt.ask(
+    if not noconfirm and not Confirm.ask(
         f"Submit [red bold]{len(requests)}[/red bold] jobs for proposal "
-        f"[bold]{proposal_no}[/bold]? [y/[bold]n[/bold]]",
+        f"[bold]{proposal_no}[/bold]?",
         default=False,
     ):
         print("[bold red]Aborted[/bold red]")
@@ -212,7 +215,7 @@ def main(
         )
         con = zmq.Context()
         socket = con.socket(zmq.REQ)
-        con = socket.connect("tcp://max-exfl-cal001:5555")
+        socket.connect("tcp://max-exfl-cal001:5555")
 
         if not really:
             #  Fake socket for testing, just logs what would have been sent via ZMQ
diff --git a/webservice/update_config.py b/webservice/update_config.py
index acfbd2c05cab591912b68e2d896b727d9b45f895..f1ae56d369ddbadf4e0d6ca2d158593b9fe47941 100755
--- a/webservice/update_config.py
+++ b/webservice/update_config.py
@@ -19,8 +19,9 @@ AGIPD_CONFIGURATIONS = {
         "xray-gain": {'type': bool},
         "blc-noise": {'type': bool},
         "blc-set-min": {'type': bool},
-        "dont-zero-nans": {'type': bool},
-        "dont-zero-orange": {'type': bool},
+        "blc-stripes": {'type': bool},
+        "zero-nans": {'type': bool},
+        "zero-orange": {'type': bool},
         "max-pulses": {'type': list,
                        'msg': "Range list of maximum pulse indices "
                               "(--max-pulses start end step). "
diff --git a/webservice/update_mdc_darks.py b/webservice/update_mdc_darks.py
new file mode 100644
index 0000000000000000000000000000000000000000..df03f8727510b81ff195e0e52210d58b8e0f1019
--- /dev/null
+++ b/webservice/update_mdc_darks.py
@@ -0,0 +1,46 @@
+import argparse
+from pathlib import Path
+
+from metadata_client.metadata_client import MetadataClient
+
+from .config import webservice as config
+
+parser = argparse.ArgumentParser(
+    description='Update run status at MDC for a given run id.')
+#  TODO: unify configuration argument names across the project
+parser.add_argument('--conf-file', type=str, help='Path to webservice config',
+                    default=None)
+parser.add_argument('--flg', type=str, choices=["IP", "F", "E"], required=True,
+                    help='Status flag for MDC: In Progress/Finished/Error.')  # noqa
+parser.add_argument('id', type=int, help='Dark run id from MDC')
+parser.add_argument('--msg', type=str, help='Message string to MDC',
+                    default='Error while job submission')
+parser.add_argument('--really', action='store_true',
+                    help="Actually make changes (otherwise dry-run)")
+args = parser.parse_args()
+
+if args.conf_file is not None:
+    config.configure(includes_for_dynaconf=[Path(args.conf_file).absolute()])
+
+mdconf = config['metadata-client']
+client_conn = MetadataClient(client_id=mdconf['user-id'],
+                             client_secret=mdconf['user-secret'],
+                             user_email=mdconf['user-email'],
+                             token_url=mdconf['token-url'],
+                             refresh_url=mdconf['refresh-url'],
+                             auth_url=mdconf['auth-url'],
+                             scope=mdconf['scope'],
+                             base_api_url=mdconf['base-api-url'])
+
+print(f"Updating dark run {args.id} to status {args.flg} at {mdconf['base-api-url']}")
+if args.really:
+    response = client_conn.update_dark_run_api(args.id, {
+        'dark_run': {'flg_status': args.flg, 'calcat_feedback': args.msg}
+    })
+
+    if response.status_code == 200:
+        print('Run is updated')
+    else:
+        print(f'Update failed {response}')
+else:
+    print("Add --really to actually make these changes")
diff --git a/webservice/webservice.py b/webservice/webservice.py
index 34da59a3d9f68f511f78e5383ca263ed67041fd1..0652255f006d1e2d5c91f6eeb525d07f428e5be9 100644
--- a/webservice/webservice.py
+++ b/webservice/webservice.py
@@ -1270,60 +1270,79 @@ class ActionsServer:
         async def _continue():
             """Runs in the background after we reply to the 'dark_request' request"""
             await update_mdc_status(self.mdc, 'dark_request', rid, queued_msg)
-            transfer_complete = await wait_transfers(
-                self.mdc, runs, proposal, cycle, instrument
-            )
-            if not transfer_complete:
-                # Timed out
-                await update_mdc_status(
-                    self.mdc, 'dark_request', rid, MDC.MIGRATION_TIMEOUT
+            try:
+                transfer_complete = await wait_transfers(
+                    self.mdc, runs, proposal, cycle, instrument
+                )
+                if not transfer_complete:
+                    # Timed out
+                    await update_mdc_status(
+                        self.mdc, 'dark_request', rid, MDC.MIGRATION_TIMEOUT
+                    )
+                    return
+
+                # Notebooks require one or three runs, depending on the
+                # detector type and operation mode.
+                triple = any(
+                    det in karabo_id for det in
+                    [
+                        "LPD",
+                        "AGIPD",
+                        "JUNGFRAU",
+                        "JF",
+                        "JNGFR",
+                        "JUNGF",
+                        "GH2",
+                        "G2",
+                    ])
+
+                # This fails silently if the hardcoded strings above are
+                # ever changed (triple = False) but the underlying notebook
+                # still expects run-high/run-med/run-low.
+                if triple and len(runs) == 1:
+                    runs_dict = {'run-high': runs[0],
+                                 'run-med': '0',
+                                 'run-low': '0'}
+                elif triple and len(runs) == 3:
+                    runs_dict = {'run-high': runs[0],
+                                 'run-med': runs[1],
+                                 'run-low': runs[2]}
+                else:  # single
+                    runs_dict = {'run': runs[0]}
+
+                # We assume that MyMDC does not allow dark request if the data
+                # is not migrated, thus skipping some validation here.
+                thisconf = copy.copy(data_conf[karabo_id])
+
+                # Pop internal key to avoid propagation to xfel-calibrate.
+                thisconf.pop('disable-correct', None)
+
+                if (karabo_id in pconf
+                        and isinstance(pconf[karabo_id], dict)):
+                    thisconf.update(copy.copy(pconf[karabo_id]))
+
+                thisconf['in-folder'] = in_folder
+                thisconf['out-folder'] = out_folder
+                thisconf['karabo-id'] = karabo_id
+                thisconf['karabo-da'] = karabo_das
+                thisconf['operation-mode'] = operation_mode
+
+                thisconf.update(runs_dict)
+
+                detectors = {karabo_id: thisconf}
+
+                ret, report_path = await self.launch_jobs(
+                    runs, req_id, detectors, 'dark', instrument, cycle, proposal,
+                    request_time
+                )
+            except Exception as e:
+                msg = Errors.JOB_LAUNCH_FAILED.format('dark', e)
+                logging.error(msg, exc_info=e)
+                asyncio.ensure_future(
+                    update_mdc_status(self.mdc, 'dark_request', rid, msg)
                 )
                 return
 
-            # Notebooks require one or three runs, depending on the
-            # detector type and operation mode.
-            triple = any(det in karabo_id for det in
-                         ["LPD", "AGIPD", "JUNGFRAU", "JF", "JNGFR", "GH2"])
-
-            # This fails silently if the hardcoded strings above are
-            # ever changed (triple = False) but the underlying notebook
-            # still expects run-high/run-med/run-low.
-            if triple and len(runs) == 1:
-                runs_dict = {'run-high': runs[0],
-                             'run-med': '0',
-                             'run-low': '0'}
-            elif triple and len(runs) == 3:
-                runs_dict = {'run-high': runs[0],
-                             'run-med': runs[1],
-                             'run-low': runs[2]}
-            else:  # single
-                runs_dict = {'run': runs[0]}
-
-            # We assume that MyMDC does not allow dark request if the data
-            # is not migrated, thus skipping some validation here.
-            thisconf = copy.copy(data_conf[karabo_id])
-
-            # Pop internal key to avoid propagation to xfel-calibrate.
-            thisconf.pop('disable-correct', None)
-
-            if (karabo_id in pconf
-                    and isinstance(pconf[karabo_id], dict)):
-                thisconf.update(copy.copy(pconf[karabo_id]))
-
-            thisconf['in-folder'] = in_folder
-            thisconf['out-folder'] = out_folder
-            thisconf['karabo-id'] = karabo_id
-            thisconf['karabo-da'] = karabo_das
-            thisconf['operation-mode'] = operation_mode
-
-            thisconf.update(runs_dict)
-
-            detectors = {karabo_id: thisconf}
-
-            ret, report_path = await self.launch_jobs(
-                runs, req_id, detectors, 'dark', instrument, cycle, proposal,
-                request_time
-            )
             await update_mdc_status(self.mdc, 'dark_request', rid, ret)
             if len(report_path) == 0:
                 logging.warning("Failed to identify report path for dark_request")