bifurcation-explorer 0.1.0__tar.gz

bifurcation_explorer-0.1.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: bifurcation-explorer
+Version: 0.1.0
+Summary: A tool for exploring bifurcations in a set of food-web networks
+Author-email: Pablo Alvarez Lopez <pablo@alvarezlopez.com>
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: dash
+Requires-Dist: numpy
+Requires-Dist: scipy
+Dynamic: license-file
+
+# Bifurcation Explorer

bifurcation_explorer-0.1.0/README.md

@@ -0,0 +1 @@
+# Bifurcation Explorer

bifurcation_explorer-0.1.0/pyproject.toml

@@ -0,0 +1,53 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "bifurcation-explorer"
+version = "0.1.0"
+description = "A tool for exploring bifurcations in a set of food-web networks"
+readme = "README.md"
+requires-python = ">=3.9"
+authors = [
+    { name = "Pablo Alvarez Lopez", email = "pablo@alvarezlopez.com" }
+]
+
+dependencies = [
+    "dash",
+    "numpy",
+    "scipy"
+]
+
+[project.scripts]
+bifurcation-explorer = "bifurcation_explorer.__main__:run"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"*" = ["*.css", "*.html", "*.png", "*.jpg"]
+
+# tools configuration
+
+[tool.black]
+line-length = 150
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+
+[tool.mypy]
+python_version = "3.9"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+#ignore_missing_imports = true
+
+[tool.pylint."MESSAGES CONTROL"]
+max-line-length = 150
+disable = [
+    "R0903", # Too few public methods
+]
+
+[tool.pylint.FORMAT]
+expected-line-ending-format = "CRLF"

bifurcation_explorer-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

bifurcation_explorer-0.1.0/src/bifurcation_explorer/__main__.py

@@ -0,0 +1,20 @@
+from threading import Timer
+import webbrowser
+import pathlib
+
+# project imports
+from bifurcation_explorer.common import glob
+from bifurcation_explorer.enums.static_options import StaticOptions
+from bifurcation_explorer.frontend.layout import html_layout
+from bifurcation_explorer.callbacks import *
+
+# main
+if __name__ == "__main__":
+    # set main folder
+    glob.config.main_folder = pathlib.Path(__file__).parent.resolve()
+    # open browser after 1 second
+    Timer(1, lambda: webbrowser.open_new("http://127.0.0.1:8050/")).start()
+    # set layout
+    glob.app.layout = html_layout
+    # run app
+    glob.app.run(debug=StaticOptions.DEBUG)

bifurcation_explorer-0.1.0/src/bifurcation_explorer/callbacks/__init__.py

@@ -0,0 +1,7 @@
+from .change_resolution import change_resolution
+from .select_network_compartments import select_network_compartments
+from .select_parameter_type import select_parameter_type
+from .update_eigenvalue_spectrum_index_alternative import update_eigenvalue_spectrum_index_alternative
+from .update_eigenvalue_spectrum_index_empirical import update_eigenvalue_spectrum_index_empirical
+from .update_fixed_parameter_value import update_fixed_parameter_value
+from .update_graphs import update_graphs

bifurcation_explorer-0.1.0/src/bifurcation_explorer/callbacks/change_resolution.py

