Upload 4 files

app.py

@@ -1,147 +1,203 @@
-import io
-import random
-from typing import List, Tuple
-
-import aiohttp
-import panel as pn
-from PIL import Image
-from transformers import CLIPModel, CLIPProcessor
-
-pn.extension(design="bootstrap", sizing_mode="stretch_width")
-
-ICON_URLS = {
-    "brand-github": "https://github.com/holoviz/panel",
-    "brand-twitter": "https://twitter.com/Panel_Org",
-    "brand-linkedin": "https://www.linkedin.com/company/panel-org",
-    "message-circle": "https://discourse.holoviz.org/",
-    "brand-discord": "https://discord.gg/AXRHnJU6sP",
-}
-
-
-async def random_url(_):
-    pet = random.choice(["cat", "dog"])
-    api_url = f"https://api.the{pet}api.com/v1/images/search"
-    async with aiohttp.ClientSession() as session:
-        async with session.get(api_url) as resp:
-            return (await resp.json())[0]["url"]
-
-
-@pn.cache
-def load_processor_model(
-    processor_name: str, model_name: str
-) -> Tuple[CLIPProcessor, CLIPModel]:
-    processor = CLIPProcessor.from_pretrained(processor_name)
-    model = CLIPModel.from_pretrained(model_name)
-    return processor, model
-
-
-async def open_image_url(image_url: str) -> Image:
-    async with aiohttp.ClientSession() as session:
-        async with session.get(image_url) as resp:
-            return Image.open(io.BytesIO(await resp.read()))
-
-
-def get_similarity_scores(class_items: List[str], image: Image) -> List[float]:
-    processor, model = load_processor_model(
-        "openai/clip-vit-base-patch32", "openai/clip-vit-base-patch32"
-    )
-    inputs = processor(
-        text=class_items,
-        images=[image],
-        return_tensors="pt",  # pytorch tensors
-    )
-    outputs = model(**inputs)
-    logits_per_image = outputs.logits_per_image
-    class_likelihoods = logits_per_image.softmax(dim=1).detach().numpy()
-    return class_likelihoods[0]
-
-
-async def process_inputs(class_names: List[str], image_url: str):
-    """
-    High level function that takes in the user inputs and returns the
-    classification results as panel objects.
-    """
-    try:
-        main.disabled = True
-        if not image_url:
-            yield "##### ⚠️ Provide an image URL"
-            return
-    
-        yield "##### ⚙ Fetching image and running model..."
-        try:
-            pil_img = await open_image_url(image_url)
-            img = pn.pane.Image(pil_img, height=400, align="center")
-        except Exception as e:
-            yield f"##### 😔 Something went wrong, please try a different URL!"
-            return
-    
-        class_items = class_names.split(",")
-        class_likelihoods = get_similarity_scores(class_items, pil_img)
-    
-        # build the results column
-        results = pn.Column("##### 🎉 Here are the results!", img)
-    
-        for class_item, class_likelihood in zip(class_items, class_likelihoods):
-            row_label = pn.widgets.StaticText(
-                name=class_item.strip(), value=f"{class_likelihood:.2%}", align="center"
-            )
-            row_bar = pn.indicators.Progress(
-                value=int(class_likelihood * 100),
-                sizing_mode="stretch_width",
-                bar_color="secondary",
-                margin=(0, 10),
-                design=pn.theme.Material,
-            )
-            results.append(pn.Column(row_label, row_bar))
-        yield results
-    finally:
-        main.disabled = False
-
-
-# create widgets
-randomize_url = pn.widgets.Button(name="Randomize URL", align="end")
-
-image_url = pn.widgets.TextInput(
-    name="Image URL to classify",
-    value=pn.bind(random_url, randomize_url),
-)
-class_names = pn.widgets.TextInput(
-    name="Comma separated class names",
-    placeholder="Enter possible class names, e.g. cat, dog",
-    value="cat, dog, parrot",
-)
-
-input_widgets = pn.Column(
-    "##### 😊 Click randomize or paste a URL to start classifying!",
-    pn.Row(image_url, randomize_url),
-    class_names,
-)
-
-# add interactivity
-interactive_result = pn.panel(
-    pn.bind(process_inputs, image_url=image_url, class_names=class_names),
-    height=600,
-)
-
-# add footer
-footer_row = pn.Row(pn.Spacer(), align="center")
-for icon, url in ICON_URLS.items():
-    href_button = pn.widgets.Button(icon=icon, width=35, height=35)
-    href_button.js_on_click(code=f"window.open('{url}')")
-    footer_row.append(href_button)
-footer_row.append(pn.Spacer())
-
-# create dashboard
-main = pn.WidgetBox(
-    input_widgets,
-    interactive_result,
-    footer_row,
-)
-
-title = "Panel Demo - Image Classification"
-pn.template.BootstrapTemplate(
-    title=title,
-    main=main,
-    main_max_width="min(50%, 698px)",
-    header_background="#F08080",
-).servable(title=title)
+import panel as pn
+import pandas as pd
+
+from consts import INVERTER_ID_MAPPING, TEMPERATURE_COLUMNS_TO_USE
+from plotting import (
+    create_heatmap,
+    create_iv_plot_with_power_curves,
+    create_iv_plot,
+    create_iv_plot_with_power_and_temperature_curves,
+    create_iv_plot_with_temperature_curves,
+)
+
+# Read metadata to get the date range
+timeseries_data = pd.read_csv(
+    r"data/multi_index_timeseries_data.csv",
+    index_col=0,
+    header=[0, 2],
+    parse_dates=True,
+)
+other_features_data = pd.read_csv(
+    r"data/other_features_data.csv", index_col=0, header=0, parse_dates=True
+)
+other_features_data = other_features_data[TEMPERATURE_COLUMNS_TO_USE]
+kpi_data = pd.read_csv(
+    r"data/kpi_data.csv", index_col=0, header=0, parse_dates=True
+)
+daily_timeseries_data = pd.read_csv(
+    r"data/daily_aggregated_timeseries_data.csv",
+    index_col=0,
+    header=0,
+    parse_dates=True,
+)
+
+# Initialize Panel extension
+pn.extension("plotly")
+
+# Widgets for selecting columns
+inverter_ids = pn.widgets.MultiSelect(
+    name="Inverter IDs",
+    value=[list(INVERTER_ID_MAPPING.keys())[0]],
+    options=list(INVERTER_ID_MAPPING.keys()),
+    size=8,
+)
+# Line Plots
+plot_power_curves = pn.widgets.Checkbox(name="Plot P-dc and P-ac", value=False)
+plot_temperature_curves = pn.widgets.Checkbox(name="Plot Temperatures", value=False)
+
+# Heatmaps
+heatmap_pr = pn.widgets.Checkbox(name="Heat Map PR", value=False)
+heatmap_sy = pn.widgets.Checkbox(name="Heat Map SY", value=False)
+heatmap_current = pn.widgets.Checkbox(name="Heat Map - Current", value=False)
+heatmap_voltage = pn.widgets.Checkbox(name="Heat Map - Voltage", value=False)
+heatmap_power = pn.widgets.Checkbox(name="Heat Map - Power", value=False)
+heatmap_irradiance = pn.widgets.Checkbox(name="Heat Map - Irradiance", value=False)
+heatmap_temperature = pn.widgets.Checkbox(
+    name="Heat Map - Temperature " "Heatsink", value=False
+)
+
+# Create a loading spinner
+loading_spinner = pn.indicators.LoadingSpinner(width=50, height=50)
+
+
+# Panel interactive functions
+@pn.depends(
+    inverter_ids.param.value,
+    plot_power_curves.param.value,
+    plot_temperature_curves.param.value,
+)
+def update_iv_plot(inverter_ids, plot_power_curves, plot_temperature_curves):
+    if not inverter_ids:
+        return pn.pane.Markdown("No Inverters selected for Plotting.")
+    else:
+        # Plot IV + Power + Temperature Curves
+        if plot_power_curves and plot_temperature_curves:
+            print("Plotting IV + Power + Temperature Curves")
+            return create_iv_plot_with_power_and_temperature_curves(
+                timeseries_data, other_features_data, inverter_ids
+            )
+        # Plot IV + Temperature Curves
+        elif (not plot_power_curves) and plot_temperature_curves:
+            print("Plot IV + Temperature Curves")
+            return create_iv_plot_with_temperature_curves(
+                timeseries_data, other_features_data, inverter_ids
+            )
+        # Plot IV + Power Curves
+        elif plot_power_curves and (not plot_temperature_curves):
+            print("Plot IV + Power Curves")
+            return create_iv_plot_with_power_curves(timeseries_data, inverter_ids)
+        # Plot only IV Curves
+        else:
+            print("Plot only IV Curves")
+            return create_iv_plot(timeseries_data, inverter_ids)
+
+
+@pn.depends(heatmap_pr.param.value)
+def update_heatmap_pr(heatmap_pr):
+    if heatmap_pr:
+        pr_df = kpi_data.filter(like="pr")
+        pr_df.columns = [i.split("-")[1] for i in pr_df.columns]
+        pr_heatmap = create_heatmap(pr_df, "PR Heatmap")
+        return pn.Row(pr_heatmap)
+    return pn.pane.Markdown("")
+
+
+@pn.depends(heatmap_sy.param.value)
+def update_heatmap_sy(heatmap_sy):
+    if heatmap_sy:
+        sy_df = kpi_data.filter(like="daily_specific_yield")
+        sy_df.columns = [i.split("-")[1] for i in sy_df.columns]
+        sy_heatmap = create_heatmap(sy_df, "SY Heatmap")
+        return pn.Row(sy_heatmap)
+    return pn.pane.Markdown("")
+
+
+@pn.depends(heatmap_current.param.value)
+def update_heatmap_current(heatmap_current):
+    if heatmap_current:
+        current_df = daily_timeseries_data.filter(like="I")
+        current_df.columns = [i.split("-")[1] for i in current_df.columns]
+        current_heatmap = create_heatmap(current_df, "Current Heatmap")
+        return pn.Row(current_heatmap)
+    return pn.pane.Markdown("")
+
+
+@pn.depends(heatmap_voltage.param.value)
+def update_heatmap_voltage(heatmap_voltage):
+    if heatmap_voltage:
+        voltage_df = daily_timeseries_data.filter(like="V")
+        voltage_df.columns = [i.split("-")[1] for i in voltage_df.columns]
+        voltage_heatmap = create_heatmap(voltage_df, "Voltage Heatmap")
+        return pn.Row(voltage_heatmap)
+    return pn.pane.Markdown("")
+
+
+@pn.depends(heatmap_power.param.value)
+def update_heatmap_power(heatmap_power):
+    if heatmap_power:
+        power_df = daily_timeseries_data.filter(like="P")
+        power_df.columns = [i.split("-")[1] for i in power_df.columns]
+        power_heatmap = create_heatmap(power_df, "Power Heatmap")
+        return pn.Row(power_heatmap)
+    return pn.pane.Markdown("")
+
+
+@pn.depends(heatmap_irradiance.param.value)
+def update_heatmap_irradiance(heatmap_irradiance):
+    if heatmap_irradiance:
+        irradiance_df = daily_timeseries_data.filter(like="G")
+        irradiance_df.columns = [i.split("-")[1] for i in irradiance_df.columns]
+        irradiance_heatmap = create_heatmap(irradiance_df, "Irradiance " "Heatmap")
+        return pn.Row(irradiance_heatmap)
+    return pn.pane.Markdown("")
+
+
+@pn.depends(heatmap_temperature.param.value)
+def update_heatmap_temperature(heatmap_temperature):
+    if heatmap_temperature:
+        temp_df = daily_timeseries_data.filter(like="THeatSink")
+        temp_df.columns = [i.split("-")[1] for i in temp_df.columns]
+        temp_heatmap = create_heatmap(temp_df, "T-Heatsink Heatmap")
+        return pn.Row(temp_heatmap)
+    return pn.pane.Markdown("")
+
+
+# Create dashboard layout
+dashboard = pn.Column(
+    "# ENEL Dashboard",
+    # IV Plots
+    pn.Row(
+        pn.Column(inverter_ids, plot_power_curves, plot_temperature_curves),
+        pn.panel(update_iv_plot, sizing_mode="stretch_width"),
+    ),
+    # Heatmaps
+    pn.Row(
+        pn.Column(heatmap_pr), pn.panel(update_heatmap_pr, sizing_mode="stretch_width")
+    ),
+    pn.Row(
+        pn.Column(heatmap_sy), pn.panel(update_heatmap_sy, sizing_mode="stretch_width")
+    ),
+    pn.Row(
+        pn.Column(heatmap_current),
+        pn.panel(update_heatmap_current, sizing_mode="stretch_width"),
+    ),
+    pn.Row(
+        pn.Column(heatmap_voltage),
+        pn.panel(update_heatmap_voltage, sizing_mode="stretch_width"),
+    ),
+    pn.Row(
+        pn.Column(heatmap_power),
+        pn.panel(update_heatmap_power, sizing_mode="stretch_width"),
+    ),
+    pn.Row(
+        pn.Column(heatmap_irradiance),
+        pn.panel(update_heatmap_irradiance, sizing_mode="stretch_width"),
+    ),
+    pn.Row(
+        pn.Column(heatmap_temperature),
+        pn.panel(update_heatmap_temperature, sizing_mode="stretch_width"),
+    ),
+)
+
+# Serve the dashboard
+dashboard.servable()

