ourocode 1.7.1__tar.gz → 1.7.3__tar.gz

{ourocode-1.7.1/ourocode.egg-info → ourocode-1.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ourocode
-Version: 1.7.1
+Version: 1.7.3
 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.3/ourocode/__version__.py

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

{ourocode-1.7.1 → ourocode-1.7.3}/ourocode/eurocode/EC1_Vent.py

@@ -11,6 +11,8 @@ from copy import copy
 import pandas as pd
 import forallpeople as si
 from handcalcs.decorator import handcalc
+from PySide6.QtWidgets import QApplication, QInputDialog
+from PySide6.QtCore import Qt
 
 # sys.path.append(os.path.join(os.getcwd(), "ourocode"))
 # from eurocode.A0_Projet import Batiment
@@ -71,20 +73,87 @@ class Vent(Batiment):
                 alt (int): altitude du batiment étudié en m.
                 cat_terrain (str): Catégorie de terrain du projet.
                 cat_oro (str): Catégorie orographique. Default to "Aucun".
+                    cas 1 : orographie constituée d'obstacles de hauteurs et de formes variées. Ce type d'orographie est le plus
+                        fréquemment rencontré.
+                    cas 2 : Non traité dans ce logiciel ! Orographie constituée d'obstacles bien individualisés. Une falaise ou une colline isolée appartiennent à 
+                        cette catégorie d'orographie, plus rarement rencontrée.
         """
         super().__init__(**kwargs)
         self.terrain = terrain
         self.oro = oro
+        if oro == "Cas 1":
+            self._calc_delta_AC()
+        elif oro == "Cas 2":
+            raise ValueError("Cas 2 non traité dans ce logiciel !")
         self.z = z * si.m
         self.CsCd = CsCd
 
     @property
     def cat_terrain(self):
-        return __class__.CAT_TERRAIN[self.terrain]
+        return self.CAT_TERRAIN[self.terrain]
 
     @property
     def cat_oro(self):
-        return __class__.CAT_ORO[self.oro]
+        return self.CAT_ORO[self.oro]
+
+    def _calc_delta_AC(self):
+        """
+        Calcule le delta AC en fonction des altitudes des obstacles environnants.
+        """
+        if not hasattr(self, "dict_alti_oro"):
+            self.dict_alti_oro = {
+                    "An1": "",
+                    "An2": "",
+                    "Ae1": "",
+                    "Ae2": "",
+                    "As1": "",
+                    "As2": "",
+                    "Ao1": "",
+                    "Ao2": "",
+                }
+            # Demande des altitudes via des boîtes de dialogue QInputDialog (PySide6), autonome si aucune QApplication n'existe
+            app = QApplication.instance()
+            owns_app = False
+            if app is None:
+                app = QApplication(sys.argv)
+                owns_app = True
+            try:
+                for cle, value in self.dict_alti_oro.items():
+                    if cle.endswith("1"):
+                        dist_msg = "à une distance de 500m"
+                    else:
+                        dist_msg = "à une distance de 1000m"
+                    val, ok = QInputDialog.getInt(
+                        None,
+                        "Altitude orographique",
+                        f"Altitude {cle} en m {dist_msg}:",
+                        0,
+                        -300,
+                        3000,
+                        1,
+                        flags=Qt.WindowSystemMenuHint | Qt.WindowTitleHint,
+                    )
+                    if not ok:
+                        raise RuntimeError("Saisie des altitudes annulée par l'utilisateur.")
+                    self.dict_alti_oro[cle] = int(val) * si.m
+            finally:
+                if owns_app:
+                    app.quit()
+
+        Am = (
+            2 * self.alt
+            + self.dict_alti_oro["An1"]
+            + self.dict_alti_oro["An2"]
+            + self.dict_alti_oro["Ae1"]
+            + self.dict_alti_oro["Ae2"]
+            + self.dict_alti_oro["As1"]
+            + self.dict_alti_oro["As2"]
+            + self.dict_alti_oro["Ao1"]
+            + self.dict_alti_oro["Ao2"]
+        ) / 10
+
+        self.delta_AC = self.alt - Am
+        return self.delta_AC
 
     @property
     def zone_vent(self):
@@ -178,45 +247,28 @@ class Vent(Batiment):
 
         match self.cat_oro:
             case "1":
-                dict_alti = {
-                    "An1": "",
-                    "An2": "",
-                    "Ae1": "",
-                    "Ae2": "",
-                    "As1": "",
-                    "As2": "",
-                    "Ao1": "",
-                    "Ao2": "",
-                }
-
-                for cle, value in dict_alti.items():
-                    dict_alti[cle] = int(input("Altitude {0} en m: ".format(cle)))
-
-                Am = (
-                    2 * self.alt
-                    + dict_alti["An1"]
-                    + dict_alti["An2"]
-                    + dict_alti["Ae1"]
-                    + dict_alti["Ae2"]
-                    + dict_alti["As1"]
-                    + dict_alti["As2"]
-                    + dict_alti["Ao1"]
-                    + dict_alti["Ao2"]
-                ) / 10
-
-                delta_AC = self.alt - Am
-
+                Delta_A_C = self.delta_AC.value
                 if self.z.value >= 10:
-                    C0_z = 1 + 0.004 * delta_AC * mt.exp(z - 10)
+                    @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)
+                        res = max(C0_z, 1)
+                        return res
                 else:
-                    C0_z = 1 + 0.004 * delta_AC * mt.exp(0)
+                    @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)
+                        res = max(C0_z, 1)
+                        return res
 
             case "2":
-                pass
+                raise ValueError("Erreur la catégorie orographique 2 n'est pas encore implémentée")
             case _:
-                C0_z = 1
-        # print("C0_z :", C0_z)
-        return max(C0_z, 1)
+                @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
+                def val():
+                    C0_z = 1
+                    return C0_z
+        return val()
 
     @property
     # @handcalc(override="params", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
@@ -228,7 +280,7 @@ class Vent(Batiment):
                 float: vitesse moyenne du vent en m/s
         """
         C_r_z = self._Cr_z
-        C_o_z = self.Co_z
+        C_o_z = self.Co_z[1]
         V_b = self.Vb[1]
 
         @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
@@ -246,7 +298,7 @@ class Vent(Batiment):
         """
         match self.cat_oro:
             case "1":
-                return self.Co_z * (
+                return self.Co_z[1] * (
                     1 - 2 * 10**-4 * (mt.log10(self.cat_terrain["Z0"]) + 3) ** 6
                 )  # 4.19NA
             case _:
@@ -276,10 +328,7 @@ class Vent(Batiment):
         ):
             return self._sigma_v / self.Vm_z[1]  # 4.7
         else:
-            print(
-                """Erreur la hauteur max du bâtiment ne peut dépasser 200m, 
-					 impossible de calculer l'intensité de turbulence Iv"""
-            )
+            raise ValueError("Erreur la hauteur max du bâtiment ne peut dépasser 200m, impossible de calculer l'intensité de turbulence Iv")
 
     @property
     def Qb(self):

