fork download
copy 
  1. #include <iostream>
  2. #include <vector>
  3. #include <cmath>
  4. #include <cassert>
  5.  
  6. using namespace std;
  7.  
  8. // Estructura para representar un nodo
  9. struct Nodo {
  10.     double x, y;  // Coordenadas del nodo
  11.     double fx, fy;  // Fuerzas aplicadas en el nodo (si las hay)
  12.     bool fijo_x, fijo_y; // Condiciones de frontera (si el nodo es fijo en X o Y)
  13. };
  14.  
  15. // Estructura para representar una barra entre dos nodos
  16. struct Barra {
  17.     int nodo1, nodo2;  // Índices de los nodos conectados
  18.     double longitud;   // Longitud de la barra
  19.     double area;       // Área de la sección transversal
  20.     double E;          // Módulo de elasticidad
  21. };
  22.  
  23. // Función para ingresar los nodos
  24. void ingresarNodos(vector<Nodo>& nodos, int num_nodos) {
  25.     for (int i = 0; i < num_nodos; ++i) {
  26.         Nodo nodo;
  27.         cout << "Ingrese las coordenadas del nodo " << i + 1 << " (x, y): ";
  28.         cin >> nodo.x >> nodo.y;
  29.         cout << "Ingrese las fuerzas aplicadas en el nodo " << i + 1 << " (fx, fy): ";
  30.         cin >> nodo.fx >> nodo.fy;
  31.  
  32.         // Condiciones de frontera
  33.         if (i == 0) {  // Nodo 1 fijo en X y Y
  34.             nodo.fijo_x = true;
  35.             nodo.fijo_y = true;
  36.         } else if (i == 1) {  // Nodo 2 fijo solo en Y
  37.             nodo.fijo_x = false;
  38.             nodo.fijo_y = true;
  39.         } else {  // Nodo 3 sin restricciones
  40.             nodo.fijo_x = false;
  41.             nodo.fijo_y = false;
  42.         }
  43.  
  44.         nodos.push_back(nodo);
  45.     }
  46. }
  47.  
  48. // Función para ingresar las barras
  49. void ingresarBarras(vector<Barra>& barras, int num_barras) {
  50.     for (int i = 0; i < num_barras; ++i) {
  51.         Barra barra;
  52.         cout << "Ingrese los nodos conectados por la barra " << i + 1 << " (nodo1, nodo2): ";
  53.         cin >> barra.nodo1 >> barra.nodo2;
  54.         cout << "Ingrese la longitud de la barra " << i + 1 << ": ";
  55.         cin >> barra.longitud;
  56.         cout << "Ingrese el área de la barra " << i + 1 << ": ";
  57.         cin >> barra.area;
  58.         cout << "Ingrese el módulo de elasticidad de la barra " << i + 1 << ": ";
  59.         cin >> barra.E;
  60.  
  61.         barras.push_back(barra);
  62.     }
  63. }
  64.  
  65. // Función para calcular la rigidez de una barra (en 2D)
  66. vector<vector<double>> rigidezBarra(const Barra& barra, const Nodo& n1, const Nodo& n2) {
  67.     double L = barra.longitud;
  68.     double A = barra.area;
  69.     double E = barra.E;
  70.  
  71.     // Cálculo de la matriz de rigidez local de la barra
  72.     double c = (n2.x - n1.x) / L;  // Coseno de la dirección de la barra
  73.     double s = (n2.y - n1.y) / L;  // Seno de la dirección de la barra
  74.  
  75.     vector<vector<double>> K(4, vector<double>(4, 0));  // Matriz de rigidez local (4x4)
  76.  
  77.     // Matriz de rigidez local (considerando 2D)
  78.     double k_local = (A * E) / L;
  79.     K[0][0] = k_local * c * c;
  80.     K[0][1] = k_local * c * s;
  81.     K[1][0] = k_local * c * s;
  82.     K[1][1] = k_local * s * s;
  83.     K[2][2] = k_local * c * c;
  84.     K[2][3] = k_local * c * s;
  85.     K[3][2] = k_local * c * s;
  86.     K[3][3] = k_local * s * s;
  87.  
  88.     return K;
  89. }
  90.  
  91. // Función para ensamblar la matriz de rigidez global
  92. vector<vector<double>> ensamblarRigidezGlobal(const vector<Barra>& barras, const vector<Nodo>& nodos) {
  93.     int n = nodos.size();
  94.     vector<vector<double>> K_global(2 * n, vector<double>(2 * n, 0));  // Matriz de rigidez global (2n x 2n)
  95.  
  96.     // Ensamblaje de la matriz de rigidez global
  97.     for (const Barra& barra : barras) {
  98.         Nodo n1 = nodos[barra.nodo1];
  99.         Nodo n2 = nodos[barra.nodo2];
  100.  
  101.         // Obtener la matriz de rigidez local
  102.         vector<vector<double>> K_local = rigidezBarra(barra, n1, n2);
  103.  
  104.         // Incluir K_local en la matriz de rigidez global
  105.         for (int i = 0; i < 4; ++i) {
  106.             for (int j = 0; j < 4; ++j) {
  107.                 K_global[2 * barra.nodo1 + i / 2][2 * barra.nodo1 + j / 2] += K_local[i][j];
  108.             }
  109.         }
  110.     }
  111.  
  112.     return K_global;
  113. }
  114.  
  115. // Función para aplicar condiciones de frontera (restringir desplazamientos)
  116. void aplicarCondicionesFrontera(vector<vector<double>>& K, vector<double>& F, const vector<Nodo>& nodos) {
  117.     int n = nodos.size();
  118.  
  119.     for (int i = 0; i < n; i++) {
  120.         if (nodos[i].fijo_x) {
  121.             // Fijar el desplazamiento en X (columna correspondiente)
  122.             for (int j = 0; j < 2 * n; j++) {
  123.                 K[2 * i][j] = 0;
  124.                 K[j][2 * i] = 0;
  125.             }
  126.             K[2 * i][2 * i] = 1;
  127.             F[2 * i] = 0;  // Fuerza en X es 0
  128.         }
  129.  
  130.         if (nodos[i].fijo_y) {
  131.             // Fijar el desplazamiento en Y (columna correspondiente)
  132.             for (int j = 0; j < 2 * n; j++) {
  133.                 K[2 * i + 1][j] = 0;
  134.                 K[j][2 * i + 1] = 0;
  135.             }
  136.             K[2 * i + 1][2 * i + 1] = 1;
  137.             F[2 * i + 1] = 0;  // Fuerza en Y es 0
  138.         }
  139.     }
  140. }
  141.  
  142. // Función para resolver el sistema de ecuaciones (desplazamientos)
  143. vector<double> resolverDesplazamientos(vector<vector<double>>& K, vector<double>& F) {
  144.     int n = K.size();
  145.  
  146.     // Resolver el sistema Kx = F usando eliminación de Gauss
  147.     vector<double> X(n, 0);  // Desplazamientos inicializados a 0
  148.     vector<vector<double>> A = K;
  149.  
  150.     // Eliminación de Gauss
  151.     for (int i = 0; i < n; i++) {
  152.         // Buscar el máximo en la columna para estabilidad
  153.         int max_row = i;
  154.         for (int k = i + 1; k < n; k++) {
  155.             if (abs(A[k][i]) > abs(A[max_row][i])) {
  156.                 max_row = k;
  157.             }
  158.         }
  159.  
  160.         // Intercambiar filas
  161.         swap(A[i], A[max_row]);
  162.         swap(F[i], F[max_row]);
  163.  
  164.         // Hacer cero las entradas debajo de la diagonal
  165.         for (int j = i + 1; j < n; j++) {
  166.             double factor = A[j][i] / A[i][i];
  167.             for (int k = i; k < n; k++) {
  168.                 A[j][k] -= factor * A[i][k];
  169.             }
  170.             F[j] -= factor * F[i];
  171.         }
  172.     }
  173.  
  174.     // Resolución hacia atrás
  175.     for (int i = n - 1; i >= 0; i--) {
  176.         X[i] = F[i] / A[i][i];
  177.         for (int j = i - 1; j >= 0; j--) {
  178.             F[j] -= A[j][i] * X[i];
  179.         }
  180.     }
  181.  
  182.     return X;
  183. }
  184.  
  185. // Función para calcular las fuerzas axiales en las barras
  186. vector<double> calcularFuerzasAxiales(const vector<Barra>& barras, const vector<double>& desplazamientos, const vector<Nodo>& nodos) {
  187.     vector<double> fuerzas_axiales;
  188.  
  189.     for (const Barra& barra : barras) {
  190.         Nodo n1 = nodos[barra.nodo1];
  191.         Nodo n2 = nodos[barra.nodo2];
  192.  
  193.         // Desplazamientos en los nodos 1 y 2
  194.         double u1 = desplazamientos[2 * barra.nodo1];  // Desplazamiento en X del nodo 1
  195.         double v1 = desplazamientos[2 * barra.nodo1 + 1];  // Desplazamiento en Y del nodo 1
  196.         double u2 = desplazamientos[2 * barra.nodo2];  // Desplazamiento en X del nodo 2
  197.         double v2 = desplazamientos[2 * barra.nodo2 + 1];  // Desplazamiento en Y del nodo 2
  198.  
  199.         // Longitud de la barra
  200.         double L = barra.longitud;
  201.  
  202.         // Cálculo de las fuerzas axiales
  203.         double c = (n2.x - n1.x) / L;
  204.         double s = (n2.y - n1.y) / L;
  205.  
  206.         // Fuerza axial
  207.         double fuerza_axial = barra.E * barra.area / L * ( (u2 - u1) * c + (v2 - v1) * s );
  208.         fuerzas_axiales.push_back(fuerza_axial);
  209.     }
  210.  
  211.     return fuerzas_axiales;
  212. }
  213.  
  214. int main() {
  215.     int num_nodos = 3;
  216.     int num_barras = 3;
  217.  
  218.     vector<Nodo> nodos;
  219.     vector<Barra> barras;
  220.  
  221.     // Ingresar los nodos y las barras
  222.     ingresarNodos(nodos, num_nodos);
  223.     ingresarBarras(barras, num_barras);
  224.  
  225.     // Ensamblar la matriz de rigidez global
  226.     vector<vector<double>> K_global = ensamblarRigidezGlobal(barras, nodos);
  227.  
  228.     // Definir el vector de fuerzas (aplicadas en los nodos)
  229.     vector<double> F(2 * nodos.size(), 0);
  230.     F[5] = nodos[2].fy;  // Fuerza en el nodo 3 (Y)
  231.  
  232.     // Aplicar condiciones de frontera
  233.     aplicarCondicionesFrontera(K_global, F, nodos);
  234.  
  235.     // Resolver el sistema de ecuaciones para obtener los desplazamientos
  236.     vector<double> desplazamientos = resolverDesplazamientos(K_global, F);
  237.  
  238.     // Mostrar los resultados de los desplazamientos
  239.     for (int i = 0; i < desplazamientos.size(); ++i) {
  240.         cout << "Desplazamiento en nodo " << i / 2 << " (componente " << i % 2 << "): " 
  241.              << desplazamientos[i] << " m" << endl;
  242.     }
  243.  
  244.     // Calcular las fuerzas axiales en las barras
  245.     vector<double> fuerzas_axiales = calcularFuerzasAxiales(barras, desplazamientos, nodos);
  246.  
  247.     // Mostrar las fuerzas axiales
  248.     for (int i = 0; i < fuerzas_axiales.size(); ++i) {
  249.         cout << "Fuerza axial en barra " << i + 1 << ": " 
  250.              << fuerzas_axiales[i] << " N" << endl;
  251.     }
  252.  
  253.     return 0;
  254. }
  255.  
