-
.Comunque come prima cosa devo cercare di ricostruire un file funzionante unendo i vari pezzi di codice... se permettete mi sembra assurdo...
Hai ragione... vedremo
. -
g.iaria .
User deleted
Generazione in automatico di una serie di sezioni predefinite, generazione di barre di armature in funzione di una serie di parametri, controlli sulle armature (esempio interne alla sezione in cls)....
Comunque come prima cosa devo cercare di ricostruire un file funzionante unendo i vari pezzi di codice... se permettete mi sembra assurdo...
Direi che se vuoi iniziare a proporre quello che hai scritto sopra lo puoi tranquillamente fare senza la necessità di ricomporre il codice, trattandosi comunque di cose prelinari alla fase di analisi.
Se permetti, inoltre, la cosa assurda é pretendere di avere un "file funzionante". Ognuno ha tutti gli strumenti per crearselo da sé il "file funzionante", dato che sono liberamente pubblicati, cosa peraltro unica nel web, da quel che ne so.
Non é mai stato obiettivo della trattazione fornire "file funzionanti".
Edited by g.iaria - 13/2/2014, 09:19. -
p.luciani .
User deleted
Ok... appena ho un po' di tempo cerco di riassemblare il tutto... mi sembra che manchi la procedura per il calcolo del dominio... potresti indicarmi dove trovarla??? grazie . -
g.iaria .
User deleted
Ok... appena ho un po' di tempo cerco di riassemblare il tutto... mi sembra che manchi la procedura per il calcolo del dominio... potresti indicarmi dove trovarla??? grazie
Eccola:CODICE' --------------------------------------------------------------------------
' Nome sub calcola_dominio(
' Scopo funzione : Facendo ruotare fittiziamente la sezione determina le
' coppie di punti mrx,mry per costruire il dominio di
' rottura per dato valore di sforzo normale.
' Parametri formali: Nd=sforzo normale di sollecitazione.
' Valore restituito: Struttura dati con varie informazioni: risultanti di
' compressione e trazione, posizioni risultanti, posizio-
' ne asse neutro, deformazioni limite a rottura sezione
' Implementazione : Luglio 2011
' Autore : Zax2010
' --------------------------------------------------------------------------
Sub calcola_dominio(ByRef dom As dominio_rottura)
Dim k As Integer
Dim np As Integer
Dim step As Integer
Dim polic() As poligono_sezione
ReDim polic(N_POLI)
Dim armc As armature_sezione
Dim Nfin As risultante_n_finale
Dim xc As Double
Dim yc As Double
Dim xt As Double
Dim yt As Double
Dim alfa As Double
Dim c As Double
Dim s As Double
PiGreco = 4 * Atn(1)
Delta_alfa = 2 * PiGreco / NMAXDOM
For step = 1 To NMAXDOM
alfa = step * Delta_alfa
c = Cos(alfa)
s = Sin(alfa)
For np = 1 To N_POLI
polic(np) = poli(np)
For k = 1 To polic(np).numv
polic(np).x(k) = poli(np).x(k) * c + poli(np).y(k) * s
polic(np).y(k) = -poli(np).x(k) * s + poli(np).y(k) * c
Next
Next
armc = arm
For k = 1 To arm.numarm
armc.x(k) = arm.x(k) * c + arm.y(k) * s
armc.y(k) = -arm.x(k) * s + arm.y(k) * c
Next
Nfin = asse_neutro_SLU(polic, armc, dom.Nd)
' Ripristina il sistema di riferimento delle risultanti
xc = Nfin.ncf.x * c - Nfin.ncf.y * s
yc = Nfin.ncf.x * s + Nfin.ncf.y * c
xt = Nfin.ntf.x * c - Nfin.ntf.y * s
yt = Nfin.ntf.x * s + Nfin.ntf.y * c
dom.mrx(step) = Nfin.ncf.N * (yc - yg) + Nfin.ntf.N * (yt - yg)
dom.mry(step) = Nfin.ncf.N * (xc - xg) + Nfin.ntf.N * (xt - xg)
dom.ang(step) = alfa
dom.nrc(step) = Nfin.ncf.N
dom.nrt(step) = Nfin.ntf.N
dom.xrc(step) = xc
dom.yrc(step) = yc
dom.xrt(step) = xt
dom.yrt(step) = yt
dom.epsc(step) = Nfin.epsc
dom.epss(step) = Nfin.epss
dom.yn(step) = Nfin.yn
dom.curv(step) = Nfin.curv
Next
End Sub. -
p.luciani .
User deleted
g.iaria ti ringrazio per la solerzia con la quale mi hai risposto... Premetto che non voglio darti il cordoglio in quanto sicuramente non sono un bravo programmatore... Vorrei comunque cercare di mettere in piedi una procedura che consenta di calcolarmi un dominio SLU di una sezione generica. Da un punto di vista teorico seguirei i seguenti passi:
1) Determino Nmax e -Nmin ultime della sezione generica
2) Definisco il numero di step per i quali calcolare gli mrx e mry (magari da -Nmin a 0 3 step e da o a +Nmax 13 step per un totale di 16 step.)
3) Per la data N comincio a calcolarmi gli mrx e mry per i 4 quadranti facendo ruotare la sezione da 0 a 360° e registro i valori del momento ultimo
4) proietto il momento ultimo nelle direzioni degli assi principali di inerzia
5) riconversione mx,my al passo dell'angolo di rotazione della sezione.
Ora a dirsi è facile far funzionare il tutto è complesso...
A I U T O ....
Potreste fornirmi tutti gli ingredienti per fare la torta???? Grazie anticipatamente. -
.
Rendo pubblico l'ultima versione del file per il calcolo/verifica di una sezione generica con tracciamento del dominio e con incluse le armature di precompressione:
VerSectZaxCap
Il nome è quello che ha dato Tex.
Note:
- chiunque può farne l'uso che vuole compreso il prelevamento e l'inserimento del codice in un suo programma commerciale; può o non può mantenere le note degli autori/traduttori/modificatori; può prenderlo e se ci riesce anche venderlo e comprarsi il gelato al pistacchio (che gli facesse acidità).
- è però gradita la discussione e la ripubblicazione di eventuali migliorie o aggiunte. In questo caso il pistacchio gli facesse giovamento.. -
p.luciani .
User deleted
Ciao Afazio,
eccomi qui a ringraziarti per la condivisione del file... in questi giorni nei ritagli di tempo ho cercato di "studiare" il file e devo dire che è veramente pazzesco.... complimenti a tutti perché veramente non c'è programma commerciale che tenga...
In questi giorni non ho avuto molto tempo ma per mantenere la promessa ho scritto qualche riga di codice per agevolare l'input sia dei poligoni che delle armature... Ovviamente nulla a che vedere con quanto fatto...
1. Aggiunto tasto "SEZIONI TIPO" dove sono contemplate diverse sezioni ricorrenti
2. Aggiunta generazione di ferri lineare
3. Aggiunta generazione di ferri circolare
Condivido il file:
https://app.box.com/s/1p0e9fjlg1gm5hc5ukvx
Facendo qualche prova ho apportato una piccola modifica per farlo girare anche su office 2003. Ovvero nella sub "TEST_SLE" ho modificato ActiveSheet.ChartObjects("Grafico 1") con ActiveSheet.ChartObjects(1) in quanto non funzionava.
Inoltre facendo alcune prove nella SUB "TEST_SLU" ho notato che eliminando i cavi di precompressione non veniva più considerato lo sforzo normale... Ovvero calcolava sempre il dominio per N=0. Quindi ho modificato il coldice in questo modo
CODICE ORIGINALE
soll(25 + n_c).n = Ndt
CODICE MODIFICATO
soll(25 + n_c).n = Ndt + soll(25 + n_c).n
Inoltre ho modificato il codice che elimina i valori del dominio all'inizio della sub "TEST_SLU" con un più snello ClearContents.
Questo velocizza di molto il tutto...
CHIEDO ANTICIPATAMENTE SCUSA A TUTTI PER LA FORMA DEL CODICE SCRITTO... CHE SICURAMENTE NON BADA MOLTO ALLA FORMA.... -
.
luciani ha appena postato, quindi è evidente che al momento nessuno ha controllato le modifiche ma, sulla fiducia in quello che ha dichiarato, gli faccio i miei complimenti. . -
p.luciani .
User deleted
Volendo fare un appunto ho notato che tutto il codice é scritto facendo riferimento a ...worksheets(1)... o worksheets(2).... questo risulta abbastanza scomodo se ad esempio si cambia la posizione dei fogli o se si inserisce un nuovo foglio.... forse sarebbe preferibile aggiornare il tutto con activesheet... cosa ne pensate???? . -
.
ripropongo una sub estratta dal codice di luciani in cui ho inserito i miei commenti: CODICESub genera_armature_circolari()
Dim nbarre As Integer
Range(Cells(5, 25), Cells(5 + 500, 27)).ClearContents
riga_rif = 5
colonna_rif = 25
PiGreco = 3.14159265358979
discreticcazione = 10 'non è utilizzato mai
Diametro = Cells(45, 17 + 3)
passo = Cells(45, 17 + 1)
sviluppo = PiGreco * Cells(45, 17)
If Cells(45, 17 + 1) = "" Then
nbarre = Cells(45, 17 + 2)
Cells(45, 17 + 1) = sviluppo / nbarre
Else
nbarre = sviluppo / Cells(45, 17 + 1)
Cells(45, 17 + 2) = Int(sviluppo / Cells(45, 17 + 1))
End If
'centro raggio
Raggio = Cells(45, 17)
t = 360 / nbarre 'che bisogno c'è di fare questo calcolo in gradi da trasformare poi in radianti?
PiGreco = 3.14159265358979 'è stato già definito
For ii = 0 To nbarre - 1
yy = Raggio * Cos(t * ii * PiGreco / 180) 'la trasformazione in radianti di cui sopra
xx = Raggio * Sin(t * ii * PiGreco / 180) 'la trasformazione in radianti di cui sopra
Cells(riga_rif + ii, colonna_rif) = xx
Cells(riga_rif + ii, colonna_rif + 1) = yy
Cells(riga_rif + ii, colonna_rif + 2) = Diametro
Next ii
Call TEST.TEST_carattGeom
Call AggiustaGraf.Avvia_AggiustaGraf
End Sub
a mio parere questa sub potrebbe così essere semplificata:CODICESub genera_armature_circolari()
Dim nbarre As Integer
Range(Cells(5, 25), Cells(5 + 500, 27)).ClearContents
riga_rif = 5
colonna_rif = 25
PiGreco = 3.14159265358979
Diametro = Cells(45, 17 + 3)
passo = Cells(45, 17 + 1)
sviluppo = PiGreco * Cells(45, 17)
If Cells(45, 17 + 1) = "" Then
nbarre = Cells(45, 17 + 2)
Cells(45, 17 + 1) = sviluppo / nbarre
Else
nbarre = sviluppo / Cells(45, 17 + 1)
Cells(45, 17 + 2) = Int(sviluppo / Cells(45, 17 + 1))
End If
'centro raggio
Raggio = Cells(45, 17)
t = 2 * PiGreco / nbarre 'direttamente in radianti
For ii = 0 To nbarre - 1
yy = Raggio * Cos(t * ii)
xx = Raggio * Sin(t * ii)
Cells(riga_rif + ii, colonna_rif) = xx
Cells(riga_rif + ii, colonna_rif + 1) = yy
Cells(riga_rif + ii, colonna_rif + 2) = Diametro
Next ii
Call TEST.TEST_carattGeom
Call AggiustaGraf.Avvia_AggiustaGraf
End Sub
preciso che non ho provato ad eseguire il codice modificato, cosa che lascio a chi sviluppa il file.
alla prossima distribuzione sarebbe anche "cortese" correggere acciao in acciaio
. -
p.luciani .
User deleted
Ragazzi buona serata... sto eseguendo alcune prove su una sezione a T... Inserendo allo SLU una coppia Mx e My uguali (piano di sollecitazione a 45°) come fa Mrx ad essere uguale a Mry???? L'asse neutro non è a 45°!!!! mentre il piano di sollecitazioni Sì... Si viene a creare un angolo tra piano di sollecitazione e piano resistente tale da determinare momenti resistenti in direzione x e y differenti. Dico bene??? correggetemi se sbaglio... . -
.
Correzione sub Test_SLU che non considerava N: CODICESub TEST_SLU()
...
...
...
n_c = Sheets(3).Range("n_c_SLU")
Dim Ndt As Double, Mxt As Double, Myt As Double
Calcolo_precompressione soll(25 + n_c).n, -soll(25 + n_c).Mx, -soll(25 + n_c).My, _
Ndt, Mxt, Myt
dominio_slu.nd = soll(25 + n_c).n
soll(25 + n_c).n = Ndt
ReDim dominio_slu.mrx(1 To NMaxDom)
ReDim dominio_slu.mry(1 To NMaxDom)
ReDim dominio_slu.ang(1 To NMaxDom)
ReDim dominio_slu.nrc(1 To NMaxDom)
ReDim dominio_slu.nrt(1 To NMaxDom)
ReDim dominio_slu.xrc(1 To NMaxDom)
ReDim dominio_slu.yrc(1 To NMaxDom)
ReDim dominio_slu.xrt(1 To NMaxDom)
ReDim dominio_slu.yrt(1 To NMaxDom)
ReDim dominio_slu.epsc(1 To NMaxDom)
ReDim dominio_slu.epss(1 To NMaxDom)
ReDim dominio_slu.yn(1 To NMaxDom)
ReDim dominio_slu.curv(1 To NMaxDom)
Call assegna_valori_SLU
Call calcola_dominio(dominio_slu)
...
...
...
End Sub
Adesso mi pare che tutto sia a posto.. -
.Correzione sub Test_SLU che non considerava N:CODICESub TEST_SLU()
...
...
...
n_c = Sheets(3).Range("n_c_SLU")
Dim Ndt As Double, Mxt As Double, Myt As Double
Calcolo_precompressione soll(25 + n_c).n, -soll(25 + n_c).Mx, -soll(25 + n_c).My, _
Ndt, Mxt, Myt
dominio_slu.nd = soll(25 + n_c).n
soll(25 + n_c).n = Ndt
ReDim dominio_slu.mrx(1 To NMaxDom)
ReDim dominio_slu.mry(1 To NMaxDom)
ReDim dominio_slu.ang(1 To NMaxDom)
ReDim dominio_slu.nrc(1 To NMaxDom)
ReDim dominio_slu.nrt(1 To NMaxDom)
ReDim dominio_slu.xrc(1 To NMaxDom)
ReDim dominio_slu.yrc(1 To NMaxDom)
ReDim dominio_slu.xrt(1 To NMaxDom)
ReDim dominio_slu.yrt(1 To NMaxDom)
ReDim dominio_slu.epsc(1 To NMaxDom)
ReDim dominio_slu.epss(1 To NMaxDom)
ReDim dominio_slu.yn(1 To NMaxDom)
ReDim dominio_slu.curv(1 To NMaxDom)
Call assegna_valori_SLU
Call calcola_dominio(dominio_slu)
...
...
...
End Sub
Adesso mi pare che tutto sia a posto.
La correzione in cosa consiste?. -
.
Prima era così: CODICESub TEST_SLU()
...
...
...
Dim Ndt As Double, Mxt As Double, Myt As Double
Calcolo_precompressione soll(25 + n_c).n, -soll(25 + n_c).Mx, -soll(25 + n_c).My, _
Ndt, Mxt, Myt
n_c = Sheets(3).Range("n_c_SLU")
dominio_slu.nd = soll(25 + n_c).n
ReDim dominio_slu.mrx(1 To NMaxDom)
ReDim dominio_slu.mry(1 To NMaxDom)
ReDim dominio_slu.ang(1 To NMaxDom)
ReDim dominio_slu.nrc(1 To NMaxDom)
ReDim dominio_slu.nrt(1 To NMaxDom)
ReDim dominio_slu.xrc(1 To NMaxDom)
ReDim dominio_slu.yrc(1 To NMaxDom)
ReDim dominio_slu.xrt(1 To NMaxDom)
ReDim dominio_slu.yrt(1 To NMaxDom)
ReDim dominio_slu.epsc(1 To NMaxDom)
ReDim dominio_slu.epss(1 To NMaxDom)
ReDim dominio_slu.yn(1 To NMaxDom)
ReDim dominio_slu.curv(1 To NMaxDom)
Call assegna_valori_SLU
soll(25 + n_c).n = Ndt
Call calcola_dominio(dominio_slu)
...
...
...
End Sub
Ora ho spostato l'ordine delle istruzioni così:CODICESub TEST_SLU()
...
...
...
n_c = Sheets(3).Range("n_c_SLU")
Dim Ndt As Double, Mxt As Double, Myt As Double
Calcolo_precompressione soll(25 + n_c).n, -soll(25 + n_c).Mx, -soll(25 + n_c).My, _
Ndt, Mxt, Myt
dominio_slu.nd = soll(25 + n_c).n
soll(25 + n_c).n = Ndt
ReDim dominio_slu.mrx(1 To NMaxDom)
ReDim dominio_slu.mry(1 To NMaxDom)
ReDim dominio_slu.ang(1 To NMaxDom)
ReDim dominio_slu.nrc(1 To NMaxDom)
ReDim dominio_slu.nrt(1 To NMaxDom)
ReDim dominio_slu.xrc(1 To NMaxDom)
ReDim dominio_slu.yrc(1 To NMaxDom)
ReDim dominio_slu.xrt(1 To NMaxDom)
ReDim dominio_slu.yrt(1 To NMaxDom)
ReDim dominio_slu.epsc(1 To NMaxDom)
ReDim dominio_slu.epss(1 To NMaxDom)
ReDim dominio_slu.yn(1 To NMaxDom)
ReDim dominio_slu.curv(1 To NMaxDom)
Call assegna_valori_SLU
Call calcola_dominio(dominio_slu)
...
...
...
End Sub. -
.
premetto che seguendo questo topic e l'altro a questo collegato cerco di mantenere aggiornati con le modifiche postate sia il file originario versectzax che versectzaxcap. e trovo anche giusto aggiungere che, senza la pubblicazione del secondo file, mai avrei potuto costruirlo io a partire dal primo.
detto ciò, nel caso del cap, mi sembra comincino a verificarsi dei "fork": ho infatti l'impressione che non ci sia, diciamo così, una "manutenzione ufficiale" ma si inizino a seguire linee diverse di sviluppo o, forse meglio, di estensione.
riconosciuta senz'altro meritevole l'opera di tex e la sua disponibilità a condividerla, e riconosciuta meritevole l'opera di luciani e parimenti la sua disponibilità a condividerla a sua volta, trovo che la pubblicazione di più file possa costituire un rischio di downgrade del codice.
se quindi io introduco la modifica appena postata da tex nel file di luciani, non posso sapere se una possibile rev.4 postata da luciani la contiene oppure no. questo mi obbliga a conservare e mantenere sia il file di tex che quello di luciani, aggiornandoli entrambi.
vale però pure l'opposto, nel caso io introduca le modifiche di luciani nel file di tex. se poi magari afazio oppure lo stesso tex postano una nuova versione di versectzaxcap, come posso sapere se anche loro hanno introdotto le mie stesse modifiche?
altro esempio: ho provato ad inputare la stessa sezione in c.a. ordinario in entrambi i file (ciò è possibile e non ci sarebbe nemmeno bisogno di dirlo) e il mio excel con versectzax si è piantato, cosa che invece non è successa con versectzaxcap. tex mi ha spiegato l'origine dell'errore e sono stato in grado di correggerlo (tra l'altro, la modifica suggeritami da tex era già presente nel suo file ma non documentata, quindi difficilmente individuabile all'interno del codice). se ora qualcuno postasse una nuova versione di versectzax mi devo ricordare delle modifiche fatte?
oppure, in tutti i casi, devo sempre confrontare volta per volta qualche migliaio di linee di codice?
ora, chi si è stancato di leggere si chiederà dove voglio arrivare. me lo chiedo anch'io, perché ho cominciato a scrivere ma inizialmente non sapevo nemmeno bene cosa dire, figuriamoci come concludere.
forse però sarebbe utile riflettere sull'ipotesi che l'eventuale file sia reso disponibile, di tanto in tanto, sempre dalla stessa persona, cui sarebbero sottoposte le eventuali modifiche, pubblicandone il relativo codice, o spediti privatamente eventuali file modificati nel caso si vogliano proporre differenti organizzazioni dell'interfaccia o cose di questo tipo..
Ci A Pi |
