ourocode 1.6.5__tar.gz → 1.6.6__tar.gz

{ourocode-1.6.5/ourocode.egg-info → ourocode-1.6.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ourocode
-Version: 1.6.5
+Version: 1.6.6
 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.6.6/ourocode/__version__.py

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

{ourocode-1.6.5 → ourocode-1.6.6}/ourocode/eurocode/A0_Projet.py

@@ -990,7 +990,7 @@ class Model_result(Projet):
     ):
         """Retourne un diagramme"""
         plt.clf()  # Effacer le graphique précédent
-        plt.figure(self.name, figsize=(12, 4))
+        plt.figure(self.name, figsize=(11, 4))
         plt.gcf().subplots_adjust(
             left=0.1, bottom=0.25, right=0.9, top=0.75, wspace=0, hspace=0.95
         )

{ourocode-1.6.5 → ourocode-1.6.6}/ourocode/eurocode/EC5_Element_droit.py

@@ -324,34 +324,41 @@ class Flexion(Barre):
         "Charge sur fibre tendue"
         )
 
-    def __init__(self, lo:si.mm, coeflef: float=COEF_LEF['Appuis simple'][1], pos: str=LOAD_POS, *args, **kwargs):
+    def __init__(self, 
+        lo_rel_y:si.mm, 
+        lo_rel_z:si.mm, 
+        coeflef_y: float=0.9, 
+        coeflef_z: float=0.9, 
+        pos: str=LOAD_POS, 
+        *args, **kwargs):
         """Classe permettant le calcul de la flexion d'une poutre bois selon l'EN 1995 §6.1.6, §6.2.3, §6.2.4 et §6.3.3.
         Cette classe est hérité de la classe Barre, provenant du module EC5_Element_droit.py.
 
         Args:
-            lo (int): longueur de déversemment en mm
-            coeflef (float): appuis simple :
+            lo_rel_y/z (int): longueur de déversemment autour de l'axe défini en mm
+            coeflef_y/z (float): appuis simple :
                                             Moment constant : 1
                                             Charge répartie constante : 0.9
                                             Charge concentrée au milieu de la portée : 0.8
-                            porte à faux :
+                                porte à faux :
                                             Charge répartie constante : 0.5
                                             Charge concentrée agissant à l'extrémité libre : 0.8.
-
             pos (str): positionnement de la charge sur la hauteur de poutre
         """
         super().__init__(*args, **kwargs)
-        self.lo = lo * si.mm
-        self.coeflef = coeflef
+        self.lo_rel_y = lo_rel_y* si.mm
+        self.lo_rel_z = lo_rel_z* si.mm
+        self.lo_rel = {"y": lo_rel_y, "z": lo_rel_z}
+        self.coeflef_y = coeflef_y
+        self.coeflef_z = coeflef_z
+        self.coeflef = {"y": coeflef_y, "z": coeflef_z}
         self.pos = pos
 
-
     @property
     def K_h(self):
         """ Retourne le coef. Kh qui peut augmenter la resistance caractéristique fm,k et ft,k """
         return self._K_h()
 
-
     @property
     def K_m(self):
         """ Retourne le coef. Km qui reduit les contrainte d'une poutre scié en flexion """
@@ -363,64 +370,82 @@ class Flexion(Barre):
         else:
             km = 1
         return km
-    
 
     @property
     def sigma_m_crit(self):
         """ Retourne sigma m,crit pour la prise en compte du déversement d'une poutre """
-        self.l_ef = self.lo * self.coeflef
+        self.l_ef_y = self.lo_rel_y * self.coeflef['y']
+        self.l_ef_z = self.lo_rel_z * self.coeflef['z']
         if self.pos == "Charge sur fibre comprimée":
-            self.l_ef = self.l_ef + 2 * self.h_calcul
+            self.l_ef_y = self.l_ef_y + 2 * self.h_calcul
+            self.l_ef_z = self.l_ef_z + 2 * self.h_calcul
         elif self.pos == "Charge sur fibre tendue":