{ourocode-1.7.1 → ourocode-1.7.3}/ourocode/eurocode/EC5_Assemblage.py

@@ -252,14 +252,14 @@ class Assemblage(Projet):
                 beta = f_h2k / f_h1k
                 a = f_h1k * t_1 * diam # N
                 b = f_h2k * t_2 * diam # N
-                c = a/(1 + beta) * (sqrt(beta + 2 * beta**2 * (1 + t_2 / t_1 + (t_2 / t_1)**2) + beta**3 * (t_2 / t_1)**2) - beta * (1 + t_2 / t_1)) # N
-                c = c + min(effet_corde, c*coef_limit_Johansen) # N
-                d = 1.05 * a / (2 + beta) * (sqrt(2 * beta * (1 + beta) + (4 * beta * (2 + beta) * M_y_Rk)/(f_h1k * t_1**2 * diam)) - beta) # N
-                d = d + min(effet_corde, d*coef_limit_Johansen) # N
-                e = 1.05 * (f_h1k * t_2 * diam) / (1 + 2 * beta) * (sqrt(2 * beta**2 * (1 + beta) + (4 * beta * (1 + 2 * beta) * M_y_Rk)/(f_h1k * t_2**2 * diam)) - beta) # N
-                e = e + min(effet_corde, e*coef_limit_Johansen) # N
-                f = 1.15 * sqrt((2 * beta)/(1 + beta)) * sqrt(2 * M_y_Rk * f_h1k * diam) # N
-                f = f + min(effet_corde, f*coef_limit_Johansen) # N
+                c_johansen = a/(1 + beta) * (sqrt(beta + 2 * beta**2 * (1 + t_2 / t_1 + (t_2 / t_1)**2) + beta**3 * (t_2 / t_1)**2) - beta * (1 + t_2 / t_1)) # N
+                c = c_johansen + min(effet_corde, c_johansen*coef_limit_Johansen) # N
+                d_johansen = 1.05 * a / (2 + beta) * (sqrt(2 * beta * (1 + beta) + (4 * beta * (2 + beta) * M_y_Rk)/(f_h1k * t_1**2 * diam)) - beta) # N
+                d = d_johansen + min(effet_corde, d_johansen*coef_limit_Johansen) # N
+                e_johansen = 1.05 * (f_h1k * t_2 * diam) / (1 + 2 * beta) * (sqrt(2 * beta**2 * (1 + beta) + (4 * beta * (1 + 2 * beta) * M_y_Rk)/(f_h1k * t_2**2 * diam)) - beta) # N
+                e = e_johansen + min(effet_corde, e_johansen*coef_limit_Johansen) # N
+                f_johansen = 1.15 * sqrt((2 * beta)/(1 + beta)) * sqrt(2 * M_y_Rk * f_h1k * diam) # N
+                f = f_johansen + min(effet_corde, f_johansen*coef_limit_Johansen) # N
                 return a, b, c, d, e, f
             
             calcul = val()
