simpest 0.0.1__py2.py3-none-any.whl

simpest/__init__.py

@@ -0,0 +1,5 @@
+"""Top-level package for simpest."""
+
+__author__ = """Kazi Rahaman"""
+__email__ = "kazijahidur.rahaman@zalf.de"
+__version__ = "0.0.1"

simpest/common.py

@@ -0,0 +1,7 @@
+"""The common module contains common functions and classes used by the other modules.
+"""
+
+def hello_world():
+    """Prints "Hello World!" to the console.
+    """
+    print("Hello World!")

simpest/models/__init__.py

@@ -0,0 +1,10 @@
+"""Model modules for SIMPLACE and FraNchEstYN workflows."""
+
+from .franchestyn import FranchestynConfig, run_franchestyn
+from .simplace import SimplaceConfig
+
+__all__ = [
+    "SimplaceConfig",
+    "FranchestynConfig",
+    "run_franchestyn",
+]

simpest/models/franchestyn.py

@@ -0,0 +1,281 @@
+import csv
+import importlib.util
+from dataclasses import dataclass
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from franchestyn.optimizer import FranchestynOptimizer
+from franchestyn.runner import FranchestynRunner
+
+
+def _resolve_default_reference() -> str:
+    """Resolve a local default reference CSV using repository files only."""
+    repo_root = Path(__file__).resolve().parents[2]
+    candidates = [
+        repo_root
+        / "franchestyn"
+        / "src_csharp"
+        / "FraNchEstYN"
+        / "FraNchEstYN"
+        / "files"
+        / "reference"
+        / "Indiana.csv",
+        repo_root
+        / "franchestyn"
+        / "src_csharp"
+        / "FraNchEstYN"
+        / "FraNchEstYN"
+        / "bin"
+        / "Debug"
+        / "net8.0"
+        / "files"
+        / "reference"
+        / "Indiana.csv",
+    ]
+
+    for path in candidates:
+        if path.exists():
+            return str(path)
+
+    # Fall back to a repository-local canonical path if files are not present yet.
+    return str(candidates[0])
+
+
+def _resolve_franchestyn_param_file() -> str:
+    pkg = Path(importlib.util.find_spec("franchestyn").origin).parent
+    return str(pkg / "parameters_by_crop.json")
+
+
+@dataclass(frozen=True)
+class FranchestynConfig:
+    param_file: str = _resolve_franchestyn_param_file()
+    reference_path: str = _resolve_default_reference()
+    crop_type: str = "wheat"
+    disease_type: str = "septoria"
+    fungicide_type: str | None = "protectant"
+    site: str = "indiana"
+    variety: str = "Generic"
+    disease: str = "thisDisease"
+    is_calibration: bool = True
+    calibration_variable: str = "all"
+    use_gdd: bool = True
+    n_restarts: int = 1
+    max_iter: int = 100
+
+
+def _outputs_to_records(date_outputs):
+    records = []
+    for dt, out in sorted(date_outputs.items()):
+        records.append(
+            {
+                "Date": dt.strftime("%d/%m/%Y"),
+                "DaysAfterSowing": out.crop.day_after_sowing,
+                "GrowingDegreeDays": out.crop.growing_degree_days,
+                "CycleCompletionPercentage": out.crop.cycle_completion_percentage,
+                "LightInterception": out.crop.light_interception_attainable,
+                "LightIntHealthy": out.crop.light_interception_actual,
+                "AGBattainable": out.crop.agb_attainable,
+                "AGBactual": out.crop.agb_actual,
+                "YieldAttainable": out.crop.yield_attainable,
+                "YieldActual": out.crop.yield_actual,
+                "HTtimeRinoculum": out.disease.hydro_thermal_time_rate,
+                "HTtimeSinoculum": out.disease.hydro_thermal_time_state,
+                "Susceptible": out.disease.susceptible_fraction,
+                "Latent": out.disease.latent_sum,
+                "Sporulating": out.disease.sporulating_sum,
+                "Affected": out.disease.affected_sum,
+                "Dead": out.disease.dead_sum,
+                "DiseaseSeverity": out.disease.disease_severity,
+                "FungicideEfficacy": out.fungicide.efficacy,
+                "Tmax": out.inputs_daily.tmax if out.inputs_daily else None,
+                "Tmin": out.inputs_daily.tmin if out.inputs_daily else None,
+                "RHx": out.inputs_daily.rhx if out.inputs_daily else None,
+                "RHn": out.inputs_daily.rhn if out.inputs_daily else None,
+                "TotalPrec": out.inputs_daily.precipitation if out.inputs_daily else None,
+                "TotalRad": out.inputs_daily.rad if out.inputs_daily else None,
+                "TotalLW": out.inputs_daily.leaf_wetness if out.inputs_daily else None,
+            }
+        )
+    return records
+
+
+def run_franchestyn(
+    weather_path: str,
+    management_path: str,
+    start_year: int,
+    end_year: int,
+    config: FranchestynConfig,
+    cropmodel_path: str | None = None,
+    crop_param_file: str | None = None,
+    disease_param_file: str | None = None,
+    fungicide_param_file: str | None = None,
+) -> dict:
+    runner = FranchestynRunner(
+        weather_dir=weather_path,
+        param_file=config.param_file,
+        sowing_file=management_path,
+        ref_dir=config.reference_path,
+        crop_model_dir=cropmodel_path,
+        site=config.site,
+        variety=config.variety,
+        disease=config.disease,
+        start_year=start_year,
+        end_year=end_year,
+        weather_time_step="daily",
+        calibration_variable=config.calibration_variable,
+        is_calibration=config.is_calibration,
+        use_gdd=config.use_gdd,
+        crop_type=config.crop_type,
+        crop_param_file=crop_param_file,
+        disease_param_file=disease_param_file,
+        disease_type=config.disease_type,
+        fungicide_param_file=fungicide_param_file,
+        fungicide_type=config.fungicide_type,
+    )
+
+    best_params = {}
+    if config.is_calibration:
+        optimizer = FranchestynOptimizer(
+            runner=runner,
+            calibration_variable=config.calibration_variable,
+            n_restarts=config.n_restarts,
+            max_iter=config.max_iter,
+        )
+        best_params = optimizer.calibrate()
+        date_outputs = runner.run(param_values=best_params)
+    else:
+        date_outputs = runner.run()
+
+    include_crop = config.calibration_variable in ("crop", "all")
+    include_disease = config.calibration_variable in ("disease", "all")
+    rmse = runner.compute_rmse(
+        date_outputs,
+        include_crop=include_crop,
+        include_disease=include_disease,
+    )
+
+    records = _outputs_to_records(date_outputs)
+    return {
+        "outputs": {
+            "simulation": records,
+            "summary": {
+                "rmse": rmse,
+                "is_calibration": config.is_calibration,
+                "calibration_variable": config.calibration_variable,
+                "best_params": best_params,
+            },
+        }
+    }
+
+
+def save_simulation_results_csv(res_ot_simulation, output_root: Path, filename: str = "franchestyn_simulation_results.csv") -> Path:
+    output_file = output_root / "SimulationExperimentTemplate" / filename
+    df = pd.DataFrame(res_ot_simulation)
+    df.to_csv(output_file, index=False)
+    return output_file
+
+
+def build_season_summary(df: pd.DataFrame, site: str, variety: str) -> pd.DataFrame:
+    if df.empty:
+        return pd.DataFrame()
+
+    d = df.copy()
+    d["Date"] = pd.to_datetime(d["Date"], dayfirst=True, errors="coerce")
+    d = d.dropna(subset=["Date"])
+
+    if "DaysAfterSowing" in d.columns:
+        d = d[d["DaysAfterSowing"] > 0]
+    if d.empty:
+        return pd.DataFrame()
+
+    if "GrowingSeason" not in d.columns:
+        d["GrowingSeason"] = d["Date"].dt.year
+
+    rows = []
+    for season, g in d.groupby("GrowingSeason"):
+        g = g.sort_values("Date")
+
+        y = g["DiseaseSeverity"].fillna(0.0).to_numpy(dtype=float) * 100.0
+        x = g["Date"].map(pd.Timestamp.toordinal).to_numpy(dtype=float)
+        audpc = float(np.trapezoid(y, x)) if len(g) >= 2 else 0.0
+
+        yield_att = float(g["YieldAttainable"].max()) if "YieldAttainable" in g.columns else 0.0
+        yield_act = float(g["YieldActual"].max()) if "YieldActual" in g.columns else 0.0
+        agb_att = float(g["AGBattainable"].max()) if "AGBattainable" in g.columns else 0.0
+        agb_act = float(g["AGBactual"].max()) if "AGBactual" in g.columns else 0.0
+        dis_sev = float(g["DiseaseSeverity"].max()) if "DiseaseSeverity" in g.columns else 0.0
+
+        loss_raw = yield_att - yield_act
+        loss_perc = (loss_raw / yield_att * 100.0) if yield_att > 0 else 0.0
+
+        row = {
+            "GrowingSeason": int(season),
+            "Site": site,
+            "Variety": variety,
+            "AUDPC": audpc,
+            "DiseaseSeverity": dis_sev,
+            "YieldAttainable": yield_att,
+            "YieldActual": yield_act,
+            "YieldLossRaw": loss_raw,
+            "YieldLossPerc": loss_perc,
+            "AGBattainable": agb_att,
+            "AGBactual": agb_act,
+        }
+
+        if "Tmax" in g.columns:
+            row["AveTx"] = float(g["Tmax"].mean())
+        if "Tmin" in g.columns:
+            row["AveTn"] = float(g["Tmin"].mean())
+        if "RHx" in g.columns:
+            row["AveRHx"] = float(g["RHx"].mean())
+        if "RHn" in g.columns:
+            row["AveRHn"] = float(g["RHn"].mean())
+        if "TotalPrec" in g.columns:
+            row["TotalPrec"] = float(g["TotalPrec"].sum())
+        if "TotalRad" in g.columns:
+            row["TotalRad"] = float(g["TotalRad"].sum())
+        if "TotalLW" in g.columns:
+            row["TotalLW"] = float(g["TotalLW"].sum())
+
+        rows.append(row)
+
+    return pd.DataFrame(rows).sort_values("GrowingSeason").reset_index(drop=True)
+
+
+def save_season_summary_csv(summary_df: pd.DataFrame, output_root: Path, filename: str = "franchestyn_season_summary.csv") -> Path | None:
+    if summary_df.empty:
+        return None
+
+    output_file = output_root / "SimulationExperimentTemplate" / filename
+    summary_df.to_csv(output_file, index=False)
+    return output_file
+
+
+def save_calibrated_parameters_csv(
+    best_params: dict,
+    output_root: Path,
+    site: str,
+    variety: str,
+    filename: str | None = None,
+) -> Path | None:
+    if not best_params:
+        return None
+
+    out_dir = output_root / "SimulationExperimentTemplate" / "calibratedParameters"
+    out_dir.mkdir(parents=True, exist_ok=True)
+    if filename is None:
+        filename = f"calibratedParameters_{site}_{variety}.csv"
+    output_file = out_dir / filename
+
+    with output_file.open("w", newline="", encoding="utf-8") as f_out:
+        writer = csv.DictWriter(f_out, fieldnames=["model", "param", "value"], delimiter=",")
+        writer.writeheader()
+        for key, value in sorted(best_params.items()):
+            if "_" in key:
+                model, param = key.split("_", 1)
+            else:
+                model, param = "", key
+            writer.writerow({"model": model, "param": param, "value": value})
+
+    return output_file