-            self.l_ef = self.l_ef - 0.5 * self.h_calcul
-
+            self.l_ef_y = self.l_ef_y - 0.5 * self.h_calcul
+            self.l_ef_z = self.l_ef_z - 0.5 * self.h_calcul
+        
+        self.l_ef = {"y": self.l_ef_y, "z": self.l_ef_z}
         b_calcul = self.b_calcul
         h_calcul = self.h_calcul
-        l_ef = self.l_ef
+        l_ef_y = self.l_ef['y']
+        l_ef_z = self.l_ef['z']
         E_0_05 = int(self.caract_meca.loc['E005']) * si.MPa
         
         @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
         def val():
-            sigma_m_crit = (0.78 * b_calcul ** 2 * E_0_05) / (h_calcul * l_ef)
-            return sigma_m_crit
+            sigma_m_crit_y = (0.78 * b_calcul ** 2 * E_0_05) / (h_calcul * l_ef_y)
+            sigma_m_crit_z = (0.78 * h_calcul ** 2 * E_0_05) / (b_calcul * l_ef_z)
+            return {"y": sigma_m_crit_y, "z": sigma_m_crit_z}
         return val()
-    
 
     @property
     def lamb_rel_m(self):
         """ Retourne l'élancement relatif de la section avec pour argument """
         f_m0k = float(self.caract_meca.loc['fm0k']) *si.MPa
-        sigma_m_crit = self.sigma_m_crit[1]
+        sigma_m_crit_y = self.sigma_m_crit[1]['y']
+        sigma_m_crit_z = self.sigma_m_crit[1]['z']
 
         @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
         def val():
-            lamb_rel_m = sqrt(f_m0k / sigma_m_crit)
-            return lamb_rel_m
+            lamb_rel_m_y = sqrt(f_m0k / sigma_m_crit_y)
+            lamb_rel_m_z = sqrt(f_m0k / sigma_m_crit_z)
+            return {"y": lamb_rel_m_y, "z": lamb_rel_m_z}
         return val()
-    
 
     @property
     def K_crit(self):
         """ Retourne K,crit le coef. de minoration de la résistance en flexion au déversement"""
-        lamb_rel_m = self.lamb_rel_m[1]
-
-        if lamb_rel_m <= 0.75:
-            @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
-            def val():
-                K_crit = 1
-                return K_crit
-        elif 0.75 < lamb_rel_m <= 1.4:
-            @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
-            def val():
-                K_crit = 1.56 - 0.75 * lamb_rel_m
-                return K_crit
-        else:
-            @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
-            def val():
-                K_crit = 1 / (lamb_rel_m ** 2)
-                return K_crit
-        return val()
-    
+        lamb_rel_m_y = self.lamb_rel_m[1]['y']
+        lamb_rel_m_z = self.lamb_rel_m[1]['z']
+        result = [None, {"y": None, "z": None}]
+
+        for axe in ["y", "z"]:
+            lamb_rel_m = lamb_rel_m_y if axe == "y" else lamb_rel_m_z
+            if lamb_rel_m <= 0.75:
+                @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
+                def val():
+                    K_crit = 1
+                    axe
+                    return K_crit
+            elif 0.75 < lamb_rel_m <= 1.4:
+                @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
+                def val():
+                    K_crit = 1.56 - 0.75 * lamb_rel_m
+                    axe
+                    return K_crit
+            else:
+                @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
+                def val():
+                    K_crit = 1 / (lamb_rel_m ** 2)
+                    axe
+                    return K_crit
+            kcrit_axe = val()
+            if result[0]:
+                result[0] = result[0] + kcrit_axe[0]
+            else:
+                result[0] = kcrit_axe[0]
+            result[1][axe] = kcrit_axe[1]
+        result = (result[0], result[1])
+        return result
     
     def f_m_d(self, loadtype=Barre.LOAD_TIME, typecombi=Barre.TYPE_ACTION):
         """Retourne la résistance f,m,d de l'élément en MPa
@@ -435,35 +460,29 @@ class Flexion(Barre):
         return self._f_type_d("fm0k", loadtype, typecombi)
     
     
-    def sigma_m_d(self, M: float, axe=['y', 'z']):
+    def sigma_m_d(self, My: float, Mz: float):
         """ Retourne la contrainte sigma,m,d suivant sont axes de flexion avec :
