Il Bar dell'Ingegneria

Verifiche sezioni complesse in c.a. agli SLE ed SLU

« Older   Newer »
 
  Share  
.
  1.     +3   +1   -1
     
    .
    Avatar

    Advanced Member

    Group
    Administrator
    Posts
    8,156
    Reputation
    +293

    Status
    Offline
    ... una dedica speciale a Zax2010, non ultimo nella condivisione della conoscenza...

    "... a volte basta una scintilla per scoprire l'acqua calda ..."

    http://ingegneriaforum.it/index.php?topic=1870.0

    partiamo

    Vedere anche il topic La teoria che mancava

    Qualche tempo fa, nelle pagine del sito http://ingegneriaforum.it l'utente Zax2010 propose ai lettori di quel sito un complesso codice e relativi commenti riccamente illustrati per la verifica di sezioni complesse (poligonali chiuse concave o convesse con presenza o meno di cavità o inclusione di altri materiali tipo profilati in acciaio) in c.a. e altri materiali, agli stati limite di esercizio e ultimi. L'argomento destò l'interesse di molti dei frequentatori, anche il mio, e in breve raggiunse il top nel numero di letture e visite.
    Il codice elegantemente presentato era scritto in C, linguaggio che io conosco in maniera assai superficiale. Qualche tempo prima io avevo presentato altro codice in VBA per Excel relativo ad una funzione utente in Excel che permetteva di condurre la verifica di una sezione regolare (sezione rettangolare, sezione a T, sezione trapezia e sezione circolare)in regime di pressoflessione retta agli stati limite ultimi e consentiva anche la generazione del dominio di rottura. Seguendo il codice di Zax2010 mi ero riproposto di tradurlo in linguaggio VBA ed avevo ottenuto da parte dell'autore il consenso di poter procedere anche mantenendo intatta la sua logica e strutturazione del programma. Cioè procedere alla sola e semplice traduzione in quanto e per quanto possibile.

    Cercherò di farlo adesso in questo 3d, riportando laddove necessario qualche citazione dell'autore Zax2010 presa dal sito di origine, integrando, sempre laddove necessario con qualche mio commento e invitando tutti quanti i lettori interessati a voler aggiungere i loro.
    Invito espressamente Francesco, che ha mostrato conoscenza del linguaggio C, a voler partecipare, se lo riterrà necessario, con suoi chiarimenti sulle istruzione del linguaggio C oltre che commenti e considerazioni relativi alla materia "verifiche sezioni in c.a."

    Edited by afazio - 21/10/2014, 08:26
     
    Top
    .
  2.     +1   -1
     
    .
    Avatar

    Advanced Member

    Group
    Administrator
    Posts
    8,156
    Reputation
    +293

    Status
    Offline
    Sottolineo il fatto che il codice che Zax2010 ha gentilmente messo a disposizione di tutti, fa parte di una sua applicazione di cui presento la schermata di info con nello sfondo una serie di iconette che danno l'idea della complessita del programma che cela quel codice.

    zax20101
     
    Top
    .
  3.     +1   -1
     
    .
    Avatar

    Member

    Group
    Member
    Posts
    883
    Reputation
    +39

    Status
    Offline
    facepalmsmiley
    L'affare s'ingrossa e si fa maledettamente interessante.
     
    Top
    .
  4.     +1   +1   -1
     
    .
    Avatar

    Advanced Member

    Group
    Administrator
    Posts
    8,156
    Reputation
    +293

    Status
    Offline
    Partiamo

    La prima operazione da fare è quella di aprire un nuovo foglio di excel, e dopo aver attivato la possibilità di esecuzione delle macro, salvarlo con nome ed accedere all'ambiente di programmazione con ALT+F11.
    Creare un nuovo modulo che chiamiamo con "ModuloPrincipale" ed iniziare ad inserire il codice.

    Stabiliamo che vogliamo essere costretti dal VBA a dichiarare le variabili, in questo modo avremo meno soroprese dovute ad errori di digitazione con creazioni di variabili (non dichiarate) che noi pensiamo essere quelle che vogliamo ma che in effetti non sono quelle.

    Option Explicit fa al nostro caso.

    Quindi definiamo le costanti utilizzate nel corso del programma e quindi la prima struttura dei dati


    CODICE
    Option Explicit
    Public Const NMAXPOLI As Integer = 6   ' Numero massimo di poligoni che possono comporre la sezione */
    Public Const NMAXVRT As Integer = 100  ' Numero massimo di vertici che possono comporre il singolo poligono della sezione */
    Public Const NMAXARM As Integer = 200  ' Numero massimo di armature che possono essere inserite nella sezione */
    Public Const NMAXCOMB As Integer = 50  ' Numero massimo di combinazioni di carico cui assoggettare la sezione */
    Public Const ULT    As Integer = 0
    Public Const SNERV  As Integer = 1
    Public Const CURV   As Integer = 2

    ' definizione dei tipi (strutture delle variabili)
    ' -------------------------------------------------------------------------- */
    ' Struttura dati in cui sono definiti i dati dei singoli poligoni che com-   */
    ' pongono la sezione                                                         */
    ' -------------------------------------------------------------------------- */
    Public Type poligono_sezione
       x(0 To NMAXVRT - 1) As Double  ' coordinata x del vertice */
       y(0 To NMAXVRT - 1) As Double    ' coordinata y del vertice */
       numv As Integer            ' numero di vertici del poligono */
       omog As Double  ' coefficiente di omogeneizzazione (per verifiche SLE) */
       traz As Integer            ' 0=non reagente a trazione; 1=reagente a trazione */
       classe As String       ' Classe di resistenza del cls */
       fd As Double            ' Resistenza massima di calcolo (per verifiche SLU) */
       automfd As Integer         ' Rende automatico il calcolo di fd in funzione della classe del cls */
       dominio As Integer          ' 0=parabola-rettangolo (cls) 1=bilatera (acciaio) */
       fase As Integer            ' A futura memoria per gestire fasi di realizzazione */
       epsc0 As Double         ' Deformazione in corrispondenza della fine della parte parabola/lineare del dominio */
       epscu As Double         ' Deformazione ultima del dominio */
       automeps As Integer        ' Rende automatico il calcolo di epsc0 e epscu in funzione della classe del cls */
       selez(0 To NMAXVRT - 1) As Integer  ' 1=vertice selezionato 0=vertice non selezionato */
       bloc(0 To NMAXVRT - 1) As Integer   ' Link rigido con altro vertice. Nessun link=-1 */
    End Type


    Il tipo poligono_sezione altro non è che un tipo di variabile alla stessa stregua dell Integer o del double o del boolean, solo che stavolta siamo noi a definirne la struttura.
    Con quelle istruzioni abbiamo stabilito che ogni volta che definiamo una variabile per esempio xyz e ad essa attribuiamo il tipo poligono_sezione con l'istruzione

    dim xyz as poligono_sezione

    non abbiamo fatto altro che preparare uno spazio di memoria atto a contenere:
    100 coordinate x
    100 coordinate y
    un numero intero che mi rappresenterà il numero dei vertici presenti
    un numero in doppia precisione che sarà il coefficiente di omogeneizzazione
    un numero intero che mi idnicherà se la sezione è reagente o meno a trazione
    una stringa che mi indicherà la classe del cls
    ....
    e cosi via secondo la definizione del tipo

    Definita la variabile xyz, potremo accedere a qualsiasi dei valori che essa contiene attraverso l'istruzione

    abc= xyz.x(52) ' accediamo all'ascissa del cinquantatreesimo vertice
    def= xyz.omog ' leggiamo il suo coefficiente di omogeneizzazione
    .....

    stessa cosa in scrittura. Se vogliamo attribuire alla sezione xyz la classe "terzaB" basta dare l'istruzione

    xyz.classe="terzaB"
    mentre se vogliomo che sia attribuita una resistenza di calcolo pari ad 14.71 basta dare l'isrtruzione

    xyz.fd=14.71
     
    Top
    .
  5. francesco.coppola
        +1   -1
     
    .

    User deleted


    Il fatto che i commenti inizino con il simbolo (') e terminino con (*/) è un semplice refuso della traduzione dal C al VBA?
    Oppure tutto il testo dal (') fino alla fine della riga è da intendersi commento? E poi si ricomincia con il codice?
    (In C il commento deve essere per forza compreso tra (/*) e (*/), oppure in C++ tra (//) iniziale e (//) finale).

    Alcuni campi della struttura dati relativa al poligono mi paiono superflui per il semplice calcolo (tipo selez o bloc), ma evidentemente avranno un senso nell'interfaccia del programma....

    Altra cosa.
    Riguardo i numeri in virgola mobile, in VBA esiste il solo tipo double?
    Oppure è una tua abitudine dichiarare tutte le variabili 'reali' con questo tipo?

    Lo chiedo perchè in C:
    float --> Numero in virgola mobile a precisione singola (di solito rappresentato utilizzando 32 bit)
    double --> Numero in virgola mobile a precisione doppia (di solito rappresentato utilizzando 64 bit)

    Poi ci sarebbe la possibilità di utilizzare ancora il 'cast' unsigned da anteporre al float o al double, che indicherebbe l'assenza del segno nel numero, raddoppiandone il range di variabilità, o ancora il 'cast' long da utilizzare davanti al double che porta il numero ad una rappresentazione ad 80 bit (ma penso che questo numero dipenda anche dalla singola implementazione del compilatore), per avere precisione ancora maggiore.
     
    Top
    .
  6.     +1   -1
     
    .
    Avatar

    Advanced Member

    Group
    Administrator
    Posts
    8,156
    Reputation
    +293

    Status
    Offline
    CITAZIONE (francesco.coppola @ 27/9/2012, 09:26) 
    Il fatto che i commenti inizino con il simbolo (') e terminino con (*/) è un semplice refuso della traduzione dal C al VBA?
    Oppure tutto il testo dal (') fino alla fine della riga è da intendersi commento? E poi si ricomincia con il codice?
    (In C il commento deve essere per forza compreso tra (/*) e (*/), oppure in C++ tra (//) iniziale e (//) finale).

    Alcuni campi della struttura dati relativa al poligono mi paiono superflui per il semplice calcolo (tipo selez o bloc), ma evidentemente avranno un senso nell'interfaccia del programma....

    Non è un refuso dato che in VBA il commento non deve essere delimitato come in C, ma basta solo che inizi con l'apostrofo. Tutto quello che ci sta a seguire nel rigo è considerato commento.
    In questo modo io ho evitato di togliere il delimitatore di chiusura presente nell'originale codice di Zax.

    Vedrai che anche nella altre stutture dati sono presenti campi che adesso sembrano superflui come nelle armature messe a congelare in frigo.
    Intanto traduco pedissequamente il codice che mi sono proposto di tradurre, rinviando al 3d di origini per approfondimenti, in alternativa dovrei inserire il codice che necessita nella fase analizzata e successivamente otornare indietro per aggiungere le definizioni che via via spunteranno essere necessarie.

    Per ogni buon conto ti invito a leggere il 3d che ho linkato al terzo rigo del presente topic e che riporto ancora una volta qui:
    http://ingegneriaforum.it/index.php?topic=1870.0

    vedrai che la cosa si sviluppa in ben 9 pagine strazeppe di commenti e codice

    CITAZIONE (francesco.coppola @ 27/9/2012, 09:34) 
    ....

    Altra cosa.
    Riguardo i numeri in virgola mobile, in VBA esiste il solo tipo double?
    Oppure è una tua abitudine dichiarare tutte le variabili 'reali' con questo tipo?

    Lo chiedo perchè in C:
    float --> Numero in virgola mobile a precisione singola (di solito rappresentato utilizzando 32 bit)
    double --> Numero in virgola mobile a precisione doppia (di solito rappresentato utilizzando 64 bit)

    tipi numerici predefiniti in VBA:

    Byte: intero tra 0 e 255 (occupa 1 byte)
    Integer: intero tra -32.768 a 32.767 (occupa 2 byte)
    Long: intero tra -2.147.483.648 a 2.147.483.6477 (occupa 4 byte)


    Single: a virgola mobile Da -3,402823E38 a -1,401298E-45 per valori negativi; da 1,401298E-45 a 3,402823E38 per valori positivi (impegna 4 byte)
    Double: a virgola mobile Da -1.79769313486231E308 a
    -4,94065645841247E-324 per valori negativi; da 4,94065645841247E-324 a 1,79769313486232E308 per valori positivi. (impegna 8 Byte)


    Poi ci sarebbe anche il decimal cosi definito:

    Decimal: +/-79.228.162.514.264.337.593.543.950.335 senza virgola;
    +/-7,9228162514264337593543950335 con 28 decimali; il numero minore diverso da zero è
    +/-0,0000000000000000000000000001 ed impegna 14 byte

    infine altri tipi che gestiscono le valute e le date, oltre ovviamente alle stringe, ai booleani. Restano ancora tre tipi particolari:

    Variant che impegna ben 22 byte e che puo' contenere qualsiasi tipo precedentemente definito. Si usa questo oneroso tipo quando la variabile che sarà trattata puo assumere diversi tipi (per esempio quando scrivo le funzioni che restituiscono uno o l'altro valore in base al flag passato, puo capitare di dover restituire una stringa o un numero, ed allora occorre definire il tipo del dato restituito dalla funzione come Variant)

    Object: è un semplice riferimento (puntatore) alla locazione di memoria dove risiede un qualsiasi oggetto.

    Tipi definito dall'utente, come quello sopra definito




    La definizione del tipo di una variabile destinata a contenere le armature:

    CODICE
    ' -------------------------------------------------------------------------- */
    ' Struttura dati in cui sono definiti i dati delle singole barre di armatura */
    ' presenti nella sezione                                                     */
    ' -------------------------------------------------------------------------- */
    Public Type armature_sezione
       af(0 To NMAXARM - 1) As Double     ' area della barra di armatura */
       diam(0 To NMAXARM - 1) As Double ' diametro della barra */
       x(0 To NMAXARM - 1) As Double     ' coordinata x della barra */
       y(0 To NMAXARM - 1) As Double     ' coordinata y della barra */
       numarm As Integer          ' numero di barre per l'intera sezione */
       omogarm As Double       ' coefficiente di omogeneizzazione (per verifiche SLE) */
       selez(0 To NMAXARM - 1) As Integer  ' 1=armatura selezionata 0=armatura non selezionata */
       cong(0 To NMAXARM - 1) As Integer  ' 0=non congelato 1=congelato */
    End Type
     
    Top
    .
  7.     +1   -1
     
    .
    Avatar

    Advanced Member

    Group
    Administrator
    Posts
    8,156
    Reputation
    +293

    Status
    Offline
    Altra struttura (definizione di tipo) relativa ad una variabile che congloba tutte le caratteristiche geometriche della sezione:

    CODICE
    ' -------------------------------------------------------------------------- */
    ' Struttura dati dove vengono definite le caratteristiche geometriche della  */
    ' sezione intera o di porzioni della sezione stessa                          */
    ' -------------------------------------------------------------------------- */
    Public Type geometria_sezione
       area As Double   ' Area della sezione */
       scx As Double   ' Momento statico rispetto ad asse x baricentrico */
       scy As Double   ' Momento statico rispetto ad asse y baricentrico */
       ix As Double   ' Momento d'inerzia rispetto ad asse x baricentrico */
       iy As Double   ' Momento d'inerzia rispetto ad asse y baricentrico */
       ixy As Double   ' Momento d'inerzia polare rispetto ad assi x,y baricentrici */
       alfa As Double   ' Inclinazione (rad) degli assi principali d'inerzia */
       ia As Double   ' Momenti principali di inerzia */
       ib As Double   '
    End Type
     
    Top
    .
  8. Ncenzo
        +1   -1
     
    .

    User deleted


    leggo con interesse.
     
    Top
    .
  9.     +1   -1
     
    .
    Avatar

    Advanced Member

    Group
    Administrator
    Posts
    8,156
    Reputation
    +293

    Status
    Offline
    Ok.

    Ho tradotto tutte le definizioni di struttura/tipo e li riporto in unica volta, cosi mi tolgo il pensiero:

    CODICE
    Option Explicit
    Public Const NMAXPOLI As Integer = 6   ' Numero massimo di poligoni che possono comporre la sezione */
    Public Const NMAXVRT As Integer = 100  ' Numero massimo di vertici che possono comporre il singolo poligono della sezione */
    Public Const NMAXARM As Integer = 200  ' Numero massimo di armature che possono essere inserite nella sezione */
    Public Const NMAXCOMB As Integer = 50  ' Numero massimo di combinazioni di carico cui assoggettare la sezione */
    Public Const ULT    As Integer = 0
    Public Const SNERV  As Integer = 1
    Public Const curv   As Integer = 2
    ' definizione dei tipi (strutture delle variabili)
    ' -------------------------------------------------------------------------- */
    ' Struttura dati in cui sono definiti i dati dei singoli poligoni che com-   */
    ' pongono la sezione                                                         */
    ' -------------------------------------------------------------------------- */
    Public Type poligono_sezione
       x(0 To NMAXVRT - 1) As Double  ' coordinata x del vertice */
       y(0 To NMAXVRT - 1) As Double    ' coordinata y del vertice */
       numv As Integer            ' numero di vertici del poligono */
       omog As Double  ' coefficiente di omogeneizzazione (per verifiche SLE) */
       traz As Integer            ' 0=non reagente a trazione; 1=reagente a trazione */
       classe As String       ' Classe di resistenza del cls */
       fd As Double            ' Resistenza massima di calcolo (per verifiche SLU) */
       automfd As Integer         ' Rende automatico il calcolo di fd in funzione della classe del cls */
       dominio As Integer          ' 0=parabola-rettangolo (cls) 1=bilatera (acciaio) */
       fase As Integer            ' A futura memoria per gestire fasi di realizzazione */
       epsc0 As Double         ' Deformazione in corrispondenza della fine della parte parabola/lineare del dominio */
       epscu As Double         ' Deformazione ultima del dominio */
       automeps As Integer        ' Rende automatico il calcolo di epsc0 e epscu in funzione della classe del cls */
       selez(0 To NMAXVRT - 1) As Integer  ' 1=vertice selezionato 0=vertice non selezionato */
       bloc(0 To NMAXVRT - 1) As Integer   ' Link rigido con altro vertice. Nessun link=-1 */
    End Type
    ' -------------------------------------------------------------------------- */
    ' Struttura dati in cui sono definiti i dati delle singole barre di armatura */
    ' presenti nella sezione                                                     */
    ' -------------------------------------------------------------------------- */
    Public Type armature_sezione
       af(0 To NMAXARM - 1) As Double     ' area della barra di armatura */
       diam(0 To NMAXARM - 1) As Double ' diametro della barra */
       x(0 To NMAXARM - 1) As Double     ' coordinata x della barra */
       y(0 To NMAXARM - 1) As Double     ' coordinata y della barra */
       numarm As Integer          ' numero di barre per l'intera sezione */
       omogarm As Double       ' coefficiente di omogeneizzazione (per verifiche SLE) */
       selez(0 To NMAXARM - 1) As Integer  ' 1=armatura selezionata 0=armatura non selezionata */
       cong(0 To NMAXARM - 1) As Integer  ' 0=non congelato 1=congelato */
    End Type
    ' -------------------------------------------------------------------------- */
    ' Struttura dati dove vengono definite le caratteristiche geometriche della  */
    ' sezione intera o di porzioni della sezione stessa                          */
    ' -------------------------------------------------------------------------- */
    Public Type geometria_sezione
       area As Double   ' Area della sezione */
       scx As Double   ' Momento statico rispetto ad asse x baricentrico */
       scy As Double   ' Momento statico rispetto ad asse y baricentrico */
       ix As Double   ' Momento d'inerzia rispetto ad asse x baricentrico */
       iy As Double   ' Momento d'inerzia rispetto ad asse y baricentrico */
       ixy As Double   ' Momento d'inerzia polare rispetto ad assi x,y baricentrici */
       alfa As Double   ' Inclinazione (rad) degli assi principali d'inerzia */
       ia As Double   ' Momenti principali di inerzia */
       ib As Double   '
    End Type
    ' -------------------------------------------------------------------------- */
    ' Struttura dati utilizzata nelle verifiche SLE. In essa vengono definiti i  */
    ' parametri deformativi u,fx,fy della sezione parzializzata (o no) che       */
    ' creano equilibrio con le sollecitazioni esterne                            */
    ' -------------------------------------------------------------------------- */
    Public Type deform
       u(0 To 2) As Double         ' u[0]=deformazione lineare in corrispondenza baricentro sezione */
                                   ' positivo se "comprime" la sezione */
                                   ' u[1]=rotazione sezione attorno all'asse X: positivo se "comprime" Y+ */
                                   ' u[2]=rotazione sezione attorno all'asse Y: positivo se "comprime" X+ */
    End Type
    ' -------------------------------------------------------------------------- */
    ' Struttura dati dove sono definite le sollecitazioni di sforzo normale e di */
    ' momenti flettenti agenti nella sezione. Punto di applicazione dei carichi: */
    ' baricentro sezione omogeneizzata senza tenere in conto le armature         */
    ' -------------------------------------------------------------------------- */
    Public Type soll_esterne
       n As doube              ' Sforzo normale: positovo se di compressione */
       mx As doube             ' Momento flettente asse momento X: positivo se comprime fibra Y+ */
       my As doube             ' Momento flettente asse momento Y: positivo se comprime fibra X+ */
       tipo As Integer         ' 0=SLE 1=SLU */
    End Type
    ' -------------------------------------------------------------------------- */
    ' Struttura dati dove viene definita la lunghezza di ogni singola fibra e la */
    ' posizione del "baricentro" della stessa. Utilizzata nelle verifiche SLU, a */
    ' seguito della suddivisione in striscie della parte compressa della sezione */
    ' -------------------------------------------------------------------------- */
    Public Type lungh_fibra
       lungh As Double          ' Lunghezza della fibra */
       xb As Double             ' Baricentro della fibra */
    End Type
    ' -------------------------------------------------------------------------- */
    ' Struttura dati dove viene definita la configurazione deformata a rottura   */
    ' della sezione, semplicemente con la deformazione nel punto più alto della  */
    ' sezione compressa e la deformazione della armatura posta più in basso      */
    ' -------------------------------------------------------------------------- */
    Public Type deform_sezione
       epsa As Double         ' Deformazione della fibra (compressa) più alta della sezione */
       epsb As Double          ' Deformazione della armatura più bassa della sezione */
    End Type
    ' -------------------------------------------------------------------------- */
    ' Struttura dati per definire lo sforzo normale della parte compressa o tesa */
    ' della sezione, in configurazione di rottura, con coordinate del relativo   */
    ' punto di applicazione                                                      */
    ' -------------------------------------------------------------------------- */
    Public Type risultante_n
       n As Double             ' Sforzo normale risultante */
       x As Double             ' Coordinate punto di applicazione risultante */
       y As Double
    End Type
    ' -------------------------------------------------------------------------- */
    ' Struttura dati che incapsula insieme le risultanti di compressione e di    */
    ' trazione della sezione, in configurazione di rottura, con posizione effet- */
    ' tiva dell'asse neutro e relative deformazioni limite della sezione         */
    ' -------------------------------------------------------------------------- */
    Public Type risultante_n_finale
       ncf As risultante_n   ' Risultante di compressione della sezione */
       ntf As risultante_n   ' Risultante di trazione della sezione */
       yn As Double
       epsc As Double
       epss As Double
    End Type
    ' -------------------------------------------------------------------------- */
    ' Struttura dati che contiene i valore dei momenti di rottura della sezione  */
    ' -------------------------------------------------------------------------- */
    Public Type momenti_rottura
       mrx As Double '           Momento di rottura con asse momento x */
       mry As Double '            Momento di rottura con asse momento y */
    End Type
    ' -------------------------------------------------------------------------- */
    ' Struttura dati in cui vengono memorizzati tutti i punti del dominio della  */
    ' sezione, per dato sforzo normale, con tutti i dati intermedi perchè si     */
    ' possano visualizzare e/o manipolare                                        */
    ' -------------------------------------------------------------------------- */
    Public Type dominio_rottura
       nd As Double '            /* Sforzo normale con cui si determinano i vari momenti di rottura */
       mrx(0 To 23) As Double '       /* vettore con i valori dei momenti Mrx del dominio */
       mry(0 To 23) As Double '      /* vettore con i valori dei momenti Mry del dominio */
       nrc(0 To 23) As Double '       /* vettore con valori dello sfozo normale nella parte compressa della sezione a rottura */
       nrt(0 To 23) As Double '       /* vettore con valori dello sforzo normale nella parte in trazione della sezione a rottura */
       xrc(0 To 23) As Double '       /* posizione della risultante dello sforzo di compressione */
       yrc(0 To 23) As Double '       /* (nel sistema di riferimento cartesiano della sezione) */
       xrt(0 To 23) As Double '       /* posizione della risultante dello sforzo di trazione */
       yrt(0 To 23) As Double '       /* (nel sistema di riferimento cartesiano della sezione) */
       epsc(0 To 23) As Double '      /* vettore con le deformazioni limite della fibra più compressa */
       epss(0 To 23) As Double '      /* vettore con le deformazioni limite della barra di armatura più distante dall'asse neutro */
       yn(0 To 23) As Double '        /* posizione asse neutro (nel sistema ruotato di ogni singola verifica) */
       curv(0 To 23) As Double '      /* Curvatura della deformazione della sezione per diagrammi momenti-curvatura */
    End Type
    ' -------------------------------------------------------------------------- */
    ' Struttura dati in cui vengono memorizzati tutti i punti del dominio 3D     */
    ' dei momenti-curvatura della sezione, per dato sforzo normale               */
    ' -------------------------------------------------------------------------- */
    Public Type dom_momenti_curv
       mcurv(0 To 11) As dominio_rottura
    End Type
    ' -------------------------------------------------------------------------- */
    ' Struttura dati in cui vengono memorizzati i valori limite SLU di massimo   */
    ' sforzo normale possibile per la sezione, sia a compressione che a trazione */
    ' con relativi valori dei momenti flettenti associati                        */
    ' -------------------------------------------------------------------------- */
    Public Type n_limite
       ncompr As Double '        /* Massimo sforzo normale di compressione */
       mrxcompr As Double '       /* Momento di rottura con asse x associato al massimo sforzo di compressione */
       mrycompr As Double '       /* Momento di rottura con asse y associato al massimo sforzo di compressione */
       ntraz As Double '          /* Massimo sforzo normale di trazione */
       mrxtraz As Double '        /* Momento di rottura con asse x associato al massimo sforzo di trazione */
       mrytraz As Double '        /* Momento di rottura con asse y associato al massimo sforzo di trazione */
    End Type
    ' -------------------------------------------------------------------------- */
    ' Struttura dati in cui vengono memorizzati tutti i punti del dominio 2D     */
    ' dei momenti-curvatura della sezione, per dato sforzo normale               */
    ' -------------------------------------------------------------------------- */
    Public Type d_curv
       mx(0 To 11) As Double
       my(0 To 11) As Double
       nc(0 To 11) As Double
       nt(0 To 11) As Double
       xc(0 To 11) As Double
       yc(0 To 11) As Double
       xt(0 To 11) As Double
       yt(0 To 11) As Double
       epsc(0 To 11) As Double
       epss(0 To 11) As Double
       yn(0 To 11) As Double
       ang(0 To 11) As Double
       m(0 To 11) As Double
       crv(0 To 11) As Double
    End Type
    ' -------------------------------------------------------------------------- */
    ' Struttura dati in cui vengono memorizzati i valori di conversione da coor- */
    ' dinate tridimensionali (x,y,z) a coordinate piane (x,y) in un piano di     */
    ' proiezione                                                                 */
    ' -------------------------------------------------------------------------- */
    Public Type coord_proiez
       x As Double
       y1 As Double
       y As Double
    End Type
    ' -------------------------------------------------------------------------- */
    ' Struttura dati in cui vengono memorizzati i valori di conversione da coor- */
    ' dinate tridimensionali (x,y,z) a coordinate piane (x,y) in un piano di     */
    ' proiezione                                                                 */
    ' -------------------------------------------------------------------------- */
    Public Type quadrangolo
       x3D(0 To 3) As Double
       y3D(0 To 3) As Double
       z3D(0 To 3) As Double
       x2D(0 To 3) As Double
       y2D(0 To 3) As Double
       y1D As Double
    End Type
    ' -------------------------------------------------------------------------- */


    Adesso ci sarebbero le dichiarazioni dei metodi che poi saranno sviluppati nel programma principale. Questo in C
    Penso che in VBA queste dichiarazioni dei metodi non sia necessaria (ricorso invece che lo era in delphi). per questo chiedo a Francesco di illustrarmi cosa significa una dichiarazione simile alla seguente:

    struct geometria_sezione calcola_caratt_geometriche (struct poligono_sezione *);

    Io la intendo cosi:

    "sarà utilizzata una procedura, chiamata calcola_caratt_geometriche che agirà su una variabile avente la struttura poligono_sezione e di cui daremo l'indirizzo di memoria. Sbaglio nell'interpretare?

    Aggiungo: ed il risultato ottenuto sarà una variabile avente struttura geometria_sezione?

    Edited by afazio - 27/9/2012, 12:14
     
    Top
    .
  10. francesco.coppola
        +1   -1
     
    .

    User deleted


    Quasi giusto.

    La traduzione effettiva è:

    "sarà utilizzata una procedura, chiamata calcola_caratt_geometriche che agirà su una variabile avente la struttura poligono_sezione che viene 'infilata' nella funzione per indirizzo di memoria (il * che si vede alla fine delle parentesi - e questo perchè non si lavora su una singola variabile, ma su un vettore di variabili, i 6 poligoni di cui potrà essere costituita la sezione), procedura che a sua volta restituisce un valore di tipo geometria_sezione (una struttura dati, precedentemente dichiarata)"

    Ho visto il comodo utilizzo delle MACRO ad inizio listato con la possibilità di modificare "in corsa" i limiti del codice (numero massimo di poligoni costituenti la sezione, numero massimo di vertici per poligono, ecc.).
    Però nella definizione delle variabili per il dominio di rottura, oppure per i diagrammi momenti-curvatura, trovo i numeri 'fissi' 24 e 12.

    Potrebbe essere opportuno "macro-izzare" anche questi, in modo da poter raffittire i punti voluti senza stravolgere il codice.

    N.B. Ti sei autocorretto in corsa, non lo avevo visto.
     
    Top
    .
  11. francesco.coppola
        +1   -1
     
    .

    User deleted


    Circa la prototipizzazione delle funzioni in C.

    Quando i signori Ritchie e Kernigan pubblicarono nel 1978 il loro 'mitico' libro "The C language", la necessità di dichiarare un prototipo delle funzioni prima del loro utilizzo era prevista solamente per le funzioni che non restituivano un intero (Ovvero funzioni che non restituiscono nulla o restituiscono un intero non hanno necessità di un prototipo).

    La necessità della dichiarazione preliminare del prototipo - parlo di cose di cui so assai poco - nascerebbe dalle 'esigenze' di ottimizzazione del codice che il C da sempre è in grado di fare. Il compilatore cioè vuol sapere prima cosa la funzione restituisce in modo da potersi organizzare di conseguenza.

    Il linguaggio ebbe un tale successo che parecchie furono le implementazioni indipendenti di compilatori che lo leggessero, con conseguente proliferazione di 'dialetti' più o meno compatibili tra loro.

    Nel 1983 si istituì un apposito comitato ANSI con il compito di mettere 'ordine'.
    I componenti di tale comitato si trovarono di fronte a parecchi problemi. La loro filosofia però, volta a salvaguardare il codice nel frattempo già scritto, fu quella di 'non decidere' in molti casi.

    Esistono oggi ad esempio compilatori che pur essendo al 100% ANSI C (dopo una prima emanazione, 1.0, mi pare che ne sia uscita una seconda), hanno comportamenti differenti.
    Ad esempio le specifiche ANSI non indicano mai quanti byte occupa un tipo float (il minimo dovrebbe essere 4 byte, ma nulla vieta, in particolari implementazioni, per sfruttare particolarità hardware o altro che esso sia costituita da 6 o 8 byte).
    Oppure non esiste un criterio unico circa il valore che assume una variabile appena dichiarata (in alcuni compilatori viene dichiarata ed automaticamente posta a 0, in altri ha un valore 'a casaccio').

    Per tornare alla prototipizzazione essa non è obbligatoria (almeno per ANSI C 1.0) ma "raccomandata", anche se la funzione restituisce un int.
     
    Top
    .
  12. g.iaria
        +1   -1
     
    .

    User deleted


    CITAZIONE (francesco.coppola @ 27/9/2012, 12:20) 
    Quasi giusto.

    La traduzione effettiva è:

    "sarà utilizzata una procedura, chiamata calcola_caratt_geometriche che agirà su una variabile avente la struttura poligono_sezione che viene 'infilata' nella funzione per indirizzo di memoria (il * che si vede alla fine delle parentesi - e questo perchè non si lavora su una singola variabile, ma su un vettore di variabili, i 6 poligoni di cui potrà essere costituita la sezione), procedura che a sua volta restituisce un valore di tipo geometria_sezione (una struttura dati, precedentemente dichiarata)"

    Se ho ben compreso, l'omologo di VBA è una funzione calcola_caratt_geometriche che riceve un argomento di tipo poligono_sezione passato per riferimento (ByRef) e che restituisce un risultato di tipo geometria_sezione.

    Edited by g.iaria - 27/9/2012, 14:16
     
    Top
    .
  13. francesco.coppola
        +1   -1
     
    .

    User deleted


    CITAZIONE (g.iaria @ 27/9/2012, 13:00) 
    Se ho ben compreso, l'omologo di VBA è una funzione calcola_caratt_geometriche che riceve un argomento di tipo poligono_sezione passato per riferimento (ByRef) e che restituisce un risultato di tipo geometria_sezione.

    Hai ben compreso.
     
    Top
    .
  14.     +1   -1
     
    .
    Avatar

    Advanced Member

    Group
    Administrator
    Posts
    8,156
    Reputation
    +293

    Status
    Offline
    Le variabili globali

    Gran parte delle procedure presenti nel codice originario richiamano delle variabili globali che devono pertanto essere definite a monte ed essere visibili alle procedure, quindi variabili pubbliche.

    /* -------------------------------------------------------------------------- */
    /* Alcune delle funzioni qui presentate presuppongono l'utilizzo di variabili */
    /* globali che devono/possono essere dichiarate nel file di progetto */
    /* Si espongono di seguito le variabili necessarie: */
    /* struct poligono_sezione poli[NMAXPOLI]; */
    /* struct armature_sezione arm; */
    /* struct soll_esterne soll[NMAXCOMB]; */
    /* float xg,yg; // Posizione baricentro senza tenere in conto le armature // */
    /* float fyd_arm,E_arm; // Tensione snervamento, modulo elastico barre // */
    /* float fyd_prof,E_prof; // Tensione snervamento, modulo elastico profili // */
    /* -------------------------------------------------------------------------- */

    In VBA la definizione delle variabili globali viene eseguita mediante l'istruzione: Public variabile as tipoVariabile
    quindi ecco le definizioni:

    CODICE
    Public poli(0 To NMAXPOLI - 1) As poligono_sezione
    Public arm As armature_sezione
    Public soll(0 To NMAXCOMB - 1) As soll_esterne
    Public xg As Double
    Public yg As Double
    Public fyd_arm As Double
    Public E_arm As Double
    Public fyd_prof As Double
    Public E_prof As Double


    La prima sub:

    ecco la prima sub che calcola le caratteristiche geometriche di un poligono passato come riferimento, leggendo i dati della variabile globale arm e depositando i risultati nella variabile passata come riferimento geo

    CODICE
    ' --------------------------------------------------------------------------
    ' nome suB         : calcola_caratt_geometriche(
    ' Scopo            : Calcola le caratteristiche geometriche della sezione.
    '                    Utilizza le variabili globali xg,yg - baricentro della
    '                    sezione omogenea senza armature - calcolate con la fun-
    '                    zione definisci_baricentro() perchè le caratteristiche
    '                    geometriche sono riferite a questo punto.
    ' Parametri         : Polic: Puntatore a struttura dati dei singoli poligoni che co-
    '                    stituiscono la sezione (in questo modo si possono pro-
    '                    cessare poligoni differenti da quelli di input, ad esem-
    '                    pio la sola parte reagente)
    '                    Geo: puntatore a variabile avente struttura geometria sezione
    '                    che sarà riempita coi valori derivanti da calcolo
    ' Valore restituito: la variabile passata come riferimento riempita coi dati calcolati
    ' Implementazione  : Luglio 2011
    ' Autore           : Zax2010
    ' traduzione in VBA : Afazio Settembre 2012
    ' ---------------------------------------------------------------------------
    Sub calcola_caratt_geometriche(ByRef polic As poligono_sezione, ByRef geo As geometria_sezione)
    Dim k As Integer, kp1 As Integer, np As Integer
    Dim a As Double, d As Double, hy As Double, hx As Double
    ' Azzera inizialmente tutte le variabili statiche da calcolare */
       geo.area = 0#
       geo.scx = 0#
       geo.scy = 0#
       geo.ix = 0#
       geo.iy = 0#
       geo.ixy = 0#
       ' Calcola le caratteristiche statiche di ogni singolo poligono */
       For np = 0 To NMAXPOLI - 1
           For k = 0 To polic(np).numv - 1
               If k = polic(np).numv - 1 Then
                   kp1 = 0
               Else
                   kp1 = k + 1
               End If
               a = polic(np).x(kp1) - polic(np).x(k)
               d = polic(np).y(kp1) - polic(np).y(k)
               hy = polic(np).y(k) - yg
               hx = polic(np).x(k) - xg
               geo.area = geo.area + polic(np).omog * a * (hy + d / 2)
               geo.scx = geo.scx + polic(np).omog * a / 2 * (hy * hy + d * d / 3 + d * hy)
               geo.scy = geo.scy - polic(np).omog * d / 2 * (hx * hx + a * a / 3 + a * hx)
               geo.ix = geo.ix + polic(np).omog * a / 3 * (hy ^ 3 + hy * d * d + 3 * hy * hy * d / 2 + (d ^ 3) / 4)
               geo.iy = geo.iy - polic(np).omog * d / 3 * (hx ^ 3 + hx * a * a + 3 * hx * hx * a / 2 + a ^ 3 / 4)
               geo.ixy = geo.ixy + polic(np).omog * a * (hx / 2 * (hy * hy + d * d / 3 + d * hy) + a / 2 * (hy * hy / 2 + d * d / 4 + 2 * d * hy / 3))
           Next
       Next
       ' Inserisce le armature ordinarie nelle caratteristiche statiche
       ' le armature vengono prelevate dalla variabile globale arm
       For k = 0 To arm.numarm - 1
           If (arm.af(k) = 0# And arm.cong(k) = 0) Then
             geo.area = geo.area + arm.omogarm * arm.af(k)
             geo.scx = geo.scx + arm.omogarm * arm.af(k) * (arm.y(k) - yg)
             geo.scy = geo.scy + arm.omogarm * arm.af(k) * (arm.x(k) - xg)
             geo.ix = geo.ix + arm.omogarm * arm.af(k) * (arm.y(k) - yg) ^ 2
             geo.iy = geo.iy + arm.omogarm * arm.af(k) * (arm.x(k) - xg) ^ 2
             geo.ixy = geo.ixy + arm.omogarm * arm.af(k) * (arm.x(k) - xg) * (arm.y(k) - yg)
           End If
       Next
       ' Inclinazione degli assi principali d'inerzia rispetto agli assi X,Y di riferimento */
       If (geo.ix - geo.iy = 0) Then
           geo.alfa = atan(-2 * geo.ixy / (geo.ix - geo.iy)) / 2
       ElseIf (geo.ixy > 0#) Then
           geo.alfa = -0.7854
       Else
           geo.alfa = 0.7854
       End If
       If (geo.ix < geo.iy) Then
           geo.alfa = geo.alfa + 1.570796327
       End If
       ' Momenti principali d'inerzia */
       geo.ia = (geo.ix + geo.iy) / 2 + Sqr((geo.ix - geo.iy) ^ 2 + 4 * geo.ixy ^ 2) / 2
       geo.ib = (geo.ix + geo.iy) / 2 - Sqr((geo.ix - geo.iy) ^ 2 + 4 * geo.ixy ^ 2) / 2
    End Sub


    Penso di apportare una modifica alla sub inserendo anche come parametro la variabile delle armature in modo da rendere la sub più autonoma.

    Mi sono accorto solo adesso della presenza della funzione Pow che penso sia mancante in VBA ed anche la funzione sqrt che in VBA diventa Sqr. Corretto.

    Edited by afazio - 27/9/2012, 17:04
     
    Top
    .
  15.     +1   -1
     
    .
    Avatar

    Advanced Member

    Group
    Administrator
    Posts
    8,156
    Reputation
    +293

    Status
    Offline
    con ogni probabilità serve definire altre variabili globali, ma lo farò via via che ne riscontro necessita nel tentativo di tradurre il codice.
    Cosi come le eventuali modifiche che intendo apportare le meterò solo alla fine.

    Intanto continuo con la traduzione: ecco la sub che inverte il senso di definizione dei vertici da orario ad antiorario e viceversa:
    CODICE
    ' --------------------------------------------------------------------------
    ' NOme sub: Inversione_poligono(
    ' Scopo             : Inverte il senso di input del singolo poligono orario
    '                     in antiorario e viceversa
    ' Parametri         : il numero del poligono da invertire
    ' Valore            : nessuno. Agisce sulla variabile globale poli()
    '                    invertendone il senso di definizione dei vertici
    ' Implementazione  : Luglio 2011                                             */
    ' Autore           : Zax2010
    ' traduzione in VBA : Afazio Settembre 2012
    ' ---------------------------------------------------------------------------

    Sub inversione_poligono(np As Integer)
    Dim k As Integer
    Dim provv As Double

       For k = 1 To poli(np).numv / 2
           provv = poli(np).x(k)
           poli(np).x(k) = poli(np).x(poli(np).numv - k)
           poli(np).x(poli(np).numv - k) = provv

           provv = poli(np).y(k)
           poli(np).y(k) = poli(np).y(poli(np).numv - k)
           poli(np).y(poli(np).numv - k) = provv
       Next
    End Sub


    Ho provato il suo funzionamento creando due range con due diverse liste dei vertici, quindi con apposita macro legata ad un bottone sul foglio, ho riempito le variabili poli(0) e poli(1) coi dati contenuti nelle due liste, quindi ho richiamato la sub sovrastante e poi ho fatto trascrivere sul foglio in due altri range diversi dai primi i risultati. pare che tutto funzioni alla perfezione

    Edited by afazio - 27/9/2012, 20:55
     
    Top
    .
390 replies since 26/9/2012, 10:47   29111 views
  Share  
.