Está en la página 1de 53

52

CAPITULO III : PROBLEMAS UNIDIMENSIONALES


3.1 INTRODUCCIN
En el captulo I se han desarrollado las bases tericas para desarrollar el mtodo de los
elementos finitos. Ahora analizaremos los problemas unidimensionales, donde la
deformacin unitaria, el esfuerzo, el desplazamiento y las cargas slo dependen de la
coordenada x. Es decir las relaciones matriciales vistos en el captulo uno se convierten
ahora en slo relaciones escalares, de tal forma que:
u = u(x)

=(x)

=(x)

T = T(x)

f = f(x)

3.1

Las relaciones esfuerzo deformacin unitaria y deformacin unitaria desplazamiento


son:
du
3.2
= E

dx

Para problemas unidimensionales, la diferencial de volumen dV puede escribirse como
dV = Adx

3.3

La carga es de tres tipos: la fuerza de cuerpo f, la fuerza de traccin T y la carga puntual


Pi . Una fuerza de cuerpo es una fuerza que acta sobre todo el volumen elemental del
cuerpo y tiene unidades de fuerza entre la unidad de volumen. El peso propio debido a la
gravedad es un ejemplo de fuerza de cuerpo. Una fuerza de traccin es una carga
distribuida que acta sobre la superficie del cuerpo. La fuerza de traccin se define como
fuerza entre rea unitaria. Para problemas unidimensionales se considera la fuerza de
traccin como fuerza sobre longitud unitaria; esto se logra haciendo que la fuerza de
traccin sea el producto de la fuerza por rea unitaria por el permetro de la seccin

53
transversal. La resistencia por friccin, la resistencia viscosa y el cortante superficial son
ejemplos de fuerzas de traccin en problemas unidimensionales. Pi es una fuerza que acta
en un punto i y u i es el desplazamiento x de ese punto.
3.2 CONSTRUCCIN DEL MODELO DEL ELEMENTO FINITO
Divisin del elemento
Considere la barra de la figura 3.1. El primer paso es modelar la barra como una flecha de
seccin variable, consistente en un nmero discreto de elementos, cada uno con seccin
transversal uniforme. Especficamente, modelamos la barra usando cuatro elementos
finitos. Un modo simple de hacer esto es dividir la barra en cuatro regiones como se
muestra en la figura 3.2a. Dentro de cada regin se evala el rea transversal promedio y
luego se usa para definir un elemento con seccin transversal uniforme. El modelo
resultante con cuatro elementos y cinco nodos se muestra en la figura 3.2b . En el modelo
del elemento finito se conecta cada elemento a dos nodos. En adicin a la seccin
transversal, las fuerzas de traccin y de cuerpo tambin se tratan normalmente como
constantes dentro de cada elemento. Al aumentar el nmero de elementos se obtienen
mejores aproximaciones. Es conveniente definir un nodo en cada lugar en que se indique
una carga.

Esquema de numeracin
Se ha mostrado cmo una barra de apariencia complicada puede modelarse usando un
nmero discreto de elementos, cada elemento con una geometra simple. La similaridad de
los diversos elementos es una razn por la que el mtodo de los elementos finitos es muy
adecuado para ser tratado en una computadora. Para su fcil implantacin debe adoptarse
un esquema ordenado de numeracin que a continuacin se detalla.

54
En un problema unidimensional los desplazamientos son slo a lo largo del eje x, por lo que
cada nodo tiene un solo grado de libertad (gdl); por tanto cada elemento finito tiene solo
dos grados de libertad ( dos nodos) . El modelo del elemento finito de cinco nodos en la
figura 3.2b tiene cinco grados de libertad. Los desplazamientos a lo largo de cada grado de
libertad se denotan por Q1 , Q2 ,, Q5 . De hecho, el vector columna Q = [ Q1 , Q2 ,, Q5 ] T
se llama vector de desplazamiento global. El vector de carga global se denota por F =
F1 , F2 ,, F5 T . Los vectores Q y F se muestran en la figura 3.3. La convencin de signos
usada es que un desplazamiento o carga tiene un valor positivo si acta en la direccin +x.
En esta etapa no se ponen las condiciones de frontera.

Cada elemento tiene dos nodos; por tanto la informacin sobre la conectividad de los
elementos puede representarse convenientemente como se muestra en la figura 3.4. En la
figura se da la tabla de conectividad. En esta tabla los encabezados 1 y 2 se refieren a los

55
nmeros locales de los nodos de un elemento, y los nmeros nodales correspondientes
sobre el cuerpo se llaman nmeros globales. La conectividad establece as la
correspondencia local global.

3.3 COORDENADAS Y FUNCIONES DE FORMA


Considere un elemento finito tpico e en la figura 3.5a. En el esquema de numeracin local,
el nmero del primer nodo ser 1 y el del segundo nodo ser 2. Se usa la notacin x 1 =
coordenada x del nodo 1, x 2 = coordenada x del nodo 2. Definimos un sistema coordenado
2
natural o intrnseco , denotado por =
x x1 1
3.4
x2 x1

De aqu vemos que = - 1 en el nodo 1 y = 1 en el nodo 2. La longitud del elemento se


cubre cuando cambia de -1 a 1. Se usa este sistema de coordenadas al definir funciones de
forma, que se usan al interpolar el campo de desplazamiento.
Ahora, el campo de desplazamiento desconocido dentro de un elemento ser interpolado
por una distribucin lineal. Esta aproximacin se vuelve cada vez ms exacta conforme se
consideran ms elementos en el modelo. Para implementar esta interpolacin lineal, se
introducirn funciones de forma lineales como

1
2
1
N 2
2

N1

3.5
3.6

Las funciones de forma N1 y N 2 se muestran en las figuras 3.7a y b, respectivamente.


Una vez definidas las funciones de forma, el campo de desplazamiento lineal dentro del
elemento puede escribirse en trminos de los desplazamientos nodales q1 y q2 como

u N1q1 N 2 q2

3.7a

u = Nq

3.7b

o, en notacin matricial como

56

donde

N = N1 , N 2 y q = q1 , q 2

3.8

En las ecuaciones anteriores a q se le llama vector de desplazamiento del elemento.


Puede verse que la transformacin de x a en la ecuacin 3.4 puede escribirse en trminos
de N1 y N 2 como
3.9
x = N1 x1 N 2 x2

Comparando las ecuaciones 3.7a y 3.9, vemos que el desplazamiento u y la coordenada x


son interpoladas dentro del elemento usando las mismas funciones de forma N1 y N 2 . A
esto se le llama formulacin isoparamtrica
En general, las funciones de forma deben satisfacer lo siguiente:

57
1. Sus primeras derivadas deben ser finitas dentro de un elemento.
2. Los desplazamientos deben ser continuos a travs de la frontera del elemento.
Los movimientos de cuerpo rgido no deben generar ningn esfuerzo en el elemento.
La relacin deformacin unitaria desplazamiento en la ecuacin 3.2 es
du

dx
Al usar la regla de la cadena de la derivacin, resulta

du d
d dx

3.10

De la relacin entre x y en la ecuacin 3.4, tenemos

d
2

dx x2 x1
Adems, como

u N1q1 N 2 q2 =

3.11

1
1
q1
q2
2
2

tenemos

du q1 q 2

d
2

3.12

Entonces, la ecuacin 3.10 nos da

1
q1 q2
x2 x1

3.13

La ecuacin anterior se puede escribir as


= Bq

3.14

donde la matriz B de (1*2), llamada matriz de deformacin unitaria desplazamiento del


elemento, est dada por
1
3.15
1 1
B=
x2 x1
El esfuerzo, de la ley de Hooke, es

E Bq

3.16

Las expresiones u = Nq, = Bq, = EBq relacionan desplazamiento, deformacin unitaria


y esfuerzo, respectivamente , en trminos de los valores nodales. Ahora con estas

58
deducciones lo reemplazaremos en la expresin de la energa potencial de la barra para
poder hallar la matriz de rigidez y la de carga.

3.4 EL ENFOQUE DE LA ENERGA POTENCIAL


La expresin general para la energa potencial dada en el captulo 1 es