-            M : Moment max dans la barre en kN.m
-            axe : Axe d'inertie quadratique à considérer
+            My/z : Moment autour de l'axe y et/ou z dans la barre en kN.m
         """
-        if not hasattr(self, "Md"):
-            self.Md = {'y': 0* si.kN*si.m, 'z': 0 * si.kN*si.m}
-            self.sigma_m_rd = {'y': 0 * si.MPa, 'z': 0 * si.MPa}
+        self.Md = {'y': My* si.kN*si.m, 'z': Mz * si.kN*si.m}
+        self.sigma_m_rd = {'y': 0 * si.MPa, 'z': 0 * si.MPa}
         
-        self.Md[axe] = M * si.kN*si.m
-
-        if axe == 'y':
-            I = self.inertie[0]
-            h_calcul = self.h_calcul
-        elif axe == 'z':
-            I = self.inertie[1]
-            h_calcul = self.b_calcul
-        #prend en compte une section circulaire si aucun des deux axes
-        else: 
-            I = self.inertie
+        Iy = self.inertie[0]
+        h_calcul = self.h_calcul
+        Iz = self.inertie[1]
+        b_calcul = self.b_calcul
         
-        M_d = self.Md[axe]
+        M_y = self.Md['y']
+        M_z = self.Md['z']
         
         @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
         def val():
-            sigma_m_d = M_d * h_calcul / (I * 2)
-            return sigma_m_d
+            sigma_my_d = M_y * h_calcul / (Iy * 2)
+            sigma_mz_d = M_z * b_calcul / (Iz * 2)
+            return {"y": sigma_my_d, "z": sigma_mz_d}
         value = val()
-        self.sigma_m_rd[axe] = value[1]
+        self.sigma_m_rd["y"] = value[1]["y"]
+        self.sigma_m_rd["z"] = value[1]["z"]
         return value
     
 
@@ -486,14 +505,15 @@ class Flexion(Barre):
         K_h_y = self.K_h['y']
         K_h_z = self.K_h['z']
         K_m = self.K_m
-        K_crit = self.K_crit[1]
+        K_crit_y = self.K_crit[1]["y"]
+        K_crit_z = self.K_crit[1]["z"]
 
         @handcalc(override="short", precision=3, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
         def base():
             taux_6_11 = sigma_my_d / (f_m_d * K_h_y) + K_m * sigma_mz_d / (f_m_d * K_h_z) # equ6.11
             taux_6_12 = K_m * sigma_my_d / (f_m_d * K_h_y) + sigma_mz_d / (f_m_d * K_h_z) # equ6.12
-            taux_6_33y = sigma_my_d / (f_m_d * K_h_y * K_crit) # equ6.33
-            taux_6_33z = sigma_mz_d / (f_m_d * K_h_z * K_crit) # equ6.33
+            taux_6_33y = sigma_my_d / (f_m_d * K_h_y * K_crit_y) # equ6.33
+            taux_6_33z = sigma_mz_d / (f_m_d * K_h_z * K_crit_z) # equ6.33
             return taux_6_11, taux_6_12, taux_6_33y, taux_6_33z
         
         base_val = base()

{ourocode-1.6.5 → ourocode-1.6.6}/ourocode/eurocode/EC5_Feu.py

@@ -500,91 +500,105 @@ class Feu(Barre):
 class Flexion_feu(Feu, Flexion):
     def __init__(
         self,
-        lo: si.mm,
-        coeflef: float = Flexion.COEF_LEF["Appuis simple"][1],
+        lo_rel_y:si.mm, lo_rel_z:si.mm, 
+        coeflef_y: float=0.9, 
+        coeflef_z: float=0.9,
         pos: str = Flexion.LOAD_POS,
         **kwargs,
     ):
         """Classe permettant le calcul de la flexion d'une poutre bois selon l'EN 1995 §6.1.6, §6.2.3, §6.2.4 et §6.3.3.