@@ -0,0 +1,97 @@
+from dash import Input, Output, Patch, callback
+
+from bifurcation_explorer.common import glob
+from bifurcation_explorer.enums.styles import Styles
+from bifurcation_explorer.frontend.ids import IDs
+
+# callback to change resolution
+@callback(
+    # outputs
+    Output(IDs.DROPDOWN_SIZE, "value"),
+    Output(IDs.FIG_TERNARY_GRAPH, "figure", allow_duplicate=True),
+    Output(IDs.FIG_BIFURCATION_DIAGRAMM_FIRST, "figure", allow_duplicate=True),
+    Output(IDs.FIG_BIFURCATION_DIAGRAMM_SECOND, "figure", allow_duplicate=True),
+    Output(IDs.FIG_EIGENVALUE_SPECTRUM_EMPIRICAL, "figure", allow_duplicate=True),
+    Output(IDs.FIG_EIGENVALUE_SPECTRUM_ALTERNATIVE, "figure", allow_duplicate=True),
+    Output(IDs.FIG_TIME_SERIES_FIRST, "figure", allow_duplicate=True),
+    Output(IDs.FIG_TIME_SERIES_SECOND, "figure", allow_duplicate=True),
+    Output(IDs.FIG_PHASE_PORTRAIT_FIRST, "figure", allow_duplicate=True),
+    Output(IDs.FIG_PHASE_PORTRAIT_SECOND, "figure", allow_duplicate=True),
+    Output(IDs.DIV_GRAPH_PLOT_01, "style"),
+    Output(IDs.DIV_GRAPH_PLOT_02, "style"),
+    Output(IDs.DIV_GRAPH_PLOT_03, "style"),
+    Output(IDs.DIV_GRAPH_PLOT_04, "style"),
+    Output(IDs.DIV_GRAPH_PLOT_05, "style"),
+    Output(IDs.DIV_GRAPH_PLOT_06, "style"),
+    Output(IDs.DIV_GRAPH_PLOT_07, "style"),
+    Output(IDs.DIV_GRAPH_PLOT_08, "style"),
+    Output(IDs.DIV_GRAPHS, "style"),
+    Output(IDs.DIV_RIGH_PANEL, "style"),
+    Output(IDs.DIV_SMALL_ROW_01, "style"),
+    Output(IDs.DIV_SMALL_ROW_02, "style"),
+    Output(IDs.DIV_SMALL_ROW_03, "style"),
+    Output(IDs.DIV_SMALL_ROW_04, "style"),
+    Output(IDs.DIV_GRAPH_TERNARY, "style"),
+    # inputs
+    Input(IDs.DROPDOWN_SIZE, "value"),
+    # we don't need an initial call
+    prevent_initial_call=True,
+)
+
+# change resolution
+def change_resolution(size: int):
+    # update resolution in config
+    glob.config.resolution = size
+    # declare patch for ternary
+    patched_ternary = Patch()
+    patched_ternary["layout"]["width"] = size * 2
+    patched_ternary["layout"]["height"] = size * 2
+    # declare patch for plots
+    patched_plot = Patch()
+    patched_plot["layout"]["width"] = size * 2
+    patched_plot["layout"]["height"] = size
+    # get div styles
+    div_graph_plot = Styles.DIV_GRAPH_PLOT
+    div_graphs = Styles.DIV_GRAPHS
+    div_right_panel = Styles.DIV_RIGHT_PANEL
+    div_small_row = Styles.DIV_SMALL_ROW
+    div_ternary_graph = Styles.DIV_GRAPH_TERNARY
+    # update styles
+    div_graph_plot["width"] = f"{size * 2}px"
+    div_graph_plot["height"] = f"{size}px"
+    div_graphs["width"] = f"{size * 4}px"
+    div_graphs["height"] = f"{size * 2}px"
+    div_right_panel["width"] = f"{size * 2}px"
+    div_right_panel["height"] = f"{size * 4}px"
+    div_small_row["width"] = f"{size * 2}px"
+    div_small_row["height"] = f"{size}px"
+    div_ternary_graph["width"] = f"{size * 2}px"
+    div_ternary_graph["height"] = f"{size * 2}px"
+    # return values
+    return (
+        size, 
+        patched_ternary,
+        patched_plot,
+        patched_plot,
+        patched_plot,
+        patched_plot,
+        patched_plot,
+        patched_plot,
+        patched_plot,
+        patched_plot,
+        div_graph_plot, 
+        div_graph_plot, 
+        div_graph_plot, 
+        div_graph_plot,
+        div_graph_plot,
+        div_graph_plot, 
+        div_graph_plot, 
+        div_graph_plot,
+        div_graphs,
+        div_right_panel,
+        div_small_row,
+        div_small_row, 
+        div_small_row,
+        div_small_row, 
+        div_ternary_graph
+    )

bifurcation_explorer-0.1.0/src/bifurcation_explorer/callbacks/select_network_compartments.py

