davide/simulatore-induttori
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

temp

Browse Source
This commit is contained in:
davide
2026-08-03 00:18:00 +02:00
parent 560c6a6a62
commit 7883f3dead
13 changed files with 1460 additions and 488 deletions
Download Patch File Download Diff File Expand all files Collapse all files
README.md
+207 -86
View File
@@ -1,4 +1,4 @@
# Simulatore Termico 2D — Fascetta, Sorgenti a Induzione Mobili, Sensore IR Fisso
# Simulatore Termico a Elementi Shell — Fascetta, Sorgenti a Induzione Mobili, Sensore IR Fisso
Questo progetto genera misurazioni CSV pseudo-realistiche della temperatura di una
fascetta (anello cilindrico sottile) riscaldata da un gruppo di sorgenti a induzione
@@ -9,105 +9,191 @@ per l'addestramento e la validazione di modelli di stima/regressione termica.
La fascetta è un anello cilindrico definito da tre dimensioni:
- **diametro** (default 70 mm) — il diametro del cilindro;
- **spessore** (default 0.12 mm) — lo spessore della parete;
- **diametro medio** (default 70 mm) — il diametro della superficie media, su cui
giace la mesh;
- **spessore** (default 0.18 mm) — lo spessore della parete;
- **lunghezza** (default 100 mm) — l'estensione assiale lungo `x`.
Il dominio simulato è la **sezione rettangolare lunghezza × spessore**. Il sistema di
coordinate ha l'origine `(0, 0)` nel vertice in alto a sinistra della sezione:
Il dominio simulato è l'**intera superficie cilindrica**, discretizzata con elementi
shell quadrilateri. La superficie è parametrizzata da `(x, θ)`:
```text
sorgenti (induttori), in moto verso -x
▼ ▼ ▼
(0,0) ─────────────────────────────────────► x
│ ┌───────────────────────────────────┐ z = 0 lato ESTERNO
│ │ sezione della fascetta │ (flusso termico)
│ └───────────────────────────────────┘ z = spessore lato INTERNO
▼ ┆
z ┆ linea di vista
▲
sensore IR (fisso, x = 50 mm,
a 10 mm dalla parete interna)
sorgenti (induttori), in moto verso -x
▼ ▼ ▼
╭────────────────────────────────╮
θ = 0 ─ ─ ─ ┤ ● ← punto osservato dal ├ ─ ─ ─ generatrice del sensore
│ sensore IR (x = 50 mm) │
╰────────────────────────────────╯
x = 0 x = lunghezza
superficie sviluppata in piano; il bordo superiore e quello inferiore
sono lo stesso punto della fascetta (θ = 0 ≡ θ = 2π)
```
- **x** = direzione della lunghezza, da `0` a `lunghezza`. Le sorgenti viaggiano in
direzione `-x` sul lato esterno.
- **z** = direzione dello spessore, da `0` (lato esterno, dove arriva il flusso
termico) a `spessore` (lato interno, osservato dal sensore).
- **y** = coordinata circonferenziale (lungo la circonferenza π·diametro). Non è
risolta spazialmente: vedi sotto come viene trattata.
direzione `-x` sulla superficie esterna.
- **θ** = coordinata circonferenziale, **periodica** e risolta spazialmente. La
generatrice `θ = 0` è quella del sensore; l'offset circonferenziale delle sorgenti
(`offset_y_percorso_m`, misurato lungo l'arco) è riferito ad essa.
- Lo **spessore non è discretizzato**: la parete è termicamente sottile, quindi la
faccia esterna e quella interna hanno la stessa temperatura.
Il **sensore** è un pirometro a infrarossi posto all'interno della fascetta, a una
distanza configurabile dalla parete interna (default 10 mm). Essendo senza contatto,
la distanza non influenza la misura: il sensore legge la temperatura della superficie
interna nel punto `x` configurato (default 50 mm, al centro della lunghezza).
interna nel punto `x` configurato (default 50 mm, al centro della lunghezza) sulla
generatrice `θ = 0`.
## Modello fisico
Non è una simulazione FEM elettromagnetica + termica completa: è un generatore
pratico di dataset. La catena di approssimazioni è la seguente.
Il campo elettromagnetico non è simulato: la parte termica è però una FEM vera. La
catena di modellazione è la seguente.
1. **Sorgenti gaussiane in moto** — ogni sorgente ha un'impronta gaussiana di raggio
`sigma_punto_m`. Un gruppo di `numero_sorgenti` sorgenti equidistanti
(`distanza_sorgenti_m`) si muove rigidamente a velocità costante. Il profilo di
flusso sul lato esterno è la somma dei contributi:
`q(x, t) = Σᵢ q_picco · efficienza · exp(-((x - xᵢ(t))² + Δy²) / (2σ²))`.
L'offset circonferenziale `Δy` tra il percorso delle sorgenti e il punto osservato
dal sensore non è risolto spazialmente: entra come attenuazione gaussiana del flusso.
1. **Shell termica** — per una parete sottile con temperatura uniforme nello spessore
l'equazione del calore sulla superficie cilindrica è
2. **Skin depth** — il riscaldamento a induzione è approssimato come riscaldamento
volumetrico che decade esponenzialmente con la profondità `z`:
`q_vol(x, z) = q(x) · exp(-z/δ) / (δ·(1 - exp(-spessore/δ)))`, normalizzato in modo
da conservare il flusso superficiale. La skin depth `δ = √(2ρₑ/(ωμ))` è calcolata
dalla resistività elettrica e dalla permeabilità del materiale alla frequenza di
induzione, oppure può essere imposta con `skin_depth_fissa_m`. Per la banda
stagnata a 20 kHz risulta ≈ 0.1 mm, confrontabile con lo spessore: la parete è
quasi isoterma attraverso lo spessore.
```text
ρ cp s ∂T/∂t = k s ( ∂²T/∂x² + (1/R²) ∂²T/∂θ² ) + q'' − q_conv
```
3. **Diffusione 2D del calore** — l'equazione del calore è integrata nella sezione
`(x, z)` con volumi finiti ed Eulero implicito (incondizionatamente stabile).
La conduzione **assiale** e quella **circonferenziale** sono entrambe risolte.
Discretizzando con elementi quadrilateri a 4 nodi e una temperatura per nodo si
ottiene `C Ṫ + K T = f(t)`, con
4. **Scambi con l'esterno** — la sezione scambia calore con l'ambiente su tutto il
contorno:
- convezione sul lato esterno (`h_esterno_W_m2K`), sul lato interno
(`h_interno_W_m2K`) e sui due bordi in x (`h_bordi_W_m2K`);
- **conduzione circonferenziale**: la sezione cede calore per conduzione lungo `y`
al resto della fascetta, assunto a temperatura ambiente. Il termine è
un'equazione di aletta ricavata sull'intero volume del cilindro: il calore
conduce lungo `y` attraverso l'intero spessore mentre le superfici esterna e
interna dell'intero cilindro perdono calore per convezione, dando
`q_y = -(h_esterno + h_interno)/spessore · (T - T_amb)` — nessun parametro di
conduzione `y` aggiuntivo da configurare.
```text
Cₑ = ∫ ρ cp s Nᵀ N dA (matrice consistente)
Kₑ_cond = ∫ Bᵀ D B s dA D = k·I (materiale isotropo)
```
La conduzione tra elementi adiacenti nasce dall'assemblaggio: due elementi
confinanti condividono i nodi del bordo comune, quindi condividono gli stessi
gradi di libertà termici. Non serve alcuna legge di scambio tra elementi dello
stesso materiale.
2. **Convezione** — nelle shell la faccia esterna e quella interna sono **entrambe**
superfici fisiche esposte, quindi ogni elemento scambia su tutta la sua area:
```text
Kₑ_conv = ∫ (h_est + h_int) Nᵀ N dA fₑ_conv = ∫ (h_est + h_int) T∞ Nᵀ dA
```
I due bordi assiali espongono solo lo spessore della lamiera:
`Kₑ_bordo = ∫ h_b s Nᵀ N dl`. Con `s = 0.18 mm` su `100 mm` di lunghezza il
contributo dei bordi vale ~0.2% dell'area ed è quindi marginale.
3. **Sorgenti gaussiane in moto** — un gruppo di `numero_sorgenti` sorgenti
equidistanti (`distanza_sorgenti_m`) si muove rigidamente a velocità costante lungo
la generatrice individuata da `offset_y_percorso_m`. Il flusso sulla superficie
esterna è
```text
q''(x, θ, t) = q_picco · efficienza · Σᵢ exp( −((x − xᵢ(t))² + Δy²) / (2σ²) )
Δy = R · wrap(θ − θ_s)
```
La distanza circonferenziale è **riavvolta** su `2πR`: la sorgente scalda anche i
punti raggiunti dall'altro verso della circonferenza. Il carico nodale è
`fₑ_src = ∫ Nᵀ q'' dA`, integrato con la stessa quadratura di Gauss delle matrici:
la posizione circonferenziale dell'induttore è quindi simulata davvero, non
rappresentata da un coefficiente di attenuazione.
4. **Skin depth** — `δ = √(2ρₑ/(ωμ))`, calcolata dalla resistività elettrica e dalla
permeabilità del materiale, oppure imposta con `skin_depth_fissa_m`. Poiché la
shell non discretizza lo spessore, la skin depth **non entra nella soluzione**: è
registrata in `metadata.csv` come diagnostica. Per la banda stagnata a 20 kHz vale
0.142 mm, confrontabile con lo spessore di 0.18 mm — cioè la deposizione è già
quasi uniforme attraverso la parete.
5. **Temperatura iniziale** — il campo parte uniformemente alla temperatura ambiente
del run (che è randomizzata, quindi varia run per run).
6. **Sensore realistico** — la lettura aggiunge alla temperatura vera della superficie
interna: inerzia del primo ordine (`costante_tempo_s`), rumore gaussiano
(`rumore_std_C`) e quantizzazione (`quantizzazione_C`).
6. **Sensore realistico** — la temperatura nel punto osservato è interpolata con le
funzioni di forma dell'elemento che lo contiene; la lettura vi aggiunge inerzia del
primo ordine (`costante_tempo_s`), rumore gaussiano (`rumore_std_C`) e
quantizzazione (`quantizzazione_C`).
### Perché una sola temperatura nello spessore
La parete è termicamente sottile con ampio margine. Il numero di Fourier che confronta
il tempo di diffusione attraverso lo spessore con il tempo di transito della sorgente,
```text
Fo = α · (σ/|v|) / s²
```
vale **5.4** con i parametri di default (ed è riportato per ogni run in
`metadata.csv`). Il modello 2D `(x, z)` precedente, che risolveva lo spessore con 15
nodi, dava un salto esterno–interno di **0.002 °C al picco** su una sovratemperatura
di ~200 °C, e 0.53 °C come massimo su tutto il run. Risolvere lo spessore non aggiunge
informazione a questi parametri.
Il criterio per sapere quando servirebbe una formulazione multistrato è `Fo ≈ 1`, cioè
uno spessore critico `s* = √(α σ/|v|)`:
| materiale | Fo a 0.18 mm | spessore critico |
|--------------------------|--------------|------------------|
| alluminio | 31.3 | 1.01 mm |
| ferro | 8.4 | 0.52 mm |
| banda stagnata / acciaio dolce | 5.4 | 0.42 mm |
| inox 304 | 1.5 | 0.22 mm |
## Metodo numerico
- Griglia a volumi finiti `n_nodi_x × n_nodi_z` (default 100 × 15); le incognite sono
i centri cella.
- Eulero implicito con passo `dt_interno_s` (default 0.2 ms), più fine del periodo di
campionamento CSV.
- Tutti i termini (diffusione, convezione, conduzione circonferenziale) sono lineari e
costanti nel run: la matrice sparsa viene costruita e **fattorizzata LU una sola
volta per run** (`scipy.sparse.linalg.splu`); ogni passo temporale risolve solo i
sistemi triangolari. Un run da 30 s simulati richiede ~20 s di calcolo.
- Mesh strutturata `n_elementi_x × n_elementi_theta` (default 100 × 110, cioè elementi
di 1.0 × 2.0 mm) per **11110 nodi**; la periodicità circonferenziale è strutturale,
non un vincolo imposto: non esiste un nodo separato per `θ = 2π`.
- Quadratura di Gauss 2×2 per tutte le matrici elementari e per il vettore della
sorgente. La mesh è uniforme, quindi tutti gli elementi sono lo stesso rettangolo:
le matrici elementari si calcolano una volta e si replicano.
- Eulero implicito (incondizionatamente stabile) con passo `dt_interno_s`
(default 1 ms), più fine del periodo di campionamento CSV.
- Tutti i termini sono lineari e costanti nel run: `A = C/dt + K_cond + K_conv` viene
**fattorizzata LU una sola volta per run** (`scipy.sparse.linalg.splu`); ogni passo
risolve solo i sistemi triangolari. `A` è simmetrica definita positiva, quindi si usa
l'ordinamento `MMD_AT_PLUS_A`, che dimezza circa il riempimento rispetto al COLAMD di
default. Un run da 30 s simulati richiede ~65 s di calcolo; i run sono generati in
parallelo su più processi.
- Se in futuro si introducessero proprietà dipendenti dalla temperatura, la matrice
andrebbe ricostruita e rifattorizzata a ogni passo.
### Validazione
`python valida_shell.py` verifica il solutore su casi con soluzione nota. Va rieseguito
dopo ogni modifica alla fisica o all'assemblaggio. Risultati con la mesh di default:
| Verifica | Esito |
|-------------------------------------------------|------------------------------------------|
| capacità totale = `ρ cp s A` | esatta a precisione macchina |
| somma righe di `K_cond` = 0 (T costante → flusso nullo) | 4·10⁻¹⁸ |
| simmetria e semidefinita positività di `K_cond` | verificate |
| raffreddamento convettivo uniforme vs `exp(−t/τ)` | errore 0.011 °C, pari a `dt/(2τ)` |
| conservazione dell'energia (adiabatico) | errore relativo 4·10⁻¹⁴ |
| `Σ f_src` vs potenza analitica `2πσ² q_max` | rapporto 1.0000; **0.5000** con sorgente centrata sul bordo |
| modi sinusoidali circonferenziali `n = 1, 2, 4` vs `exp(−α n²t/R²)` | errore 0.04% – 0.17% |
| convergenza al raffinamento (modo `n = 4`) | 2.75% → 1.07% → 0.17% → 0.05% da 30 a 220 elementi |
| simmetria della diffusione attorno a `θ = 0` | 2·10⁻¹⁴ |
L'ultima riga è la prova che la periodicità funziona davvero: un impulso su `θ = 0`
diffonde in modo identico nei due versi solo se la connettività riavvolge la
circonferenza.
## File
```text
config.py tutti i parametri di simulazione
materials.py proprietà termofisiche ed elettriche dei materiali
simulate.py motore fisico + generazione dei CSV
plot_csv.py grafici rapidi (temperature e flusso) del primo run
plot_animazione.py animazione della sezione: campo T(x,z), sorgenti, sensore
dataset/ output generato da simulate.py (ricreato a ogni esecuzione)
config.py tutti i parametri di simulazione
materials.py proprietà termofisiche ed elettriche dei materiali
mesh.py nodi, connettività Q4, periodicità circonferenziale
elementi_shell.py funzioni di forma, quadratura, matrici del singolo elemento
assemblaggio.py assemblaggio delle matrici globali e del vettore sorgente
sorgente.py moto degli induttori e distribuzione gaussiana del flusso
solutore.py integrazione implicita e fattorizzazione sparsa
sensore.py interpolazione, inerzia, rumore, quantizzazione
simulate.py orchestrazione dei run + generazione dei CSV
valida_shell.py verifiche del solutore su casi con soluzione nota
plot_csv.py grafici rapidi (temperature e flusso) del primo run
plot_animazione.py animazione della superficie sviluppata T(x, θ)
plot_animazione_3d.py animazione 3D isometrica del cilindro
dataset/ output generato da simulate.py (ricreato a ogni esecuzione)
```
## Installazione
@@ -127,19 +213,50 @@ python simulate.py
# grafici statici del primo run (temperatura e flusso nel tempo)
python plot_csv.py
# animazione della sezione durante il passaggio delle sorgenti
# animazione della superficie sviluppata durante il passaggio delle sorgenti
python plot_animazione.py
# animazione 3D isometrica del cilindro
python plot_animazione_3d.py
```
Gli script di visualizzazione aprono finestre interattive (backend Qt); se il backend
non è interattivo (es. sessione senza display) salvano automaticamente PNG/GIF in
`dataset/`.
L'animazione riproduce esattamente la fisica di `run_0001` (stesso seed) e mostra tre
pannelli allineati: il profilo di flusso `q(x)` con le sorgenti in transito, il campo
di temperatura nella sezione con il sensore IR, e la temperatura nel punto osservato
(vera e con inerzia del sensore). Finestra temporale e cadenza dei fotogrammi si
regolano con le costanti in testa a `plot_animazione.py`.
Entrambe le animazioni riproducono esattamente la fisica di `run_0001` (stesso seed).
Quella 2D mostra tre pannelli allineati: il profilo di flusso `q(x)` con le sorgenti in
transito, il campo di temperatura sulla superficie sviluppata in piano (asse verticale
= arco circonferenziale, con il sensore a quota 0), e la temperatura nel punto
osservato (vera e con inerzia del sensore). Quella 3D disegna il campo calcolato sulla
superficie del cilindro — non è più una ricostruzione, il modello risolve davvero la
distribuzione circonferenziale. Finestra temporale e cadenza dei fotogrammi si regolano
con le costanti in testa a `plot_animazione.py`.
La mappa sviluppata usa `pcolormesh` con shading Gouraud, che interpola linearmente tra
i valori nodali: è esattamente ciò che fanno le funzioni di forma bilineari del Q4,
quindi si guarda la soluzione dell'elemento finito e non un'interpolazione grafica.
### Vedere gli elementi shell
Entrambe le animazioni hanno una costante `MOSTRA_MESH` che disegna i bordi degli
elementi. È `False` di default perché con la mesh di produzione gli elementi sono
1 × 2 mm, più fitti dei pixel disponibili, e il reticolo coprirebbe il campo. Per
ispezionare la mesh servono due modifiche insieme:
```python
# in plot_animazione.py e/o plot_animazione_3d.py
MOSTRA_MESH = True
# in config.py, dentro FASCETTA
"n_elementi_x": 25,
"n_elementi_theta": 28,
```
Così si vedono i singoli quadrilateri, in piano e avvolti sul cilindro. Attenzione: con
28 elementi sulla circonferenza l'arco vale 7.9 mm contro un `sigma_punto_m` di 12 mm,
cioè meno di due elementi per sigma — la mesh grossolana serve a **guardare la
discretizzazione**, non a produrre risultati (vedi la tabella di convergenza sopra).
## Configurazione
@@ -148,8 +265,8 @@ Tutto si modifica in `config.py`. I dizionari principali:
| Dizionario | Contenuto |
|------------------|---------------------------------------------------------------------------|
| `SIMULAZIONE` | numero di run, durata, campionamento CSV, passo interno, seed, cartella |
| `FASCETTA` | diametro, lunghezza, spessore, griglia, conduzione circonferenziale, materiale |
| `ARIA` | temperatura ambiente e coefficienti di convezione dei quattro lati |
| `FASCETTA` | diametro medio, lunghezza, spessore, densità della mesh, materiale |
| `ARIA` | temperatura ambiente e coefficienti di convezione di facce e bordi |
| `SORGENTE` | corsa, velocità (il segno dà il verso), gruppo di sorgenti, gaussiana, flusso, frequenza |
| `SENSORE` | posizione (x e distanza dalla parete), inerzia, rumore, quantizzazione |
| `RANDOMIZZAZIONE`| entità delle perturbazioni per run |
@@ -191,26 +308,30 @@ Punti da conoscere:
| `skin_depth_m` | skin depth usata (costante nel run) |
| `T_vera_lato_sensore_C` | temperatura vera della superficie interna nel punto del sensore |
| `T_misurata_sensore_C` | lettura del sensore (inerzia + rumore + quantizzazione) |
| `T_lato_caldo_C` | temperatura della superficie esterna nello stesso punto x |
| `T_max_fascetta_C` | temperatura massima su tutta la superficie in quell'istante |
| `T_media_fascetta_C` | temperatura media su tutta la superficie in quell'istante |
| `T_ambiente_C` | temperatura ambiente del run |
| `velocita_m_s`, `sigma_punto_m`, `flusso_picco_W_m2` | parametri randomizzati del run |
| `materiale` | chiave del materiale |
### `dataset/metadata.csv` — una riga per run
Contiene tutti i parametri effettivi del run (geometria, griglia, coefficienti di
scambio, parametri delle sorgenti e del sensore, valori randomizzati) e le temperature
di picco vera e misurata: utile come ground truth e per filtrare i run.
Contiene tutti i parametri effettivi del run (geometria, dimensioni della mesh,
coefficienti di scambio, parametri delle sorgenti e del sensore, valori randomizzati),
le diagnostiche `skin_depth_m` e `numero_fourier_spessore`, e le temperature di picco:
utile come ground truth e per filtrare i run.
## Limitazioni
1. Il campo elettromagnetico non è simulato: l'accoppiamento induttivo è ridotto a
impronta gaussiana × efficienza × decadimento esponenziale in z.
2. La coordinata circonferenziale y non è risolta: offset del percorso e conduzione
verso il resto della fascetta sono modelli collassati (attenuazione gaussiana e
scambio lineare verso T ambiente).
un'impronta gaussiana moltiplicata per un'efficienza costante.
2. Lo spessore non è discretizzato: il modello non può rappresentare un gradiente tra
faccia esterna e faccia interna. Con i parametri di default il gradiente reale è di
pochi millesimi di grado (vedi `numero_fourier_spessore`), ma con pareti più spesse
di ~0.4 mm, materiali a bassa diffusività o sorgenti molto più veloci servirebbe una
shell multistrato.
3. Le proprietà dei materiali sono costanti con la temperatura; per gli acciai
ferromagnetici la skin depth reale varia fortemente con temperatura e campo
(punto di Curie non modellato).
4. Irraggiamento non modellato: a ~220 °C le perdite radiative non sono del tutto
4. Irraggiamento non modellato: a ~210 °C le perdite radiative non sono del tutto
trascurabili rispetto alla convezione.