@@ -287,10 +287,10 @@ class Assemblage(Projet):
                 beta = f_h2k / f_h1k
                 g = f_h1k * t_1 * diam # N
                 h = 0.5 * f_h2k * t_2 * diam # N
-                j = 1.05 * g / (2 + beta) * (sqrt(2 * beta * (1 + beta) + (4 * beta * (2 + beta) * M_y_Rk)/ (f_h1k * t_1**2 * diam)) - beta) # N
-                j = j + min(effet_corde, j*coef_limit_Johansen) # N
-                k = 1.15 * sqrt((2 * beta)/(1 + beta)) * sqrt(2 * M_y_Rk * f_h1k * diam) # N
-                k = k + min(effet_corde, k*coef_limit_Johansen) # N
+                j_johansen = 1.05 * g / (2 + beta) * (sqrt(2 * beta * (1 + beta) + (4 * beta * (2 + beta) * M_y_Rk)/ (f_h1k * t_1**2 * diam)) - beta) # N
+                j = j_johansen + min(effet_corde, j_johansen*coef_limit_Johansen) # N
+                k_johansen = 1.15 * sqrt((2 * beta)/(1 + beta)) * sqrt(2 * M_y_Rk * f_h1k * diam) # N
+                k = k_johansen + min(effet_corde, k_johansen*coef_limit_Johansen) # N
                 return g, h, j, k
             
             calcul = val()
@@ -355,16 +355,16 @@ class Assemblage(Projet):
                 def val():
                     effet_corde = F_ax_Rk/4 # N
                     a = 0.4 * f_h2k * t_2 * diam # N
-                    b = 1.15 * sqrt(2 * M_y_Rk * f_h2k * diam) # N
-                    b = b + min(effet_corde, b*coef_limit_Johansen) # N
+                    b_johansen = 1.15 * sqrt(2 * M_y_Rk * f_h2k * diam) # N
+                    b = b_johansen + min(effet_corde, b_johansen*coef_limit_Johansen) # N
                     return a, b
             else:
                 @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
                 def val():
                     effet_corde = F_ax_Rk/4 # N
                     a = 0.4 * f_h1k * t_1 * diam # N
