diff --git a/alphastats/DataSet_Preprocess.py b/alphastats/DataSet_Preprocess.py
index 1b7338ed..acc014f8 100644
--- a/alphastats/DataSet_Preprocess.py
+++ b/alphastats/DataSet_Preprocess.py
@@ -9,11 +9,11 @@
 import streamlit as st
 from sklearn.experimental import enable_iterative_imputer  # noqa
 
-from alphastats.keys import Cols
+from alphastats.keys import Cols, ConstantsClass
 from alphastats.utils import ignore_warning
 
 
-class PreprocessingStateKeys:
+class PreprocessingStateKeys(metaclass=ConstantsClass):
     """Keys for accessing the dictionary holding the information about preprocessing."""
 
     # TODO disentangle these keys from the human-readably display strings
diff --git a/alphastats/gui/pages/04_Analysis.py b/alphastats/gui/pages/04_Analysis.py
index e1a0990c..75e8bc33 100644
--- a/alphastats/gui/pages/04_Analysis.py
+++ b/alphastats/gui/pages/04_Analysis.py
@@ -4,7 +4,7 @@
 from alphastats.gui.utils.analysis_helper import (
     display_df,
     display_plot,
-    do_analysis,
+    gather_parameters_and_do_analysis,
 )
 from alphastats.gui.utils.ui_helper import (
     StateKeys,
@@ -51,29 +51,28 @@
     method = st.selectbox(
         "Analysis",
         options=["<select>"]
-        + ["------- plots -------"]
+        + ["------- plots ------------"]
         + plotting_options
         + ["------- statistics -------"]
         + statistic_options,
     )
 
     if method in plotting_options:
-        analysis_result, analysis_object, parameters = do_analysis(
-            method, options_dict=None
+        analysis_result, analysis_object, parameters = (
+            gather_parameters_and_do_analysis(method)
         )
         show_plot = analysis_result is not None
 
     elif method in statistic_options:
-        analysis_result, *_ = do_analysis(
+        analysis_result, _, parameters = gather_parameters_and_do_analysis(
             method,
-            options_dict=None,
         )
         show_df = analysis_result is not None
 
 with c2:
     # --- SHOW PLOT -------------------------------------------------------
     if show_plot:
-        display_plot(method, analysis_result)
+        display_plot(method, analysis_result, parameters)
 
     # --- SHOW STATISTICAL ANALYSIS -------------------------------------------------------
     elif show_df:
diff --git a/alphastats/gui/pages/06_Results.py b/alphastats/gui/pages/06_Results.py
index 9df0b0c5..308d5bda 100644
--- a/alphastats/gui/pages/06_Results.py
+++ b/alphastats/gui/pages/06_Results.py
@@ -21,9 +21,11 @@
 
     method = saved_item[0]
     plot = saved_item[1]
+    parameters = saved_item[2]
 
     st.markdown("\n\n\n")
     st.markdown(f"#### {method}")
+    st.write(f"Parameters used for analysis: {parameters}")
 
     if st.button("x remove analysis", key="remove" + method + str(count)):
         st.session_state[StateKeys.PLOT_LIST].remove(saved_item)
diff --git a/alphastats/gui/utils/analysis.py b/alphastats/gui/utils/analysis.py
index 89450986..e4de3c5b 100644
--- a/alphastats/gui/utils/analysis.py
+++ b/alphastats/gui/utils/analysis.py
@@ -6,25 +6,10 @@
 import streamlit as st
 
 from alphastats.DataSet import DataSet
-from alphastats.keys import Cols
+from alphastats.keys import Cols, ConstantsClass
 from alphastats.plots.VolcanoPlot import VolcanoPlot
 
 
-class ConstantsClass(type):
-    """A metaclass for classes that should only contain string constants."""
-
-    def __setattr__(self, name, value):
-        raise TypeError("Constants class cannot be modified")
-
-    def get_values(cls):
-        """Get all user-defined string values of the class."""
-        return [
-            value
-            for key, value in cls.__dict__.items()
-            if not key.startswith("__") and isinstance(value, str)
-        ]
-
-
 class PlottingOptions(metaclass=ConstantsClass):
     """Keys for the plotting options."""
 
@@ -35,16 +20,19 @@ class PlottingOptions(metaclass=ConstantsClass):
     SAMPLE_DISTRIBUTION_PLOT = "Sampledistribution Plot"
     INTENSITY_PLOT = "Intensity Plot"
     CLUSTERMAP = "Clustermap"
+    DENDROGRAM = "Dendrogram"
 
 
 class StatisticOptions(metaclass=ConstantsClass):
+    """Keys for the statistical options."""
+
     DIFFERENTIAL_EXPRESSION = "Differential Expression Analysis"
     TUKEY_TEST = "Tukey-Test"
     ANOVA = "ANOVA"
     ANCOVA = "ANCOVA"
 
 
-class Analysis(ABC):
+class AbstractAnalysis(ABC):
     """Abstract class for analysis widgets."""
 
     _works_with_nans = True
@@ -58,7 +46,7 @@ def show_widget(self):  # noqa: B027
         pass
 
     def do_analysis(self):
-        """Perform the analysis.
+        """Perform the analysis after an optional check for NaNs.
 
         Returns a tuple(figure, analysis_object, parameters) where figure is the plot,
         analysis_object is the underlying object, parameters is a dictionary of the parameters used.
@@ -66,14 +54,14 @@ def do_analysis(self):
         if not self._works_with_nans and self._dataset.mat.isnull().values.any():
             st.error("This analysis does not work with NaN values.")
             st.stop()
-        return self._do_analysis()
+        return *self._do_analysis(), dict(self._parameters)
 
     @abstractmethod
     def _do_analysis(self):
         pass
 
 
-class GroupCompareAnalysis(Analysis, ABC):
+class AbstractGroupCompareAnalysis(AbstractAnalysis, ABC):
     """Abstract class for group comparison analysis widgets."""
 
     def show_widget(self):
@@ -130,7 +118,7 @@ def show_widget(self):
             self._parameters["column"] = column
 
 
-class DimensionReductionAnalysis(Analysis, ABC):
+class AbstractDimensionReductionAnalysis(AbstractAnalysis, ABC):
     """Abstract class for dimension reduction analysis widgets."""
 
     def show_widget(self):
@@ -146,7 +134,7 @@ def show_widget(self):
         self._parameters.update({"circle": circle, "group": group})
 
 
-class AbstractIntensityPlot(Analysis, ABC):
+class AbstractIntensityPlot(AbstractAnalysis, ABC):
     """Abstract class for intensity plot analysis widgets."""
 
     def show_widget(self):
@@ -185,7 +173,7 @@ def _do_analysis(self):
             method=self._parameters["method"],
             group=self._parameters["group"],
         )
-        return intensity_plot, None, self._parameters
+        return intensity_plot, None
 
 
 class SampleDistributionPlot(AbstractIntensityPlot, ABC):
@@ -197,10 +185,10 @@ def _do_analysis(self):
             method=self._parameters["method"],
             color=self._parameters["group"],  # no typo
         )
-        return intensity_plot, None, self._parameters
+        return intensity_plot, None
 
 
-class PCAPlotAnalysis(DimensionReductionAnalysis):
+class PCAPlotAnalysis(AbstractDimensionReductionAnalysis):
     """Widget for PCA Plot analysis."""
 
     def _do_analysis(self):
@@ -210,10 +198,10 @@ def _do_analysis(self):
             group=self._parameters["group"],
             circle=self._parameters["circle"],
         )