-        Cette classe est hérité de la classe Barre, provenant du module EC5_Element_droit.py.
+        Cette classe est hérité de la classe Feu, provenant du module EC5_Feu.py.
 
         Args:
-            lo (int): longueur de déversemment en mm
-            coeflef (float): appuis simple :
+            lo_rel_y/z (int): longueur de déversemment autour de l'axe défini en mm
+            coeflef_y/z (float): appuis simple :
                                             Moment constant : 1
                                             Charge répartie constante : 0.9
                                             Charge concentrée au milieu de la portée : 0.8
-                            porte à faux :
+                                porte à faux :
                                             Charge répartie constante : 0.5
                                             Charge concentrée agissant à l'extrémité libre : 0.8.
-
             pos (str): positionnement de la charge sur la hauteur de poutre
         """
-        super().__init__(lo=lo, coeflef=coeflef, pos=pos, **kwargs)
+        super().__init__(lo_rel_y=lo_rel_y, lo_rel_z=lo_rel_z, coeflef_y=coeflef_y, coeflef_z=coeflef_z, pos=pos, **kwargs)
 
     @property
     def sigma_m_crit(self):
-        """Retourne sigma m,crit pour la prise en compte du déversement d'une poutre"""
-        self.l_ef = self.lo * self.coeflef
+        """ Retourne sigma m,crit pour la prise en compte du déversement d'une poutre """
+        self.l_ef_y = self.lo_rel_y * self.coeflef['y']
+        self.l_ef_z = self.lo_rel_z * self.coeflef['z']
         if self.pos == "Charge sur fibre comprimée":
-            self.l_ef = self.l_ef + 2 * self.h_calcul
+            self.l_ef_y = self.l_ef_y + 2 * self.h_calcul
+            self.l_ef_z = self.l_ef_z + 2 * self.h_calcul
         elif self.pos == "Charge sur fibre tendue":
-            self.l_ef = self.l_ef - 0.5 * self.h_calcul
-
+            self.l_ef_y = self.l_ef_y - 0.5 * self.h_calcul
+            self.l_ef_z = self.l_ef_z - 0.5 * self.h_calcul
+        
+        self.l_ef = {"y": self.l_ef_y, "z": self.l_ef_z}
         b_calcul = self.b_calcul
         h_calcul = self.h_calcul
-        l_ef = self.l_ef
-        E_0_05 = int(self.caract_meca.loc["E005"]) * si.MPa
+        l_ef_y = self.l_ef['y']
+        l_ef_z = self.l_ef['z']
+        E_0_05 = int(self.caract_meca.loc['E005']) * si.MPa
         K_fi = self.K_fi
-
+        
         @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
         def val():
-            sigma_m_crit_fi = (0.78 * b_calcul**2 * E_0_05 * K_fi) / (h_calcul * l_ef)
-            return sigma_m_crit_fi
-
+            sigma_m_crit_y_fi = (0.78 * b_calcul ** 2 * E_0_05 * K_fi) / (h_calcul * l_ef_y)
+            sigma_m_crit_z_fi = (0.78 * h_calcul ** 2 * E_0_05 * K_fi) / (b_calcul * l_ef_z)
+            return {"y": sigma_m_crit_y_fi, "z": sigma_m_crit_z_fi}
         return val()
 
     @property
     def lamb_rel_m(self):
-        """Retourne l'élancement relatif de la section avec pour argument"""
-        f_m0k = float(self.caract_meca.loc["fm0k"]) * si.MPa
+        """ Retourne l'élancement relatif de la section avec pour argument """
+        f_m0k = float(self.caract_meca.loc['fm0k']) *si.MPa
+        sigma_m_crit_y_fi = self.sigma_m_crit[1]['y']
+        sigma_m_crit_z_fi = self.sigma_m_crit[1]['z']
         K_fi = self.K_fi
-        sigma_m_crit = self.sigma_m_crit[1]
 
         @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
         def val():
