geoloop 0.0.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

geoloop/axisym/__init__.py

@@ -0,0 +1,3 @@
+"""
+This package contains a module with a class for simulation of a 3D Grid.
+"""

geoloop/bin/Flowdatamain.py

@@ -0,0 +1,89 @@
+import sys
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+from geoloop.configuration import FlowDataConfig, load_single_config
+from geoloop.loadflowdata.flow_data import FlowData
+
+
+def main_flow_data(config_path: str | Path):
+    """
+    Command-line entry point to calculate, plot and optionally save a time-profile of flow rate.
+
+    Parameters
+    ----------
+    config_path : str or Path
+        Path to a JSON config file.
+
+    Notes
+    -----
+    This function:
+      • Loads a FlowData configuration file
+      • Builds a FlowData instance
+      • Computes 1 year of hourly flow data
+      • Plots instantaneous and cumulative flow
+      • Saves the plot in the configured output directory
+    """
+
+    # 1. Load configuration
+    config_dict = load_single_config(config_path)
+    config = FlowDataConfig(**config_dict)
+
+    flow = FlowData.from_config(config)
+
+    # 2. Simulation time setup (1 hour step)
+    dt = 3600.0  # seconds
+    tmax = 8760.0 * 3600  # one year in seconds
+    Nt = int(np.ceil(tmax / dt))
+
+    time = dt * np.arange(1, Nt + 1)
+    hours = time / 3600
+
+    # Compute flow data
+    Q_flow = flow.getflow(hours)
+
+    # 3. Plotting
+    fig, (ax1, ax2) = plt.subplots(2, figsize=(9, 9))
+
+    # Instantaneous flow
+    ax1.set_xlabel(r"$t$ [hours]")
+    ax1.set_ylabel(r"$\dot{m}$ [kg/s]")
+    ax1.plot(hours, Q_flow)
+    ax1.set_title("Instantaneous Flow Rate")
+
+    # Cumulative flow (kg)
+    Qcum = np.cumsum(Q_flow) * dt  # dt is seconds → sum(kg/s * s) = kg
+    ax2.set_xlabel(r"$t$ [hours]")
+    ax2.set_ylabel(r"Cumulative flow [kg]")
+    ax2.plot(hours, Qcum)
+    ax2.set_title("Cumulative Flow")
+
+    plt.tight_layout()
+
+    # 4. Save figure
+    plot_dir = Path(config.fp_outdir)
+
+    if config.fp_type == "FROMFILE":
+        if config.fp_smoothing is not None:
+            fig_name = f"{config.fp_filename[:-4]}_{config.fp_smoothing}_flow"
+        else:
+            fig_name = f"{config.fp_filename[:-4]}_flow"
+    else:
+        fig_name = f"{config.fp_type}_flow_profile"
+
+    fig_path = plot_dir / fig_name
+    plt.savefig(fig_path)
+
+    # 5. Print summary
+    print("Flow profile summary:")
+    print("---------------------")
+    print("Mean flow rate [kg/s]:", np.mean(Q_flow))
+    print("Min flow rate  [kg/s]:", np.min(Q_flow))
+    print("Max flow rate  [kg/s]:", np.max(Q_flow))
+    print("Total cumulative flow [kg]:", Qcum[-1])
+
+
+if __name__ == "__main__":
+    main_flow_data(sys.argv[1])

geoloop/bin/Lithologymain.py