-        return pca_plot, None, self._parameters
+        return pca_plot, None
 
 
-class UMAPPlotAnalysis(DimensionReductionAnalysis):
+class UMAPPlotAnalysis(AbstractDimensionReductionAnalysis):
     """Widget for UMAP Plot analysis."""
 
     def _do_analysis(self):
@@ -222,10 +210,10 @@ def _do_analysis(self):
             group=self._parameters["group"],
             circle=self._parameters["circle"],
         )
-        return umap_plot, None, self._parameters
+        return umap_plot, None
 
 
-class TSNEPlotAnalysis(DimensionReductionAnalysis):
+class TSNEPlotAnalysis(AbstractDimensionReductionAnalysis):
     """Widget for t-SNE Plot analysis."""
 
     def show_widget(self):
@@ -254,10 +242,10 @@ def _do_analysis(self):
             perplexity=self._parameters["perplexity"],
             n_iter=self._parameters["n_iter"],
         )
-        return tsne_plot, None, self._parameters
+        return tsne_plot, None
 
 
-class VolcanoPlotAnalysis(GroupCompareAnalysis):
+class VolcanoPlotAnalysis(AbstractGroupCompareAnalysis):
     """Widget for Volcano Plot analysis."""
 
     def show_widget(self):
@@ -320,10 +308,10 @@ def _do_analysis(self):
             fdr=self._parameters["fdr"],
             color_list=self._parameters["color_list"],
         )