-            lamb_rel_m_fi = sqrt(f_m0k * K_fi / sigma_m_crit)
-            return lamb_rel_m_fi
-
+            lamb_rel_m_y_fi = sqrt(f_m0k * K_fi / sigma_m_crit_y_fi)
+            lamb_rel_m_z_fi = sqrt(f_m0k * K_fi / sigma_m_crit_z_fi)
+            return {"y": lamb_rel_m_y_fi, "z": lamb_rel_m_z_fi}
         return val()
 
     @property
     def K_crit(self):
-        """Retourne K,crit le coef. de minoration de la résistance en flexion au déversement"""
-        lamb_rel_m_fi = self.lamb_rel_m[1]
-
-        if lamb_rel_m_fi <= 0.75:
-
-            @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
-            def val():
-                K_crit_fi = 1
-                return K_crit_fi
-
-        elif 0.75 < lamb_rel_m_fi <= 1.4:
-
-            @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
-            def val():
-                K_crit_fi = 1.56 - 0.75 * lamb_rel_m_fi
-                return K_crit_fi
-
-        else:
-
-            @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
-            def val():
-                K_crit_fi = 1 / (lamb_rel_m_fi**2)
-                return K_crit_fi
-
-        return val()
+        """ Retourne K,crit le coef. de minoration de la résistance en flexion au déversement"""
+        lamb_rel_m_y = self.lamb_rel_m[1]['y']
+        lamb_rel_m_z = self.lamb_rel_m[1]['z']
+        result = [None, {"y": None, "z": None}]
+
+        for axe in ["y", "z"]:
+            lamb_rel_m_fi = lamb_rel_m_y if axe == "y" else lamb_rel_m_z
+            if lamb_rel_m_fi <= 0.75:
+                @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
+                def val():
+                    K_crit_fi = 1
+                    axe
+                    return K_crit_fi
+            elif 0.75 < lamb_rel_m_fi <= 1.4:
+                @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
+                def val():
+                    K_crit_fi = 1.56 - 0.75 * lamb_rel_m_fi
+                    axe
+                    return K_crit_fi
+            else:
+                @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
+                def val():
+                    K_crit_fi = 1 / (lamb_rel_m_fi ** 2)
+                    axe
+                    return K_crit_fi
+            kcrit_axe = val()
+            if result[0]:
+                result[0] = result[0] + kcrit_axe[0]
+            else:
+                result[0] = kcrit_axe[0]
+            result[1][axe] = kcrit_axe[1]
+        result = (result[0], result[1])
+        return result
     
     def f_m_d(self):
         """Retourne la résistance f,m,d au feu de l'élément en MPa
@@ -610,14 +624,15 @@ class Flexion_feu(Feu, Flexion):
         K_h_y = self.K_h["y"]
         K_h_z = self.K_h["z"]
         K_m = self.K_m
-        K_crit_fi = self.K_crit[1]
+        K_crit_y_fi = self.K_crit[1]["y"]
+        K_crit_z_fi = self.K_crit[1]["z"]
 
         @handcalc(override="short", precision=3, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
         def base():
             taux_6_11 = sigma_my_d_fi / (f_m_d_fi * K_h_y) + K_m * sigma_mz_d_fi / (f_m_d_fi * K_h_z)  # equ6.11
             taux_6_12 = K_m * sigma_my_d_fi / (f_m_d_fi * K_h_y) + sigma_mz_d_fi / (f_m_d_fi * K_h_z)  # equ6.12
-            taux_6_33y = sigma_my_d_fi / (f_m_d_fi * K_h_y * K_crit_fi)  # equ6.33
-            taux_6_33z = sigma_mz_d_fi / (f_m_d_fi * K_h_z * K_crit_fi)  # equ6.33
+            taux_6_33y = sigma_my_d_fi / (f_m_d_fi * K_h_y * K_crit_y_fi)  # equ6.33
+            taux_6_33z = sigma_mz_d_fi / (f_m_d_fi * K_h_z * K_crit_z_fi)  # equ6.33
             return taux_6_11, taux_6_12, taux_6_33y, taux_6_33z
 
         base_val = base()
@@ -627,7 +642,7 @@ class Flexion_feu(Feu, Flexion):
         self.taux_m_rd["equ6.33y"] = base_val[1][2]
         self.taux_m_rd["equ6.33z"] = base_val[1][3]
 
-        if compression and isinstance(compression, Compression):
+        if compression and isinstance(compression, Compression_feu):
             sigma_c_0_d = compression.sigma_c_0_rd
             f_c_0_d = compression.f_type_rd
             K_c_y = compression.kc_Axe[1]["y"]
@@ -646,14 +661,7 @@ class Flexion_feu(Feu, Flexion):
                 taux_6_35yzz = (taux_6_33y + (sigma_mz_d_fi / (f_m_d_fi * K_h_z)) ** 2 + taux_6_24)  # equ6.35 interprétation
                 taux_6_35yzy = (taux_6_33z**2 + (sigma_my_d_fi / (f_m_d_fi * K_h_y)) + taux_6_23)  # equ6.35
                 taux_6_35zyy = (taux_6_33z + (sigma_my_d_fi / (f_m_d_fi * K_h_y)) ** 2 + taux_6_23)  # equ6.35 interprétation
-                return (
-                    taux_6_19,
-                    taux_6_20,
-                    taux_6_35zyz,
-                    taux_6_35yzz,
-                    taux_6_35yzy,
-                    taux_6_35zyy,
-                )
+                return (taux_6_19, taux_6_20, taux_6_35zyz, taux_6_35yzz, taux_6_35yzy, taux_6_35zyy)
 
             compression_val = comp(
                 self.taux_m_rd["equ6.11"],
@@ -670,7 +678,7 @@ class Flexion_feu(Feu, Flexion):
             self.taux_m_rd["equ6.35yzy"] = compression_val[1][4]
             self.taux_m_rd["equ6.35zyy"] = compression_val[1][5]
 
-        if traction and isinstance(traction, Traction):
+        if traction and isinstance(traction, Traction_feu):
             taux_6_1 = traction.taux_t_0_rd["equ6.1"]
 
             @handcalc(override="short", precision=3, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
@@ -693,7 +701,7 @@ class Flexion_feu(Feu, Flexion):
 class Traction_feu(Feu, Traction):
     def __init__(self, **kwargs):
         """Classe permettant le calcul de la Traction d'un élément bois selon l'EN 1995.