@@ -0,0 +1,84 @@
+from pathlib import Path
+
+import numpy as np
+import xarray as xr
+
+from geoloop.configuration import LithologyConfig, load_single_config
+from geoloop.geoloopcore.strat_interpolator import StratInterpolator
+from geoloop.lithology.plot_lithology import plot_lithology_and_thermcon
+from geoloop.lithology.process_lithology import ProcessLithologyToThermalConductivity
+
+
+def main_lithology(config_path: str | Path) -> None:
+    """
+    Command-line entry point to calculate and optionally save lithology to thermal conductivity
+    conversions and produce and save plots.
+
+    Parameters
+    ----------
+    config_path : str
+        Path to a JSON configuration file.
+
+    Notes
+    -----
+    Expected JSON configuration fields (minimum):
+    ``litho_k_param``
+        Defines parameter distributions for stochastic evaluation.
+
+    Returns
+    -------
+    None
+    """
+    config_dict = load_single_config(config_path)
+    config = LithologyConfig(**config_dict)  # validated Pydantic object
+
+    # initiate object for lithology_to_k simulation and create (stochastic) thermcon-depth profiles
+    lithology_to_k = ProcessLithologyToThermalConductivity.from_config(config)
+    if lithology_to_k.read_from_table:
+        pass
+    else:
+        lithology_to_k.create_multi_thermcon_profiles()
+        lithology_to_k.save_thermcon_sample_profiles()
+
+    # Create plots
+    # load in the h5 dataset again for convenient plotting
+    lithology_h5path = lithology_to_k.out_dir / lithology_to_k.out_table
+
+    lithology_k_ds = xr.open_dataset(
+        lithology_h5path, group="litho_k", engine="h5netcdf"
+    )
+    # select only basecase
+    lithology_k_base_case = lithology_k_ds.sel(n_samples=0)
+
+    z = lithology_k_base_case.depth.values
+    zval = lithology_k_base_case.kh_bulk.values
+
+    zend = z
+    zstart = z[:-1] * 1
+
+    # Append 0 at the beginning of zstart
+    zstart = np.insert(zstart, 0, 0)
+
+    # Interpolate basecase thermal conductivity values
+    interp_obj = StratInterpolator(zend, zval)
+    kh_bulk_plotting_base_case = interp_obj.interp_plot(zstart, zend)
+
+    # Extract max and min thermal conductivity profiles and interpolate
+    kh_bulk_max = lithology_k_ds.kh_bulk.max(dim="n_samples").values
+    interp_obj.zval = kh_bulk_max
+    kh_bulk_plotting_max = interp_obj.interp_plot(zstart, zend)
+
+    kh_bulk_min = lithology_k_ds.kh_bulk.min(dim="n_samples").values
+    interp_obj.zval = kh_bulk_min
+    kh_bulk_plotting_min = interp_obj.interp_plot(zstart, zend)
+
+    # Create the layer cake plot
+    plot_lithology_and_thermcon(
+        lithology_k_base_case,
+        kh_bulk_plotting_base_case,
+        interp_obj,
+        kh_bulk_plotting_max,
+        kh_bulk_plotting_min,
+        lithology_h5path,
+        lithology_to_k.out_dir,
+    )

geoloop/bin/Loadprofilemain.py

