Giovanni/PV_Simulator
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Simulatore dell'impianto

Browse Source
This commit is contained in:
Giovanni
2026-07-19 15:03:02 +00:00
parent 65cd36892d
commit 7b2025a8e6
1 changed files with 891 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

891
pvsim/plant.py Normal file
View File

@@ -0,0 +1,891 @@
```python
"""
plant.py
Modello gerarchico completo dell'impianto fotovoltaico.
Gerarchia:
PVPlant
|
+-- Inverter
| |
| +-- CombinerBox
| |
| +-- PVPanel
| +-- PVPanel
| +-- ...
|
+-- Inverter
|
+-- CombinerBox
|
+-- PVPanel
Il modulo costruisce automaticamente l'intero impianto
a partire dal file di configurazione plant.json.
Responsabilità:
- creazione della gerarchia;
- gestione degli inverter;
- gestione delle Combiner Box;
- creazione automatica dei pannelli;
- aggiornamento dell'intero impianto;
- aggregazione della potenza;
- aggregazione dell'energia;
- calcolo della disponibilità;
- diagnostica della struttura.
"""
from __future__ import annotations
from dataclasses import dataclass, field
from datetime import datetime
from typing import Dict, List, Any
import json
from pathlib import Path
from .panel import PVPanel
from .combiner import CombinerBox
from .inverter import Inverter
@dataclass
class PVPlant:
"""
Rappresenta l'intero impianto fotovoltaico.
"""
plant_id: str
inverters: List[Inverter] = field(
default_factory=list
)
total_energy_Wh: float = 0.0
total_dc_energy_Wh: float = 0.0
total_ac_energy_Wh: float = 0.0
# Numero di timestep elaborati
timestep_count: int = 0
# ------------------------------------------------------------------
# Costruzione da configurazione
# ------------------------------------------------------------------
@classmethod
def from_config(
cls,
config: Dict[str, Any]
) -> "PVPlant":
"""
Crea un impianto completo leggendo la configurazione.
La configurazione deve avere la struttura:
layout
|
+-- inverters
|
+-- combiners
|
+-- strings
+-- panels_per_string
Returns
-------
PVPlant
Impianto completamente costruito.
"""
plant_name = (
config[
"plant"
][
"name"
]
)
plant = cls(
plant_id=plant_name
)
module_config = (
config[
"module"
]
)
layout_config = (
config[
"layout"
]
)
# --------------------------------------------------------------
# Creazione inverter
# --------------------------------------------------------------
for inverter_config in (
layout_config[
"inverters"
]
):
inverter = (
cls._create_inverter(
inverter_config,
module_config
)
)
plant.inverters.append(
inverter
)
return plant
# ------------------------------------------------------------------
@classmethod
def from_json(
cls,
config_path: str | Path
) -> "PVPlant":
"""
Carica la configurazione da un file JSON
e costruisce l'impianto.
"""
config_path = Path(
config_path
)
if not config_path.exists():
raise FileNotFoundError(
f"Configurazione non trovata: "
f"{config_path}"
)
with open(
config_path,
"r",
encoding="utf-8"
) as file:
config = json.load(
file
)
return cls.from_config(
config
)
# ------------------------------------------------------------------
# Creazione inverter
# ------------------------------------------------------------------
@staticmethod
def _create_inverter(
inverter_config: Dict[str, Any],
module_config: Dict[str, Any]
) -> Inverter:
"""
Crea un inverter e tutte le relative Combiner Box.
"""
inverter = Inverter(
inverter_id=
inverter_config[
"id"
],
nominal_power_kW=
inverter_config[
"nominal_power_kW"
],
nominal_efficiency=
inverter_config[
"efficiency"
][
"nominal"
],
night_consumption_W=
inverter_config[
"efficiency"
][
"night_consumption_W"
]
)
# --------------------------------------------------------------
# Creazione Combiner Box
# --------------------------------------------------------------
for combiner_config in (
inverter_config[
"combiners"
]
):
combiner = (
PVPlant._create_combiner(
combiner_config,
module_config
)
)
inverter.add_combiner(
combiner
)
return inverter
# ------------------------------------------------------------------
# Creazione Combiner Box
# ------------------------------------------------------------------
@staticmethod
def _create_combiner(
combiner_config: Dict[str, Any],
module_config: Dict[str, Any]
) -> CombinerBox:
"""
Crea una Combiner Box e tutti i relativi pannelli.
La configurazione definisce:
strings = numero di stringhe
panels_per_string =
pannelli per ogni stringa
In questa versione la struttura delle stringhe
viene rappresentata logicamente creando tutti i pannelli
nella Combiner Box.
L'ID del pannello contiene:
Combiner ID
String ID
Panel ID
"""
combiner = CombinerBox(
combiner_id=
combiner_config[
"id"
]
)
strings = (
combiner_config[
"strings"
]
)
panels_per_string = (
combiner_config[
"panels_per_string"
]
)
# --------------------------------------------------------------
# Parametri pannello
# --------------------------------------------------------------
nominal_power = (
module_config[
"nominal_power_W"
]
)
electrical = (
module_config[
"electrical"
]
)
physical = (
module_config[
"physical"
]
)
degradation = (
module_config[
"degradation"
]
)
# --------------------------------------------------------------
# Creazione pannelli
# --------------------------------------------------------------
for string_number in range(
1,
strings + 1
):
for panel_number in range(
1,
panels_per_string + 1
):
panel_id = (
f"{combiner_config['id']}"
f"_STR_{string_number:02d}"
f"_PANEL_{panel_number:02d}"
)
panel = PVPanel(
panel_id=
panel_id,
nominal_power=
nominal_power,
area=
physical[
"area_m2"
],
vmp=
electrical[
"vmp_V"
],
imp=
electrical[
"imp_A"
],
voc=
electrical[
"voc_V"
],
isc=
electrical[
"isc_A"
],
temp_coeff=
physical[
"temperature_coefficient_power"
],
nominal_temp=
physical[
"nominal_temperature_C"
],
annual_degradation=
degradation[
"annual_rate"
]
)
combiner.add_panel(
panel
)
return combiner
# ------------------------------------------------------------------
# Gestione inverter
# ------------------------------------------------------------------
def add_inverter(
self,
inverter: Inverter
) -> None:
"""
Aggiunge un inverter all'impianto.
"""
self.inverters.append(
inverter
)
# ------------------------------------------------------------------
def get_inverter_count(
self
) -> int:
"""
Restituisce il numero di inverter.
"""
return len(
self.inverters
)
# ------------------------------------------------------------------
def get_active_inverter_count(
self
) -> int:
"""
Restituisce il numero di inverter attivi.
"""
return sum(
1
for inverter
in self.inverters
if inverter.enabled
)
# ------------------------------------------------------------------
# Conteggi gerarchici
# ------------------------------------------------------------------
def get_combiner_count(
self
) -> int:
"""
Restituisce il numero totale di Combiner Box.
"""
return sum(
len(
inverter.combiners
)
for inverter
in self.inverters
)
# ------------------------------------------------------------------
def get_panel_count(
self
) -> int:
"""
Restituisce il numero totale di pannelli.
"""
return sum(
len(
combiner.panels
)
for inverter
in self.inverters
for combiner
in inverter.combiners
)
# ------------------------------------------------------------------
def get_active_panel_count(
self
) -> int:
"""
Restituisce il numero di pannelli attivi.
"""
return sum(
1
for inverter
in self.inverters
for combiner
in inverter.combiners
for panel
in combiner.panels
if panel.enabled
)
# ------------------------------------------------------------------
# Aggiornamento impianto
# ------------------------------------------------------------------
def update(
self,
timestamp: datetime,
irradiance: float,
ambient_temperature: float,
years_from_start: float,
timestep_minutes: float
) -> Dict[str, Any]:
"""
Esegue un timestep sull'intero impianto.
Flusso:
Plant
|
+-- Inverter
|
+-- Combiner
|
+-- Panel
Returns
-------
Dict
Dati aggregati dell'impianto.
"""
inverter_data = []
# --------------------------------------------------------------
# Aggiornamento inverter
# --------------------------------------------------------------
for inverter in self.inverters:
data = inverter.update(
timestamp=
timestamp,
irradiance=
irradiance,
ambient_temperature=
ambient_temperature,
years_from_start=
years_from_start,
timestep_minutes=
timestep_minutes
)
inverter_data.append(
data
)
# --------------------------------------------------------------
# Aggregazione potenza
# --------------------------------------------------------------
total_dc_power = sum(
data[
"dc_power_W"
]
for data
in inverter_data
)
total_ac_power = sum(
data[
"ac_power_W"
]
for data
in inverter_data
)
# --------------------------------------------------------------
# Aggregazione energia
# --------------------------------------------------------------
dc_energy = (
total_dc_power
* timestep_minutes
/ 60.0
)
ac_energy = (
total_ac_power
* timestep_minutes
/ 60.0
)
self.total_dc_energy_Wh += (
dc_energy
)
self.total_ac_energy_Wh += (
ac_energy
)
self.total_energy_Wh += (
ac_energy
)
self.timestep_count += 1
# --------------------------------------------------------------
# Disponibilità
# --------------------------------------------------------------
total_inverters = (
self.get_inverter_count()
)
active_inverters = (
self.get_active_inverter_count()
)
if total_inverters > 0:
availability = (
active_inverters
/ total_inverters
)
else:
availability = 0.0
# --------------------------------------------------------------
# Output
# --------------------------------------------------------------
return {
"timestamp":
timestamp,
"plant_id":
self.plant_id,
"dc_power_W":
total_dc_power,
"ac_power_W":
total_ac_power,
"dc_energy_Wh":
dc_energy,
"ac_energy_Wh":
ac_energy,
"total_energy_Wh":
self.total_energy_Wh,
"dc_total_energy_Wh":
self.total_dc_energy_Wh,
"ac_total_energy_Wh":
self.total_ac_energy_Wh,
"inverters":
total_inverters,
"active_inverters":
active_inverters,
"combiners":
self.get_combiner_count(),
"panels":
self.get_panel_count(),
"active_panels":
self.get_active_panel_count(),
"availability":
availability,
"enabled":
True
}
# ------------------------------------------------------------------
# Struttura impianto
# ------------------------------------------------------------------
def describe(
self
) -> str:
"""
Restituisce una descrizione testuale
della gerarchia dell'impianto.
"""
lines = []
lines.append(
f"PV Plant: "
f"{self.plant_id}"
)
lines.append(
f" Inverters: "
f"{self.get_inverter_count()}"
)
lines.append(
f" Combiners: "
f"{self.get_combiner_count()}"
)
lines.append(
f" Panels: "
f"{self.get_panel_count()}"
)
lines.append("")
for inverter in self.inverters:
lines.append(
f" ├── "
f"{inverter.inverter_id} "
f"({inverter.nominal_power_kW} kW)"
)
for combiner in (
inverter.combiners
):
lines.append(
f" │ ├── "
f"{combiner.combiner_id} "
f"({len(combiner.panels)} panels)"
)
# Raggruppamento logico delle stringhe
panel_count = (
len(
combiner.panels
)
)
lines.append(
f" │ │ └── "
f"{panel_count} panels"
)
return "\n".join(
lines
)
# ------------------------------------------------------------------
# Ricerca componenti
# ------------------------------------------------------------------
def find_inverter(
self,
inverter_id: str
) -> Inverter | None:
"""
Cerca un inverter tramite ID.
"""
for inverter in self.inverters:
if (
inverter.inverter_id
== inverter_id
):
return inverter
return None
# ------------------------------------------------------------------
def find_combiner(
self,
combiner_id: str
) -> CombinerBox | None:
"""
Cerca una Combiner Box tramite ID.
"""
for inverter in self.inverters:
for combiner in (
inverter.combiners
):
if (
combiner.combiner_id
== combiner_id
):
return combiner
return None
# ------------------------------------------------------------------
def find_panel(
self,
panel_id: str
) -> PVPanel | None:
"""
Cerca un pannello tramite ID.
"""
for inverter in self.inverters:
for combiner in (
inverter.combiners
):
for panel in (
combiner.panels
):
if (
panel.panel_id
== panel_id
):
return panel
return None
# ------------------------------------------------------------------
def __repr__(
self
) -> str:
"""
Rappresentazione leggibile dell'impianto.
"""
return (
f"PVPlant("
f"id={self.plant_id}, "
f"inverters="
f"{self.get_inverter_count()}, "
f"combiners="
f"{self.get_combiner_count()}, "
f"panels="
f"{self.get_panel_count()})"
)
```