simpest/models/simplace.py

@@ -0,0 +1,213 @@
+import csv
+import math
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+
+import jpype
+import pandas as pd
+import simplace
+
+
+_SIMPLACE_INSTANCE = None
+
+
+@dataclass(frozen=True)
+class SimplaceConfig:
+    install_dir: str = "C:/ParamVC/Research/simplace+/simplace_portable/workspace/"
+    work_dir: str = "C:/ParamVC/Research/simplace+/simplace_portable/workspace/simplace_run/simulation/"
+    output_dir: str = "C:/ParamVC/Research/simplace+/simplace_out/"
+    solution_path: str = "SimulationExperimentTemplate/solution/Lintul5_indiana.sol.xml"
+    project_path: str = "SimulationExperimentTemplate/project/Lintul5All_indiana.proj.xml"
+
+
+def init_simplace(config: SimplaceConfig):
+    global _SIMPLACE_INSTANCE
+
+    if _SIMPLACE_INSTANCE is not None and jpype.isJVMStarted():
+        return _SIMPLACE_INSTANCE
+
+    if jpype.isJVMStarted():
+        Wrapper = jpype.JClass('net.simplace.sim.wrapper.SimplaceWrapper')
+        _SIMPLACE_INSTANCE = Wrapper(config.work_dir, config.output_dir, None, None)
+        return _SIMPLACE_INSTANCE
+
+    _SIMPLACE_INSTANCE = simplace.initSimplace(
+        installDir=config.install_dir,
+        workDir=config.work_dir,
+        outputDir=config.output_dir,
+    )
+    return _SIMPLACE_INSTANCE
+
+
+def run_simplace(shell, config: SimplaceConfig, project_lines: list[int]):
+    simplace.openProject(shell, config.solution_path, config.project_path)
+    simplace.setProjectLines(shell, project_lines)
+    simplace.runProject(shell)
+
+
+def get_project_row(work_root: Path, selected_line: int) -> dict:
+    project_csv = (
+        work_root
+        / "SimulationExperimentTemplate"
+        / "data"
+        / "projectdata"
+        / "lintul5all_indiana.csv"
+    )
+    with project_csv.open(newline="", encoding="utf-8") as f_proj:
+        proj_reader = csv.reader(f_proj, delimiter=";")
+        _ = next(proj_reader, None)
+        project_rows = list(proj_reader)
+
+    row = project_rows[selected_line - 1]
+    return {
+        "projectid": row[0],
+        "simulationid": row[1],
+        "startdate": row[2],
+        "enddate": row[3],
+        "location": row[4],
+        "iopt": row[5],
+        "idem": int(row[6]),
+        "irri": row[7],
+    }
+
+
+def export_crop_model_data(output_root: Path, project_row: dict) -> Path:
+    src = output_root / "SimulationExperimentTemplate" / f"{project_row['location']}{project_row['iopt']}_daily.csv"
+    dst = output_root / "SimulationExperimentTemplate" / "cropModel_data.csv"
+
+    with src.open(newline="", encoding="utf-8") as f_in, dst.open("w", newline="", encoding="utf-8") as f_out:
+        reader = csv.DictReader(f_in, delimiter=";")
+        writer = csv.DictWriter(
+            f_out,
+            fieldnames=["year", "doy", "agb", "yield", "fint", "lai", "gdd"],
+            delimiter=",",
+        )
+        writer.writeheader()
+
+        for row in reader:
+            if all(float(row[name]) == 0.0 for name in ("TAGB", "WSO", "FINT", "LAI")):
+                continue
+
+            d = datetime.strptime(row["CURRENT.DATE"], "%d.%m.%Y")
+            writer.writerow(
+                {
+                    "year": d.year,
+                    "doy": d.timetuple().tm_yday,
+                    "agb": float(row["TAGB"]) * 10,
+                    "yield": float(row["WSO"]) * 10,
+                    "fint": row["FINT"],
+                    "lai": row["LAI"],
+                    "gdd": row["TSUM"],
+                }
+            )
+    return dst
+
+
+def _saturation_vapor_pressure(t_celsius: float) -> float:
+    return 0.6108 * math.exp((17.27 * t_celsius) / (t_celsius + 237.3))
+
+
+def convert_weather(work_root: Path, output_root: Path, location: str) -> Path:
+    weather_src = work_root / "SimulationExperimentTemplate" / "data" / "weather" / f"{location}.txt"
+    weather_dst = output_root / "SimulationExperimentTemplate" / "weather_franchestyn.csv"
+
+    with weather_src.open(newline="", encoding="utf-8-sig") as f_in, weather_dst.open(
+        "w", newline="", encoding="utf-8"
+    ) as f_out:
+        reader = csv.DictReader(f_in, delimiter="\t")
+        reader.fieldnames = [h.lstrip("\ufeff").strip() for h in reader.fieldnames]
+
+        writer = csv.DictWriter(
+            f_out,
+            fieldnames=["site", "year", "month", "day", "tx", "tn", "p", "rad", "vp", "rhx", "rhn"],
+            delimiter=",",
+        )
+        writer.writeheader()
+
+        for row in reader:
+            d = datetime.strptime(row["CURRENTDAY"], "%d.%m.%Y")
+            tmax = float(row["Tmax"])
+            tmin = float(row["Tmin"])
+            vp = float(row["VapourPressure"])
+
+            es_tmax = _saturation_vapor_pressure(tmax)
+            es_tmin = _saturation_vapor_pressure(tmin)
+            rhx = min(100.0, max(0.0, 100.0 * vp / es_tmin)) if es_tmin > 0 else 0.0
+            rhn = min(100.0, max(0.0, 100.0 * vp / es_tmax)) if es_tmax > 0 else 0.0
+
+            writer.writerow(
+                {
+                    "site": location,
+                    "year": d.year,
+                    "month": d.month,
+                    "day": d.day,
+                    "tx": tmax,
+                    "tn": tmin,
+                    "p": row["Precipitation"],
+                    "rad": float(row["Irradiation"]) / 1000.0,
+                    "vp": vp,
+                    "rhx": rhx,
+                    "rhn": rhn,
+                }
+            )
+
+    return weather_dst
+
+
+def build_management(output_root: Path, project_row: dict, crop: str = "wheat", variety: str = "generic") -> Path:
+    start_date = datetime.strptime(project_row["startdate"], "%d.%m.%Y")
+    _ = start_date
+    sowing_doy = max(1, project_row["idem"] - 7)
+
+    management_dst = output_root / "SimulationExperimentTemplate" / "management_franchestyn.csv"
+    with management_dst.open("w", newline="", encoding="utf-8") as f_out:
+        writer = csv.DictWriter(
+            f_out,
+            fieldnames=["site", "crop", "variety", "year", "sowingDOY"],
+            delimiter=",",
+        )
+        writer.writeheader()
+        writer.writerow(
+            {
+                "site": project_row["location"],
+                "crop": crop,
+                "variety": variety,
+                "year": "All",
+                "sowingDOY": sowing_doy,
+            }
+        )
+
+    return management_dst
+
+
+def merge_simplace_and_franchestyn(
+    output_root: Path,
+    project_row: dict,
+    franchestyn_df: pd.DataFrame,
+    out_name: str = "merged_simulation_data.csv",
+) -> Path:
+    simplace_daily_path = output_root / "SimulationExperimentTemplate" / f"{project_row['location']}{project_row['iopt']}_daily.csv"
+    simplace_df = pd.read_csv(simplace_daily_path, sep=";")
+
+    simplace_df.columns = simplace_df.columns.str.strip()
+    franchestyn_df.columns = franchestyn_df.columns.str.strip()
+
+    simplace_df["date"] = pd.to_datetime(simplace_df["CURRENT.DATE"], format="%d.%m.%Y")
+    franchestyn_df["date"] = pd.to_datetime(franchestyn_df["Date"], dayfirst=True)
+
+    sim_df = simplace_df.rename(columns={c: f"{c}_S" for c in simplace_df.columns if c != "date"})
+    fran_df = franchestyn_df.rename(columns={c: f"{c}_F" for c in franchestyn_df.columns if c != "date"})
+
+    merged = pd.merge(sim_df, fran_df, on="date", how="left")
+    merged = merged.rename(
+        columns={
+            "WSO_S": "WSO_S_g_m2",
+            "YieldAttainable_F": "YieldAttainable_F_kg_ha",
+            "YieldActual_F": "YieldActual_F_kg_ha",
+        }
+    )
+
+    out_path = output_root / "SimulationExperimentTemplate" / out_name
+    merged.to_csv(out_path, index=False)
+    return out_path

