mnspy 0.9.14__tar.gz → 0.9.16__tar.gz

{mnspy-0.9.14 → mnspy-0.9.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mnspy
-Version: 0.9.14
+Version: 0.9.16
 Summary: Paquete didáctico para métodos numéricos
 Home-page: https://github.com/EdwinSoft/mnspy
 Author: Edwin Córdoba

{mnspy-0.9.14 → mnspy-0.9.16}/mnspy/ecuaciones_diferenciales_parciales/mef/marco.py

@@ -215,28 +215,18 @@ class Marco(Elemento):
         # Esto se hace aplicando un momento corrector en el nodo i y las fuerzas
         # cortantes correspondientes en ambos nodos para mantener el equilibrio.
         if self._nodo_j.es_rotula:
-            # Momento de empotramiento en el extremo j (a liberar)
-            m_fem_j = -q * self._L ** 2 / 12
-            # Momento transferido al nodo i (carry-over) y fuerzas cortantes resultantes
-            m_corrector_i = -0.5 * m_fem_j
-            v_corrector = m_fem_j * 3.0 / (2.0 * self._L)
-
-            # Aplicar correcciones a las fuerzas nodales globales
-            self._nodo_i.grados_libertad['x'].fuerza -= -self._s * v_corrector
-            self._fuerzas_i_rot[0, 0] -= -self._s * v_corrector
-            self._nodo_i.grados_libertad['y'].fuerza -= self._c * v_corrector
-            self._fuerzas_i_rot[1, 0] -= self._c * v_corrector
-            self._nodo_i.grados_libertad['eje_z'].fuerza -= m_corrector_i
-            self._fuerzas_i_rot[2, 0] -= m_corrector_i
-
-            self._nodo_j.grados_libertad['x'].fuerza -= -self._s * -v_corrector
-            self._fuerzas_j_rot[0, 0] -= -self._s * -v_corrector
-            self._nodo_j.grados_libertad['y'].fuerza -= self._c * -v_corrector
-            self._fuerzas_j_rot[1, 0] -= self._c * -v_corrector
-
-            # La fuerza de momento en el nodo j se anula completamente.
-            self._nodo_j.grados_libertad['eje_z'].fuerza -= m_fem_j
-            self._fuerzas_j_rot[2, 0] -= m_fem_j
+            self._nodo_i.grados_libertad['x'].fuerza -= -self._s * (-q * self._L ** 2 / 12) * 3.0 / (2.0 * self._L)
+            self._fuerzas_i_rot[0, 0] -= -self._s * (-q * self._L ** 2 / 12) * 3.0 / (2.0 * self._L)
+            self._nodo_i.grados_libertad['y'].fuerza -= self._c * (-q * self._L ** 2 / 12) * 3.0 / (2.0 * self._L)
+            self._fuerzas_i_rot[1, 0] -= self._c * (-q * self._L ** 2 / 12) * 3.0 / (2.0 * self._L)
+            self._nodo_i.grados_libertad['eje_z'].fuerza -= 0.5 * (-q * self._L ** 2 / 12)
+            self._fuerzas_i_rot[2, 0] -= 0.5 * (-q * self._L ** 2 / 12)
+            self._nodo_j.grados_libertad['x'].fuerza -= -self._s * -(-q * self._L ** 2 / 12) * 3.0 / (2.0 * self._L)
+            self._fuerzas_j_rot[0, 0] -= -self._s * -(-q * self._L ** 2 / 12) * 3.0 / (2.0 * self._L)
+            self._nodo_j.grados_libertad['y'].fuerza -= self._c * -(-q * self._L ** 2 / 12) * 3.0 / (2.0 * self._L)
+            self._fuerzas_j_rot[1, 0] -= self._c * -(-q * self._L ** 2 / 12) * 3.0 / (2.0 * self._L)
+            self._nodo_j.grados_libertad['eje_z'].fuerza -= -q * self._L ** 2 / 12
+            self._fuerzas_j_rot[2, 0] -= -q * self._L ** 2 / 12
 
     def agregar_carga_trapezoidal(self, q_1: float, q_2: float):
         """Agrega una carga trapezoidalmente distribuida perpendicular al elemento.
@@ -273,25 +263,31 @@ class Marco(Elemento):
 
         # Corrección por rótula en el nodo j
         if self._nodo_j.es_rotula:
-            # Momento de empotramiento en j (a liberar)
-            m_fem_j = -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20
-            m_corrector_i = -0.5 * m_fem_j
-            v_corrector = m_fem_j * 3.0 / (2.0 * self._L)
-
-            self._nodo_i.grados_libertad['x'].fuerza -= -self._s * v_corrector
-            self._fuerzas_i_rot[0, 0] -= -self._s * v_corrector
-            self._nodo_i.grados_libertad['y'].fuerza -= self._c * v_corrector
-            self._fuerzas_i_rot[1, 0] -= self._c * v_corrector
-            self._nodo_i.grados_libertad['eje_z'].fuerza -= m_corrector_i
-            self._fuerzas_i_rot[2, 0] -= m_corrector_i
-
-            self._nodo_j.grados_libertad['x'].fuerza -= -self._s * -v_corrector
-            self._fuerzas_j_rot[0, 0] -= -self._s * -v_corrector
-            self._nodo_j.grados_libertad['y'].fuerza -= self._c * -v_corrector
-            self._fuerzas_j_rot[1, 0] -= self._c * -v_corrector
-
-            self._nodo_j.grados_libertad['eje_z'].fuerza -= m_fem_j
-            self._fuerzas_j_rot[2, 0] -= m_fem_j
+            self._nodo_i.grados_libertad['x'].fuerza -= -self._s * (-q_1 * self._L ** 2 / 12 - (
+                    q_2 - q_1) * self._L ** 2 / 20) * 3.0 / (2.0 * self._L)
+            self._fuerzas_i_rot[0, 0] -= -self._s * (
+                    -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20) * 3.0 / (
+                                                 2.0 * self._L)
+            self._nodo_i.grados_libertad['y'].fuerza -= self._c * (-q_1 * self._L ** 2 / 12 - (
+                    q_2 - q_1) * self._L ** 2 / 20) * 3.0 / (2.0 * self._L)
+            self._fuerzas_i_rot[1, 0] -= self._c * (
+                    -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20) * 3.0 / (
+                                                 2.0 * self._L)
+            self._nodo_i.grados_libertad['eje_z'].fuerza -= 0.5 * (
+                    -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20)
+            self._fuerzas_i_rot[2, 0] -= 0.5 * (-q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20)
+            self._nodo_j.grados_libertad['x'].fuerza -= -self._s * -(
+                    -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20) * 3.0 / (2.0 * self._L)
+            self._fuerzas_j_rot[0, 0] -= -self._s * -(
+                    -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20) * 3.0 / (
+                                                 2.0 * self._L)
+            self._nodo_j.grados_libertad['y'].fuerza -= self._c * -(
+                    -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20) * 3.0 / (2.0 * self._L)
+            self._fuerzas_j_rot[1, 0] -= self._c * -(
+                    -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20) * 3.0 / (
+                                                 2.0 * self._L)
+            self._nodo_j.grados_libertad['eje_z'].fuerza -= -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20
+            self._fuerzas_j_rot[2, 0] -= -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20
 
     def agregar_carga_puntual(self, p: float, a: float = None):
         """Agrega una carga puntual perpendicular al elemento a una distancia 'a'.
@@ -332,24 +328,25 @@ class Marco(Elemento):
 
         # Corrección por rótula en el nodo j
         if self._nodo_j.es_rotula:
-            m_fem_j = -p * (self._L - a) * a ** 2 / self._L ** 2
-            m_corrector_i = -0.5 * m_fem_j
-            v_corrector = m_fem_j * 3.0 / (2.0 * self._L)
-
-            self._nodo_i.grados_libertad['x'].fuerza -= -self._s * v_corrector
-            self._fuerzas_i_rot[0, 0] -= -self._s * v_corrector
-            self._nodo_i.grados_libertad['y'].fuerza -= self._c * v_corrector
-            self._fuerzas_i_rot[1, 0] -= self._c * v_corrector
-            self._nodo_i.grados_libertad['eje_z'].fuerza -= m_corrector_i
-            self._fuerzas_i_rot[2, 0] -= m_corrector_i
-
-            self._nodo_j.grados_libertad['x'].fuerza -= -self._s * -v_corrector
-            self._fuerzas_j_rot[0, 0] -= -self._s * -v_corrector
-            self._nodo_j.grados_libertad['y'].fuerza -= self._c * -v_corrector
-            self._fuerzas_j_rot[1, 0] -= self._c * -v_corrector
-
-            self._nodo_j.grados_libertad['eje_z'].fuerza -= m_fem_j
-            self._fuerzas_j_rot[2, 0] -= m_fem_j
+            self._nodo_i.grados_libertad['x'].fuerza -= -self._s * (
+                    -p * (self._L - a) * a ** 2 / self._L ** 2) * 3.0 / (
+                                                                2.0 * self._L)
+            self._fuerzas_i_rot[0, 0] -= -self._s * (-p * (self._L - a) * a ** 2 / self._L ** 2) * 3.0 / (2.0 * self._L)
+            self._nodo_i.grados_libertad['y'].fuerza -= self._c * (-p * (self._L - a) * a ** 2 / self._L ** 2) * 3.0 / (
+                    2.0 * self._L)
+            self._fuerzas_i_rot[1, 0] -= self._c * (-p * (self._L - a) * a ** 2 / self._L ** 2) * 3.0 / (2.0 * self._L)
+            self._nodo_i.grados_libertad['eje_z'].fuerza -= 0.5 * (-p * (self._L - a) * a ** 2 / self._L ** 2)
+            self._fuerzas_i_rot[2, 0] -= 0.5 * (-p * (self._L - a) * a ** 2 / self._L ** 2)
+            self._nodo_j.grados_libertad['x'].fuerza -= -self._s * -(
+                    -p * (self._L - a) * a ** 2 / self._L ** 2) * 3.0 / (2.0 * self._L)
+            self._fuerzas_j_rot[0, 0] -= -self._s * -(-p * (self._L - a) * a ** 2 / self._L ** 2) * 3.0 / (
+                    2.0 * self._L)
+            self._nodo_j.grados_libertad['y'].fuerza -= self._c * -(
+                    -p * (self._L - a) * a ** 2 / self._L ** 2) * 3.0 / (
+                                                                2.0 * self._L)
+            self._fuerzas_j_rot[1, 0] -= self._c * -(-p * (self._L - a) * a ** 2 / self._L ** 2) * 3.0 / (2.0 * self._L)
+            self._nodo_j.grados_libertad['eje_z'].fuerza -= -p * (self._L - a) * a ** 2 / self._L ** 2
+            self._fuerzas_j_rot[2, 0] -= -p * (self._L - a) * a ** 2 / self._L ** 2
 
     def agregar_momento(self, m: float, a: float = None):
         m *= -1.0
@@ -708,8 +705,8 @@ class Marco(Elemento):
         return lista_x, lista_m, lista_p
 
     def _obtener_arrays_angulos(self, n_puntos: int = 100):
-        x = sp.symbols('x', real=True)
-        f = self.ecuacion_de_giro() #TODO: Check
+        x = sp.symbols('x')
+        f = self.ecuacion_de_giro()
         x_1 = 0.0
         x_2 = self._L
         lista_x = np.linspace(x_1, x_2, n_puntos)
@@ -1054,12 +1051,11 @@ class Marco(Elemento):
             else:
                 desplazamiento = np.hstack((desplazamiento, d_i))
         b = np.array(desplazamiento).reshape(-1, 1)
-
-        # NOTA: La lógica original contenía un cálculo especial para la rotación en
-        #       la rótula, pero fue eliminada por ser conceptualmente
-        #       incorrecta en este contexto, ya que los desplazamientos deben ser
-        #       resueltos por el sistema global, no recalculados aquí.
-
+        # Si hay una rotula en el nodo derecho, se ajusta el ángulo
+        if self._nodo_j.es_rotula:
+            b[5] = (self._fuerzas_j[2] * self._L / self._E - np.matmul(np.array(
+                [[- 6 * self._I * self._s / self._L, 6 * self._I * self._c / self._L, 2 * self._I,
+                  6 * self._I * self._s / self._L, -6 * self._I * self._c / self._L]]), b[0:5, ])) / 4 / self._I
         return b
 
     def mostrar_sistema(self, reducida: bool = False):

{mnspy-0.9.14 → mnspy-0.9.16}/mnspy/ecuaciones_diferenciales_parciales/mef/viga.py

@@ -163,25 +163,14 @@ class Viga(Elemento):
         # Esto se hace aplicando un momento corrector y las fuerzas cortantes
         # correspondientes para mantener el equilibrio.
         if self._nodo_j.es_rotula:
-            # Momento de empotramiento en j (a liberar)
-            m_fem_j = -q * self._L ** 2 / 12
-            # Momento corrector para anular el momento en j
-            m_corrector = -m_fem_j
-            # Momento transferido al nodo i (carry-over)
-            m_carry_over_i = 0.5 * m_corrector
-            # Fuerzas cortantes de corrección
-            v_corrector = 1.5 * m_corrector / self._L
-
-            # Aplicar correcciones a las fuerzas nodales
-            self._nodo_i.grados_libertad['y'].fuerza += v_corrector
-            self._fuerzas_i_rot[0, 0] += v_corrector
-            self._nodo_i.grados_libertad['eje_z'].fuerza += m_carry_over_i
-            self._fuerzas_i_rot[1, 0] += m_carry_over_i
-            
-            self._nodo_j.grados_libertad['y'].fuerza -= v_corrector
-            self._fuerzas_j_rot[0, 0] -= v_corrector
-            self._nodo_j.grados_libertad['eje_z'].fuerza += m_corrector
-            self._fuerzas_j_rot[1, 0] += m_corrector
+            self._nodo_i.grados_libertad['y'].fuerza -= (-q * self._L ** 2 / 12) * 3.0 / (2.0 * self._L)
+            self._fuerzas_i_rot[0, 0] -= (-q * self._L ** 2 / 12) * 3.0 / (2.0 * self._L)
+            self._nodo_i.grados_libertad['eje_z'].fuerza -= 0.5 * (-q * self._L ** 2 / 12)
+            self._fuerzas_i_rot[1, 0] -= 0.5 * (-q * self._L ** 2 / 12)
+            self._nodo_j.grados_libertad['y'].fuerza -= -(-q * self._L ** 2 / 12) * 3.0 / (2.0 * self._L)
+            self._fuerzas_j_rot[0, 0] -= -(-q * self._L ** 2 / 12) * 3.0 / (2.0 * self._L)
+            self._nodo_j.grados_libertad['eje_z'].fuerza -= -q * self._L ** 2 / 12
+            self._fuerzas_j_rot[1, 0] -= -q * self._L ** 2 / 12
 
     def agregar_carga_trapezoidal(self, q_1: float, q_2: float):
         """Agrega una carga trapezoidalmente distribuida."""
@@ -199,20 +188,19 @@ class Viga(Elemento):
 
         # Corrección por rótula en el nodo j
         if self._nodo_j.es_rotula:
-            m_fem_j = -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20
-            m_corrector = -m_fem_j
-            m_carry_over_i = 0.5 * m_corrector
-            v_corrector = 1.5 * m_corrector / self._L
-
-            self._nodo_i.grados_libertad['y'].fuerza += v_corrector
-            self._fuerzas_i_rot[0, 0] += v_corrector
-            self._nodo_i.grados_libertad['eje_z'].fuerza += m_carry_over_i
-            self._fuerzas_i_rot[1, 0] += m_carry_over_i
-
-            self._nodo_j.grados_libertad['y'].fuerza -= v_corrector
-            self._fuerzas_j_rot[0, 0] -= v_corrector
-            self._nodo_j.grados_libertad['eje_z'].fuerza += m_corrector
-            self._fuerzas_j_rot[1, 0] += m_corrector
+            self._nodo_i.grados_libertad['y'].fuerza -= (-q_1 * self._L ** 2 / 12 - (
+                    q_2 - q_1) * self._L ** 2 / 20) * 3.0 / (2.0 * self._L)
+            self._fuerzas_i_rot[0, 0] -= (-q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20) * 3.0 / (
+                    2.0 * self._L)
+            self._nodo_i.grados_libertad['eje_z'].fuerza -= 0.5 * (
+                    -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20)
+            self._fuerzas_i_rot[1, 0] -= 0.5 * (-q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20)
+            self._nodo_j.grados_libertad['y'].fuerza -= -(
+                    -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20) * 3.0 / (2.0 * self._L)
+            self._fuerzas_j_rot[0, 0] -= -(-q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20) * 3.0 / (
+                    2.0 * self._L)
+            self._nodo_j.grados_libertad['eje_z'].fuerza -= -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20
+            self._fuerzas_j_rot[1, 0] -= -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20
 
     def agregar_carga_puntual(self, p: float, a: float = None):
         """Agrega una carga puntual perpendicular a una distancia 'a'."""
@@ -232,20 +220,16 @@ class Viga(Elemento):
 
         # Corrección por rótula en el nodo j
         if self._nodo_j.es_rotula:
-            m_fem_j = -p * (self._L - a) * a ** 2 / self._L ** 2
-            m_corrector = -m_fem_j
-            m_carry_over_i = 0.5 * m_corrector
-            v_corrector = 1.5 * m_corrector / self._L
-
-            self._nodo_i.grados_libertad['y'].fuerza += v_corrector
-            self._fuerzas_i_rot[0, 0] += v_corrector
-            self._nodo_i.grados_libertad['eje_z'].fuerza += m_carry_over_i
-            self._fuerzas_i_rot[1, 0] += m_carry_over_i
-            
-            self._nodo_j.grados_libertad['y'].fuerza -= v_corrector
-            self._fuerzas_j_rot[0, 0] -= v_corrector
-            self._nodo_j.grados_libertad['eje_z'].fuerza += m_corrector
-            self._fuerzas_j_rot[1, 0] += m_corrector
+            self._nodo_i.grados_libertad['y'].fuerza -= (-p * (self._L - a) * a ** 2 / self._L ** 2) * 3.0 / (
+                    2.0 * self._L)
+            self._fuerzas_i_rot[0, 0] -= (-p * (self._L - a) * a ** 2 / self._L ** 2) * 3.0 / (2.0 * self._L)
+            self._nodo_i.grados_libertad['eje_z'].fuerza -= 0.5 * (-p * (self._L - a) * a ** 2 / self._L ** 2)
+            self._fuerzas_i_rot[1, 0] -= 0.5 * (-p * (self._L - a) * a ** 2 / self._L ** 2)
+            self._nodo_j.grados_libertad['y'].fuerza -= -(-p * (self._L - a) * a ** 2 / self._L ** 2) * 3.0 / (
+                    2.0 * self._L)
+            self._fuerzas_j_rot[0, 0] -= -(-p * (self._L - a) * a ** 2 / self._L ** 2) * 3.0 / (2.0 * self._L)
+            self._nodo_j.grados_libertad['eje_z'].fuerza -= -p * (self._L - a) * a ** 2 / self._L ** 2
+            self._fuerzas_j_rot[1, 0] -= -p * (self._L - a) * a ** 2 / self._L ** 2
 
     def agregar_momento(self, m: float, a: float = None):
         """Agrega un momento concentrado a una distancia 'a'."""
@@ -266,20 +250,16 @@ class Viga(Elemento):
 
         # Corrección por rótula en el nodo j
         if self._nodo_j.es_rotula:
-            m_fem_j = m * a * (2 * self._L - 3 * a) / self._L ** 2
-            m_corrector = -m_fem_j
-            m_carry_over_i = 0.5 * m_corrector
-            v_corrector = 1.5 * m_corrector / self._L
-            
-            self._nodo_i.grados_libertad['y'].fuerza += v_corrector
-            self._fuerzas_i_rot[0, 0] += v_corrector
-            self._nodo_i.grados_libertad['eje_z'].fuerza += m_carry_over_i
-            self._fuerzas_i_rot[1, 0] += m_carry_over_i
-            
-            self._nodo_j.grados_libertad['y'].fuerza -= v_corrector
-            self._fuerzas_j_rot[0, 0] -= v_corrector
-            self._nodo_j.grados_libertad['eje_z'].fuerza += m_corrector
-            self._fuerzas_j_rot[1, 0] += m_corrector
+            self._nodo_i.grados_libertad['y'].fuerza -= (m * a * (2 * self._L - 3 * a) / self._L ** 2) * 3.0 / (
+                    2.0 * self._L)
+            self._fuerzas_i_rot[0, 0] -= (m * a * (2 * self._L - 3 * a) / self._L ** 2) * 3.0 / (2.0 * self._L)
+            self._nodo_i.grados_libertad['eje_z'].fuerza -= 0.5 * (m * a * (2 * self._L - 3 * a) / self._L ** 2)
+            self._fuerzas_i_rot[1, 0] -= 0.5 * (m * a * (2 * self._L - 3 * a) / self._L ** 2)
+            self._nodo_j.grados_libertad['y'].fuerza -= -(m * a * (2 * self._L - 3 * a) / self._L ** 2) * 3.0 / (
+                    2.0 * self._L)
+            self._fuerzas_j_rot[0, 0] -= -(m * a * (2 * self._L - 3 * a) / self._L ** 2) * 3.0 / (2.0 * self._L)
+            self._nodo_j.grados_libertad['eje_z'].fuerza -= m * a * (2 * self._L - 3 * a) / self._L ** 2
+            self._fuerzas_j_rot[1, 0] -= m * a * (2 * self._L - 3 * a) / self._L ** 2
 
     def agregar_carga_triangular_descendente(self, q: float):
         """Agrega una carga triangular con valor máximo en el nodo i."""
@@ -296,15 +276,14 @@ class Viga(Elemento):
 
         # Corrección por rótula en el nodo j
         if self._nodo_j.es_rotula:
-            m_fem_j = -q * self._L ** 2 / 30
-            m_corrector = -m_fem_j
-            m_carry_over_i = 0.5 * m_corrector
-            v_corrector = 1.5 * m_corrector / self._L
-            
-            self._nodo_i.grados_libertad['y'].fuerza += v_corrector
-            self._fuerzas_i_rot[0, 0] += v_corrector
-            self._nodo_i.grados_libertad['eje_z'].fuerza += m_carry_over_i
-            self._fuerzas_i_rot[1, 0] += m_carry_over_i
+            self._nodo_i.grados_libertad['y'].fuerza -= (-q * self._L ** 2 / 30) * 3.0 / (2.0 * self._L)
+            self._fuerzas_i_rot[0, 0] -= (-q * self._L ** 2 / 30) * 3.0 / (2.0 * self._L)
+            self._nodo_i.grados_libertad['eje_z'].fuerza -= 0.5 * (-q * self._L ** 2 / 30)
+            self._fuerzas_i_rot[1, 0] -= 0.5 * (-q * self._L ** 2 / 30)
+            self._nodo_j.grados_libertad['y'].fuerza -= -(-q * self._L ** 2 / 30) * 3.0 / (2.0 * self._L)
+            self._fuerzas_j_rot[0, 0] -= -(-q * self._L ** 2 / 30) * 3.0 / (2.0 * self._L)
+            self._nodo_j.grados_libertad['eje_z'].fuerza -= -q * self._L ** 2 / 30
+            self._fuerzas_j_rot[1, 0] -= -q * self._L ** 2 / 30
 
     def agregar_carga_triangular_ascendente(self, q: float):
         """Agrega una carga triangular con valor máximo en el nodo j."""
@@ -321,15 +300,14 @@ class Viga(Elemento):
 
         # Corrección por rótula en el nodo j
         if self._nodo_j.es_rotula:
-            m_fem_j = -q * self._L ** 2 / 20
-            m_corrector = -m_fem_j
-            m_carry_over_i = 0.5 * m_corrector
-            v_corrector = 1.5 * m_corrector / self._L
-            
-            self._nodo_i.grados_libertad['y'].fuerza += v_corrector
-            self._fuerzas_i_rot[0, 0] += v_corrector
-            self._nodo_i.grados_libertad['eje_z'].fuerza += m_carry_over_i
-            self._fuerzas_i_rot[1, 0] += m_carry_over_i
+            self._nodo_i.grados_libertad['y'].fuerza -= (-q * self._L ** 2 / 20) * 3.0 / (2.0 * self._L)
+            self._fuerzas_i_rot[0, 0] -= (-q * self._L ** 2 / 20) * 3.0 / (2.0 * self._L)
+            self._nodo_i.grados_libertad['eje_z'].fuerza -= 0.5 * (-q * self._L ** 2 / 20)
+            self._fuerzas_i_rot[1, 0] -= 0.5 * (-q * self._L ** 2 / 20)
+            self._nodo_j.grados_libertad['y'].fuerza -= -(-q * self._L ** 2 / 20) * 3.0 / (2.0 * self._L)
+            self._fuerzas_j_rot[0, 0] -= -(-q * self._L ** 2 / 20) * 3.0 / (2.0 * self._L)
+            self._nodo_j.grados_libertad['eje_z'].fuerza -= -q * self._L ** 2 / 20
+            self._fuerzas_j_rot[1, 0] -= -q * self._L ** 2 / 20
 
     def _obtener_cargas(self) -> dict:
         return self._cargas
@@ -720,11 +698,10 @@ class Viga(Elemento):
             else:
                 desplazamiento = np.hstack((desplazamiento, d_i))
         b = np.array(desplazamiento).reshape(-1, 1)
-
-        # NOTA: La lógica original contenía un cálculo especial para la rotación en
-        #       la rótula, pero fue eliminada por ser conceptualmente
-        #       incorrecta. Los desplazamientos nodales son resueltos por el
-        #       sistema global y esta función solo debe recolectarlos.
+        # Si hay una rotula en el nodo derecho, se ajusta el ángulo
+        if self._nodo_j.es_rotula:
+            b[3] = (self._fuerzas_j[1] * self._L ** 3 / self._E / self._I - np.matmul(np.array(
+                [[6 * self._L, 2 * self._L ** 2, - 6 * self._L]]), b[0:3, ])) / 4 / self._L ** 2
         return b
 
     def __obtener_path_elemento(self, espesor: float) -> Path:

{mnspy-0.9.14 → mnspy-0.9.16}/mnspy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mnspy
-Version: 0.9.14
+Version: 0.9.16
 Summary: Paquete didáctico para métodos numéricos
 Home-page: https://github.com/EdwinSoft/mnspy
 Author: Edwin Córdoba

{mnspy-0.9.14 → mnspy-0.9.16}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup
 
 setup(
     name='mnspy',
-    version='0.9.14',
+    version='0.9.16',
     packages=['mnspy', 'mnspy.raíces', 'mnspy.derivada', 'mnspy.integrales', 'mnspy.interpolación',
               'mnspy.ecuaciones_algebraicas_lineales', 'mnspy.ecuaciones_diferenciales_ordinarias',
               'mnspy.ecuaciones_diferenciales_parciales', 'mnspy.ecuaciones_diferenciales_parciales.mdf',