Metodo de La Rigidez 1.0

(* :Nombre: Programm`CalculodeEstructuras` *)
(* :Titulo: Calculo de estructuras por el metodo de la rigides*)

(* :Autor: Jose Dario Prieto *)
(* :Package Version: 1.0 *)
(* :Historia:
Trabajo realizado por Jose Dario Prieto para la catedra
Integradora III dictada por el Ing. Fortunato .
U.T.N. San Rafael 1997.
*)
Print["------------------------------------------"];
Print[""];
Print["SOFTWARE EDUCATIVO DE LIBRE DISTRIBUCION \n
PARA CALCULO DE ESTRUCTUCTURAS POR EL \n
METODO DE LA RIGIDEZ."];
Print[" VERSION 1.0 "];
Print[""];
Print["AUTOR : JOSE DARIO PRIETO "];
Print["INGENIERIA ELECTROMECANICA \n
UNIVERSIDAD TECNOLOGICA NACIONAL \n
FACULTAD REGIONAL SAN RAFAEL \n MZA. ARGENTINA 1998."];
Print[""];
Print["email: jdario.prieto@gmail.com"];
Print[""];
Print["EL AUTOR NO SE RESPOSABILIZA NI DE LOS \n

RESULTADOS NI DE LOS POSIBLES \n PROBLEMAS CAUSADOS POR ESTE SOFTWARE."];
Print[""];
BeginPackage["Metodo`Rigidez`"]
ResolverC::usage="
La funcion ResolverC[nudos_List ,barras_List,apoyos_List] carga \n
en memoria las listas Deformaciones , Esfuerzos , Reacciones , \n
EsfNudos, KK, T, Fp, Dp, Kp y kb.\n
Este comando opera igual que el comando Resolver[..] imprimendo \n
brevemente los pasos del calculo .
"
Resolver::usage=" La funcion Resolver[nudos_List ,barras_List,

apoyos_List] carga \n
en memoria las listas Deformaciones , Esfuerzos , Reacciones y \n
EsfNudos.\n\n
La lista Deformaciones estara compuesta por n elementos igual \n
ala cantidad de nudos de la estructura. La ubicacion de cada \n
elemento en la lista coincidira con su correspondiente numero \n
de nudo y tendra el siguiente formato :\n
{u-j , v-j , teta-j}\n
u-j = desplazamiento del nudo j en el eje x.\n
u-j = desplazamiento del nudo j en el eje y.\n
teta-j = rotacion del nudo j .\n\n
La lista Esfuerzos estara compuesta por n elementos igual \n
ala cantidad de barras de la estructura. La ubicacion de cada \n
elemento en la lista coincidira con su correspondiente numero\n
de barra y tendra el siguiente formato :\n
{S'xi-j , S'yi-j , S'tetai-j, S'xf-j , S'yf-j , S'tetaf-j}\n
S'xi-j = Esfuerzo de compresion en el nudo inicial de la barra j.\n
S'yi-j = Esfuerzo de corte en el nudo inicial de la barra j.\n
S'tetai-j = Momento torsor en el nudo inicial de la barra j.\n
S'xf-j = Esfuerzo de compresion en el nudo final de la barra j.\n
S'yf-j = Esfuerzo de corte en el nudo final de la barra j.\n
S'tetaf-j = Momento torsor en el nudo final de la barra j.\n
\n
La lista Reacciones estara compuesta por n elementos igual \n
ala cantidad de apoyos de la estructura. Cada elemento tendra\n
el siguiente formato :\n
{Nudo j , rx-j , ry-j, m-j }\n
Nudo j = Texto indicativo del nudo j .\n
rx-j = Reaccion en el sentido del eje x del nudo j.\n
ry-j = Reaccion en el sentido del eje y del nudo j.\n
m-j = Momento reaccion del nudo j.\n
\n
\n
----- CARGA DE LA ESTRUCTURA -----
\n
\n
\n
La lista Nudos estara compuesta por n elementos igual\n
ala cantidad de nudos de la estructura. La ubicacion de \n
cada elemento en la lista coincidira con su correspondiente\n
numero de nudo y tendra cualquiera de los siguientes formatos\n
{x-j , y-j , fx-j , fy-j , m-j , Rot} o {x-j , y-j , fx-j , fy-j , m-j }\n
x-j = Coordenada x del nudo j .\n
y-j = Coordenada y del nudo j .\n
fx-j = Fuerza aplicada en el nudo j en sentido paralelo al eje x.\n
fx-j = Fuerza aplicada en el nudo j en sentido paralelo al eje y.\n
m-j = Momento aplicado en el nudo j .\n
Rot = Simbolo que indica que el nudo j sera una articulacion\n
para todas las barras que concurren al mismo.\n
(Este puede o no existir ).
\n
\n
La lista Barras estara compuesta por n elementos igual\n
a la cantidad de barras de la estructura.La ubicacion \n
de cada elemento en la lista coincidira con su correspondiente\n
numero de barra y tendra cualquiera de los siguientes formatos :\n
{ ni-j,nf-j, I-j , A-j , E-j , Cargas_Lista , Opcion-Barra} o\n
{ ni-j,nf-j, I-j , A-j , E-j , Cargas_Lista }\n
ni-j = Nudo inicial de la barra j .\n
nf-j = Nudo final de la barra j .\n
I-j = Momento de inercia de la barra j .\n
A-j = Area de la seccion transversal de la barra j .\n
E-j = Modulo Elastico de la barra j .\n
\n
Cargas_Lista = Lista de cargas . Puede estar compuesta por \n
varios elementos que pueden indicar varias condiciones de \n
carga para la barra j.\n
Tipos de elementos que admite Cargas_Lista.\n
-----Carga Puntual----\n
Primer caso\n
{a , Fx , Fy} \n
a = Distancia entre el punto de aplicacion de la fuerza al \n
nudo inicial de la barra , medido sobre el eje de la misma.\n
Fx = Modulo de la componente de la fuerza aplicada en \n
sentido paralelo al eje x.\n
Fy = Modulo de la componente de la fuerza aplicada en \n
sentido paralelo al eje y.\n
Segundo caso\n
{a , Fp , P }\n
a = Distancia entre el punto de aplicacion de la fuerza al\n
nudo inicial de la barra, medido sobre el eje de la misma.\n
Fp = Modulo de la fuerza aplicada perpendicularmente a la\n
barra .Su signo indica el sentido .\n
P = Simbolo que indica que la fuerza es aplicada \n
perpendicularmente a la barra.\n
-----Momento----\n
{a , M}\n
a = Distancia entre el punto de aplicacion del momento\n
al nudo inicial de la barra, medido sobre el eje de la misma.\n
M = Momento aplicado .\n
-----Carga Trapezoidal ----\n
{a , b, Q1 , Q2 , Opcion ( Y , X , P)}\n
a = Distancia entre el punto en el cual comenzara a actuar\n
la carga distribuida trapezoidal al nudo inicial de la barra,\n
medido sobre el eje de la misma .\n
b = Distancia entre el punto en el cual terminara de actuar\n
la carga distribuida trapezoidal al nudo inicial de la barra,\n
medido sobre el eje de la misma .\n
Q1 = Valor de la carga distribuida en el punto a.\n
Q2 = Valor de la carga distribuida en el punto b.\n
Opcion = Puede estar especificado por cualquiera de\n
los simbolos Y, X o P\n
opcion Y la carga trapezoidal estara aplicada en sentido\n
paralelo al eje y.\n
opcion X la carga trapezoidal estara aplicada en sentido\n
paralelo al eje x.\n
opcion P la carga trapezoidal estara aplicada \n
perpendicularmente al eje de la barra . \n
\n
Opcion-Barra = Puede estar especificado por cualquiera\n
de los simbolos Ri, Rf , Ba o Be\n \n
opcion Ri =Rotula en nudo inicial. \n
opcion Rf =Rotula en nudo final. \n
opcion Ba =Rotula en ambos nudos. \n
opcion Be =empotrada en ambos nudos. \n
\n
La lista apoyos estara compuesta por elementos del tipo \n
{apoyo-j, restriccion x-j, restriccion y-j, \n
restriccion m-j}, donde cada elemento \n
representa un apoyo de la estructura. \n
Siendo : \n
apoyo-j : numero de nodo donde se encuentra el
apoyo \n
restriccion x-j : restriccion en x ( 1 si esta \n
restringido , 0 no restringido) \n
restriccion y-j : restriccion en y ( 1 si esta \n
restringido , 0 no restringido) \n
restriccion m-j : restriccion de rotacion ( 1 \n
si esta restringido , 0 no restringido)
"
GraficarEstructura::usage ="
El comando GraficarEstructura[{ Nudos_List ,Barras_List , \n
Apoyos_List } , opciones_List , opciones de Graphics ] grafica la \n
estructura determinada por las listas Nudos,Barras y Apoyos,\n
siendo estas mismas listas las utilizadas en el comando Resolver.\n
La lista opciones es la lista de opciones del comando \n
GraficarEstructura , opciones de Graphics esta compuesto por \n
las opciones del comando Graphics.\n
Elementos posibles de opciones_List : \n
Graficar->{ Todo , Momentos , CargasPuntuales, \n
CargasDistribuidas, DMomento , DCorte , DNormal , DGiro , \n
Elastica , ElasticaSinEstructura }\n
Todo = indica que se grafiquen los momentos , cargas puntuales y \n
cargas distribuidas de la estructura . \n
Momentos = indica que se grafiquen los momentos de la estructura. \n
CargasPuntuales = indica que se grafiquen las cargas puntuales \n
de la estructura . \n
CargasDistribuidas = indica que se grafiquen las cargas distribuidas \n
de la estructura . \n
DMomento = indica que se grafique el diagrama de momento de \n
cada barra. \n
DCorte = indica que se grafique el diagrama de corte de cada barra.\n
DNormal = indica que se grafique el diagrama normal de cada \n
barra. \n
DGiro = indica que se grafique el diagrama de giros de cada barra.\n
Elastica = indica que se grafique la elastica de cada barra.\n
ElasticaSinEstructura = indica que se grafique la elastica de\n
todas las barras sin las barras.\n
\n
NOTA : Las especificaciones de DMomento, DCorte, DNormal,\n
DGiro y Elastica solo pueden hacerse habiendo ejecutado \n
anteriormente el comando Resolver en caso contrario se \n
produciran ERRORES. \n
\n
Indicar->{ Todo , Barras , Nudos , Cargas }\n
Todo = Se indicaran los numeros de barras , nudos y valores de \n
las cargas en gral. \n
Barras = Se indicaran los numeros de barras. \n
Nudos = Se indicaran los numeros de nudos. \n
Cargas = Se indicaran los valores de las cargas en gral. \n
EscalaFuerza-> numero indicativo de la escala de fuerza tomada. \n
EscalaNCM-> numero indicativo de la escala tomada para los \n
diagramas normales , de corte y momento. \n
EscalaG-> numero indicativo de la escala de giros. \n
EscalaE-> numero indicativo de la escala de la elastica. \n
DPasos-> numero que indica la cantidad tramos que se tomaran \n
para el trazado de todos los diagramas . \n
ColorDM-> RGBColor[rojo, verde, azul] (color del diagrama de \n
momento) \n
ColorDN-> RGBColor[rojo, verde, azul] (color del diagrama \n
normal) \n
ColorDC-> RGBColor[rojo, verde, azul] (color del diagrama de \n
corte) \n
ColorDG-> RGBColor[rojo, verde, azul] (color del diagrama de \n
giros) \n
ColorE-> RGBColor[rojo, verde, azul] (color de la elastica) \n
ColorBarras-> RGBColor[rojo, verde, azul] (color de las barras) \n
ColorApoyos-> RGBColor[rojo, verde, azul] (color de los apoyos) \n
ColorCargas-> RGBColor[rojo, verde, azul] (color de las cargas) \n
ColorTextoNudos-> RGBColor[rojo, verde, azul] (color del texto \n
indicativo de los nudos) \n
ColorTextoBarras-> RGBColor[rojo, verde, azul] (color del texto \n
indicativo de las barras) \n
ColorTextoCargas-> RGBColor[rojo, verde, azul] (color del texto \n
indicativo de las cargas)
"
Informe::usage="Informe[{Barra_List,Nudo_List,Apoyo_List},Opcion__List] \n
El comando presenta un informe\n
de las caracteristicas de cada barra y de la estructura en gral.
\n
Las listas Barras , Nudos y Apoyos son las listas que \n
definen la estructura (tal como lo explicado para el \n
comando Resolver[..]) y la lista Opcion contiene solo \n
las barras que seran procesadas, en caso de no estar , \n
(lista Opcion) el comando procesara todas las barras. \n
"
Salvar::usage ="Salvar[{nudo_List,barra_List,apoyo_List},Opcion__List]
\nLas listas Barras , Nudos y Apoyos son las listas que
\n definen la estructura (tal como lo explicado para el
\n comando Resolver) y la lista Opcion contiene solo las
\n barras que seran procesadas, en caso no estar el comando \n
procesara todas las barras.
\nEl proceso de cada barra consiste en cargar matrices de
\n funciones protegidas que contienen las funciones
\n caracteristicas de cada barra.
\n\nL[n] = Longitud de la barra n.
\n\nENormal[n , x] = Esfuerzo normal de la barra n en fusion de
\n x , es valida de 0 a L[n]. (suma de funciones seccionalmente continuas)\n
\nCorte[n , x] = Esfuerzo de corte de la barra n en fusion de
\n x , es valida de 0 a L[n]. (suma de funciones
\n seccionalmente continuas)\n
\nMomento[n , x] = Momento torsor de la barra n en fusion de
\n x , es valida de 0 a L[n]. (suma de funciones
\n seccionalmente continuas)\n\nRotacion[n,x] = Giro de la barra n en fusion de
x , es
\n valida de 0 a L[n]. (funcion interpolada).\n
\nElastica[n,x] = Flecha de la barra n en fusion de x , es
\n valida de 0 a L[n]. (funcion interpolada).
"
Begin["`Privado`"]
(* -------------------------Funciones-------------------------------*)
diagrama[x1_,y1_,l_,alpa_,escala_,pasos_]:=Module[
{xll},
ff1=Compile[{xll},ff[xll]];
Join[{
Line[Table[
{N[x1 + xll*Cos[alpa] -escala*ff[xll]*Sin[alpa]],N[y1 +escala*ff[xll]*Cos[alpa]
+ xll*Sin[alpa]]}
,{xll,0,l,l/pasos}]]}
,
Table[
Line[{{N[x1 + xll Cos[alpa]], N[y1 + xll Sin[alpa]] },
{N[x1 + xll*Cos[alpa] -escala*ff[xll]*Sin[alpa]],
N[y1 +escala*ff[xll]*Cos[alpa] + xll*Sin[alpa]]}}]
,{xll,0,l,l/pasos}]
]
];
moo[x_,x1_,m_]=If[x>x1,m,0];
mo[x_,m1_,c1_]=m1 + c1 x ;
co[x_,m1_,c1]= c1;
m1[x_,x1_,f1_]=If[x<x1,0,(x-x1) f1];
c1[x_,x1_,f1_]=If[x<x1,0,f1];
m2[x_,x1_,x2_,q1_,q2_]=Which[x<x1,0,x1<=x<=x2,(q1*(x - x1)^2)/2 +
((-q1 + q2)*(x - x1)^3)/(6*(-x1 + x2)),x>x2,
((x1 - x2)*(-3*q1*x - 3*q2*x + 2*q1*x1 + q2*x1 + q1*x2 + 2*q2*x2))/6];
c2[x_,x1_,x2_,q1_,q2_]=Which[x < x1, 0, x1 <= x <= x2,
q1*(x - x1) + ((-q1 + q2)*(x - x1)^2)/
(2*(-x1 + x2)), x > x2,
((q1 + q2)*(-x1 + x2))/2];
nor1y[x_,x1_,f1_,a_]=If[x<x1,0, f1 Sin[a]];
nor1x[x_,x1_,f1_,a_]=If[x<x1,0, f1 Cos[a]];
nor2y[x_,x1_,x2_,q1_,q2_,a_]=Which[x<x1,0,x1<=x<=x2,(x*(q1*x - q2*x + 2*q2*x1 -
2*q1*x2)*Sin[a])/(2*(x1 - x2))
,x>x2,(x2*(2*q2*x1 - q1*x2 - q2*x2)*Sin[a])/(2*(x1 - x2))];
nor2x[x_,x1_,x2_,q1_,q2_,a_]=Which[x<x1,0,x1<=x<=x2,
(x*(q1*x - q2*x + 2*q2*x1 - 2*q1*x2)*Cos[a])/(2*(x1 - x2))
,x>x2,(x2*(2*q2*x1 - q1*x2 - q2*x2)*Cos[a])/(2*(x1 - x2))];
lsim[x_,y_,alpa_,b_]=Line[{{x - 1.25831*b*Sin[1.16216 - alpa],

y - 1.25831*b*Cos[1.16216 - alpa]},
{x - 1.25831*b*Sin[1.97943 - alpa],
y - 1.25831*b*Cos[1.97943 - alpa]}}];
ltemp[x_,y_,alpa_,b_]={Line[{{x + b*Cos[alpa - (5*Pi)/6], y + b*Sin[alpa - (5*Pi
)/6]},
{x - 1.17388*b*Sin[1.38979 - alpa],y - 1.17388*b*Cos[1.38979 - alpa]}}],
Line[{{x - 0.866025*b*Cos[alpa], y - 0.866025*b*Sin[alpa]},
{x - 1.19024*b*Sin[1.81578 - alpa],
y - 1.19024*b*Cos[1.81578 - alpa]}}],
Line[{{x + b*Cos[alpa - (7*Pi)/6], y + b*Sin[alpa - (7*Pi)/6]},
{x - 1.39824*b*Sin[2.17003 - alpa],
y - 1.39824*b*Cos[2.17003 - alpa]}}]};
tria[x_,y_,alpa_,b_]=Line[{{x, y}, {x + b*Cos[alpa - (5*Pi)/6],
y + b*Sin[alpa - (5*Pi)/6]},
{x + b*Cos[alpa - (7*Pi)/6], y + b*Sin[alpa - (7*Pi)/6]}, {x, y}}];
cir[x_,y_,r_]=Circle[{x,y},r];
lemp[x_,y_,alpa_,b_]={Line[{{x - 0.85054*b*Sin[2.78489 - alpa],
y - 0.85054*b*Cos[2.78489 - alpa]},
{x - 0.5*b*Sin[alpa], y + 0.5*b*Cos[alpa]},
{x + 0.5*b*Sin[alpa], y - 0.5*b*Cos[alpa]},
{x - 0.3597*b*Sin[0.9712 - alpa],
y - 0.3597*b*Cos[0.9712 - alpa]}}],
Line[{{x, y}, {x - 0.4200021*b*Sin[2.35619 - alpa],
y - 0.4200021*b*Cos[2.35619 - alpa]}}]};
ang=Compile[{x,y},If[ArcSin[y/Sqrt[x^2+y^2]]>=0,ArcCos[x/Sqrt[x^2+y^2]],Pi+Pi-Ar
cCos[x/Sqrt[x^2+y^2]]]//N];
momento[x_,y_,r_,f_]={Polygon[{{-0.43*r + x, -0.77*f*r +y}, {x, -(f*r) + y},
{-0.5*r + x, -(f*r) + y}}], Circle[{x, y},r,{Pi/2, 1.5*Pi}]};
vector[x_,y_,x1_,y1_,b_]:=Block[{alpa},
alpa=ang[(-x + x1),(-y + y1)];

{Polygon[{
{1.6 b Cos[.321+alpa]+x,1.6 b Sin[.321+alpa]+y},
{x,y},
{1.6 b Cos[-.321+alpa]+x,1.6 b Sin[-.321+alpa]+y}}],
Line[{{x,y},{x1,y1}}]}
]
cargatrapezoidal[x1_,y1_,x2_,y2_,x3_,y3_,x4_,y4_,b_]:=Block[
{l,t,ix1,iy1,ix2,iy2,xl1,yl1,xl2,yl2},
l=Sqrt[(x2-x1)^2+(y2-y1)^2];
t=2+Round[l/b];(*regulacion de cantidad de flechas*)
ix1=(x2-x1)/t;
ix2=(x4-x3)/t;
iy1=(y2-y1)/t;
iy2=(y4-y3)/t;
xl1=x1-ix1;
yl1=y1-iy1;
xl2=x3-ix2;
yl2=y3-iy2;
Join[{Line[{{x1,y1},{x2,y2}}],Line[{{x4,y4},{x3,y3}}]},
Table[Block[{alpa,b1=(b/6)},
xl1=xl1+ix1;
yl1=yl1+iy1;
xl2=xl2+ix2;
yl2=yl2+iy2;
If[N[xl2-xl1]==0. && N[yl2-yl1]==0.,
{Line[{{xl1,yl1},{xl2,yl2}}]}
,
alpa=ang[xl2-xl1,yl2-yl1];
{Polygon[{
{1.6 b1 Cos[.321+alpa]+xl1,1.6 b1 Sin[.321+alpa]+yl1},
{xl1,yl1},
{1.6 b1 Cos[-.321+alpa]+xl1,1.6 b1 Sin[-.321+alpa]+yl1}}],
Line[{{xl1,yl1},{xl2,yl2}}]}
]
]
,{i,1,t+1,1}]
]
]
cartexto[x1_,y1_,x2_,y2_,x3_,y3_,x4_,y4_,q1_String,q2_String]=
{Text[q1,{(x3+x1)/2.,(y3+y1)/2.}],Text[q2,{(x2+x4)/2.,(y2+y4)/2.}]}//N;
(*caso [caso,1x 2y ,extremo, *)

ang1[x_,y_]=ArcTan[y/x];
ang1[0,y_]=Pi/2 Sign[y];
ang1[0.,y_]=Pi/2 Sign[y];
Caso[Global`Be,1,1,a_,b_,q1_,q2_,l_,t_]={-((-a + b)*(24*a^3*q1 + 18*a^2*b*q1 + 1
2*a*b^2*q1 + 6*b^3*q1 -
45*a^2*l*q1 - 30*a*b*l*q1 - 15*b^2*l*q1 + 20*a*l^2*q1 +
10*b*l^2*q1 + 6*a^3*q2 + 12*a^2*b*q2 + 18*a*b^2*q2 +
24*b^3*q2 - 15*a^2*l*q2 - 30*a*b*l*q2 - 45*b^2*l*q2 +
10*a*l^2*q2 + 20*b*l^2*q2)*Cos[t]^2*Sin[t])/(60*l^3),
-((a - b)*(q1 + q2)*Cos[t])/2 -
((-a + b)*(2*a*q1 + b*q1 + a*q2 + 2*b*q2)*Cos[t])/(6*l) -
((a - b)*(24*a^3*q1 + 18*a^2*b*q1 + 12*a*b^2*q1 + 6*b^3*q1 -
45*a^2*l*q1 - 30*a*b*l*q1 - 15*b^2*l*q1 + 20*a*l^2*q1 +
10*b*l^2*q1 + 6*a^3*q2 + 12*a^2*b*q2 + 18*a*b^2*q2 +
24*b^3*q2 - 15*a^2*l*q2 - 30*a*b*l*q2 - 45*b^2*l*q2 +
10*a*l^2*q2 + 20*b*l^2*q2)*Cos[t]^3)/(60*l^3),
((-a + b)*(12*a^3*q1 + 9*a^2*b*q1 + 6*a*b^2*q1 + 3*b^3*q1 -
30*a^2*l*q1 - 20*a*b*l*q1 - 10*b^2*l*q1 + 20*a*l^2*q1 +
10*b*l^2*q1 + 3*a^3*q2 + 6*a^2*b*q2 + 9*a*b^2*q2 + 12*b^3*q2 -
10*a^2*l*q2 - 20*a*b*l*q2 - 30*b^2*l*q2 + 10*a*l^2*q2 +
20*b*l^2*q2)*Cos[t]^2)/(60*l^2)};
Caso[Global`Be,1,2,a_,b_,q1_,q2_,l_,t_]={-((a - b)*(24*a^3*q1 + 18*a^2*b*q1 + 12
*a*b^2*q1 + 6*b^3*q1 -
45*a^2*l*q1 - 30*a*b*l*q1 - 15*b^2*l*q1 + 20*a*l^2*q1 +
10*b*l^2*q1 + 6*a^3*q2 + 12*a^2*b*q2 + 18*a*b^2*q2 +
24*b^3*q2 - 15*a^2*l*q2 - 30*a*b*l*q2 - 45*b^2*l*q2 +
-((a - b)*(2*a*q1 + b*q1 + a*q2 + 2*b*q2)*Cos[t])/(6*l) -
((-a + b)*(24*a^3*q1 + 18*a^2*b*q1 + 12*a*b^2*q1 + 6*b^3*q1 -
45*a^2*l*q1 - 30*a*b*l*q1 - 15*b^2*l*q1 + 20*a*l^2*q1 +
10*b*l^2*q1 + 6*a^3*q2 + 12*a^2*b*q2 + 18*a*b^2*q2 +
24*b^3*q2 - 15*a^2*l*q2 - 30*a*b*l*q2 - 45*b^2*l*q2 +
10*a*l^2*q2 + 20*b*l^2*q2)*Cos[t]^3)/(60*l^3),
((-a + b)*(12*a^3*q1 + 9*a^2*b*q1 + 6*a*b^2*q1 + 3*b^3*q1 -
15*a^2*l*q1 - 10*a*b*l*q1 - 5*b^2*l*q1 + 3*a^3*q2 +
6*a^2*b*q2 + 9*a*b^2*q2 + 12*b^3*q2 - 5*a^2*l*q2 -
10*a*b*l*q2 - 15*b^2*l*q2)*Cos[t]^2)/(60*l^2)};
Caso[Global`Be,2,1,a_,b_,q1_,q2_,l_,t_]={-((a - b)*(q1 + q2)*Sin[t])/2 +
((a - b)*(2*a*q1 + b*q1 + a*q2 + 2*b*q2)*Sin[t])/(6*l) -
((a - b)*(24*a^3*q1 + 18*a^2*b*q1 + 12*a*b^2*q1 + 6*b^3*q1 -
45*a^2*l*q1 - 30*a*b*l*q1 - 15*b^2*l*q1 + 20*a*l^2*q1 +
10*b*l^2*q1 + 6*a^3*q2 + 12*a^2*b*q2 + 18*a*b^2*q2 +
24*b^3*q2 - 15*a^2*l*q2 - 30*a*b*l*q2 - 45*b^2*l*q2 +
10*a*l^2*q2 + 20*b*l^2*q2)*Sin[t]^3)/(60*l^3),
((a - b)*(24*a^3*q1 + 18*a^2*b*q1 + 12*a*b^2*q1 + 6*b^3*q1 -
45*a^2*l*q1 - 30*a*b*l*q1 - 15*b^2*l*q1 + 20*a*l^2*q1 +
10*b*l^2*q1 + 6*a^3*q2 + 12*a^2*b*q2 + 18*a*b^2*q2 +
24*b^3*q2 - 15*a^2*l*q2 - 30*a*b*l*q2 - 45*b^2*l*q2 +
10*a*l^2*q2 + 20*b*l^2*q2)*Cos[t]*Sin[t]^2)/(60*l^3),
((a - b)*(12*a^3*q1 + 9*a^2*b*q1 + 6*a*b^2*q1 + 3*b^3*q1 -
30*a^2*l*q1 - 20*a*b*l*q1 - 10*b^2*l*q1 + 20*a*l^2*q1 +
10*b*l^2*q1 + 3*a^3*q2 + 6*a^2*b*q2 + 9*a*b^2*q2 + 12*b^3*q2 -
10*a^2*l*q2 - 20*a*b*l*q2 - 30*b^2*l*q2 + 10*a*l^2*q2 +
20*b*l^2*q2)*Sin[t]^2)/(60*l^2)};
Caso[Global`Be,2,2,a_,b_,q1_,q2_,l_,t_]={-((a - b)*(2*a*q1 + b*q1 + a*q2 + 2*b*q

2)*Sin[t])/(6*l) +
((a - b)*(24*a^3*q1 + 18*a^2*b*q1 + 12*a*b^2*q1 + 6*b^3*q1 -
45*a^2*l*q1 - 30*a*b*l*q1 - 15*b^2*l*q1 + 20*a*l^2*q1 +
10*b*l^2*q1 + 6*a^3*q2 + 12*a^2*b*q2 + 18*a*b^2*q2 +
24*b^3*q2 - 15*a^2*l*q2 - 30*a*b*l*q2 - 45*b^2*l*q2 +
10*a*l^2*q2 + 20*b*l^2*q2)*Sin[t]^3)/(60*l^3),
-((a - b)*(24*a^3*q1 + 18*a^2*b*q1 + 12*a*b^2*q1 + 6*b^3*q1 -
45*a^2*l*q1 - 30*a*b*l*q1 - 15*b^2*l*q1 + 20*a*l^2*q1 +
10*b*l^2*q1 + 6*a^3*q2 + 12*a^2*b*q2 + 18*a*b^2*q2 +
24*b^3*q2 - 15*a^2*l*q2 - 30*a*b*l*q2 - 45*b^2*l*q2 +
10*a*l^2*q2 + 20*b*l^2*q2)*Cos[t]*Sin[t]^2)/(60*l^3),
((a - b)*(12*a^3*q1 + 9*a^2*b*q1 + 6*a*b^2*q1 + 3*b^3*q1 -
15*a^2*l*q1 - 10*a*b*l*q1 - 5*b^2*l*q1 + 3*a^3*q2 +
6*a^2*b*q2 + 9*a*b^2*q2 + 12*b^3*q2 - 5*a^2*l*q2 -
10*a*b*l*q2 - 15*b^2*l*q2)*Sin[t]^2)/(60*l^2)};
Caso[Global`Rf,1,1,a_,b_,q1_,q2_,l_,t_]={-((-a + b)*(12*a^3*q1 + 9*a^2*b*q1 + 6*
a*b^2*q1 + 3*b^3*q1 -
45*a^2*l*q1 - 30*a*b*l*q1 - 15*b^2*l*q1 + 40*a*l^2*q1 +
20*b*l^2*q1 + 3*a^3*q2 + 6*a^2*b*q2 + 9*a*b^2*q2 +
12*b^3*q2 - 15*a^2*l*q2 - 30*a*b*l*q2 - 45*b^2*l*q2 +
-((a - b)*(q1 + q2)*Cos[t])/2 -
((-a + b)*(2*a*q1 + b*q1 + a*q2 + 2*b*q2)*Cos[t])/(6*l) -
((a - b)*(12*a^3*q1 + 9*a^2*b*q1 + 6*a*b^2*q1 + 3*b^3*q1 -
45*a^2*l*q1 - 30*a*b*l*q1 - 15*b^2*l*q1 + 40*a*l^2*q1 +
20*b*l^2*q1 + 3*a^3*q2 + 6*a^2*b*q2 + 9*a*b^2*q2 +
12*b^3*q2 - 15*a^2*l*q2 - 30*a*b*l*q2 - 45*b^2*l*q2 +
20*a*l^2*q2 + 40*b*l^2*q2)*Cos[t]^3)/(120*l^3),
((-a + b)*(12*a^3*q1 + 9*a^2*b*q1 + 6*a*b^2*q1 + 3*b^3*q1 -
45*a^2*l*q1 - 30*a*b*l*q1 - 15*b^2*l*q1 + 40*a*l^2*q1 +
20*b*l^2*q1 + 3*a^3*q2 + 6*a^2*b*q2 + 9*a*b^2*q2 + 12*b^3*q2 -
15*a^2*l*q2 - 30*a*b*l*q2 - 45*b^2*l*q2 + 20*a*l^2*q2 +
40*b*l^2*q2)*Cos[t]^2)/(120*l^2)};
Caso[Global`Rf,1,2,a_,b_,q1_,q2_,l_,t_]={-((a - b)*(12*a^3*q1 + 9*a^2*b*q1 + 6*a
*b^2*q1 + 3*b^3*q1 -
45*a^2*l*q1 - 30*a*b*l*q1 - 15*b^2*l*q1 + 40*a*l^2*q1 +
20*b*l^2*q1 + 3*a^3*q2 + 6*a^2*b*q2 + 9*a*b^2*q2 +
12*b^3*q2 - 15*a^2*l*q2 - 30*a*b*l*q2 - 45*b^2*l*q2 +
-((a - b)*(2*a*q1 + b*q1 + a*q2 + 2*b*q2)*Cos[t])/(6*l) -
((-a + b)*(12*a^3*q1 + 9*a^2*b*q1 + 6*a*b^2*q1 + 3*b^3*q1 -
45*a^2*l*q1 - 30*a*b*l*q1 - 15*b^2*l*q1 + 40*a*l^2*q1 +
20*b*l^2*q1 + 3*a^3*q2 + 6*a^2*b*q2 + 9*a*b^2*q2 +
12*b^3*q2 - 15*a^2*l*q2 - 30*a*b*l*q2 - 45*b^2*l*q2 +
20*a*l^2*q2 + 40*b*l^2*q2)*Cos[t]^3)/(120*l^3), 0};
Caso[Global`Rf,2,1,a_,b_,q1_,q2_,l_,t_]={-((a - b)*(q1 + q2)*Sin[t])/2 +
((a - b)*(2*a*q1 + b*q1 + a*q2 + 2*b*q2)*Sin[t])/(6*l) -
((a - b)*(12*a^3*q1 + 9*a^2*b*q1 + 6*a*b^2*q1 + 3*b^3*q1 -
45*a^2*l*q1 - 30*a*b*l*q1 - 15*b^2*l*q1 + 40*a*l^2*q1 +
20*b*l^2*q1 + 3*a^3*q2 + 6*a^2*b*q2 + 9*a*b^2*q2 +
12*b^3*q2 - 15*a^2*l*q2 - 30*a*b*l*q2 - 45*b^2*l*q2 +
20*a*l^2*q2 + 40*b*l^2*q2)*Sin[t]^3)/(120*l^3),
((a - b)*(12*a^3*q1 + 9*a^2*b*q1 + 6*a*b^2*q1 + 3*b^3*q1 -
45*a^2*l*q1 - 30*a*b*l*q1 - 15*b^2*l*q1 + 40*a*l^2*q1 +
20*b*l^2*q1 + 3*a^3*q2 + 6*a^2*b*q2 + 9*a*b^2*q2 + 12*b^3*q2 -
15*a^2*l*q2 - 30*a*b*l*q2 - 45*b^2*l*q2 + 20*a*l^2*q2 +
40*b*l^2*q2)*Cos[t]*Sin[t]^2)/(120*l^3),
((a - b)*(12*a^3*q1 + 9*a^2*b*q1 + 6*a*b^2*q1 + 3*b^3*q1 -
45*a^2*l*q1 - 30*a*b*l*q1 - 15*b^2*l*q1 + 40*a*l^2*q1 +
20*b*l^2*q1 + 3*a^3*q2 + 6*a^2*b*q2 + 9*a*b^2*q2 + 12*b^3*q2 -
15*a^2*l*q2 - 30*a*b*l*q2 - 45*b^2*l*q2 + 20*a*l^2*q2 +
40*b*l^2*q2)*Sin[t]^2)/(120*l^2)};
Caso[Global`Rf,2,2,a_,b_,q1_,q2_,l_,t_]={-((a - b)*(2*a*q1 + b*q1 + a*q2 + 2*b*q
2)*Sin[t])/(6*l) +
((a - b)*(12*a^3*q1 + 9*a^2*b*q1 + 6*a*b^2*q1 + 3*b^3*q1 -
45*a^2*l*q1 - 30*a*b*l*q1 - 15*b^2*l*q1 + 40*a*l^2*q1 +
20*b*l^2*q1 + 3*a^3*q2 + 6*a^2*b*q2 + 9*a*b^2*q2 +
12*b^3*q2 - 15*a^2*l*q2 - 30*a*b*l*q2 - 45*b^2*l*q2 +
20*a*l^2*q2 + 40*b*l^2*q2)*Sin[t]^3)/(120*l^3),
-((a - b)*(12*a^3*q1 + 9*a^2*b*q1 + 6*a*b^2*q1 + 3*b^3*q1 -
45*a^2*l*q1 - 30*a*b*l*q1 - 15*b^2*l*q1 + 40*a*l^2*q1 +
20*b*l^2*q1 + 3*a^3*q2 + 6*a^2*b*q2 + 9*a*b^2*q2 +
12*b^3*q2 - 15*a^2*l*q2 - 30*a*b*l*q2 - 45*b^2*l*q2 +
20*a*l^2*q2 + 40*b*l^2*q2)*Cos[t]*Sin[t]^2)/(120*l^3), 0};
Caso[Global`Ri,1,1,a_,b_,q1_,q2_,l_,t_]={-((a - b)*(-12*a^3*q1 - 9*a^2*b*q1 - 6*
a*b^2*q1 - 3*b^3*q1 +
20*a*l^2*q1 + 10*b*l^2*q1 - 3*a^3*q2 - 6*a^2*b*q2 -
9*a*b^2*q2 - 12*b^3*q2 + 10*a*l^2*q2 + 20*b*l^2*q2)*Cos[t]^2*
Sin[t])/(120*l^3), -((-a + b)*
(2*a*q1 + b*q1 - 3*l*q1 + a*q2 + 2*b*q2 - 3*l*q2)*Cos[t])/(6*l)
- ((a - b)*(12*a^3*q1 + 9*a^2*b*q1 + 6*a*b^2*q1 + 3*b^3*q1 -
20*a*l^2*q1 - 10*b*l^2*q1 + 3*a^3*q2 + 6*a^2*b*q2 +
9*a*b^2*q2 + 12*b^3*q2 - 10*a*l^2*q2 - 20*b*l^2*q2)*Cos[t]^3)/
(120*l^3), 0};
Caso[Global`Ri,1,2,a_,b_,q1_,q2_,l_,t_]={-((a - b)*(12*a^3*q1 + 9*a^2*b*q1 + 6*a
*b^2*q1 + 3*b^3*q1 -
20*a*l^2*q1 - 10*b*l^2*q1 + 3*a^3*q2 + 6*a^2*b*q2 +
9*a*b^2*q2 + 12*b^3*q2 - 10*a*l^2*q2 - 20*b*l^2*q2)*Cos[t]^2*
Sin[t])/(120*l^3), -((a - b)*(q1 + q2)*Cos[t])/2 -
((a - b)*(2*a*q1 + b*q1 - 3*l*q1 + a*q2 + 2*b*q2 - 3*l*q2)*Cos[t])/
(6*l) - ((a - b)*(-12*a^3*q1 - 9*a^2*b*q1 - 6*a*b^2*q1 -
3*b^3*q1 + 20*a*l^2*q1 + 10*b*l^2*q1 - 3*a^3*q2 -
6*a^2*b*q2 - 9*a*b^2*q2 - 12*b^3*q2 + 10*a*l^2*q2 +
20*b*l^2*q2)*Cos[t]^3)/(120*l^3),
((-a + b)*(12*a^3*q1 + 9*a^2*b*q1 + 6*a*b^2*q1 + 3*b^3*q1 -
20*a*l^2*q1 - 10*b*l^2*q1 + 3*a^3*q2 + 6*a^2*b*q2 +
9*a*b^2*q2 + 12*b^3*q2 - 10*a*l^2*q2 - 20*b*l^2*q2)*Cos[t]^2)/
(120*l^2)};
Caso[Global`Ri,2,1,a_,b_,q1_,q2_,l_,t_]={((a - b)*(2*a*q1 + b*q1 - 3*l*q1 + a*q2
+ 2*b*q2 - 3*l*q2)*Sin[t])/
(6*l) - ((a - b)*(12*a^3*q1 + 9*a^2*b*q1 + 6*a*b^2*q1 +
3*b^3*q1 - 20*a*l^2*q1 - 10*b*l^2*q1 + 3*a^3*q2 +
6*a^2*b*q2 + 9*a*b^2*q2 + 12*b^3*q2 - 10*a*l^2*q2 -
20*b*l^2*q2)*Sin[t]^3)/(120*l^3),
((a - b)*(12*a^3*q1 + 9*a^2*b*q1 + 6*a*b^2*q1 + 3*b^3*q1 -
20*a*l^2*q1 - 10*b*l^2*q1 + 3*a^3*q2 + 6*a^2*b*q2 +
9*a*b^2*q2 + 12*b^3*q2 - 10*a*l^2*q2 - 20*b*l^2*q2)*Cos[t]*
Sin[t]^2)/(120*l^3), 0};
Caso[Global`Ri,2,2,a_,b_,q1_,q2_,l_,t_]={-((a - b)*(q1 + q2)*Sin[t])/2 -
((a - b)*(2*a*q1 + b*q1 - 3*l*q1 + a*q2 + 2*b*q2 - 3*l*q2)*Sin[t])/
(6*l) + ((a - b)*(12*a^3*q1 + 9*a^2*b*q1 + 6*a*b^2*q1 +
3*b^3*q1 - 20*a*l^2*q1 - 10*b*l^2*q1 + 3*a^3*q2 +
6*a^2*b*q2 + 9*a*b^2*q2 + 12*b^3*q2 - 10*a*l^2*q2 -
20*b*l^2*q2)*Sin[t]^3)/(120*l^3),
-((a - b)*(12*a^3*q1 + 9*a^2*b*q1 + 6*a*b^2*q1 + 3*b^3*q1 -
20*a*l^2*q1 - 10*b*l^2*q1 + 3*a^3*q2 + 6*a^2*b*q2 +
9*a*b^2*q2 + 12*b^3*q2 - 10*a*l^2*q2 - 20*b*l^2*q2)*Cos[t]*
Sin[t]^2)/(120*l^3), ((a - b)*
(12*a^3*q1 + 9*a^2*b*q1 + 6*a*b^2*q1 + 3*b^3*q1 - 20*a*l^2*q1 -
10*b*l^2*q1 + 3*a^3*q2 + 6*a^2*b*q2 + 9*a*b^2*q2 + 12*b^3*q2 -
10*a*l^2*q2 - 20*b*l^2*q2)*Sin[t]^2)/(120*l^2)};
Caso[Global`Ba,1,1,a_,b_,q1_,q2_,l_,t_]={0, -((-a + b)*(2*a*q1 + b*q1 - 3*l*q1 +
a*q2 + 2*b*q2 - 3*l*q2)*
Cos[t])/(6*l), 0};
Caso[Global`Ba,1,2,a_,b_,q1_,q2_,l_,t_]={0, -((a - b)*(2*a*q1 + b*q1 + a*q2 + 2*
b*q2)*Cos[t])/(6*l), 0};
Caso[Global`Ba,2,1,a_,b_,q1_,q2_,l_,t_]={((a - b)*(2*a*q1 + b*q1 - 3*l*q1 + a*q2
+ 2*b*q2 - 3*l*q2)*Sin[t])/
(6*l), 0, 0};
Caso[Global`Ba,2,2,a_,b_,q1_,q2_,l_,t_]={-((a - b)*(2*a*q1 + b*q1 + a*q2 + 2*b*q
2)*Sin[t])/(6*l), 0, 0};
Caso1[Global`Be,1,1,a_,p_,l_,t_]={-(a*(2*a^2 - 3*a*l + l^2)*p*Sin[2*t])/(2*l^3),
-((-a + l)*p*(2*a^2 - a*l - 2*l^2 + 2*a^2*Cos[2*t] - a*l*Cos[2*t]))/
(2*l^3), (a*(a - l)^2*p*Cos[t])/l^2};
Caso1[Global`Be,1,2,a_,p_,l_,t_]={-(a*(-2*a^2 + 3*a*l - l^2)*p*Sin[2*t])/(2*l^3)
,
-(a*p*(2*a^2 - 3*a*l - l^2 + 2*a^2*Cos[2*t] - 3*a*l*Cos[2*t] +
l^2*Cos[2*t]))/(2*l^3), (a^2*(a - l)*p*Cos[t])/l^2};
Caso1[Global`Be,2,1,a_,p_,l_,t_]={-((-a + l)*p*(2*a^2 - a*l - 2*l^2 - 2*a^2*Cos[

2*t] + a*l*Cos[2*t]))/
(2*l^3), -(a*(2*a^2 - 3*a*l + l^2)*p*Sin[2*t])/(2*l^3),
-((a*(a - l)^2*p*Sin[t])/l^2)};
Caso1[Global`Be,2,2,a_,p_,l_,t_]={(a*p*(-2*a^2 + 3*a*l + l^2 + 2*a^2*Cos[2*t] -
3*a*l*Cos[2*t] +
l^2*Cos[2*t]))/(2*l^3),
(a*(2*a^2 - 3*a*l + l^2)*p*Sin[2*t])/(2*l^3),
(a^2*(-a + l)*p*Sin[t])/l^2};
Caso1[Global`Rf,1,1,a_,p_,l_,t_]={-(a*(a^2 - 3*a*l + 2*l^2)*p*Sin[2*t])/(4*l^3),
-((-a + l)*p*(a^2 - 2*a*l - 4*l^2 + a^2*Cos[2*t] - 2*a*l*Cos[2*t]))/
(4*l^3), (a*(a^2 - 3*a*l + 2*l^2)*p*Cos[t])/(2*l^2)};
Caso1[Global`Rf,1,2,a_,p_,l_,t_]={-(a*(-a^2 + 3*a*l - 2*l^2)*p*Sin[2*t])/(4*l^3)
,
-(a*p*(a^2 - 3*a*l - 2*l^2 + a^2*Cos[2*t] - 3*a*l*Cos[2*t] +
2*l^2*Cos[2*t]))/(4*l^3), 0};
Caso1[Global`Rf,2,1,a_,p_,l_,t_]={-((-a + l)*p*(a^2 - 2*a*l - 4*l^2 - a^2*Cos[2*
t] + 2*a*l*Cos[2*t]))/
(4*l^3), -(a*(a^2 - 3*a*l + 2*l^2)*p*Sin[2*t])/(4*l^3),
-(a*(a^2 - 3*a*l + 2*l^2)*p*Sin[t])/(2*l^2)};
Caso1[Global`Rf,2,2,a_,p_,l_,t_]={-(a*p*(a^2 - 3*a*l - 2*l^2 - a^2*Cos[2*t] + 3*
a*l*Cos[2*t] -
2*l^2*Cos[2*t]))/(4*l^3),
(a*(a^2 - 3*a*l + 2*l^2)*p*Sin[2*t])/(4*l^3), 0};
Caso1[Global`Ri,1,1,a_,p_,l_,t_]={-(a*(a - l)*(a + l)*p*Sin[2*t])/(4*l^3),
-((-a + l)*p*(a^2 + a*l - 4*l^2 + a^2*Cos[2*t] + a*l*Cos[2*t]))/
(4*l^3), 0};
Caso1[Global`Ri,1,2,a_,p_,l_,t_]={-(a*(-a + l)*(a + l)*p*Sin[2*t])/(4*l^3),
-(a*p*(a^2 - 5*l^2 + a^2*Cos[2*t] - l^2*Cos[2*t]))/(4*l^3),
(a*(a^2 - l^2)*p*Cos[t])/(2*l^2)};
Caso1[Global`Ri,2,1,a_,p_,l_,t_]={-((-a + l)*p*(a^2 + a*l - 4*l^2 - a^2*Cos[2*t]
- a*l*Cos[2*t]))/
(4*l^3), -(a*(a - l)*(a + l)*p*Sin[2*t])/(4*l^3), 0};
Caso1[Global`Ri,2,2,a_,p_,l_,t_]={-(a*p*(a^2 - 5*l^2 - a^2*Cos[2*t] + l^2*Cos[2*
t]))/(4*l^3),
(a*(a - l)*(a + l)*p*Sin[2*t])/(4*l^3),
-(a*(a^2 - l^2)*p*Sin[t])/(2*l^2)};
Caso1[Global`Ba,1,1,a_,p_,l_,t_]={0, -(((a - l)*p)/l), 0};
Caso1[Global`Ba,1,2,a_,p_,l_,t_]={0, (a*p)/l, 0};
Caso1[Global`Ba,2,1,a_,p_,l_,t_]={p - (a*p)/l, 0, 0};
Caso1[Global`Ba,2,2,a_,p_,l_,t_]={(a*p)/l, 0, 0};
Caso3[Global`Be,1,a_,m_,l_,t_]:={(6*a*(a - l)*m*Sin[t])/l^3, (-6*a*(a - l)*m*Cos
[t])/l^3,
((-3*a^2 + 4*a*l - l^2)*m)/l^2};
Caso3[Global`Be,2,a_,m_,l_,t_]:={(6*a*(-a + l)*m*Sin[t])/l^3, (-6*a*(-a + l)*m*C
os[t])/l^3,
(a*(-3*a + 2*l)*m)/l^2};
Caso3[Global`Rf,1,a_,m_,l_,t_]:={(3*a*(a - 2*l)*m*Sin[t])/(2*l^3), (-3*a*(a - 2*
l)*m*Cos[t])/(2*l^3),
((-3*a^2 + 6*a*l - 2*l^2)*m)/(2*l^2)};
Caso3[Global`Rf,2,a_,m_,l_,t_]:={(3*a*(-a + 2*l)*m*Sin[t])/(2*l^3),
(-3*a*(-a + 2*l)*m*Cos[t])/(2*l^3), 0};
Caso3[Global`Ri,1,a_,m_,l_,t_]:={(-3*(-a + l)*(a + l)*m*Sin[t])/(2*l^3),
(-3*(a - l)*(a + l)*m*Cos[t])/(2*l^3), 0};
Caso3[Global`Ri,2,a_,m_,l_,t_]:={(-3*(a - l)*(a + l)*m*Sin[t])/(2*l^3),
(-3*(-a + l)*(a + l)*m*Cos[t])/(2*l^3), m/2 - (3*a^2*m)/(2*l^2)};
Caso3[Global`Ba,1,a_,m_,l_,t_]:={-((m*Sin[t])/l), (m*Cos[t])/l, 0};
Caso3[Global`Ba,2,a_,m_,l_,t_]:={(m*Sin[t])/l, -((m*Cos[t])/l), 0};
(*--------------------------------------*)
Resolver[nudo_List,barra_List,apoyo_List]:=Module[
{a, alpa, ba, cantapoyos, cantbarras, cantnudos, cc, cfx,
cfy, cix, ciy, dato, def, deform, e, fbnudos, ff, fila, fnudos, i,
ii, ke, kg, kke, kp, l, lca, ldato, ll, ll1, ll2, long, ls, l2, m,
napoyo, nf, ni, nu, nudosel, nuu, opnf, opni, ops, r,
seleccion, sm, ss, sss, ssss, t, ti, tt},
cantnudos=Length[nudo];
cantbarras=Length[barra];
cantapoyos=Length[apoyo];
Unprotect[Global`Deformaciones,GlobalÈsfuerzos,Global`Reacciones,GlobalÈsfNudo
s];
Clear[Global`Deformaciones,GlobalÈsfuerzos,Global`Reacciones,GlobalÈsfNudos];
l2=Table[{0,0,0},{i,1,cantnudos}];
fbnudos:=Array[nuu,{cantbarras,2}];
fnudos:=Array[nu,cantnudos];
Do[nuu[i,1]={0,0,0}; nuu[i,2]={0,0,0}; ,{i,1,cantbarras,1}];
Do[nu[i]={0,0,0};,{i,1,cantnudos,1}];
kke:=Array[ke,{cantnudos,cantnudos}];
Do[
ke[i,ii]={{0,0,0},{0,0,0},{0,0,0}};
,{i,1,cantnudos,1},{ii,1,cantnudos,1}];
kg={};
Do[ (*-------------------------------------ba------------------*)
ni=barra[[ba,1]];
nf=barra[[ba,2]];
i=barra[[ba,3]];
a=barra[[ba,4]];
e=barra[[ba,5]];
cix=nudo[[ni,1]];
ciy=nudo[[ni,2]];
cfx=nudo[[nf,1]];
cfy=nudo[[nf,2]];
l=Sqrt[(cfx-cix)^2+(cfy-ciy)^2];
alpa =ang1[cfx-cix,cfy-ciy];
t={{Cos[alpa],-Sin[alpa],0},{Sin[alpa],Cos[alpa],0},{0,0,1}};
tt={{Cos[alpa], Sin[alpa], 0}, {-Sin[alpa], Cos[alpa], 0}, {0, 0, 1}};
opni=If[Length[nudo[[ni]]]==5,GlobalÈmp,nudo[[ni,6]]];
opnf=If[Length[nudo[[nf]]]==5,GlobalÈmp,nudo[[nf,6]]];
ops=Which[
opni===GlobalÈmp && opnf===GlobalÈmp ,If[Length[barra[[ba]]]==7,barra[[ba,7]]
,Global`Be],
opni===Global`Rot && opnf===Global`Rot ,Global`Ba,
opni===GlobalÈmp && opnf===Global`Rot ,Global`Rf,
opni===Global`Rot && opnf===GlobalÈmp ,Global`Ri
];
Which[
ops===Global`Be , (* biempotrada*)
l2[[nf]]={(nf-1)*3+1,(nf-1)*3+2,(nf-1)*3+3};
l2[[ni]]={(ni-1)*3+1,(ni-1)*3+2,(ni-1)*3+3};
,
ops===Global`Rf, (* articulada nudo final *)
l2[[ni]]={(ni-1)*3+1,(ni-1)*3+2,(ni-1)*3+3};
l2[[nf,1]]=(nf-1)*3+1;
l2[[nf,2]]=(nf-1)*3+2;
,
ops===Global`Ri, (* articulada nudo inicial *)
l2[[nf]]={(nf-1)*3+1,(nf-1)*3+2,(nf-1)*3+3};
l2[[ni,1]]=(ni-1)*3+1;
l2[[ni,2]]=(ni-1)*3+2;
,
ops===Global`Ba, (* biarticulada*)
l2[[ni,1]]=(ni-1)*3+1;
l2[[ni,2]]=(ni-1)*3+2;
l2[[nf,1]]=(nf-1)*3+1;
l2[[nf,2]]=(nf-1)*3+2;
];
AppendTo[kg,Which[
{t.{{e a/l,0,0},{0,12 e i/l^3,6 e i/l^2},{0,6 e i/l^2,4 e i/l}}.tt,

t.{{-e a/l,0,0},{0,-12 e i/l^3,6 e i/l^2},{0,-6e i/l^2,2 e i/l}}.tt,
t.{{-e a/l,0,0},{0,-12 e i/l^3,-6 e i/l^2},{0,6e i/l^2,2 e i/l}}.tt,
t.{{e a/l,0,0},{0,12 e i/l^3,-6 e i/l^2},{0,-6e i/l^2,4 e i/l}}.tt}
,
{t.{{e a/l,0,0},{0,3 e i/l^3,3 e i/l^2},{0,3 e i/l^2,3 e i/l}}.tt,

t.{{-e a/l,0,0},{0,-3 e i/l^3,0},{0,-3e i/l^2,0}}.tt,
t.{{-e a/l,0,0},{0,-3 e i/l^3,-3 e i/l^2},{0,0,0}}.tt,
t.{{e a/l,0,0},{0,3 e i/l^3,0},{0,0,0}}.tt}
,
{t.{{e a/l,0,0},{0,3 e i/l^3,0},{0,0,0}}.tt,
t.{{-e a/l,0,0},{0,-3 e i/l^3,3 e i/l^2},{0,0,0}}.tt,
t.{{-e a/l,0,0},{0,-3 e i/l^3,0},{0,3e i/l^2,0}}.tt,
t.{{e a/l,0,0},{0,3 e i/l^3,-3 e i/l^2},{0,-3 e i/l^2,3 e i/l}}.tt}
,
{t.{{e a/l,0,0},{0,0,0},{0,0,0}}.tt,
t.{{-e a/l,0,0},{0,0,0},{0,0,0}}.tt,
t.{{-e a/l,0,0},{0,0,0},{0,0,0}}.tt,
t.{{e a/l,0,0},{0,0,0},{0,0,0}}.tt}
,
True, (* error en barras *)
Print["---------------------------------------------------"];
Print["Error de sintaxis en la barra nº: ",ba," ",barra[[ba]]];
Print["La opcion <",barra[[ba,7]],"> no es ninguna del tipo Ri, Re ,Ba o Be "];
Print["---------------------------------------------------"];
Throw["Calculo abortado"]
]];
lca=barra[[ba,6]];
long=Length[lca];
Do[ (*---------------------i----long------------------------------------*)
dato=lca[[i]];
ldato=Length[dato];
Which[
Length[dato]==0 , (* peso propio a1---*)
If[(NumberQ[dato] && N[dato]!=0) || (Not[NumberQ[dato]]),
nuu[ba,1]=nuu[ba,1]-Caso[ops,1,1,0,l,-dato/Cos[alpa],
-dato/Cos[alpa],l,alpa];
];
,
ldato==5 , (* proceso para carga distribuida trapesoidal a2--*)
ll1=dato[[1]]/.{Global`Longitud->l};
Which [
dato[[5]]===Global`Y , (*--------Proyeccion en x-----------*)
nuu[ba,1]=nuu[ba,1]-Caso[ops,1,1,ll1,ll2,dato[[3]],dato[[4]],l,alpa];
,
dato[[5]]===Global`X, (*--------Proyeccion en y-----------*)
,
dato[[5]]===Global`P, (*--------Proyeccion en perpendicular a la barra ---------
--*)
(*nuu[ba,1]=nuu[ba,1]-Caso[ops,1,1,ll1,ll2,dato[[3]]Cos[alpa],dato[[4]]Cos[alpa]
,l,alpa]-
Caso[ops,2,1,ll1,ll2,-dato[[3]]Sin[alpa],-dato[[4]]Sin[alpa],l,alpa];
nuu[ba,2]=nuu[ba,2]-Caso[ops,1,2,ll1,ll2,dato[[3]]Cos[alpa],dato[[4]]Cos[alpa],l
,alpa]-
Caso[ops,2,2,ll1,ll2,-dato[[3]]Sin[alpa],-dato[[4]]Sin[alpa],l,alpa];*)
nuu[ba,1]=nuu[ba,1]-Caso[ops,1,1,ll1,ll2,dato[[3]],dato[[4]],l,alpa]-
Caso[ops,2,1,ll1,ll2,-dato[[3]],-dato[[4]],l,alpa];
, True , (* error en la sintaxis de la barra *)
Print["---------------------------------------------------"];
Print["Error en la barra nº: ",ba];
Print[" "];
Print["< ",barra[[ba]]," >"];
Print[" "];
Print["El termino ",dato," no es de la forma
{ a , b , q1 , q2 , X/Y/P }" ];
Print[" "];
Print[" Recuerde que las proyecciones de las cargas distribuidas se
indican con las letras X,Y y P "];
Print["---------------------------------------------------"];
];
,
ldato==3, (* proceso para carga puntual a4-- *)
If[dato[[3]]===Global`P,
nuu[ba,1]=nuu[ba,1]-Caso1[ops,2,1,ll1,-dato[[2]]Sin[alpa],l,alpa]-
Caso1[ops,1,1,ll1,dato[[2]]Cos[alpa],l,alpa];
,
nuu[ba,1]=nuu[ba,1]-Caso1[ops,2,1,ll1,dato[[2]],l,alpa]-
Caso1[ops,1,1,ll1,dato[[3]],l,alpa];
];
,
ldato==2,
ll1=dato[[1]]/.Global`Longitud->l;
nuu[ba,1]=nuu[ba,1]+Caso3[ops,1,ll1,dato[[2]],l,alpa];
,True,
Print["---------------------------------------------------"];
Print[" "];
Print[" "];
Print["El termino ",dato," no es de algunas de las formas
{ a , b , q1 , q2 , X/Y/P },{ a , fx/fp , fy/P } , { a , m } o peso/m" ];
Print[""];
Print["---------------------------------------------------"];
];
,{i,1,long,1}]; (*-------------------------------------------*)
nu[ni]=nu[ni]+nuu[ba,1];
nu[nf]=nu[nf]+nuu[ba,2];
Do[
If [barra[[ba,1]]==fila,
ke[fila,barra[[ba,1]]]=ke[fila,barra[[ba,1]]]+kg[[ba,1]];
];
];
,{fila,1,cantnudos,1}];
,{ba,1,cantbarras}];(*--------------------ba fin-------------*)
Do[
l2[[ apoyo[[i,1]] ]]*=Abs[(Take[apoyo[[i]],{2,4}]-{1,1,1})];
,{i,1,cantapoyos,1}];
ls=DeleteCases[Flatten[l2],0];
Clear[l2,m];
m=Table[
Table[ke[Quotient[ls[[i]]+2,3],Quotient[ls[[ii]]+2,3]][[Mod[ls[[i]]+2,3]+1,Mod[l
s[[ii]]+2,3]+1]]
,{ii,1,Length[ls],1}],{i,1,Length[ls],1}];
Do[nu[i]=nu[i]-Take[nudo[[i]],{3,5}];,{i,1,cantnudos,1}];
fnudos=fnudos//Flatten;
nudosel=Table[-fnudos[[ls[[a]]]],{a,1,Length[ls],1}];
deform=Inverse[N[m]].nudosel;
ii=0;
def=Table[
If[MemberQ[ls,i],ii++; deform[[ii]],0]
,{i,1,cantnudos*3,1}];
Global`Deformaciones=Partition[def,3];
GlobalÈsfNudos=Partition[(-1)*fnudos,3];
Global`Reacciones=Table[Block[{},
sss={};
ss=Take[fnudos,{((apoyo[[r,1]]-1)*3)+1,((apoyo[[r,1]]-1)*3)+3}];
seleccion={};
Do[
If[apoyo[[r,ff+1]]==1,
sss=Append[sss,ss[[ff]]];
seleccion=Append[seleccion,
Table[ke[apoyo[[r,1]],Quotient[ls[[cc]]+2,3]][[ff,Mod[ls[[cc]]+2,3]+1]]
,
{cc,1,Length[ls],1}]];
]
,
{ff,1,3,1}];
If[Length[ls]==0,ssss=sss;,ssss=seleccion.deform+sss;];
Do[If[apoyo[[r,a+1]]==0,ssss=Insert[ssss,0,a]];,{a,1,3,1}];
Prepend[ssss,"Nodo"ToString[apoyo[[r,1]]]]
,{r,1,cantapoyos,1}];
Clear[sss,ss,ssss];
napoyo=Transpose[apoyo][[1]];
GlobalÈsfuerzos=Table[
Block[{cix,ciy,cfx,cfy,alpa,ni,nf,ti,t},
ni=barra[[ba,1]];
nf=barra[[ba,2]];
cix=nudo[[ni,1]];
ciy=nudo[[ni,2]];
cfx=nudo[[nf,1]];
cfy=nudo[[nf,2]];
t={{Cos[alpa], -Sin[alpa], 0}, {Sin[alpa], Cos[alpa], 0}, {0, 0, 1}};
ti={{Cos[alpa], Sin[alpa], 0}, {-Sin[alpa], Cos[alpa], 0}, {0, 0, 1}};
Join[Apply[Join, Transpose[{ti.kg[[ba,1]],ti.kg[[ba,2]]}], {1}],

Apply[Join, Transpose[{ti.kg[[ba,3]],ti.kg[[ba,4]]}], {1}]].
Join[Take[def,{((ni-1)*3)+1,((ni-1)*3)+3}],Take[def,{((nf-1)*3)+1,((nf-1)*3)+3}]
]+
Join[ti.fbnudos[[ba,1]],ti.fbnudos[[ba,2]]]
]
,{ba,1,cantbarras}];
Protect[Global`Deformaciones,GlobalÈsfuerzos,Global`Reacciones,GlobalÈsfNudos]
;
]
(*------------------------------------------------------------------*)
ResolverC[nudo_List,barra_List,apoyo_List]:=Module[
{a, alpa, ba, cantapoyos, cantbarras, cantnudos, cc, cfx,
cfy, cix, ciy, dato, def, e, fbnudos, ff, fila, fnudos, i,
ii, ke, kg, l, lca, ldato, ll, ll1, ll2, long, ls, l2, m,
napoyo, nf, ni, nu, nuu, opnf, opni, ops, r,
seleccion, sm, ss, sss, ssss, t, ti, tt,tem,tem1,tem2,tem3,tem4},
cantnudos=Length[nudo];
cantbarras=Length[barra];
cantapoyos=Length[apoyo];
Unprotect[Global`Deformaciones,GlobalÈsfuerzos,Global`Reacciones,GlobalÈsfNudo
s,
Global`KK,Global`T,Global`Fp,Global`Dp,Global`Kp,Global`kb];
Clear[Global`Deformaciones,GlobalÈsfuerzos,Global`Reacciones,GlobalÈsfNudos];
l2=Table[{0,0,0},{i,1,cantnudos}];
fbnudos:=Array[nuu,{cantbarras,2}];
fnudos:=Array[nu,cantnudos];
Do[nuu[i,1]={0,0,0}; nuu[i,2]={0,0,0}; ,{i,1,cantbarras,1}];
Do[nu[i]={0,0,0};,{i,1,cantnudos,1}];
Global`KK:=Array[ke,{cantnudos,cantnudos}];
Do[
ke[i,ii]={{0,0,0},{0,0,0},{0,0,0}};
,{i,1,cantnudos,1},{ii,1,cantnudos,1}];
Print["-----------------------------------------------"];
Print[""];
Print[" RESOLUCIoN "];
Print[""];
Print["-----------------------------------------------"];
kg={};
Do[ (*-------------------------------------ba------------------*)
ni=barra[[ba,1]];
nf=barra[[ba,2]];
i=barra[[ba,3]];
a=barra[[ba,4]];
e=barra[[ba,5]];
cix=nudo[[ni,1]];
ciy=nudo[[ni,2]];
cfx=nudo[[nf,1]];
cfy=nudo[[nf,2]];
Print[""];
Print["------------ BARRA ",ni," ",nf," --------------"];
Print[""];
Print["Momento de inercia : ",N[i]];
Print["Seccion : ",N[a]];
Print["Modulo de elasticidad : ",N[e]];
Print["Longitud : ",N[l]];
Print["angulo de inclinacion en grados : ",N[alpa/Degree]];
Print[""];
t={{Cos[alpa],-Sin[alpa],0},{Sin[alpa],Cos[alpa],0},{0,0,1}};
tt={{Cos[alpa], Sin[alpa], 0}, {-Sin[alpa], Cos[alpa], 0}, {0, 0, 1}};
Print["Matriz de transformacion de coordenadas T[",ba,"]"];
Print[""];
Print[MatrixForm[N[t]]];
Print[""];
Global`T[ba]=t;
ops=Which[
opni===GlobalÈmp && opnf===GlobalÈmp ,If[Length[barra[[ba]]]==7,barra[[ba,7]]
,Global`Be],
opni===Global`Rot && opnf===Global`Rot ,Global`Ba,
opni===GlobalÈmp && opnf===Global`Rot ,Global`Rf,
opni===Global`Rot && opnf===GlobalÈmp ,Global`Ri
];
Which[
l2[[nf]]={(nf-1)*3+1,(nf-1)*3+2,(nf-1)*3+3};
l2[[ni]]={(ni-1)*3+1,(ni-1)*3+2,(ni-1)*3+3};
,
l2[[ni]]={(ni-1)*3+1,(ni-1)*3+2,(ni-1)*3+3};
l2[[nf,1]]=(nf-1)*3+1;
l2[[nf,2]]=(nf-1)*3+2;
,
l2[[nf]]={(nf-1)*3+1,(nf-1)*3+2,(nf-1)*3+3};
l2[[ni,1]]=(ni-1)*3+1;
l2[[ni,2]]=(ni-1)*3+2;
,
l2[[ni,1]]=(ni-1)*3+1;
l2[[ni,2]]=(ni-1)*3+2;
l2[[nf,1]]=(nf-1)*3+1;
l2[[nf,2]]=(nf-1)*3+2;
];
AppendTo[kg,Which[
Print["Tipo de barra : biempotrada"];
tem={t.{{e a/l,0,0},{0,12 e i/l^3,6 e i/l^2},{0,6 e i/l^2,4 e i/l}}.tt,
t.{{-e a/l,0,0},{0,-12 e i/l^3,6 e i/l^2},{0,-6e i/l^2,2 e i/l}}.tt,
t.{{-e a/l,0,0},{0,-12 e i/l^3,-6 e i/l^2},{0,6e i/l^2,2 e i/l}}.tt,
t.{{e a/l,0,0},{0,12 e i/l^3,-6 e i/l^2},{0,-6e i/l^2,4 e i/l}}.tt};
Print["Matriz de rigides de la barra ref. a coordenadas globales"];
Print[" KK= T KK' T-transpuesta = kb[",ba,"]" ];
Print[""];
Print[MatrixForm[N[tem]]];
Print[""];
Global`kb[ba]=tem;
tem
,
Print["Tipo de barra : articulada en nudo final"];
tem={t.{{e a/l,0,0},{0,3 e i/l^3,3 e i/l^2},{0,3 e i/l^2,3 e i/l}}.tt,
t.{{-e a/l,0,0},{0,-3 e i/l^3,0},{0,-3e i/l^2,0}}.tt,
t.{{-e a/l,0,0},{0,-3 e i/l^3,-3 e i/l^2},{0,0,0}}.tt,
t.{{e a/l,0,0},{0,3 e i/l^3,0},{0,0,0}}.tt};
Print[" KK= T KK' T-transpuesta = Kb[",ba,"]" ];
Print[""];
Print[""];
Global`kb[ba]=tem;
tem
,
Print["Tipo de barra : articulada en nudo inicial"];
tem={t.{{e a/l,0,0},{0,3 e i/l^3,0},{0,0,0}}.tt,
t.{{-e a/l,0,0},{0,-3 e i/l^3,3 e i/l^2},{0,0,0}}.tt,
t.{{-e a/l,0,0},{0,-3 e i/l^3,0},{0,3e i/l^2,0}}.tt,
t.{{e a/l,0,0},{0,3 e i/l^3,-3 e i/l^2},{0,-3 e i/l^2,3 e i/l}}.tt};
Print[""];
Print[""];
Global`kb[ba]=tem;
tem
,
Print["Tipo de barra : biarticulada "];
tem={t.{{e a/l,0,0},{0,0,0},{0,0,0}}.tt,
t.{{-e a/l,0,0},{0,0,0},{0,0,0}}.tt,
t.{{-e a/l,0,0},{0,0,0},{0,0,0}}.tt,
t.{{e a/l,0,0},{0,0,0},{0,0,0}}.tt};
Print[""];
Print[""];
Print[""];
Global`kb[ba]=tem;
tem
,
True, (* error en barras *)
Print["---------------------------------------------------"];
Print["Error de sintaxis en la barra nº: ",ba," ",barra[[ba]]];
Print["La opcion <",barra[[ba,7]],"> no es ninguna del tipo Ri, Re ,Ba o Be "];
Print["---------------------------------------------------"];
]];
lca=barra[[ba,6]];
long=Length[lca];
Do[ (*---------------------i----long------------------------------------*)
dato=lca[[i]];
ldato=Length[dato];
Which[
];
,
Which [
dato[[5]]===Global`Y , (*--------Proyeccion en x-----------*)
,
dato[[5]]===Global`X, (*--------Proyeccion en y-----------*)
,
--*)
(*nuu[ba,1]=nuu[ba,1]-Caso[ops,1,1,ll1,ll2,dato[[3]]Cos[alpa],dato[[4]]Cos[alpa]
,l,alpa]-
Caso[ops,2,1,ll1,ll2,-dato[[3]]Sin[alpa],-dato[[4]]Sin[alpa],l,alpa];
nuu[ba,2]=nuu[ba,2]-Caso[ops,1,2,ll1,ll2,dato[[3]]Cos[alpa],dato[[4]]Cos[alpa],l
,alpa]-
Caso[ops,2,2,ll1,ll2,-dato[[3]]Sin[alpa],-dato[[4]]Sin[alpa],l,alpa];*)
Print["---------------------------------------------------"];
Print[" "];
Print[" "];
Print["El termino ",dato," no es de la forma
{ a , b , q1 , q2 , X/Y/P }" ];
Print[" "];
Print["---------------------------------------------------"];
];
,
ldato==3, (* proceso para carga puntual a4-- *)
,
];
,
ldato==2,
ll1=dato[[1]]/.Global`Longitud->l;
,True,
Print["---------------------------------------------------"];
Print[" "];
Print[" "];
Print["El termino ",dato," no es de algunas de las formas
{ a , b , q1 , q2 , X/Y/P },{ a , fx/fp , fy/P } , { a , m } o peso/m" ];
Print[""];
Print["---------------------------------------------------"];
];
,{i,1,long,1}]; (*-------------------------------------------*)
nu[ni]=nu[ni]+nuu[ba,1];
nu[nf]=nu[nf]+nuu[ba,2];
Do[
];
];
,{fila,1,cantnudos,1}];
,{ba,1,cantbarras}];(*--------------------ba fin-------------*)
Print["-----------------------------------------------"];
Print[""];
Print[""];
Print["Matriz de rigides global KK"];
Print[""];
Print[""];
Print[MatrixForm[N[Global`KK]]];
Do[
l2[[ apoyo[[i,1]] ]]*=Abs[(Take[apoyo[[i]],{2,4}]-{1,1,1})];
,{i,1,cantapoyos,1}];
ls=DeleteCases[Flatten[l2],0];
Clear[l2,m];
Global`Kp=Table[
Table[ke[Quotient[ls[[i]]+2,3],Quotient[ls[[ii]]+2,3]][[Mod[ls[[i]]+2,3]+1,Mod[l
s[[ii]]+2,3]+1]]
,{ii,1,Length[ls],1}],{i,1,Length[ls],1}];
Do[nu[i]=nu[i]-Take[nudo[[i]],{3,5}];,{i,1,cantnudos,1}];
fnudos=fnudos//Flatten;
Global`Fp=Table[-fnudos[[ls[[a]]]],{a,1,Length[ls],1}];
Global`Dp=Inverse[N[Global`Kp]].Global`Fp;
Print["-----------------------------------------------"];
Print[""];
Print[""];
Print["Ecucion general modificada f*=KK* d* = Fp = Kp Dp "];
Print["--------- Fp -----------"];
Print[MatrixForm[N[Global`Fp]]];
Print[""];
Print["--------- Kp -----------"];
Print[MatrixForm[N[Global`Kp]]];
Print[""];
Print["--------- Dp (incognita)-----------"];
Print[MatrixForm[N[Global`Dp]]];
Print[""];
ii=0;
def=Table[
If[MemberQ[ls,i],ii++; Global`Dp[[ii]],0]
,{i,1,cantnudos*3,1}];
Global`Deformaciones=Partition[def,3];
GlobalÈsfNudos=Partition[(-1)*fnudos,3];
Print["-----------------------------------------------"];
Print[""];
Print["Matriz desplazamientos (Deformaciones) "];
Print[MatrixForm[N[Global`Deformaciones]]];
Print[""];
Print["-----------------------------------------------"];
Print[""];
Print["Calculo de las reacciones "];
Print["Responden a la ecucion general : "];
Print[" ri = k d* + rei "];
Print[""];
Global`Reacciones=Table[Block[{},
sss={};
ss=Take[fnudos,{((apoyo[[r,1]]-1)*3)+1,((apoyo[[r,1]]-1)*3)+3}];
seleccion={};
Do[
If[apoyo[[r,ff+1]]==1,
sss=Append[sss,ss[[ff]]];
seleccion=Append[seleccion,
Table[ke[apoyo[[r,1]],Quotient[ls[[cc]]+2,3]][[ff,Mod[ls[[cc]]+2,3]+1]]
,
{cc,1,Length[ls],1}]];
]
,
{ff,1,3,1}];
If[Length[ls]==0,ssss=sss;,ssss=seleccion.Global`Dp+sss;];
Do[If[apoyo[[r,a+1]]==0,ssss=Insert[ssss,0,a]];,{a,1,3,1}];
Print["Apoyo ",apoyo[[r,1]]," resolucion :"];
Print[""];
Print["r",apoyo[[r,1]],"="];
Print[""];
Print[MatrixForm[N[ssss]]];
Print[""];
Print["="];
Print[""];
Print[MatrixForm[N[seleccion]]];
Print[""];
Print["."];
Print[""];
Print[MatrixForm[N[Global`Dp]]];
Print[""];
Print["+"];
Print[""];
Print[MatrixForm[N[sss]]];
Print[""];
Prepend[ssss,"Nodo"ToString[apoyo[[r,1]]]]
]
,{r,1,cantapoyos,1}];
Clear[sss,ss,ssss];
napoyo=Transpose[apoyo][[1]];
Print["-----------------------------------------------"];
Print[""];
Print[""];
Print["Calculo de los esfuerzos en los extremos \n de las barras"];
Print[""];
GlobalÈsfuerzos=Table[
Block[{cix,ciy,cfx,cfy,alpa,ni,nf,ti,t},
ni=barra[[ba,1]];
nf=barra[[ba,2]];
cix=nudo[[ni,1]];
ciy=nudo[[ni,2]];
cfx=nudo[[nf,1]];
cfy=nudo[[nf,2]];
t={{Cos[alpa], -Sin[alpa], 0}, {Sin[alpa], Cos[alpa], 0}, {0, 0, 1}};
ti={{Cos[alpa], Sin[alpa], 0}, {-Sin[alpa], Cos[alpa], 0}, {0, 0, 1}};
tem1=Join[Apply[Join, Transpose[{ti.kg[[ba,1]],ti.kg[[ba,2]]}], {1}],

Apply[Join, Transpose[{ti.kg[[ba,3]],ti.kg[[ba,4]]}], {1}]];
tem2=Join[Take[def,{((ni-1)*3)+1,((ni-1)*3)+3}],Take[def,{((nf-1)*3)+1,((nf-1)*3
)+3}]];
tem3=Join[ti.fbnudos[[ba,1]],ti.fbnudos[[ba,2]]];
tem4=tem1.tem2+tem3;
Print[""];
Print["------------ BARRA ",ni," ",nf," --------------"];
Print[""];
Print[MatrixForm[N[tem4]]];
Print[""];
Print[" = "];
Print[""];
Print[""];
Print[" . "];
Print[""];
Print[""];
Print[" + "];
Print[""];
Print[""];
tem4
]
,{ba,1,cantbarras}];
Print["-----------------------------------------------"];
Print[""];
Print[" FIN DEL CaLCULO "];
Print[""];
Print["Cargando matrices en memoria :"];
Print["Deformaciones,Esfuerzos,Reacciones,\nEsfNudos,T,kb,KK,Kp,Fp,Dp"];
Protect[Global`Deformaciones,GlobalÈsfuerzos,Global`Reacciones,GlobalÈsfNudos,
Global`KK,Global`T,Global`Fp,Global`Dp,Global`Kp,Global`kb];
(*--------------------------------------------------------------------------*)
GraficarEstructura[{nudo_List,barra_List,apoyo_List},op1___List,op2___Rule]:=Mod
ule[
{a, alpa, apo, b, ba, Ba, b1, CApoyos1, CBarras1,
CCargas1, cfx, cfy, cix, ciy, cof, coi, colordc, colordg, colordm,
colordn, colore, corte1, CTextoBarras1, CTextoCargas1,
CTextoNudos1, c1fx, c1fy, c1ix, c1iy, dato, def, defor, Error,
escalaflecha, escalatita, escdef, escfue, fApoyos, fBarras,
fCargas, fcargasdistribuidas, fcargaspuntuales, fdco, fdgi, fdmo,
fdmo1, fdno, fela,fese, ff, fl, flag, fmomentos, fnada, fNudos, fx, fy,
graf, Graficar1, i, ii, Indicar1, l, la, lca, ldato, ll1, ll2,
long, mm, momen1, nf, ni, normal1, Null, nuu, opnf, opni,
ops, pasos, rad, salvar, tcc, x, xd1, xd2, xf, xi, xl,
xll, xm, xmax, xmin, xx, xx1, x1, x2, y, yd1, yd2, yf, yi, ym,
ymax, ymin, yy, yy1, y1, y2,c,fff},
Unprotect[
Global`Graficar,
GlobalÌndicar,
Global`ColorBarras,
Global`ColorApoyos,
Global`ColorTextoNudos,
Global`ColorTextoBarras,
Global`ColorCargas,
Global`ColorTextoCargas,
Global`Deformaciones,
GlobalÈsfuerzos,
Global`Reacciones,
GlobalÈsfNudos,
GlobalÈscalaFuerza,
Global`DMomento,
Global`DCorte,
Global`DNormal,
Global`DGiro,
GlobalÈlastica,
Global`ColorDM,
Global`ColorDC,
Global`ColorDN,
Global`ColorDG,
Global`ColorE,
Global`Momentos,
Global`CargasPuntuales,
Global`CargasDistribuidas,
Global`Nada,
Global`Barras,
Global`Nudos,
Global`Cargas
];
Clear[Global`Graficar,GlobalÌndicar,Global`ColorBarras,Global`ColorApoyos,Globa
l`ColorTextoNudos,
Global`ColorTextoBarras,Global`ColorCargas,GlobalÈscalaFuerza,
Global`ColorTextoCargas];
Protect[
GlobalÈscalaFuerza,
Global`Graficar,
GlobalÌndicar,
Global`ColorBarras,
Global`ColorApoyos,
Global`ColorTextoNudos,
Global`ColorTextoBarras,
Global`ColorCargas,
Global`ColorTextoCargas,
Global`ColorDM,
Global`ColorDN,
Global`ColorDC,
Global`ColorDG,
Global`ColorE,
GlobalÈlasticaSinEstructura,
Global`DPasos,
GlobalÈscalaNCM,
GlobalÈscalaG,
GlobalÈscalaE,
Global`Momentos,
Global`CargasPuntuales,
Global`CargasDistribuidas,
Global`Nada,
Global`Barras,
Global`Nudos,
Global`Cargas
];
If[!NumberQ[1 op1],
If[MemberQ[op1,Global`Graficar->_],
Graficar1=Global`Graficar/.op1;,Graficar1={Global`Nada};];
If[MemberQ[op1,GlobalÌndicar->_],Indicar1=GlobalÌndicar/.op1;
,Indicar1={Global`Todo};];
If[MemberQ[op1,GlobalÈscalaFuerza->_],
escfue=GlobalÈscalaFuerza/.op1;,escfue=.5;];
If[MemberQ[op1,Global`ColorDM->_],colordm=Global`ColorDM/.op1;,
colordm=RGBColor[1.000,0.000,0.000];];
If[MemberQ[op1,Global`ColorDN->_],colordn=Global`ColorDN/.op1;,
colordn=RGBColor[0.000,0.000,1.000];];
If[MemberQ[op1,Global`ColorDC->_],colordc=Global`ColorDC/.op1;,
colordc=RGBColor[0.000,0.502,0.000];];
If[MemberQ[op1,Global`ColorDG->_],colordg=Global`ColorDG/.op1;,
colordg=RGBColor[0.502,0.000,0.502];];
If[MemberQ[op1,Global`ColorE->_],colore=Global`ColorE/.op1;,
colore=RGBColor[0.000,0.000,0.502];];
If[MemberQ[op1,Global`DPasos->_],pasos=Global`DPasos/.op1;,
pasos=20;];
If[MemberQ[op1,GlobalÈscalaNCM->_],escdef=GlobalÈscalaNCM/.op1;,
escdef=.1;];
If[MemberQ[op1,GlobalÈscalaG->_],escalatita=GlobalÈscalaG/.op1;,
escalatita=10;];
If[MemberQ[op1,GlobalÈscalaE->_],escalaflecha=GlobalÈscalaE/.op1;,
escalaflecha=100;];
If[MemberQ[op1,Global`ColorBarras->_],CBarras1=Global`ColorBarras/.op1;,
CBarras1=RGBColor[0.502,0.000,0.000];];
If[MemberQ[op1,Global`ColorApoyos->_],CApoyos1=Global`ColorApoyos/.op1;,
CApoyos1=RGBColor[0.000,0.000,1.000];];
If[MemberQ[op1,Global`ColorTextoNudos->_],CTextoNudos1=Global`ColorTextoNudos/.o
p1;,
CTextoNudos1=RGBColor[1.000,0.000,0.000];];
If[MemberQ[op1,Global`ColorTextoBarras->_], CTextoBarras1=Global`ColorTextoBarra
s/.op1;,
CTextoBarras1=RGBColor[0.502,0.000,0.000];];
If[MemberQ[op1,Global`ColorCargas->_],CCargas1=Global`ColorCargas/.op1;,
CCargas1=RGBColor[0.000,0.000,0.000];];
If[MemberQ[op1,Global`ColorTextoCargas->_],CTextoCargas1=Global`ColorTextoCargas
/.op1;
,
CTextoCargas1=RGBColor[0.000,0.000,0.000];];
,
(* valores Por defecto*)
Graficar1={Global`Nada};
Indicar1={Global`Todo};
CBarras1=RGBColor[0.502,0.000,0.000];
CApoyos1=RGBColor[0.000,0.000,1.000];
CTextoNudos1=RGBColor[1.000,0.000,0.000];
CTextoBarras1=RGBColor[0.502,0.000,0.000];
CCargas1=RGBColor[0.000,0.000,0.000];
CTextoCargas1=RGBColor[0.000,0.000,0.000];
colordm=RGBColor[1.000,0.000,0.000];
colordn=RGBColor[0.000,0.000,1.000];
colordc=RGBColor[0.000,0.502,0.000];
colordg=RGBColor[0.502,0.000,0.502];
colore=RGBColor[0.000,0.000,0.502];
pasos=20;
escdef=.1;
escalatita=10;
escalaflecha=100;
escfue=.5;
];
fBarras=False;
fNudos=False;
fCargas=False;
fnada=True;
If[MemberQ[Indicar1,Global`Todo],
fBarras=True;
fNudos=True;
fCargas=True;
fApoyos=True;
fnada=False;
];
If[MemberQ[Indicar1,Global`Barras],fnada=False;fBarras=True;];
If[MemberQ[Indicar1,Global`Nudos],fnada=False;fNudos=True;];
If[MemberQ[Indicar1,Global`Cargas],fnada=False;fCargas=True;];
fmomentos=False;
fcargaspuntuales=False;
fcargasdistribuidas=False;
If[MemberQ[Graficar1,Global`Todo],
fmomentos=True;
fcargaspuntuales=True;
fcargasdistribuidas=True;
(*fnada=False;*)
];
def=False;
fdmo=False;
fdmo1=False;
fdco=False;
fdno=False;
fdgi=False;
fela=False;
fese=False;
If[MemberQ[Graficar1,GlobalÈlasticaSinEstructura],
fnada=False;
fese=True;
def=True;
fdmo=True;
fela=True;
];
If[MemberQ[Graficar1,Global`Momentos],fmomentos=True;];
If[MemberQ[Graficar1,Global`CargasPuntuales],fcargaspuntuales=True;];
If[MemberQ[Graficar1,Global`CargasDistribuidas],fcargasdistribuidas=True;];
If[MemberQ[Graficar1,Global`DMomento],fnada=False;def=True;fdmo1=True;fdmo=True;
];
If[MemberQ[Graficar1,Global`DCorte],fnada=False;def=True;fdco=True;];
If[MemberQ[Graficar1,Global`DNormal],fnada=False;def=True;fdno=True;];
If[MemberQ[Graficar1,Global`DGiro],fnada=False;def=True;fdmo=True;fdgi=True;];
If[MemberQ[Graficar1,GlobalÈlastica],fnada=False;def=True;fdmo=True;fela=True;]
;
salvar=True;
yy=Table[nudo[[i,2]],{i,1,Length[nudo],1}];
xx=Table[nudo[[i,1]],{i,1,Length[nudo],1}];
xmax=Max[xx];
xmin=Min[xx];
ymax=Max[yy];
ymin=Min[yy];
b=If[Abs[xmin-xmax] < Abs[ymin-ymax],Abs[ymin-ymax]/20,Abs[xmin-xmax]/20];
fl=1.5 b;
rad= b/5//N;
graf={};
tcc={};
defor={};
If [fese==False ,
AppendTo[graf,CBarras1];
Do[(*----------------- ba --------------------------*)
ni=barra[[ba,1]];
nf=barra[[ba,2]];
cix=nudo[[ni,1]];
ciy=nudo[[ni,2]];
cfx=nudo[[nf,1]];
cfy=nudo[[nf,2]];
AppendTo[graf,
Which[
opni===GlobalÈmp && opnf===GlobalÈmp ,
If[Length[barra[[ba]]]==7,
ops=barra[[ba,7]];
Which[
ops===Global`Be ,
{Line[{{cix,ciy},{cfx,cfy}}]}
,ops===Global`Rf, (* articulada nudo final *)
{Circle[{cfx-rad*Cos[alpa],cfy-rad*Sin[alpa]},rad],
Line[{{cix,ciy},{cfx-2*rad*Cos[alpa],cfy-2*rad*Sin[alpa]}}]
}
,ops===Global`Ri, (* articulada nudo inicial *)
{
Circle[{cix+rad*Cos[alpa],ciy+rad*Sin[alpa]},rad],
Line[{{cix+2*rad*Cos[alpa],ciy+2*rad*Sin[alpa]},{cfx,cfy}}]
}
,ops===Global`Ba, (* biarticulada*)
{
Circle[{cix+rad*Cos[alpa],ciy+rad*Sin[alpa]},rad],
Circle[{cfx-rad*Cos[alpa],cfy-rad*Sin[alpa]},rad],
Line[{
{cix+2*rad*Cos[alpa],ciy+2*rad*Sin[alpa]},
{cfx-2*rad*Cos[alpa],cfy-2*rad*Sin[alpa]}}]
}
,True, (* error en barras *)
Error::Datos="Error de sintaxis en la barra nº: `1` , `2`
La opcion <`3`> no es ninguna del tipo Ri, Re , Ba o Be
---------------------------------------------------";
Message[Error::Datos,ba,barra[[ba]],barra[[ba,7]]];
]
,
Line[{Take[nudo[[ni]],{1,2}],Take[nudo[[nf]],{1,2}]}]
]
,
opni===Global`Rot && opnf===Global`Rot ,
{Disk[{cix,ciy},rad],Disk[{cfx,cfy},rad],Line[{Take[nudo[[ni]],{1,2}],Take[nudo[
[nf]],{1,2}]}]},
opni===GlobalÈmp && opnf===Global`Rot ,
{Disk[{cfx,cfy},rad],Line[{Take[nudo[[ni]],{1,2}],Take[nudo[[nf]],{1,2}]}]},
opni===Global`Rot && opnf===GlobalÈmp ,
{Disk[{cix,ciy},rad],Line[{Take[nudo[[ni]],{1,2}],Take[nudo[[nf]],{1,2}]}]}
]
]
,{ba,1,Length[barra]}];
];
AppendTo[graf,CApoyos1];
Do[
x=nudo[[apoyo[[ii,1]],1]];
y=nudo[[apoyo[[ii,1]],2]];
apo=Take[apoyo[[ii]],{2,4}];
coi=Select[barra,(apoyo[[ii,1]]==#[[1]])&];
cof=Select[barra,(apoyo[[ii,1]]==#[[2]])&];
xi=0;yi=0;xf=0;yf=0;
Do[xi=xi+nudo[[coi[[i,2]],1]]; yi=yi+nudo[[coi[[i,2]],2]]; ,{i,1,Length[coi],1}]
;
Do[xf=xf+nudo[[cof[[i,1]],1]]; yf=yf+nudo[[cof[[i,1]],2]]; ,{i,1,Length[cof],1}]
;
ym=(yi+yf)/(Length[coi]+Length[cof]);
xm=(xi+xf)/(Length[coi]+Length[cof]);
alpa=ang[xm-x,ym-y];
AppendTo[graf,
Which[
apo=={1,1,1},
lemp[x,y,alpa,b] ,
apo=={1,1,0},
a=If[alpa>=4/3 Pi ,-Pi/2,Pi/2]//N;
Join[{tria[x,y,a,b]},{ltemp[x,y,a,b]},{cir[x,y,rad 1.5]}],
apo=={1,0,0},
a=If[ 1.5 Pi>= alpa >=Pi/2 , Pi,0 ]//N;
Join[{tria[x,y,a,b]},{lsim[x,y,a,b]}]
,
apo=={0,1,0},
a=If[alpa>=4/3 Pi ,-Pi/2,Pi/2]//N;
Join[{tria[x,y,a,b]},{lsim[x,y,a,b]}]
]
];(*******************************************)
,{ii,1,Length[apoyo],1}];
If [fese==False,
Do[ AppendTo[graf,Point[{nudo[[i,1]],nudo[[i,2]]}]],{i,1,Length[nudo],1}];
];
If[fNudos,
AppendTo[graf,CTextoNudos1];
(*color del texto*)
Do[
AppendTo[graf,Text[" n"ToString[i],{nudo[[i,1]],nudo[[i,2]]}]]
,{i,1,Length[nudo],1}]
];
If[fBarras,
AppendTo[graf,CTextoBarras1];
(* Color del texto*)

b1=0;
Do[
x1=nudo[[barra[[i,1]],1]];
x2=nudo[[barra[[i,2]],1]];
y1=nudo[[barra[[i,1]],2]];
y2=nudo[[barra[[i,2]],2]];
AppendTo[graf,
Text[" b"ToString[i],{(x1+x2)/2+b1(x1-x2),(y1+y2)/2+b1(y1-y2)}]
]
,{i,1,Length[barra],1}]
];
If[ ! fnada ,
(* -----------------color texto cargas-----------------------------*)
If[fCargas,
AppendTo[tcc,CTextoCargas1];
flag=True;,
flag=False;];
AppendTo[graf,CCargas1];
(*color de las cargas*)
Do[(*---------------------------ba-----------------------*)
corte1={};
momen1={};
normal1={};
ni=barra[[ba,1]];
nf=barra[[ba,2]];
cix=nudo[[ni,1]];
ciy=nudo[[ni,2]];
cfx=nudo[[nf,1]];
cfy=nudo[[nf,2]];
alpa = ang[(cfx-cix),(cfy-ciy)];
lca=barra[[ba,6]];
long=Length[lca];
Do[ (*---------------------i----long------------------------------------*)
dato=lca[[i]];
ldato=Length[dato];
Which[
(* grafica de deformaciones *)

If[def,
If[fdco,AppendTo[corte1,c2[xl,0,l,-dato Cos[alpa],-dato Cos[alpa]]]];
If[fdmo,AppendTo[momen1,m2[xl,0,l,-dato Cos[alpa],-dato Cos[alpa]]]];
If[fdno,AppendTo[normal1,nor2y[x,0,l,-Cos[alpa] dato,-Cos[alpa] dato,alpa]]];
];
(*--------------------------*)
If[fcargasdistribuidas,
If[flag,AppendTo[tcc,Text[StringJoin["p/l =",ToString[dato]],
{(cix+cfx)/2.,(ciy+cfy)/2.}]]];
AppendTo[graf,
cargatrapezoidal[cix,ciy,cfx,cfy,cix,ciy+dato escfue,cfx,cfy+dato escfue,b]
];
];
];
,
c1ix=cix+Cos[alpa] ll1;
c1iy=ciy+Sin[alpa] ll1;
c1fx=cix+Cos[alpa] ll2;
c1fy=ciy+Sin[alpa] ll2;
Which [
dato[[5]]===Global`Y , (*--------Proyeccion en Y-----------*)
If[def,
If[fdco,AppendTo[corte1,c2[xl,ll1,ll2,dato[[3]] Cos[alpa]^2,dato[[4]] Cos[alpa]^

2]]];
If[fdmo,AppendTo[momen1,m2[xl,ll1,ll2,dato[[3]] Cos[alpa]^2,dato[[4]] Cos[alpa]^
2]]];
If[fdno,AppendTo[normal1,nor2y[xl,ll1,ll2,dato[[3]] Cos[alpa],dato[[4]] Cos[alpa
],alpa]]];
];
(*--------------------------*)
If[N[c1iy]<N[c1fy],
If[flag,AppendTo[tcc,cartexto[c1ix,c1fy,c1fx,c1fy,
c1ix,c1fy-dato[[3]] escfue,c1fx,c1fy-dato[[4]] escfue,
StringJoin["q1=",ToString[dato[[3]]]],StringJoin["q2=",ToString[dato[[4]]]]]]];
AppendTo[graf,
cargatrapezoidal[
c1ix,c1fy,c1fx,c1fy,
c1ix,c1fy-dato[[3]] escfue,c1fx,c1fy-dato[[4]] escfue,fl]//N
];
,
If[flag,AppendTo[tcc,cartexto[c1ix,c1iy,c1fx,c1iy,
c1ix,c1iy-dato[[3]] escfue,c1fx,c1iy-dato[[4]] escfue,
StringJoin["q1=",ToString[dato[[3]]]],
StringJoin["q2=",ToString[dato[[4]]]]]]];
AppendTo[graf,
cargatrapezoidal[c1ix,c1iy,c1fx,c1iy,
c1ix,c1iy-dato[[3]] escfue,c1fx,c1iy-dato[[4]] escfue,fl]//N
];
];
];
,
dato[[5]]===Global`X, (*--------Proyeccion en X-----------*)
If[def,
If[fdco,AppendTo[corte1,c2[xl,ll1,ll2,dato[[3]] Sin[alpa]^2,dato[[4]] Sin[alpa]^
2]]];
If[fdmo,AppendTo[momen1,m2[xl,ll1,ll2,-dato[[3]] Sin[alpa]^2,-dato[[4]] Sin[alpa
]^2]]];
If[fdno,AppendTo[normal1,nor2x[xl,ll1,ll2,dato[[3]] Sin[alpa],dato[[4]] Sin[alpa
],alpa]]];
];
(*--------------------------*)
If[N[c1ix]>N[c1fx],
If[flag,AppendTo[tcc,cartexto[c1ix,c1iy,c1ix,c1fy,
c1ix-dato[[3]] escfue,c1iy,c1ix-dato[[4]] escfue,c1fy,
AppendTo[graf,
cargatrapezoidal[c1ix,c1iy,c1ix,c1fy,
c1ix-dato[[3]] escfue,c1iy,c1ix-dato[[4]] escfue,c1fy,fl]//N
];
,
If[flag,AppendTo[tcc,cartexto[c1fx,c1iy,c1fx,c1fy,
c1fx-dato[[3]] escfue,c1iy,c1fx-dato[[4]] escfue,c1fy,
AppendTo[graf,
cargatrapezoidal[c1fx,c1iy,c1fx,c1fy,
c1fx-dato[[3]] escfue,c1iy,c1fx-dato[[4]] escfue,c1fy,fl]//N
];
];
];
,
--*)
If[def,
If[fdco,AppendTo[corte1,c2[xl,ll1,ll2,dato[[3]],dato[[4]]]]];
If[fdmo,AppendTo[momen1,m2[xl,ll1,ll2,dato[[3]] ,dato[[4]]]]];
(* no hay componente normal *)
];
(*--------------------------*)
If[flag,AppendTo[tcc,cartexto[c1ix,c1iy,c1fx,c1fy,
c1ix-Cos[alpa+Pi/2]*dato[[3]] escfue,
c1iy-Sin[alpa+Pi/2]*dato[[3]] escfue,
c1fx-Cos[alpa+Pi/2]*dato[[4]] escfue,
c1fy-Sin[alpa+Pi/2]*dato[[4]] escfue,
StringJoin["q1=",ToString[dato[[3]]]],StringJoin["q2=",ToString[dato[[4]]]]]];
];
AppendTo[graf,
cargatrapezoidal[c1ix,c1iy,c1fx,c1fy,
c1ix-Cos[alpa+Pi/2]*dato[[3]] escfue,
c1iy-Sin[alpa+Pi/2]*dato[[3]] escfue,
c1fx-Cos[alpa+Pi/2]*dato[[4]] escfue,
c1fy-Sin[alpa+Pi/2]*dato[[4]] escfue,fl]//N
];
];
Error::Datos="Error en la barra nº: `1` < `2` >
El termino `3` no es de la forma { a , b , q1 , q2 , X/Y/P }
Recuerde que las proyecciones de las cargas distribuidas se
indican con las letras X,Y y P \n
------------------------------------------------------";
Message[Error::Datos,ba,barra[[ba]],dato];
];(* del if *)
,
ldato==3 , (* proceso para carga puntual a4-- *)
If[fcargaspuntuales || def ,
If[def,
If[fdco,AppendTo[corte1,c1[xl,ll1,dato[[2]]]]];
If[fdmo,AppendTo[momen1,m1[xl,ll1,dato[[2]]]]];
(* no hay componente normal *)
];
(*--------------------------*)
If[fcargaspuntuales,
If[flag,AppendTo[tcc,Text[ StringJoin["fp=",ToString[dato[[2]]] ],
{c1ix-.5 Cos[alpa+Pi/2] dato[[2]] escfue,
c1iy-.5 Sin[alpa+Pi/2] dato[[2]] escfue}]]];
AppendTo[graf,
vector[c1ix,c1iy,
c1ix-Cos[alpa+Pi/2] dato[[2]] escfue,
c1iy-Sin[alpa+Pi/2] dato[[2]] escfue,b/2.5]
];
];
,
If[def,
If[fdco,
AppendTo[corte1,-c1[xl,ll1,Sin[alpa] dato[[2]]]];];
If[fdmo,AppendTo[momen1,-m1[xl,ll1,Sin[alpa] dato[[2]]]];];
If[fdno,AppendTo[normal1,nor1x[xl,ll1,dato[[2]],alpa]];];
If[fdco,AppendTo[corte1,c1[xl,ll1,Cos[alpa] dato[[3]]]];];
If[fdmo,AppendTo[momen1,m1[xl,ll1,Cos[alpa] dato[[3]]]];];
If[fdno,AppendTo[normal1,nor1y[xl,ll1,dato[[3]],alpa]];];
];
(*--------------------------*)
If[flag,
AppendTo[tcc,Text[
Which[
N[dato[[2]]]!=0 && N[dato[[3]]]!=0,
StringJoin["fx=",ToString[dato[[2]]]," fy=",ToString[dato[[3]]]],
N[dato[[2]]]!=0 && N[dato[[3]]]==0,
StringJoin["fx=",ToString[dato[[2]]]],
N[dato[[2]]]==0 && N[dato[[3]]]!=0,
StringJoin[" fy=",ToString[dato[[3]]]],
True,
""
],{ c1ix-.5 dato[[2]] escfue,
c1iy-.5 dato[[3]] escfue}]]];
AppendTo[graf,
vector[c1ix,c1iy,
c1ix -dato[[2]] escfue,
c1iy -dato[[3]] escfue,b/2.5]
];
];
];
];
,
ldato==2,(* momento *)
If[fmomentos || def,
If[def,
If[fdmo,AppendTo[momen1,moo[xl,ll1,dato[[2]]]];];
];
(*--------------------------*)
If[fmomentos,
If[flag,AppendTo[tcc,
Text[StringJoin["m=",ToString[dato[[2]]]],
{c1ix,c1iy}]]] ;
AppendTo[graf,momento[c1ix,c1iy,b,If[dato[[2]]>0,1,-1]]];
];
];
,True,
El termino `3` no es de algunas de las formas
{ a , b , q1 , q2 , X/Y/P },{ a , fx/fp , fy/P } , { a , m } o peso/m.
Recuerde que las proyecciones de las cargas distribuidas se indican
con las letras X,Y y P .\n
---------------------------------------------------";
];
,{i,1,long,1}]; (*-------------------------------------------*)
If[def,
If[fdmo ,AppendTo[momen1,
mo[xl,-GlobalÈsfuerzos[[ba,3]],GlobalÈsfuerzos[[ba,2]]]];];
If[fdmo1 ,
AppendTo[defor,colordm]; (*color de diag. de momento *)
Clear[xl,ff,x];
ff[x_]=-Apply[Plus,momen1]/.xl->x;
AppendTo[defor,
Join[{
Line[Table[
{N[cix + xll*Cos[alpa] -escdef*ff[xll]*Sin[alpa]],N[ciy +escdef*ff[xll]*Cos[alpa
] + xll*Sin[alpa]]}
,
Table[
Line[{{N[cix + xll Cos[alpa]], N[ciy + xll Sin[alpa]] },
{N[cix + xll*Cos[alpa] -escdef*ff[xll]*Sin[alpa]],
N[ciy +escdef*ff[xll]*Cos[alpa] + xll*Sin[alpa]]}}]
,{xll,0,l,l/pasos}]
]
];
];
If[fdco ,
AppendTo[corte1,GlobalÈsfuerzos[[ba,2]]];
AppendTo[defor,colordc]; (*color de diag. de corte *)
Clear[xl,ff,x];
ff[x_]=Apply[Plus,corte1]/.xl->x;
AppendTo[defor,
Join[{
Line[Table[
] + xll*Sin[alpa]]}
,
Table[
,{xll,0,l,l/pasos}]
]
];
];
If[fdno,AppendTo[normal1,GlobalÈsfuerzos[[ba,1]]];
AppendTo[defor,colordn]; (*color de diag. normal *)
Clear[xl,ff,x];
ff[x_]=Apply[Plus,normal1]/.xl->x;
AppendTo[defor,
Join[{
Line[Table[
] + xll*Sin[alpa]]}
,
Table[
,{xll,0,l,l/pasos}]
]
];
];
If[fdgi ,(*--------- tita ------------------*)
Clear[ff,fff,x,xl];
fff[x_]=fff[x]/.NDSolve[{fff''[x]==(N[Apply[Plus,momen1]]/.xl->x)/
(barra[[ba,3]] barra[[ba,5]]),fff[0]==0,fff'[0]==0},fff[x],{x,0,l+.1}][[1]];
c=-((fff[l] - Cos[alpa]*Global`Deformaciones[[nf,2]]+Cos[alpa]*Global`Deformacio
nes[[ni,2]] +
Global`Deformaciones[[nf,1]]*Sin[alpa]-Global`Deformaciones[[ni,1]]*Sin[alpa])/l
);
Clear[ff,x,xl];
ff[x_]=escalatita * ff[x]/.NDSolve[{ff'[x]==(N[Apply[Plus,momen1]]/.xl->x)/(barr
a[[ba,3]]*barra[[ba,5]]),
ff[0]==c},ff[x],{x,0,l+.001}][[1]];
AppendTo[defor,colordg];
AppendTo[defor,
Join[{
Line[Table[
] + xll*Sin[alpa]]}
,
Table[
,{xll,0,l,l/pasos}]
]
];
];
If[fela ,(* --------- flecha -----------*)
xd1=Global`Deformaciones[[ni,1]] escalaflecha;
yd1=Global`Deformaciones[[ni,2]] escalaflecha;
xd2=Global`Deformaciones[[nf,1]] escalaflecha;
yd2=Global`Deformaciones[[nf,2]] escalaflecha;
(*AppendTo[defor,Disk[{nudo[[ni,1]]+xd1,nudo[[ni,2]]+yd1},rad/2]];*)
la=(l-xd1 Cos[alpa]- yd1 Sin[alpa]+xd2 Cos[alpa]+ yd2 Sin[alpa])/l//N;
xx1=cix+xd1;
yy1=ciy+yd1;
AppendTo[defor,colore];
Clear[ff,fff,x,xl];
fff[x_]=fff[x]/.NDSolve[{fff''[x]==(N[Apply[Plus,momen1]]/.xl->x)/
c=-((yd1*Cos[alpa] - yd2*Cos[alpa] + escalaflecha*fff[l] -
xd1*Sin[alpa] + xd2*Sin[alpa])/(escalaflecha*l));
ff[x_]=escalaflecha*ff[x]/.NDSolve[{ff''[x]==(N[Apply[Plus,momen1]]/.xl->x)/
(barra[[ba,3]] barra[[ba,5]]),ff[0]==0,ff'[0]==c},ff[x],{x,0,l+.1}][[1]];
AppendTo[defor,
Line[Append[Table[{N[xx1 +la*xl*Cos[alpa] -ff[xl]*Sin[alpa]],
N[yy1 +ff[xl]*Cos[alpa] +la*xl*Sin[alpa]]}
,{xl,0,l-l/pasos,l/pasos}],{cfx+xd2,cfy+yd2}]]];
];
];
(*--------------------------*)
,{ba,1,Length[barra],1}];
]; (*fin de if*)
Do[
x=nudo[[nuu,1]];
y=nudo[[nuu,2]];
fx=nudo[[nuu,3]];
fy=nudo[[nuu,4]];
mm=nudo[[nuu,5]];
If[flag ,
If[N[mm]!=0 && fmomentos ,AppendTo[tcc,Text[StringJoin["m=",ToString[mm]],{x,y}]
]];
AppendTo[tcc,Text[
Which[
N[fx]!=0 && N[fy]!=0,
StringJoin["fx=",ToString[fx]," fy=",ToString[fy]],
N[fx]!=0 && N[fy]==0,
StringJoin["fx=",ToString[fx]],
N[fx]==0 && N[fy]!=0,
StringJoin[" fy=",ToString[fy]],
True,
""
]
,{ x-.5 fx escfue,y-.5 fy escfue}]];
];
If[N[fy+fx]!=0,AppendTo[graf,vector[x,y,x- fx escfue,y- fy escfue,b/2.5]]];

];
If[fmomentos && N[mm]!=0 ,
AppendTo[graf,momento[x,y,b,If[mm>0,1,-1]]]];
,
{nuu,1,Length[nudo],1}];
PrependTo[graf,AbsoluteThickness[.01]];
Show[Graphics[Join[graf,tcc,defor]//Flatten],AspectRatio->Automatic,
PlotRange->All,op2]
Informe[{nudo_List,barra_List,apoyo_List},op1___List]:=Module[
{Momento, c,Corte, Normal, Rotacion, Elastica, alpa, ba,
cfx, cfy, cix, ciy, corte1, c1fx, c1fy, c1ix, c1iy, dato, Error,
fdmo, ff, flag, i, informe, informe1, l, la, lca, ldato, ll1, ll2,
long, m, momen1, nf, ni, normal1, x, xd1, xl, yd1,fff},
If[VectorQ[op1,IntegerQ],flag=True,flag=False];
informe1={};
Do[(*---------------------------ba-----------------------*)
If[(flag && MemberQ[op1,ba]) || flag==False ,
informe={};
corte1={};
momen1={};
normal1={};
ni=barra[[ba,1]];
nf=barra[[ba,2]];
cix=nudo[[ni,1]];
ciy=nudo[[ni,2]];
cfx=nudo[[nf,1]];
cfy=nudo[[nf,2]];
l=Sqrt[(cfx-cix)^2+(cfy-ciy)^2]//N;
alpa = ang[(cfx-cix),(cfy-ciy)]//N;
lca=barra[[ba,6]];
long=Length[lca];
Do[ (*---------------------i----long------------------------------------*)
dato=lca[[i]];
ldato=Length[dato];
Which[

AppendTo[corte1,c2[xl,0,l,-dato Cos[alpa],-dato Cos[alpa]]];
AppendTo[momen1,m2[xl,0,l,-dato Cos[alpa],-dato Cos[alpa]]];
AppendTo[normal1,nor2y[x,0,l,-Cos[alpa] dato,-Cos[alpa] dato,alpa]];
];
,
Which [
AppendTo[corte1,c2[xl,ll1,ll2,dato[[3]] Cos[alpa]^2,dato[[4]] Cos[alpa]^2]];

AppendTo[momen1,m2[xl,ll1,ll2,dato[[3]] Cos[alpa]^2,dato[[4]] Cos[alpa]^2]];
AppendTo[normal1,nor2y[xl,ll1,ll2,dato[[3]] Cos[alpa],dato[[4]] Cos[alpa],alpa]]
;
,
AppendTo[corte1,c2[xl,ll1,ll2,dato[[3]] Sin[alpa]^2,dato[[4]] Sin[alpa]^2]];

AppendTo[momen1,m2[xl,ll1,ll2,-dato[[3]] Sin[alpa]^2,-dato[[4]] Sin[alpa]^2]];
AppendTo[normal1,nor2x[xl,ll1,ll2,dato[[3]] Sin[alpa],dato[[4]] Sin[alpa],alpa]]
;
,
--*)
AppendTo[corte1,c2[xl,ll1,ll2,dato[[3]],dato[[4]]]];
AppendTo[momen1,m2[xl,ll1,ll2,dato[[3]] ,dato[[4]]]];
------------------------------------------------------";
];
,
AppendTo[corte1,c1[xl,ll1,dato[[2]]]];
AppendTo[momen1,m1[xl,ll1,dato[[2]]]];
AppendTo[corte1,-c1[xl,ll1,Sin[alpa] dato[[2]]]];
AppendTo[momen1,-m1[xl,ll1,Sin[alpa] dato[[2]]]];
AppendTo[normal1,nor1x[xl,ll1,dato[[2]],alpa]];
AppendTo[corte1,c1[xl,ll1,Cos[alpa] dato[[3]]]];
AppendTo[momen1,m1[xl,ll1,Cos[alpa] dato[[3]]]];
AppendTo[normal1,nor1y[xl,ll1,dato[[3]],alpa]];
];
,
,True,
---------------------------------------------------";
];
,{i,1,long,1}]; (*-------------------------------------------*)
AppendTo[
informe,
Flatten[Append[Prepend[Table[x,{x,0,l,l/10}]//N,ToString[ba]<>")Long."],{"Min.",
"Max."}]]];
AppendTo[normal1,GlobalÈsfuerzos[[ba,1]]];
Normal[x_]=Apply[Plus,normal1]/.xl->x;
m=Table[Normal[x],{x,0,l,l/10}]//N;
AppendTo[informe,
Flatten[Append[Prepend[m,"E.Normal"],{Min[m],Max[m]}]]];
Corte[x_]=Apply[Plus,corte1]/.xl->x;
m=Table[Corte[x],{x,0,l,l/10}]//N;
AppendTo[informe,
Flatten[Append[Prepend[m,"E.Corte"],{Min[m],Max[m]}]]];
AppendTo[momen1,mo[xl,-GlobalÈsfuerzos[[ba,3]],GlobalÈsfuerzos[[ba,2]]]];
Momento[x_]=-Apply[Plus,momen1]/.xl->x;
m=Table[Momento[x],{x,0,l,l/10}]//N;
AppendTo[informe,
Flatten[Append[Prepend[m,"Momento"],{Min[m],Max[m]}]]];
Clear[fff,ff,x];
fff[x_]=fff[x]/.NDSolve[{fff''[x]==-Momento[x]/
c=-((fff[l] - Cos[alpa]*Global`Deformaciones[[nf,2]] +Cos[alpa]*Global`Deformaci
ones[[ni,2]] +
Global`Deformaciones[[nf,1]]*Sin[alpa] - Global`Deformaciones[[ni,1]]*Sin[
alpa])/l);
Rotacion[x_]=ff[x]/.NDSolve[{ff'[x]==-Momento[x]/(barra[[ba,3]]*barra[[ba,5]]),
ff[0]==c},ff[x],{x,0,l+.001}][[1]];
m=Table[Rotacion[x],{x,0,l,l/10}]//N;
AppendTo[informe,
Flatten[Append[Prepend[m,"Rotacion"],{Min[m],Max[m]}]]];
xd1=Global`Deformaciones[[ni,1]];
yd1=Global`Deformaciones[[ni,2]];
la=yd1*Cos[alpa] - xd1*Sin[alpa]//N;
Elastica[x_]=ff[x]/.NDSolve[{ff''[x]==-Momento[x]/
(barra[[ba,3]] barra[[ba,5]]),ff[0]==la,ff'[0]==c},ff[x],{x,0,l+.1}][[1]];
m=Table[Elastica[x],{x,0,l,l/10}]//N;
AppendTo[informe,
Flatten[Append[Prepend[m,"Flecha"],{Min[m],Max[m]}]]];
AppendTo[informe1,{informe//Chop}];
];
TableForm[{informe1," Reacciones" ,{Global`Reacciones//N}},TableSpacing->{1,1,1,
1,1,1}]
]
Salvar[{nudo_List,barra_List,apoyo_List},op1___List]:=Module[
{pa, ba,c, cfx, cfy, cix, ciy, corte1, c1fx, c1fy, c1ix, c1iy, dato,
Error, fdmo, ff, flag, i, informe, l, la, lca, ldato, ll1, ll2,
long, momen1, nf, ni, normal1, x, xd1, xl, yd1,fff},
Unprotect[Global`Momento,Global`Corte,GlobalÈNormal,Global`Rotacion,GlobalÈlas
tica,Global`L];
Clear[Global`Momento,Global`Corte,GlobalÈNormal,Global`Rotacion,GlobalÈlastica
];
If[VectorQ[op1,IntegerQ],flag=True,flag=False];
informe={};
Do[(*---------------------------ba-----------------------*)
If[(flag && MemberQ[op1,ba]) || flag==False ,
corte1={};
momen1={};
normal1={};
ni=barra[[ba,1]];
nf=barra[[ba,2]];
cix=nudo[[ni,1]];
ciy=nudo[[ni,2]];
cfx=nudo[[nf,1]];
cfy=nudo[[nf,2]];
alpa = ang[(cfx-cix),(cfy-ciy)];
lca=barra[[ba,6]];
long=Length[lca];
Do[ (*---------------------i----long------------------------------------*)
dato=lca[[i]];
ldato=Length[dato];
Which[

AppendTo[corte1,c2[xl,0,l,-dato Cos[alpa],-dato Cos[alpa]]];
AppendTo[momen1,m2[xl,0,l,-dato Cos[alpa],-dato Cos[alpa]]];
AppendTo[normal1,nor2y[x,0,l,-Cos[alpa] dato,-Cos[alpa] dato,alpa]];
];
,
Which [
AppendTo[corte1,c2[xl,ll1,ll2,dato[[3]] Cos[alpa]^2,dato[[4]] Cos[alpa]^2]];

AppendTo[momen1,m2[xl,ll1,ll2,dato[[3]] Cos[alpa]^2,dato[[4]] Cos[alpa]^2]];
AppendTo[normal1,nor2y[xl,ll1,ll2,dato[[3]] Cos[alpa],dato[[4]] Cos[alpa],alpa]]
;
,
AppendTo[corte1,c2[xl,ll1,ll2,dato[[3]] Sin[alpa]^2,dato[[4]] Sin[alpa]^2]];

AppendTo[momen1,m2[xl,ll1,ll2,-dato[[3]] Sin[alpa]^2,-dato[[4]] Sin[alpa]^2]];
AppendTo[normal1,nor2x[xl,ll1,ll2,dato[[3]] Sin[alpa],dato[[4]] Sin[alpa],alpa]]
;
,
--*)
AppendTo[corte1,c2[xl,ll1,ll2,dato[[3]],dato[[4]]]];
AppendTo[momen1,m2[xl,ll1,ll2,dato[[3]] ,dato[[4]]]];
------------------------------------------------------";
];
,
AppendTo[corte1,c1[xl,ll1,dato[[2]]]];
AppendTo[momen1,m1[xl,ll1,dato[[2]]]];
AppendTo[corte1,-c1[xl,ll1,Sin[alpa] dato[[2]]]];
AppendTo[momen1,-m1[xl,ll1,Sin[alpa] dato[[2]]]];
AppendTo[normal1,nor1x[xl,ll1,dato[[2]],alpa]];
AppendTo[corte1,c1[xl,ll1,Cos[alpa] dato[[3]]]];
AppendTo[momen1,m1[xl,ll1,Cos[alpa] dato[[3]]]];
AppendTo[normal1,nor1y[xl,ll1,dato[[3]],alpa]];
];
,
,True,
---------------------------------------------------";
];
,{i,1,long,1}]; (*-------------------------------------------*)
AppendTo[momen1,mo[xl,-GlobalÈsfuerzos[[ba,3]],GlobalÈsfuerzos[[ba,2]]]];
Global`Momento[ba,x_]=-Apply[Plus,momen1]/.xl->x;
Global`Corte[ba,x_]=Apply[Plus,corte1]/.xl->x;
AppendTo[normal1,GlobalÈsfuerzos[[ba,1]]];
GlobalÈNormal[ba,x_]=Apply[Plus,normal1]/.xl->x;
Clear[ff,fff,x,xl];
fff[x_]=fff[x]/.NDSolve[{fff''[x]==-Global`Momento[ba,x]/
c=-((fff[l] - Cos[alpa]*Global`Deformaciones[[nf,2]] + Cos[alpa]*Global`Deformac
iones[[ni,2]] +
Global`Deformaciones[[nf,1]]*Sin[alpa] - Global`Deformaciones[[ni,1]]*Sin
[alpa])/l);
Global`Rotacion[ba,x_]=ff[x]/.NDSolve[{ff'[x]==-Global`Momento[ba,x]/(barra[[ba,
3]]*barra[[ba,5]]),
ff[0]==c},ff[x],{x,0,l+.001}][[1]];
Global`L[ba]=l//N;
xd1=Global`Deformaciones[[ni,1]];
yd1=Global`Deformaciones[[ni,2]];
la=yd1*Cos[alpa] - xd1*Sin[alpa]//N;
Clear[ff,x,xl];
GlobalÈlastica[ba,x_]=ff[x]/.NDSolve[{ff''[x]==-Global`Momento[ba,x]/
(barra[[ba,3]] barra[[ba,5]]),ff[0]==la,ff'[0]==c},ff[x],{x,0,l+.1}][[1]];
Print["Proceso para la barra nº: ",ba," realizado."];
];
Protect[Global`Momento,Global`Corte,GlobalÈNormal,Global`Rotacion,GlobalÈlasti
ca,Global`L];
]
End[]
EndPackage[]
SetAttributes[{
GraficarEstructura,
ResolverC,
Resolver,
Salvar,
Informe,
Global`Longitud,
Global`Y,
Global`X,
Global`P,
Global`Be,
Global`Ba,
Global`Ri,
Global`Rf,
GlobalÈmp,
Global`Rot
},{Protected,ReadProtected,Locked}];
Print["Contexto del paquete : Metodo`Rigidez` "];

Metodo de La Rigidez 1.0

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Metodo de La Rigidez 1.0

Încărcat de

Drepturi de autor:

Formate disponibile

(* :Nombre: Programm`CalculodeEstructuras` *)

(* :Titulo: Calculo de estructuras por el metodo de la rigides*)

Print["EL AUTOR NO SE RESPOSABILIZA NI DE LOS \n

Resolver::usage=" La funcion Resolver[nudos_List ,barras_List,

lsim[x_,y_,alpa_,b_]=Line[{{x - 1.25831*b*Sin[1.16216 - alpa],

alpa=ang[(-x + x1),(-y + y1)];

(*caso [caso,1x 2y ,extremo, *)

Caso[Global`Be,2,2,a_,b_,q1_,q2_,l_,t_]={-((a - b)*(2*a*q1 + b*q1 + a*q2 + 2*b*q

Caso1[Global`Be,2,1,a_,p_,l_,t_]={-((-a + l)*p*(2*a^2 - a*l - 2*l^2 - 2*a^2*Cos[

{t.{{e a/l,0,0},{0,12 e i/l^3,6 e i/l^2},{0,6 e i/l^2,4 e i/l}}.tt,

{t.{{e a/l,0,0},{0,3 e i/l^3,3 e i/l^2},{0,3 e i/l^2,3 e i/l}}.tt,

Join[Apply[Join, Transpose[{ti.kg[[ba,1]],ti.kg[[ba,2]]}], {1}],

tem1=Join[Apply[Join, Transpose[{ti.kg[[ba,1]],ti.kg[[ba,2]]}], {1}],

(* Color del texto*)

If[(NumberQ[dato] && N[dato]!=0) || (Not[NumberQ[dato]]),

If[fdco,AppendTo[corte1,c2[xl,ll1,ll2,dato[[3]] Cos[alpa]^2,dato[[4]] Cos[alpa]^

If[fdgi ,(*--------- tita ------------------*)

If[fela ,(* --------- flecha -----------*)

If[N[fy+fx]!=0,AppendTo[graf,vector[x,y,x- fx escfue,y- fy escfue,b/2.5]]];

If[(NumberQ[dato] && N[dato]!=0) || (Not[NumberQ[dato]]),

AppendTo[corte1,c2[xl,ll1,ll2,dato[[3]] Cos[alpa]^2,dato[[4]] Cos[alpa]^2]];

AppendTo[corte1,c2[xl,ll1,ll2,dato[[3]] Sin[alpa]^2,dato[[4]] Sin[alpa]^2]];

If[(NumberQ[dato] && N[dato]!=0) || (Not[NumberQ[dato]]),

AppendTo[corte1,c2[xl,ll1,ll2,dato[[3]] Cos[alpa]^2,dato[[4]] Cos[alpa]^2]];

AppendTo[corte1,c2[xl,ll1,ll2,dato[[3]] Sin[alpa]^2,dato[[4]] Sin[alpa]^2]];

Print["Contexto del paquete : Metodo`Rigidez` "];

S-ar putea să vă placă și

lsim[x_,y_,alpa_,b_]=Line[{{x - 1.25831bSin[1.16216 - alpa],

(caso [caso,1x 2y ,extremo, )

Caso[Global`Be,2,2,a_,b_,q1_,q2_,l_,t_]={-((a - b)(2a*q1 + bq1 + aq2 + 2bq

Caso1[Global`Be,2,1,a_,p_,l_,t_]={-((-a + l)p(2a^2 - al - 2l^2 - 2a^2*Cos[

If[fdgi ,(--------- tita ------------------)