simpest/pipeline.py

@@ -0,0 +1,104 @@
+from pathlib import Path
+
+import pandas as pd
+import simplace
+
+from .models.franchestyn import (
+    FranchestynConfig,
+    build_season_summary,
+    run_franchestyn,
+    save_calibrated_parameters_csv,
+    save_season_summary_csv,
+    save_simulation_results_csv,
+)
+from .models.simplace import (
+    SimplaceConfig,
+    build_management,
+    convert_weather,
+    export_crop_model_data,
+    get_project_row,
+    init_simplace,
+    merge_simplace_and_franchestyn,
+    run_simplace,
+)
+
+
+def run_pipeline(
+    simplace_config: SimplaceConfig,
+    franchestyn_config: FranchestynConfig,
+    project_lines: list[int],
+    shutdown_simplace: bool = False,
+) -> dict:
+    """Run the full SIMPLACE -> FraNchEstYN pipeline.
+
+    Parameters
+    ----------
+    shutdown_simplace : bool
+        If True, calls ``simplace.shutDown(shell)`` in ``finally``.
+        Keep this False in Jupyter to avoid possible kernel restarts when
+        the underlying JVM is terminated.
+    """
+    shell = init_simplace(simplace_config)
+    try:
+        run_simplace(shell, simplace_config, project_lines=project_lines)
+
+        dirs = simplace.getSimplaceDirectories(shell)
+        work_root = Path(dirs["_WORKDIR_"])
+        output_root = Path(dirs["_OUTPUTDIR_"])
+
+        selected_line = project_lines[0]
+        project_row = get_project_row(work_root, selected_line=selected_line)
+
+        crop_model_path = export_crop_model_data(output_root, project_row)
+        weather_path = convert_weather(work_root, output_root, project_row["location"])
+        management_path = build_management(output_root, project_row)
+
+        start_year = int(project_row["startdate"].split(".")[-1])
+        end_year = int(project_row["enddate"].split(".")[-1])
+
+        result = run_franchestyn(
+            weather_path=str(weather_path),
+            management_path=str(management_path),
+            cropmodel_path=str(crop_model_path),
+            start_year=start_year,
+            end_year=end_year,
+            config=franchestyn_config,
+        )
+
+        summary = result.get("outputs", {}).get("summary", {})
+        simulation = result.get("outputs", {}).get("simulation", [])
+
+        save_simulation_results_csv(simulation, output_root)
+
+        simulation_df = pd.DataFrame(simulation)
+        season_summary = build_season_summary(
+            simulation_df,
+            site=franchestyn_config.site,
+            variety=franchestyn_config.variety,
+        )
+        save_season_summary_csv(season_summary, output_root)
+
+        best_params = summary.get("best_params", {}) if isinstance(summary, dict) else {}
+        save_calibrated_parameters_csv(
+            best_params,
+            output_root,
+            site=franchestyn_config.site,
+            variety=franchestyn_config.variety,
+        )
+
+        merged_path = merge_simplace_and_franchestyn(output_root, project_row, simulation_df)
+
+        return {
+            "work_root": str(work_root),
+            "output_root": str(output_root),
+            "project_row": project_row,
+            "merged_csv": str(merged_path),
+            "result": result,
+            "simplace_shutdown": bool(shutdown_simplace),
+        }
+    finally:
+        if shutdown_simplace:
+            try:
+                simplace.shutDown(shell)
+            except Exception as exc:
+                print(f"Warning: SIMPLACE shutdown failed: {exc}")