-        Cette classe est hérité de la classe Barre, provenant du module EC5_Element_droit.py.
+        Cette classe est hérité de la classe Feu, provenant du module EC5_Feu.py.
         """
         super().__init__(**kwargs)
     
@@ -732,7 +740,7 @@ class Traction_feu(Feu, Traction):
 class Compression_feu(Feu, Compression):
     def __init__(self, lo_y: si.mm, lo_z: si.mm, type_appuis: str = Compression.COEF_LF, **kwargs):
         """Classe permettant le calcul de la Compression d'un élément bois selon l'EN 1995.
-        Cette classe est hérité de la classe Barre, provenant du module EC5_Element_droit.py.
+        Cette classe est hérité de la classe Feu, provenant du module EC5_Feu.py.
 
         Args:
             lo : Longueur de flambement suivant l'axe de rotation (y ou z) en mm si pas de flambement alors 0
@@ -818,7 +826,7 @@ class Compression_feu(Feu, Compression):
         K_c_y_fi = self.kc_Axe[1]["y"]
         K_c_z_fi = self.kc_Axe[1]["z"]
 
-        if flexion and isinstance(flexion, Flexion):
+        if flexion and isinstance(flexion, Flexion_feu):
             taux_6_11 = flexion.taux_m_rd["equ6.11"]
             taux_6_12 = flexion.taux_m_rd["equ6.12"]
         else:
@@ -859,7 +867,7 @@ class Compression_feu(Feu, Compression):
 class Cisaillement_feu(Cisaillement, Feu):
     def __init__(self, **kwargs):
         """Classe qui permet de calculer le cisaillement d'une poutre comme décrit à l'EN 1995 §6.1.7 et §6.5.
-        Cette classe est hérité de la classe Barre, provenant du module EC5_Element_droit.py.
+        Cette classe est hérité de la classe Feu, provenant du module EC5_Feu.py.
         """
         super().__init__(**kwargs)
 