1
3.17
T Adx u T fAdx u T Tdx ui Pi

L
L
L
2
i
Como el continuo ha sido discretizado en elementos finitos, la expresin para es entonces

1 T
Adx
2 e
e

fAdx
e

u
e

Tdx Qi Pi

3.18a

El ltimo trmino supone que las cargas puntuales Pi estn aplicadas en los nodos. Esta
suposicin hace la presente deduccin ms simple con respecto a la notacin y tambin es
una prctica comn en el modelado. La ecuacin anterior, 3.18a, puede escribirse como

U e
e

fAdx
e

Tdx Qi Pi

3.18b

1
T Adx

2
es la energa de deformacin unitaria del elemento.
donde

Ue

Matriz de rigidez del elemento


Considerando el trmino de energa

Ue

1
T Adx

3.19

sustituyendo E Bq y = Bq en la expresin anterior, resulta


3.20a
o
3.20b
En el modelo del elemento finito, el rea de la seccin transversal del elemento e, denotada
por Ae es constante. Adems, B es una matriz constante. La transformacin de x a en la
ecuacin 3.4 nos da
x x
3.21a
dx 2 1 d
2
3.21b

59

dx

e
d
2

donde 1 1 y e es la longitud del elemento, e x2 x1 .


La energa de deformacin unitaria U e del elemento se escribe ahora como
3.22
1

donde Ee es el mdulo de Young del elemento e. Notando que

d 2 , y sustituyendo el

valor de B dado por la ecuacin 3.15, obtenemos


3.23
que conduce a
3.24
La ecuacin anterior es de la forma
3.25

donde la matriz

de rigidez del elemento est dado por


3.26

Ejemplo 3.1. Considere la barra en la figura P3.1. El rea transversal es de 1.2in y el


mdulo de Young E = 30Mpsi. Si q1 0.02in y q2 0.025in, determine(a mano):
a. El desplazamiento en el punto P.
b. La deformacin unitaria y el esfuerzo .
c. La matriz de rigidez del elemento.
d. La energa de deformacin unitaria en el elemento.

60
SOLUCIN:
a.
De la figura hallamos .
2
=
x x1 1 = 2 20 15 1 0.25
23 15
x2 x1
Hallamos las funciones de forma:
1 1 0.25

N1
0.375
2
2
1 1 0.25

N 2
0.625
2
2
El desplazamiento en P se calcula con:

u P N1q1 N 2 q2 0.375 * 0.02 0.625 * 0.025 0.023125in. Respuesta.


b.

La deformacin unitaria se calcula con la siguiente expresin:

1
q1 q2 1 (0.02 0.025) 0.000625
x2 x1
23 15

El esfuerzo se calcula con : =E


=30e6*0.000625 = 18750psi.
c.

La matriz de rigidez del elemento es:

d.

1 1
1.2 * 30e6 1 1

4
.
5
e
6
1 1 Respuesta.
23 15 1 1

La energa de deformacin unitaria se calcula con:

1 1 0.02
1
0.02 0.025 4.5e6

56.25in*lb. Respuesta.
2
1 1 0.025

Trminos de fuerza
Consideremos primero el trmino de fuerza de cuerpo del elemento que aparece en la
energa potencial total. Sustituyendo u N1q1 N 2 q2 , tenemos

u
e

fAdx Ae f N1q1 N 2 q2 dx
e

3.27

61
La ecuacin anterior puede escribirse como

Ae f N1 dx

eu fAdx q Ae f eN 2 dx
e

3.28

Las integrales de las funciones de forma anteriores pueden evaluarse fcilmente haciendo la
sustitucin dx ( e / 2)d . Entonces,
e 1 1
e
e N1dx 2 1 2 d 2
3.29
e 1 1
e
e N 2 dx 2 1 2 d 2

El trmino de fuerza de cuerpo en la ecuacin 3.28 se reduce a


3.30a
que es de la forma
3.30b
El lado derecho de la ecuacin anterior es de la forma: Desplazamiento x Fuerza .
As, el vector de fuerza de cuerpo del elemento, se identifica como

3.31
Consideremos a hora el trmino de la fuerza de traccin del elemento que aparece en la
energa potencial total. Tenemos,

u Tdx N q
T

1 1

N 2 q2 Tdx

Como la fuerza de traccin T es constante dentro del elemento, tenemos

3.32

62

3.33
Ya hemos obtenido las integrales de las funciones de forma. Por tanto la ecuacin 3.33 es
de la forma

donde el vector de fuerza de traccin

del elemento est dado por


3.35

En esta etapa, se han obtenido ya las matrices del elemento , y . Despus de tomar en
cuenta la conectividad de los elementos, la energa potencial total se puede escribirse as,
3.36
donde K es la matriz de rigidez global, F es el vector de carga global y Q es el vector de
desplazamiento global.

3.5 ENSAMBLE DE LA MATRIZ DE RIGIDEZ GLOBAL Y DEL VECTOR


CARGA
Notamos antes que la energa potencial total escrita en la forma

puede escribirse en la forma

tomando en cuenta la conectividad del elemento. Este paso implica ensamblar K y F a


partir de las matrices de rigidez y fuerza del elemento.
En consecuencia , al sumar las energas de deformacin unitaria del elemento, los
elementos de
se colocan en los lugares apropiados de la matriz global K, con base en la
conectividad del elemento; los elementos que se traslapan simplemente se suman. Podemos
denotar este ensamble en forma simblica como
3.37

63
De manera muy parecida, el vector de carga global F se ensambla a partir de los vectores de
fuerza y de los vectores de carga puntual de los elementos, como
3.38

3.6 PROPIEDADES DE K
Ahora deduciremos algunas propiedades importantes, de la matriz de rigidez tratado
anteriormente.
1. La dimensin de la matriz de rigidez global K es (N x N) , donde N es el
nmero de nodos. Esto se obtiene del hecho de que cada nodo slo tiene un
grado de libertad.
2. K es simtrica.
3. K es una matriz en banda. Es decir todos los elementos fuera de la banda son
cero.

3.7 ECUACIONES DEL ELEMENTO FINITO; MANEJO DE LAS CONDICIONES


DE FRONTERA
Tipos de condiciones de frontera
Al usar un esquema de discretizacin para modelar el continuo, obtuvimos una expresin
para la energa potencial total en el cuerpo dada por

donde K es la matriz de rigidez estructural, F es el vector de carga global y Q es el vector


de desplazamiento global. Como se vio antes, K y F se ensamblan a partir de las matrices
de rigidez y fuerza de los elementos, respectivamente. Para poder hallar los
desplazamientos nodales, esfuerzos en los elementos y fuerzas en los soportes, tenemos que
usar las ecuaciones de equilibrio. Esto lo podemos deducir del teorema de la energa
potencial mnima : De todos los desplazamientos posibles que satisfacen las condiciones de
frontera de un sistema estructural, aquellos que corresponden a configuraciones de
equilibrio hacen que la energa potencial total adquiera un valor mnimo. Pon tanto, las
ecuaciones de equilibrio pueden obtenerse minimizando con respecto a Q, teniendo en
cuenta que previamente se halla sometido a las condiciones de frontera de la estructura.
Las condiciones de frontera son usualmente del tipo

Q p1 a1 , Q p 2 a2 ,, Q pr ar

3.39

Es decir, los desplazamientos a lo largo de los grados de libertad p1 , p2 ,, pr se


especifican como iguales a a1 , a2 ,, ar , respectivamente. En otras palabras, hay un

64
nmero r de soportes en la estructura; con cada nodo de soporte est asociado un
desplazamiento especfico.
Hay restricciones de multipunto del tipo

1Q p1 2 Q p 2 0

3.40

donde 1 , 2 y 0 son constantes conocidas. Estos tipos de frontera se usan para modelar
soportes inclinados con rodillo, conexiones rgidas o ajustes por contraccin.
Debe enfatizarse que una especificacin impropia de las condiciones de frontera puede
conducir a resultados errneos. Las condiciones de frontera eliminan la posibilidad que la
estructura se mueva como cuerpo rgido. Las condiciones de frontera deben modelar el
sistema fsico con exactitud. En este apartado se vern dos enfoques para el manejo de las
condiciones de frontera: el enfoque de la eliminacin y el enfoque de la penalizacin.
Enfoque de eliminacin
Para ilustrar la idea bsica, consideremos la sola condicin de frontera Q1 a1 . Las
ecuaciones de equilibrio se obtienen minimizando con respecto a Q, sometida a la
condicin de frontera Q1 a1 . Para una estructura con N grados de libertad, tenemos
Q = Q1 , Q2 ,, QN