-        return volcano_plot.plot, volcano_plot, self._parameters
+        return volcano_plot.plot, volcano_plot
 
 
-class ClustermapAnalysis(Analysis):
+class ClustermapAnalysis(AbstractAnalysis):
     """Widget for Clustermap analysis."""
 
     _works_with_nans = False
@@ -331,10 +319,21 @@ class ClustermapAnalysis(Analysis):
     def _do_analysis(self):
         """Draw Clustermap using the Clustermap class."""
         clustermap = self._dataset.plot_clustermap()
-        return clustermap, None, self._parameters
+        return clustermap, None
+
+
+class DendrogramAnalysis(AbstractAnalysis):
+    """Widget for Dendrogram analysis."""
+
+    _works_with_nans = False
+
+    def _do_analysis(self):
+        """Draw Clustermap using the Clustermap class."""
+        dendrogram = self._dataset.plot_dendrogram()
+        return dendrogram, None
 
 
-class DifferentialExpressionAnalysis(GroupCompareAnalysis):
+class DifferentialExpressionAnalysis(AbstractGroupCompareAnalysis):
     """Widget for differential expression analysis."""
 
     def show_widget(self):
@@ -360,10 +359,10 @@ def _do_analysis(self):
             group2=self._parameters["group2"],
             column=self._parameters["column"],
         )
-        return diff_exp_analysis, None, self._parameters
+        return diff_exp_analysis, None
 
 
-class TukeyTestAnalysis(Analysis):
+class TukeyTestAnalysis(AbstractAnalysis):
     """Widget for Tukey-Test analysis."""
 
     def show_widget(self):
@@ -385,10 +384,10 @@ def _do_analysis(self):
             protein_id=self._parameters["protein_id"],
             group=self._parameters["group"],
         )
-        return tukey_test_analysis, None, self._parameters
+        return tukey_test_analysis, None
 
 
-class AnovaAnalysis(GroupCompareAnalysis):
+class AnovaAnalysis(AbstractGroupCompareAnalysis):
     """Widget for ANOVA analysis."""
 
     def show_widget(self):
@@ -416,10 +415,10 @@ def _do_analysis(self):
             protein_ids=self._parameters["protein_ids"],
             tukey=self._parameters["tukey"],
         )
-        return anova_analysis, None, self._parameters
+        return anova_analysis, None
 
 
-class AncovaAnalysis(Analysis):
+class AncovaAnalysis(AbstractAnalysis):
     """Widget for Ancova analysis."""
 
     def show_widget(self):
@@ -449,4 +448,20 @@ def _do_analysis(self):
             covar=self._parameters["covar"],
             between=self._parameters["between"],
         )