@@ -0,0 +1,100 @@
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+from geoloop.configuration import LoadProfileConfig, load_single_config
+from geoloop.loadflowdata.loadprofile import LoadProfile
+
+
+def main_load_profile(config_path: str | Path):
+    """
+    Command-line entry point to calculate, plot and optionally save a time-profile of heat load.
+
+    Parameters
+    ----------
+    config_path : str or Path
+        The path to a JSON configuration file.
+
+    Notes
+    -----
+    The function:
+      • loads a configuration file
+      • builds a LoadProfile instance
+      • computes 1 year of hourly load data
+      • plots instantaneous and cumulative energy
+      • writes the plot to the configured output directory
+    """
+    # Parse the configuration file and combine with standard configuration
+    config_dict = load_single_config(config_path)
+    config = LoadProfileConfig(**config_dict)  # validated Pydantic object
+
+    loadprof = LoadProfile.from_config(config)
+
+    # Simulation parameters
+    dt = 3600.0  # Time step (s)
+    tmax = 1.0 * 8760.0 * 3600.0  # Maximum time (s)
+    Nt = int(np.ceil(tmax / dt))  # Number of time steps
+    time = dt * np.arange(1, Nt + 1)
+
+    # Load function expects hours
+    Q = loadprof.getload(time / 3600)
+
+    # plot results
+    fig, (ax1, ax2) = plt.subplots(2, figsize=(9, 9))
+
+    # Instantaneous load
+    ax1.set_xlabel(r"$t$ [hours]")
+    ax1.set_ylabel(r"$Q_b$ [W]")
+    hours = np.arange(1, Nt + 1) * dt / 3600.0
+    ax1.plot(hours, Q)
+
+    # Cumulative energy
+    ax2.set_xlabel(r"$t$ [hours]")
+    ax2.set_ylabel(r"$Q_b$ [MWh]")
+
+    # Combined cumulative (heating + cooling)
+    Qcum_all = np.cumsum(Q) * (dt / 3600) * 1e-6
+    ax2.plot(hours, Qcum_all, label="Cumulative heating + cooling load")
+
+    # Heating only
+    Q_heating = Q * 1
+    Q_heating[Q_heating <= 0] = 0
+    Qcum_heating = np.cumsum(Q_heating) * (dt / 3600) * 1e-6
+    ax2.plot(hours, Qcum_heating, label="Cumulative heating load")
+
+    # Cooling only
+    Q_cooling = Q * 1
+    Q_cooling[Q_cooling > 0] = 0
+    Qcum_cooling = np.cumsum(Q_cooling) * (dt / 3600) * 1e-6
+    ax2.plot(hours, Qcum_cooling, label="Cumulative cooling load")
+
+    plt.legend()
+    plt.tight_layout()
+
+    # Save figure
+    plot_dir = config.lp_outdir
+    if config.lp_type == "FROMFILE":
+        if config.lp_smoothing is not None:
+            fig_name = f"{config.lp_filename[:-4]}_{config.lp_smoothing}_smoothing"
+        else:
+            fig_name = config.lp_filename[:-3]
+    else:
+        fig_name = f"{config.lp_type}_load_profile"
+
+    fig_path = plot_dir / fig_name
+    plt.savefig(fig_path)
+
+    # Print results summary
+    print(
+        "total energy consumed [MWh]:", np.sum(Q) * 1e-6
+    )  # total net energy demand in one year
+    print(
+        "total energy heating [MWh]:", np.sum(Q[Q > 0]) * 1e-6
+    )  # total heating demand in one year
+    print(
+        "total energy cooling [MWh]:", np.sum(Q[Q <= 0]) * 1e-6
+    )  # total cooling demand in one year
+    print(
+        "yearly average energy consumed [W]:", np.mean(Q)
+    )  # yearly average energy consumed

geoloop/bin/Plotmain.py