F = F1 , F2 ,, FN

La matriz de rigidez global es de la forma

K11
K
21
K=

K N1

K12
K 22
KN2

K1N
K 2 N

K NN

3.41

Note que K es una matriz simtrica. La energa potencial


puede
escribirse de forma explcita como
Q1 K11Q1 Q1 K12Q2 Q1 K1N QN

Q
K
Q

Q
K
Q

Q
K
Q

2
21
1
2
22
2
2
2
N
N
12
Q1 F1 Q2 F2 QN FN 3.42

Q K Q Q K Q Q K Q
N
N1 1
N
N2 2
N
NN N

Si sustituimos ahora la condicin de frontera Q1 a1 en la expresin para , obtenemos

65

a1 K11a1 a1 K12Q2 a1 K1N QN

Q2 K 21a1 Q2 K 22Q2 Q2 K 2 N QN
1
2
a1 F1 Q2 F2 QN FN 3.43

Q K a Q K Q Q K Q
N
N1 1
N
N2 2
N
NN N

Note que el desplazamiento Q1 ha sido eliminado de la expresin anterior para la energa


potencial. En consecuencia, el requisito de que adquiera un valor mnimo, implica que

0
Qi

i 2,3,, N

3.44

De las ecuaciones 3.43 y 3.44 obtenemos entonces,

K 22Q2 K 23Q3 K 2 N QN F2 K 21a1


K 32Q2 K 33Q3 K 3 N QN F3 K 31a1

K N 2 Q2 K N 3Q3 K NN QN FN K N1a1

3.45

Las ecuaciones del elemento finito anteriores se puede escribirse matricialmente as,

K 22
K
32

K N 2

K 23
K 33
K N3

K 2 N Q2 F2 K 21a1
K 3 N Q3 F3 K 31a1

K NN QN FN K N1a1

3.46

Ahora observamos que la matriz de rigidez de (N-1 x N-1) anterior se obtiene simplemente
borrando o eliminando la primera fila y columna (en vista de que Q1 a1 ) de la matriz de
rigidez original de (N x N). La ecuacin 3.63 puede escribirse como
KQ = F

3.47

Donde K es una matriz de rigidez reducida que se obtiene eliminando la fila y columna
correspondiente al grado de libertad o soporte especificado. Las ecuaciones 3.47 pueden
resolverse para el vector de desplazamiento Q usando la eliminacin de Gauss. Note que la
matriz reducida K es no singular, siempre que las condiciones de frontera se hallan
especificado apropiadamente; por otra parte, la matriz K original es una matriz singular.
Una vez determinada Q, el esfuerzo en los elementos puede evaluarse usando la ecuacin
3.16 : E Bq, donde q para cada elemento se extrae de Q usando informacin sobre la
conectividad del elemento.

66
Una vez obtenidos los esfuerzos en los elementos es necesario calcular la fuerza de
reaccin R1 en el soporte. Esta fuerza de reaccin puede obtenerse de la ecuacin del
elemento finito (o ecuacin de equilibrio) para el nodo 1:
3.48
K11Q1 K12Q2 K1N QN F1 R1
3.49
R1 K11Q1 K12Q2 K1N QN F1
Note que los elementos K11 , K12 ,, K1N usados antes, que forman la primera fila de K,
deben ser almacenados en forma separada. Esto se debe a que K de la ecuacin 3.47 se
obtiene borrando esta fila y columna de la K original.
Ejemplo 3.2. Considere la barra en la figura P3.3 cargada como se muestra. Determine
los desplazamientos nodales, los esfuerzos en los elementos y las reacciones en los
soportes. Resuelva este problema a mano usando el mtodo de eliminacin para manejar
las condiciones de frontera. Verifique sus resultados usando el programa Unidimensional.

SOLUCIN: Se consideran tres elementos con 4 grados de libertad.

1) Calculamos las matrices de rigidez de cada uno de los elementos:

250 * 200000 1 1 333333 . 3 333333 . 3 1


k


1 1
150

333333 . 3 333333 . 3 2
1

250 * 200000 1 1 333333 . 3 333333 . 3 2


k


1 1
150

333333 . 3 333333 . 3 3
2

67

400 * 200000 1 1 266666 . 6 266666 . 6 3


k


1 1
300

266666 . 6 266666 . 6 4
3

2) Se ensambla las tres matrices anteriores para hallar la matriz de rigidez global de la
estructura, considerando la conectividad de los elementos que tambin se ha indicado.
1

1
333333
.
3

333333
.
3
0
0

333333 . 3 666666 . 6 333333 . 3


2
0
K

0
333333 . 3
600000
266666 . 6 3

0
0
266666 . 6 266666 . 6 4

3) Calculamos la columna vector de las fuerzas globales de la estructura. En este


problema slo la carga puntual aplicado en el nodo 2 contribuye con la carga global.
Por tanto:
0 1
300000 2

F
0 3

0 4
4) Formamos el sistema KQ = F. En el enfoque de eliminacin se eliminan las filas y
columnas de las condiciones de frontera. Por tanto el sistema queda como

Q2 300000
666666
.
6

333333
.
3

333333 . 3
600000 Q3 0
donde se han eliminado las correspondientes filas y columnas de los grados de libertad
1 y 4 de las tres matrices K, Q y F.
Resolviendo dicho sistema tenemos:
Q2 0.62307692
Q 0.346153846

5) Los esfuerzos en los elementos se calculan con:


1
1 1
B=
x2 x1
El esfuerzo, de la ley de Hooke, es
E Bq

68

200000
1 1

150
0.62307692
1 830.769 N / mm

0.62307692
200000
1 1

150
0.346153846
2 369.231N / mm

0.346153846
200000
1 1

0
150

3 230.769 N / mm

K11Q1 K12Q2 K1N QN F1 R1


R1 K11Q1 K12Q2 K1N QN F1
0

0.62307692
R1 333333 . 3 333333 . 3 0 0
207692 .3N .

0.346153846

0.62307692
R4 0 0 266666 . 6 266666 . 6
92307 .7 N .

0.346153846

6) Las reacciones se calculan de acuerdo a

Esta es la salida del problema anterior con el Programa Unidimensional desarrollado


por el tesista; se usa el enfoque de penalizacin:

69

Enfoque de la penalizacin
Este segundo enfoque para tratar las condiciones de frontera, es fcil de implementar en
una computadora y retiene su simplicidad an cuando se consideran condiciones de frontera
generales.
Condiciones de frontera con desplazamiento especificado. Considere la condicin de
frontera
Q1 a1
donde a1 es un desplazamiento especfico a lo largo del grado de libertad 1 del soporte.
Para modelar el soporte se usa un resorte con gran rigidez C. La magnitud de C se
analizar posteriormente. En este caso se desplaza en un extremo del resorte una cantidad
a1 , como se muestra en la figura 3.10. El desplazamiento Q1 a lo largo del grado de
libertad 1 ser aproximadamente igual a a1 , debido a la relativa resistencia ofrecida por la
estructura. En consecuencia , la extensin neta del resorte es igual a ( Q1 a1 ). La energa
de deformacin unitaria en el resorte es igual a

U s 12 CQ1 a1

3.50

70

Esta energa de deformacin contribuye a la energa potencial total. Como resultado,


3.51
La minimizacin de
puede llevarse a cabo haciendo M / Qi 0, i 1,2,, N . Las
ecuaciones del elemento finito se pueden escribirse as,

( K11 C ) K12 K1N Q1 F1 Ca1


K
K 22 K 2 N Q2 F2
21

K N 2 K NN QN FN
K N1

3.52

