ourocode 1.7.2__tar.gz → 1.7.4__tar.gz

{ourocode-1.7.2/ourocode.egg-info → ourocode-1.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ourocode
-Version: 1.7.2
+Version: 1.7.4
 Summary: Ceci est un catalogue de fonction permettant une utilisation rapide pour la réalisation de note de calcul personnalisée.
 Author-email: Anthony PARISOT <contact@ourea-structure.fr>
 License-Expression: Apache-2.0

ourocode-1.7.4/ourocode/__version__.py

@@ -0,0 +1 @@
+__version__ = "1.7.4"

{ourocode-1.7.2 → ourocode-1.7.4}/ourocode/eurocode/EC1_Vent.py

@@ -252,12 +252,14 @@ class Vent(Batiment):
                     @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
                     def val():
                         C0_z = 1 + 0.004 * Delta_A_C * mt.exp(z - 10)
-                        return C0_z
+                        res = max(C0_z, 1)
+                        return res
                 else:
                     @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
                     def val():
                         C0_z = 1 + 0.004 * Delta_A_C * mt.exp(0)
-                        return C0_z
+                        res = max(C0_z, 1)
+                        return res
 
             case "2":
                 raise ValueError("Erreur la catégorie orographique 2 n'est pas encore implémentée")

{ourocode-1.7.2 → ourocode-1.7.4}/ourocode/eurocode/EC3_Assemblage.py

@@ -175,22 +175,27 @@ class Tige(Element):
         return self.taux_bl
     
     
-    def Bp_Rd(self, d_ecrou: int, d_head_bl: int, *args):
+    def Bp_Rd(self, d_ecrou: int, d_head_bl: int):
         """Retourne la résistance au poinçonnement de la plaque en N
 
         Args:
             d_ecrou (int): diamètre extérieur de l'écrou en mm
             d_head_bl (int): diamètre de la tête de boulon en mm
-            tp, i (int, args): épaisseur des plaques dans l'assemblage, sinon récupère le t de la classe Element
 
         Returns:
             float: résistance de calcul en N
         """
         d_ecrou = d_ecrou * si.mm
         d_head_bl = d_head_bl * si.mm
-        dm = (d_ecrou + d_head_bl) / 2
-        tp = min(self.t.value*10**3, *args) * si.mm
-        return (0.6 * pi * dm * tp * self.fu) / __class__.GAMMA_M["gamma_M2"]
+        d_m = (d_ecrou + d_head_bl) / 2
+        t_p = self.t
+        gamma_M2 = self.GAMMA_M["gamma_M2"]
+        f_u = self.fu
+        @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\[", right="\]")
+        def val():
+            B_p_Rd = (0.6 * pi * d_m * t_p * f_u) / gamma_M2
+            return B_p_Rd
+        return val()
 
     
     def Fb_Rd(self, e1: float ,e2: float , p1: float, p2: float):
@@ -218,7 +223,7 @@ class Tige(Element):
         d_0 = self.d0
         d = self.d
         t = self.t
-        gamma_M_2 = __class__.GAMMA_M["gamma_M2"]
+        gamma_M_2 = self.GAMMA_M["gamma_M2"]
 
         @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\[", right="\]")
         def val():
@@ -246,7 +251,7 @@ class Tige(Element):
         f_y = self.fy
         f_u = self.fu
         k_ex = 1
-        gamma_M_2 = __class__.GAMMA_M["gamma_M2"]
+        gamma_M_2 = self.GAMMA_M["gamma_M2"]
 
         if effort == "Excentré":
             k_ex = 0.5
@@ -369,7 +374,16 @@ class Soudure(Element):
             N_Ed (float): Effort de traction en kN.
         """
         N_Ed = N_Ed * si.kN
-        return (self.beta_w * self.GAMMA_M["gamma_M2"] * (N_Ed * sqrt(2)) / self.fu) / (self.gorge * self.lef)
+        gamma_M_2 = self.GAMMA_M["gamma_M2"]
+        beta_w = self.beta_w
+        a = self.gorge
+        l_ef = self.lef
+        fu = self.fu
+        @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\[", right="\]")
+        def val():
+            cordon_frontal = (beta_w * gamma_M_2 * (N_Ed * sqrt(2)) / fu) / (a * l_ef)
+            return cordon_frontal
+        return val()
 
 
     def cordon_laterale(self, V_Ed: float):
@@ -379,7 +393,16 @@ class Soudure(Element):
             V_Ed (float): Effort de cisaillement du cordon en kN.
         """
         V_Ed = V_Ed * si.kN
-        return (self.beta_w * self.GAMMA_M["gamma_M2"] * (V_Ed * sqrt(3)) / self.fu) / (self.gorge * self.lef)
+        gamma_M_2 = self.GAMMA_M["gamma_M2"]
+        beta_w = self.beta_w
+        a = self.gorge
+        l_ef = self.lef
+        fu = self.fu
+        @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\[", right="\]")
+        def val():
+            cordon_laterale = (beta_w * gamma_M_2 * (V_Ed * sqrt(3)) / fu) / (a * l_ef)
+            return cordon_laterale
+        return val()
 
 
     def cordon_oblique(self, alpha_cordon: float, N_Ed: float):
@@ -390,7 +413,16 @@ class Soudure(Element):
         """
         self.alpha_cordon = alpha_cordon
         N_Ed = N_Ed * si.kN
-        return (self.beta_w * self.GAMMA_M["gamma_M2"] * (N_Ed * sqrt(3 - sin(radians(self.alpha_cordon))**2)) / self.fu) / (self.gorge * self.lef)
+        gamma_M_2 = self.GAMMA_M["gamma_M2"]
+        beta_w = self.beta_w
+        a = self.gorge
+        l_ef = self.lef
+        fu = self.fu
+        @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\[", right="\]")
+        def val():
+            cordon_oblique = (beta_w * gamma_M_2 * (N_Ed * sqrt(3 - sin(radians(self.alpha_cordon))**2)) / fu) / (a * l_ef)
+            return cordon_oblique
+        return val()
 
 
     def cordon_pieces_obliques(self, N_Ed: float):
@@ -400,10 +432,19 @@ class Soudure(Element):
             N_Ed (float): Effort de traction en kN.
         """
         N_Ed = N_Ed * si.kN
-        if self.alpha < 90:
-            return (self.beta_w * self.GAMMA_M["gamma_M2"] * (N_Ed * sqrt(2 - sin(radians(self.alpha)))) / self.fu) / (self.gorge * self.lef)
-        elif self.alpha > 90:
-            return (self.beta_w * self.GAMMA_M["gamma_M2"] * (N_Ed * sqrt(2 + sin(radians(self.alpha)))) / self.fu) / (self.gorge * self.lef)
+        gamma_M_2 = self.GAMMA_M["gamma_M2"]
+        beta_w = self.beta_w
+        a = self.gorge
+        l_ef = self.lef
+        fu = self.fu
+        @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\[", right="\]")
+        def val():
+            if self.alpha < 90:
+                cordon_pieces_obliques = (beta_w * gamma_M_2 * (N_Ed * sqrt(2 - sin(radians(self.alpha)))) / fu) / (a * l_ef)
+            elif self.alpha > 90:
+                cordon_pieces_obliques = (beta_w * gamma_M_2 * (N_Ed * sqrt(2 + sin(radians(self.alpha)))) / fu) / (a * l_ef)
+            return cordon_pieces_obliques
+        return val()
 
 
     def critere_generale(self, FvEd: float, FaxEd: float):
@@ -430,7 +471,7 @@ class Soudure(Element):
     
 
     def soudure_discontinue(self, b: int, b1: int, t1: int, corrosion: bool=("False", "True")):
-        """_summary_
+        """Détermine les dimensions des cordons de soudure discontinue
 
         Args:
             b (int): voir EC3 1-8
@@ -440,7 +481,7 @@ class Soudure(Element):
             corrosion (bool, optional): _description_. Defaults to False.
 
         Returns:
-            _type_: _description_
+            dict: dimensions des cordons de soudure discontinue
         """
         if corrosion:
             print("Il n'est pas possible d'avoir une soudure discontinue en ambiance corrosive")

{ourocode-1.7.2 → ourocode-1.7.4}/ourocode/eurocode/EC5_Assemblage.py

@@ -311,9 +311,19 @@ class Assemblage(Projet):
             
         return (calcul[0] + calcul2[0], calcul2[1])
 
+    def _type_plaque(self):
+        if self.t <= 0.5 * self.d:
+            self.type_plaque = "mince"
+
+        elif self.d <= self.t:
+            self.type_plaque = "epaisse"
+            
+        else:
+            self.type_plaque = "intermédiaire"
+        return self.type_plaque
 
     # 8.2.3 Assemblage bois métal
-    def _FvRk_BoisMetal(self, effet_corde: bool):
+    def _FvRk_BoisMetal(self, effet_corde: bool, test_type_plaque:bool=True):
         """Calcul la capacité résistante en cisaillement de la tige en N par plan de cisaillement avec
             t1 : valeur minimale entre epaisseur de l'élément bois latéral et la profondeur de pénétration en mm
             t2 : epaisseur de l'élément bois central en mm
@@ -338,16 +348,29 @@ class Assemblage(Projet):
             self.t = self.beam_2.t
             if self.nCis == 2:
                 self.pos_plaq = "centrale"
-            
-        if self.t <= 0.5 * self.d:
-            self.type_plaque = "mince"
 
-        elif self.d <= self.t:
+        # On détecte le type de plaque
+        if test_type_plaque:
+            self._type_plaque()
+
+        # Si la plaque est intermédiaire, alors on fait une interpolation linéaire entre la valeur critique d'une plaque mince et d'une plaque epaisse
+        if self.type_plaque == "intermédiaire":
+            t = self.t
+            t_mince = 0.5 * self.d
+            t_epaisse = self.d
+            self.type_plaque = "mince"
+            FvRk_mince = self._FvRk_BoisMetal(effet_corde,test_type_plaque=False)
+            F_v_Rk_mince = FvRk_mince[1][0]
             self.type_plaque = "epaisse"
-            
-        else:
+            FvRk_epaisse = self._FvRk_BoisMetal(effet_corde,test_type_plaque=False)
+            F_v_Rk_epaisse = FvRk_epaisse[1][0]
             self.type_plaque = "intermédiaire"
-            print("ATTENTION interpolation linéaire à faire ! EC5-8.2.3.1")
+            @handcalc(override="long", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
+            def val():
+                F_v_Rk_inter = F_v_Rk_mince + (t - t_mince) * ((F_v_Rk_epaisse - F_v_Rk_mince)/(t_epaisse - t_mince))  # interpolation entre plaque mince et épaisse
+                return F_v_Rk_inter
+            FvRk_inter = val()
+            return (FvRk_mince[0] + FvRk_epaisse[0] + FvRk_inter[0], (FvRk_inter[1], (FvRk_mince[1][1], FvRk_epaisse[1][1])))
 
         if self.type_plaque == "mince" and self.nCis == 1:
             if self._type_beam[0] == "Métal":
@@ -618,46 +641,59 @@ class Assemblage(Projet):
         latex = L_net_value[0]
         L_net_v, L_net_t = L_net_value[1]
 
+        if not isinstance(mode_rupture, (list, tuple)):
+            mode_rupture = [mode_rupture]
+
+        def _Anet_v(mode: str):
+            """ détermine la surface Anet_v en fonction du mode de rupture """
+            if mode in ("C", "F", "J", "L", "K", "M"):
+                @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
+                def a_net_v():
+                    A_net_v = L_net_v * (t_1 * K_cr)
+                    return A_net_v
+                a_net_v_result = a_net_v()
+                return a_net_v_result
+            else:
+                @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
+                def a_net_v(t_ef):
+                    A_net_v = L_net_v / 2 * (L_net_t + 2 * (t_ef * K_cr))
+                    return A_net_v
+                
+                match mode:
+                    case "A":
+                        @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
+                        def tef():
+                            t_ef = 0.4*t_1 # Épaisseur efficace
+                            return t_ef
+                    case "B":
+                        @handcalc(override="long", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
+                        def tef():
+                            t_ef = 1.4 * sqrt(M_y_Rk / (f_hk * diam)) # Épaisseur efficace
+                            return t_ef
+                    case "D"|"G":
+                        @handcalc(override="long", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
+                        def tef():
+                            t_ef = t_1 * (sqrt(2 + (4 * M_y_Rk ) / (f_hk * diam * t_1**2)-1)) # Épaisseur efficace
+                            return t_ef
+                    case "E"|"H":
+                        @handcalc(override="long", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
+                        def tef():
+                            t_ef = 2 * sqrt(M_y_Rk / (f_hk * diam)) # Épaisseur efficace
+                            return t_ef
+                tef_result = tef()
+                a_net_v_result = a_net_v(tef_result[1])
+                a_net_v_result = (tef_result[0] + a_net_v_result[0], a_net_v_result[1])
+                return a_net_v_result
+
+        list_A_net_v = []
+        for mode in mode_rupture:
+            a_net_v = _Anet_v(mode)
+            list_A_net_v.append(a_net_v)
         
-        if mode_rupture in ("C", "F", "J", "L", "K", "M"):
-            @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
-            def a_net_v():
-                A_net_v = L_net_v * (t_1 * K_cr)
-                return A_net_v
-            a_net_v_result = a_net_v()
-            latex = latex + a_net_v_result[0]
-            A_net_v = a_net_v_result[1]
-        else:
-            @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
-            def a_net_v(t_ef):
-                A_net_v = L_net_v / 2 * (L_net_t + 2 * (t_ef * K_cr))
-                return A_net_v
-            
-            match mode_rupture:
-                case "A":
-                    @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
-                    def tef():
-                        t_ef = 0.4*t_1 # Épaisseur efficace
-                        return t_ef
-                case "B":
-                    @handcalc(override="long", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
-                    def tef():
-                        t_ef = 1.4 * sqrt(M_y_Rk / (f_hk * diam)) # Épaisseur efficace
-                        return t_ef
-                case "D"|"G":
-                    @handcalc(override="long", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
-                    def tef():
-                        t_ef = t_1 * (sqrt(2 + (4 * M_y_Rk ) / (f_hk * diam * t_1**2)-1)) # Épaisseur efficace
-                        return t_ef
-                case "E"|"H":
-                    @handcalc(override="long", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
-                    def tef():
-                        t_ef = 2 * sqrt(M_y_Rk / (f_hk * diam)) # Épaisseur efficace
-                        return t_ef
-            tef_result = tef()
-            a_net_v_result = a_net_v(tef_result[1])
-            latex = latex + tef_result[0] + a_net_v_result[0]
-            A_net_v = a_net_v_result[1]
+        a_net_v_result = min(list_A_net_v, key=lambda x: x[1])
+
+        latex = latex + a_net_v_result[0]    
+        A_net_v = a_net_v_result[1]
 
         @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
         def f_bs_Rk():
@@ -669,7 +705,7 @@ class Assemblage(Projet):
         self.F_bs_Rk = result[1]
         return (latex + result[0], self.F_bs_Rk)
     
-    def taux_cisaillement(self, Fv_Ed: si.kN, Fax_Ed: si.kN=0, loadtype=Barre.LOAD_TIME):
+    def taux_cisaillement(self, Fv_Ed: si.kN=0, Fax_Ed: si.kN=0, loadtype=Barre.LOAD_TIME):
         """Détermine le taux de cisaillement ou du chargement combiné de l'assemblage
 
         Args:
@@ -1492,8 +1528,11 @@ class Boulon(Assemblage):
 
         if self._type_beam[0] == "Métal":
             FtRd = Tige(self.d.value*10**3, d_int, self.qualite, True, filetage_EN1090, t=self.beam_1.t.value*10**3, h=self.beam_1.h.value*10**3, classe_acier=self.beam_1.classe_acier, classe_transv=self.beam_1.classe_transv).FtRd
-            d_ext = min(self.beam_1.t*12, 4*self.d)
             fc_90_k = float(self.beam_2.caract_meca.loc["fc90k"]) * si.MPa
+            if self.nCis == 1:
+                d_ext = min(self.beam_1.t*12, 4*self.d, d_ext)
+            else:
+                d_ext = min(self.beam_1.t*12, 4*self.d)
         else:
             FtRd = Tige(self.d.value*10**3, d_int, self.qualite, True, filetage_EN1090, t=0, h=0, classe_acier="S235", classe_transv=3).FtRd
             fc_90_k = float(self.beam_1.caract_meca.loc["fc90k"]) * si.MPa
@@ -1569,7 +1608,7 @@ class Broche(Boulon):
 
 
 class _Tirefond(object):
-    def __init__(self, d:si.mm, d1:si.mm, ds:si.mm, dh:si.mm, l:si.mm, n, rho_a:float, fhead:float, ftensk:float, MyRk:float=0, alpha1: float=0, alpha2: float=0, percage: bool=("False", "True"), **kwargs):
+    def __init__(self, d:si.mm, d1:si.mm, ds:si.mm, dh:si.mm, l:si.mm, n: int, rho_a:float, fhead:float, ftensk:float, MyRk:float=0, alpha1: float=0, alpha2: float=0, percage: bool=("False", "True"), **kwargs):
         """Défini un object tirefond
 
         Args:
@@ -1717,7 +1756,7 @@ class _Tirefond(object):
         else:
             @handcalc(override="long", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
             def val():
-                F_head_Rk = mt.inf * si.kN #l'élément 1 est métallique donc infini pour ce calcul
+                F_head_Rk = 10**6 * si.kN #l'élément 1 est métallique donc infini pour ce calcul
                 return F_head_Rk
         return val()
     
@@ -1818,7 +1857,7 @@ class Tirefond_inf_7(_Tirefond, Pointe):
 
 
 class Tirefond_sup_6(_Tirefond, Boulon):
-    def __init__(self, d:si.mm, d1:float, ds:float, dh:float, l:si.mm, n, rho_a:float, fhead:float, ftensk:float, MyRk:float=0, alpha1: float=0, alpha2: float=0, **kwargs):
+    def __init__(self, d:si.mm, d1:float, ds:float, dh:float, l:si.mm, n: int, rho_a:float, fhead:float, ftensk:float, MyRk:float=0, alpha1: float=0, alpha2: float=0, **kwargs):
         """
         Crée une classe Tirefond_sup_6 pour les tirefonds avec un diamètre efficace supérieur à 6mm
         Cette classe hérite de la classe Assemblage du module EC5_Assemblage.py.

{ourocode-1.7.2 → ourocode-1.7.4}/ourocode/eurocode/EC5_CVT.py

@@ -25,15 +25,23 @@ class MOB(Batiment):
         Cette classe est hérité de la classe Batiment, provenant du module A0_Projet.py.
 
 
+
         Un système de mur à ossature bois est composé de plusieurs murs servant aux contreventements, 
         ces murs sont intérompus par les portes et fenêtres. Ces murs sont eux même composés de plusieurs panneaux.
 
-        Il convient donc d'ajouter une classe MOB puis d'ajouter via la méthode "add_wall" chaque système de mur. 
-        Ensuite d'ajouter les murs internes au système de mur via la méthode "add_internal_wall", puis d'ajouter ensuite les panneaux
+        Il convient donc d'ajouter une classe MOB puis d'ajouter via la méthode "add_sys_wall" chaque système de mur. 
+        Ensuite d'ajouter les murs internes au système de mur via la méthode "add_wall_to_sys", puis d'ajouter ensuite les panneaux
         à chaque murs via la méthode "add_panel_to_wall".
-
         Une méthode plus efficace consiste à écrire dans un fichier JSON les informations pour chaque système de mur, 
-        puis d'utiliser la méthode "load_data" pour charger les informations.
+        puis d'utiliser la méthode "load_walls_data" pour charger les informations.
+
+        Ensuite on peu utiliser la méthode "calculate_loads_and_deformations" pour calculer les efforts de contreventements et les déformations,
+        suivant le centre de gravité et la raideur des systèmes de mur. 
+        Sinon on peux donner directement les efforts Fv_Ed_ELS et Fv_Ed_ELU par système de mur dans la méthode "add_sys_wall".
+
+        Enfin on utilise les méthodes "taux_walls" et "taux_ancrage" pour récupérer les taux de contreventements et les taux d'ancrage.
+        Attention cette classe ne calcule pas les montants bois notamment au flambement, ni la compression perpendiculaire des montants sur la lisse basse.
+        Pour réaliser ces calculs, il faut utiliser la classe Barre et les classes de vérification associées du module EC5_Element_droit.py
 
         Args:
             connecteurs_int (Agrafe, Pointe, optional): Objet Agrafe ou Pointe, représentant les connecteurs intérieurs du mur à ossature bois provenant du module EC5_Assemblage.py.
@@ -103,11 +111,11 @@ class MOB(Batiment):
         alpha_Fw_rad = radians(alpha_Fw)
         Ks = self.get_Kser_wall()
         sys_walls_names = self._get_all_sys_walls_names()
+        df_sw = pd.DataFrame(index=sys_walls_names, columns=["dn_p_sw", "dn_sw", "a", "b", "c", "d", "e", "C1", "C2", "C3", "C6"])
         if not hasattr(self, "data_sys_walls_loads"):
             self.data_sys_walls_loads = pd.DataFrame(index=sys_walls_names, columns=["Étage", "delta,v,Ed,i ELS", "Fv,Ed,i ELU"])
             self.data_walls_loads = pd.DataFrame(index=self.data_walls.keys(), columns=["Étage", "Fv,Ed,i ELU", "Ft,Ed,i ELU (soulèvement)"])
             self.data_panels_loads = pd.DataFrame(index=self.data_panels.keys(), columns=["Étage", "Fv,Ed,i ELU"])
-            df_sw = pd.DataFrame(index=sys_walls_names, columns=["dn_p_sw", "dn_sw", "a", "b", "c", "d", "e", "C1", "C2", "C3", "C6"])
 
         for etage_data, sys in self.data.items():
             if etage_data != etage:
@@ -608,12 +616,10 @@ class MOB(Batiment):
                         k_wall[1] = k_wall[1] + panel['Nombre'] * self.data_Kser_panels.loc[panel_name]['Kser,p unit.']
                         k_wall[2] = k_wall[2] + panel['Nombre'] * self.data_Kser_panels.loc[panel_name]['Coeff. équivalence']
                         k_wall[3] = self.data_Kser_panels.loc[panel_name]['Kser,p,ref']
+                        k_sys_wall[3] = self.data_Kser_panels.loc[panel_name]['Kser,p,ref']
                     self.data_Kser_walls.loc[wall_name] = k_wall
                     k_sys_wall[1] = k_sys_wall[1] + k_wall[1]
                     k_sys_wall[2] = k_sys_wall[2] + k_wall[2]
-
-                if self.data_Kser_panels.get(panel_name):
-                    k_sys_wall[3] = self.data_Kser_panels.loc[panel_name]['Kser,p,ref']
                 self.data_Kser_sys_walls.loc[sys_name] = k_sys_wall
 
         # Trier par index (nommés 'Système de mur' et 'Mur')
@@ -788,7 +794,7 @@ class MOB(Batiment):
         Fv_Rk_anc_li = Fv_Rk_anc_li * si.kN
         e_anc_lb = e_anc_lb * si.mm
         e_anc_li = e_anc_li * si.mm
-        self.taux_ancr_walls = pd.DataFrame(columns=['Étage', 'Longueur mur', 'Ft,Ed', 'Ft,Rd', 'Taux ancrage soulèvement (%)', 'Fv,anc,Ed', 'Fv,anc,lb,Rd', 'Nbr ancr,lb', 'entraxe anc,lb',  'Taux ancr. lisse basse (%)', 'Fv,anc,li,Rd', 'Nbr ancr,li', 'entraxe anc,li', 'Taux ancr. lisse impl. (%)'])
+        self.taux_ancr_walls = pd.DataFrame(columns=['Étage', 'Longueur mur', 'Ft,Ed', 'Ft,Rd', 'Taux ancr. soulèvement (%)', 'Fv,anc,Ed', 'Fv,anc,lb,Rd', 'Nbr ancr,lb', 'entraxe anc,lb',  'Taux ancr. lisse basse (%)', 'Fv,anc,li,Rd', 'Nbr ancr,li', 'entraxe anc,li', 'Taux ancr. lisse impl. (%)'])
         
         for wall_name, wall in self.data_walls_loads.iterrows():
             if etage and wall['Étage'] != etage:

{ourocode-1.7.2 → ourocode-1.7.4/ourocode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ourocode
-Version: 1.7.2
+Version: 1.7.4
 Summary: Ceci est un catalogue de fonction permettant une utilisation rapide pour la réalisation de note de calcul personnalisée.
 Author-email: Anthony PARISOT <contact@ourea-structure.fr>
 License-Expression: Apache-2.0

{ourocode-1.7.2 → ourocode-1.7.4}/pyproject.toml

@@ -8,7 +8,7 @@ include = ["ourocode*"]
 
 [project]
 name = "ourocode"
-version = "1.7.2"
+version = "1.7.4"
 description = "Ceci est un catalogue de fonction permettant une utilisation rapide pour la réalisation de note de calcul personnalisée."
 readme = "README.md"
 authors = [{name = "Anthony PARISOT", email = "contact@ourea-structure.fr"}]

ourocode-1.7.2/ourocode/__version__.py

@@ -1 +0,0 @@
-__version__ = "1.7.2"