mnspy 0.9.14__py3-none-any.whl → 0.9.16__py3-none-any.whl

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/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.dist-info → mnspy-0.9.16.dist-info}/METADATA

@@ -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.dist-info → mnspy-0.9.16.dist-info}/RECORD

@@ -28,11 +28,11 @@ mnspy/ecuaciones_diferenciales_parciales/mef/__init__.py,sha256=-ZqVb1Pn4CGcUKL5
 mnspy/ecuaciones_diferenciales_parciales/mef/armadura.py,sha256=J0Og6NCSBLcwZCsb2_tzPdZAnUfLiSO-BZ82b86GC7Q,14761
 mnspy/ecuaciones_diferenciales_parciales/mef/barra.py,sha256=FB8dVdtRSMRAQYCjYgC8_yO8nShk8_uDBt5meHrAz9c,9867
 mnspy/ecuaciones_diferenciales_parciales/mef/ensamble.py,sha256=U6OrhxMubrmnIKkXyfTdM9UoQcAunTqRUcfxMGWtx30,105934
-mnspy/ecuaciones_diferenciales_parciales/mef/marco.py,sha256=RinUjwDG5rNH7E0K649zCi6x1k2IQ8yZqtQcZeIroaI,68983
+mnspy/ecuaciones_diferenciales_parciales/mef/marco.py,sha256=LGTZ--wfC3Bytp242aCX4iVQ4okD69tC04dIbaX8fJQ,70564
 mnspy/ecuaciones_diferenciales_parciales/mef/mef.py,sha256=SotSyqCblPRwcnzr1j0srKA60hKuPIzIWTjXSZu3nhw,43812
 mnspy/ecuaciones_diferenciales_parciales/mef/resorte.py,sha256=Jeq9bQjLfmIW0jkNA-ob6C27k5JGywZ1T9qLr4hMD0Q,13852
 mnspy/ecuaciones_diferenciales_parciales/mef/triangular_cst.py,sha256=nWK1uv9F9wpE_eelfhm1LyDiW7aMnckKf0mIcuhiY7U,12094
-mnspy/ecuaciones_diferenciales_parciales/mef/viga.py,sha256=zXRcs7oT5NEASf8y624rrXt7CZZdoS44Z-tYyZIZy4o,41511
+mnspy/ecuaciones_diferenciales_parciales/mef/viga.py,sha256=-YNv-_XJabSmvSKGUREWhjClNd9Ip0QSa8zYNASF05s,42505
 mnspy/ecuaciones_diferenciales_parciales/mvf/__init__.py,sha256=TDanegLPvu7-F5UYKEFdDXhXUeptbYDzPcD7N3Ozd8s,1369
 mnspy/ecuaciones_diferenciales_parciales/mvf/mvf.py,sha256=nthYy1DeRYHEi3E_yX4GeEbAhZAdJAkZJzPEWwjkpfg,30053
 mnspy/ecuaciones_diferenciales_parciales/mvf/volumen_finito.py,sha256=cjIenv-mMDhfPXj0uL24G0Sm9WexWAane3ni8GXvoPc,32334
@@ -63,8 +63,8 @@ mnspy/raíces/raices.py,sha256=lTjSOk84sg1VdlElmHaZSRen00zpt0jNrnFBx_SStnU,17510
 mnspy/raíces/secante.py,sha256=t8-NcN-Ki8BYrh3Cf3VUjaaRLxz6qV1v5i8johKBlZs,5220
 mnspy/raíces/secante_modificada.py,sha256=0bLgcG8K_O6Ras3vKBIQpUdDlB69tWKHbx_fE8-47SE,5105
 mnspy/raíces/wegstein.py,sha256=23HQ6QuelMNo8S8W1fzha8ozbcy_NdsjK5XLMaH-m38,5397
-mnspy-0.9.14.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-mnspy-0.9.14.dist-info/METADATA,sha256=BT2v0nnDpH7mpjAvLHBHgKauQJ7FUXL9XZUi8-TIDt0,4641
-mnspy-0.9.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mnspy-0.9.14.dist-info/top_level.txt,sha256=fbooZdZwS41I8vFuAXnn5qL4_mfc1aPt_DM60ZpvtKE,6
-mnspy-0.9.14.dist-info/RECORD,,
+mnspy-0.9.16.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+mnspy-0.9.16.dist-info/METADATA,sha256=HHpKYobl4Z5NXZj2Or0JDvX9o0m5x4CV9njoPk_LcC4,4641
+mnspy-0.9.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mnspy-0.9.16.dist-info/top_level.txt,sha256=fbooZdZwS41I8vFuAXnn5qL4_mfc1aPt_DM60ZpvtKE,6
+mnspy-0.9.16.dist-info/RECORD,,