Anteriormente vimos que las nicas modificaciones para tratar Q1 a1 son: que debe
agregarse un gran nmero C al primer elemento diagonal de K y que C a1 se agrega a F1 .
La fuerza de reaccin en el nodo 1 es igual a la fuerza ejercida por el resorte sobre la
estructura. Como la extensin neta del resorte es ( Q1 a1 ) y la rigidez del resorte es C, la
fuerza de reaccin est dada por
3.53
R1 CQ1 a1
Seleccin de C. Desarrollemos la primera de estas ecuaciones en la ecuacin 3.52,
tenemos,

K11 C Q1 K12Q2 K1N QN


Al dividir entre C, obtenemos

F1 Ca1

3.54a

71

K
K
F
K11
1Q1 12 Q2 1N QN 1 a1

C
C
C
C

3.54b

De la ecuacin anterior, vemos que si se escoge C suficientemente grande, entonces


Q1 a1 . De manera especfica, vemos que si C es grande en comparacin con los
coeficientes de rigidez K11 , K12 ,, K1N , entonces Q1 a1 . Note que F1 es una carga
aplicada en el soporte (si existe) y que F1 /C es generalmente de pequea magnitud.
Un simple esquema sugiere por s mismo la eleccin de la magnitud de C:
C = mx K ij 10 4

1 i N
1 j N

3.55

La seleccin de 10 4 se ha encontrado satisfactoria en la mayor parte de los clculos.


Restricciones de multipunto
En problemas donde, por ejemplo, deben modelarse soportes inclinados con rodillos o
conexiones rgidas, las condiciones de frontera toman la forma

1Q p1 2 Q p 2 0
donde 1 , 2 y 0 son constantes conocidas. A tales condiciones de frontera se les llama
restricciones de multipunto. El enfoque de penalizacin se aplicar a este tipo de condicin
de frontera.
Considere la expresin de la energa potencial total modificada a ser minimizada
3.56
donde C es un nmero grande. Como C es grande ,

adquiere un valor mnimo slo

es muy pequea, es decir, cuando 1Q p1 2 Q p 2 0 ,

cuando

como se desea. Haciendo M / Qi 0, i 1,2,, N se obtienen las matrices de rigidez


y fuerza modificadas.
Estas modificaciones estn dadas por

K P1P1
K
P 2 P1
y

K P1P 2 K P1P1 C12

K P 2 P 2 K P 2 P1 C1 2

K P1P 2 C1 2

K P 2 P 2 C 22

3.57

72

FP1 FP1 C 0 1
F F C
0 2
P2 P2

3.58

Si consideramos las ecuaciones de equilibrio M / QP1 y M / QP 2 , y las reordenamos


en la forma

p1 j

Q j Fp1 R p1

p2 j

Q j Fp 2 R p 2

obtenemos las fuerzas de reaccin R p1 y R p 2 que son las componentes de reaccin a lo


largo de los grados de libertad p1 y p2 , respectivamente , como

R p1
y

Q p1

C Q
1
2

2Q p 2 0

p1

1
2

2 C 1Q p1 2 Q p 2 0
Q p 2
Despus de simplificar, las ecuaciones 3.84 toman la forma
R p1

3.59a

3.59b

R p1 C1 1Q p1 2 Q p 2 0

3.60a

R p 2 C 2 1Q p1 2 Q p 2 0

3.60b

Vemos que el enfoque de penalizacin nos permite manejar las restricciones de multipunto
y es nuevamente fcil implementarlo en un programa de computadora.
Ejemplo 3.3. Se aplica una carga axial P = 385 kN al bloque compuesto mostrado en la
figura P3.5. Determine el esfuerzo en cada material.

73

SOLUCIN:
En este problema consideramos 2 elementos con dos condiciones de frontera y dos
restricciones de multipunto y 5 grados de libertad , as:
5
2

Condiciones de Frontera:
Q1 0

Q3 0
Restricciones de multipunto:
Q2 Q5 0
Q4 Q5 0
Con la corrida del programa obtenemos los siguientes esfuerzos:
1 85.55898 N / mm
2 128.32991 N / mm

74

Ejemplo 3.4 Considere la barra en la figura P3.6 Determine los desplazamientos nodales,
los esfuerzos en los elementos y las reacciones en los soportes.

SOLUCIN:

1. Se considera 4 elementos, 1 condicin de frontera y 5 grados de libertad.


La condicin de frontera se expresa en que el nodo 1 es fijo, es decir:

Q1 0
Resolviendo el problema con el programa tenemos:

75

Se nota que el desplazamiento en el nodo 5 es de 6.000125mm, por lo que volvemos


ha resolver el problema considerando una condicin de frontera ms.
2. Las condiciones de frontera en este nuevo problema son:
Q1 0

Q5 3.5mm

76

Las reacciones en los soportes son:


R1 672722 .21N

R2 227277 .79 N
Los esfuerzos, desplazamientos, se muestran en la salida del programa.

77
Ejemplo 3.5. La viga rgida en la figura P3.9 estaba a nivel antes de aplicarse la carga.
Encuentre el esfuerzo en cada miembro vertical
SOLUCIN: Se consideran 2 elementos, 2 condiciones de frontera, 2 restricciones de
multipunto y 5 grados de libertad.
3

Condiciones de frontera:
Q1 0

Q3 0
Restricciones de multipunto:
36
15 Q2 Q5 0

Q4 Q5 0
De la salida del programa tenemos:
1 15318 .69 psi
2 9191 .69 psi
36
27

78
3.8 FUNCIONES DE FORMA CUADRTICA
Hasta ahora, el campo de desplazamiento ha sido considerado por funciones de forma lineal
dentro de cada elemento. Sin embargo, en algunos problemas, el uso de una interpolacin
cuadrtica conduce a resultados bastante ms exactos. En esta seccin se presentarn las
funciones de forma cuadrtica y la correspondiente matriz de rigidez del elemento y se
deducirn los vectores de carga.

Consideremos un elemento tpico cuadrtico de tres nodos, como el mostrado en la figura


3.11a. En el esquema local de numeracin, el nodo izquierdo se designar como 1, el nodo
derecho como 2 y el punto medio como 3. El nodo 3 se ha introducido con el fin de pasar
un ajuste cuadrtico y se llama nodo interno. Se usa la notacin xi x coordenada del
nodo i, i = 1, 2, 3. Adems q = q1, q2 , q3 , donde q1, q2 , q3 son los desplazamientos de los
nodos 1, 2 y 3, respectivamente. El sistema coordenado x es mapeado en un sistema
coordenado , que se obtiene con la transformacin
T

2x x3
x2 x1

3.61

79

De la ecuacin 3.86 vemos que = -1, 0 y +1 en los nodos 1, 3 y 2.


Ahora se introducirn, en coordenadas , las funciones de forma cuadrtica N1, N2 y N3

como

N1 12 1

3.62a

N 3 1 1

3.62b
3.62c

N 2 12 1

La funcin de forma N 1 es igual a la unidad en el nodo 1 y cero en los nodos 2 y 3.


Similarmente, N 2 es igual a la unidad en el nodo 2 e igual a cero en los otros dos nodos;
N3 es igual a la unidad en el nodo 3 e igual a cero en los nodos 1 y 2. Las funciones de
forma N1, N2 y N3 estn graficadas en la figura 3.12. Las expresiones para esas funciones
de forma pueden escribirse por inspeccin.

Ahora el campo de desplazamiento dentro del elemento se escribe en trminos de los


desplazamientos nodales como
3.63a
u N1q1 N 2 q2 N3 q3
o
3.63b
u = Nq

donde N = [ N1 , N 2 , N 3 ] es un vector de (1 *3) de funciones de forma y q = q1 , q2 , q3 un


vector columna de (3*1) de desplazamiento del elemento. En el nodo 1 vemos que
N1 1, N 2 N3 0 y por consiguiente , u q1 . De igual manera, u q2 en el nodo 2 y
T

80

u q3 en el nodo 3. Entonces, u en la ecuacin 3.89a es una interpolacin cuadrtica que


pasa por q1 , q2 , q3 .
La deformacin unitaria ahora est dada por
du
=
(relacin deformacin unitaria desplazamiento)
dx
du d
=
(regla de la cadena)
d dx
2 du
3.64
=
(usando la ecuacin 3.61)
x2 x1 d
=