Success #stdin #stdout 0.01s 5300KB
comments (?)
stdin
copy 
0 0
0 0
0 5
0 0
2.5 2.5
0 -1000
0 1
5.0
0.01
210000000000
1 2
3.5355
0.01
210000000000
0 2
3.5355
0.01
210000000000
stdout
copy 
Ingrese las coordenadas del nodo 1 (x, y): Ingrese las fuerzas aplicadas en el nodo 1 (fx, fy): Ingrese las coordenadas del nodo 2 (x, y): Ingrese las fuerzas aplicadas en el nodo 2 (fx, fy): Ingrese las coordenadas del nodo 3 (x, y): Ingrese las fuerzas aplicadas en el nodo 3 (fx, fy): Ingrese los nodos conectados por la barra 1 (nodo1, nodo2): Ingrese la longitud de la barra 1: Ingrese el área de la barra 1: Ingrese el módulo de elasticidad de la barra 1: Ingrese los nodos conectados por la barra 2 (nodo1, nodo2): Ingrese la longitud de la barra 2: Ingrese el área de la barra 2: Ingrese el módulo de elasticidad de la barra 2: Ingrese los nodos conectados por la barra 3 (nodo1, nodo2): Ingrese la longitud de la barra 3: Ingrese el área de la barra 3: Ingrese el módulo de elasticidad de la barra 3: Desplazamiento en nodo 0 (componente 0): -nan m
Desplazamiento en nodo 0 (componente 1): -nan m
Desplazamiento en nodo 1 (componente 0): -nan m
Desplazamiento en nodo 1 (componente 1): -nan m
Desplazamiento en nodo 2 (componente 0): -nan m
Desplazamiento en nodo 2 (componente 1): -nan m
Fuerza axial en barra 1: -nan N
Fuerza axial en barra 2: -nan N
Fuerza axial en barra 3: -nan N
https://ideone.com/j4LFuU
language:
C++ (gcc 8.3)
created:
3 days ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!