@@ -0,0 +1,52 @@
+from dash import Input, Output, callback
+
+from bifurcation_explorer.common import glob
+from bifurcation_explorer.frontend.ids import IDs
+from bifurcation_explorer.graph.ternary.build import build_ternary
+from bifurcation_explorer.graph.ternary.update_traces import update_traces
+
+
+# callback to select network
+@callback(
+    # outputs
+    Output(IDs.DROPDOWN_NETWORK, "value"),
+    Output(IDs.DROPDOWN_COMPARTMENT_FIRST, "options"),
+    Output(IDs.DROPDOWN_COMPARTMENT_FIRST, "value"),
+    Output(IDs.DROPDOWN_COMPARTMENT_SECOND, "options"),
+    Output(IDs.DROPDOWN_COMPARTMENT_SECOND, "value"),
+    # inputs
+    Input(IDs.DROPDOWN_NETWORK, "value"),
+    Input(IDs.DROPDOWN_COMPARTMENT_FIRST, "value"),
+    Input(IDs.DROPDOWN_COMPARTMENT_SECOND, "value"),
+)
+
+# select network and compartments
+def select_network_compartments(network: str, compartment_value_a: str, compartment_value_b: str):
+    # check if update network
+    if glob.config.network != network:
+        # update network
+        glob.config.update_network(network)
+        # reset ternary
+        glob.figures.ternary = build_ternary()
+        # load ternary data
+        glob.plot_data.load_ternary_data()
+    # update compartments
+    glob.config.update_comparment_first(compartment_value_a)
+    glob.config.update_comparment_second(compartment_value_b)
+    # get the list of new compartments
+    new_compartments = glob.config.get_current_compartments()
+    # update branch datas
+    glob.plot_data.load_branch_datas()
+    # update ternary traces
+    update_traces()
+    # redraw bifurcation diagrams
+    glob.config.drawing_options.redraw_bifurcation_diagrams_first.redraw_all()
+    glob.config.drawing_options.redraw_bifurcation_diagrams_second.redraw_all()
+    # return network and new list of compartments
+    return (
+        network,
+        new_compartments,
+        glob.config.compartment_first,
+        new_compartments,
+        glob.config.compartment_second,
+    )

bifurcation_explorer-0.1.0/src/bifurcation_explorer/callbacks/select_parameter_type.py

@@ -0,0 +1,29 @@
+from dash import Input, Output, callback
+
+from bifurcation_explorer.common import glob
+from bifurcation_explorer.enums.types.parameter_types import ParameterTypes
+from bifurcation_explorer.frontend.ids import IDs
+
+
+# callback to sync parameter checkboxes
+@callback(
+    # outputs
+    Output(IDs.DROPDOWN_PARAMETER_TYPE, "value"),
+    # inputs
+    Input(IDs.DROPDOWN_PARAMETER_TYPE, "value"),
+    # we don't need an initial call
+    prevent_initial_call=True,
+)
+
+# select parameter type
+def select_parameter_type(parameter_type_str: str):
+    # set new parameter type
+    try:
+        glob.config.update_fixed_parameter_type(ParameterTypes(parameter_type_str))
+    except ValueError:
+        print(f"Error: invalid parameter '{parameter_type_str}'.")
+    # force redraw ternaries and bifurcation diagrams
+    glob.config.drawing_options.redraw_ternary.redraw_all()
+    glob.config.drawing_options.redraw_bifurcation_diagrams_first.redraw_all()
+    glob.config.drawing_options.redraw_bifurcation_diagrams_second.redraw_all()
+    return parameter_type_str

bifurcation_explorer-0.1.0/src/bifurcation_explorer/callbacks/update_eigenvalue_spectrum_index_alternative.py

@@ -0,0 +1,26 @@
+from dash import Input, Output, callback
+
+from bifurcation_explorer.common import glob
+from bifurcation_explorer.enums.types.branch_types import BranchTypes
+from bifurcation_explorer.frontend.ids import IDs
+
+
+# callback to update analyzed value
+@callback(
+    # outputs
+    Output(IDs.TEXTFIELD_EIGENVALUE_SPECTRUM_INDEX_ALTERNATIVE, "value"),
+    # inputs
+    Input(IDs.TEXTFIELD_EIGENVALUE_SPECTRUM_INDEX_ALTERNATIVE, "value"),
+    # we don't need an initial call
+    prevent_initial_call=True,
+)
+
+# update analyzed value
+def update_eigenvalue_spectrum_index_alternative(eigenvalue_spectrum_index: int):
+    # check that we introduced a valid number
+    if eigenvalue_spectrum_index is not None:
+        # update index
+        glob.config.update_eigenvalue_spectrum_index(
+            eigenvalue_spectrum_index, BranchTypes.ALTERNATIVE
+        )
+    return eigenvalue_spectrum_index