2 dN1 dN 2 dN3
,
,
q
x2 x1 d d d

(usando la ecuacin 3.63)

Usando las ecuaciones 3.62, tenemos


2 1 2 1 2

,
,2 q

x2 x1
2
2

3.65

que es de la forma
3.66

= Bq
donde B est dada por
B

2 1 2 1 2

,
,2

x2 x1
2
2

3.67

Usando la ley de Hooke, podemos escribir el esfuerzo como


= EBq

3.68

Note que las N i son funciones de forma cuadrtica, B en la ecuacin 3.67 es lineal en .
Esto significa que la deformacin unitaria y el esfuerzo pueden variar linealmente dentro
del elemento.
Ahora tenemos expresiones para u, y en las ecuaciones 3.63b, 3.66 y 3.68,
respectivamente. Tambin tenemos que dx = ( e / 2)d de la ecuacin 3.61.
Nuevamente, en el modelo del elemento finito considerado aqu, se supondr que el rea
transversal Ae , la fuerza de cuerpo f y la fuerza de traccin T, son constantes dentro del

81
elemento. Al sustituir u, , y dx de las expresiones anteriores en la expresin para la
energa potencial, obtenemos

1 T
Adx
2 e
e

u
e

fAdx
e

Tdx Qi Pi
i

3.69

Comparando la ecuacin anterior con la forma general

resulta
3.70a
que, al sustituir por B en la ecuacin 3.67, da

3.70b

El vector de fuerza de cuerpo del elemento

est dado por


3.71a

que, al sustituir por N en las ecuaciones 362, da

3.71b

similarmente, el vector de fuerza de traccin del elemento

est dado por


3.72a

que conduce a

82

3.72b

La energa potencial total es nuevamente de la forma


, donde la matriz
K de rigidez estructural y el vector F de carga nodal son ensamblados a partir de las
matrices de rigidez y de los vectores de carga de los elementos, respectivamente.

3.9 EFECTOS POR CAMBIO DE TEMPERATURA


Se considerar aqu los esfuerzos producidos por cambio de temperatura en un material
elstico isotrpico lineal. Si se conoce la distribucin del cambio de temperatura T(x),
entonces la deformacin unitaria debido a este cambio de temperatura puede tratarse como
una deformacin unitaria lineal 0 , dada como
0 = T

3.73

donde es el coeficiente de dilatacin trmica. La ley de esfuerzo deformacin unitaria


en presencia de 0 se muestra en la figura3.14. De esta figura, vemos que la relacin
esfuerzo deformacin unitaria est dada por
= E(- 0 )

3.74

La energa de deformacin unitaria por unidad de volumen, u 0 , es igual al rea sombreada


de la figura 3.14 y est dada por

u0 12 (- 0 )

3.75

83
Usando la ecuacin 3.74, encontramos que la ecuacin 3.75 da

u0 12 (- 0 ) T E (- 0 )

3.76a

La energa de deformacin unitaria total U en la estructura se obtiene integrando u 0 sobre


el volumen de la estructura:
3.76b

Para una estructura modelada usando elementos lineales unidimensionales, la ecuacin


anterior toma la forma
3.76c

Notando que = Bq, obtenemos

3.76d

Examinando la expresin de la energa de deformacin unitaria anterior, vemos que el


primer trmino del segundo miembro de la ecuacin da la matriz de rigidez de un elemento
que se obtuvo en la ecuacin 3.4; el ltimo trmino es una constante y al derivar la energa
potencial total con respecto a Q, para hallar las ecuaciones de equilibrio, desaparece. El
segundo trmino da el vector de carga e deseado del elemento , ocasionado por el cambio
de temperatura:
e

3.77a

La ecuacin anterior puede simplificarse sustituyendo B =

1
1 1 y notando que
x2 x1

0 = T, entonces
e

3.77b

En la expresin anterior es el cambio de temperatura promedio dentro del elemento. El


vector de carga por temperatura en la ecuacin 3.77b puede ensamblarse junto con la fuerza
de cuerpo, la fuerza de traccin y los vectores de carga puntual para dar el vector de carga
global F para la estructura. Este ensamblaje puede denotarse por

84
3.78
Despus de resolver las ecuaciones del elemento finito KQ = F para los desplazamientos
Q, el esfuerzo en cada elemento puede obtenerse con la ecuacin 3.74 como
= E(Bq - )

3.79

Ejemplo 3.6. La estructura en la figura P3.18 est sometida a un incremento de


temperatura = 80C. Determine los desplazamientos, los esfuerzos y las reacciones en
los soportes.

SOLUCIN: Se consideran 3 elementos, 4 grados de libertad y 2 condiciones de frontera.


Condiciones de frontera:

Q1 0
Q4 0

85

3.10 PROGRAMAS DE COMPUTADORA


Se dan los cdigos del proyecto UnaDimension.bpr , la salida en pantalla es tal como se
ha visto anteriormente al resolver los ejercicios. Note la inclusin de la clase TMatriz
desarrollada en el anterior captulo.
/**************************************
* UnaDimension.h Versin 1.0
*
* D.R. Adolfo Linares Flores 2003
*
* El Mtodo de los Elementos Finitos
*
* Todos los Derechos Reservados
*
***************************************/
//--------------------------------------------------------------------------#ifndef UnaDimensionH
#define UnaDimensionH
//--------------------------------------------------------------------------#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <Buttons.hpp>
#include <ComCtrls.hpp>

86
#include <Menus.hpp>
#include <ToolWin.hpp>
#include <DBGrids.hpp>
#include <Grids.hpp>
#include <Db.hpp>
#include <iostream.h>
#include <assert.h>
#include "TMatriz.h"
//--------------------------------------------------------------------------class TForm1 : public TForm
{
__published: // IDE-managed Components
TLabel *Label1;
TEdit *Edit1;
TButton *Button1;
TMainMenu *MainMenu1;
TMenuItem *Archivo1;
TMenuItem *Imprimir1;
TMenuItem *N1;
TMenuItem *Salir1;
TMenuItem *Editar1;
TMenuItem *Copiar1;
TMenuItem *Cortar1;
TMenuItem *Pegar1;
TDBGrid *DBGrid1;
TButton *Button2;
TLabel *Label2;
TDataSource *DataSource1;
TLabel *Label3;
TLabel *Label4;
TEdit *Edit2;
TLabel *Label5;
TEdit *Edit3;
TLabel *Label6;
TDBGrid *DBGrid2;
TLabel *Label7;
TDBGrid *DBGrid3;
TDataSource *DataSource2;
TDataSource *DataSource3;
TMenuItem *Acerca;
TMenuItem *AcercaDelMEF;
TLabel *Label8;
TEdit *Edit4;
TLabel *Label9;
TLabel *Label10;
TEdit *Edit5;

87
TEdit *Edit6;
TDBGrid *DBGrid4;
TDBGrid *DBGrid5;
TLabel *Label11;
TLabel *Label12;
TDataSource *DataSource4;
TDataSource *DataSource5;
TLabel *Label13;
TDBGrid *DBGrid6;
TDataSource *DataSource6;
TLabel *Label14;
TLabel *Label15;
TDBGrid *DBGrid7;
TDBGrid *DBGrid8;
TDataSource *DataSource7;
TDataSource *DataSource8;
TButton *Button3;
TDBGrid *DBGrid9;
TLabel *Label16;
TDataSource *DataSource9;
TButton *Button4;
TButton *Button5;
TLabel *Label17;
TLabel *Label18;
TDataSource *DataSource10;
TDBGrid *DBGrid10;
TMenuItem *VistaPrevia1;
void __fastcall Edit1KeyPress(TObject *Sender, char &Key);
void __fastcall Button1Click(TObject *Sender);
void __fastcall Button2Click(TObject *Sender);
void __fastcall Salir1Click(TObject *Sender);
void __fastcall AcercaDelMEFClick(TObject *Sender);

void __fastcall Button3Click(TObject *Sender);


void __fastcall Button5Click(TObject *Sender);
void __fastcall Imprimir1Click(TObject *Sender);
void __fastcall FormActivate(TObject *Sender);
void __fastcall Button4Click(TObject *Sender);
void __fastcall Button6Click(TObject *Sender);
void __fastcall Button7Click(TObject *Sender);

88
void __fastcall VistaPrevia1Click(TObject *Sender);
private:
// User declarations
int n; //nmero de elementos
int ng; //nmero de grados de libertad
int ncf; //nmero de condiciones de frontera
int nrmp; //nmero de restricciones de multipunto
double C; //constante para la penalizacin
TTable *tabla, *tabla2, *tabla3, *tabla4, *tabla5, *Respuesta;
TTable *rigidez, *fuerza, *funo;
TMatriz *B;
TMatriz *q;
TMatriz *N;
TMatriz *K;
TMatriz *f;
TMatriz *T;
TMatriz *P;
TMatriz *gl;
TMatriz ST;
TMatriz F;
TMatriz *delTem;
TMatriz *fn;
public:
// User declarations
__fastcall TForm1(TComponent* Owner);
};
//--------------------------------------------------------------------------extern PACKAGE TForm1 *Form1;
//--------------------------------------------------------------------------#endif

