Calcolo di sollecitazioni e spostamenti
in un sistema di travi rettilinee

Anche se non sembra semplice assegnare i dati conviene leggere le istruzioni ed evitare adattamenti con conseguenze imprevedibili

v. 2.02 (10/4/2003)    
© Amabile Tatone, Università dell'Aquila, L'Aquila, IT         
tatone@ing.univaq.it

Istruzioni

Sono da assegnare:
- i vettori a1 e a2 della base adattata alla sezione [D1]
- la distribuzione di forza [D2]
- i vincoli e le basi adattate al bordo [D3]
- le forze e i momenti alle estremità [D4]
- costanti (lunghezze, moduli, intensità delle forze) [D5]

Sono da adattare:
- la funzione di semplificazione extraSimplify [●]
- la cornice per la visualizzazione della deformazione [●]
- i fattori di scala per i diagrammi tecnici N, Q, M [●]

Sono da controllare:
- alcune definizioni riguardanti semplificazioni

Viene prima calcolata la soluzione bulk delle equazioni di bilancio in corrispondenza di una qualsiasi distribuzione di forze (integrabile).
Vengono assegnati i vincoli. Esiste il problema di compatibilita' dei vincoli solo in forma banale. Non esiste certamente per gli atti di moto, essendo per questi i vincoli delle condizioni omogenee.
Vengono poi costruite le equazioni di bilancio al bordo corrispondenti agli atti di moto vincolati, fornendo l'elenco delle forze attive da assegnare.
Sostituendo in queste equazioni la soluzione bulk si generano delle equazioni algebriche nelle costanti di integrazione.
Viene calcolata la soluzione che, nel caso di "vincoli eccedenti",  lascia indeterminate alcune delle costanti. 
Si puo' dire che si determina lo spazio delle soluzioni in termini di tensione bilanciata al bordo.
In caso di "vincoli in difetto" occorre verificare la compatibilità dei dati al bordo sulle forze.
Si prosegue calcolando, attraverso la funzione di risposta, lo spazio degli spostamenti corrispondente alla tensione, introducendo altre costanti di integrazione.
Dalle equazioni di vincolo si generano le equazioni algebriche da cui si calcolano infine tutte le costanti.