bifurcation_explorer-0.1.0/src/bifurcation_explorer/callbacks/update_eigenvalue_spectrum_index_empirical.py

@@ -0,0 +1,34 @@
+from dash import Input, Output, callback
+
+from bifurcation_explorer.common import glob
+from bifurcation_explorer.enums.types.branch_types import BranchTypes
+from bifurcation_explorer.frontend.ids import IDs
+
+
+# callback to update analyzed value
+@callback(
+    # outputs
+    Output(IDs.TEXTFIELD_EIGENVALUE_SPECTRUM_INDEX_EMPIRICAL, "value"),
+    # inputs
+    Input(IDs.TEXTFIELD_EIGENVALUE_SPECTRUM_INDEX_EMPIRICAL, "value"),
+    # we don't need an initial call
+    prevent_initial_call=True,
+)
+
+
+def update_eigenvalue_spectrum_index_empirical(eigenvalue_spectrum_index: int):
+    """Update the eigenvalue spectrum index for empirical data.
+
+    Args:
+        eigenvalue_spectrum_index: The index value to set for the eigenvalue spectrum.
+
+    Returns:
+        The eigenvalue spectrum index value.
+    """
+    # check that we introduced a valid number
+    if eigenvalue_spectrum_index is not None:
+        # update index
+        glob.config.update_eigenvalue_spectrum_index(
+            eigenvalue_spectrum_index, BranchTypes.EMPIRICAL
+        )
+    return eigenvalue_spectrum_index

bifurcation_explorer-0.1.0/src/bifurcation_explorer/callbacks/update_fixed_parameter_value.py

@@ -0,0 +1,30 @@
+from dash import Input, Output, callback
+
+from bifurcation_explorer.common import glob
+from bifurcation_explorer.frontend.ids import IDs
+
+
+# callback to update fixed value
+@callback(
+    # outputs
+    Output(IDs.TEXTFIELD_FIXED_PARAMETER_VALUE, "value"),
+    # inputs
+    Input(IDs.TEXTFIELD_FIXED_PARAMETER_VALUE, "value"),
+    # we don't need an initial call
+    prevent_initial_call=True,
+)
+
+# update fixed value
+def update_fixed_parameter_value(fixed_parameter_value: float):
+    # check that we introduced a valid number
+    if fixed_parameter_value is not None:
+        # set new value
+        fixed_parameter_value = glob.config.update_fixed_parameter_value(fixed_parameter_value)
+        # read branch datas
+        glob.plot_data.load_branch_datas()
+        # update only ternary branches
+        glob.config.drawing_options.redraw_ternary.branches = True
+        # redraw full bifurcation diagrams
+        glob.config.drawing_options.redraw_bifurcation_diagrams_first.redraw_all()
+        glob.config.drawing_options.redraw_bifurcation_diagrams_second.redraw_all()
+    return fixed_parameter_value

bifurcation_explorer-0.1.0/src/bifurcation_explorer/callbacks/update_graphs.py