@@ -0,0 +1,250 @@
+import sys
+import time
+from pathlib import Path
+
+import pandas as pd
+
+from geoloop.bin.SingleRunSim import SingleRun
+from geoloop.configuration import (
+    LithologyConfig,
+    PlotInputConfig,
+    SingleRunConfig,
+    load_nested_config,
+    load_single_config,
+)
+from geoloop.lithology.process_lithology import ProcessLithologyToThermalConductivity
+from geoloop.plotting.create_plots import PlotResults
+from geoloop.plotting.load_data import DataSelection, DataTotal, PlotInput
+
+
+def main_plotmain(config_path: str | Path) -> None:
+    """
+    Main entry point for plotting BHE analysis.
+
+    This function loads simulation parameters and results, organizes them into
+    plot-ready data structures, and generates figures for multiple combinations
+    of deterministic and Monte-Carlo simulation types. Supports plotting either:
+
+    * Multiple **deterministic** (SR) runs, or
+    * Multiple **stochastic** (MC) runs
+
+    Mixed SR/MC plotting is not supported. Plotting more than two runs is possible
+    but not optimally formatted.
+
+    Parameters
+    ----------
+    config_path : str
+        Path to a JSON configuration file.
+
+    Returns
+    -------
+    None
+    """
+
+    start_time = time.time()
+
+    config_dict = load_single_config(config_path)
+    config = PlotInputConfig(**config_dict)  # validated Pydantic object
+
+    print("Processing results and visualizing...")
+
+    # Build data input object
+    plotinput = PlotInput.from_config(config)
+    plotinput.list_filenames()
+    param_ds, results_ds = plotinput.load_params_result_data()
+
+    temperature_field_da = None
+    if plotinput.plot_temperature_field:
+        temperature_field_da = plotinput.load_temperature_field_data()
+
+    datatotal = DataTotal(results_ds, param_ds, temperature_field_da)
+    dataselection = DataSelection.select_sub_datasets(plotinput, datatotal)
+
+    # NEW individual run plotting
+    if plotinput.newplot:
+        for i in range(len(plotinput.run_names)):
+            out_path = (
+                plotinput.base_dir / plotinput.run_names[i] / plotinput.file_names[i]
+            )
+
+            # -------- Single Run (SR) --------
+            if plotinput.run_modes[i] == "SR":
+                if plotinput.plot_time_depth:
+                    # Only create time and depth plots if the data is from a single run
+                    PlotResults.create_timeseriesplot(
+                        dataselection.timeplot_results_df[i],
+                        out_path,
+                        plotinput.plot_time_parameters,
+                    )
+                    PlotResults.create_depthplot(
+                        plotinput.plot_depth_parameters,
+                        plotinput.plot_times,
+                        dataselection.depthplot_params_ds[i],
+                        dataselection.depthplot_results_ds[i],
+                        out_path,
+                    )
+
+                    if config.plot_borehole_temp:
+                        run_name = plotinput.run_names[i]
+                        runjson = run_name + ".json"
+                        keysneeded = []
+                        keysoptional = [
+                            "litho_k_param",
+                            "loadprofile",
+                            "borefield",
+                            "variables_config",
+                            "flow_data",
+                        ]
+                        config_sim = load_nested_config(
+                            runjson, keysneeded, keysoptional
+                        )
+
+                        run_config = SingleRunConfig(**config_sim)
+
+                        run_config.lithology_to_k = None
+                        if run_config.litho_k_param:
+                            # in a single run always set the base case to True
+                            run_config.litho_k_param["basecase"] = True
+                            lithology_to_k = (
+                                ProcessLithologyToThermalConductivity.from_config(
+                                    LithologyConfig(**run_config.litho_k_param)
+                                )
+                            )
+                            lithology_to_k.create_multi_thermcon_profiles()
+                            run_config.lithology_to_k = lithology_to_k
+                        single_run = SingleRun.from_config(run_config)
+                        PlotResults.create_borehole_temp_plot(
+                            plotinput.plot_borehole_temp,
+                            plotinput.plot_times,
+                            dataselection.depthplot_params_ds[i],
+                            dataselection.depthplot_results_ds[i],
+                            single_run,
+                            out_path,
+                        )
+
+                # T-field movie & snapshots
+                if plotinput.plot_temperature_field:
+                    figure_folder = "Tfield_time"
+
+                    out_path = plotinput.base_dir / plotinput.run_names[i]
+
+                    # Create the figure folder if it doesn't exist
+                    figure_folder_path = out_path / figure_folder
+                    figure_folder_path.mkdir(parents=True, exist_ok=True)
+
+                    # Full path for the file
+                    out_path = figure_folder_path / plotinput.file_names[i]
+
+                    Tmin = datatotal.temperature_field_da[i].values.min()
+                    Tmax = datatotal.temperature_field_da[i].values.max()
+                    for j in range(len(datatotal.temperature_field_da[i].time)):
+                        PlotResults.plot_temperature_field(
+                            j, datatotal.temperature_field_da[i], Tmin, Tmax, out_path
+                        )
+                    in_path = figure_folder_path
+                    PlotResults.create_temperature_field_movie(in_path)
+
+            # -------- Monte-Carlo (MC) --------
+            elif plotinput.run_modes[i] == "MC":
+                if plotinput.plot_crossplot_barplot:
+                    # Only make scatter and bar plots is the simulation is a MC run
+                    # Make plots for target parameter vs the other results and params
+                    if plotinput.run_types[i] == "TIN":
+                        target = "Q_b"
+                    elif plotinput.run_types[i] == "POWER":
+                        target = "T_fi"
+                    else:
+                        target = None
+                        print("The run_type is not recognized")
+                    plotinput.crossplot_vars.append(target)
+
+                    for y_var_name in plotinput.crossplot_vars:
+                        PlotResults.create_scatterplots(
+                            dataselection.crossplot_results_df[i],
+                            dataselection.crossplot_params_df[i],
+                            y_var_name,
+                            out_path,
+                        )
+                        PlotResults.create_barplot(
+                            dataselection.crossplot_results_df[i],
+                            dataselection.crossplot_params_df[i],
+                            y_var_name,
+                            out_path,
+                        )
+
+            else:
+                print("Run_mode not recognized")
+                pass
+
+    # COMBINED multi-simulation plotting
+    elif not plotinput.newplot:
+        # below make sure that the figure name is shorter so that more than three simulations can be plotted together
+        combined_fig_folder = "combined_plots"
+        figure_name = "_".join([str(i) for i in plotinput.file_names])
+        subfolder = figure_name
+
+        # Build the full path
+        combined_path = plotinput.base_dir / combined_fig_folder / subfolder
+
+        # Create the folder if it doesn't exist
+        combined_path.mkdir(parents=True, exist_ok=True)
+
+        # Full output path for the figure
+        out_path = combined_path / figure_name
+
+        # Define runtype and create combined scatter and bar plots
+        for run_type in plotinput.run_types:
+            # Make plots for target parameter vs the other results and params
+            if run_type == "TIN":
+                target = "Q_b"
+            elif run_type == "POWER":
+                target = "T_fi"
+            else:
+                target = None
+                print("The run_type is not recognized")
+            plotinput.crossplot_vars.append(target)
+
+        # Only create time and depth plots if the data is from a single run
+        if (
+            all(mode == "SR" for mode in plotinput.run_modes)
+            and plotinput.plot_time_depth
+        ):
+            PlotResults.create_timeseriesplot(
+                dataselection.timeplot_results_df,
+                out_path,
+                plotinput.plot_time_parameters,
+            )
+            PlotResults.create_depthplot(
+                plotinput.plot_depth_parameters,
+                plotinput.plot_times,
+                dataselection.depthplot_params_ds,
+                dataselection.depthplot_results_ds,
+                out_path,
+            )
+
+        # Only make scatter and bar plots is the simulation is a MC run
+        elif (
+            all(mode == "MC" for mode in plotinput.run_modes)
+            and plotinput.plot_crossplot_barplot
+        ):
+            # Combine dataframes for crossplots per run_name
+            results_df = pd.concat(
+                dataselection.crossplot_results_df, ignore_index=True
+            )
+            param_df = pd.concat(dataselection.crossplot_params_df, ignore_index=True)
+
+            for y_var_name in plotinput.crossplot_vars:
+                PlotResults.create_scatterplots(
+                    results_df, param_df, y_var_name, out_path
+                )
+                PlotResults.create_barplot(results_df, param_df, y_var_name, out_path)
+
+        else:
+            print("Can not plot a single run and MC simulation together")
+
+    # Runtime log
+    print(f"Total runtime: {(time.time() - start_time) / 60.0:.2f} minutes")
+
+
+if __name__ == "__main__":
+    main_plotmain(sys.argv[1])