consts.py

@@ -0,0 +1,23 @@
+INVERTER_ID_MAPPING = {
+    "01.01.1A.2 (699)": 699,
+    "02.08.1A.2 (700)": 700,
+    "02.09.1A.2 (701)": 701,
+    "03.08.1A.2 (702)": 702,
+    "05.02.1A.2 (703)": 703,
+    "05.06.1A.2 (704)": 704,
+}
+
+CURRENT = "I"
+VOLTAGE = "V"
+IRRADIANCE = "G"
+POWER_AC = "P-AC"
+POWER_DC = "P"
+T_AMBIENT = "T_Air"
+T_MODULE = "Tmod"
+T_HEATSINK = "T_HEAT_SINK"
+T_CPU = "T_CPU"
+T_BOARD = "T_BOARD"
+
+TEMPERATURE_COLUMNS_TO_USE = ["T_CPU", "T_BOARD", "T_Air", "Inv", "T_HEAT_SINK"]
+
+HEATMAP_OPTIONS = ["PR", "SY", "IVPGT"]

plotting.py

@@ -0,0 +1,427 @@
+import panel as pn
+import plotly.graph_objs as go
+import plotly.express as px
+from plotly.subplots import make_subplots
+
+from consts import (
+    INVERTER_ID_MAPPING,
+    CURRENT,
+    IRRADIANCE,
+    VOLTAGE,
+    POWER_DC,
+    POWER_AC,
+    T_AMBIENT,
+    T_MODULE,
+    T_HEATSINK,
+    T_CPU,
+    T_BOARD,
+)
+
+
+def create_iv_plot(df, inverter_ids):
+    """# Helper function to create a line plot with secondary y-axis"""
+
+    print("Selected Inverter Ids: {}".format(inverter_ids))
+    fig = make_subplots(
+        rows=2,
+        cols=1,
+        shared_xaxes=True,
+        vertical_spacing=0.01,
+        specs=[[{"secondary_y": True}], [{}]],
+    )
+
+    for inverter in inverter_ids:
+        inv_id = INVERTER_ID_MAPPING[inverter]
+        print("Creating plot for inv_id: {}".format(inv_id))
+        inv_data = df[str(inv_id)]
+
+        # Graph 1: DC current and G-POA (Twin Y-Axis)
+        fig.add_trace(
+            go.Scatter(
+                x=inv_data.index,
+                y=inv_data[CURRENT],
+                mode="lines",
+                name=f"{CURRENT}-{inv_id}",
+            ),
+            row=1,
+            col=1,
+            secondary_y=False,
+        )
+
+        fig.add_trace(
+            go.Scatter(
+                x=inv_data.index,
+                y=inv_data[IRRADIANCE],
+                mode="lines",
+                name=f"{IRRADIANCE}-{inv_id}",
+            ),
+            row=1,
+            col=1,
+            secondary_y=True,
+        )
+
+        # Graph 2: Voltage
+        fig.add_trace(
+            go.Scatter(
+                x=inv_data.index,
+                y=inv_data[VOLTAGE],
+                mode="lines",
+                name=f"{VOLTAGE}-{inv_id}",
+            ),
+            row=2,
+            col=1,
+        )
+    # Update axis labels
+    fig.update_yaxes(title_text="Current (A)", row=1, col=1)
+    fig.update_yaxes(title_text="Irradiance (W/m2)", row=1, col=1, secondary_y=True)
+    fig.update_yaxes(title_text="Voltage (V)", row=2, col=1)
+    fig.update_xaxes(title_text="Datetime", row=2, col=1)
+
+    # Update layout to add titles and adjust axis labels
+    fig.update_layout(title_text="IV Plots", height=800, width=1000)
+
+    return fig
+
+
+def create_iv_plot_with_power_curves(df, inverter_ids):
+    """# Helper function to create a line plot with secondary y-axis"""
+
+    print("Selected Inverter Ids: {}".format(inverter_ids))
+    fig = make_subplots(
+        rows=3,
+        cols=1,
+        shared_xaxes=True,
+        vertical_spacing=0.01,
+        specs=[[{"secondary_y": True}], [{}], [{}]],
+    )
+
+    for inverter in inverter_ids:
+        inv_id = INVERTER_ID_MAPPING[inverter]
+        print("Creating plot for inv_id: {}".format(inv_id))
+        inv_data = df[str(inv_id)]
+
+        # Graph 1: DC current and G-POA (Twin Y-Axis)
+        fig.add_trace(
+            go.Scatter(
+                x=inv_data.index,
+                y=inv_data[CURRENT],
+                mode="lines",
+                name=f"{CURRENT}-{inv_id}",
+            ),
+            row=1,
+            col=1,
+            secondary_y=False,
+        )
+
+        fig.add_trace(
+            go.Scatter(
+                x=inv_data.index,
+                y=inv_data[IRRADIANCE],
+                mode="lines",
+                name=f"{IRRADIANCE}-{inv_id}",
+            ),
+            row=1,
+            col=1,
+            secondary_y=True,
+        )
+
+        # Graph 2: Voltage
+        fig.add_trace(
+            go.Scatter(
+                x=inv_data.index,
+                y=inv_data[VOLTAGE],
+                mode="lines",
+                name=f"{VOLTAGE}-{inv_id}",
+            ),
+            row=2,
+            col=1,
+        )
+
+        # Graph 3: P-dc and P-ac
+        fig.add_trace(
+            go.Scatter(
+                x=inv_data.index,
+                y=inv_data[POWER_DC],
+                mode="lines",
+                name=f"{POWER_DC}-{inv_id}",
+            ),
+            row=3,
+            col=1,
+        )
+        fig.add_trace(
+            go.Scatter(
+                x=inv_data.index,
+                y=inv_data[POWER_AC],
+                mode="lines",
+                name=f"{POWER_AC}-{inv_id}",
+            ),
+            row=3,
+            col=1,
+        )
+
+    # Update axis labels
+    fig.update_yaxes(title_text="Current (A)", row=1, col=1)
+    fig.update_yaxes(title_text="Irradiance (W/m2)", row=1, col=1, secondary_y=True)
+    fig.update_yaxes(title_text="Voltage (V)", row=2, col=1)
+    fig.update_yaxes(title_text="P-dc & P-ac (W)", row=3, col=1)
+    fig.update_xaxes(title_text="Datetime", row=3, col=1)
+
+    # Update layout to add titles
+    fig.update_layout(title_text="IV Plot with Power Curves", height=800, width=1000)
+
+    return fig
+
+
+def create_iv_plot_with_power_and_temperature_curves(df, df2, inverter_ids):
+    # Create the specs for subplots
+    print("Selected Inverter Ids: {}".format(inverter_ids))
+    fig = make_subplots(
+        rows=4,
+        cols=1,
+        shared_xaxes=True,
+        vertical_spacing=0.01,
+        specs=[[{"secondary_y": True}], [{}], [{}], [{}]],
+    )
+
+    for inverter in inverter_ids:
+        inv_id = INVERTER_ID_MAPPING[inverter]
+        print("Creating plot for inv_id: {}".format(inv_id))
+        inv_data = df[str(inv_id)]
+        temperature_data = df2[df2["Inv"] == inv_id]
+
+        # Graph 1: DC current and G-POA (Twin Y-Axis)
+        fig.add_trace(
+            go.Scatter(
+                x=inv_data.index,
+                y=inv_data[CURRENT],
+                mode="lines",
+                name=f"{CURRENT}-{inv_id}",
+            ),
+            row=1,
+            col=1,
+            secondary_y=False,
+        )
+
+        fig.add_trace(
+            go.Scatter(
+                x=inv_data.index,
+                y=inv_data[IRRADIANCE],
+                mode="lines",
+                name=f"{IRRADIANCE}-{inv_id}",
+            ),
+            row=1,
+            col=1,
+            secondary_y=True,
+        )
+
+        # Graph 2: Voltage
+        fig.add_trace(
+            go.Scatter(
+                x=inv_data.index,
+                y=inv_data[VOLTAGE],
+                mode="lines",
+                name=f"{VOLTAGE}-{inv_id}",
+            ),
+            row=2,
+            col=1,
+        )
+
+        # Graph 3: P-dc and P-ac
+        fig.add_trace(
+            go.Scatter(
+                x=inv_data.index,
+                y=inv_data[POWER_DC],
+                mode="lines",
+                name=f"{POWER_DC}-{inv_id}",
+            ),
+            row=3,
+            col=1,
+        )
+        fig.add_trace(
+            go.Scatter(
+                x=inv_data.index,
+                y=inv_data[POWER_AC],
+                mode="lines",
+                name=f"{POWER_AC}-{inv_id}",
+            ),
+            row=3,
+            col=1,
+        )
+
+        # Graph 4: T-amb, T-mod, T-heatsink, T-CPU and T-board
+        fig.add_trace(
+            go.Scatter(
+                x=temperature_data.index,
+                y=temperature_data[T_AMBIENT],
+                name=f"{T_AMBIENT}-{inv_id}",
+            ),
+            row=4,
+            col=1,
+        )
+        fig.add_trace(
+            go.Scatter(
+                x=inv_data.index, y=inv_data[T_MODULE], name=f"{T_MODULE}-{inv_id}"
+            ),
+            row=4,
+            col=1,
+        )
+        fig.add_trace(
+            go.Scatter(
+                x=temperature_data.index,
+                y=temperature_data[T_HEATSINK],
+                name=f"{T_HEATSINK}-{inv_id}",
+            ),
+            row=4,
+            col=1,
+        )
+        fig.add_trace(
+            go.Scatter(
+                x=temperature_data.index,
+                y=temperature_data[T_CPU],
+                name=f"{T_CPU}-{inv_id}",
+            ),
+            row=4,
+            col=1,
+        )
+        fig.add_trace(
+            go.Scatter(
+                x=temperature_data.index,
+                y=temperature_data[T_BOARD],
+                name=f"{T_BOARD}-{inv_id}",
+            ),
+            row=4,
+            col=1,
+        )
+
+    # Update axis labels
+    fig.update_yaxes(title_text="Current (A)", row=1, col=1)
+    fig.update_yaxes(title_text="Irradiance (W/m2)", row=1, col=1, secondary_y=True)
+    fig.update_yaxes(title_text="Voltage (V)", row=2, col=1)
+    fig.update_yaxes(title_text="P-dc & P-ac (W)", row=3, col=1)
+    fig.update_xaxes(title_text="Datetime", row=4, col=1)
+    fig.update_yaxes(title_text="Temperature (°C)", row=4, col=1)
+
+    # Update layout to add titles
+    fig.update_layout(
+        title_text="IV Plots with Power and Temperature", height=800, width=1000
+    )
+
+    return pn.pane.Plotly(fig)
+
+
+def create_iv_plot_with_temperature_curves(df, df2, inverter_ids):
+    # Create the specs for subplots
+    print("Selected Inverter Ids: {}".format(inverter_ids))
+    fig = make_subplots(
+        rows=3,
+        cols=1,
+        shared_xaxes=True,
+        vertical_spacing=0.01,
+        specs=[[{"secondary_y": True}], [{}], [{}]],
+    )
+
+    for inverter in inverter_ids:
+        inv_id = INVERTER_ID_MAPPING[inverter]
+        print("Creating plot for inv_id: {}".format(inv_id))
+        inv_data = df[str(inv_id)]
+        temperature_data = df2[df2["Inv"] == inv_id]
+
+        # Graph 1: DC current and G-POA (Twin Y-Axis)
+        fig.add_trace(
+            go.Scatter(
+                x=inv_data.index,
+                y=inv_data[CURRENT],
+                mode="lines",
+                name=f"{CURRENT}-{inv_id}",
+            ),
+            row=1,
+            col=1,
+            secondary_y=False,
+        )
+
+        fig.add_trace(
+            go.Scatter(
+                x=inv_data.index,
+                y=inv_data[IRRADIANCE],
+                mode="lines",
+                name=f"{IRRADIANCE}-{inv_id}",
+            ),
+            row=1,
+            col=1,
+            secondary_y=True,
+        )
+
+        # Graph 2: Voltage
+        fig.add_trace(
+            go.Scatter(
+                x=inv_data.index,
+                y=inv_data[VOLTAGE],
+                mode="lines",
+                name=f"{VOLTAGE}-{inv_id}",
+            ),
+            row=2,
+            col=1,
+        )
+
+        # Graph 4: T-amb, T-mod, T-heatsink, T-CPU and T-board
+        fig.add_trace(
+            go.Scatter(
+                x=temperature_data.index,
+                y=temperature_data[T_AMBIENT],
+                name=f"{T_AMBIENT}-{inv_id}",
+            ),
+            row=3,
+            col=1,
+        )
+        fig.add_trace(
+            go.Scatter(
+                x=inv_data.index, y=inv_data[T_MODULE], name=f"{T_MODULE}-{inv_id}"
+            ),
+            row=3,
+            col=1,
+        )
+        fig.add_trace(
+            go.Scatter(
+                x=temperature_data.index,
+                y=temperature_data[T_HEATSINK],
+                name=f"{T_HEATSINK}-{inv_id}",
+            ),
+            row=3,
+            col=1,
+        )
+        fig.add_trace(
+            go.Scatter(
+                x=temperature_data.index,
+                y=temperature_data[T_CPU],
+                name=f"{T_CPU}-{inv_id}",
+            ),
+            row=3,
+            col=1,
+        )
+        fig.add_trace(
+            go.Scatter(
+                x=temperature_data.index,
+                y=temperature_data[T_BOARD],
+                name=f"{T_BOARD}-{inv_id}",
+            ),
+            row=3,
+            col=1,
+        )
+
+    # Update axis labels
+    fig.update_yaxes(title_text="Current (A)", row=1, col=1)
+    fig.update_yaxes(title_text="Irradiance (W/m2)", row=1, col=1, secondary_y=True)
+    fig.update_yaxes(title_text="Voltage (V)", row=2, col=1)
+    fig.update_xaxes(title_text="Datetime", row=3, col=1)
+    fig.update_yaxes(title_text="Temperature (°C)", row=3, col=1)
+
+    # Update layout to add titles
+    fig.update_layout(title_text="IV Plots with Temperature", height=800, width=1000)
+
+    return pn.pane.Plotly(fig)
+
+
+def create_heatmap(df, title):
+    fig = px.imshow(df.transpose(), aspect="auto", title=title)
+    fig.update_layout(height=400, width=1200)
+    return pn.pane.Plotly(fig)

requirements.txt

@@ -1,6 +1,3 @@
-panel
-jupyter
-transformers
-numpy
-torch
-aiohttp
+pandas
+plotly
+panel