-        return ancova_analysis, None, self._parameters
+        return ancova_analysis, None
+
+
+ANALYSIS_OPTIONS = {
+    PlottingOptions.VOLCANO_PLOT: VolcanoPlotAnalysis,
+    PlottingOptions.PCA_PLOT: PCAPlotAnalysis,
+    PlottingOptions.UMAP_PLOT: UMAPPlotAnalysis,
+    PlottingOptions.TSNE_PLOT: TSNEPlotAnalysis,
+    PlottingOptions.SAMPLE_DISTRIBUTION_PLOT: SampleDistributionPlot,
+    PlottingOptions.INTENSITY_PLOT: IntensityPlot,
+    PlottingOptions.CLUSTERMAP: ClustermapAnalysis,
+    PlottingOptions.DENDROGRAM: DendrogramAnalysis,
+    StatisticOptions.DIFFERENTIAL_EXPRESSION: DifferentialExpressionAnalysis,
+    StatisticOptions.TUKEY_TEST: TukeyTestAnalysis,
+    StatisticOptions.ANOVA: AnovaAnalysis,
+    StatisticOptions.ANCOVA: AncovaAnalysis,
+}
diff --git a/alphastats/gui/utils/analysis_helper.py b/alphastats/gui/utils/analysis_helper.py
index aa2597f2..ad70e954 100644
--- a/alphastats/gui/utils/analysis_helper.py
+++ b/alphastats/gui/utils/analysis_helper.py
@@ -4,23 +4,8 @@
 import pandas as pd
 import streamlit as st
 
-from alphastats.gui.utils.analysis import (
-    AncovaAnalysis,
-    AnovaAnalysis,
-    ClustermapAnalysis,
-    DifferentialExpressionAnalysis,
-    IntensityPlot,
-    PCAPlotAnalysis,
-    PlottingOptions,
-    SampleDistributionPlot,
-    StatisticOptions,
-    TSNEPlotAnalysis,
-    TukeyTestAnalysis,
-    UMAPPlotAnalysis,
-    VolcanoPlotAnalysis,
-)
+from alphastats.gui.utils.analysis import ANALYSIS_OPTIONS
 from alphastats.gui.utils.ui_helper import StateKeys, convert_df
-from alphastats.keys import Cols
 
 
 def display_figure(plot):
@@ -33,22 +18,13 @@ def display_figure(plot):
         st.pyplot(plot)
 
 
-def save_plot_to_session_state(method, plot):
-    """
-    save plot with method to session state to retrieve old results
-    """
-    st.session_state[StateKeys.PLOT_LIST] += [(method, plot)]
-
-
-def display_df(df):
-    mask = df.applymap(type) != bool  # noqa: E721
-    d = {True: "TRUE", False: "FALSE"}
-    df = df.where(mask, df.replace(d))
-    st.dataframe(df)
-
-
 @st.fragment
-def display_plot(method, analysis_result, show_save_button=True) -> None:
+def display_plot(
+    method: str,
+    analysis_result: Any,
+    parameters: Optional[Dict] = None,
+    show_save_button=True,
+) -> None:
     """A fragment to display the plot and download options."""
     display_figure(analysis_result)
 
@@ -56,16 +32,21 @@ def display_plot(method, analysis_result, show_save_button=True) -> None:
 
     with c1:
         if show_save_button and st.button("Save to results page.."):
-            save_plot_to_session_state(method, analysis_result)
+            save_plot_to_session_state(method, analysis_result, parameters)
 
     with c2:
         download_figure(method, analysis_result, format="pdf")
         download_figure(method, analysis_result, format="svg")
 
     with c3:
-        download_preprocessing_info(
-            method, analysis_result
-        )  # TODO this should go elsewhere
+        download_analysis_and_preprocessing_info(method, analysis_result, parameters)
+
+
+def display_df(df):
+    mask = df.applymap(type) != bool  # noqa: E721
+    d = {True: "TRUE", False: "FALSE"}
+    df = df.where(mask, df.replace(d))
+    st.dataframe(df)
 
 
 def download_figure(method, plot, format):
@@ -85,169 +66,49 @@ def download_figure(method, plot, format):
     st.download_button(label="Download as " + format, data=buffer, file_name=filename)
 
 
-def download_preprocessing_info(method, plot):
-    preprocesing_dict = plot.preprocessing
-    df = pd.DataFrame(preprocesing_dict.items())
-    filename = "plot" + method + "preprocessing_info.csv"
+def download_analysis_and_preprocessing_info(method, plot, parameters):
+    parameters_pretty = {f"analysis_parameter__{k}": v for k, v in parameters.items()}
+    dict_to_save = {
+        **plot.preprocessing,
+        **parameters_pretty,
+    }  # TODO why is the preprocessing info saved in the plots?
+
+    df = pd.DataFrame(dict_to_save.items())
+
+    filename = "plot" + method + "analysis_info.csv"
     csv = convert_df(df)
     st.download_button(
-        "Download DataSet Info as .csv",
+        "Download Analysis info as .csv",
         csv,
         filename,
         "text/csv",
     )
 
 