geoloop/bin/Runbatch.py

@@ -0,0 +1,81 @@
+import json
+import sys
+from pathlib import Path
+
+from geoloop.bin.Flowdatamain import main_flow_data
+from geoloop.bin.Lithologymain import main_lithology
+from geoloop.bin.Loadprofilemain import main_load_profile
+from geoloop.bin.Plotmain import main_plotmain
+from geoloop.bin.Runmain import main_runmain
+from geoloop.bin.SingleRunSim import main_single_run_sim
+
+command_dict = {
+    "SingleRunSim": main_single_run_sim,
+    "Runmain": main_runmain,
+    "Plotmain": main_plotmain,
+    "Loadprofile": main_load_profile,
+    "Lithology": main_lithology,
+    "FlowData": main_flow_data,
+}
+
+
+def run_batch_from_json(config_file: str) -> None:
+    """
+    Execute internal registered command functions defined in a JSON batch file.
+
+    Parameters
+    ----------
+    config_file : str
+        Path to a JSON file specifying commands to be executed.
+
+    Notes
+    -----
+    Expected JSON format::
+
+        {
+            "commands": [
+                {"command": "Plotmain", "args": ["config.json"]},
+                ...
+            ]
+        }
+
+    Raises
+    ------
+    ValueError
+        If an unknown command is encountered.
+
+    Returns
+    -------
+    None
+    """
+    with open(config_file) as file:
+        config_path = Path(config_file).resolve()
+        base_dir = config_path.parent  # directory of the batch file
+
+        config = json.load(file)
+
+    for command_spec in config["commands"]:
+        command = command_spec["command"]
+        args_json = Path(command_spec.get("args", []))
+
+        if args_json.is_absolute():
+            command_config_path = args_json
+        else:
+            command_config_path = base_dir / args_json
+
+        if command in command_dict:
+            print("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
+            print("Running command", command)
+            print("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
+            command_dict[command](command_config_path)
+        else:
+            raise ValueError(f"Command {command} not recognized")
+
+
+def main(args):
+    config_file = args[0]
+    run_batch_from_json(config_file)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

geoloop/bin/Runmain.py

@@ -0,0 +1,86 @@
+import sys
+import time
+from pathlib import Path
+
+from geoloop.configuration import (
+    LithologyConfig,
+    SingleRunConfig,
+    StochasticRunConfig,
+    load_nested_config,
+)
+from geoloop.lithology.process_lithology import ProcessLithologyToThermalConductivity
+from geoloop.utils.helpers import save_MCrun_results
+from geoloop.utils.RunManager import run_models
+
+
+def main_runmain(config_file_path: str | Path) -> None:
+    """
+    Run a **stochastic BHE analysis** and write results to disk.
+
+    This function loads a combined configuration, optionally generates
+    lithology-based thermal conductivity samples, executes stochastic BHE
+    model runs, and stores output files.
+
+    Parameters
+    ----------
+    config_file_path : str or Path
+        The path to a JSON configuration file.
+
+    Notes
+    -----
+    Expected JSON configuration fields (minimum):
+        `variables_config`
+            Defines parameter distributions for stochastic evaluation.
+
+    Returns
+    -------
+    None
+    """
+    start_time = time.time()
+
+    # Load configuration
+    keysneeded = ["variables_config"]
+    keysoptional = ["litho_k_param", "loadprofile", "borefield", "flow_data"]
+    config_dict = load_nested_config(config_file_path, keysneeded, keysoptional)
+
+    config = SingleRunConfig(**config_dict)
+    # load configuration for variable parameters
+    config.variables_config = StochasticRunConfig(**config.variables_config)
+
+    # Optional lithology-based thermal conductivity sample generation
+    config.lithology_to_k = None
+    if config.litho_k_param:
+        lithology_to_k = ProcessLithologyToThermalConductivity.from_config(
+            LithologyConfig(**config.litho_k_param)
+        )
+        lithology_to_k.create_multi_thermcon_profiles()
+        config.lithology_to_k = lithology_to_k
+
+    # Model execution
+    parameters, results = run_models(config)
+
+    print("Saving results and visualizing...")
+
+    # output directory setup
+    if config.run_name:
+        runfolder = config.run_name
+    else:
+        runfolder = Path(config_file_path).stem
+        config.run_name = runfolder
+
+    out_dir = (
+        config.base_dir / runfolder
+    )  # Check if the runfolder already exists, and create it if not
+    out_dir.mkdir(parents=True, exist_ok=True)  # creates all missing directories
+
+    basename = f"{runfolder}_{config.model_type[0]}_{config.run_type[0]}"
+    outpath = out_dir / basename
+
+    # Write results to disk
+    save_MCrun_results(config, parameters, results, outpath)
+
+    print(f"Total runtime: {(time.time() - start_time) / 60.0:.2f} minutes")
+
+
+if __name__ == "__main__":
+    main_runmain(sys.argv[1])