{ourocode-1.6.5 → ourocode-1.6.6/ourocode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ourocode
-Version: 1.6.5
+Version: 1.6.6
 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.6.5 → ourocode-1.6.6}/pyproject.toml

@@ -8,7 +8,7 @@ include = ["ourocode*"]
 
 [project]
 name = "ourocode"
-version = "1.6.5"
+version = "1.6.6"
 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.6.5 → ourocode-1.6.6}/tests/test_EC5_Element_droit.py

@@ -45,9 +45,9 @@ def compression(barre, load_and_combi_data):
 @pytest.fixture
 def flexion(barre, load_and_combi_data):
     flexion = EC5.Flexion._from_parent_class(
-        barre, lo=7000, coeflef=0.8, pos="Charge sur fibre comprimée"
+        barre, lo_rel_y=7000, lo_rel_z=3500, coeflef_y=0.9, coeflef_z=0.8, pos="Charge sur fibre comprimée"
     )
-    flexion.sigma_m_d(100, axe="y")
+    flexion.sigma_m_d(100, 50)
     flexion.f_m_d(**load_and_combi_data)
     flexion.taux_m_d()
     return flexion
@@ -100,8 +100,10 @@ class Test_Flexion(object):
         self.flexion.taux_m_d(compression, traction)
 
     def test_init(self):
-        assert self.flexion.lo == 7 * si.m
-        assert self.flexion.coeflef == 0.8
+        assert self.flexion.lo_rel_y == 7 * si.m
+        assert self.flexion.lo_rel_z == 3.5 * si.m
+        assert self.flexion.coeflef_y == 0.9
+        assert self.flexion.coeflef_z == 0.8
         assert self.flexion.pos == "Charge sur fibre comprimée"
 
     def test_Kh(self):
@@ -111,30 +113,32 @@ class Test_Flexion(object):
         assert self.flexion.K_m == 0.7
 
     def test_sig_m_crit(self):
-        assert self.flexion.sigma_m_crit[1].value == 40258064.51612905
+        assert self.flexion.sigma_m_crit[1]['y'].value == 36173913.04347827
+        assert self.flexion.sigma_m_crit[1]['z'].value == 1982117647.058823
 
     def test_lamb_rel_m(self):
-        assert self.flexion.lamb_rel_m[1] == 0.7721099961494126
+        assert self.flexion.lamb_rel_m[1]['y'] == 0.8145314840210526
+        assert self.flexion.lamb_rel_m[1]['z'] == 0.1100375486289208
 
     def test_sigma_m_d(self):
         assert self.flexion.sigma_m_rd["y"].value == 66666666.66666668
-        assert self.flexion.sigma_m_rd["z"].value == 0
+        assert self.flexion.sigma_m_rd["z"].value == 99999999.99999997
 
     def test_f_m_d(self):
         assert self.flexion.f_type_rd == 16.896 * si.MPa
 
     def test_taux_m_d(self):
         assert self.flexion.taux_m_rd == {
-            "equ6.11": 3.7320951513985103,
-            "equ6.12": 2.627652689825585,
-            "equ6.33y": 3.7530932632673393,
-            "equ6.33z": 0.0,
-            "equ6.19": 3.693248628902421,
-            "equ6.20": 2.5888061673294955,
-            "equ6.35zyz": 15.743161072121572,
-            "equ6.35yzz": 5.410545292606226,
-            "equ6.35yzy": 3.8840891485379205,
-            "equ6.35zyy": 13.755871509131088,
+            "equ6.11": 7.498451900709802,
+            "equ6.12": 8.008162331698859,
+            "equ6.33y": 3.8789057969957397,
+            "equ6.33z": 5.3805096418732745,
+            "equ6.19": 7.4596053782137135,
+            "equ6.20": 7.9693158092027705,
+            "equ6.35zyz": 22.083871853179318,
+            "equ6.35yzz": 34.4862418326259,
+            "equ6.35yzy": 32.833973154829195,
+            "equ6.35zyy": 19.13638115100436,
         }
 
 