Vincoli "eccedenti"  => equazioni di bilancio al bordo "in difetto"
Vincoli "in difetto" => equazioni di bilancio al bordo "eccedenti"  (occorre verificare la compatibilita' delle forze al bordo)

Le lunghezze dei vari tratti possono essere assegnate utilizzando una lunghezza base (ad esempio ℒ ), in modo che non compaiano in tutte le espressioni  L[1], L[2] ecc.; così pure gli angoli. Occorre poi assegnare i valori di tali parametri in datiO per poter realizzare le figure.

Inizializzazione

\(\(outputDir = "C:/Wrk/Corsi/Scost/esercizi/7-travi/7-08/outmath";\)\)

SetDirectory[outputDir]

In fase di modifica del notebook riattivare gli "spelling warning"

Off[General::"spell"];
Off[General::"spell1"];

Off[Solve::"svars"];
<<  LinearAlgebra`MatrixManipulation`;
<< Graphics`Colors`;
SetOptions[Plot, ImageSize -> 228];
SetOptions[ParametricPlot, 
        ImageSize -> {200, 200}];
SetOptions[Plot, PlotRange -> All];
SetOptions[ParametricPlot, PlotRange -> All];

Descrizione della configurazione originaria [D1]

Definizione delle basi

Base del sistema di coordinate  (non modificare)

(Subscript[e, 1]) = {1, 0};
(Subscript[e, 2]) = {0, 1};

Basi adattate alla sezione di ciascun tratto  (non modificare)

(Subscript[a, 1])[i_] := 
        Cos[α[i]] (Subscript[e, 1]) + Sin[α[i]] (Subscript[e, 2]);
(Subscript[a, 2])[i_] := -Sin[α[i]] (Subscript[e, 1]) + 
          Cos[α[i]] (Subscript[e, 2]);

Dati [D1]

Numero di tratti di trave

travi = 1;

Angoli che definiscono le basi adattate (possono anche non essere assegnati; in tal caso se ne assegni il valore nella lista datiO)
[ l'uso di caratteri script per i parametri rende tutto molto più leggibile]

α[1] = 0;

Lunghezze (possono anche non essere assegnate; in tal caso se ne assegni il valore nella lista successiva datiO)
[ l'uso caratteri script per i parametri rende tutto molto più leggibile]

L[1] = ℒ;

YA[1] := 𝒴𝒜  
YJ[1] := 𝒴𝒥

Valori numerici (di angoli e lunghezze) necessari alla visualizzazione e utilizzati solo per questo

datiO = {ℒ -> 1};

Altri dati EVENTUALMENTE assegnati (anche per ottenere espressioni più semplici).

𝒴𝒜 := 𝒴(𝒥/(κ (ℒ^2)))

Definizioni per la visualizzazione

lunghezza caratteristica

maxL = 
        Max[Table[
            L[i] /. datiO, {i, 1, travi}]];

definizione dell'asse

asseO[i_][ζ_] := 
        org[i] + (Subscript[a, 1])[i] ζ /. datiO;

Clear[org]

Coordinate dell'estremità sinistra di ciascun tratto (utilizzate solo per la visualizzazione dei tratti separati). Quelle deivanti dai vincoli sono descritte a parte, più avanti.

org[1] = {0, 0};

org[i_] := 
      org[i - 1] + {Max[(Subscript[(asseO[i - 1][0]), [[1]]]), (Subscript[(asseO[i - 1][L[i - 1]]), [[1]]])], 0} + {(maxL/10), 0}

definizione delle sezioni

secO[
          i_][ζ_] := {asseO[i][ζ] - 
            (maxL/20) (Subscript[a, 2])[i] , asseO[i][ζ] + 
            (maxL/20) (Subscript[a, 2])[i] } /. datiO

definizione della base adattata

vecOa1[
          i_][ζ_] := {{asseO[i][ζ], asseO[i][ζ] + 
              (maxL/5)  (Subscript[a, 1])[i]}, {asseO[i][ζ + (maxL/5)] + 
              (maxL/15) (-(Subscript[a, 1])[i] + (Subscript[a, 2])[i]/2), asseO[
                i][ζ + 
                (maxL/5)]}, {asseO[i][ζ + 
                  (maxL/5)] + ((maxL )/15) (-(Subscript[a, 1])[i] - 
                    (Subscript[a, 2])[i]/2), asseO[i][ζ + (maxL/5)]}} /. 
        datiO

vecOa2[
          i_][ζ_] := {{asseO[i][ζ], asseO[i][ζ] + 
              (maxL/5)  (Subscript[a, 2])[i]}, {asseO[i][ζ] + 
              (1/5) maxL (Subscript[a, 2])[
                  i] + ((maxL )/15) (-(1/2) (Subscript[a, 1])[i] - 
                    (Subscript[a, 2])[i]), asseO[i][ζ] + 
              (1/5) maxL (Subscript[a, 2])[i]}, {asseO[i][ζ] + 
              (1/5) maxL (Subscript[a, 2])[
                  i] + ((maxL )/15) ((Subscript[a, 1])[i]/2 - 
                    (Subscript[a, 2])[i]), asseO[i][ζ] + 
              (1/5) maxL (Subscript[a, 2])[i]}} /. datiO

numero di suddivisioni nel disegno di ciascun tratto

ndiv = 4;

disegno dell'asse (la definizione delle estremità sinistre cambierà più avanti)

pltO := 
        Table[Graphics[{AbsoluteThickness[2], 
              Line[{asseO[i][0], asseO[i][L[i]]}]}], {i, 1, 
            travi}];

pltOx := 
        Table[Graphics[{Line[{asseO[i][0], asseO[i][L[i]]}]}], {i, 1, 
            travi}];

disegno delle sezioni

pltOs := 
        Table[Table[
              Graphics[{Line[secO[i][j (( L[i])/ndiv)]]}], {j, 
                1, ndiv - 1}], {i, 1, travi}] // Flatten;

disegno della base adattata

pltOa := 
        Graphics[
          Table[{Black, AbsoluteThickness[2], 
              Line /@ Join[vecOa1[i][L[i]/2], vecOa2[i][
                    L[i]/2]]}, {i, 1, travi}]];

pltOax := 
        Graphics[
          Table[{Black, 
              Line /@ Join[vecOa1[i][L[i]/2], vecOa2[i][
                    L[i]/2]]}, {i, 1, travi}]];

Disegno della configurazione originaria di ciascuna trave e delle basi adattate

Show[pltO, pltOs, pltOa, DisplayFunction -> $DisplayFunction, 
        AspectRatio -> Automatic];

Distribuzione di forza applicata [D2]

Dati [D2]

b[i_][ζ_] := {0, 0}

c[i_][ζ_] := 0

Se la distribuzione è nulla assegnare il vettore e1 moltiplicato per 0 (zero)
(si possono anche usare dei parametri; in tal caso se ne assegni il valore nella lista dei dati numerici datip(D5))
[ l'uso caratteri script per i parametri rende tutto molto più leggibile]

b[1][ζ_] := -𝒷 (Subscript[e, 2])

Proprietà di  UnitStep  nel contesto di questo calcolo (da controllare ogni volta) [●]

Unprotect[UnitStep]

UnitStep[-ℒ] = 0;
UnitStep[-(ℒ/2)] = 
        0;
UnitStep[(ℒ/2)] = 1;
UnitStep[ℒ] = 1;

Protect[UnitStep]

Soluzione generale delle equazioni differenziali di bilancio (bulk)

Descrittori della tensione (forza normale, taglio e momento) e integrali delle equazioni di bilancio

s[
          i_][ζ_] := sN[i][ζ] (Subscript[a, 1])[
            i] + sQ[i][ζ] (Subscript[a, 2])[i]

m[i_][ζ_] := sM[i][ζ]

eqbilt[i_]:={((s[i])'[ζ]+b[i][ζ]).(Subscript[a, 1])[i]==0,((s[i])'[ζ]+b[i][ζ]).(Subscript[a, 2])[i]==0,(sM[i])'[ζ]+sQ[i][ζ]+c[i][ζ]==0}

svar = Flatten[Table[{sN[i], sQ[i], sM[i]}, {i, 1, travi}]]

eqbil = 
        Flatten[Simplify[Table[eqbilt[i], {i, 1, travi}]]];

bulksolC = DSolve[eqbil, svar, ζ, 
          DSolveConstants -> 𝒞][[1]]

Cambiamento delle costanti di integrazione

Viene costruita la lista cNQMO delle costanti di integrazione delle equazioni di bilancio. 
La lista cNQM delle costanti di integrazione presenti nelle condizioni al bordo, costruita più avanti, è in generale contenuta in questa.

cClist = Table[𝒞[i], {i, 1, 3  travi}]

cNQM = 
      Table[{sNo[i], sQo[i], sMo[i]}, {i, 1, travi}] // Flatten

Table[{sN[i][0] == sNo[i], sQ[i][0] == sQo[i], sM[i][0] == 
                sMo[i]} /. bulksolC, {i, 1, travi}] // Simplify // 
      Flatten

fromCtoNQM = (Subscript[(Solve[Table[{sN[i][0] == sNo[i], sQ[i][0] == sQo[i], sM[i][0] == sMo[i]} /. bulksolC, {i, 1, travi}] // Simplify // Flatten, cClist]), [[1]]])

bulksol = bulksolC /. fromCtoNQM

Equazioni di bilancio e integrali  (sintesi)

Table[eqbilt[i], {i, 1, travi}] // Simplify // Flatten // 
      ColumnForm

Table[svar[[
                  i]][ζ] == (svar[[i]][ζ] /. bulksolC), {i, 1, 
              Length[svar]}] // Simplify // Flatten // 
      ColumnForm

Table[svar[[
                  i]][ζ] == (svar[[i]][ζ] /. bulksol), {i, 1, 
              Length[svar]}] // Simplify // Flatten // 
      ColumnForm

Definizioni di spostamenti e forze al bordo

meno = "-"; più = "+";

Spostamento, atti di moto e forze al bordo come combinazioni lineari dei vettori delle basi adattate al bordo {d,n}

ub[i_][
          bd_] := (Subscript[ub, d])[i][bd] d[i][bd] + (Subscript[ub, n])[i][bd] n[i][
              bd];
wb[i_][
          bd_] := (Subscript[wb, d])[i][bd] d[i][bd] + (Subscript[wb, n])[i][bd] n[i][
              bd];
sb[i_][
          bd_] := (Subscript[sb, d])[i][bd] d[i][bd] + (Subscript[sb, n])[i][bd] n[i][
              bd];

Lista delle componenti dello spostamento al bordo

spbd = 
      Table[{(Subscript[ub, d])[i][#], (Subscript[ub, n])[i][#], θb[
                    i][#]} &  /@  {più, meno}, {i, 1, travi}] // 
        Flatten

Lista delle componenti dell'atto di moto al bordo

ambd = 
      Table[{(Subscript[wb, d])[i][#], (Subscript[wb, n])[i][#], ωb[
                    i][#]} &  /@  {più, meno}, {i, 1, travi}] // 
        Flatten

Lista delle componenti delle forze al bordo

fbd = 
      Table[{(Subscript[sb, d])[i][#], (Subscript[sb, n])[i][#], mb[
                    i][#]} &  /@  {più, meno}, {i, 1, travi}] // 
        Flatten

Basi adattate al bordo e vincoli [D3]

Descrizioni di vincoli standard

carrelloV[trv_][bnd_] := ub[trv][bnd] . n[trv][bnd] == 
        0

cernieraV[trv_][
        bnd_] := {ub[trv][bnd] . (Subscript[a, 1])[trv] == 
          0, ub[trv][bnd] . (Subscript[a, 2])[trv] == 0}

pernoV[trv1_, trv2_][bnd1_, 
        bnd2_] := {(ub[trv2][bnd2] - ub[trv1][bnd1]) . 
            (Subscript[a, 1])[trv2] == 
          0, (ub[trv2][bnd2] - ub[trv1][bnd1]) . (Subscript[a, 2])[trv2] == 
          0}

saldaturaV[trv1_, trv2_][bnd1_, 
        bnd2_] := {(ub[trv2][bnd2] - ub[trv1][bnd1]) . 
            (Subscript[a, 1])[trv2] == 
          0, (ub[trv2][bnd2] - ub[trv1][bnd1]) . (Subscript[a, 2])[trv2] == 
          0, θb[trv2][bnd2] - θb[trv1][bnd1] == 
          0}

incastroV[trv_][
        bnd_] := {ub[trv][bnd] . (Subscript[a, 1])[trv] == 
          0, ub[trv][bnd] . (Subscript[a, 2])[trv] == 0, θb[trv][bnd] == 
          0}

Per ogni nuova definizione, anche occasionale, occorre dare la corrispondente definizione della figura

Dati [D3]

n  vettore normale al piano di scorrimento di un carrello; 
d  vettore tangenziale;
{d, n} base ortonormale orientata come {e1, e2}

Clear[d, n];

d[i_][bd_] := (Subscript[e, 1]);
n[i_][bd_] := (Subscript[e, 2]);

Si assume che {d,n} siano identici a {e1,e2} a meno di una esplicita diversa definizione

Vincoli in forma scalare. Non usare esplicitamente le componenti ! Si pregiudicherebbe il meccanismo di sostituzione utilizzato nel calcolo della soluzione in termini di spostamento dalle equazioni di vincolo, oltre che incorrere più facilmente in errore. Utilizzare SEMPRE  vincoli definiti secondo il modello dei vincoli standard, anche per definizioni occasionali. Ricordare di dare una definizione anche della figura del vincolo per la visualizzazione.

vincoliDef := {incastro[1][meno], carrello[1][
          più]}

vincoli := Block[{carrello = carrelloV, cerniera = cernieraV, 
              perno = pernoV, incastro = incastroV, saldatura = saldaturaV}, 
            vincoliDef] // Flatten // Simplify

vincoli

Condizioni di vincolo come regole di sostituzione

vsp = Solve[ vincoli, 
            spbd][[1]] // 
        Sort

Definizioni per la visualizzazione

Condizioni di vincolo sui collegamenti tra le travi

Clear[coll]

vincoliDef

Complement[
      vincoliDef /. {carrello -> ((Null  &)  &), 
          incastro -> ((Null  &)  &), 
          cerniera -> ((Null  &)  &), perno -> coll, 
          saldatura -> coll}, {Null}]

Calcolo della posizione della estremità sinistra indotta dalla presenza di vincoli di collegamento tra le tarvi

Clear[org]

org[1] = {0, 0};

coll[i_, j_][bi_, bj_] := 
      Block[{p = 
            Sort[{{i, bi}, {j, 
                  bj}}, #(Subscript[1, [[1]]]) < #(Subscript[2, [[1]]])  &]}, 
        Block[{ix = 
              (Subscript[p, [[1, 1]]]), 
            jx = (Subscript[p, [[2, 1]]]), bix = (Subscript[p, [[1, 2]]]), 
            bjx = (Subscript[p, [[2, 2]]])}, 
Switch[{bix, 
              bjx}, 
{più, 
              meno}, {org[jx] = 
                Evaluate[
                  org[ix] + (Subscript[a, 1])[ix] L[ix] /. 
                    datiO]}, 
{più, 
              più}, {org[jx] = 
                Evaluate[
                  org[ix] + (Subscript[a, 1])[ix] L[ix] - (Subscript[a, 1])[jx] L[jx] /. 
                    datiO]}, 
{meno, 
              meno}, {org[jx] = 
                Evaluate[org[ix] /. datiO]}, 
{meno, 
              più}, {org[jx] = 
                Evaluate[org[ix] - (Subscript[a, 1])[jx] L[jx] /. datiO]}]]]

Block[{carrello = ((Null  &)  &), 
        incastro = ((Null  &)  &), 
        cerniera = ((Null  &)  &), perno = coll, saldatura = coll}, 
      Complement[vincoliDef, {Null}]]

Definition[org]

Definizione delle funzioni che generano le figure dei vincoli

vincoliDef

vincoliFig := 
        Block[{carrello = carrelloFig, cerniera = cernieraFig, 
            perno = pernoFig, saldatura = saldaturaFig, 
            incastro = incastroFig}, vincoliDef];

vincolibFig := 
      Block[{carrello = crosshairFig, cerniera = crosshairFig, 
          perno = crosshairFig, saldatura = crosshairFig, 
          incastro = crosshairFig}, vincoliDef]

definizione delle estrremità dell'asse

asseOb[i_][meno] := asseO[i][0]

asseOb[i_][più] := asseO[i][L[i]]

crosshairFig[i_] [bd_] := 
      Graphics[{AbsoluteThickness[1], 
          Line[{asseOb[i][bd] - d[i][bd] (maxL/12), asseOb[i][
                  bd] + d[i][bd] (maxL/12)}], 
          Line[{asseOb[i][bd] - n[i][bd] (maxL/8), asseOb[i][
                  bd] + n[i][bd] (maxL/8)}], 
          Circle[asseOb[i][bd], 0.04]}]

crosshairFig[i_, j_] [bd_, bdj_] := 
      Graphics[{AbsoluteThickness[1], 
          Line[{asseOb[i][bd] - d[i][bd] (maxL/12), asseOb[i][
                  bd] + d[i][bd] (maxL/12)}], 
          Line[{asseOb[i][bd] - n[i][bd] (maxL/8), asseOb[i][
                  bd] + n[i][bd] (maxL/8)}], 
          Circle[asseOb[i][bd], 0.04]}]

incastroFig[i_] [bd_] := 
      Graphics[{AbsoluteThickness[2], 
          Line[{asseOb[i][bd] - (Subscript[a, 2])[i] (maxL/10), asseOb[i][bd] + 
                (Subscript[a, 2])[i] (maxL/10)}]}]

carrelloFig[i_] [bd_] := 
      Graphics[{AbsoluteThickness[2], 
          Line[{asseOb[i][
                bd], asseOb[i][bd] - (d[i][bd] + n[i][bd]) 
                  (maxL/10), asseOb[i][
                  bd] + (d[i][bd] - n[i][bd]) (maxL/10), asseOb[
                  i][bd]}], 
          Line[{asseOb[i][bd] - (d[i][bd] + n[i][bd]) 
                  (maxL/10) - n[i][bd] (maxL/50), asseOb[i][
                  bd] + (d[i][bd] - n[i][bd]) 
                  (maxL/10) - n[i][bd] (maxL/50)}], {GrayLevel[1], 
            Disk[asseOb[i][bd], 0.04]}, 
          Circle[asseOb[i][bd], 0.04]}]

cernieraFig[i_] [bd_] := 
      Graphics[{AbsoluteThickness[2], 
          Line[{asseOb[i][
                bd], asseOb[i][bd] - (d[i][bd] + n[i][bd]) 
                  (maxL/10), asseOb[i][
                  bd] + (d[i][bd] - n[i][bd]) (maxL/10), asseOb[
                  i][bd]}], {GrayLevel[1], Disk[asseOb[i][bd], 0.04]}, 
          Circle[asseOb[i][bd], 0.04]}]

pernoFig[i_, j_] [bd_, bdj_] := 
      Graphics[{AbsoluteThickness[2], {GrayLevel[1], 
            Disk[asseOb[i][bd], 0.04]}, 
          Circle[asseOb[i][bd], 0.04]}]

saldaturaFig[i_, j_] [bd_, bdj_] := 
      Graphics[{AbsoluteThickness[2], 
          Disk[asseOb[i][bd], 0.02]}]

pltOv := vincoliFig;

pltObv := vincolibFig;

Disegno della configurazione originaria con i vincoli

Show[pltO, pltOa, pltObv, DisplayFunction -> $DisplayFunction, 
        AspectRatio -> Automatic];

Show[pltO, pltOa, pltOv, DisplayFunction -> $DisplayFunction, 
        AspectRatio -> Automatic];

Elenco dei vincoli per ciascuna trave (sinistra, destra)

Gli spostamenti al bordo ub sono descritti nella base {e1, e2}, non nelle basi adattate ai vincoli, utilizzando le componenti nelle basi adattate ai vincoli {d,n} (vedi la definizione di ub, sopra).

TableForm[
      Table[(Append[ub[i][#], θb[i][#]] /. 
                vsp) &   /@  {meno, più}, {i, 1, travi}], 
      TableSpacing -> {4, 2, 2}]

vincoli // Simplify // ColumnForm

Generazione delle equazioni di bilancio al bordo

Potenza residua al bordo

Le forze al bordo sono da definire dopo la separazione tra forze attive e forze reattive

Espressione della potenza totale residua per la soluzione bulk (soluzione generale delle equazioni differenziali di bilancio)

pote := (∑_(i = 1)^travi)((sb[i][
                    più] . wb[i][più]) + (sb[i][
                    meno] . wb[i][meno]) + mb[i][
                  più] ωb[i][più] + mb[i][
                  meno] ωb[i][meno]) // Simplify

potbd := 
      pote - (∑_(i = 1)^travi)((s[i][L[i]] . wb[i][
                      più]) - (s[i][0] . wb[i][
                      meno]) + m[i][L[i]] ωb[i][
                    più] - m[i][0] ωb[i][meno]) // 
        Simplify

pote

Map[Factor, Collect[potbd, ambd], {2}]

Vincoli sugli atti di moto al bordo

Si generano le equazioni di vincolo omogenee per gli atti di moto

Map[(# == 0) &, LinearEquationsToMatrices[vincoli, 
            spbd][[1]] . 
        spbd]

Block[{ub = wb, θb = ωb}, vincoli] // Simplify

Condizioni di vincolo sugli atti di moto

vam = Solve[ 
            Map[(# == 0) &, LinearEquationsToMatrices[
                    Block[{ub = wb, θb = ωb}, vincoli], 
                    ambd][[1]] . 
                ambd], ambd][[1]] // 
        Sort

ambdv = Complement[ambd /. vam, {0}]

Potenza al bordo per atti di moto vincolati

potbdv = Collect[potbd /. vam, ambdv]

Equazioni di bilancio al bordo (corrispondenti agli atti di moto vincolati)

eqbilbd = (#1 == 0 &) /@ 
        Table[Coefficient[potbdv, 
            ambdv[[j]]], {j, 1, 
            Length[ambdv]}]

eqbilbd /. bulksol // Simplify

Matrice delle equazioni di bilancio al bordo

Vengono elencate le costanti di integrazione presenti nelle espressioni calcolate
(per sicurezza vengono utilizzate le espressioni con le costanti C)

cNQM

cNQMb = 
      Complement[
        Map[If[FreeQ[eqbilbd /. bulksol, #], 0, #]  &, 
          cNQM], {0}]

matbilbd = 
      LinearEquationsToMatrices[eqbilbd /. bulksol, cNQMb]

If[Length[cNQMb] > 0, 
      MatrixForm[
        matbilbd[[1]]]]

If[Length[cNQMb] > 0, 
      ColumnForm[
        matbilbd[[2]]]]

Rango della matrice delle equazioni di bilancio al bordo

ordine del sistema delle equazioni differenziali di bilancio

no = 3*travi

numero di costanti  nelle equazioni di bilancio al bordo per atti di moto vincolati (parametri dei descrittori della tensione da determinare)
tale numero potrebbe risultare inferiore a no

nc = Length[cNQMb]

numero di condizioni scalari di vincolo (o numero descrittori delle forze al bordo reattive)

nv = Length[vincoli]

numero di descrittori degli atti di moto vincolati (o numero descrittori delle forze al bordo attive)

nf = Length[ambdv]

controlli

{nf == Length[matbilbd[[1]]], 
      nc == no, nf == 2  no - nv}

rango = 
      nc - Length[
          If[Length[matbilbd[[1]]] > 0, 
            NullSpace[matbilbd[[1]]], 
            0]]

Proprietà dei vincoli e delle forze attive

\(StylePrint[
	\ \ \ \ \ " no -> "\  <> \ 
        ToString[no]\  <> \ 
	"
 nc -> "\  <> \ 
        ToString[nc]\  <> \ 
	"
 nv -> "\  <> \ 
        ToString[nv]\  <> 
	"
 nf -> "\  <> \ 
        ToString[nf]\  <> 
	"
 rango -> " <> ToString[rango], 
	
      FontSlant -> "Plain", CellFrame -> True, 
      Background -> Hue[0.17]]\)

\(\(\(If[\((nf ≠ \((2  no - nv)\))\), 
	
        StylePrint["Vincoli espressi da condizioni ripetute (rivedere le espressioni!)", FontSlant -> "Italic", CellFrame -> True, 
          Background -> Hue[0.17]]];\)\(
\)
    \)\)
\(\(If[\((nv < no)\) && \((rango == no)\), 
	
        StylePrint["Vincoli in difetto (le forze attive al bordo potrebbero non essere ammissibili)", FontSlant -> "Italic", 
          CellFrame -> True, Background -> Hue[0.17]]];\)\)
\(\(If[\((nv < no)\) && \((rango < no)\), 
	
        StylePrint["Vincoli in difetto e degeneri (le forze attive al bordo potrebbero non essere ammissibili)", FontSlant -> "Italic", 
          CellFrame -> True, Background -> Hue[0.17]]];\)\)
\(\(If[\((nv == no)\) && \((rango == nf)\), 
	
        StylePrint["Vincoli giusti (le forze attive al bordo possono essere qualsiasi)", FontSlant -> "Italic", CellFrame -> True, 
          Background -> Hue[0.17]]];\)\)
If[(nv == no) && (rango < nf), 
        StylePrint["Vincoli apparentemente giusti ma degeneri (le forze \
attive al bordo potrebbero non essere ammissibili)", 
          FontSlant -> "Italic", CellFrame -> True, 
          Background -> Hue[0.17]]];
\(\(If[\((nv > no)\) && \((rango == nf)\), 
	
        StylePrint["Vincoli eccedenti (le forze attive al bordo possono essere qualsiasi)", FontSlant -> "Italic", CellFrame -> True, 
          Background -> Hue[0.17]]];\)\)
\(\(If[\((nv > no)\) && \((rango < nf)\), 
	
        StylePrint["Vincoli apparentemente eccedenti ma degeneri (le forze attive al bordo potrebbero non essere ammissibili)", 
          FontSlant -> "Italic", CellFrame -> True, 
          Background -> Hue[0.17]]];\)\)

Forze assegnate al bordo [D4]

Elenco delle forze attive al bordo

Potenza delle forze al bordo in atti di moto vincolati

Map[Together, Collect[pote /. vam, ambdv], {2}] // Simplify

Forze attive al bordo (dalla espressione della potenza esterna si estraggono le forze corrispondenti a ciascun descrittore dell'atto di moto vincolato)

fabd = 
        Factor[Table[
            Coefficient[pote /. vam, 
              ambdv[[j]]], {j, 1, 
              Length[ambdv]}]];

If[Length[fabd] > 0, ColumnForm[fabd]]

Dati sulle forze assegnate al bordo [D4]

Condizioni assegnate alle forze al bordo. Si tratta in genere della selezione di un sottoinsieme descritto da alcuni parametri, come f ad esempio, il cui valore verrà assegnato tra i dati numerici [ l'uso caratteri script per i parametri rende tutto molto più leggibile]. I DATI VANNO ASSEGNATI IN FORMA DI EQUAZIONI (per via delle condizioni di continuità)

forze = { };

Una assegnazione esplicita dei dati sulle forze è la lista seguente, data qui come esempio e non assegnata a forze. Con sb si intende il vettore forza al bordo.

{(sb[1][più] + sb[2][meno]) . (Subscript[e, 1]) == 
          0, (sb[1][più] + sb[2][meno]) . (Subscript[e, 2]) == 
          0, mb[1][meno] == 0, mb[1][più] == 
          0, mb[2][meno] == 0, mb[2][più] == 
          0, sb[2][più] . d[2][più] == 
          0};

I dati sulle forze sono tradotti in una lista di sostituzioni

fabdp1 = Solve[forze, 
            fbd][[1]] // 
        Sort

Si controlla che tutti i valori siano stati assegnati e si  assegna il valore nullo ai rimanenti

Select[
      fabd /. fabdp1, (Length[Intersection[Variables[# /. fabdp1], fbd]] > 
            0)  &]

fabdp = 
      Join[fabdp1, Solve[Map[(# == 0)  &, %], 
              fbd][[1]]] // 
        Sort

Si fa un controllo finale

fabd /. fabdp

Test di compatibilità dei dati sulle forze

Il termine noto deve appartenere all'immagine, ovvero deve essere ortogonale allo spazio nullo della trasposta

ker = 
      Block[{ker0 = 
            If[nc > 0, 
              NullSpace[
                Transpose[
                  matbilbd[[1]]]], {}]}, 
        If[Length[ker0] > 0, ker0, {Array[0  &, nf]}]]

prodotto scalare dei vettori base del nucleo della trasposta per il termine noto; 
ciascun prodotto deve essere nullo; si selezionano i prodotti non nulli

spro = 
      Complement[
        ker . matbilbd[[2]] /. fabdp // 
          Flatten, {0}]

\(If[\((nf > rango)\), 
      If[\((Length[spro] > 0)\), 
	
        StylePrint["Non esiste soluzione per il sistema di forze assegnato (Abort)", FontWeight -> "Bold", FontSlant -> "Italic", 
          CellFrame -> True, Background -> Hue[1]]; 
        Interrupt[], 
	
        StylePrint["Il sistema di forze assegnato è ammissibile", 
          FontSlant -> "Italic", CellFrame -> True, 
          Background -> Hue[0.17]]]]\)

Soluzione delle equazioni di bilancio al bordo

Equazioni di bilancio al bordo

eqbilbd /. bulksol /. fabdp // Simplify

Soluzione delle equazioni di bilancio al bordo

\(If[\((nf == nc)\) && \((rango == nf)\) && \((nc > 0)\), 
      cNQMsol = 
        LinearSolve[matbilbd[[1]], 
          matbilbd[[2]] /. fabdp]; 
	
      cNQMval = 
        Table[cNQMb[[i]] -> 
            cNQMsol[[i]], {i, 1, 
            Length[cNQMb]}], 
	
      cNQMval = \(Solve[\(eqbilbd /. bulksol\) /. fabdp, 
            cNQMb]\)[[1]]]\)

Table[{sN[i][ζ], sQ[i][ζ], sM[i][ζ]} /. 
          bulksol, {i, 1, travi}] // Simplify

cNQMval

Funzioni di risposta e soluzione generale per lo spostamento (bulk)

Spostamento e gradiente

u[
          i_][ζ_] := (Subscript[u, 1])[i][ζ] (Subscript[a, 1])[
            i] + (Subscript[u, 2])[i][ζ] (Subscript[a, 2])[i]

grad={ϵ[i_]->Function[ζ,((Subscript[u, 1])[i])'[ζ]],γ[i_]->Function[ζ,((Subscript[u, 2])[i])'[ζ]-θ[i][ζ]],χ[i_]->Function[ζ,(θ[i])'[ζ]]}

Funzioni di risposta e vincolo di Bernoulli

\(risp = {sNf[i_] -> 
          Function[ζ, YA[i]\ \(ϵ[i]\)[ζ]], 
		sMf[
            i_] -> 
          Function[ζ, YJ[i]\ \(χ[i]\)[ζ]]}\)

Vincolo di scorrimento nullo (Modello di Eulero-Bernoulli)

vinBer={θ[i_]->Function[ζ,((Subscript[u, 2])[i])'[ζ]]}

Soluzione generale

Prima della sostisuzione delle soluzioni delle equazioni di bilancio al bordo e del vincolo di Eulero-Bernoulli

Table[{sN[i][ζ] == sNf[i][ζ], sM[
                      i][ζ] == sMf[i][ζ]}, {i, 1, travi}] /. 
            bulksol /. risp // Flatten // Simplify

Prima della sostituzione delle soluzioni delle equazioni di bilancio al bordo

eqnspO = Table[{sN[i][ζ] == sNf[i][ζ], sM[
                            i][ζ] == sMf[i][ζ]}, {i, 1, 
                      travi}] /. bulksol /. risp /. grad /. vinBer // 
          Flatten // Simplify

spsolDO = DSolve[eqnspO, 
            Flatten[Table[{(Subscript[u, 1])[i], (Subscript[u, 2])[i]}, {i, 1, travi}]], ζ, 
            DSolveConstants -> 𝒟][[1]] // Simplify

Dopo la sostisuzione delle soluzioni delle equazioni di bilancio al bordo

eqnsp = Table[{sN[i][ζ] == sNf[
                              i][ζ], sM[i][ζ] == sMf[
                              i][ζ]}, {i, 1, travi}] /. bulksol /. 
                  cNQMval /. risp /. grad /. vinBer // Flatten // 
        Simplify

spsolD = DSolve[eqnsp, 
            Flatten[Table[{(Subscript[u, 1])[i], (Subscript[u, 2])[i]}, {i, 1, travi}]], ζ, 
            DSolveConstants -> 𝒟][[1]] // Simplify

splist = 
      Table[{(Subscript[u, 1])[i][ζ], (Subscript[u, 2])[i][ζ], θ[
                i][ζ]}, {i, 1, travi}] // Flatten

splist /. vinBer /. spsolDO // Simplify

splist /. vinBer /. spsolD // Simplify

Cambiamento delle costanti di integrazione

Viene costruita la lista delle costanti di integrazione delle funzioni di risposta. 
La lista delle costanti di integrazione presenti nelle condizioni di vincolo in generale contiene la prima.

cDlistO = 
      Complement[
        Map[If[FreeQ[splist /. vinBer /. spsolD, #], 0, #]  &, 
          Table[𝒟[i], {i, 3 travi}]], {0}]

Vengono elencate le costanti di integrazione presenti nelle espressioni calcolate

\(cDlist = 
      Block[{splistV = \(splist /. vinBer\) /. spsolD}, 
          Join[
	Complement[
              Map[If[FreeQ[splistV, #], 0, #]\  &, cNQM], {0}], 
	
            Complement[
              Map[If[FreeQ[splistV, #], 0, #]\  &, cDlistO], {0}]
]] // 
        Union\)

Table[{(Subscript[u, 1])[i][0] == (Subscript[uo, 1])[i], (Subscript[u, 2])[i][0] == 
                  (Subscript[uo, 2])[i], θ[i][0] == θo[i]} /. 
              vinBer /. spsolD, {i, 1, travi}] // Simplify // 
      Flatten

fromDtoU = (Subscript[(Solve[%, cDlistO]), [[1]]])

cRlist = cDlist /. fromDtoU

Prima della sostituzione delle soluzioni delle equazioni di bilancio al bordo

spsolO = spsolDO /. fromDtoU

Dopo la sostisuzione delle soluzioni delle equazioni di bilancio al bordo

spsol = spsolD /. fromDtoU

Soluzione delle equazioni di vincolo

Equazioni di vincolo

Le variabili che hanno il significato di spostamenti al bordo vengono sostituite con i valori al bordo dello spostamento

\(eqvinO = 
      Block[{
		ub = \((Function[
                    j, \((Switch[j, meno, \(u[#]\)[0], 
                        più, \(u[#]\)[
                          L[#]]])\)] &)\), θb = \((Function[
                    j, \((Switch[j, meno, \(θ[#]\)[0], 
                        più, \(θ[#]\)[L[#]]])\)] &)\)
		}, 
          vincoli] // Simplify\)

Qui è essenziale che "vincoli" sia stata definita con ":=" e utilizzando il prodotto scalare invece che i nomi delle componenti dello spostamento.

eqvin = eqvinO /. vinBer /. spsol // Simplify

Matrice delle equazioni di vincolo

matvin = 
        LinearEquationsToMatrices[eqvin, cRlist] // Simplify;

MatrixForm[matvin[[1]]]

ColumnForm[matvin[[2]]]

Length[
      Transpose[matvin[[1]]]]

cRnull = 
      NullSpace[matvin[[1]]]

cRlist

Proprietà della soluzione

If[Length[cRnull] > 0, 
        StylePrint["La soluzione in termini di spostamento non è \
unica", FontSlant -> "Italic", CellFrame -> True, 
          Background -> Hue[0.17]]];

If[nv > Length[cRlist], 
        StylePrint["I cedimenti vincolari potrebbero non essere ammissibili\
", FontSlant -> "Italic", CellFrame -> True, 
          Background -> Hue[0.17]]];

Soluzione delle equazioni di vincolo

cRsol0 = 
      LinearSolve[matvin[[1]], 
        matvin[[2]]]

Clear[cA]

cRsol1 = Array[cA[#] &, Length[cRnull]] . cRnull;

cRsol = If[Length[cRnull] > 0, cRsol0 + cRsol1, cRsol0]

cRval = 
      Table[cRlist[[i]] -> 
            cRsol[[i]], {i, 1, 
            Length[cRlist]}] // Simplify

splist /. vinBer /. spsol /. cRval // Simplify // 
        Factor // ColumnForm

Espressioni delle soluzioni (N, Q, M), (u, v, θ), (forze al bordo)

Definizione di extraSimplify [●]

extraSimplify = (Simplify[
              Cancel[TrigExpand[#]]]  &);

extraSimplify = (Simplify[N[#]]  &);

extraSimplify = (Expand[N[#]]  &);

extraSimplify = Apart;

simplifyDirac[ζ_, Lo_, Li_][expr1__] := 
      Module[{g}, 
        Simplify[Distribute[(∫_Lo^Li)(Distribute[ 
                        Factor[
                            expr1] g[ζ]]) \[DifferentialD]ζ] /. (∫_Lo^Li) g[ζ] anyexpr_ \[DifferentialD]ζ -> 
                anyexpr /. (∫_Lo^Li) 
                    g[ζ] \[DifferentialD]ζ -> 1]]

extraSimplify = (#  &);

extraSimplify = simplifyDirac[ζ, 0, L[i]];

extraSimplify = (Simplify[
              Collect[#, {DiracDelta[__], 
                  UnitStep[__]}]]  &);

Selezione automatica della funzione di semplificazione extraSimplify, basata sulla verifica della presenza di UnitStep o DiracDelta nella espressione di N, Q, M

If[FreeQ[(#[ζ]  &) /@ svar /. bulksolC, UnitStep] && 
        FreeQ[(#[ζ]  &) /@ svar /. bulksolC, DiracDelta], 
      extraSimplify = (#  &), 
      extraSimplify = (Simplify[
              Collect[#, {DiracDelta[__], UnitStep[__]}]]  &)]

Espressioni delle costanti di integrazione

Map[Factor, cNQMval // Simplify // extraSimplify, {2}]

Map[Factor, cRval // Simplify // extraSimplify, {2}]

Sollecitazioni

Forza normale

\(TableForm[
      Table[{"trave " <> 
            ToString[
              i], \(\(\(\(sN[i]\)[ζ] /. bulksol\) /. cNQMval\) /. 
                cRval // Simplify\) // extraSimplify}, 
	{i, 1, travi}], 
      TableDepth -> 2, TableAlignments -> Left]\)

Forza di taglio

\(TableForm[
      Table[{"trave " <> 
            ToString[
              i], \(\(\(\(sQ[i]\)[ζ] /. bulksol\) /. cNQMval\) /. 
                cRval // Simplify\) // extraSimplify}, 
	{i, 1, travi}], 
      TableDepth -> 2, TableAlignments -> Left]\)

Momento

\(TableForm[
      Table[{"trave " <> 
            ToString[
              i], \(\(\(\(sM[i]\)[ζ] /. bulksol\) /. cNQMval\) /. 
                cRval // Simplify\) // extraSimplify}, 
	{i, 1, travi}], 
      TableDepth -> 2, TableAlignments -> Left]\)

Spostamenti

Spostamento assiale

\(TableForm[
      Table[{"trave " <> 
            ToString[
              i], \(\(\(\(u\_1[i]\)[ζ] /. vinBer\) /. spsol\) /. cRval // 
              Simplify\) // extraSimplify}, 
	{i, 1, travi}], 
      TableDepth -> 2, TableAlignments -> Left]\)

Spostamento trasversale

\(TableForm[
      Table[{"trave " <> 
            ToString[
              i], \(\(\(\(u\_2[i]\)[ζ] /. vinBer\) /. spsol\) /. cRval // 
              Simplify\) // extraSimplify}, 
	{i, 1, travi}], 
      TableDepth -> 2, TableAlignments -> Left]\)

Rotazione

\(TableForm[
      Table[{"trave " <> 
            ToString[
              i], \(\(\(\(θ[i]\)[ζ] /. vinBer\) /. spsol\) /. 
                cRval // Simplify\) // extraSimplify}, 
	{i, 1, travi}], 
      TableDepth -> 2, TableAlignments -> Left]\)

Forze e momenti al bordo calcolati (parte attiva e parte reattiva)

Definition[extraSimplify]

Forze (bordo sinistro e bordo destro)

Le componenti sono nella base {e1, e2}

\(TableForm[
      Table[\(\(\({"trave " <> ToString[i], \(-\(s[i]\)[0]\), \(s[i]\)[
                      L[i]]} /. bulksol\) /. cNQMval\) /. cRval // 
            Simplify\) // extraSimplify, 
	{i, 1, travi}], TableDepth -> 2, 
      TableAlignments -> Left]\)

Momenti (bordo sinistro e bordo destro)

\(TableForm[
      Table[\(\(\({"trave " <> ToString[i], \(-\(m[i]\)[0]\), \(m[i]\)[
                      L[i]]} /. bulksol\) /. cNQMval\) /. cRval // 
            Simplify\) // extraSimplify, 
	{i, 1, travi}], TableDepth -> 2, 
      TableAlignments -> Left]\)

Verifiche: forza risultante

\(TableForm[
      Table[\(\(\({"trave " <> 
                      ToString[i], \(-\(s[i]\)[0]\) + \(s[i]\)[
                        L[i]] + ∫\_0\%\(L[i]\)Evaluate[\(b[
                                i]\)[ζ]] \[DifferentialD]ζ} /. 
                  bulksol\) /. cNQMval\) /. cRval // Simplify\) // 
          extraSimplify, 
	{i, 1, travi}], TableDepth -> 2, 
      TableAlignments -> Center]\)

Verifiche: momento risultante

\(TableForm[
      Table[extraSimplify[
          Simplify[\(\({"trave " <> 
                      ToString[i], \(-\(m[i]\)[0]\) + \(m[i]\)[
                        L[i]] + \(s[i]\)[L[i]] . a\_2[i]\ L[
                          i] + ∫\_0\%\(L[i]\)\(\(b[i]\)[ζ] . 
                              a\_2[i]\ ζ\) \[DifferentialD]ζ + ∫\_0\%\(L[i]\)\(c[
                              i]\)[ζ] \[DifferentialD]ζ} /. bulksol\) /. cNQMval\) /. cRval]], {i, 1, travi}], 
      TableDepth -> 2, TableAlignments -> Center]\)

Dati numerici [D5]

Sono assegnati valori numerici alle rigidezze e ai parametri che descrivono le forse attive.

datip = {𝒷 -> 
            100, 𝒴𝒥 -> 
            10, κ -> 0.01};

Potrebbe essere necessario assegnare dei valori (arbitrari) ai coefficienti cA[i] per selezionare una delle molteplici soluzioni 
Sono assegnati automaticamente dei valori nulli ai coefficienti A[i]

cAval0 = 
      If[Length[cRnull] > 0, 
        Table[cA[i] -> 0, {i, 1, Length[cRnull]}], {}]

Se si vogliono assegnare altri valori, farlo qui. Altrimenti assegnare una lista vuota:  iAval={}

cAval = {};

cAval1 = 
      If[(Length[cRnull] > 0) && (Length[cAval] == Length[cRnull]), 
        cAval, cAval0]

datinum = Join[datiO, datip, cAval1]

Visualizzazione delle soluzioni (N, Q, M) (u, v, θ)

Definizioni

sNQM[
          i_][ζ_] := {sN[i][ζ], sQ[
                    i][ζ], sM[i][ζ]} /. bulksol /. 
            cNQMval /. cRval // Simplify

spuvθ[
          i_][ζ_] := {(Subscript[u, 1])[i][ζ], (Subscript[u, 2])[
                  i][ζ], θ[i][ζ]} /. vinBer /. 
          spsol /. cRval

Eventuali valutazioni

spuvθ[1][0] // Simplify

spuvθ[1][L[1]] // Factor

spuvθ[2][0] // Simplify // Factor

spuvθ[2][L[2]] // Simplify // Factor

sNQM[1][0] // Simplify // Factor

sNQM[1][L[1]] // Simplify // Factor

sNQM[2][0] // Simplify // Factor

sNQM[2][L[2]] // Simplify // Factor

Funzioni per la visualizzazione

Assegnare a  ticksOption    Automatic   per avere gli assi graduati,   None;  altrimenti

Adattare  PlotRange o lasciare   All

grNQM[it_]:=GraphicsArray[{Table[Plot[Evaluate[{0, sNQM[
                                  it][ζ][[
                              i]] /. datinum // 
                          Simplify}],Evaluate[{ζ, 0, L[it]} /. datinum],DisplayFunction -> Identity,Ticks -> ticksOption,PlotRange -> {All, All, All}_([[i]]),PlotStyle->{Black,{Thickness[0.004],(Subscript[{Hue[0.5],Hue[0.6],Hue[0.85]}, [[i]]])}}],{i, 1, 3}]},GraphicsSpacing -> 0.4]

gruvθ[it_]:=GraphicsArray[{Table[Plot[Evaluate[{0, spuvθ[
                                  it][ζ][[
                              i]] /. datinum // 
                          Simplify}],Evaluate[{ζ, 0, L[it]} /. datinum],DisplayFunction -> Identity,Ticks -> ticksOption,PlotRange -> {All, All, All}_([[i]]),PlotStyle->{Black,{Thickness[0.004],(Subscript[{Hue[0.15],Hue[0.10],Hue[0.22]}, [[i]]])}}],{i, 1, 3}]},GraphicsSpacing -> 0.3]

Assegnare a  ticksOption    Automatic   per avere gli assi graduati,   None;  altrimenti

ticksOption = {None, None};

Grafici dei descrittori della tensione (N, Q, M)

Do[Show[grNQM[it], ImageSize -> {420, Automatic}], {it, 1, 
        travi}]

Grafici dello spostamento (u, v, θ)

Do[
        Show[gruvθ[it], ImageSize -> {420, Automatic}], {it, 1, 
          travi}];

Visualizzazione della deformazione [●]

Definizioni per la visualizzazione

Si vedano anche le definizioni già date per realizzare il disegno della configurazione originaria

asseD[
          i_][ζ_] := org[i] + 
              (Subscript[a, 1])[i] ζ + u[
                  i][ζ] /. spsol /. cRval /. datinum

secD[
          i_][ζ_] := {asseD[i][ζ] - 
                  (maxL/20) (-θ[i][ζ] (Subscript[a, 1])[i] + 
                        (Subscript[a, 2])[i]) , asseD[i][ζ] + 
                  (maxL/20) (-θ[i][ζ] (Subscript[a, 1])[i] + 
                        (Subscript[a, 2])[i]) } /. vinBer /. spsol /. cRval /. datinum

disegno dell'asse

pltD = 
        ParametricPlot[
          Evaluate[
            Flatten[Table[{asseD[i][L[i] ξ]}, {i, 1, travi}], 
              1]], {ξ, 0, 1}, Axes -> False, 
          AspectRatio -> Automatic, DisplayFunction -> Identity, 
          PlotStyle -> Hue[1]];

disegno delle sezioni

pltDs = 
        Table[Table[
              Graphics[{Hue[1], 
                  Line[secD[i][j (( L[i])/ndiv)]]}], {j, 1, 
                ndiv - 1}], {i, 1, travi}] // Flatten;

pltDv = Block[{asseO = asseD}, vincoliFig /. datinum]

pltDbv = Block[{asseO = asseD}, vincolibFig /. datinum]

Definizione cornice

Serve per ottenere figure confrontabili. Scegliere i parametri in modo che la figura sia contenuta nel rettangolo di sfondo. Verificare che anche i diagrammi N Q M risultino contenuti nel rettangolo.

xMax = 
      Max /@ N[Transpose[
              Flatten[Table[{asseO[i][0], asseO[i][
                      L[i]], asseD[i][0], asseD[i][L[i]]}, {i, 1, 
                    travi}], 1]] /. datinum]

xMin = 
      Min /@ N[Transpose[
              Flatten[Table[{asseO[i][0], asseO[i][
                      L[i]], asseD[i][0], asseD[i][L[i]]}, {i, 1, 
                    travi}], 1]] /. datinum]

xDiag := (xMax - xMin) + ((Subscript[e, 1]) + (Subscript[e, 2])) 0.001

xLowerL := xC - mU . (xDiag/2);
xUpperR := xC + mU . (xDiag/2);

frameb := 
        Graphics[{GrayLevel[0.9], Rectangle[xLowerL, xUpperR]}];

frame := 
        Graphics[{GrayLevel[0], {Point[xLowerL], 
              Point[xUpperR]}}];

xC := ((xMax + xMin)/2) + xCshift

Adattamento cornice [●]

Il rettangolo di sfondo risulta definito dalla posizione del centro e dalla dilatazione dei lati

xCshift = 0.05 (Sqrt[ xDiag . xDiag]) ((Subscript[e, 2]))

mU=(({{1.2, 0}, {0, 512}}));

{(xUpperR - xLowerL), xC}

Figura

Show[frameb, frame, pltO, pltOs, pltOax, pltObv, pltD, pltDs, pltDbv, 
        DisplayFunction -> $DisplayFunction, 
        AspectRatio -> Automatic, PlotRange -> All];

Show[frameb, frame, pltO, pltOs, pltOax, pltOv, pltD, pltDs, pltDv, 
        DisplayFunction -> $DisplayFunction, 
        AspectRatio -> Automatic, PlotRange -> All];

Diagrammi tecnici  (N, Q, M) [●]

Definizioni

Si vedano anche le definizioni già date per realizzare il disegno della configurazione originaria

diaN[i_][ζ_] := asseO[i][ζ] + 
        scN sNQM[
                i][ζ][[1]] (Subscript[a, 2])[i]

Valori al bordo

diaNb[
        i_] := {asseO[i][0] + 
          scN sNQM[i][
                0][[1]] (Subscript[a, 2])[
              i] ξ, asseO[i][L[i]] + 
          scN sNQM[i][
                L[i]][[1]] (Subscript[a, 2])[
              i] ξ}

Segni dei valori al bordo

diaNs[i_] := 
      Block[{y1 = 
              scN sNQM[i][
                      0][[1]] /. datinum, 
            y2 = scN sNQM[i][
                      L[i]][[1]] /. datinum, 
            pt1 = asseO[i][0] + 0.5 y1 (Subscript[a, 2])[i] + 0.04 (Subscript[a, 1])[i], 
            pt2 = asseO[i][L[i]] + 0.5 y2 (Subscript[a, 2])[i] - 0.04 (Subscript[a, 1])[i], 
            dsh = 0.04}, 
          Complement[{If[y1 ≠ 0, 
                pt1 + dsh (Subscript[a, 1])[i] (ξ - 0.5)], 
              If[y1 > 0, pt1 + dsh (Subscript[a, 2])[i] (ξ - 0.5)], 
              If[y2 ≠ 0, pt2 + dsh (Subscript[a, 1])[i] (ξ - 0.5)], 
              If[y2 > 0, 
                pt2 + dsh (Subscript[a, 2])[
                      i] (ξ - 
                        0.5)]}, {Null}]] /. datinum

figN := 
        Table[diaN[i][L[i] ξ], {i, 1, travi}] /. 
          datinum;

figNb := 
        Flatten[Table[diaNb[i], {i, 1, travi}], 1] /. datinum;

figNs := 
        Flatten[Table[diaNs[i], {i, 1, travi}], 1] /. datinum;

pltN := 
        ParametricPlot[Evaluate[Join[figN, figNb, figNs]], {ξ, 0, 1}, 
          Axes -> False, AspectRatio -> Automatic, 
          DisplayFunction -> Identity, 
          PlotStyle -> {{Hue[0.4]}}];

diaQ[i_][ζ_] := asseO[i][ζ] - 
        scQ sNQM[
                i][ζ][[2]] (Subscript[a, 2])[i]

diaQb[
        i_] := {asseO[i][0] - 
          scQ sNQM[i][
                0][[2]] (Subscript[a, 2])[
              i] ξ, asseO[i][L[i]] - 
          scQ sNQM[i][
                L[i]][[2]] (Subscript[a, 2])[
              i] ξ}

diaQs[i_] := 
      Block[{y1 = 
              scQ sNQM[i][
                      0][[2]] /. datinum, 
            y2 = scQ sNQM[i][
                      L[i]][[2]] /. datinum, 
            pt1 = asseO[i][0] - 0.5 y1 (Subscript[a, 2])[i] + 0.04 (Subscript[a, 1])[i], 
            pt2 = asseO[i][L[i]] - 0.5 y2 (Subscript[a, 2])[i] - 0.04 (Subscript[a, 1])[i], 
            dsh = 0.04}, 
          Complement[{If[y1 ≠ 0, 
                pt1 + dsh (Subscript[a, 1])[i] (ξ - 0.5)], 
              If[y1 > 0, pt1 + dsh (Subscript[a, 2])[i] (ξ - 0.5)], 
              If[y2 ≠ 0, pt2 + dsh (Subscript[a, 1])[i] (ξ - 0.5)], 
              If[y2 > 0, 
                pt2 + dsh (Subscript[a, 2])[
                      i] (ξ - 
                        0.5)]}, {Null}]] /. datinum

figQ := 
        Table[diaQ[i][L[i] ξ], {i, 1, travi}] /. 
          datinum;

figQb := 
        Flatten[Table[diaQb[i], {i, 1, travi}], 1] /. datinum;

figQs := 
        Flatten[Table[diaQs[i], {i, 1, travi}], 1] /. datinum;

pltQ := 
        ParametricPlot[Evaluate[Join[figQ, figQb, figQs]], {ξ, 0, 1}, 
          Axes -> False, AspectRatio -> Automatic, 
          DisplayFunction -> Identity, 
          PlotStyle -> {{Hue[0.6]}}];

diaM[i_][ζ_] := asseO[i][ζ] - 
        scM sNQM[
                i][ζ][[3]] (Subscript[a, 2])[i]

diaMb[
        i_] := {asseO[i][0] - 
          scM sNQM[i][
                0][[3]] (Subscript[a, 2])[
              i] ξ, asseO[i][L[i]] - 
          scM sNQM[i][
                L[i]][[3]] (Subscript[a, 2])[
              i] ξ}

figM := 
        Table[diaM[i][L[i] ξ], {i, 1, travi}] /. 
          datinum;

figMb := 
        Flatten[Table[diaMb[i], {i, 1, travi}], 1] /. datinum;

pltM := 
        ParametricPlot[Evaluate[Join[figM, figMb]], {ξ, 0, 1}, 
          Axes -> False, AspectRatio -> Automatic, 
          DisplayFunction -> Identity, 
          PlotStyle -> {{Hue[0.8]}}];

Fattori di scala [●]

scN := scQ;

scQ = 0.005;

scM = 0.02;

Diagramma della forza normale

Show[frameb, pltO, pltN, DisplayFunction -> $DisplayFunction, 
        AspectRatio -> Automatic, PlotRange -> All];

Diagramma del taglio

Show[frameb, pltO, pltQ, DisplayFunction -> $DisplayFunction, 
        AspectRatio -> Automatic, PlotRange -> All];

Diagramma del momento

Show[frameb, pltO, pltM, DisplayFunction -> $DisplayFunction, 
        AspectRatio -> Automatic, PlotRange -> All];

Salvataggio figure in formato EPS

Directory[]

phframe = 
        Graphics[{GrayLevel[1], {Point[xLowerL], Point[xUpperR]}}] /. 
          datinum;

Do[Display["grNQM-" <> ToString[it] <> ".eps", 
        Show[grNQM[it], ImageSize -> {320, Automatic}, 
          DisplayFunction -> Identity], "EPS"], {it, 1, 
        travi}]

Do[Display["gruv-" <> ToString[it] <> ".eps", 
        Show[gruvθ[it], ImageSize -> {320, Automatic}, 
          DisplayFunction -> Identity], "EPS"], {it, 1, 
        travi}]

Adattare ImageSize nei comandi seguenti

Block[{sc = 100}, 
{imageW = 
          sc*(Subscript[((xUpperR - xLowerL)), [[1]]]) // Floor, 
imageH = 
          sc*(Subscript[((xUpperR - xLowerL)), [[2]]]) // Floor}]

Display["dis0.eps", 
        Show[phframe, pltO, pltOv, ImageSize -> {imageW, imageH}, 
          AspectRatio -> Automatic, DisplayFunction -> Identity, 
          PlotRange -> All], "EPS"];

Display["basi.eps", 
        Show[phframe, pltOx, pltOax, ImageSize -> {imageW, imageH}, 
          AspectRatio -> Automatic, DisplayFunction -> Identity, 
          PlotRange -> All], "EPS"];

Display["deform.eps", 
        Show[phframe, pltO, pltOs, pltD, pltDs, 
          ImageSize -> {imageW, imageH}, AspectRatio -> Automatic, 
          DisplayFunction -> Identity, 
          PlotRange -> All], "EPS"];

Display["diaN.eps", 
        Show[phframe, pltO, pltN, ImageSize -> {imageW, imageH}, 
          AspectRatio -> Automatic, DisplayFunction -> Identity, 
          PlotRange -> All], "EPS"];

Display["diaQ.eps", 
        Show[phframe, pltO, pltQ, ImageSize -> {imageW, imageH}, 
          AspectRatio -> Automatic, DisplayFunction -> Identity, 
          PlotRange -> All], "EPS"];

Display["diaM.eps", 
        Show[phframe, pltO, pltM, ImageSize -> {imageW, imageH}, 
          AspectRatio -> Automatic, DisplayFunction -> Identity, 
          PlotRange -> All], "EPS"];

Salvataggio espressioni in formato TEX

Definizioni generali

Directory[]

{α, b, c, d, f, L, M, YA, YJ}

Controllare che le variabili precedenti non abbiano un valore. Per sicurezza vengono utilizzati gli apici.

myTeXForm[exp_] := 
      Block[{α}, 
        TeXForm[Evaluate[
            exp /. {𝒶 -> α, 𝒷 -> 
                  b, 𝒸 -> c, 𝒹 -> 
                  d, 𝒻 -> f, ℒ -> 
                  L, ℳ -> 
                  M, 𝒴𝒜  -> 
                  YA ,  𝒴𝒥 -> 
                  YJ}]]]

Definition[extraSimplify]

Questa funzione serve ad apporre la numerazione delle travi ai simboli delle variabili
[ATTENZIONE al fatto che tale definizione potrebbe dar luogo a LOOP senza fine nel caso di una sola trave]

newsym[var_[n_]] := 
      If[travi > 1, Superscript[var, "\\bn{" <> ToString[n] <> "}"], 
        var]

La seconda definizione di newsym è utilizzata per costruire le espressioni di forze e momenti alle estremità (bd è più o meno)

newsym[var_[n_, bd_]] := 
      If[travi > 1, 
        Superscript[
          var, "\\bbn{" <> ToString[n] <> "}{" <> bd <> "}"], 
        var^bd]

newsymlist1 = {sNo[bn_] :> newsym[sNo[bn]], 
          sQo[bn_] :> newsym[sQo[bn]], 
          sMo[bn_] :> newsym[sMo[bn]], 
          sN[bn_] :> newsym[sN[bn]], 
          sQ[bn_] :> newsym[sQ[bn]], 
          sM[bn_] :> newsym[sM[bn]]};

newsymlist2 = {(Subscript[u, 1])[bn_] :> newsym[u1[bn]], 
          (Subscript[u, 2])[bn_] :> 
            newsym[u2[bn]], θ[bn_] :> 
            newsym[theta[bn]]};

newsymlist3 = {sNo[bn_] :> newsym[sNo[bn]], 
          sQo[bn_] :> newsym[sQo[bn]], 
          sMo[bn_] :> newsym[sMo[bn]], 
          (Subscript[uo, 1])[bn_] :> newsym[u1o[bn]], 
          (Subscript[uo, 2])[bn_] :> 
            newsym[u2o[bn]], θo[bn_] :> 
            newsym[thetao[bn]], (Subscript[u, 1])[bn_] :> newsym[u1[bn]], 
          (Subscript[u, 2])[bn_] :> 
            newsym[u2[bn]], θ[bn_] :> 
            newsym[theta[bn]]};

newsymlist4 = {sNo[bn_] :> newsym[sNo[bn]], 
          sQo[bn_] :> newsym[sQo[bn]], 
          sMo[bn_] :> newsym[sMo[bn]]};

newsymlist5 = {sNo[bn_] :> newsym[sNo[bn]], 
          sQo[bn_] :> newsym[sQo[bn]], 
          sMo[bn_] :> newsym[sMo[bn]], 
          (Subscript[uo, 1])[bn_] :> newsym[u1o[bn]], 
          (Subscript[uo, 2])[bn_] :> 
            newsym[u2o[bn]], θo[bn_] :> 
            newsym[thetao[bn]]};

newsymlist6 = {s[bn_, bd_] :> newsym[s[bn, bd]], 
          m[bn_, bd_] :> newsym[m[bn, bd]], 
          (Subscript[s, 1])[bn_, bd_] :> newsym[(Subscript[s, 1])[bn, bd]], 
          (Subscript[s, 2])[bn_, bd_] :> newsym[(Subscript[s, 2])[bn, bd]]};

Forma TEX delle equazioni di bilancio

Notare la tecnica utilizzata per generare la forma TEX di equazioni, separando i due mebri.

texBil1[i_, j_] := 
      myTeXForm[
        Evaluate[(Subscript[(eqbilt[i]), [[1, j]]]) // Simplify] /. newsymlist]

texBil2[i_, j_] := 
      myTeXForm[
        Evaluate[(Subscript[(eqbilt[i]), [[2, j]]]) // Simplify] /. newsymlist]

texBil3[i_, j_] := 
      myTeXForm[
        Evaluate[(Subscript[(eqbilt[i]), [[3, j]]]) // Simplify] /. newsymlist]

\(Block[{stFile = OpenWrite["expBil.tex"]}, 
      Block[{newsymlist = newsymlist1}, 
        Do[
WriteString[stFile, texBil1[i, 1], " &= ", 
            texBil1[i, 2]]; 
          WriteString[
            stFile, " \>,    \", "\[2\jot]
"]; 
WriteString[stFile, texBil2[i, 1], " &= ", 
            texBil2[i, 2]]; 
          WriteString[
            stFile, " \>,    \", "\[2\jot]
"]; 
WriteString[stFile, texBil3[i, 1], " &= ", 
            texBil3[i, 2]]; 
If[i < travi, 
            WriteString[stFile, " \>,    \", "\[2\jot]
"], 
            WriteString[stFile, " \>."]];, {i, 1, 
            travi}]]; 
Close[stFile]]\)

Forma TEX degli integrali delle equazioni di bilancio

texNin[i_] := 
      myTeXForm[
        Evaluate[sN[i][ζ] /. bulksol // Simplify // 
              extraSimplify] /. newsymlist]

texQin[i_] := 
      myTeXForm[
        Evaluate[sQ[i][ζ] /. bulksol // Simplify // 
              extraSimplify] /. newsymlist]

texMin[i_] := 
      myTeXForm[
        Evaluate[sM[i][ζ] /. bulksol // Simplify // 
              extraSimplify] /. newsymlist]

texNn[i_] := myTeXForm[sN[i][ζ] /. newsymlist]

texQn[i_] := myTeXForm[sQ[i][ζ] /. newsymlist]

texMn[i_] := myTeXForm[sM[i][ζ] /. newsymlist]

\(Block[{stFile = OpenWrite["expNQMin.tex"]}, 
      Block[{newsymlist = newsymlist1}, 
        Do[
WriteString[stFile, texNn[i], " &= ", 
            texNin[i]]; 
          WriteString[
            stFile, "\>,    \", "\[2\jot]
"]; 
WriteString[stFile, texQn[i], " &= ", texQin[i]]; 
          WriteString[
            stFile, "\>,    \", "\[2\jot]
"]; 
WriteString[stFile, texMn[i], " &= ", 
            texMin[i]]; 
If[i < travi, 
            WriteString[stFile, "\>,    \", "\[2\jot]
"], 
            WriteString[stFile, "\>."]];, {i, 1, 
            travi}]]; 
Close[stFile]]\)

Forma TEX delle condizioni di vincolo

Notare la tecnica utilizzata per generare la forma TEX di equazioni, separando i due mebri.

texvincO[i_, j_] := 
      myTeXForm[(Subscript[(Evaluate[eqvinO // Simplify // extraSimplify]), [[i, j]]]) /. 
          newsymlist]

texvinc[i_, j_] := 
      myTeXForm[(Subscript[(Evaluate[eqvin // Simplify // extraSimplify]), [[i, j]]]) /. 
          newsymlist]

Block[{stFile = OpenWrite["expVincO.tex"]}, 
      Block[{newsymlist = newsymlist2}, 
        Do[WriteString[stFile, texvincO[i, 1], " &= ", 
            texvincO[i, 2]]; 
If[i < Length[eqvinO], 
            WriteString[stFile, " \\>,    \\", "\[2\jot]\n"], 
            WriteString[stFile, " \\>."]];, {i, 1, 
            Length[eqvinO]}]]; 
Close[stFile]]

Block[{stFile = OpenWrite["expVinc.tex"]}, 
      Block[{newsymlist = newsymlist3}, 
        Do[WriteString[stFile, "& ", texvinc[i, 1], " = ", 
            texvinc[i, 2]]; 
If[i < Length[eqvin], 
            WriteString[stFile, " \\>,    \\", "\[2\jot]\n"], 
            WriteString[stFile, " \\>."]];, {i, 1, 
            Length[eqvin]}]]; 
Close[stFile]]

Forma TEX delle equazioni di bilancio al bordo

Notare la tecnica utilizzata per generare la forma TEX di equazioni, separando i due mebri.

texeqbdO[i_, j_] := 
      myTeXForm[(Subscript[(Evaluate[eqbilbd /. fabdp // Simplify // extraSimplify]), [[i, j]]]) /. 
          newsymlist]

texeqbd[i_, j_] := 
      myTeXForm[(Subscript[(Evaluate[eqbilbd /. bulksol /. fabdp // Simplify // extraSimplify]), [[i, j]]]) /. newsymlist]

Block[{stFile = OpenWrite["expBilbdO.tex"]}, 
      Block[{newsymlist = newsymlist1}, 
        Do[WriteString[stFile, texeqbdO[i, 1], " &= ", 
            texeqbdO[i, 2]]; 
If[i < Length[eqbilbd], 
            WriteString[stFile, " \\>,    \\", "\[2\jot]\n"], 
            WriteString[stFile, " \\>."]];, {i, 1, 
            Length[eqbilbd]}]]; 
Close[stFile]]

Block[{stFile = OpenWrite["expBilbd.tex"]}, 
      Block[{newsymlist = newsymlist1}, 
        Do[WriteString[stFile, texeqbd[i, 1], " &= ", 
            texeqbd[i, 2]]; 
If[i < Length[eqbilbd], 
            WriteString[stFile, " \\>,    \\", "\[2\jot]\n"], 
            WriteString[stFile, " \\>."]];, {i, 1, 
            Length[eqbilbd]}]]; 
Close[stFile]]

Forma TEX delle costanti di integrazione

texCname[i_] := 
      myTeXForm[((Subscript[cNQMval, [[i, 1]]]) // Simplify // extraSimplify) /. 
          newsymlist]

texCval[i_] := 
      myTeXForm[((Subscript[cNQMval, [[i, 2]]]) // Simplify // extraSimplify // Factor) /. 
          newsymlist]

texCDval[i_] := 
      myTeXForm[((Subscript[cNQMval, [[i, 2]]]) /. cRval // Simplify // extraSimplify // 
              Factor) /. newsymlist]

texDname[i_] := 
      myTeXForm[((Subscript[cRval, [[i, 1]]]) // Simplify // extraSimplify) /. 
          newsymlist]

texDval[i_] := 
      myTeXForm[((Subscript[cRval, [[i, 2]]]) // Simplify // extraSimplify // Factor) /. 
          newsymlist]

Block[{stFile = OpenWrite["expC.tex"]}, 
      Block[{newsymlist = newsymlist4}, 
Do[
          WriteString[stFile, ToString[texCname[i]] <> " &= ", 
            texCval[i]]; 
If[i < Length[cNQMval], 
            WriteString[stFile, " \\>,    \\", "\[2\jot]\n"], 
            WriteString[stFile, " \\>."]], {i, 1, 
            Length[cNQMval]}]]; 
Close[stFile]]

Block[{stFile = OpenWrite["expD.tex"]}, 
      Block[{newsymlist = newsymlist5}, 
Do[
          WriteString[stFile, ToString[texDname[i]] <> " &= ", 
            texDval[i]]; 
If[i < Length[cRval], 
            WriteString[stFile, " \\>,    \\", "\[2\jot]\n"], 
            WriteString[stFile, " \\>."]], {i, 1, 
            Length[cRval]}]]; 
Close[stFile]]

Block[{stFile = OpenWrite["expCD.tex"]}, 
      Block[{newsymlist = newsymlist4}, 
Do[
          WriteString[stFile, ToString[texCname[i]] <> " &= ", 
            texCDval[i]]; 
If[i < Length[cNQMval], 
            WriteString[stFile, " \\>,    \\", "\[2\jot]\n"], 
            WriteString[stFile, " \\>."]], {i, 1, 
            Length[cNQMval]}]]; 
Close[stFile]]

Forma TEX dei descrittori della tensione (N, Q, M)

texN[i_] := 
      myTeXForm[
        Evaluate[sN[i][ζ] /. bulksol /. cNQMval /. cRval // 
                Simplify // extraSimplify] /. newsymlist]

texQ[i_] := 
      myTeXForm[
        Evaluate[sQ[i][ζ] /. bulksol /. cNQMval /. cRval // 
                Simplify // extraSimplify] /. newsymlist]

texM[i_] := 
      myTeXForm[
        Evaluate[sM[i][ζ] /. bulksol /. cNQMval /. cRval // 
                Simplify // extraSimplify] /. newsymlist]

\(Block[{stFile = OpenWrite["expNQM.tex"]}, 
      Block[{newsymlist = newsymlist1}, 
        Do[
WriteString[stFile, texNn[i], " &= ", 
            texN[i]]; 
          WriteString[
            stFile, "\>,    \", "\[2\jot]
"]; 
WriteString[stFile, texQn[i], " &= ", texQ[i]]; 
          WriteString[
            stFile, "\>,    \", "\[2\jot]
"]; 
WriteString[stFile, texMn[i], " &= ", 
            texM[i]]; 
If[i < travi, 
            WriteString[stFile, "\>,    \", "\[2\jot]
"], 
            WriteString[stFile, "\>."]];, {i, 1, 
            travi}]]; 
Close[stFile]]\)

Forma TEX degli integrali delle funzioni di risposta senza sostituzioni

Prima della sostituzione delle soluzioni delle equazioni di bilancio al bordo

texu1inO[i_] := 
myTeXForm[
        Evaluate[(Subscript[u, 1])[i][ζ] /. vinBer /. spsolO // 
                Simplify // extraSimplify] /. newsymlist]

texu2inO[i_] := 
      myTeXForm[
        Evaluate[(Subscript[u, 2])[i][ζ] /. vinBer /. spsolO // 
                Simplify // extraSimplify] /. newsymlist]

texθinO[i_] := 
      myTeXForm[
        Evaluate[θ[i][ζ] /. vinBer /. spsolO // 
                Simplify // extraSimplify] /. newsymlist]

texu1n[i_] := myTeXForm[(Subscript[u, 1])[i][ζ] /. newsymlist]

texu2n[i_] := myTeXForm[(Subscript[u, 2])[i][ζ] /. newsymlist]

texθn[i_] := 
      myTeXForm[θ[i][ζ] /. newsymlist]

\(Block[{stFile = OpenWrite["expuvinO.tex"]}, 
      Block[{newsymlist = newsymlist3}, 
        Do[
WriteString[stFile, texu1n[i], " &= ", 
            texu1inO[i]]; 
          WriteString[
            stFile, "\>,    \", "\[2\jot]
"]; 
WriteString[stFile, texu2n[i], " &= ", texu2inO[i]]; 
          WriteString[
            stFile, "\>,    \", "\[2\jot]
"]; 
WriteString[stFile, texθn[i], " &= ", 
            texθinO[i]]; 
If[i < travi, 
            WriteString[stFile, "\>,    \", "\[2\jot]
"], 
            WriteString[stFile, "\>."]];, {i, 1, 
            travi}]]; 
Close[stFile]]\)

Forma TEX degli integrali delle funzioni di risposta

Dopo la sostituzione delle soluzioni delle equazioni di bilancio al bordo

texu1in[i_] := 
myTeXForm[
        Evaluate[(Subscript[u, 1])[i][ζ] /. vinBer /. spsol // Simplify // 
              extraSimplify] /. newsymlist]

texu2in[i_] := 
      myTeXForm[
        Evaluate[(Subscript[u, 2])[i][ζ] /. vinBer /. spsol // Simplify // 
              extraSimplify] /. newsymlist]

texθin[i_] := 
      myTeXForm[
        Evaluate[θ[i][ζ] /. vinBer /. spsol // 
                Simplify // extraSimplify] /. newsymlist]

texu1n[i_] := myTeXForm[(Subscript[u, 1])[i][ζ] /. newsymlist]

texu2n[i_] := myTeXForm[(Subscript[u, 2])[i][ζ] /. newsymlist]

texθn[i_] := 
      myTeXForm[θ[i][ζ] /. newsymlist]

\(Block[{stFile = OpenWrite["expuvin.tex"]}, 
      Block[{newsymlist = newsymlist3}, 
        Do[
WriteString[stFile, texu1n[i], " &= ", 
            texu1in[i]]; 
          WriteString[
            stFile, "\>,    \", "\[2\jot]
"]; 
WriteString[stFile, texu2n[i], " &= ", texu2in[i]]; 
          WriteString[
            stFile, "\>,    \", "\[2\jot]
"]; 
WriteString[stFile, texθn[i], " &= ", 
            texθin[i]]; 
If[i < travi, 
            WriteString[stFile, "\>,    \", "\[2\jot]
"], 
            WriteString[stFile, "\>."]];, {i, 1, 
            travi}]]; 
Close[stFile]]\)

Forma TEX degli spostamenti (u, v, θ)

texu1[i_] := 
      myTeXForm[((Subscript[u, 1])[i][ζ] /. vinBer /. spsol /. 
                  cRval // Simplify // extraSimplify) /. 
          newsymlist]

texu2[i_] := 
      myTeXForm[((Subscript[u, 2])[i][ζ] /. vinBer /. spsol /. 
                  cRval // Simplify // extraSimplify) /. 
          newsymlist]

texθ[i_] := 
      myTeXForm[(Evaluate[θ[i][ζ] /. vinBer /. 
                      spsol /. cRval // Simplify // extraSimplify]) /. 
          newsymlist]

texu1n[i_] := myTeXForm[(Subscript[u, 1])[i][ζ] /. newsymlist]

texu2n[i_] := myTeXForm[(Subscript[u, 2])[i][ζ] /. newsymlist]

texθn[i_] := 
      myTeXForm[θ[i][ζ] /. newsymlist]

\(Block[{stFile = OpenWrite["expuv.tex"]}, 
      Block[{newsymlist = 
            newsymlist2}, 
Do[
WriteString[stFile, 
            texu1n[i], \ " &= ", texu1[i]]; 
          WriteString[
            stFile, "\>,    \", "\[2\jot]
"]; 
WriteString[stFile, texu2n[i], " &= ", texu2[i]]; 
          WriteString[
            stFile, "\>,    \", "\[2\jot]
"]; 
WriteString[stFile, texθn[i], " &= ", 
            texθ[i]]; 
If[i < travi, 
            WriteString[stFile, "\>,    \", "\[2\jot]
"], 
            WriteString[stFile, "\>."]];, {i, 1, 
            travi}]]; 
Close[stFile]]\)

Forma TEX delle forze e dei momenti alle estremità

Clear[texs, texsn]

texs[i_, meno, j_] := 
      myTeXForm[
        Evaluate[-(Subscript[(s[i][0]), [[j]]]) /. bulksol /. cNQMval /. cRval // Simplify // 
              extraSimplify] /. newsymlist]

texs[i_, più, j_] := 
      myTeXForm[
        Evaluate[(Subscript[(s[i][L[i]]), [[j]]]) /. bulksol /. cNQMval /. cRval // Simplify // 
              extraSimplify] /. newsymlist]

texm[i_, meno] := 
      myTeXForm[
        Evaluate[-m[i][0] /. bulksol /. cNQMval /. cRval // 
                Simplify // extraSimplify] /. newsymlist]

texm[i_, più] := 
      myTeXForm[
        Evaluate[m[i][L[i]] /. bulksol /. cNQMval /. cRval // 
                Simplify // extraSimplify] /. newsymlist]

texsn[i_, bd_, j_] := myTeXForm[(Subscript[s, j])[i, bd] /. newsymlist]

texsm[i_, bd_] := myTeXForm[m[i, bd] /. newsymlist]

\(Do[Block[{stFile = 
            OpenWrite["expFb-" <> ToString[i] <> ".tex"]}, 
        Block[{newsymlist = newsymlist6}, 
          WriteString[stFile, texsn[i, meno, 1], " &= ", 
            texs[i, meno, 1]]; 
          WriteString[
            stFile, "\>,    \", "\[2\jot]
"]; 
WriteString[stFile, texsn[i, meno, 2], " &= ", 
            texs[i, meno, 2]]; 
          WriteString[
            stFile, "\>,    \", "\[2\jot]
"]; 
WriteString[stFile, texsm[i, meno], " &= ", 
            texm[i, meno]]; 
          WriteString[
            stFile, "\>,    \", "\[2\jot]
"]; 
WriteString[stFile, texsn[i, più, 1], " &= ", 
            texs[i, più, 1]]; 
          WriteString[
            stFile, "\>,    \", "\[2\jot]
"]; 
WriteString[stFile, texsn[i, più, 2], " &= ", 
            texs[i, più, 2]]; 
          WriteString[
            stFile, "\>,    \", "\[2\jot]
"]; 
WriteString[stFile, texsm[i, più], " &= ", 
            texm[i, più]]; 
If[i < travi, 
            WriteString[stFile, "\>,    \", "\[2\jot]
"], 
            WriteString[stFile, "\>."]];]; 
Close[
          stFile]], {i, 1, travi}]\)

Elenco dei simboli usati

TableForm[
      Block[{col = 6}, 
        Join[Partition[Names["Global`*"], 
            col], {Take[
              Names["Global`*"], -(Length[Names["Global`*"]] - 
                    Length[Partition[Names["Global`*"], col] // 
                        Flatten])]}]]]