-                    b = 1.15 * sqrt(2 * M_y_Rk * f_h1k * diam) # N
-                    b = b + min(effet_corde, b*coef_limit_Johansen) # N
+                    b_johansen = 1.15 * sqrt(2 * M_y_Rk * f_h1k * diam) # N
+                    b = b_johansen + min(effet_corde, b_johansen*coef_limit_Johansen) # N
                     return a, b
             
             calcul = val()
@@ -387,20 +387,20 @@ class Assemblage(Projet):
                 def val():
                     effet_corde = F_ax_Rk/4 # N
                     c = f_h2k * t_2 * diam # N
-                    d = c * (sqrt(2 + (4 * M_y_Rk) / (f_h2k * diam * t_2 ** 2)) - 1) # N
-                    d = d + min(effet_corde, d*coef_limit_Johansen) # N
-                    e = 2.3 * sqrt(M_y_Rk * f_h2k * diam) # N
-                    e = e + min(effet_corde, e*coef_limit_Johansen) # N
+                    d_johansen = c * (sqrt(2 + (4 * M_y_Rk) / (f_h2k * diam * t_2 ** 2)) - 1) # N
+                    d = d_johansen + min(effet_corde, d_johansen*coef_limit_Johansen) # N
+                    e_johansen = 2.3 * sqrt(M_y_Rk * f_h2k * diam) # N
+                    e = e_johansen + min(effet_corde, e_johansen*coef_limit_Johansen) # N
                     return c, d, e
             else:
                 @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
                 def val():
                     effet_corde = F_ax_Rk/4 # N
                     c = f_h1k * t_1 * diam # N
-                    d = c * (sqrt(2 + (4 * M_y_Rk) / (f_h1k * diam * t_1 ** 2)) - 1) # N
-                    d = d + min(effet_corde, d*coef_limit_Johansen) # N
-                    e = 2.3 * sqrt(M_y_Rk * f_h1k * diam) # N
-                    e = e + min(effet_corde, e*coef_limit_Johansen) # N
+                    d_johansen = c * (sqrt(2 + (4 * M_y_Rk) / (f_h1k * diam * t_1 ** 2)) - 1) # N
+                    d = d_johansen + min(effet_corde, d_johansen*coef_limit_Johansen) # N
+                    e_johansen = 2.3 * sqrt(M_y_Rk * f_h1k * diam) # N
+                    e = e_johansen + min(effet_corde, e_johansen*coef_limit_Johansen) # N
                     return c, d, e
             
             calcul = val()
@@ -423,10 +423,10 @@ class Assemblage(Projet):
             def val():
                 effet_corde = F_ax_Rk/4 # N
                 f = f_h1k * t_1 * diam # N
-                g = f * (sqrt(2 + (4 * M_y_Rk) / (f_h1k * diam * t_1 ** 2)) - 1) # N
-                g = g + min(effet_corde, g*coef_limit_Johansen) # N
-                h = 2.3 * sqrt(M_y_Rk * f_h1k * diam) # N
-                h = h + min(effet_corde, h*coef_limit_Johansen) # N
+                g_johansen = f * (sqrt(2 + (4 * M_y_Rk) / (f_h1k * diam * t_1 ** 2)) - 1) # N
+                g = g_johansen + min(effet_corde, g_johansen*coef_limit_Johansen) # N
+                h_johansen = 2.3 * sqrt(M_y_Rk * f_h1k * diam) # N
+                h = h_johansen + min(effet_corde, h_johansen*coef_limit_Johansen) # N
                 return f, g, h
 
             calcul = val()
@@ -449,8 +449,8 @@ class Assemblage(Projet):
             def val():
                 effet_corde = F_ax_Rk/4 # N
                 j = 0.5 * f_h2k * t_2 * diam # N