@@ -0,0 +1,146 @@
+from dash import Input, Output, callback
+
+from bifurcation_explorer.common import glob
+from bifurcation_explorer.enums.types.branch_types import BranchTypes
+from bifurcation_explorer.enums.types.plot_types import PlotTypes
+from bifurcation_explorer.frontend.ids import IDs
+from bifurcation_explorer.graph.bifurcation_diagram.update import update_bifurcation_diagram
+from bifurcation_explorer.graph.eigenvalue_spectrum.update import update_eigenvalue_spectrum
+from bifurcation_explorer.graph.ternary.update_data import update_ternary_data
+
+
+# callback to update graphs
+@callback(
+    # outputs
+    [
+        Output(IDs.FIG_TERNARY_GRAPH, "figure"),
+        Output(IDs.FIG_BIFURCATION_DIAGRAMM_FIRST, "figure"),
+        Output(IDs.FIG_BIFURCATION_DIAGRAMM_SECOND, "figure"),
+        Output(IDs.FIG_EIGENVALUE_SPECTRUM_EMPIRICAL, "figure"),
+        Output(IDs.FIG_EIGENVALUE_SPECTRUM_ALTERNATIVE, "figure"),
+        Output(IDs.ERROR_MESSAGE, "children"),
+    ],
+    # inputs
+    [
+        # general
+        Input(IDs.DROPDOWN_NETWORK, "value"),
+        Input(IDs.DROPDOWN_PARAMETER_TYPE, "value"),
+        Input(IDs.DROPDOWN_COMPARTMENT_FIRST, "value"),
+        Input(IDs.DROPDOWN_COMPARTMENT_SECOND, "value"),
+        Input(IDs.TEXTFIELD_FIXED_PARAMETER_VALUE, "value"),
+        # branches
+        Input(IDs.CHECKBOX_EQUILIBRIA_AREA, "value"),
+        Input(IDs.CHECKBOX_EQUILIBRIA_STABLE, "value"),
+        Input(IDs.CHECKBOX_EQUILIBRIA_UNSTABLE, "value"),
+        Input(IDs.CHECKBOX_EQUILIBRIA_OVERINFORMATION, "value"),
+        # bifurcations
+        Input(IDs.CHECKBOX_BIFURCATIONS_SADDLENODE_EMPIRICAL, "value"),
+        Input(IDs.CHECKBOX_BIFURCATIONS_SADDLENODE_ALTERNATIVE, "value"),
+        Input(IDs.CHECKBOX_BIFURCATIONS_TRANSCRITICAL_EMPIRICAL, "value"),
+        Input(IDs.CHECKBOX_BIFURCATIONS_TRANSCRITICAL_ALTERNATIVE, "value"),
+        Input(IDs.CHECKBOX_BIFURCATIONS_HOPF_EMPIRICAL, "value"),
+        Input(IDs.CHECKBOX_BIFURCATIONS_ENVELOPE_EMPIRICAL, "value"),
+        Input(IDs.CHECKBOX_BIFURCATIONS_HOPF_ALTERNATIVE, "value"),
+        Input(IDs.CHECKBOX_BIFURCATIONS_ENVELOPE_ALTERNATIVE, "value"),
+        # others
+        Input(IDs.CHECKBOX_OTHERS_EXTINCT, "value"),
+        Input(IDs.CHECKBOX_OTHERS_INTERNALERROR, "value"),
+        Input(IDs.CHECKBOX_OTHERS_EIGENVALUE_SPECTRUM_INDEX, "value"),
+        # draw options
+        Input(IDs.CHECKBOX_DRAW_BRANCH_EMPIRICAL, "value"),
+        Input(IDs.CHECKBOX_DRAW_BRANCH_ALTERNATIVE, "value"),
+        Input(IDs.CHECKBOX_DRAW_LINES, "value"),
+        Input(IDs.CHECKBOX_DRAW_POINTS, "value"),
+        # eigen values spectrum
+        Input(IDs.TEXTFIELD_EIGENVALUE_SPECTRUM_INDEX_EMPIRICAL, "value"),
+        Input(IDs.TEXTFIELD_EIGENVALUE_SPECTRUM_INDEX_ALTERNATIVE, "value"),
+        # eigen values centering
+        Input(IDs.CHECKBOX_EIGENVALUE_SPECTRUM_CENTERED_EMPIRICAL, "value"),
+        Input(IDs.CHECKBOX_EIGENVALUE_SPECTRUM_CENTERED_ALTERNATIVE, "value"),
+    ],
+)
+
+# update graph
+def update_graphs(
+    _network: str,
+    _parameter_type: str,
+    _compartment_a: str,
+    _compartment_b: str,
+    _fixed_parameter_value: float,
+    # equilibria
+    equilibria_area: bool,
+    equilibria_stable: bool,
+    equilibria_unstable: bool,
+    equilibria_over_information: bool,
+    # bifurcations
+    bifurcations_saddlenode_empirical: bool,
+    bifurcations_saddlenode_alternative: bool,
+    bifurcations_transcritical_empirical: bool,
+    bifurcations_transcritical_alternative: bool,
+    bifurcations_hopf_empirical: bool,
+    bifurcations_envelope_empirical: bool,
+    bifurcations_hopf_alternative: bool,
+    bifurcations_envelope_alternative: bool,
+    # others
+    others_extinct: bool,
+    others_internal_error: bool,
+    others_eigenvalue_spectrum_index: bool,
+    # drawing options
+    draw_branch_empirical: bool,
+    draw_branch_alternative: bool,
+    draw_lines: bool,
+    draw_points: bool,
+    # eigenvalue spectrum
+    _eigenvalue_spectrum_index_empirical: float,
+    _eigenvalue_spectrum_index_alternative: float,
+    # eigenvalue spectrum (centering)
+    eigenvalue_spectrum_centered_empirical: bool,
+    eigenvalue_spectrum_centered_alternative: bool,
+):
+    # update drawing config
+    glob.config.drawing_options.update_flags(
+        equilibria_area,
+        equilibria_stable,
+        equilibria_unstable,
+        equilibria_over_information,
+        bifurcations_saddlenode_empirical,
+        bifurcations_saddlenode_alternative,
+        bifurcations_transcritical_empirical,
+        bifurcations_transcritical_alternative,
+        bifurcations_hopf_empirical,
+        bifurcations_envelope_empirical,
+        bifurcations_hopf_alternative,
+        bifurcations_envelope_alternative,
+        others_extinct,
+        others_internal_error,
+        others_eigenvalue_spectrum_index,
+        draw_branch_empirical,
+        draw_branch_alternative,
+        draw_lines,
+        draw_points,
+        eigenvalue_spectrum_centered_empirical,
+        eigenvalue_spectrum_centered_alternative,
+    )
+    # update both bifurcation diagrams
+    glob.figures.bifurcation_diagram_first = update_bifurcation_diagram(
+        glob.figures.bifurcation_diagram_first, PlotTypes.FIRST
+    )
+    glob.figures.bifurcation_diagram_second = update_bifurcation_diagram(
+        glob.figures.bifurcation_diagram_second, PlotTypes.SECOND
+    )
+    # update both bifurcation diagrams
+    glob.figures.eigenvalue_spectrum_empirical = update_eigenvalue_spectrum(
+        glob.figures.eigenvalue_spectrum_empirical, BranchTypes.EMPIRICAL
+    )
+    glob.figures.eigenvalue_spectrum_alternative = update_eigenvalue_spectrum(
+        glob.figures.eigenvalue_spectrum_alternative, BranchTypes.ALTERNATIVE
+    )
+    # return both figure and the empty error message
+    return (
+        update_ternary_data(),
+        glob.figures.bifurcation_diagram_first,
+        glob.figures.bifurcation_diagram_second,
+        glob.figures.eigenvalue_spectrum_empirical,
+        glob.figures.eigenvalue_spectrum_alternative,
+        "",
+    )

