Professional Documents
Culture Documents
=(x)
=(x)
T = T(x)
f = f(x)
3.1
dx
Para problemas unidimensionales, la diferencial de volumen dV puede escribirse como
dV = Adx
3.3
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.
1
2
1
N 2
2
N1
3.5
3.6
u N1q1 N 2 q2
3.7a
u = Nq
3.7b
56
donde
N = N1 , N 2 y q = q1 , q 2
3.8
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
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
1
q1 q2
x2 x1
3.13
3.14
E Bq
3.16
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.
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
Ue
1
T Adx
3.19
59
dx
e
d
2
d 2 , y sustituyendo el
donde la matriz
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:
1
q1 q2 1 (0.02 0.025) 0.000625
x2 x1
23 15
d.
1 1
1.2 * 30e6 1 1
4
.
5
e
6
1 1 Respuesta.
23 15 1 1
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
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
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
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.
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.
Q p1 a1 , Q p 2 a2 ,, Q pr ar
3.39
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
K11
K
21
K=
K N1
K12
K 22
KN2
K1N
K 2 N
K NN
3.41
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
65
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
0
Qi
i 2,3,, N
3.44
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.
1 1
150
333333 . 3 333333 . 3 2
1
1 1
150
333333 . 3 333333 . 3 3
2
67
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
0
333333 . 3
600000
266666 . 6 3
0
0
266666 . 6 266666 . 6 4
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
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
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
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
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,
F1 Ca1
3.54a
71
K
K
F
K11
1Q1 12 Q2 1N QN 1 a1
C
C
C
C
3.54b
1 i N
1 j N
3.55
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 ,
cuando
K P1P1
K
P 2 P1
y
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
p1 j
Q j Fp1 R p1
p2 j
Q j Fp 2 R p 2
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:
Q1 0
Resolviendo el problema con el programa tenemos:
75
Q5 3.5mm
76
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.
2x x3
x2 x1
3.61
79
como
N1 12 1
3.62a
N 3 1 1
3.62b
3.62c
N 2 12 1
80
2 dN1 dN 2 dN3
,
,
q
x2 x1 d d d
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
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
resulta
3.70a
que, al sustituir por B en la ecuacin 3.67, da
3.70b
3.71b
que conduce a
82
3.72b
3.73
3.74
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
3.76d
3.77a
1
1 1 y notando que
x2 x1
0 = T, entonces
e
3.77b
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
Q1 0
Q4 0
85
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);
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)
{
}
//---------------------------------------------------------------------------
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
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();
}
//---------------------------------------------------------------------------
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();
}
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
//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
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;
}
//---------------------------------------------------------------------------