simpest/plot.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+
+
+def plot_distribution_lines(
+    df: pd.DataFrame,
+    variables: Sequence[str],
+    *,
+    bins: int = 50,
+    figsize: tuple[float, float] = (12, 5),
+    title: str = "Distribution Line Plot",
+    xlabel: str = "Value",
+    ylabel: str = "Density",
+    ax=None,
+):
+    """Plot line-based distributions for a list of numeric variables.
+
+    This function draws one line per variable using histogram-bin centers,
+    so the output stays a line plot while still showing value distribution.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        Source table containing the variables.
+    variables : Sequence[str]
+        Column names to include in the distribution line plot.
+    bins : int, optional
+        Number of histogram bins used for each variable. Default is 50.
+    figsize : tuple[float, float], optional
+        Figure size used when creating a new figure.
+    title, xlabel, ylabel : str, optional
+        Plot labels.
+    ax : matplotlib.axes.Axes, optional
+        Existing axes to draw on. If None, a new figure/axes is created.
+
+    Returns
+    -------
+    tuple[matplotlib.figure.Figure, matplotlib.axes.Axes]
+        Figure and axes containing the plot.
+    """
+    if not variables:
+        raise ValueError("'variables' cannot be empty.")
+
+    missing = [col for col in variables if col not in df.columns]
+    if missing:
+        raise ValueError(f"Variables not found in DataFrame: {missing}")
+
+    created_fig = False
+    if ax is None:
+        fig, ax = plt.subplots(figsize=figsize)
+        created_fig = True
+    else:
+        fig = ax.figure
+
+    plotted = 0
+    for var in variables:
+        values = pd.to_numeric(df[var], errors="coerce").dropna().to_numpy(dtype=float)
+        if values.size == 0:
+            continue
+
+        hist, edges = np.histogram(values, bins=bins, density=True)
+        centers = (edges[:-1] + edges[1:]) / 2.0
+        ax.plot(centers, hist, linewidth=2, label=var)
+        plotted += 1
+
+    if plotted == 0:
+        raise ValueError("No numeric data available to plot for the selected variables.")
+
+    ax.set_title(title)
+    ax.set_xlabel(xlabel)
+    ax.set_ylabel(ylabel)
+    ax.grid(True, alpha=0.3)
+    ax.legend()
+
+    if created_fig:
+        fig.tight_layout()
+
+    return fig, ax
+
+
+def plot_timeseries_lines(
+    df: pd.DataFrame,
+    x: str,
+    variables: Sequence[str],
+    *,
+    figsize: tuple[float, float] = (14, 5),
+    title: str = "Time Series Plot",
+    xlabel: str = "Date",
+    ylabel: str = "Value",
+    ax=None,
+):
+    """Plot multiple variables as time-series lines against a date/time column."""
+    if x not in df.columns:
+        raise ValueError(f"x column '{x}' not found in DataFrame.")
+    if not variables:
+        raise ValueError("'variables' cannot be empty.")
+
+    missing = [col for col in variables if col not in df.columns]
+    if missing:
+        raise ValueError(f"Variables not found in DataFrame: {missing}")
+
+    created_fig = False
+    if ax is None:
+        fig, ax = plt.subplots(figsize=figsize)
+        created_fig = True
+    else:
+        fig = ax.figure
+
+    x_values = pd.to_datetime(df[x], errors="coerce")
+    plotted = 0
+    for var in variables:
+        y_values = pd.to_numeric(df[var], errors="coerce")
+        valid = x_values.notna() & y_values.notna()
+        if not valid.any():
+            continue
+        ax.plot(x_values[valid], y_values[valid], linewidth=1.2, label=var)
+        plotted += 1
+
+    if plotted == 0:
+        raise ValueError("No valid numeric time-series values available to plot.")
+
+    ax.set_title(title)
+    ax.set_xlabel(xlabel)
+    ax.set_ylabel(ylabel)
+    ax.grid(True, alpha=0.3)
+    ax.legend(ncol=2, fontsize=9)
+
+    if created_fig:
+        fig.tight_layout()
+
+    return fig, ax
+