/**************************************
* UnaDimension.cpp Versin 1.0
*
* D.R. Adolfo Linares Flores 2003
*
* El Mtodo de los Elementos Finitos
*
* Todos los Derechos Reservados
*
***************************************/
//--------------------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include "UnaDimension.h"
#include "TMatriz.h"
#include "AcercaDel.h"
#include "ResultadosUnidimensional.h"
#include "Informe.h"

89
USEUNIT("TMatriz.cpp");
//--------------------------------------------------------------------------#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//--------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key)


{
//Si no es un dgito o la tecla de borrado
if((Key < '0' || Key > '9') && Key != 8)
Key = 0; // no admitir la pulsacin
}
//--------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender)
{
n = Edit1->Text.ToInt();
if(n > 0) Edit1->ReadOnly = true;
else {
do {
MessageBox(Handle, "Ingrese un entero positivo", "Mensaje", MB_OK);
} while(n < 0);
}
//Crea el Alias para la base de datos de las propiedades de los elementos
/* const char* dir = "c:\\Elementos Finitos\\UnaDimension";
CreateDirectory(dir,0);
try {
Session->AddStandardAlias("Base de Datos Unidimensional", dir, "DBASE");
Session->SaveConfigFile();
}
catch(...) {
MessageBox(Handle, "Error de Creacin del Alias de la Base de Datos", "Mensaje",
0);
return ;
} */
ncf = Edit5->Text.ToInt();
nrmp = Edit6->Text.ToInt();

90
//Cambia el cursor al estilo de reloj de arena
Screen->Cursor = crHourGlass;
//Ahora crea la tabla
try {
tabla = new TTable(this);
tabla->DatabaseName = "Base de Datos Unidimensional";
tabla->TableName = "materiales.dbf";
tabla->Active = false;
//Borra todos los campos de la tabla
tabla->FieldDefs->Clear();
//Agrega las definiciones para los campos
tabla->FieldDefs->Add("Area", ftFloat, 0, true);
tabla->FieldDefs->Add("Longitud", ftFloat, 0, true);
tabla->FieldDefs->Add("Mdulo E", ftFloat, 0,true);
tabla->FieldDefs->Add("Delta Temp", ftFloat, 0, true);
tabla->FieldDefs->Add("Alfa", ftFloat, 0, true);
//Crea la tabla
tabla->CreateTable();
}
catch(...) {
MessageBox(Handle, "Error en la Creacin de la Tabla", "Mensaje", 0);
Screen->Cursor = crDefault;
delete tabla;
return ;
}
//Ahora crea la tabla
try {
tabla2 = new TTable(this);
tabla2->DatabaseName = "Base de Datos Unidimensional";
tabla2->TableName = "cargasPuntuales.dbf";
tabla2->Active = false;
//Borra todos los campos de la tabla
tabla2->FieldDefs->Clear();
//Agrega las definiciones para los campos
tabla2->FieldDefs->Add("Cargas Puntuales", ftFloat, 0, true);
//Crea la tabla
tabla2->CreateTable();
}

91
catch(...) {
MessageBox(Handle, "Error en la Creacin de la Tabla de las Cargas Puntuales",
"Mensaje", 0);
Screen->Cursor = crDefault;
delete tabla2;
return ;
}
//Ahora crea la tabla
try {
tabla3 = new TTable(this);
tabla3->DatabaseName = "Base de Datos Unidimensional";
tabla3->TableName = "conectividad.dbf";
tabla3->Active = false;
//Borra todos los campos de la tabla
tabla3->FieldDefs->Clear();
//Agrega las definiciones para los campos
tabla3->FieldDefs->Add("Nodo 1", ftSmallint, 0, true);
tabla3->FieldDefs->Add("Nodo 2", ftSmallint, 0, true);
//Crea la tabla
tabla3->CreateTable();
}
catch(...) {
MessageBox(Handle, "Error en la Creacin de la Tabla de Conectividad", "Mensaje",
0);
Screen->Cursor = crDefault;
delete tabla3;
return ;
}
if(ncf) {
//Ahora crea la tabla
try {
tabla4 = new TTable(this);
tabla4->DatabaseName = "Base de Datos Unidimensional";
tabla4->TableName = "CondicionesDeFrontera.dbf";
tabla4->Active = false;
//Borra todos los campos de la tabla
tabla4->FieldDefs->Clear();
//Agrega las definiciones para los campos
tabla4->FieldDefs->Add("Nodo", ftSmallint, 0, true);

92
tabla4->FieldDefs->Add("Desplazamiento", ftFloat, 0, true);
//Crea la tabla
tabla4->CreateTable();
}
catch(...) {
MessageBox(Handle, "Error en la Creacin de la Tabla de Condiciones de
frontera", "Mensaje", 0);
Screen->Cursor = crDefault;
delete tabla4;
return ;
}
}
if(nrmp) {
//Ahora crea la tabla
try {
tabla5 = new TTable(this);
tabla5->DatabaseName = "Base de Datos Unidimensional";
tabla5->TableName = "RestriccionesMP.dbf";
tabla5->Active = false;
//Borra todos los campos de la tabla
tabla5->FieldDefs->Clear();
//Agrega las definiciones para los campos
tabla5->FieldDefs->Add("Beta1", ftFloat, 0, true);
tabla5->FieldDefs->Add("nodoQi", ftSmallint, 0, true);
tabla5->FieldDefs->Add("Beta2", ftFloat, 0, true);
tabla5->FieldDefs->Add("nodoQj", ftSmallint, 0, true);
tabla5->FieldDefs->Add("Beta3", ftFloat, 0, true);

//Crea la tabla
tabla5->CreateTable();
}
catch(...) {
MessageBox(Handle, "Error en la Creacin de la Tabla de Restricciones
Multipunto", "Mensaje", 0);
Screen->Cursor = crDefault;
delete tabla5;
return ;
}
}

93

//Todo est concluido. Informar al usuario.


Screen->Cursor = crDefault;
//Desactiva el botn del ingreso de datos de los elementos finitos
Button1->Enabled = false;
MessageBox(Handle, "Las tablas han sido creadas satisfactoriamente", "Mensaje", 0);
//Ponenos la tabla creada anteriormente en modo de edicin para que el usuario ingrese
los datos
DataSource1->DataSet = tabla;
DBGrid1->DataSource = DataSource1;
DataSource2->DataSet = tabla2;
DBGrid2->DataSource = DataSource2;
DataSource3->DataSet = tabla3;
DBGrid3->DataSource = DataSource3;
if(ncf) {
DataSource4->DataSet = tabla4;
DBGrid4->DataSource = DataSource4;
}
if(nrmp) {
DataSource5->DataSet = tabla5;
DBGrid5->DataSource = DataSource5;
}

//Muestra la malla con su ttulo


Label2->Visible = true;
Label3->Visible = true;
Edit2->Visible = true;
Label4->Visible = true;
Edit3->Visible = true;
Label5->Visible = true;
Label6->Visible = true;
Label7->Visible = true;
Label8->Visible = true;
Edit4->Visible = true;
if(ncf) Label11->Visible = true;
if(nrmp) Label12->Visible = true;
DBGrid1->Visible = true;
DBGrid2->Visible = true;

94
DBGrid3->Visible = true;
if(ncf) DBGrid4->Visible = true;
if(nrmp)DBGrid5->Visible = true;
//Abre la tabla
tabla->Active = true;
tabla2->Active = true;
tabla3->Active = true;
if(ncf) tabla4->Active = true;
if(nrmp)tabla5->Active = true;
//Coloca la tabla en modo de edicin
tabla->Edit();
tabla2->Edit();
tabla3->Edit();
if(ncf) tabla4->Edit();
if(nrmp)tabla5->Edit();
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button2Click(TObject *Sender)


{
tabla->Active = true;
tabla2->Active = true;
tabla3->Active = true;
const int nn = Edit1->Text.ToInt();
B = new TMatriz[nn];
for(int i = 0; i<nn; i++)
B[i] = TMatriz(1,2);
tabla->First();
for(int i = 0; i<nn; i++) {
B[i].elementos[0][0] = -1.0/tabla->FieldByName("Longitud")->Value;
B[i].elementos[0][1] = 1.0/tabla->FieldByName("Longitud")->Value;
tabla->Next();
}
delTem = new TMatriz[n];
for(int i = 0; i<n; i++)
delTem[i] = TMatriz(2,1);
fn = new TMatriz[n];
for(int i = 0; i<n; i++)
fn[i] = TMatriz(2,1);

95

tabla->First();
for(int i = 0; i<nn; i++) {
delTem[i].elementos[0][0] = -(tabla->FieldByName("Mdulo E")->Value)*(tabla>FieldByName("Area")->Value)*(tabla->FieldByName("Delta Temp")->Value)*(tabla>FieldByName("Alfa")->Value);
delTem[i].elementos[1][0] = -delTem[i].elementos[0][0];
tabla->Next();
}
q = new TMatriz[nn];
for(int i = 0; i<nn; i++)
q[i] = TMatriz(2,1);
N = new TMatriz[nn];
for(int i = 0; i<nn; i++)
N[i] = TMatriz(1,2);
K = new TMatriz[nn];
for(int i = 0; i<nn; i++)
K[i] = TMatriz(2,2);
tabla->First();
for(int i = 0; i<nn; i++) {
K[i].elementos[0][0] = (tabla->FieldByName("Area")->Value)*(tabla>FieldByName("Mdulo E")->Value)/tabla->FieldByName("Longitud")->Value;
K[i].elementos[0][1] = -K[i].elementos[0][0];
K[i].elementos[1][0] = K[i].elementos[0][1];
K[i].elementos[1][1] = K[i].elementos[0][0];
tabla->Next();
}
tabla->First();
f = new TMatriz[nn];
for(int i = 0; i<nn; i++)
f[i] = TMatriz(2,1);
double ff = Edit2->Text.ToDouble();
for(int i = 0; i<nn; i++) {
f[i].elementos[0][0] = ff*(tabla->FieldByName("Area")->Value)*(tabla>FieldByName("Longitud")->Value)/2.0;
f[i].elementos[1][0] = f[i].elementos[0][0];
tabla->Next();
}
tabla->First();
T = new TMatriz[nn];
for(int i = 0; i<nn; i++)
T[i] = TMatriz(2,1);
double tt = Edit3->Text.ToDouble();
for(int i = 0; i<nn; i++) {

96
T[i].elementos[0][0] = tt*(tabla->FieldByName("Longitud")->Value)/2.0;
T[i].elementos[1][0] = T[i].elementos[0][0];
tabla->Next();
}
ng = Edit4->Text.ToInt();
P = new TMatriz(ng,1);
tabla2->First();
for(int i = 0; i<ng; i++) {
P->elementos[i][0] = tabla2->FieldByName("Cargas Puntuales")->Value;
tabla2->Next();
}
tabla3->First();
gl = new TMatriz[nn];
for(int i = 0; i<nn; i++)
gl[i] = TMatriz(2,1);
for(int i = 0; i<nn; i++) {
gl[i].elementos[0][0] = tabla3->FieldByName("Nodo 1")->Value;
gl[i].elementos[1][0] = tabla3->FieldByName("Nodo 2")->Value;
tabla3->Next();
}
TMatriz ST(ng,ng);
for(int i = 0; i<n; i++)
for(int j = 0; j<2; j++)
for(int k = 0; k<2; k++) {
int a = gl[i].elementos[j][0];
int b = gl[i].elementos[k][0];
ST.elementos[a-1][b-1] += K[i].elementos[j][k];
}
TMatriz F(ng,1);
for(int i = 0; i<n;i++)
for(int j = 0; j<2; j++) {
int a = gl[i].elementos[j][0];
F.elementos[a-1][0] +=
f[i].elementos[j][0]+T[i].elementos[j][0]+delTem[i].elementos[j][0];
}
F = F+(*P);
if(ncf) {
tabla4->Active = true;
tabla4->First();

97
C = 0;
for(int i = 0; i < ng; i++) {
if(C < ST.elementos[i][i])
C = ST.elementos[i][i];
}
C *= 10000;
//Modificacin por los desplazamientos de las condiciones de frontera
for(int i = 0; i < ncf; i++) {
int k = tabla4->FieldByName("Nodo")->Value;
double u = tabla4->FieldByName("Desplazamiento")->Value;
ST.elementos[k-1][k-1] += C;
F.elementos[k-1][0] += C*u;
tabla4->Next();
}
}
//Modificacin por las restricciones de multipunto
if(nrmp) {tabla5->Active = true;
tabla5->First();
}
for(int i = 0; i < nrmp; i++) {
double b1 = tabla5->FieldByName("Beta1")->Value;
int k = tabla5->FieldByName("nodoQi")->Value;
double b2 = tabla5->FieldByName("Beta2")->Value;
int m = tabla5->FieldByName("nodoQj")->Value;
ST.elementos[k-1][k-1] += C*b1*b1;
ST.elementos[k-1][m-1] += C*b1*b2;
ST.elementos[m-1][k-1] += C*b1*b2;
ST.elementos[m-1][m-1] += C*b2*b2;
tabla5->Next();
}
try {
rigidez = new TTable(this);
rigidez->DatabaseName = "Base de Datos Unidimensional";
rigidez->TableName = "rigido.dbf";
DataSource7->DataSet = rigidez;
DBGrid7->DataSource = DataSource7;
rigidez->Active = false;
//Borra todos los campos de la tabla
rigidez->FieldDefs->Clear();
//Agrega las definiciones para los campos
String cad;
for(int j = 0; j<ng; j++){

98
cad = "K_0_"+IntToStr(j);
rigidez->FieldDefs->Add(cad, ftFloat, 0, true);
}
//Crea la tabla
rigidez->CreateTable();
}
catch(...) {
MessageBox(Handle, "Error en la Creacin de la Tabla de rigidez", "Mensaje", 0);
Screen->Cursor = crDefault;
delete rigidez;
return ;
}
try {
fuerza = new TTable(this);
fuerza->DatabaseName = "Base de Datos Unidimensional";
fuerza->TableName = "force.dbf";
DataSource8->DataSet = fuerza;
DBGrid8->DataSource = DataSource8;
fuerza->Active = false;
//Borra todos los campos de la tabla
fuerza->FieldDefs->Clear();
//Agrega las definiciones para los campos
fuerza->FieldDefs->Add("Fuerzas", ftFloat, 0, true);
//Crea la tabla
fuerza->CreateTable();
}
catch(...) {
MessageBox(Handle, "Error en la Creacin de la Tabla de fuerzas", "Mensaje", 0);
Screen->Cursor = crDefault;
delete fuerza;
return ;
}
rigidez->Active = true;
fuerza->Active = true;
rigidez->Edit();
fuerza->Edit();
Label14->Visible = true;
Label15->Visible = true;
DBGrid7->Visible = true;
DBGrid8->Visible = true;

99
for(int i = 0; i<ng; i++){
fuerza->Append();
fuerza->FieldByName("Fuerzas")->Value = F.elementos[i][0];
fuerza->Next();
}
for(int i = 0; i<ng; i++){ rigidez->Append();
for(int j = 0; j<ng; j++){
String cad = "K_0_" +IntToStr(j);
rigidez->FieldByName(cad)->Value = ST.elementos[i][j];
}
rigidez->Next();
}

//Resolucin del sistema de ecuaciones


double cc;
for(int k = 0; k<ng-1; k++){
for(int i = k + 1; i<ng; i++) {
cc = ST.elementos[i][k]/ST.elementos[k][k];
for(int j = k+1; j<ng; j++){
ST.elementos[i][j] = ST.elementos[i][j]-cc*ST.elementos[k][j];
}
F.elementos[i][0] = F.elementos[i][0] - cc*F.elementos[k][0];
}
}
F.elementos[ng-1][0] = F.elementos[ng-1][0]/ST.elementos[ng-1][ng-1];
for(int i = ng-2; i>=0; i--) {
cc = 1.0/ST.elementos[i][i];
F.elementos[i][0] = cc*F.elementos[i][0];
for(int k = i + 1 ; k<ng; k++){
F.elementos[i][0] =F.elementos[i][0]- cc*ST.elementos[i][k]*F.elementos[k][0];
}
}

for(int i = 0; i<n; i++) {


int k = gl[i].elementos[0][0];
int m = gl[i].elementos[1][0];
q[i].elementos[0][0] =F.elementos[k-1][0];
q[i].elementos[1][0] =F.elementos[m-1][0];
}
try {
Respuesta = new TTable(this);

100
Respuesta->DatabaseName = "Base de Datos Unidimensional";
Respuesta->TableName = "respuesta.dbf";
DataSource6->DataSet = Respuesta;
DBGrid6->DataSource = DataSource6;
Respuesta->Active = false;
//Borra todos los campos de la tabla
Respuesta->FieldDefs->Clear();
//Agrega las definiciones para los campos
Respuesta->FieldDefs->Add("Nodo", ftSmallint, 0, true);
Respuesta->FieldDefs->Add("Desplazam", ftFloat, 0, true);
//Crea la tabla
Respuesta->CreateTable();
}
catch(...) {
MessageBox(Handle, "Error en la Creacin de la Tabla de Respuestas", "Mensaje", 0);
Screen->Cursor = crDefault;
delete Respuesta;
return ;
}
Screen->Cursor = crDefault;
MessageBox(Handle, "Las tabla de respuesta ha sido creada satisfactoriamente",
"Mensaje", 0);
Label13->Visible = true;
DBGrid6->Visible = true;
Respuesta->Active = true;
Respuesta->Edit();
for(int i = 0; i <ng; i++) {
Respuesta->Append();
Respuesta->FieldByName("Nodo")->Value = i+1;
Respuesta->FieldByName("Desplazam")->Value = F.elementos[i][0];
Respuesta->Next();
}
Button2->Enabled = false;

}
//---------------------------------------------------------------------------

101

void __fastcall TForm1::Salir1Click(TObject *Sender)


{
Close();
}
//---------------------------------------------------------------------------

void __fastcall TForm1::AcercaDelMEFClick(TObject *Sender)


{
AcercaDe->ShowModal();
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button3Click(TObject *Sender)


{
TTable * esfuerzo;
try {
esfuerzo = new TTable(this);
esfuerzo->DatabaseName = "Base de Datos Unidimensional";
esfuerzo->TableName = "esfuerzo.dbf";
esfuerzo->Active = false;
//Borra todos los campos de la tabla
esfuerzo->FieldDefs->Clear();
//Agrega las definiciones para los campos
esfuerzo->FieldDefs->Add("Elemento", ftSmallint, 0, true);
esfuerzo->FieldDefs->Add("Esfuerzo", ftFloat, 0, true);

//Crea la tabla
esfuerzo->CreateTable();
}
catch(...) {
MessageBox(Handle, "Error en la Creacin de la Tabla de Restricciones
Multipunto", "Mensaje", 0);
Screen->Cursor = crDefault;
delete esfuerzo;
return ;
}
MessageBox(Handle, "Las tablade los esfuerzos ha sido creada satisfactoriamente",
"Mensaje", 0);

102
//Ponenos la tabla creada anteriormente en modo de edicin para que el usuario ingrese
los datos
DataSource9->DataSet = esfuerzo;
DBGrid9->DataSource = DataSource9;
Label16->Visible = true;
DBGrid9->Visible = true;
esfuerzo->Active = true;
esfuerzo->Edit();
tabla->First();
for(int i = 0; i<n; i++){
esfuerzo->Append();
TMatriz prod(1,1);
prod = B[i]*q[i];
double esf = (tabla->FieldByName("Mdulo E")->Value)*(prod.elementos[0][0](tabla->FieldByName("Delta Temp")->Value)*(tabla->FieldByName("Alfa")->Value));
esfuerzo->FieldByName("Elemento")->Value = i+1;
esfuerzo->FieldByName("Esfuerzo")->Value = esf;
esfuerzo->Next();
tabla->Next();
}
Button3->Enabled = false;
}
//--------------------------------------------------------------------------void __fastcall TForm1::Button5Click(TObject *Sender)
{
AnsiString cad, cad2;
cad2 = InputBox("Desplazamiento", "Ingrese el nmero del elemento", "");
int num = cad2.ToInt();
cad = InputBox("Desplazamiento", "Ingrese la posicin con respecto del elemento","");
double x =cad.ToDouble();
double e;
tabla->First();
for(int i= 0; i<num-1; i++)
tabla->Next();
e = 2.0*x/(tabla->FieldByName("Longitud")->Value) -1.0;
N[num-1].elementos[0][0] = (1.0 - e)/2.0;
N[num-1].elementos[0][1] = (1.0 + e)/2.0;
TMatriz prod(1,1);
prod = N[num-1]*q[num-1];
ShowMessage(AnsiString(prod.elementos[0][0]));
}
//---------------------------------------------------------------------------

103

void __fastcall TForm1::Imprimir1Click(TObject *Sender)


{
QuickReport1->Print();
}
//--------------------------------------------------------------------------void __fastcall TForm1::FormActivate(TObject *Sender)
{
AnsiString cad;
cad = InputBox("Elementos Finitos", "Ingrese el nombre del Problema","");
Label17->Caption = cad;
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button4Click(TObject *Sender)


{
for(int i = 0; i < n; i++)
fn[i] = K[i]*q[i];
try {
funo = new TTable(this);
funo->DatabaseName = "Base de Datos Unidimensional";
funo->TableName = "fuerzaNodo.dbf";
funo->Active = false;
//Borra todos los campos de la tabla
funo->FieldDefs->Clear();
//Agrega las definiciones para los campos
funo->FieldDefs->Add("Elemento", ftSmallint, 0, true);
funo->FieldDefs->Add("Fuerza1", ftFloat, 0, true);
funo->FieldDefs->Add("Fuerza2", ftFloat, 0, true);
//Crea la tabla
funo->CreateTable();
}
catch(...) {
MessageBox(Handle, "Error en la Creacin de la Tabla de Restricciones
Multipunto", "Mensaje", 0);
Screen->Cursor = crDefault;
delete funo;
return ;
}
MessageBox(Handle, "Las tabla de las Fuerzas en los nodos ha sido creada
satisfactoriamente", "Mensaje", 0);

104
//Ponenos la tabla creada anteriormente en modo de edicin para que el usuario ingrese
los datos
DataSource10->DataSet = funo;
DBGrid10->DataSource = DataSource10;
Label18->Visible = true;
DBGrid10->Visible = true;
funo->Active = true;
funo->Edit();
for(int i = 0; i<n; i++){
funo->Append();
funo->FieldByName("Elemento")->Value = i+1;
funo->FieldByName("Fuerza1")->Value = fn[i].elementos[0][0];
funo->FieldByName("Fuerza2")->Value = fn[i].elementos[1][0];
funo->Next();
}
Button4->Enabled = false;
}
//---------------------------------------------------------------------------

void __fastcall TForm1::VistaPrevia1Click(TObject *Sender)


{
QuickReport1->Preview();
}
//---------------------------------------------------------------------------

También podría gustarte