-def get_unique_values_from_column(column):
-    unique_values = (
-        st.session_state[StateKeys.DATASET].metadata[column].unique().tolist()
-    )
-    return unique_values
-
-
-def st_general(method_dict):
-    chosen_parameter_dict = {}
-
-    if "settings" not in method_dict:
-        # TODO: is this check really required here? If so, refactor to be part of plotting/statistic_options
-        if st.session_state[StateKeys.DATASET].mat.isna().values.any():
-            st.error(
-                "Data contains missing values impute your data before plotting (Preprocessing - Imputation)."
-            )
-            return None
-
-        st.info("No parameters to set.")
-
-    else:
-        for parameter, parameter_dict in method_dict["settings"].items():
-            if "options" in parameter_dict:
-                chosen_parameter = st.selectbox(
-                    parameter_dict.get("label"), options=parameter_dict.get("options")
-                )
-            else:
-                chosen_parameter = st.checkbox(parameter_dict.get("label"))
-
-            chosen_parameter_dict[parameter] = chosen_parameter
-
-    return chosen_parameter_dict
+def save_plot_to_session_state(method, plot, parameters):
+    """
+    save plot with method to session state to retrieve old results
+    """
+    st.session_state[StateKeys.PLOT_LIST] += [(method, plot, parameters)]
 
 
-def do_analysis(
-    method: str, options_dict: Dict[str, Any]
-) -> Tuple[Optional[Any], Optional[Any], Dict[str, Any]]:
+def gather_parameters_and_do_analysis(
+    analysis_name: str,
+) -> Tuple[Optional[Any], Optional[Any], Optional[Dict[str, Any]]]:
     """Extract plotting options and display.
 
     Returns a tuple(figure, analysis_object, parameters) where figure is the plot,
     analysis_object is the underlying object, parameters is a dictionary of the parameters used.
 
     Currently, analysis_object is only not-None for Volcano Plot.
-    # TODO unify the API of all analysis methods
     """
-    options = {
-        PlottingOptions.VOLCANO_PLOT: VolcanoPlotAnalysis,
-        PlottingOptions.PCA_PLOT: PCAPlotAnalysis,
-        PlottingOptions.UMAP_PLOT: UMAPPlotAnalysis,
-        PlottingOptions.TSNE_PLOT: TSNEPlotAnalysis,
-        PlottingOptions.SAMPLE_DISTRIBUTION_PLOT: SampleDistributionPlot,
-        PlottingOptions.INTENSITY_PLOT: IntensityPlot,
-        PlottingOptions.CLUSTERMAP: ClustermapAnalysis,
-        # "Dendrogram": dataet.plot_dendrogram},  # TODO this was commented out in the original code?
-        StatisticOptions.DIFFERENTIAL_EXPRESSION: DifferentialExpressionAnalysis,
-        StatisticOptions.TUKEY_TEST: TukeyTestAnalysis,
-        StatisticOptions.ANOVA: AnovaAnalysis,
-        StatisticOptions.ANCOVA: AncovaAnalysis,
-    }
-
-    if (analysis_class := options.get(method)) is not None:
+    if (analysis_class := ANALYSIS_OPTIONS.get(analysis_name)) is not None:
         analysis = analysis_class(st.session_state[StateKeys.DATASET])
         analysis.show_widget()
         if st.button("Run analysis .."):
             with st.spinner("Running analysis .."):
                 return analysis.do_analysis()