simpest/simpest.py

@@ -0,0 +1 @@
+"""Main module."""

simpest-0.0.1.dist-info/METADATA

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: simpest
+Version: 0.0.1
+Summary: integrated crop growth modelling with pest and disease affect
+Author-email: Kazi Rahaman <kazijahidur.rahaman@zalf.de>
+License: MIT License
+Project-URL: Homepage, https://github.com/KaziJahidurRahaman/simpest
+Keywords: simpest
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: AUTHORS.rst
+Requires-Dist: numpy
+Provides-Extra: all
+Requires-Dist: simpest[extra]; extra == "all"
+Provides-Extra: extra
+Requires-Dist: pandas; extra == "extra"
+Dynamic: license-file
+
+# simpest
+
+
+[![image](https://img.shields.io/pypi/v/simpest.svg)](https://pypi.python.org/pypi/simpest)
+[![image](https://img.shields.io/conda/vn/conda-forge/simpest.svg)](https://anaconda.org/conda-forge/simpest)
+
+
+**integrated crop growth modelling with pest and disease affect**
+
+
+-   Free software: MIT License
+-   Documentation: https://KaziJahidurRahaman.github.io/simpest
+    
+
+## Features
+
+-   TODO

simpest-0.0.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+simpest/__init__.py,sha256=qOncQ2F-oR3_cMtklLIS9WyJc5s0sD0UdNvUq-kSI2w,134
+simpest/common.py,sha256=UkxoF8RazqaFu7o-ZH3HUoPu7oVGAAB3Ja02Zm6IW9I,189
+simpest/pipeline.py,sha256=ipTcsVdmpFUqDIGm0N9sYjCmjCJnkfnS7LsX7L173Io,3364
+simpest/plot.py,sha256=8uNhFz6c4uj7L56crxsPt3uy9dGSF4EJZxiaSrO5E8s,3885
+simpest/simpest.py,sha256=h0hwdogXGFqerm-5ZPeT-irPn91pCcQRjiHThXsRzEk,19
+simpest/models/__init__.py,sha256=ZEqB5wJ-AaD9frZ_vJAqWeaVxGjPbGxmEytOA7vTgwY,243
+simpest/models/franchestyn.py,sha256=aFa37pzzAxcr51i80OW75GpuWi47hV_yivI9cS0MHXI,9946
+simpest/models/simplace.py,sha256=jWc_0mL5zjvqRZieLQpxw0bdddIZmBatZMF5eQ-MCs4,7563
+simpest-0.0.1.dist-info/licenses/AUTHORS.rst,sha256=_FR4-DPaw9K6vKgBvHSzxqkCLhS75qCN8SNfET2Mn3M,165
+simpest-0.0.1.dist-info/licenses/LICENSE,sha256=PW54hdSF4p4OYx3GQ9cFEQaa5Eowv4ETM3_1SE0Lqw8,1071
+simpest-0.0.1.dist-info/METADATA,sha256=23tDVJcGcsVu-shc3L9zTzsZ9LM3uN2LM9SFz6oxEm4,1365
+simpest-0.0.1.dist-info/WHEEL,sha256=TdQ5LtNwLuxTCjgxN51AgdU5w-KkB9ttmLbzjTH02pg,109
+simpest-0.0.1.dist-info/entry_points.txt,sha256=bi_iC_exixFRaJreyMKpmbx3ielc9KJnzjdIbjv1FdE,45
+simpest-0.0.1.dist-info/top_level.txt,sha256=CaomRknVGLDQbLQ35PQERc4eHlpZ9cLzv9-uE-6HA7w,8
+simpest-0.0.1.dist-info/RECORD,,

simpest-0.0.1.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+

simpest-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+simpest = simpest.cli:main

simpest-0.0.1.dist-info/licenses/AUTHORS.rst

@@ -0,0 +1,13 @@
+=======
+Credits
+=======
+
+Development Lead
+----------------
+
+* Kazi Rahaman <kazijahidur.rahaman@zalf.de>
+
+Contributors
+------------
+
+None yet. Why not be the first?

simpest-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026, Kazi Rahaman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

simpest-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+simpest