bifurcation_explorer-0.1.0/src/bifurcation_explorer/common/config.py

@@ -0,0 +1,130 @@
+import os
+
+from bifurcation_explorer.common.drawing_options import DrawingOptions
+from bifurcation_explorer.common.exceptions import ParameterTypeError
+from bifurcation_explorer.enums.types.branch_types import BranchTypes
+from bifurcation_explorer.enums.network_data import NetworkData
+from bifurcation_explorer.enums.types.parameter_types import ParameterTypes
+from bifurcation_explorer.enums.resolutions import Resolutions
+
+
+# config file
+class Config:
+
+    def __init__(self):
+        # main folder
+        self.main_folder = "."
+        # current dynamic options
+        self.network: str = None
+        self.resolution: Resolutions = int(Resolutions.DEFAULT)
+        self.compartment_first_index: int = 0
+        self.compartment_first: str = None
+        self.compartment_second_index: int = 1
+        self.compartment_second: str = None
+        self.fixed_parameter_type: ParameterTypes = ParameterTypes.LOTKAVOLTERRA
+        self.dynamic_paramameter_type: ParameterTypes = ParameterTypes.RECIPIENT
+        self.fixed_parameter_value: float = 0.4
+        self.fixed_parameter_value_str: str = f"{self.fixed_parameter_value:.5f}"
+        # eigenValues spectrum options
+        self.eigenvalue_spectrum_index: dict[BranchTypes, int] = {}
+        for branch_type in BranchTypes:
+            self.eigenvalue_spectrum_index[branch_type] = 0
+        # drawing options
+        self.drawing_options: DrawingOptions = DrawingOptions()
+
+    def get_current_compartments(self):
+        """Return the list of current compartments for the selected network."""
+        if self.network is not None:
+            return NetworkData.VALUES[self.network]
+        # return empty list
+        return []
+
+    def get_pseudoarc_result_folder_data(self):
+        """Return the path to the result pseudo-arc data folder."""
+        return "D:/OIST/foodweb-dynamics/matlab_pablo/branches/13-continuation-pseudoArc/results"
+
+    def get_envelope_result_folder_data(self):
+        """Return the path to the result envelope data folder."""
+        return "D:/OIST/foodweb-dynamics/matlab_pablo/branches/16-hopf-bifurcation-envelope/results"
+
+    def get_pickle_cache_folder(self):
+        """Return the path to the pickle cache folder."""
+        return os.path.join(self.main_folder, "cache")
+
+    def get_pickle_network_folder(self):
+        """Return the path to the pickle network folder."""
+        return os.path.join(self.get_pickle_cache_folder(), self.network)
+
+    def get_pickle_plot_data(self):
+        """Return the path to the bifurcations pickle file."""
+        return os.path.join(self.get_pickle_network_folder(), "plot_data.pkl")
+
+    def get_continuation_zip_file(self, fixed_parameter_value_str: str):
+        """Return the path to the continuation zip file."""
+        return os.path.join(self.get_pseudoarc_result_folder_data(), self.network, fixed_parameter_value_str + ".zip")
+
+    def get_envelope_zip_file(self, fixed_parameter_value_str: str):
+        """Return the path to the envelope zip file."""
+        return os.path.join(self.get_envelope_result_folder_data(), self.network, fixed_parameter_value_str + ".zip")
+
+    def get_pickle_branch_file(self, fixed_parameter_value: str):
+        """Return the path to the branch pickle file."""
+        return os.path.join(self.get_pickle_network_folder(), fixed_parameter_value + ".pkl")
+
+    def update_network(self, network: str):
+        """Update the current network and adjust compartment indices if necessary."""
+        self.network = network
+        # adjust compartments
+        num_compartments: int = len(self.get_current_compartments())
+        if self.compartment_first_index >= num_compartments:
+            self.compartment_first_index = 0
+        if self.compartment_second_index >= num_compartments:
+            self.compartment_second_index = 0
+
+    def update_fixed_parameter_type(self, fixed_parameter_type: ParameterTypes):
+        """Update the type of the fixed parameter."""
+        self.fixed_parameter_type = fixed_parameter_type
+        # set dynamic parameter
+        if self.fixed_parameter_type == ParameterTypes.DONOR:
+            self.dynamic_paramameter_type = ParameterTypes.LOTKAVOLTERRA
+        elif self.fixed_parameter_type == ParameterTypes.RECIPIENT:
+            self.dynamic_paramameter_type = ParameterTypes.DONOR
+        elif self.fixed_parameter_type == ParameterTypes.LOTKAVOLTERRA:
+            self.dynamic_paramameter_type = ParameterTypes.RECIPIENT
+        else:
+            raise ParameterTypeError("invalid parameter")
+
+    def update_fixed_parameter_value(self, fixed_parameter_value: float):
+        """Update the value of the fixed parameter and its string representation."""
+        self.fixed_parameter_value = fixed_parameter_value
+        self.fixed_parameter_value_str = f"{fixed_parameter_value:.5f}"
+        # return new value
+        return self.fixed_parameter_value
+
+    def update_eigenvalue_spectrum_index(
+        self, eigenvalue_spectrum_index: int, branch_type: BranchTypes
+    ):
+        """Update the eigenvalue spectrum index for a given branch type."""
+        self.eigenvalue_spectrum_index[branch_type] = eigenvalue_spectrum_index
+
+    def update_comparment_first(self, compartment_first: str):
+        """Update first compartment to the specified value if it exists, otherwise set to the first compartment."""
+        compartments: list[str] = self.get_current_compartments()
+        # continue depending if value exist in the current compartments
+        if compartment_first in compartments:
+            self.compartment_first = compartment_first
+            self.compartment_first_index = compartments.index(compartment_first)
+        else:
+            self.compartment_first = compartments[0]
+            self.compartment_first_index = 0
+
+    def update_comparment_second(self, compartment_second: str):
+        """Update second compartment to the specified value if it exists, otherwise set to the second compartment."""
+        compartments: list[str] = self.get_current_compartments()
+        # continue depending if value exist in the current compartments
+        if compartment_second in compartments:
+            self.compartment_second = compartment_second
+            self.compartment_second_index = compartments.index(compartment_second)
+        else:
+            self.compartment_second = compartments[1]
+            self.compartment_second_index = 1