@@ -168,8 +172,8 @@ class Test_Compression:
     def test_taux_c_0_d(self):
         print(self.compression.taux_c_0_rd)
         assert self.compression.taux_c_0_rd == {
-            "equ6.23": 3.8840891485379205,
-            "equ6.24": 4.234484439675713,
+            "equ6.23": 7.650445897849212,
+            "equ6.24": 9.614994081548987,
             "equ6.2": 0.10850694444444445,
         }
 

{ourocode-1.6.5 → ourocode-1.6.6}/tests/test_EC5_Feu.py

@@ -78,9 +78,9 @@ def compression(feu):
 @pytest.fixture
 def flexion(feu):
     flexion = EC5_feu.Flexion_feu._from_parent_class(
-        feu, lo=7000, coeflef=0.8, pos="Charge sur fibre tendue"
+        feu, lo_rel_y=7000, lo_rel_z=3500, coeflef_y=0.9, coeflef_z=0.8, pos="Charge sur fibre tendue"
     )
-    flexion.sigma_m_d(100, axe="y")
+    flexion.sigma_m_d(100, 50)
     flexion.f_m_d()
     flexion.taux_m_d()
     return flexion
@@ -90,11 +90,13 @@ class Test_Flexion(object):
     @pytest.fixture(autouse=True)
     def setup_method(self, flexion, compression, traction):
         self.flexion = flexion
-        self.flexion.taux_m_d(traction=traction)
+        self.flexion.taux_m_d(traction=traction, compression=compression)
 
     def test_init(self):
-        assert self.flexion.lo == 7 * si.m
-        assert self.flexion.coeflef == 0.8
+        assert self.flexion.lo_rel_y == 7 * si.m
+        assert self.flexion.lo_rel_z == 3.5 * si.m
+        assert self.flexion.coeflef_y == 0.9
+        assert self.flexion.coeflef_z == 0.8
         assert self.flexion.pos == "Charge sur fibre tendue"
 
     def test_Kh(self):
@@ -102,7 +104,7 @@ class Test_Flexion(object):
 
     def test_sigma_m_d(self):
         assert self.flexion.sigma_m_rd["y"].value == 163675555.10053056
-        assert self.flexion.sigma_m_rd["z"].value == 0
+        assert self.flexion.sigma_m_rd["z"].value == 437396117.6737902
 
     def test_f_m_d(self):
         assert self.flexion.f_type_rd == 30.360 * si.MPa
@@ -110,10 +112,16 @@ class Test_Flexion(object):
     def test_taux_m_d(self):
         # print(self.flexion.taux_m_rd)
         assert self.flexion.taux_m_rd == {
-            "equ6.11": 5.092280445969156,
-            "equ6.12": 3.583241979399042,
-            "equ6.33y": 9.345977483810818,
-            "equ6.33z": 0.0,
+            "equ6.11": 14.260362922063692,
+            "equ6.12": 16.680502659534092,
+            "equ6.19": 14.215959920703218,
+            "equ6.20": 16.63609965817362,
+            "equ6.33y": 10.532177484564267,
+            "equ6.33z": 13.097260680135049,
+            "equ6.35yzy": 176.8685066512106,
+            "equ6.35yzz": 189.9693597600049,
+            "equ6.35zyy": 38.69959171479235,
+            "equ6.35zyz": 131.92296819852655,
         }
 
 
@@ -147,8 +155,8 @@ class Test_Compression:
     def test_taux_c_0_d(self):
         # print(self.compression.taux_c_0_rd)
         assert self.compression.taux_c_0_rd == {
-            "equ6.23": 5.330269327798991,
-            "equ6.24": 11.420034707359275,
+            "equ6.23": 14.498351803893526,
+            "equ6.24": 24.517295387494325,
             "equ6.2": 0.13322620878904579,
         }
 

ourocode-1.6.5/ourocode/__version__.py

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