-
.Immaginate ogni singolo poligono di mesh costituito da un materiale diverso.
Cosa può cambiare rispetto ad uno stesso materiale con caratteristiche diverse in funzione della temperatura diversa?
Le due situazioni sono simili e non vedo ostacoli alla implementazione del metodo.
Per di più col calcestruzzo armato precompresso stiamo già operando con un materiale composto da tre materiali diversi calcestruzzo, acciaio ordinario, ed acciaio da precompressione, e se includiamo il getto di completamento abbiamo il quarto materiale.
. -
.
Quindi Tex, mi stai confermando che rispetto allo Zaxcode, anche la funzione che determina le deformazioni limite (dalle quali poi ricavare le deformazioni in ogni punto della sezione) andrà in qualche modo modificata. . -
.Ma è qui che mi pare ci sia qualcosa che non va.
L'ipotesi di sezione
piana continua a mantenersi, qualsiasi sia la temperatura raggiunta nella sezione.
Ora, per determinare la deformazione del baricentro del generico triangolino io ho necessità di conoscere la deformazione massima sul bordo superiore della trave, oppure sul bordo inferiore.
Diciamo pure che mantenere ferma l'ipotesi di mantenimento delle sezioni piane è la più grande forzatura che si possa imporre nel caso di analisi di resistenza termica. Lo era già senza gli effetti termici lo è ancor di piu' nel caso di andamento variabile della temperatura punto a punto.
Mi pare pero' di aver letto che l'analisi avviene ipotizzando una deformata della sezione a freddo ed applicando le riduzioni alle tensioni in funzioni della temperatura assunta nel punto. Penso di dover leggere meglio questo aspetto.. -
.
Comunque io sto cominciando ad intuire cosa sta facendo Tex partendo dallo Zaxcode.
Se vi ricordate l'algoritmo prevedeva l'utilizzo di sezioni costituite da più poligoni. In questo modo si potevano gestire sezioni con vuoti all'interno, con porzioni (tipicamente travi in c.a.p. con solette in seconda fase) di differente caratteristiche meccaniche, ecc.
Ma io avevo 'bloccato' il mio codice alla gestione di un massimo di 6 poligoni.
Ma avendo riletto Tex che accenna a gestione dinamica della memoria, starei capendo che Tex di fatto non ha nessun bisogno di modificare nulla. Ogni singolo triangolo/quadrangolo della mesh utilizzata per la mappatura termica è di fatto un poligono. Tex deve solamente 'sbloccarne' (in maniera dinamica) il numero massimo gestibile, in modo da portarlo a 100-1000-10000, fino a che insomma la memoria ce la fa.
Egli deve poi solamente 'generare' il legame costitutivo ad hoc per ogni singolo elemento in funzione della temperatura.
Anche la funzione che determina le deformazioni limite ai punti 'estremi' della sezione riesce a tenere conto di poligoni con materiali che possano avere deformazioni limite del legame costitutivo differente (forse proprio qui, comunque, qualche modifica andrà fatta).
A questo punto intuisco anche il motivo per cui sempre Tex accenna alla scarsa efficienza dell'algoritmo.
Perchè se così fosse, anche per triangoli di pochi cm, l'algoritmo continua ad 'affettare' le parti compresse, invece di accontentarsi di un valore un pò più grossolano.
E concludo: ma tu guarda un pò la 'versatilità' dello Zaxcode!. -
.
@afazio
Noi stiamo per produrre un modello di calcolo alternativo a quello che ricordi (presumo ti riferisca al metodo semplificato del limite isobaro dei 500°C).
La novità della nuova procedura che non credo abbia precedenti, stà appunto nell'utilizzo di legami costitutivi modificati in funzione della temperatura media (baricentrica) dei sottopoligoni analizzati.
Dovremmo aspettarci di ottenere risultati più precisi rispetto ai metodi semplificati sinora utilizzati.. -
.CITAZIONEA questo punto intuisco anche il motivo per cui sempre Tex accenna alla scarsa efficienza dell'algoritmo.
Perchè se così fosse, anche per triangoli di pochi cm, l'algoritmo continua ad 'affettare' le parti compresse, invece di accontentarsi di un valore un pò più grossolano.
E concludo: ma tu guarda un pò la 'versatilità' dello Zaxcode!
In effetti la lentezza del calcolo oltre a questo è dovuta anche all'utilizzo di software di terze parti, seppure open-source, e poi c'è anche un problema di interfacciamento ed importazione dati.
Come dato indicativo la immagine della trave che ho postato ha una mesh triangolare di lato max 2cm ed è composta da 5656 elementi ed è stata bruciata a 90'.
Per velocizzare il calcolo da parte nostra possiamo modulare la dimensione minima della fibra, e ricordo che questa modifica al codice di zax che ho fatto a suo tempo fu segnalata da reversi.. -
.Per velocizzare il calcolo da parte nostra possiamo modulare la dimensione minima della fibra, e ricordo che questa modifica al codice di zax che ho fatto a suo tempo fu segnalata da reversi.
Ma secondo me nemmeno quello...
Basta 'entrare' nel singolo triangolino, capire dalla deformazione che esso è in compressione (o per lo meno il suo baricentro) e tramite il legame costitutivo risalire alla tensione.
Il contributo di tale triangolino alla N è quindi sigma*area_triangolo, allo Mrx è sigma*area_triangolo*yg, allo Mry è sigma *area_triangolo*xg
Dove xg e yg, sono le coordinate del baricentro del triangolino rispetto al baricentro della sezione 'tutta'.
Tutto qui. Abbastanza approssimato magari, ma con unica 'passata' si fa tutto quel che si deve.
Se si vuole maggiore 'finezza' basterà raffittire la mesh.. -
.
@zax
La tua proposta di modifica del codice è interessante, ma potremmo svilupparla in seconda fase.
Il primo obiettivo da raggiungere per quanto lento sia il procedimento è ricavare un risultato valido.
Dopo i perfezionamenti si potranno fare a piacimento.. -
.
Ora presento la formulazione del diagramma tensioni/deformazioni del calcestruzzo sottoposto ad alte temperature, per il ramo discendente ho usato un andamento lineare, dato che di quello curvilineo possibile anch'esso non ho trovato la debita documentazione, inoltre non considero la piccola resistenza a trazione a favore di sicurezza. CODICE'----------------------------------------------------------------------------------------------
' Funzione che determina i parametri del legame costitutivo del cls riscaldato
' dati in ingresso:
' fck --> resistenza cilindrica del calcestruzzo a 20°C
' T --> temperatura in °C
' sc --> 1 per aggregato siliceo, 2 per aggregato calcareo
' po --> 1 per calcestruzzo da precompressione, 2 per il calcestruzzo ordinario
' dati in uscita:
' epsc0 --> deformazione cuspide del legame costitutivo alla temperatura T
' epscu --> deformazione ultima del legame costitutivo alla temperatura T
' autore: Tex
' data: Agosto 2014
'----------------------------------------------------------------------------------------------
Public Sub valori_cls_fire(fck As Double, T As Double, sc As Integer, po As Integer, epsc0 As Double, epscu As Double, fd As Double)
'trovo il coefficiente moltiplicatore in funzione della temperatura
Dim cr As Double
If sc = 1 Then
Select Case T
Case Is < 20#
fd = fck
epsc0 = 0.0025
epscu = 0.02
Case 20# To 100#
cr = CfIntLin(20#, 100#, T, 1#, 1#)
fd = cr * fck
epsc0 = CfIntLin(20#, 100#, T, 0.0025, 0.004)
epscu = CfIntLin(20#, 100#, T, 0.02, 0.0225)
Case 100# To 200#
...........................................................................
Case Is > 1200#
fd = 0#
epsc0 = 0.025
epscu = 0.0475
End Select
Else
Select Case T
Case Is < 20#
fd = fck
epsc0 = 0.0025
epscu = 0.02
Case 20# To 100#
cr = CfIntLin(20#, 100#, T, 1#, 1#)
fd = cr * fck
epsc0 = CfIntLin(20#, 100#, T, 0.0025, 0.004)
epscu = CfIntLin(20#, 100#, T, 0.02, 0.0225)
Case 100# To 200#
.........................................................................
Case Is > 1200#
fd = 0#
epsc0 = 0.025
epscu = 0.0475
End Select
End If
If po = 1 Then
fd = 0.85 * fd / gammap
Else
fd = 0.85 * fd / gammac
End If
End Sub
'----------------------------------------------------------------------------------------------
' Interpolazione lineare
' dati in ingresso:
' T1 --> temperatura punto A
' T2 --> temperatura punto B
' T3 --> temperatura punto C interno alla linea congiungente A con B
' A --> valore in A
' B --> valore in B
' dati in uscita:
' restituisce il valore C interpolato
' autore: Tex
' data: Agosto 2014
'----------------------------------------------------------------------------------------------
Private Function CfIntLin(T1 As Double, T2 As Double, T3 As Double, A As Double, B As Double) As Double
Dim denom As Double
denom = T2 - T1
If denom = 0# Then
CfIntLin = (A + B) / 2
Else
CfIntLin = A + (T3 - T1) * (B - A) / (T2 - T1)
End If
End Function
'----------------------------------------------------------------------------------------------
' legame deformazioni-sforzo del calcestruzzo riscaldato ad alte temperature
' dati in ingresso:
' def --> deformazione
' fd --> resistenza massima del calcestruzzo alla temperatura T
' epsc0 --> deformazione cuspide del legame costitutivo alla temperatura T
' epscu --> deformazione ultima del legame costitutivo alla temperatura T
' dati in uscita:
' tensione corrispondente alla deformazione def
' autore: Tex
' data: Agosto 2014
'----------------------------------------------------------------------------------------------
Public Function legame_cls_fire(def As Double, epsc0 As Double, epscu As Double, fd As Double) As Double
Select Case def
Case Is >= epsc0
'tratto discendente lineare
legame_cls_fire = CfIntLin(epsc0, epscu, def, fd, 0#)
Case Is <= 0#
legame_cls_fire = 0#
Case Else
legame_cls_fire = 3 * def * fd / (epsc0 * (2# + (def / epsc0) ^ 3))
End Select
End Function
Edited by texitaliano64 - 20/8/2014, 20:36Attached Image
. -
.
Ecco quà la formulazione dei legami costitutivi dell'acciaio ordinario e di quello da pretensione riscaldato ad alte temperature: CODICE'----------------------------------------------------------------------------------------------
' sub che determina i parametri del legame costitutivo dell'acciaio lento riscaldato
' dati in ingresso:
' fyk --> resistenza acciaio a 20°C
' Es --> modulo tangente a 20°C
' T --> temperatura in °C
' nx --> 1 per classe N, 2 per classe X
' lc_tf --> 1 per laminato a caldo, 2 per trafilato a freddo
' dati in uscita:
' fsp_teta --> tensione oltre la quale inizia il tratto curvo
' fsy_teta --> tensione dove inizia il tratto orrizzontale
' Es_teta --> modulo secante primo tratto rettilineo
' autore: Tex
' data: Agosto 2014
'----------------------------------------------------------------------------------------------
Public Sub valori_steel_fire(fyk As Double, Es As Double, T As Double, nx As Integer, lc_tf As Integer, _
fsy_teta As Double, fsp_teta As Double, Es_teta As Double)
'trovo il coefficiente moltiplicatore in funzione della temperatura
Dim cr As Double
If nx = 1 Then
'Classe N
If lc_tf = 1 Then
'laminato a caldo
Select Case T
Case Is < 20#
fsy_teta = fyk
fsp_teta = fyk
Es_teta = Es
Case 20# To 100#
cr = CfIntLin(20#, 100#, T, 1#, 1#)
fsy_teta = cr * fyk
cr = CfIntLin(20#, 100#, T, 1#, 1#)
fsp_teta = cr * fyk
cr = CfIntLin(20#, 100#, T, 1#, 1#)
Es_teta = cr * Es
Case 100# To 200#
..........................................................
Case Is > 1200#
fsy_teta = 0#
fsp_teta = 0#
Es_teta = 0#
End Select
Else
'trafilato a freddo
Select Case T
Case Is < 20#
fsy_teta = fyk
fsp_teta = fyk
Es_teta = Es
Case 20# To 100#
cr = CfIntLin(20#, 100#, T, 1#, 1#)
fsy_teta = cr * fyk
cr = CfIntLin(20#, 100#, T, 1#, 0.96)
fsp_teta = cr * fyk
cr = CfIntLin(20#, 100#, T, 1#, 1#)
Es_teta = cr * Es
Case 100# To 200#
..............................................................
Case Is > 1200#
fsy_teta = 0#
fsp_teta = 0#
Es_teta = 0#
End Select
End If
Else
'Classe X
'laminato a caldo e trafilato a freddo
Select Case T
Case Is < 20#
fsy_teta = fyk
fsp_teta = fyk
Es_teta = Es
Case 20# To 100#
cr = CfIntLin(20#, 100#, T, 1#, 1#)
fsy_teta = cr * fyk
cr = CfIntLin(20#, 100#, T, 1#, 1#)
fsp_teta = cr * fyk
cr = CfIntLin(20#, 100#, T, 1#, 1#)
Es_teta = cr * Es
Case 100# To 200#
..........................................................
Case Is > 1200#
fsy_teta = 0#
fsp_teta = 0#
Es_teta = 0#
End Select
End If
End Sub
'----------------------------------------------------------------------------------------------
' sub che determina i parametri del legame costitutivo dell'acciaio da pretensione riscaldato
' dati in ingresso:
' fpk --> tensione caratteristica di snervamento trefoli a 20°C
' fp1k --> tensione caratteristica all'1% di deformazione sotto carico (0.9*fpk) a 20°C
' Ep --> modulo di elasticità trefoli a 20°C
' T --> temperatura in °C
' ClAB --> 1 per classe A, 2 per classe B
' FilTrefBar --> 1 per filo, 2 per trefolo, 3 per barra
' dati in uscita:
' fpp_teta --> tensione oltre la quale inizia il tratto curvo
' fpy_teta --> tensione dove inizia il tratto orrizzontale
' Es_teta --> modulo secante primo tratto rettilineo
' epspt_teta --> deformazione in cui inizia il tratto discendente, per acciaio ordinario 0.15
' epspu_teta --> deformazione ultima, per acciaio ordinario 0.2
' autore: Tex
' data: Agosto 2014
'----------------------------------------------------------------------------------------------
Public Sub valori_steelp_fire(fpk As Double, fp1k As Double, Ep As Double, T As Double, Cl_AB As Integer, FilTrefBar As Integer, _
fpy_teta As Double, fpp_teta As Double, Es_teta As Double, epspt_teta As Double, epspu_teta As Double)
'trovo il coefficiente moltiplicatore in funzione della temperatura
Dim cw As Double
Dim qt As Double
Dim Beta As Double
'trovo il coefficiente Beta
Beta = trova_beta(fpk, fp1k, eud, euk, Ep, Cl_AB)
Select Case FilTrefBar
Case 1, 2
'fili e trefoli
Select Case Cl_AB
Case 1
'Classe A
Select Case T
Case Is < 20#
fpy_teta = Beta * fpk
fpp_teta = Beta * fpk
fpp_teta = Ep
epspt_teta = 0.05
epspu_teta = 0.1
Case 20# To 100#
cw = CfIntLin(20#, 100#, T, 1#, 1#)
fpy_teta = cw * Beta * fpk
cw = CfIntLin(20#, 100#, T, 1#, 0.68)
fpp_teta = cw * Beta * fpk
cw = CfIntLin(20#, 100#, T, 1#, 0.98)
fpp_teta = cw * Ep
epspt_teta = CfIntLin(20#, 100#, T, 0.05, 0.05)
epspu_teta = CfIntLin(20#, 100#, T, 0.1, 0.1)
Case 100# To 200#
.....................................................................
Case Is > 1200#
fpy_teta = 0#
fpp_teta = 0#
fpp_teta = 0#
epspt_teta = 0.1
epspu_teta = 0.15
End Select
Case 2
'Classe B
Select Case T
Case Is < 20#
fpy_teta = Beta * fpk
fpp_teta = Beta * fpk
fpp_teta = Ep
epspt_teta = 0.05
epspu_teta = 0.1
Case 20# To 100#
cw = CfIntLin(20#, 100#, T, 1#, 0.99)
fpy_teta = cw * Beta * fpk
cw = CfIntLin(20#, 100#, T, 1#, 0.68)
fpp_teta = cw * Beta * fpk
cw = CfIntLin(20#, 100#, T, 1#, 0.98)
fpp_teta = cw * Ep
epspt_teta = CfIntLin(20#, 100#, T, 0.05, 0.05)
epspu_teta = CfIntLin(20#, 100#, T, 0.1, 0.1)
Case 100# To 200#
..........................................................................
Case Is > 1200#
fpy_teta = 0#
fpp_teta = 0#
fpp_teta = 0#
epspt_teta = 0.1
epspu_teta = 0.15
End Select
End Select
Case 3
'barre
Select Case T
Case Is < 20#
fpy_teta = Beta * fpk
fpp_teta = Beta * fpk
fpp_teta = Ep
epspt_teta = 0.05
epspu_teta = 0.1
Case 20# To 100#
qt = CfIntLin(20#, 100#, T, 1#, 0.98)
fpy_teta = qt * Beta * fpk
qt = CfIntLin(20#, 100#, T, 1#, 0.77)
fpp_teta = qt * Beta * fpk
qt = CfIntLin(20#, 100#, T, 1#, 0.76)
fpp_teta = qt * Ep
epspt_teta = CfIntLin(20#, 100#, T, 0.05, 0.05)
epspu_teta = CfIntLin(20#, 100#, T, 0.1, 0.1)
Case 100# To 200#
............................................................................
Case Is > 1200#
fpy_teta = 0#
fpp_teta = 0#
fpp_teta = 0#
epspt_teta = 0.1
epspu_teta = 0.15
End Select
End Select
End Sub
'----------------------------------------------------------------------------------------------
' funzione per calcolare il coefficiente Beta
' ingresso:
' fpk --> tensione caratteristica di snervamento trefoli
' fp1k --> tensione caratteristica all'1% di deformazione sotto carico (0.9*fpk)
' Ep --> modulo di elasticità trefoli
' Cl_AB --> 1 per classe A, 2 per classe B
' uscita:
' Beta
' autore: Tex
' data: agosto 2014
'----------------------------------------------------------------------------------------------
Private Function trova_beta(fpk As Double, fp1k As Double, Ep As Double, Cl_AB As Integer) As Double
'euk = 0.035 deformazione di rottura 35 per mille
Const euk As Double = 0.035
'limite di deformazione nel caso di tratto incrudente
Dim eud As Double
eud = 0.9 * euk
Dim Beta As Double
If Cl_AB = 1 Then
'Classe A
Beta = ((eud - fp1k / Ep) / (euk - fp1k / Ep)) * ((fpk - fp1k) / fpk) + fp1k / fpk
Else
'Classe B
Beta = 0.9
End If
trova_beta = Beta
End Function
'----------------------------------------------------------------------------------------------
' legame deformazioni-sforzo dell'acciaio ordinario e da pretensione riscaldato ad alte temperature
' dati in ingresso:
' def --> deformazione
' fsp_teta --> tensione oltre la quale inizia il tratto curvo
' fsy_teta --> tensione dove inizia il tratto orrizzontale
' Es_teta --> modulo secante primo tratto rettilineo
' opzionali:
' epsst_teta --> deformazione in cui inizia il tratto discendente, per acciaio ordinario 0.15
' epssu_teta --> deformazione ultima, per acciaio ordinario 0.2
' dati in uscita:
' tensione corrispondente alla deformazione def
' autore: Tex
' data: Agosto 2014
'----------------------------------------------------------------------------------------------
Public Function legame_steel_fire(def As Double, Es_teta As Double, fsp_teta As Double, fsy_teta As Double, _
Optional epsst_teta As Double = 0.15, Optional epssu_teta As Double = 0.2) As Double
Dim epssp_teta As Double
Dim epssy_teta As Double
epssp_teta = fsy_teta / Es_teta
epssy_teta = 0.02
Dim a As Double
Dim b As Double
Dim c As Double
c = (fsy_teta - fsp_teta) ^ 2 / ((epssy_teta - epssp_teta) * Es_teta - 2# * (fsy_teta - fsp_teta))
a = ((epssy_teta - epssp_teta) * (epssy_teta - epssp_teta + c / Es_teta)) ^ 0.5
b = (c * (epssy_teta - epssp_teta) * Es_teta + c ^ 2) ^ 0.5
Dim eps As Double
eps = Abs(def)
Dim sigma As Double
Select Case eps
Case Is <= epssp_teta
sigma = eps * Es_teta
Case epssp_teta To epssy_teta
sigma = fsp_teta - c + (b / a) * (a ^ 2 - (epssy_teta - eps) ^ 2) ^ 0.5
Case epssy_teta To epsst_teta
sigma = fsy_teta
Case epsst_teta To epssu_teta
sigma = fsy_teta * (1# - (eps - epsst_teta) / (epssu_teta - epsst_teta))
Case Is >= epssu_teta
sigma = 0#
End Select
legame_steel_fire = Sgn(def) * sigma
End Function
Edited by texitaliano64 - 20/8/2014, 20:37Attached Image
. -
.
Tex, Tex.....io presentivo che sarebbe andata a finire così......
Ma debbo rimproverarti.
Se continui a pubblicare solamente codice, alla fine non riuscirà a seguirti più nessuno.
Vedo che hai pubblicato i diagrammi dell'EC2 relativo all'incendio.
Ma almeno due paroline su calcestruzzo calcareo e siliceo che secondo tale norma hanno curve differenti (e sfido chiunque all'istante a rispondersi se il cls che ha sempre utilizzato è calcareo o siliceo).
Prima del codice pubblicare le tabelle che EC2 riporta, in modo da cercare di capire cosa fanno le varie funzioni che pubblichi, e perchè....Prima del codice pubblicare le formule (in bella, riprese pari da EC2) che il codice riprende....
Insomma, un minimo di commento....
Capisco che tu sia tutto codice e distintivo, e che ritieni che il codice parli da solo, ma qui buona parte dei lettori non è programmatore.
Aggiungo che vedo la sfila di case nelle funzioni che riprendono degli input puntuali e tabellari.....ebbene, per Califfo nel caso del diagramma Ny di Terzaghi, ma anche per altri enne-gammisti che fornivano una semplice tabella di valori 'discreti' da interpolare linearmente, avevamo sviluppato qualcosa di molto più generale e conciso.
Sentitamente, e senza alcuna offesa, Zax.. -
.Aggiungo che vedo la sfila di case nelle funzioni che riprendono degli input puntuali e tabellari.....ebbene, per Califfo nel caso del diagramma Ny di Terzaghi, ma anche per altri enne-gammisti che fornivano una semplice tabella di valori 'discreti' da interpolare linearmente, avevamo sviluppato qualcosa di molto più generale e conciso.
stralcio di codice che si potrebbe pure pubblicare qui per dare un piccolo aiuto a tex.... -
.
@zax
OK, è che ero preso nei meandri del codice,ed ero impaziente di pubblicarlo via via che procede il lavoro, davo per scontato che chi legge questa sezione del forum mastichi un qualche linguaggio di programmazione, e che ognuno di noi abbia già scaricato la norma in oggetto, comunque vedrò di rimediare prossimamente.
@zax+reversi
Il discorso sul come attualmente ho implementato i dati tabellari fa ribrezzo anche a mè, (è più bella la Gioconda di Leonardo o i bronzi di Riace?) avrei dovuto usare qualche tecnica più raffinata, ma per ora il mio primo obiettivo è quello di far girare il codice per ricavare un risultato utile.
Potevo inserire le tabelle in fogli di excel, oppure riempire delle matrici, o caricarle da file, le possibilità sono tante più o meno flessibili.
Miglioramenti se ne potranno fare anche in fase successiva, quando tutto funzioni a dovere.. -
.Capisco che tu sia tutto codice e distintivo, e che ritieni che il codice parli da solo, ma qui buona parte dei lettori non è programmatore.
Non fatevi problemi, né qui, né altrove, per i non programmatori; al più si legge molto velocissimamente e si passa avanti.
@ tex: io voto per gli (s)tronzi di Riace.. -
.
Dunque, prima pubblico il codice contenuto in Califfo, perchè Reversi ha ragione.
Innanzitutto una struttura dati:CODICEstruct punti_diagramma
{
float asc[100];
float ord[100];
int numpunti;
};
Si tratta banalmente dei punti che in EC2 sono tabellati. In ascissa ci saranno le temperature. In ordinata ..... quello che si vuole (valori riduttivi di fck in funzione della temperatura, valori del diagramma cls calcareo, siliceo, armatura ordinaria, acciaio armonico).
In Califfo la funzione era stata pensata solamente per i diagrammi Ny di Terzaghi, Martin, Kunbhojkar.
Ovviamente si dovranno dichiarare più variabili di tipo struct punti_diagramma, inserendo preliminarmente i valori tabellati (tra cui il numero di punti che al massimo compongono il diagramma).
Poi abbiamo una unica funzione (il cui nome deriva dalla unica variabile che ci interessava gestire Ny_interpola):CODICEint Ny_interpola(float fi,float *ny,struct punti_diagramma ny1grado)
{
int register k;
if (fi<ny1grado.asc[0] || fi>ny1grado.asc[ny1grado.numpunti-1]) return(-1);
for (k=0;k<=ny1grado.numpunti-2;k++)
{
if (fi>ny1grado.asc[k] && fi<=ny1grado.asc[k+1])
*ny=ny1grado.ord[k]+(ny1grado.ord[k+1]-ny1grado.ord[k])*(fi-ny1grado.asc[k])/(ny1grado.asc[k+1]-ny1grado.asc[k]);
}
return (0);
}
Il primo parametro in ingresso, fi, sarebbe in effetti una ascissa generica (nel tuo caso temperatura), il secondo parametro, passato per indirizzo, è il valore che la funzione dovrà restituire. Il terzo parametro in ingresso è infine la struttura dati dove sono contenuti i vari valori tabellari.
La funzione restituisce un valore int che tipicamente sarà 0, per indicare che tutto è andato a buon fine, -1 per indicare che il parametro ascissa è fuori dai valori minimo e massimo tabellati per le ascisse.
Tipicamente il suo utilizzo all'interno di un listato sarebbe:CODICEcod_err=Ny_interpola(temp,&val,valtab)
Dove temp è l'ascissa, val è la corrispondente ordinata interpolata del diagramma, una variabile float passata per indirizzo, valtab la variabile strutturata di tipo struct punti_diagramma.
Detto questo, è vero come dice Salvatore, ovvero che il non programmatore probabilmente legge velocissimamente e non guarda al listato, però anche io che quasi-programmatore sono (nel senso che conosco le basi, ed un linguaggio), poichè probabilmente sono più ingegnere che quasi programmatore, preferirei prima affrontare la questione con tanto di tabelle, formule e numeri. Insomma un minimo di base teorica.
Con quello diventa lievemente più semplice andare a guardare il listato. Intuirne meglio il funzionamento, e perchè no, proporne variazioni e migliorie.....
Detto questo, non voglio che Tex si senta rimproverato. E' che io ho sempre avuto difficoltà ad 'infilarmi' nei listati altrui.
Quindi procedi pure come meglio preferisci. Io ho semplicemente detto la mia..
FIRE 2D |