-                k = 1.15 * sqrt(2 * M_y_Rk * f_h2k * diam) # N
-                k = k + min(effet_corde, k*coef_limit_Johansen) # N
+                k_johansen = 1.15 * sqrt(2 * M_y_Rk * f_h2k * diam) # N
+                k = k_johansen + min(effet_corde, k_johansen*coef_limit_Johansen) # N
                 return j, k
 
             calcul = val()
@@ -472,8 +472,8 @@ class Assemblage(Projet):
             def val():
                 effet_corde = F_ax_Rk/4 # N
                 l = 0.5 * f_h2k * t_2 * diam # N
-                m = 2.3 * sqrt(M_y_Rk * f_h2k * diam) # N
-                m = m + min(effet_corde, m*coef_limit_Johansen) # N
+                m_johansen = 2.3 * sqrt(M_y_Rk * f_h2k * diam) # N
+                m = m_johansen + min(effet_corde, m_johansen*coef_limit_Johansen) # N
                 return l, m
 
             calcul = val()
@@ -731,6 +731,7 @@ class Pointe(Assemblage):
         self.l = l * si.mm #longueur sous tête
         self.qualite = qualite
         self.n = n
+        self._nef = n
         self.fu = self.__qualite_acier.loc["fub"] *si.MPa
         self.alpha = [alpha1, alpha2]
         self.percage = percage
@@ -851,7 +852,7 @@ class Pointe(Assemblage):
             float: portance locale en MPa
         """
         d = self.d.value * 10**3
-        b_calcul = beam.b_calcul
+        b_calcul = beam.b_calcul.value * 10**3
         rho_k = beam.rho_k
         if self.dh >= 2*self.d or self.type_organe == "Agrafe":
             if beam.type_bois == "CP":
@@ -871,7 +872,7 @@ class Pointe(Assemblage):
                     return fhk * si.MPa
             return val()
         else:
-            raise ValueError(f"La tête de la pointe doit être au moins égale à {2*d} mm")
+            raise ValueError(f"La tête de la pointe doit être au moins égale à {2*d} mm selon l'EN 1995-1-1 §8.3.1.3 (3).")
 
 
     def _fhik(self) -> tuple:
@@ -919,7 +920,7 @@ class Pointe(Assemblage):
         if self.type_organe == "Autres pointes":
             @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
             def val():
-                f_ax_k = 70 * 10**-6 * rho_k_ax**2 * si.MPa
+                f_ax_k = 20 * 10**-6 * rho_k_ax**2 * si.MPa
                 F_ax_a_Rk = f_ax_k * d * t_pen
                 f_head_k = 70 * 10**-6 * rho_k_head**2 * si.MPa
                 F_head_Rk = f_head_k * d_h**2
@@ -928,7 +929,7 @@ class Pointe(Assemblage):
         else:
             @handcalc(override="short", precision=2, jupyter_display=self.JUPYTER_DISPLAY, left="\\[", right="\\]")
             def val():
-                f_ax_k = 70 * 10**-6 * rho_k_ax**2 * si.MPa
+                f_ax_k = 20 * 10**-6 * rho_k_ax**2 * si.MPa
                 F_ax_a_Rk = f_ax_k * d * t_pen
                 f_head_k = 70 * 10**-6 * rho_k_head**2 * si.MPa
                 F_head_Rk = f_ax_k * d * t + f_head_k * d_h**2
@@ -1078,7 +1079,7 @@ class Pointe(Assemblage):
                     a3c = round(10 * self.d, 1)
                     a4c = a2
 
-                elif rho_k > 420 and rho_k <= 500:
+                elif (rho_k > 420 and rho_k <= 500) or self._type_beam[i] in self.TYPE_BOIS_ASSEMBLAGE[1:]:
                     a1 = round((7 + 8 * mt.cos(mt.radians(alpha))) * self.d, 1)
                     a2 = round(7 * self.d, 1)
                     a3t = round((15 + 5 * mt.cos(mt.radians(alpha))) * self.d, 1)