-        return None, None, {}
-
-    method_dict = options_dict.get(method)
-
-    # old, to be refactored logic:
-    parameters = st_general(method_dict=method_dict)
-
-    submitted = st.button("Run analysis ..")
-
-    if submitted:
-        with st.spinner("Calculating..."):
-            return method_dict["function"](**parameters), None, parameters
-
-    return None, None, {}
-
-
-# TODO this can be deleted after all analysis adapted the new Pattern (cf. analysis.py:Analysis())
-def helper_plot_dimensionality_reduction(method_dict):
-    group = st.selectbox(
-        method_dict["settings"]["group"].get("label"),
-        options=method_dict["settings"]["group"].get("options"),
-    )
-
-    circle = False
-
-    if group is not None:
-        circle = st.checkbox("circle")
-
-    chosen_parameter_dict = {
-        "circle": circle,
-        "group": group,
-    }
-    return chosen_parameter_dict
-
-
-# TODO this can be deleted after all analysis adapted the new Pattern (cf. analysis.py:Analysis())
-def helper_compare_two_groups():
-    """
-    Helper function to compare two groups for example
-    Volcano Plot, Differential Expression Analysis and t-test
-    selectbox based on selected column
-    """
-    dataset = st.session_state[StateKeys.DATASET]
-    chosen_parameter_dict = {}
-    default_option = "<select>"
-    group = st.selectbox(
-        "Grouping variable",
-        options=[default_option] + dataset.metadata.columns.to_list(),
-    )
-
-    if group != default_option:
-        unique_values = dataset.metadata[group].unique().tolist()
-
-        group1 = st.selectbox("Group 1", options=unique_values)
-
-        group2 = st.selectbox("Group 2", options=list(reversed(unique_values)))
-
-        chosen_parameter_dict.update(
-            {"column": group, "group1": group1, "group2": group2}
-        )
-
-        if group1 == group2:
-            st.error(
-                "Group 1 and Group 2 can not be the same please select different group."
-            )
+        return None, None, None
 
     else:
-        group1 = st.multiselect(
-            "Group 1 samples:",
-            options=dataset.metadata[Cols.SAMPLE].to_list(),
-        )
-
-        group2 = st.multiselect(
-            "Group 2 samples:",
-            options=list(reversed(dataset.metadata[Cols.SAMPLE].to_list())),
-        )
-
-        intersection_list = list(set(group1).intersection(set(group2)))
-
-        if len(intersection_list) > 0:
-            st.warning(
-                "Group 1 and Group 2 contain same samples: " + str(intersection_list)
-            )
-
-        chosen_parameter_dict.update({"group1": group1, "group2": group2})
-
-    return chosen_parameter_dict
+        raise ValueError(f"Analysis method {analysis_name} not found.")
diff --git a/alphastats/gui/utils/ui_helper.py b/alphastats/gui/utils/ui_helper.py
index 23387c49..0db3bf51 100644
--- a/alphastats/gui/utils/ui_helper.py
+++ b/alphastats/gui/utils/ui_helper.py
@@ -6,6 +6,7 @@
 
 from alphastats import __version__
 from alphastats.gui.utils.preprocessing_helper import PREPROCESSING_STEPS
+from alphastats.keys import ConstantsClass
 
 # TODO add logo above the options when issue is closed
 # https://github.com/streamlit/streamlit/issues/4984
@@ -101,7 +102,7 @@ def init_session_state() -> None:
         st.session_state[StateKeys.LLM_INTEGRATION] = {}
 
 
-class StateKeys:
+class StateKeys(metaclass=ConstantsClass):
     ## 02_Data Import
     # on 1st run
     ORGANISM = "organism"  # TODO this is essentially a constant
diff --git a/alphastats/keys.py b/alphastats/keys.py
index f6b82429..4583cf03 100644
--- a/alphastats/keys.py
+++ b/alphastats/keys.py
@@ -1,11 +1,24 @@
 """String constants for accessing columns."""
 
 
-class Cols:
+class ConstantsClass(type):
+    """A metaclass for classes that should only contain string constants."""
+
+    def __setattr__(self, name, value):
+        raise TypeError("Constants class cannot be modified")
+
+    def get_values(cls):
+        """Get all user-defined string values of the class."""
+        return [
+            value
+            for key, value in cls.__dict__.items()
+            if not key.startswith("__") and isinstance(value, str)
+        ]
+
+
+class Cols(metaclass=ConstantsClass):
     """String constants for accessing columns of the main dataframe in DataSet."""
 
     INDEX = "index_"
-
     GENE_NAMES = "gene_names_"
-
     SAMPLE = "sample_"