Acciaio — §4.2

Verifiche per strutture in acciaio secondo NTC18 §4.2.

Riferimento normativo

NTC18 §4.2, Tab. 4.2.I/VIII/XIII, Formule [4.2.4]–[4.2.85]

Include flessione classe 3/4 [4.2.13–4.2.14], torsione [4.2.28], snellezza relativa [4.2.45–4.2.46], instabilità classe 4 [4.2.43], area taglio profili [4.2.18–4.2.23], von Mises [4.2.4], bulloneria e saldatura [4.2.65–4.2.81], perni SLU e SLE [4.2.75–4.2.79], instabilità laterale torsionale LTB [4.2.48–4.2.52], fatica e regola di Miner [4.2.54–4.2.57], deformabilità SLE e deriva di interpiano [Tab. 4.2.XIII], saldatura cordone d'angolo metodo direzionale e semplificato [4.2.83–4.2.85].

API

pyntc.checks.steel

Costruzioni di acciaio — NTC18 §4.2.

Proprieta' materiali, resistenza sezioni, instabilita', collegamenti bullonati e saldati.

Unita': - Tensioni/Resistenze: [N/mm^2] = [MPa] - Forze: [N] - Aree: [mm^2] - Moduli di resistenza: [mm^3] - Coefficienti: [-]

bolt_bearing_resistance(k1, alpha_b, f_u, d, t, gamma_M2)

Resistenza a rifollamento del piatto dell'unione [N].

NTC18 §4.2.8.1.1, Formula [4.2.67]: F_b,Rd = k1 * alpha_b * f_u * d * t / gamma_M2

I coefficienti k1 e alpha_b dipendono dalla posizione del bullone:

alpha_b (direzione del carico): bordo: min(e1 / (3d0), f_ub/f_u, 1.0) interno: min(p1 / (3d0) - 1/4, f_ub/f_u, 1.0)

k1 (direzione perpendicolare al carico): bordo: min(2.8 * e2/d0 - 1.7, 2.5) interno: min(1.4 * p2/d0 - 1.7, 2.5)

Parameters

k1 : float Coefficiente k1 [-]. alpha_b : float Coefficiente alpha_b [-]. f_u : float Tensione di rottura dell'acciaio del piatto [N/mm^2]. d : float Diametro nominale del bullone [mm]. t : float Spessore del piatto collegato [mm]. gamma_M2 : float Coefficiente parziale gamma_M2 [-].

Returns

float F_b,Rd: resistenza a rifollamento [N].

Source code in src/pyntc/checks/steel.py

@ntc_ref(article="4.2.8.1.1", formula="4.2.67", latex=r"F_{b,Rd} = \frac{k_1 \cdot \alpha_b \cdot f_u \cdot d \cdot t}{\gamma_{M2}}")
def bolt_bearing_resistance(
    k1: float, alpha_b: float, f_u: float, d: float, t: float, gamma_M2: float
) -> float:
    """Resistenza a rifollamento del piatto dell'unione [N].

    NTC18 §4.2.8.1.1, Formula [4.2.67]:
        F_b,Rd = k1 * alpha_b * f_u * d * t / gamma_M2

    I coefficienti k1 e alpha_b dipendono dalla posizione del bullone:

    alpha_b (direzione del carico):
        bordo:   min(e1 / (3*d0),  f_ub/f_u,  1.0)
        interno: min(p1 / (3*d0) - 1/4,  f_ub/f_u,  1.0)

    k1 (direzione perpendicolare al carico):
        bordo:   min(2.8 * e2/d0 - 1.7,  2.5)
        interno: min(1.4 * p2/d0 - 1.7,  2.5)

    Parameters
    ----------
    k1 : float
        Coefficiente k1 [-].
    alpha_b : float
        Coefficiente alpha_b [-].
    f_u : float
        Tensione di rottura dell'acciaio del piatto [N/mm^2].
    d : float
        Diametro nominale del bullone [mm].
    t : float
        Spessore del piatto collegato [mm].
    gamma_M2 : float
        Coefficiente parziale gamma_M2 [-].

    Returns
    -------
    float
        F_b,Rd: resistenza a rifollamento [N].
    """
    if k1 <= 0:
        raise ValueError("k1 deve essere > 0")
    if alpha_b <= 0:
        raise ValueError("alpha_b deve essere > 0")
    if f_u <= 0:
        raise ValueError("f_u deve essere > 0")
    if d <= 0:
        raise ValueError("d deve essere > 0")
    if t <= 0:
        raise ValueError("t deve essere > 0")
    if gamma_M2 <= 0:
        raise ValueError("gamma_M2 deve essere > 0")
    return k1 * alpha_b * f_u * d * t / gamma_M2

bolt_friction_resistance(n, mu, F_p_Cd, gamma_M3)

Resistenza allo scorrimento di un bullone precaricato [N].

NTC18 §4.2.8.1.1, Formula [4.2.72]: F_s,Rd = n * mu * F_p,Cd / gamma_M3

Valori tipici di mu

0.5 — superfici sabbiate, esenti da ruggine 0.4 — superfici sabbiate e verniciate (Al o Zn) 0.3 — superfici spazzolate o alla fiamma 0.2 — superfici non trattate

Parameters

n : int Numero di superfici di attrito [-]. mu : float Coefficiente di attrito [-]. F_p_Cd : float Forza di precarico del bullone [N]. gamma_M3 : float Coefficiente parziale gamma_M3 [-].

Returns

float F_s,Rd: resistenza allo scorrimento [N].

Source code in src/pyntc/checks/steel.py

@ntc_ref(article="4.2.8.1.1", formula="4.2.72", latex=r"F_{s,Rd} = \frac{n \cdot \mu \cdot F_{p,Cd}}{\gamma_{M3}}")
def bolt_friction_resistance(
    n: int, mu: float, F_p_Cd: float, gamma_M3: float
) -> float:
    """Resistenza allo scorrimento di un bullone precaricato [N].

    NTC18 §4.2.8.1.1, Formula [4.2.72]:
        F_s,Rd = n * mu * F_p,Cd / gamma_M3

    Valori tipici di mu:
        0.5 — superfici sabbiate, esenti da ruggine
        0.4 — superfici sabbiate e verniciate (Al o Zn)
        0.3 — superfici spazzolate o alla fiamma
        0.2 — superfici non trattate

    Parameters
    ----------
    n : int
        Numero di superfici di attrito [-].
    mu : float
        Coefficiente di attrito [-].
    F_p_Cd : float
        Forza di precarico del bullone [N].
    gamma_M3 : float
        Coefficiente parziale gamma_M3 [-].

    Returns
    -------
    float
        F_s,Rd: resistenza allo scorrimento [N].
    """
    if n <= 0:
        raise ValueError("n deve essere > 0")
    if mu <= 0:
        raise ValueError("mu deve essere > 0")
    if F_p_Cd <= 0:
        raise ValueError("F_p_Cd deve essere > 0")
    if gamma_M3 <= 0:
        raise ValueError("gamma_M3 deve essere > 0")
    return n * mu * F_p_Cd / gamma_M3

bolt_friction_tension_resistance(n, mu, F_p_Cd, F_t_Ed, gamma_M3)

Resistenza allo scorrimento con trazione concomitante [N].

NTC18 §4.2.8.1.1, Formula [4.2.73]: F_s,Rd = n * mu * (F_p,Cd - 0.8 * F_t,Ed) / gamma_M3

Parameters

n : int Numero di superfici di attrito [-]. mu : float Coefficiente di attrito [-]. F_p_Cd : float Forza di precarico del bullone [N]. F_t_Ed : float Trazione di progetto sul bullone [N]. gamma_M3 : float Coefficiente parziale gamma_M3 [-].

Returns

float F_s,Rd: resistenza allo scorrimento ridotta [N].

Source code in src/pyntc/checks/steel.py

@ntc_ref(article="4.2.8.1.1", formula="4.2.73", latex=r"F_{s,Rd} = \frac{n \cdot \mu \cdot (F_{p,Cd} - 0{,}8 \cdot F_{t,Ed})}{\gamma_{M3}}")
def bolt_friction_tension_resistance(
    n: int, mu: float, F_p_Cd: float, F_t_Ed: float, gamma_M3: float
) -> float:
    """Resistenza allo scorrimento con trazione concomitante [N].

    NTC18 §4.2.8.1.1, Formula [4.2.73]:
        F_s,Rd = n * mu * (F_p,Cd - 0.8 * F_t,Ed) / gamma_M3

    Parameters
    ----------
    n : int
        Numero di superfici di attrito [-].
    mu : float
        Coefficiente di attrito [-].
    F_p_Cd : float
        Forza di precarico del bullone [N].
    F_t_Ed : float
        Trazione di progetto sul bullone [N].
    gamma_M3 : float
        Coefficiente parziale gamma_M3 [-].

    Returns
    -------
    float
        F_s,Rd: resistenza allo scorrimento ridotta [N].
    """
    if n <= 0:
        raise ValueError("n deve essere > 0")
    if mu <= 0:
        raise ValueError("mu deve essere > 0")
    if F_p_Cd <= 0:
        raise ValueError("F_p_Cd deve essere > 0")
    if F_t_Ed < 0:
        raise ValueError("F_t_Ed deve essere >= 0")
    if gamma_M3 <= 0:
        raise ValueError("gamma_M3 deve essere > 0")
    return n * mu * (F_p_Cd - 0.8 * F_t_Ed) / gamma_M3

bolt_grade_properties(grade)

Caratteristiche meccaniche di bulloni da Tab. 4.2.IX [N/mm^2].

NTC18 §4.2.8, Tab. 4.2.IX — Tensione di rottura f_ub e tensione di snervamento f_yb per bulloni a testa esagonale (ISO 898-1).

Parameters

grade : str Classe del bullone: "4.6", "4.8", "5.6", "5.8", "6.8", "8.8", "10.9".

Returns

tuple[float, float] (f_ub, f_yb): tensione di rottura e di snervamento [N/mm^2].

Raises

ValueError Se la classe non e' riconosciuta.

Source code in src/pyntc/checks/steel.py

@ntc_ref(article="4.2.8", table="Tab.4.2.IX", latex=r"\text{Tab.\,4.2.IX}")
def bolt_grade_properties(grade: str) -> tuple[float, float]:
    """Caratteristiche meccaniche di bulloni da Tab. 4.2.IX [N/mm^2].

    NTC18 §4.2.8, Tab. 4.2.IX — Tensione di rottura f_ub e tensione di
    snervamento f_yb per bulloni a testa esagonale (ISO 898-1).

    Parameters
    ----------
    grade : str
        Classe del bullone: "4.6", "4.8", "5.6", "5.8", "6.8", "8.8", "10.9".

    Returns
    -------
    tuple[float, float]
        (f_ub, f_yb): tensione di rottura e di snervamento [N/mm^2].

    Raises
    ------
    ValueError
        Se la classe non e' riconosciuta.
    """
    if grade not in _BOLT_GRADES:
        valid = ", ".join(_BOLT_GRADES)
        raise ValueError(
            f"grade deve essere {valid}, ricevuto: '{grade}'"
        )
    return _BOLT_GRADES[grade]

bolt_punching_resistance(d_m, t_p, f_u, gamma_M2)

Resistenza a punzonamento del piatto collegato [N].

NTC18 §4.2.8.1.1, Formula [4.2.70]: F_p,Rd = 0.6 * pi * d_m * t_p * f_u / gamma_M2

Parameters

d_m : float Minimo tra diametro del dado e diametro medio della testa del bullone [mm]. t_p : float Spessore del piatto [mm]. f_u : float Tensione di rottura dell'acciaio del piatto [N/mm^2]. gamma_M2 : float Coefficiente parziale gamma_M2 [-].

Returns

float F_p,Rd: resistenza a punzonamento [N].

Source code in src/pyntc/checks/steel.py

@ntc_ref(article="4.2.8.1.1", formula="4.2.70", latex=r"F_{p,Rd} = \frac{0{,}6 \cdot \pi \cdot d_m \cdot t_p \cdot f_u}{\gamma_{M2}}")
def bolt_punching_resistance(
    d_m: float, t_p: float, f_u: float, gamma_M2: float
) -> float:
    """Resistenza a punzonamento del piatto collegato [N].

    NTC18 §4.2.8.1.1, Formula [4.2.70]:
        F_p,Rd = 0.6 * pi * d_m * t_p * f_u / gamma_M2

    Parameters
    ----------
    d_m : float
        Minimo tra diametro del dado e diametro medio della testa
        del bullone [mm].
    t_p : float
        Spessore del piatto [mm].
    f_u : float
        Tensione di rottura dell'acciaio del piatto [N/mm^2].
    gamma_M2 : float
        Coefficiente parziale gamma_M2 [-].

    Returns
    -------
    float
        F_p,Rd: resistenza a punzonamento [N].
    """
    if d_m <= 0:
        raise ValueError("d_m deve essere > 0")
    if t_p <= 0:
        raise ValueError("t_p deve essere > 0")
    if f_u <= 0:
        raise ValueError("f_u deve essere > 0")
    if gamma_M2 <= 0:
        raise ValueError("gamma_M2 deve essere > 0")
    return 0.6 * math.pi * d_m * t_p * f_u / gamma_M2

bolt_shear_resistance(f_ub, A_s, bolt_class, gamma_M2)

Resistenza a taglio di un bullone [N].

NTC18 §4.2.8.1.1, Formula [4.2.63]: F_v,Rd = alpha_v * f_ub * A_s / gamma_M2

dove alpha_v = 0.6 per classi 4.6, 5.6, 8.8 = 0.5 per classi 5.8, 6.8, 10.9

Parameters

f_ub : float Tensione di rottura del bullone [N/mm^2]. A_s : float Area resistente a trazione del bullone [mm^2]. bolt_class : str Classe del bullone: "4.6", "5.6", "5.8", "6.8", "8.8", "10.9". gamma_M2 : float Coefficiente parziale gamma_M2 [-].

Returns

float F_v,Rd: resistenza a taglio [N].

Source code in src/pyntc/checks/steel.py

@ntc_ref(article="4.2.8.1.1", formula="4.2.63", latex=r"F_{v,Rd} = \frac{\alpha_v \cdot f_{ub} \cdot A_s}{\gamma_{M2}}")
def bolt_shear_resistance(
    f_ub: float, A_s: float, bolt_class: str, gamma_M2: float
) -> float:
    """Resistenza a taglio di un bullone [N].

    NTC18 §4.2.8.1.1, Formula [4.2.63]:
        F_v,Rd = alpha_v * f_ub * A_s / gamma_M2

    dove alpha_v = 0.6 per classi 4.6, 5.6, 8.8
                 = 0.5 per classi 5.8, 6.8, 10.9

    Parameters
    ----------
    f_ub : float
        Tensione di rottura del bullone [N/mm^2].
    A_s : float
        Area resistente a trazione del bullone [mm^2].
    bolt_class : str
        Classe del bullone: "4.6", "5.6", "5.8", "6.8", "8.8", "10.9".
    gamma_M2 : float
        Coefficiente parziale gamma_M2 [-].

    Returns
    -------
    float
        F_v,Rd: resistenza a taglio [N].
    """
    if bolt_class not in _BOLT_SHEAR_COEFFICIENTS:
        raise ValueError(
            f"bolt_class deve essere 4.6, 5.6, 5.8, 6.8, 8.8 o 10.9, "
            f"ricevuto: '{bolt_class}'"
        )
    if f_ub <= 0:
        raise ValueError("f_ub deve essere > 0")
    if A_s <= 0:
        raise ValueError("A_s deve essere > 0")
    if gamma_M2 <= 0:
        raise ValueError("gamma_M2 deve essere > 0")

    alpha_v = _BOLT_SHEAR_COEFFICIENTS[bolt_class]
    return alpha_v * f_ub * A_s / gamma_M2

bolt_shear_tension_interaction(F_v_Ed, F_t_Ed, F_v_Rd, F_t_Rd)

Verifica interazione taglio + trazione bullone [-].

NTC18 §4.2.8.1.1, Formula [4.2.71]: F_v,Ed / F_v,Rd + F_t,Ed / F_t,Rd <= 1.0

Parameters

F_v_Ed : float Taglio di progetto sul bullone [N]. F_t_Ed : float Trazione di progetto sul bullone [N]. F_v_Rd : float Resistenza a taglio del bullone [N]. F_t_Rd : float Resistenza a trazione del bullone [N].

Returns

tuple[bool, float] (verifica_superata, utilization): - verifica_superata: True se rapporto <= 1 - utilization: valore del rapporto di interazione [-]

Source code in src/pyntc/checks/steel.py

@ntc_ref(article="4.2.8.1.1", formula="4.2.71", latex=r"\frac{F_{v,Ed}}{F_{v,Rd}} + \frac{F_{t,Ed}}{F_{t,Rd}} \le 1{,}0")
def bolt_shear_tension_interaction(
    F_v_Ed: float, F_t_Ed: float, F_v_Rd: float, F_t_Rd: float
) -> tuple[bool, float]:
    """Verifica interazione taglio + trazione bullone [-].

    NTC18 §4.2.8.1.1, Formula [4.2.71]:
        F_v,Ed / F_v,Rd + F_t,Ed / F_t,Rd <= 1.0

    Parameters
    ----------
    F_v_Ed : float
        Taglio di progetto sul bullone [N].
    F_t_Ed : float
        Trazione di progetto sul bullone [N].
    F_v_Rd : float
        Resistenza a taglio del bullone [N].
    F_t_Rd : float
        Resistenza a trazione del bullone [N].

    Returns
    -------
    tuple[bool, float]
        (verifica_superata, utilization):
        - verifica_superata: True se rapporto <= 1
        - utilization: valore del rapporto di interazione [-]
    """
    if F_v_Rd <= 0:
        raise ValueError("F_v_Rd deve essere > 0")
    if F_t_Rd <= 0:
        raise ValueError("F_t_Rd deve essere > 0")
    if F_v_Ed < 0:
        raise ValueError("F_v_Ed deve essere >= 0")
    if F_t_Ed < 0:
        raise ValueError("F_t_Ed deve essere >= 0")

    utilization = F_v_Ed / F_v_Rd + F_t_Ed / F_t_Rd
    return utilization <= 1.0, utilization

bolt_tension_resistance(f_ub, A_s, gamma_M2)

Resistenza a trazione di un bullone [N].

NTC18 §4.2.8.1.1, Formula [4.2.68]: F_t,Rd = 0.9 * f_ub * A_s / gamma_M2

Parameters

f_ub : float Tensione di rottura del bullone [N/mm^2]. A_s : float Area resistente a trazione del bullone [mm^2]. gamma_M2 : float Coefficiente parziale gamma_M2 [-].

Returns

float F_t,Rd: resistenza a trazione [N].

Source code in src/pyntc/checks/steel.py

@ntc_ref(article="4.2.8.1.1", formula="4.2.68", latex=r"F_{t,Rd} = \frac{0{,}9 \cdot f_{ub} \cdot A_s}{\gamma_{M2}}")
def bolt_tension_resistance(
    f_ub: float, A_s: float, gamma_M2: float
) -> float:
    """Resistenza a trazione di un bullone [N].

    NTC18 §4.2.8.1.1, Formula [4.2.68]:
        F_t,Rd = 0.9 * f_ub * A_s / gamma_M2

    Parameters
    ----------
    f_ub : float
        Tensione di rottura del bullone [N/mm^2].
    A_s : float
        Area resistente a trazione del bullone [mm^2].
    gamma_M2 : float
        Coefficiente parziale gamma_M2 [-].

    Returns
    -------
    float
        F_t,Rd: resistenza a trazione [N].
    """
    if f_ub <= 0:
        raise ValueError("f_ub deve essere > 0")
    if A_s <= 0:
        raise ValueError("A_s deve essere > 0")
    if gamma_M2 <= 0:
        raise ValueError("gamma_M2 deve essere > 0")
    return 0.9 * f_ub * A_s / gamma_M2

pin_bearing_resistance(t, d, f_y, gamma_M3)

Resistenza a rifollamento del foro del perno [N].

NTC18 §4.2.8.1.2, Formula [4.2.76]: F_b,Rd = 1.5 * t * d * f_y / gamma_M3

Parameters

t : float Spessore della piastra [mm]. d : float Diametro del perno [mm]. f_y : float Tensione di snervamento della piastra [N/mm^2]. gamma_M3 : float Coefficiente parziale gamma_M3 [-].

Returns

float F_b,Rd: resistenza a rifollamento [N].

Source code in src/pyntc/checks/steel.py

@ntc_ref(
    article="4.2.8.1.2",
    formula="4.2.76",
    latex=r"F_{b,Rd} = \frac{1{,}5 \cdot t \cdot d \cdot f_y}{\gamma_{M3}}",
)
def pin_bearing_resistance(
    t: float, d: float, f_y: float, gamma_M3: float
) -> float:
    """Resistenza a rifollamento del foro del perno [N].

    NTC18 §4.2.8.1.2, Formula [4.2.76]:
        F_b,Rd = 1.5 * t * d * f_y / gamma_M3

    Parameters
    ----------
    t : float
        Spessore della piastra [mm].
    d : float
        Diametro del perno [mm].
    f_y : float
        Tensione di snervamento della piastra [N/mm^2].
    gamma_M3 : float
        Coefficiente parziale gamma_M3 [-].

    Returns
    -------
    float
        F_b,Rd: resistenza a rifollamento [N].
    """
    if t <= 0:
        raise ValueError("t deve essere > 0")
    if d <= 0:
        raise ValueError("d deve essere > 0")
    if f_y <= 0:
        raise ValueError("f_y deve essere > 0")
    if gamma_M3 <= 0:
        raise ValueError("gamma_M3 deve essere > 0")
    return 1.5 * t * d * f_y / gamma_M3

pin_bearing_resistance_sle(t, d, f_y, gamma_M3_ser=1.0)

Resistenza a rifollamento perno SLE [4.278].

NTC18 §4.2.7.4, Formula [4.278]: F_b,Rd,ser = 0.6 * t * d * f_y / gamma_M3,ser

Parameters

t : float Spessore della piastra [mm]. d : float Diametro del perno [mm]. f_y : float Tensione di snervamento [N/mm^2]. gamma_M3_ser : float Coefficiente parziale SLE (default 1.0).

Returns

float F_b,Rd,ser: resistenza a rifollamento SLE [N].

Source code in src/pyntc/checks/steel.py

@ntc_ref(
    article="4.2.7.4",
    formula="4.278",
    latex=r"F_{b,Rd,ser} = \frac{0{,}6 \cdot t \cdot d \cdot f_y}{\gamma_{M3,ser}}",
)
def pin_bearing_resistance_sle(
    t: float, d: float, f_y: float, gamma_M3_ser: float = 1.0
) -> float:
    """Resistenza a rifollamento perno SLE [4.278].

    NTC18 §4.2.7.4, Formula [4.278]:
        F_b,Rd,ser = 0.6 * t * d * f_y / gamma_M3,ser

    Parameters
    ----------
    t : float
        Spessore della piastra [mm].
    d : float
        Diametro del perno [mm].
    f_y : float
        Tensione di snervamento [N/mm^2].
    gamma_M3_ser : float
        Coefficiente parziale SLE (default 1.0).

    Returns
    -------
    float
        F_b,Rd,ser: resistenza a rifollamento SLE [N].
    """
    return 0.6 * t * d * f_y / gamma_M3_ser

pin_bending_resistance(W_el, f_yp, gamma_M0=1.05)

Resistenza a flessione di un perno [N*mm].

NTC18 §4.2.8.10, Formula [4.2.77]: M_Rd = 1.5 * W_el * f_yp / gamma_M0

Parameters

W_el : float Modulo di resistenza elastico del perno [mm^3]. f_yp : float Tensione di snervamento del perno [N/mm^2]. gamma_M0 : float, optional Coefficiente parziale gamma_M0 [-]. Default 1.05 (Tab. 4.2.VII).

Returns

float M_Rd: resistenza a flessione del perno [N*mm].

Raises

ValueError Se W_el, f_yp o gamma_M0 non sono positivi.

Source code in src/pyntc/checks/steel.py

@ntc_ref(article="4.2.8.10", formula="4.2.77", latex=r"M_{Rd} = \frac{1{,}5 \cdot W_{el} \cdot f_{yp}}{\gamma_{M0}}")
def pin_bending_resistance(
    W_el: float, f_yp: float, gamma_M0: float = 1.05
) -> float:
    """Resistenza a flessione di un perno [N*mm].

    NTC18 §4.2.8.10, Formula [4.2.77]:
        M_Rd = 1.5 * W_el * f_yp / gamma_M0

    Parameters
    ----------
    W_el : float
        Modulo di resistenza elastico del perno [mm^3].
    f_yp : float
        Tensione di snervamento del perno [N/mm^2].
    gamma_M0 : float, optional
        Coefficiente parziale gamma_M0 [-]. Default 1.05 (Tab. 4.2.VII).

    Returns
    -------
    float
        M_Rd: resistenza a flessione del perno [N*mm].

    Raises
    ------
    ValueError
        Se W_el, f_yp o gamma_M0 non sono positivi.
    """
    if W_el <= 0:
        raise ValueError("W_el deve essere > 0")
    if f_yp <= 0:
        raise ValueError("f_yp deve essere > 0")
    if gamma_M0 <= 0:
        raise ValueError("gamma_M0 deve essere > 0")
    return 1.5 * W_el * f_yp / gamma_M0

pin_bending_resistance_sle(W_el, f_up, gamma_M3_ser=1.0)

Resistenza a flessione perno SLE [4.279].

NTC18 §4.2.7.4, Formula [4.279]: M_b,Rd,ser = 0.8 * W_el * f_up / gamma_M3,ser

Parameters

W_el : float Modulo di resistenza elastico del perno [mm^3]. f_up : float Resistenza a trazione del perno [N/mm^2]. gamma_M3_ser : float Coefficiente parziale SLE (default 1.0).

Returns

float M_b,Rd,ser: resistenza flessionale SLE [N*mm].

Source code in src/pyntc/checks/steel.py

@ntc_ref(
    article="4.2.7.4",
    formula="4.279",
    latex=r"M_{b,Rd,ser} = \frac{0{,}8 \cdot W_{el} \cdot f_{up}}{\gamma_{M3,ser}}",
)
def pin_bending_resistance_sle(
    W_el: float, f_up: float, gamma_M3_ser: float = 1.0
) -> float:
    """Resistenza a flessione perno SLE [4.279].

    NTC18 §4.2.7.4, Formula [4.279]:
        M_b,Rd,ser = 0.8 * W_el * f_up / gamma_M3,ser

    Parameters
    ----------
    W_el : float
        Modulo di resistenza elastico del perno [mm^3].
    f_up : float
        Resistenza a trazione del perno [N/mm^2].
    gamma_M3_ser : float
        Coefficiente parziale SLE (default 1.0).

    Returns
    -------
    float
        M_b,Rd,ser: resistenza flessionale SLE [N*mm].
    """
    return 0.8 * W_el * f_up / gamma_M3_ser

pin_shear_resistance(f_upk, A, gamma_M2)

Resistenza a taglio del perno [N].

NTC18 §4.2.8.1.2, Formula [4.2.75]: F_v,Rd = 0.6 * f_upk * A / gamma_M2

Parameters

f_upk : float Tensione di rottura caratteristica del perno [N/mm^2]. A : float Area della sezione trasversale del perno [mm^2]. gamma_M2 : float Coefficiente parziale gamma_M2 [-].

Returns

float F_v,Rd: resistenza a taglio del perno [N].

Source code in src/pyntc/checks/steel.py

@ntc_ref(
    article="4.2.8.1.2",
    formula="4.2.75",
    latex=r"F_{v,Rd} = \frac{0{,}6 \cdot f_{upk} \cdot A}{\gamma_{M2}}",
)
def pin_shear_resistance(
    f_upk: float, A: float, gamma_M2: float
) -> float:
    """Resistenza a taglio del perno [N].

    NTC18 §4.2.8.1.2, Formula [4.2.75]:
        F_v,Rd = 0.6 * f_upk * A / gamma_M2

    Parameters
    ----------
    f_upk : float
        Tensione di rottura caratteristica del perno [N/mm^2].
    A : float
        Area della sezione trasversale del perno [mm^2].
    gamma_M2 : float
        Coefficiente parziale gamma_M2 [-].

    Returns
    -------
    float
        F_v,Rd: resistenza a taglio del perno [N].
    """
    if f_upk <= 0:
        raise ValueError("f_upk deve essere > 0")
    if A <= 0:
        raise ValueError("A deve essere > 0")
    if gamma_M2 <= 0:
        raise ValueError("gamma_M2 deve essere > 0")
    return 0.6 * f_upk * A / gamma_M2

steel_NM_resistance_y(n, a, M_pl_y_Rd)

Resistenza a flessione ridotta per sforzo assiale — asse forte [N*mm].

NTC18 §4.2.4.1.2.7, Formula [4.2.33]: M_N,y,Rd = M_pl,y,Rd * (1 - n) / (1 - 0.5 * a) con M_N,y,Rd <= M_pl,y,Rd.

Parameters

n : float Rapporto N_Ed / N_pl,Rd [-]. a : float Rapporto (A - 2bt_f) / A [-] (area anima / area totale). M_pl_y_Rd : float Resistenza plastica a flessione M_pl,y,Rd [N*mm].

Returns

float M_N,y,Rd: resistenza a flessione ridotta [N*mm].

Source code in src/pyntc/checks/steel.py

@ntc_ref(article="4.2.4.1.2.7", formula="4.2.33", latex=r"M_{N,y,Rd} = M_{pl,y,Rd} \cdot \frac{1 - n}{1 - 0{,}5\,a}")
def steel_NM_resistance_y(
    n: float, a: float, M_pl_y_Rd: float
) -> float:
    """Resistenza a flessione ridotta per sforzo assiale — asse forte [N*mm].

    NTC18 §4.2.4.1.2.7, Formula [4.2.33]:
        M_N,y,Rd = M_pl,y,Rd * (1 - n) / (1 - 0.5 * a)
    con M_N,y,Rd <= M_pl,y,Rd.

    Parameters
    ----------
    n : float
        Rapporto N_Ed / N_pl,Rd [-].
    a : float
        Rapporto (A - 2*b*t_f) / A [-] (area anima / area totale).
    M_pl_y_Rd : float
        Resistenza plastica a flessione M_pl,y,Rd [N*mm].

    Returns
    -------
    float
        M_N,y,Rd: resistenza a flessione ridotta [N*mm].
    """
    if n < 0 or n > 1:
        raise ValueError("n deve essere 0 <= n <= 1")
    if a < 0 or a > 1:
        raise ValueError("a deve essere 0 <= a <= 1")
    if M_pl_y_Rd <= 0:
        raise ValueError("M_pl_y_Rd deve essere > 0")

    M_N_y_Rd = M_pl_y_Rd * (1.0 - n) / (1.0 - 0.5 * a)
    return min(M_N_y_Rd, M_pl_y_Rd)

steel_NM_resistance_z(n, a, M_pl_z_Rd)

Resistenza a flessione ridotta per sforzo assiale — asse debole [N*mm].

NTC18 §4.2.4.1.2.7, Formule [4.2.34-4.2.35]: Se n <= a: M_N,z,Rd = M_pl,z,Rd Se n > a: M_N,z,Rd = M_pl,z,Rd * [1 - ((n - a) / (1 - a))^2]

Parameters

n : float Rapporto N_Ed / N_pl,Rd [-]. a : float Rapporto (A - 2bt_f) / A [-] (area anima / area totale). M_pl_z_Rd : float Resistenza plastica a flessione M_pl,z,Rd [N*mm].

Returns

float M_N,z,Rd: resistenza a flessione ridotta [N*mm].

Source code in src/pyntc/checks/steel.py

@ntc_ref(article="4.2.4.1.2.7", formula="4.2.34", latex=r"M_{N,z,Rd} = M_{pl,z,Rd} \cdot \left[1 - \left(\frac{n - a}{1 - a}\right)^2\right]")
def steel_NM_resistance_z(
    n: float, a: float, M_pl_z_Rd: float
) -> float:
    """Resistenza a flessione ridotta per sforzo assiale — asse debole [N*mm].

    NTC18 §4.2.4.1.2.7, Formule [4.2.34-4.2.35]:
        Se n <= a: M_N,z,Rd = M_pl,z,Rd
        Se n > a:  M_N,z,Rd = M_pl,z,Rd * [1 - ((n - a) / (1 - a))^2]

    Parameters
    ----------
    n : float
        Rapporto N_Ed / N_pl,Rd [-].
    a : float
        Rapporto (A - 2*b*t_f) / A [-] (area anima / area totale).
    M_pl_z_Rd : float
        Resistenza plastica a flessione M_pl,z,Rd [N*mm].

    Returns
    -------
    float
        M_N,z,Rd: resistenza a flessione ridotta [N*mm].
    """
    if n < 0 or n > 1:
        raise ValueError("n deve essere 0 <= n <= 1")
    if a < 0 or a > 1:
        raise ValueError("a deve essere 0 <= a <= 1")
    if M_pl_z_Rd <= 0:
        raise ValueError("M_pl_z_Rd deve essere > 0")

    if n <= a:
        return M_pl_z_Rd

    return M_pl_z_Rd * (1.0 - ((n - a) / (1.0 - a)) ** 2)

steel_bending_resistance(W, f_yk, gamma_M0)

Resistenza a flessione della sezione [N*mm].

NTC18 §4.2.4.1.2.3, Formula [4.2.12]: M_c,Rd = W * f_yk / gamma_M0

Per sezioni di classe 1 e 2: W = W_pl (modulo plastico). Per sezioni di classe 3: W = W_el (modulo elastico).

Parameters

W : float Modulo di resistenza (plastico o elastico) [mm^3]. f_yk : float Tensione di snervamento [N/mm^2]. gamma_M0 : float Coefficiente parziale gamma_M0 [-].

Returns

float M_c,Rd: resistenza a flessione [N*mm].

Source code in src/pyntc/checks/steel.py

@ntc_ref(article="4.2.4.1.2.3", formula="4.2.12", latex=r"M_{c,Rd} = \frac{W \cdot f_{yk}}{\gamma_{M0}}")
def steel_bending_resistance(
    W: float, f_yk: float, gamma_M0: float
) -> float:
    """Resistenza a flessione della sezione [N*mm].

    NTC18 §4.2.4.1.2.3, Formula [4.2.12]:
        M_c,Rd = W * f_yk / gamma_M0

    Per sezioni di classe 1 e 2: W = W_pl (modulo plastico).
    Per sezioni di classe 3: W = W_el (modulo elastico).

    Parameters
    ----------
    W : float
        Modulo di resistenza (plastico o elastico) [mm^3].
    f_yk : float
        Tensione di snervamento [N/mm^2].
    gamma_M0 : float
        Coefficiente parziale gamma_M0 [-].

    Returns
    -------
    float
        M_c,Rd: resistenza a flessione [N*mm].
    """
    if W <= 0:
        raise ValueError("W deve essere > 0")
    if f_yk <= 0:
        raise ValueError("f_yk deve essere > 0")
    if gamma_M0 <= 0:
        raise ValueError("gamma_M0 deve essere > 0")
    return W * f_yk / gamma_M0

steel_bending_resistance_class3(W_el_min, f_yk, gamma_M0=1.0)

Resistenza a flessione elastica per sezioni di classe 3 [N*mm].

NTC18 §4.2.4.1.2.3, Formula [4.2.13]: M_c,Rd = M_el,Rd = W_el,min * f_yk / gamma_M0

Parameters

W_el_min : float Modulo di resistenza elastico minimo della sezione [mm^3]. f_yk : float Tensione di snervamento caratteristica [N/mm^2]. gamma_M0 : float Coefficiente parziale gamma_M0 [-]. Default NTC18: 1.0.

Returns

float M_el,Rd: resistenza a flessione elastica [N*mm].

Source code in src/pyntc/checks/steel.py

@ntc_ref(
    article="4.2.4.1.2.3",
    formula="4.2.13",
    latex=r"M_{el,Rd} = \frac{W_{el,min} \cdot f_{yk}}{\gamma_{M0}}",
)
def steel_bending_resistance_class3(
    W_el_min: float, f_yk: float, gamma_M0: float = 1.0
) -> float:
    """Resistenza a flessione elastica per sezioni di classe 3 [N*mm].

    NTC18 §4.2.4.1.2.3, Formula [4.2.13]:
        M_c,Rd = M_el,Rd = W_el,min * f_yk / gamma_M0

    Parameters
    ----------
    W_el_min : float
        Modulo di resistenza elastico minimo della sezione [mm^3].
    f_yk : float
        Tensione di snervamento caratteristica [N/mm^2].
    gamma_M0 : float
        Coefficiente parziale gamma_M0 [-]. Default NTC18: 1.0.

    Returns
    -------
    float
        M_el,Rd: resistenza a flessione elastica [N*mm].
    """
    if W_el_min <= 0:
        raise ValueError("W_el_min deve essere > 0")
    if f_yk <= 0:
        raise ValueError("f_yk deve essere > 0")
    if gamma_M0 <= 0:
        raise ValueError("gamma_M0 deve essere > 0")
    return W_el_min * f_yk / gamma_M0

steel_bending_resistance_class4(W_eff_min, f_yk, gamma_M0=1.0)

Resistenza a flessione per sezioni di classe 4 (sezione efficace) [N*mm].

NTC18 §4.2.4.1.2.3, Formula [4.2.14]: M_c,Rd = M_eff,Rd = W_eff,min * f_yk / gamma_M0

Parameters

W_eff_min : float Modulo di resistenza della sezione efficace minimo [mm^3]. f_yk : float Tensione di snervamento caratteristica [N/mm^2]. gamma_M0 : float Coefficiente parziale gamma_M0 [-]. Default NTC18: 1.0.

Returns

float M_eff,Rd: resistenza a flessione sezione efficace [N*mm].

Source code in src/pyntc/checks/steel.py

@ntc_ref(
    article="4.2.4.1.2.3",
    formula="4.2.14",
    latex=r"M_{eff,Rd} = \frac{W_{eff,min} \cdot f_{yk}}{\gamma_{M0}}",
)
def steel_bending_resistance_class4(
    W_eff_min: float, f_yk: float, gamma_M0: float = 1.0
) -> float:
    """Resistenza a flessione per sezioni di classe 4 (sezione efficace) [N*mm].

    NTC18 §4.2.4.1.2.3, Formula [4.2.14]:
        M_c,Rd = M_eff,Rd = W_eff,min * f_yk / gamma_M0

    Parameters
    ----------
    W_eff_min : float
        Modulo di resistenza della sezione efficace minimo [mm^3].
    f_yk : float
        Tensione di snervamento caratteristica [N/mm^2].
    gamma_M0 : float
        Coefficiente parziale gamma_M0 [-]. Default NTC18: 1.0.

    Returns
    -------
    float
        M_eff,Rd: resistenza a flessione sezione efficace [N*mm].
    """
    if W_eff_min <= 0:
        raise ValueError("W_eff_min deve essere > 0")
    if f_yk <= 0:
        raise ValueError("f_yk deve essere > 0")
    if gamma_M0 <= 0:
        raise ValueError("gamma_M0 deve essere > 0")
    return W_eff_min * f_yk / gamma_M0

steel_bending_shear_reduction(V_Ed, V_c_Rd)

Fattore di riduzione rho per flessione in presenza di taglio [-].

NTC18 §4.2.4.1.2.6, Formula [4.2.31]: Se V_Ed <= 0.5 * V_c,Rd: rho = 0 (nessuna riduzione) Se V_Ed > 0.5 * V_c,Rd: rho = (2 * V_Ed / V_c,Rd - 1)^2

Parameters

V_Ed : float Taglio di progetto [N]. V_c_Rd : float Resistenza a taglio della sezione [N].

Returns

float Fattore di riduzione rho [-], 0 <= rho <= 1.

Source code in src/pyntc/checks/steel.py

@ntc_ref(article="4.2.4.1.2.6", formula="4.2.31", latex=r"\rho = \left(\frac{2 V_{Ed}}{V_{c,Rd}} - 1\right)^2")
def steel_bending_shear_reduction(
    V_Ed: float, V_c_Rd: float
) -> float:
    """Fattore di riduzione rho per flessione in presenza di taglio [-].

    NTC18 §4.2.4.1.2.6, Formula [4.2.31]:
        Se V_Ed <= 0.5 * V_c,Rd: rho = 0 (nessuna riduzione)
        Se V_Ed > 0.5 * V_c,Rd:  rho = (2 * V_Ed / V_c,Rd - 1)^2

    Parameters
    ----------
    V_Ed : float
        Taglio di progetto [N].
    V_c_Rd : float
        Resistenza a taglio della sezione [N].

    Returns
    -------
    float
        Fattore di riduzione rho [-], 0 <= rho <= 1.
    """
    if V_c_Rd <= 0:
        raise ValueError("V_c_Rd deve essere > 0")
    if V_Ed < 0:
        raise ValueError("V_Ed deve essere >= 0")

    if V_Ed <= 0.5 * V_c_Rd:
        return 0.0

    return (2.0 * V_Ed / V_c_Rd - 1.0) ** 2

steel_biaxial_check(M_y_Ed, M_z_Ed, M_N_y_Rd, M_N_z_Rd, n)

Verifica presso/tenso-flessione biassiale [-].

NTC18 §4.2.4.1.28, Formule [4.2.38-4.2.39]: Se n >= 0.2: (M_y_Ed / M_N,y,Rd)^2 + (M_z_Ed / M_N,z,Rd)^(5n) <= 1 Se n < 0.2: M_y_Ed / M_N,y,Rd + M_z_Ed / M_N,z,Rd <= 1

Parameters

M_y_Ed : float Momento flettente di progetto asse forte [Nmm]. M_z_Ed : float Momento flettente di progetto asse debole [Nmm]. M_N_y_Rd : float Resistenza ridotta a flessione asse forte [Nmm]. M_N_z_Rd : float Resistenza ridotta a flessione asse debole [Nmm]. n : float Rapporto N_Ed / N_pl,Rd [-].

Returns

tuple[bool, float] (verifica_superata, utilization): - verifica_superata: True se il rapporto <= 1 - utilization: valore del rapporto di interazione [-]

Source code in src/pyntc/checks/steel.py

@ntc_ref(article="4.2.4.1.28", formula="4.2.38", latex=r"\left(\frac{M_{y,Ed}}{M_{N,y,Rd}}\right)^2 + \left(\frac{M_{z,Ed}}{M_{N,z,Rd}}\right)^{5n} \le 1")
def steel_biaxial_check(
    M_y_Ed: float,
    M_z_Ed: float,
    M_N_y_Rd: float,
    M_N_z_Rd: float,
    n: float,
) -> tuple[bool, float]:
    """Verifica presso/tenso-flessione biassiale [-].

    NTC18 §4.2.4.1.28, Formule [4.2.38-4.2.39]:
        Se n >= 0.2: (M_y_Ed / M_N,y,Rd)^2 + (M_z_Ed / M_N,z,Rd)^(5n) <= 1
        Se n < 0.2:  M_y_Ed / M_N,y,Rd + M_z_Ed / M_N,z,Rd <= 1

    Parameters
    ----------
    M_y_Ed : float
        Momento flettente di progetto asse forte [N*mm].
    M_z_Ed : float
        Momento flettente di progetto asse debole [N*mm].
    M_N_y_Rd : float
        Resistenza ridotta a flessione asse forte [N*mm].
    M_N_z_Rd : float
        Resistenza ridotta a flessione asse debole [N*mm].
    n : float
        Rapporto N_Ed / N_pl,Rd [-].

    Returns
    -------
    tuple[bool, float]
        (verifica_superata, utilization):
        - verifica_superata: True se il rapporto <= 1
        - utilization: valore del rapporto di interazione [-]
    """
    if M_N_y_Rd <= 0:
        raise ValueError("M_N_y_Rd deve essere > 0")
    if M_N_z_Rd <= 0:
        raise ValueError("M_N_z_Rd deve essere > 0")
    if n < 0:
        raise ValueError("n deve essere >= 0")

    ratio_y = abs(M_y_Ed) / M_N_y_Rd
    ratio_z = abs(M_z_Ed) / M_N_z_Rd

    if n >= 0.2:
        # [4.2.38]: esponente alpha=2 per y, beta=5*n per z
        utilization = ratio_y ** 2 + ratio_z ** (5.0 * n)
    else:
        # [4.2.39]: interazione lineare
        utilization = ratio_y + ratio_z

    return utilization <= 1.0, utilization

steel_buckling_imperfection(curve)

Fattore di imperfezione alpha da Tab. 4.2.VIII [-].

NTC18 §4.2.4.1.3.1, Tab. 4.2.VIII: a0 → 0.13, a → 0.21, b → 0.34, c → 0.49, d → 0.76

Parameters

curve : str Curva di instabilita': "a0", "a", "b", "c" o "d".

Returns

float Fattore di imperfezione alpha [-].

Source code in src/pyntc/checks/steel.py

@ntc_ref(article="4.2.4.1.3.1", table="Tab.4.2.VIII", latex=r"\text{Tab.\,4.2.VIII}")
def steel_buckling_imperfection(curve: str) -> float:
    """Fattore di imperfezione alpha da Tab. 4.2.VIII [-].

    NTC18 §4.2.4.1.3.1, Tab. 4.2.VIII:
        a0 → 0.13, a → 0.21, b → 0.34, c → 0.49, d → 0.76

    Parameters
    ----------
    curve : str
        Curva di instabilita': "a0", "a", "b", "c" o "d".

    Returns
    -------
    float
        Fattore di imperfezione alpha [-].
    """
    key = curve.lower()
    if key not in _IMPERFECTION_FACTORS:
        raise ValueError(
            f"curve deve essere 'a0', 'a', 'b', 'c' o 'd', "
            f"ricevuto: '{curve}'"
        )
    return _IMPERFECTION_FACTORS[key]

steel_buckling_reduction(lambda_bar, alpha)

Coefficiente di riduzione per instabilita' chi [-].

NTC18 §4.2.4.1.3.1, Formula [4.2.44]: Phi = 0.5 * [1 + alpha * (lambda_bar - 0.2) + lambda_bar^2] chi = 1 / (Phi + sqrt(Phi^2 - lambda_bar^2)) con chi <= 1.0.

Per lambda_bar <= 0.2 si assume chi = 1.0 (instabilita' trascurabile).

Parameters

lambda_bar : float Snellezza adimensionale [-]. alpha : float Fattore di imperfezione [-] (da Tab. 4.2.VIII).

Returns

float Coefficiente di riduzione chi [-], 0 < chi <= 1.

Source code in src/pyntc/checks/steel.py

@ntc_ref(article="4.2.4.1.3.1", formula="4.2.44", latex=r"\chi = \frac{1}{\Phi + \sqrt{\Phi^2 - \bar{\lambda}^2}}")
def steel_buckling_reduction(
    lambda_bar: float, alpha: float
) -> float:
    """Coefficiente di riduzione per instabilita' chi [-].

    NTC18 §4.2.4.1.3.1, Formula [4.2.44]:
        Phi = 0.5 * [1 + alpha * (lambda_bar - 0.2) + lambda_bar^2]
        chi = 1 / (Phi + sqrt(Phi^2 - lambda_bar^2))
    con chi <= 1.0.

    Per lambda_bar <= 0.2 si assume chi = 1.0 (instabilita' trascurabile).

    Parameters
    ----------
    lambda_bar : float
        Snellezza adimensionale [-].
    alpha : float
        Fattore di imperfezione [-] (da Tab. 4.2.VIII).

    Returns
    -------
    float
        Coefficiente di riduzione chi [-], 0 < chi <= 1.
    """
    if lambda_bar < 0:
        raise ValueError("lambda_bar deve essere >= 0")
    if alpha < 0:
        raise ValueError("alpha deve essere >= 0")

    if lambda_bar <= 0.2:
        return 1.0

    Phi = 0.5 * (1.0 + alpha * (lambda_bar - 0.2) + lambda_bar ** 2)
    chi = 1.0 / (Phi + math.sqrt(Phi ** 2 - lambda_bar ** 2))
    return min(chi, 1.0)

steel_buckling_resistance(chi, A, f_yk, gamma_M1)

Resistenza ad instabilita' per aste compresse [N].

NTC18 §4.2.4.1.3.1, Formula [4.2.42]: N_b,Rd = chi * A * f_yk / gamma_M1

Parameters

chi : float Coefficiente di riduzione per instabilita' [-]. A : float Area della sezione [mm^2]. f_yk : float Tensione di snervamento [N/mm^2]. gamma_M1 : float Coefficiente parziale gamma_M1 [-].

Returns

float N_b,Rd: resistenza ad instabilita' [N].

Source code in src/pyntc/checks/steel.py

@ntc_ref(article="4.2.4.1.3.1", formula="4.2.42", latex=r"N_{b,Rd} = \frac{\chi \cdot A \cdot f_{yk}}{\gamma_{M1}}")
def steel_buckling_resistance(
    chi: float, A: float, f_yk: float, gamma_M1: float
) -> float:
    """Resistenza ad instabilita' per aste compresse [N].

    NTC18 §4.2.4.1.3.1, Formula [4.2.42]:
        N_b,Rd = chi * A * f_yk / gamma_M1

    Parameters
    ----------
    chi : float
        Coefficiente di riduzione per instabilita' [-].
    A : float
        Area della sezione [mm^2].
    f_yk : float
        Tensione di snervamento [N/mm^2].
    gamma_M1 : float
        Coefficiente parziale gamma_M1 [-].

    Returns
    -------
    float
        N_b,Rd: resistenza ad instabilita' [N].
    """
    if chi <= 0 or chi > 1:
        raise ValueError("chi deve essere 0 < chi <= 1")
    if A <= 0:
        raise ValueError("A deve essere > 0")
    if f_yk <= 0:
        raise ValueError("f_yk deve essere > 0")
    if gamma_M1 <= 0:
        raise ValueError("gamma_M1 deve essere > 0")
    return chi * A * f_yk / gamma_M1

steel_buckling_resistance_class4(chi, A_eff, f_yk, gamma_M1=1.0)

Resistenza ad instabilita' per sezioni di classe 4 [N].

NTC18 §4.2.4.1.3.1, Formula [4.2.43]: N_b,Rd = chi * A_eff * f_yk / gamma_M1

Parameters

chi : float Coefficiente di riduzione per instabilita' [-]. A_eff : float Area efficace della sezione di classe 4 [mm^2]. f_yk : float Tensione di snervamento caratteristica [N/mm^2]. gamma_M1 : float Coefficiente parziale gamma_M1 [-]. Default NTC18: 1.0.

Returns

float N_b,Rd: resistenza ad instabilita' [N].

Source code in src/pyntc/checks/steel.py

@ntc_ref(
    article="4.2.4.1.3.1",
    formula="4.2.43",
    latex=r"N_{b,Rd} = \frac{\chi \cdot A_{\text{eff}} \cdot f_{yk}}{\gamma_{M1}}",
)
def steel_buckling_resistance_class4(
    chi: float, A_eff: float, f_yk: float, gamma_M1: float = 1.0
) -> float:
    """Resistenza ad instabilita' per sezioni di classe 4 [N].

    NTC18 §4.2.4.1.3.1, Formula [4.2.43]:
        N_b,Rd = chi * A_eff * f_yk / gamma_M1

    Parameters
    ----------
    chi : float
        Coefficiente di riduzione per instabilita' [-].
    A_eff : float
        Area efficace della sezione di classe 4 [mm^2].
    f_yk : float
        Tensione di snervamento caratteristica [N/mm^2].
    gamma_M1 : float
        Coefficiente parziale gamma_M1 [-]. Default NTC18: 1.0.

    Returns
    -------
    float
        N_b,Rd: resistenza ad instabilita' [N].
    """
    if chi <= 0 or chi > 1:
        raise ValueError("chi deve essere 0 < chi <= 1")
    if A_eff <= 0:
        raise ValueError("A_eff deve essere > 0")
    if f_yk <= 0:
        raise ValueError("f_yk deve essere > 0")
    if gamma_M1 <= 0:
        raise ValueError("gamma_M1 deve essere > 0")
    return chi * A_eff * f_yk / gamma_M1

steel_compression_resistance(A, f_yk, gamma_M0)

Resistenza a compressione della sezione [N].

NTC18 §4.2.4.1.2.2, Formula [4.2.10]: N_c,Rd = A * f_yk / gamma_M0

Parameters

A : float Area della sezione [mm^2]. f_yk : float Tensione di snervamento [N/mm^2]. gamma_M0 : float Coefficiente parziale gamma_M0 [-].

Returns

float N_c,Rd: resistenza a compressione [N].

Source code in src/pyntc/checks/steel.py

@ntc_ref(article="4.2.4.1.2.2", formula="4.2.10", latex=r"N_{c,Rd} = \frac{A \cdot f_{yk}}{\gamma_{M0}}")
def steel_compression_resistance(
    A: float, f_yk: float, gamma_M0: float
) -> float:
    """Resistenza a compressione della sezione [N].

    NTC18 §4.2.4.1.2.2, Formula [4.2.10]:
        N_c,Rd = A * f_yk / gamma_M0

    Parameters
    ----------
    A : float
        Area della sezione [mm^2].
    f_yk : float
        Tensione di snervamento [N/mm^2].
    gamma_M0 : float
        Coefficiente parziale gamma_M0 [-].

    Returns
    -------
    float
        N_c,Rd: resistenza a compressione [N].
    """
    if A <= 0:
        raise ValueError("A deve essere > 0")
    if f_yk <= 0:
        raise ValueError("f_yk deve essere > 0")
    if gamma_M0 <= 0:
        raise ValueError("gamma_M0 deve essere > 0")
    return A * f_yk / gamma_M0

steel_drift_limit(delta, h, building_type='standard')

Verifica spostamento di interpiano SLE [Tab 4.2.XIII].

NTC18 §4.2.4.3, Tab. 4.2.XIII: - Capannoni industriali monopiano: delta/h <= 1/150 - Edifici standard (altri casi): delta/h <= 1/300 - Edifici multipiano: delta/h <= 1/500

Parameters

delta : float Spostamento di interpiano [mm]. h : float Altezza di interpiano [mm]. building_type : str Tipo di struttura: 'industrial' (1/150), 'standard' (1/300), 'multistorey' (1/500).

Returns

tuple[bool, float] (ok, ratio): True se verificata, rapporto (delta/h)*L_lim.

Source code in src/pyntc/checks/steel.py

@ntc_ref(
    article="4.2.4.3",
    table="4.2.XIII",
    latex=r"\frac{\delta}{h} \leq \frac{1}{L_{lim}}",
)
def steel_drift_limit(
    delta: float, h: float, building_type: str = "standard"
) -> tuple[bool, float]:
    """Verifica spostamento di interpiano SLE [Tab 4.2.XIII].

    NTC18 §4.2.4.3, Tab. 4.2.XIII:
        - Capannoni industriali monopiano: delta/h <= 1/150
        - Edifici standard (altri casi): delta/h <= 1/300
        - Edifici multipiano: delta/h <= 1/500

    Parameters
    ----------
    delta : float
        Spostamento di interpiano [mm].
    h : float
        Altezza di interpiano [mm].
    building_type : str
        Tipo di struttura: 'industrial' (1/150), 'standard' (1/300),
        'multistorey' (1/500).

    Returns
    -------
    tuple[bool, float]
        (ok, ratio): True se verificata, rapporto (delta/h)*L_lim.
    """
    limits = {
        "industrial": 1.0 / 150.0,
        "standard": 1.0 / 300.0,
        "multistorey": 1.0 / 500.0,
    }
    limit = limits.get(building_type, 1.0 / 300.0)
    ratio = (delta / h) / limit
    return (ratio <= 1.0, ratio)

steel_fatigue_check(delta_s, delta_R, gamma_Mf=1.15)

Verifica a fatica — variazione di tensione [4.254].

NTC18 §4.2.4.2, Formula [4.254]: delta_s <= delta_R / gamma_Mf

Parameters

delta_s : float Variazione di tensione di progetto [N/mm^2]. delta_R : float Resistenza a fatica caratteristica (categoria dettaglio) [N/mm^2]. gamma_Mf : float Coefficiente parziale fatica (default 1.15).

Returns

tuple[bool, float] (ok, ratio): True se verificata, rapporto delta_s/(delta_R/gamma_Mf).

Source code in src/pyntc/checks/steel.py

@ntc_ref(
    article="4.2.4.2",
    formula="4.254",
    latex=r"\Delta s \leq \frac{\Delta R}{\gamma_{Mf}}",
)
def steel_fatigue_check(
    delta_s: float, delta_R: float, gamma_Mf: float = 1.15
) -> tuple[bool, float]:
    """Verifica a fatica — variazione di tensione [4.254].

    NTC18 §4.2.4.2, Formula [4.254]:
        delta_s <= delta_R / gamma_Mf

    Parameters
    ----------
    delta_s : float
        Variazione di tensione di progetto [N/mm^2].
    delta_R : float
        Resistenza a fatica caratteristica (categoria dettaglio) [N/mm^2].
    gamma_Mf : float
        Coefficiente parziale fatica (default 1.15).

    Returns
    -------
    tuple[bool, float]
        (ok, ratio): True se verificata, rapporto delta_s/(delta_R/gamma_Mf).
    """
    limit = delta_R / gamma_Mf
    ratio = delta_s / limit
    return (ratio <= 1.0, ratio)

steel_fatigue_damage(n_cycles, N_resistances)

Danno cumulato a fatica — regola di Miner [4.257].

NTC18 §4.2.4.2, Formula [4.257]: D = sum(n_i / N_i) <= 1.0

Parameters

n_cycles : list of float Numero di cicli applicati per ogni livello di tensione. N_resistances : list of float Numero di cicli ammissibili per ogni livello di tensione.

Returns

tuple[bool, float] (ok, D): True se verificata, danno cumulato totale D.

Source code in src/pyntc/checks/steel.py

@ntc_ref(
    article="4.2.4.2",
    formula="4.257",
    latex=r"D = \sum_{i} \frac{n_i}{N_i} \leq 1{,}0",
)
def steel_fatigue_damage(n_cycles: list, N_resistances: list) -> tuple[bool, float]:
    """Danno cumulato a fatica — regola di Miner [4.257].

    NTC18 §4.2.4.2, Formula [4.257]:
        D = sum(n_i / N_i) <= 1.0

    Parameters
    ----------
    n_cycles : list of float
        Numero di cicli applicati per ogni livello di tensione.
    N_resistances : list of float
        Numero di cicli ammissibili per ogni livello di tensione.

    Returns
    -------
    tuple[bool, float]
        (ok, D): True se verificata, danno cumulato totale D.
    """
    D = sum(n / N for n, N in zip(n_cycles, N_resistances))
    return (D <= 1.0, D)

steel_fatigue_normal_stress_check(delta_sigma_max, delta_sigma_D, gamma_MT=1.0)

Verifica a fatica — tensione normale massima [4.255].

NTC18 §4.2.4.2, Formula [4.255]: delta_sigma_max,d = gamma_MT * delta_sigma_max <= delta_sigma_D

Parameters

delta_sigma_max : float Variazione massima di tensione normale caratteristica [N/mm^2]. delta_sigma_D : float Limite di resistenza a fatica per tensioni normali [N/mm^2]. gamma_MT : float Coefficiente di danno a fatica (default 1.0).

Returns

tuple[bool, float] (ok, ratio): True se verificata, rapporto delta_sigma_max,d/delta_sigma_D.

Source code in src/pyntc/checks/steel.py

@ntc_ref(
    article="4.2.4.2",
    formula="4.255",
    latex=r"\Delta\sigma_{max,d} = \gamma_{MT} \cdot \Delta\sigma_{max} \leq \Delta\sigma_{D}",
)
def steel_fatigue_normal_stress_check(
    delta_sigma_max: float, delta_sigma_D: float, gamma_MT: float = 1.0
) -> tuple[bool, float]:
    """Verifica a fatica — tensione normale massima [4.255].

    NTC18 §4.2.4.2, Formula [4.255]:
        delta_sigma_max,d = gamma_MT * delta_sigma_max <= delta_sigma_D

    Parameters
    ----------
    delta_sigma_max : float
        Variazione massima di tensione normale caratteristica [N/mm^2].
    delta_sigma_D : float
        Limite di resistenza a fatica per tensioni normali [N/mm^2].
    gamma_MT : float
        Coefficiente di danno a fatica (default 1.0).

    Returns
    -------
    tuple[bool, float]
        (ok, ratio): True se verificata, rapporto delta_sigma_max,d/delta_sigma_D.
    """
    delta_sigma_d = gamma_MT * delta_sigma_max
    ratio = delta_sigma_d / delta_sigma_D
    return (ratio <= 1.0, ratio)

steel_fatigue_shear_stress_check(delta_tau_max, delta_tau_D, gamma_MT=1.0)

Verifica a fatica — tensione tangenziale massima [4.256].

NTC18 §4.2.4.2, Formula [4.256]: delta_tau_max,d = gamma_MT * delta_tau_max <= delta_tau_D

Parameters

delta_tau_max : float Variazione massima di tensione tangenziale caratteristica [N/mm^2]. delta_tau_D : float Limite di resistenza a fatica per tensioni tangenziali [N/mm^2]. gamma_MT : float Coefficiente di danno a fatica (default 1.0).

Returns

tuple[bool, float] (ok, ratio): True se verificata, rapporto delta_tau_max,d/delta_tau_D.

Source code in src/pyntc/checks/steel.py

@ntc_ref(
    article="4.2.4.2",
    formula="4.256",
    latex=r"\Delta\tau_{max,d} = \gamma_{MT} \cdot \Delta\tau_{max} \leq \Delta\tau_{D}",
)
def steel_fatigue_shear_stress_check(
    delta_tau_max: float, delta_tau_D: float, gamma_MT: float = 1.0
) -> tuple[bool, float]:
    """Verifica a fatica — tensione tangenziale massima [4.256].

    NTC18 §4.2.4.2, Formula [4.256]:
        delta_tau_max,d = gamma_MT * delta_tau_max <= delta_tau_D

    Parameters
    ----------
    delta_tau_max : float
        Variazione massima di tensione tangenziale caratteristica [N/mm^2].
    delta_tau_D : float
        Limite di resistenza a fatica per tensioni tangenziali [N/mm^2].
    gamma_MT : float
        Coefficiente di danno a fatica (default 1.0).

    Returns
    -------
    tuple[bool, float]
        (ok, ratio): True se verificata, rapporto delta_tau_max,d/delta_tau_D.
    """
    delta_tau_d = gamma_MT * delta_tau_max
    ratio = delta_tau_d / delta_tau_D
    return (ratio <= 1.0, ratio)

steel_grade_properties(grade, thickness)

Proprieta' acciaio da Tab. 4.2.I [N/mm^2].

NTC18 §4.2.1.1, Tab. 4.2.I — Tensione di snervamento f_yk e tensione di rottura f_tk per laminati a caldo (EN 10025).

Parameters

grade : str Grado dell'acciaio: "S235", "S275", "S355", "S420", "S450", "S460". thickness : float Spessore nominale dell'elemento [mm]. Deve essere 0 < t <= 80 mm.

Returns

tuple[float, float] (f_yk, f_tk): tensione di snervamento e di rottura [N/mm^2].

Source code in src/pyntc/checks/steel.py

@ntc_ref(article="4.2.1.1", table="Tab.4.2.I", latex=r"\text{Tab.\,4.2.I}")
def steel_grade_properties(
    grade: str, thickness: float
) -> tuple[float, float]:
    """Proprieta' acciaio da Tab. 4.2.I [N/mm^2].

    NTC18 §4.2.1.1, Tab. 4.2.I — Tensione di snervamento f_yk e
    tensione di rottura f_tk per laminati a caldo (EN 10025).

    Parameters
    ----------
    grade : str
        Grado dell'acciaio: "S235", "S275", "S355", "S420", "S450", "S460".
    thickness : float
        Spessore nominale dell'elemento [mm]. Deve essere 0 < t <= 80 mm.

    Returns
    -------
    tuple[float, float]
        (f_yk, f_tk): tensione di snervamento e di rottura [N/mm^2].
    """
    key = grade.upper()
    if key not in _STEEL_GRADES:
        raise ValueError(
            f"grade deve essere S235, S275, S355, S420, S450 o S460, "
            f"ricevuto: '{grade}'"
        )
    if thickness <= 0 or thickness > 80.0:
        raise ValueError(
            f"thickness deve essere 0 < t <= 80 mm, ricevuto: {thickness}"
        )
    for t_max, f_yk, f_tk in _STEEL_GRADES[key]:
        if thickness <= t_max:
            return f_yk, f_tk
    # Fallback (non raggiungibile per thickness <= 80)
    raise ValueError(f"thickness fuori range: {thickness}")  # pragma: no cover

steel_lt_buckling_reduction(lambda_LT_bar, alpha_LT)

Coefficiente di riduzione per instabilita' flesso-torsionale chi_LT [-].

NTC18 §4.2.4.1.3.2, Formula [4.2.50] (metodo generale): Phi_LT = 0.5 * [1 + alpha_LT * (lambda_LT_bar - 0.2) + lambda_LT_bar^2] chi_LT = 1 / (Phi_LT + sqrt(Phi_LT^2 - lambda_LT_bar^2)) con chi_LT <= 1.0.

Per lambda_LT_bar <= 0.2 si assume chi_LT = 1.0.

Parameters

lambda_LT_bar : float Snellezza adimensionale flesso-torsionale [-]. alpha_LT : float Fattore di imperfezione flesso-torsionale [-].

Returns

float Coefficiente di riduzione chi_LT [-], 0 < chi_LT <= 1.

Source code in src/pyntc/checks/steel.py

@ntc_ref(article="4.2.4.1.3.2", formula="4.2.50", latex=r"\chi_{LT} = \frac{1}{\Phi_{LT} + \sqrt{\Phi_{LT}^2 - \bar{\lambda}_{LT}^2}}")
def steel_lt_buckling_reduction(
    lambda_LT_bar: float, alpha_LT: float
) -> float:
    """Coefficiente di riduzione per instabilita' flesso-torsionale chi_LT [-].

    NTC18 §4.2.4.1.3.2, Formula [4.2.50] (metodo generale):
        Phi_LT = 0.5 * [1 + alpha_LT * (lambda_LT_bar - 0.2) + lambda_LT_bar^2]
        chi_LT = 1 / (Phi_LT + sqrt(Phi_LT^2 - lambda_LT_bar^2))
    con chi_LT <= 1.0.

    Per lambda_LT_bar <= 0.2 si assume chi_LT = 1.0.

    Parameters
    ----------
    lambda_LT_bar : float
        Snellezza adimensionale flesso-torsionale [-].
    alpha_LT : float
        Fattore di imperfezione flesso-torsionale [-].

    Returns
    -------
    float
        Coefficiente di riduzione chi_LT [-], 0 < chi_LT <= 1.
    """
    if lambda_LT_bar < 0:
        raise ValueError("lambda_LT_bar deve essere >= 0")
    if alpha_LT < 0:
        raise ValueError("alpha_LT deve essere >= 0")

    if lambda_LT_bar <= 0.2:
        return 1.0

    Phi_LT = 0.5 * (1.0 + alpha_LT * (lambda_LT_bar - 0.2) + lambda_LT_bar ** 2)
    chi_LT = 1.0 / (Phi_LT + math.sqrt(Phi_LT ** 2 - lambda_LT_bar ** 2))
    return min(chi_LT, 1.0)

steel_lt_buckling_resistance(chi_LT, W_y, f_yk, gamma_M1)

Resistenza ad instabilita' flesso-torsionale [N*mm].

NTC18 §4.2.4.1.3.2, Formula [4.2.49]: M_b,Rd = chi_LT * W_y * f_yk / gamma_M1

Parameters

chi_LT : float Coefficiente di riduzione flesso-torsionale [-]. W_y : float Modulo di resistenza rispetto all'asse forte [mm^3]. f_yk : float Tensione di snervamento [N/mm^2]. gamma_M1 : float Coefficiente parziale gamma_M1 [-].

Returns

float M_b,Rd: resistenza ad instabilita' flesso-torsionale [N*mm].

Source code in src/pyntc/checks/steel.py

@ntc_ref(article="4.2.4.1.3.2", formula="4.2.49", latex=r"M_{b,Rd} = \frac{\chi_{LT} \cdot W_y \cdot f_{yk}}{\gamma_{M1}}")
def steel_lt_buckling_resistance(
    chi_LT: float, W_y: float, f_yk: float, gamma_M1: float
) -> float:
    """Resistenza ad instabilita' flesso-torsionale [N*mm].

    NTC18 §4.2.4.1.3.2, Formula [4.2.49]:
        M_b,Rd = chi_LT * W_y * f_yk / gamma_M1

    Parameters
    ----------
    chi_LT : float
        Coefficiente di riduzione flesso-torsionale [-].
    W_y : float
        Modulo di resistenza rispetto all'asse forte [mm^3].
    f_yk : float
        Tensione di snervamento [N/mm^2].
    gamma_M1 : float
        Coefficiente parziale gamma_M1 [-].

    Returns
    -------
    float
        M_b,Rd: resistenza ad instabilita' flesso-torsionale [N*mm].
    """
    if chi_LT <= 0 or chi_LT > 1:
        raise ValueError("chi_LT deve essere 0 < chi_LT <= 1")
    if W_y <= 0:
        raise ValueError("W_y deve essere > 0")
    if f_yk <= 0:
        raise ValueError("f_yk deve essere > 0")
    if gamma_M1 <= 0:
        raise ValueError("gamma_M1 deve essere > 0")
    return chi_LT * W_y * f_yk / gamma_M1

steel_ltb_check(M_Ed, M_b_Rd)

Verifica a instabilita' laterale torsionale [4.248].

NTC18 §4.2.4.1.3.2, Formula [4.248]: M_Ed / M_b,Rd <= 1

Parameters

M_Ed : float Momento flettente di progetto [Nmm]. M_b_Rd : float Resistenza LTB di progetto [Nmm].

Returns

tuple[bool, float] (ok, ratio): True se verificata, rapporto M_Ed/M_b_Rd.

Source code in src/pyntc/checks/steel.py

@ntc_ref(
    article="4.2.4.1.3.2",
    formula="4.248",
    latex=r"\frac{M_{Ed}}{M_{b,Rd}} \leq 1",
)
def steel_ltb_check(M_Ed: float, M_b_Rd: float) -> tuple[bool, float]:
    """Verifica a instabilita' laterale torsionale [4.248].

    NTC18 §4.2.4.1.3.2, Formula [4.248]:
        M_Ed / M_b,Rd <= 1

    Parameters
    ----------
    M_Ed : float
        Momento flettente di progetto [N*mm].
    M_b_Rd : float
        Resistenza LTB di progetto [N*mm].

    Returns
    -------
    tuple[bool, float]
        (ok, ratio): True se verificata, rapporto M_Ed/M_b_Rd.
    """
    ratio = M_Ed / M_b_Rd
    return (ratio <= 1.0, ratio)

steel_ltb_correction_factor(lambda_LT, k_c=0.94)

Fattore correttivo f per riduzione LTB [4.252].

NTC18 §4.2.4.1.3.2, Formula [4.252]: f = 1 - 0.5(1 - k_c)(1 - 2(lambda_LT - 0.8)*2) f <= 1.0

Parameters

lambda_LT : float Snellezza relativa LTB [-]. k_c : float Fattore di conversione (default 0.94 per carico uniforme).

Returns

float f: fattore correttivo [-].

Source code in src/pyntc/checks/steel.py

@ntc_ref(
    article="4.2.4.1.3.2",
    formula="4.252",
    latex=r"f = 1 - 0.5\,(1 - k_c)\,\left[1 - 2\,(\bar{\lambda}_{LT} - 0.8)^2\right]",
)
def steel_ltb_correction_factor(lambda_LT: float, k_c: float = 0.94) -> float:
    """Fattore correttivo f per riduzione LTB [4.252].

    NTC18 §4.2.4.1.3.2, Formula [4.252]:
        f = 1 - 0.5*(1 - k_c)*(1 - 2*(lambda_LT - 0.8)**2)
        f <= 1.0

    Parameters
    ----------
    lambda_LT : float
        Snellezza relativa LTB [-].
    k_c : float
        Fattore di conversione (default 0.94 per carico uniforme).

    Returns
    -------
    float
        f: fattore correttivo [-].
    """
    if lambda_LT <= 0:
        raise ValueError("lambda_LT deve essere > 0")
    f = 1.0 - 0.5 * (1.0 - k_c) * (1.0 - 2.0 * (lambda_LT - 0.8) ** 2)
    return min(f, 1.0)

steel_ltb_reduction_factor(lambda_LT, alpha_LT=0.34, lambda_LT0=0.4, beta=0.75, f_corr=1.0)

Fattore di riduzione chi_LT per instabilita' laterale torsionale [4.250].

NTC18 §4.2.4.1.3.2, Formula [4.250]: Phi_LT = 0.5(1 + alpha_LT(lambda_LT - lambda_LT0) + betalambda_LT2) chi_LT = (1/f_corr) * 1/(Phi_LT + sqrt(Phi_LT2 - betalambda_LT2)) chi_LT <= min(1.0, 1/lambda_LT2)

Parameters

lambda_LT : float Snellezza relativa LTB [-]. alpha_LT : float Fattore di imperfezione (curva a=0.21, b=0.34, c=0.49, d=0.76). lambda_LT0 : float Snellezza limite (default NTC18 = 0.4). beta : float Parametro riduzione (default NTC18 = 0.75). f_corr : float Fattore correttivo f da Formula [4.252] (default 1.0).

Returns

float chi_LT: fattore di riduzione LTB [-].

Source code in src/pyntc/checks/steel.py

@ntc_ref(
    article="4.2.4.1.3.2",
    formula="4.250",
    latex=r"\chi_{LT} = \frac{1}{\Phi_{LT} + \sqrt{\Phi_{LT}^2 - \beta\,\bar{\lambda}_{LT}^2}}",
)
def steel_ltb_reduction_factor(
    lambda_LT: float,
    alpha_LT: float = 0.34,
    lambda_LT0: float = 0.4,
    beta: float = 0.75,
    f_corr: float = 1.0,
) -> float:
    """Fattore di riduzione chi_LT per instabilita' laterale torsionale [4.250].

    NTC18 §4.2.4.1.3.2, Formula [4.250]:
        Phi_LT = 0.5*(1 + alpha_LT*(lambda_LT - lambda_LT0) + beta*lambda_LT**2)
        chi_LT = (1/f_corr) * 1/(Phi_LT + sqrt(Phi_LT**2 - beta*lambda_LT**2))
        chi_LT <= min(1.0, 1/lambda_LT**2)

    Parameters
    ----------
    lambda_LT : float
        Snellezza relativa LTB [-].
    alpha_LT : float
        Fattore di imperfezione (curva a=0.21, b=0.34, c=0.49, d=0.76).
    lambda_LT0 : float
        Snellezza limite (default NTC18 = 0.4).
    beta : float
        Parametro riduzione (default NTC18 = 0.75).
    f_corr : float
        Fattore correttivo f da Formula [4.252] (default 1.0).

    Returns
    -------
    float
        chi_LT: fattore di riduzione LTB [-].
    """
    if lambda_LT <= lambda_LT0:
        return 1.0
    phi = 0.5 * (1.0 + alpha_LT * (lambda_LT - lambda_LT0) + beta * lambda_LT ** 2)
    chi_raw = 1.0 / (phi + math.sqrt(phi ** 2 - beta * lambda_LT ** 2))
    chi_LT = chi_raw / f_corr
    return min(chi_LT, 1.0, 1.0 / lambda_LT ** 2)

steel_ltb_resistance(chi_LT, W_y, f_yk, gamma_M1=1.05)

Resistenza a instabilita' laterale torsionale M_b,Rd [4.249].

NTC18 §4.2.4.1.3.2, Formula [4.249]: M_b,Rd = chi_LT * W_y * f_yk / gamma_M1

Parameters

chi_LT : float Fattore di riduzione LTB [-]. W_y : float Modulo di resistenza plastico rispetto all'asse forte [mm^3]. f_yk : float Tensione caratteristica di snervamento [N/mm^2]. gamma_M1 : float Coefficiente parziale gamma_M1 (default 1.05).

Returns

float M_b,Rd: resistenza LTB [N*mm].

Source code in src/pyntc/checks/steel.py

@ntc_ref(
    article="4.2.4.1.3.2",
    formula="4.249",
    latex=r"M_{b,Rd} = \chi_{LT}\,W_y\,\frac{f_{yk}}{\gamma_{M1}}",
)
def steel_ltb_resistance(
    chi_LT: float, W_y: float, f_yk: float, gamma_M1: float = 1.05
) -> float:
    """Resistenza a instabilita' laterale torsionale M_b,Rd [4.249].

    NTC18 §4.2.4.1.3.2, Formula [4.249]:
        M_b,Rd = chi_LT * W_y * f_yk / gamma_M1

    Parameters
    ----------
    chi_LT : float
        Fattore di riduzione LTB [-].
    W_y : float
        Modulo di resistenza plastico rispetto all'asse forte [mm^3].
    f_yk : float
        Tensione caratteristica di snervamento [N/mm^2].
    gamma_M1 : float
        Coefficiente parziale gamma_M1 (default 1.05).

    Returns
    -------
    float
        M_b,Rd: resistenza LTB [N*mm].
    """
    return chi_LT * W_y * f_yk / gamma_M1

steel_ltb_slenderness(W_y, f_yk, M_cr)

Snellezza relativa per instabilita' laterale torsionale [4.251].

NTC18 §4.2.4.1.3.2, Formula [4.251]: lambda_LT = sqrt(W_y * f_yk / M_cr)

Parameters

W_y : float Modulo di resistenza plastico (o elastico) rispetto all'asse forte [mm^3]. f_yk : float Tensione caratteristica di snervamento [N/mm^2]. M_cr : float Momento critico elastico di instabilita' laterale torsionale [N*mm].

Returns

float lambda_LT: snellezza relativa LTB [-].

Source code in src/pyntc/checks/steel.py

@ntc_ref(
    article="4.2.4.1.3.2",
    formula="4.251",
    latex=r"\bar{\lambda}_{LT} = \sqrt{\frac{W_y \cdot f_{yk}}{M_{cr}}}",
)
def steel_ltb_slenderness(W_y: float, f_yk: float, M_cr: float) -> float:
    """Snellezza relativa per instabilita' laterale torsionale [4.251].

    NTC18 §4.2.4.1.3.2, Formula [4.251]:
        lambda_LT = sqrt(W_y * f_yk / M_cr)

    Parameters
    ----------
    W_y : float
        Modulo di resistenza plastico (o elastico) rispetto all'asse forte [mm^3].
    f_yk : float
        Tensione caratteristica di snervamento [N/mm^2].
    M_cr : float
        Momento critico elastico di instabilita' laterale torsionale [N*mm].

    Returns
    -------
    float
        lambda_LT: snellezza relativa LTB [-].
    """
    if W_y <= 0:
        raise ValueError("W_y deve essere > 0")
    if f_yk <= 0:
        raise ValueError("f_yk deve essere > 0")
    if M_cr <= 0:
        raise ValueError("M_cr deve essere > 0")
    return math.sqrt(W_y * f_yk / M_cr)

steel_relative_slenderness(A_or_A_eff, f_yk, N_cr, section_class=1)

Snellezza adimensionale per aste compresse [-].

NTC18 §4.2.4.1.3.1: Classi 1, 2, 3 — Formula [4.2.45]: lambda_bar = sqrt(A * f_yk / N_cr) Classe 4 — Formula [4.2.46]: lambda_bar = sqrt(A_eff * f_yk / N_cr)

Parameters

A_or_A_eff : float Area lorda A (classi 1-3) o area efficace A_eff (classe 4) [mm^2]. f_yk : float Tensione di snervamento caratteristica [N/mm^2]. N_cr : float Carico critico euleriano [N]. section_class : int Classe della sezione: 1, 2, 3 → Formula [4.2.45]; 4 → Formula [4.2.46]. Default: 1.

Returns

float lambda_bar: snellezza adimensionale [-].

Source code in src/pyntc/checks/steel.py

@ntc_ref(
    article="4.2.4.1.3.1",
    formula="4.2.45",
    latex=(
        r"\bar{\lambda} = \sqrt{\frac{A \cdot f_{yk}}{N_{cr}}}"
        r"\quad \text{(cl.\,1\text{-}3)} \;"
        r";\quad \bar{\lambda} = \sqrt{\frac{A_{\text{eff}} \cdot f_{yk}}{N_{cr}}}"
        r"\quad \text{(cl.\,4)}"
    ),
)
def steel_relative_slenderness(
    A_or_A_eff: float,
    f_yk: float,
    N_cr: float,
    section_class: int = 1,
) -> float:
    """Snellezza adimensionale per aste compresse [-].

    NTC18 §4.2.4.1.3.1:
        Classi 1, 2, 3 — Formula [4.2.45]:
            lambda_bar = sqrt(A * f_yk / N_cr)
        Classe 4 — Formula [4.2.46]:
            lambda_bar = sqrt(A_eff * f_yk / N_cr)

    Parameters
    ----------
    A_or_A_eff : float
        Area lorda A (classi 1-3) o area efficace A_eff (classe 4) [mm^2].
    f_yk : float
        Tensione di snervamento caratteristica [N/mm^2].
    N_cr : float
        Carico critico euleriano [N].
    section_class : int
        Classe della sezione: 1, 2, 3 → Formula [4.2.45];
        4 → Formula [4.2.46]. Default: 1.

    Returns
    -------
    float
        lambda_bar: snellezza adimensionale [-].
    """
    if A_or_A_eff <= 0:
        raise ValueError("A_or_A_eff deve essere > 0")
    if f_yk <= 0:
        raise ValueError("f_yk deve essere > 0")
    if N_cr <= 0:
        raise ValueError("N_cr deve essere > 0")
    if section_class not in (1, 2, 3, 4):
        raise ValueError("section_class deve essere 1, 2, 3 o 4")
    return math.sqrt(A_or_A_eff * f_yk / N_cr)

steel_shear_area(section, A, *, b=None, t_f=None, t_w=None, r=0.0, h=None, hw_tw_sum=None, load_direction='height')

Area resistente a taglio A_v per diversi profili [mm^2].

NTC18 §4.2.4.1.2.4, Formule [4.2.18]–[4.2.23]: - "I_H_rolled": A_v = A - 2bt_f + (t_w + 2r)t_f [4.2.18] - "I_H_weld": A_v = A - 2bt_f + (t_w + r)t_f [4.2.19] - "box": A_v = A - hw_tw_sum [4.2.20] - "T": A_v = 0.9(A - bt_f) [4.2.21] - "rectangular": A_v = Ah/(b+h) o Ab/(b+h) [4.2.22] - "circular": A_v = 2A/pi [4.2.23]

Parameters

section : str Tipo di sezione: "I_H_rolled", "I_H_weld", "box", "T", "rectangular", "circular". A : float Area totale della sezione [mm^2]. b : float, optional Larghezza delle ali [mm]. t_f : float, optional Spessore delle ali [mm]. t_w : float, optional Spessore dell'anima [mm]. r : float, optional Raccordo d'angolo o gola della saldatura [mm]. Default 0. h : float, optional Altezza del profilo [mm] (per sezione rettangolare). hw_tw_sum : float, optional Somma (h_w * t_w) delle anime [mm^2] (per sezione scatolare). load_direction : str, optional Direzione del carico per sezione rettangolare: "height" (carico parallelo all'altezza) o "width". Default "height".

Returns

float A_v: area resistente a taglio [mm^2].

Source code in src/pyntc/checks/steel.py

@ntc_ref(
    article="4.2.4.1.2.4",
    formula="4.2.18",
    latex=(
        r"A_v = \begin{cases}"
        r"A - 2bt_f + (t_w + 2r)t_f & \text{I/H laminati}\\"
        r"A - 2bt_f + (t_w + r)t_f & \text{I/H saldati}\\"
        r"A - \sum h_w t_w & \text{scatolare}\\"
        r"0{,}9(A - b t_f) & \text{T}\\"
        r"2A/\pi & \text{circolare piena}"
        r"\end{cases}"
    ),
)
def steel_shear_area(
    section: str,
    A: float,
    *,
    b: float | None = None,
    t_f: float | None = None,
    t_w: float | None = None,
    r: float = 0.0,
    h: float | None = None,
    hw_tw_sum: float | None = None,
    load_direction: str = "height",
) -> float:
    """Area resistente a taglio A_v per diversi profili [mm^2].

    NTC18 §4.2.4.1.2.4, Formule [4.2.18]–[4.2.23]:
    - "I_H_rolled": A_v = A - 2*b*t_f + (t_w + 2*r)*t_f  [4.2.18]
    - "I_H_weld":   A_v = A - 2*b*t_f + (t_w + r)*t_f    [4.2.19]
    - "box":        A_v = A - hw_tw_sum                    [4.2.20]
    - "T":          A_v = 0.9*(A - b*t_f)                 [4.2.21]
    - "rectangular": A_v = A*h/(b+h) o A*b/(b+h)          [4.2.22]
    - "circular":   A_v = 2*A/pi                           [4.2.23]

    Parameters
    ----------
    section : str
        Tipo di sezione: "I_H_rolled", "I_H_weld", "box", "T",
        "rectangular", "circular".
    A : float
        Area totale della sezione [mm^2].
    b : float, optional
        Larghezza delle ali [mm].
    t_f : float, optional
        Spessore delle ali [mm].
    t_w : float, optional
        Spessore dell'anima [mm].
    r : float, optional
        Raccordo d'angolo o gola della saldatura [mm]. Default 0.
    h : float, optional
        Altezza del profilo [mm] (per sezione rettangolare).
    hw_tw_sum : float, optional
        Somma (h_w * t_w) delle anime [mm^2] (per sezione scatolare).
    load_direction : str, optional
        Direzione del carico per sezione rettangolare:
        "height" (carico parallelo all'altezza) o "width". Default "height".

    Returns
    -------
    float
        A_v: area resistente a taglio [mm^2].
    """
    if A <= 0:
        raise ValueError("A deve essere > 0")

    if section in ("I_H_rolled", "I_H_weld"):
        if b is None or t_f is None or t_w is None:
            raise ValueError(
                f"Per section='{section}' sono richiesti b, t_f, t_w"
            )
        factor = 2.0 if section == "I_H_rolled" else 1.0
        return A - 2.0 * b * t_f + (t_w + factor * r) * t_f

    elif section == "box":
        if hw_tw_sum is None:
            raise ValueError("Per section='box' è richiesto hw_tw_sum")
        return A - hw_tw_sum

    elif section == "T":
        if b is None or t_f is None:
            raise ValueError("Per section='T' sono richiesti b e t_f")
        return 0.9 * (A - b * t_f)

    elif section == "rectangular":
        if b is None or h is None:
            raise ValueError("Per section='rectangular' sono richiesti b e h")
        if load_direction == "height":
            return A * h / (b + h)
        elif load_direction == "width":
            return A * b / (b + h)
        else:
            raise ValueError(
                "load_direction deve essere 'height' o 'width'"
            )

    elif section == "circular":
        return 2.0 * A / math.pi

    else:
        raise ValueError(
            f"section '{section}' non riconosciuto. "
            "Valori ammessi: 'I_H_rolled', 'I_H_weld', 'box', 'T', "
            "'rectangular', 'circular'."
        )

steel_shear_resistance(A_v, f_yk, gamma_M0)

Resistenza a taglio della sezione [N].

NTC18 §4.2.4.1.2.4, Formula [4.2.17]: V_c,Rd = A_v * f_yk / (sqrt(3) * gamma_M0)

Parameters

A_v : float Area resistente a taglio [mm^2]. f_yk : float Tensione di snervamento [N/mm^2]. gamma_M0 : float Coefficiente parziale gamma_M0 [-].

Returns

float V_c,Rd: resistenza a taglio [N].

Source code in src/pyntc/checks/steel.py

@ntc_ref(article="4.2.4.1.2.4", formula="4.2.17", latex=r"V_{c,Rd} = \frac{A_v \cdot f_{yk}}{\sqrt{3} \cdot \gamma_{M0}}")
def steel_shear_resistance(
    A_v: float, f_yk: float, gamma_M0: float
) -> float:
    """Resistenza a taglio della sezione [N].

    NTC18 §4.2.4.1.2.4, Formula [4.2.17]:
        V_c,Rd = A_v * f_yk / (sqrt(3) * gamma_M0)

    Parameters
    ----------
    A_v : float
        Area resistente a taglio [mm^2].
    f_yk : float
        Tensione di snervamento [N/mm^2].
    gamma_M0 : float
        Coefficiente parziale gamma_M0 [-].

    Returns
    -------
    float
        V_c,Rd: resistenza a taglio [N].
    """
    if A_v <= 0:
        raise ValueError("A_v deve essere > 0")
    if f_yk <= 0:
        raise ValueError("f_yk deve essere > 0")
    if gamma_M0 <= 0:
        raise ValueError("gamma_M0 deve essere > 0")
    return A_v * f_yk / (math.sqrt(3) * gamma_M0)

steel_tension_resistance(A, f_yk, gamma_M0, *, A_net=None, f_tk=None, gamma_M2=None)

Resistenza a trazione della sezione [N].

NTC18 §4.2.4.1.2.1 — Formule [4.2.6] e [4.2.7]: N_pl,Rd = A * f_yk / gamma_M0 (plasticizzazione lorda) N_u,Rd = 0.9 * A_net * f_tk / gamma_M2 (rottura sezione netta)

Parameters

A : float Area lorda della sezione [mm^2]. f_yk : float Tensione di snervamento [N/mm^2]. gamma_M0 : float Coefficiente parziale gamma_M0 [-]. A_net : float or None Area netta della sezione (fori bulloni) [mm^2]. f_tk : float or None Tensione di rottura [N/mm^2]. Richiesto se A_net fornito. gamma_M2 : float or None Coefficiente parziale gamma_M2 [-]. Richiesto se A_net fornito.

Returns

tuple[float, float | None] (N_pl_Rd, N_u_Rd): resistenza plastica e a rottura [N]. N_u_Rd e' None se A_net non e' fornito.

Source code in src/pyntc/checks/steel.py

@ntc_ref(article="4.2.4.1.2.1", formula="4.2.6", latex=r"N_{pl,Rd} = \frac{A \cdot f_{yk}}{\gamma_{M0}}")
def steel_tension_resistance(
    A: float,
    f_yk: float,
    gamma_M0: float,
    *,
    A_net: float | None = None,
    f_tk: float | None = None,
    gamma_M2: float | None = None,
) -> tuple[float, float | None]:
    """Resistenza a trazione della sezione [N].

    NTC18 §4.2.4.1.2.1 — Formule [4.2.6] e [4.2.7]:
        N_pl,Rd = A * f_yk / gamma_M0       (plasticizzazione lorda)
        N_u,Rd  = 0.9 * A_net * f_tk / gamma_M2  (rottura sezione netta)

    Parameters
    ----------
    A : float
        Area lorda della sezione [mm^2].
    f_yk : float
        Tensione di snervamento [N/mm^2].
    gamma_M0 : float
        Coefficiente parziale gamma_M0 [-].
    A_net : float or None
        Area netta della sezione (fori bulloni) [mm^2].
    f_tk : float or None
        Tensione di rottura [N/mm^2]. Richiesto se A_net fornito.
    gamma_M2 : float or None
        Coefficiente parziale gamma_M2 [-]. Richiesto se A_net fornito.

    Returns
    -------
    tuple[float, float | None]
        (N_pl_Rd, N_u_Rd): resistenza plastica e a rottura [N].
        N_u_Rd e' None se A_net non e' fornito.
    """
    if A <= 0:
        raise ValueError("A deve essere > 0")
    if f_yk <= 0:
        raise ValueError("f_yk deve essere > 0")
    if gamma_M0 <= 0:
        raise ValueError("gamma_M0 deve essere > 0")

    N_pl_Rd = A * f_yk / gamma_M0

    if A_net is not None:
        if f_tk is None or gamma_M2 is None:
            raise ValueError(
                "f_tk e gamma_M2 sono richiesti quando si fornisce A_net"
            )
        if A_net <= 0:
            raise ValueError("A_net deve essere > 0")
        N_u_Rd = 0.9 * A_net * f_tk / gamma_M2
        return N_pl_Rd, N_u_Rd

    return N_pl_Rd, None

steel_torsion_check(T_Ed, T_Rd)

Verifica a torsione della sezione [-].

NTC18 §4.2.4.1.2.5, Formula [4.2.28]: T_Ed / T_Rd <= 1.0

Parameters

T_Ed : float Momento torcente di progetto [Nmm]. T_Rd : float Resistenza a torsione della sezione [Nmm].

Returns

tuple[bool, float] (verifica_superata, utilization): - verifica_superata: True se T_Ed / T_Rd <= 1.0 - utilization: rapporto T_Ed / T_Rd [-]

Source code in src/pyntc/checks/steel.py

@ntc_ref(
    article="4.2.4.1.2.5",
    formula="4.2.28",
    latex=r"\frac{T_{Ed}}{T_{Rd}} \le 1{,}0",
)
def steel_torsion_check(T_Ed: float, T_Rd: float) -> tuple[bool, float]:
    """Verifica a torsione della sezione [-].

    NTC18 §4.2.4.1.2.5, Formula [4.2.28]:
        T_Ed / T_Rd <= 1.0

    Parameters
    ----------
    T_Ed : float
        Momento torcente di progetto [N*mm].
    T_Rd : float
        Resistenza a torsione della sezione [N*mm].

    Returns
    -------
    tuple[bool, float]
        (verifica_superata, utilization):
        - verifica_superata: True se T_Ed / T_Rd <= 1.0
        - utilization: rapporto T_Ed / T_Rd [-]
    """
    if T_Rd <= 0:
        raise ValueError("T_Rd deve essere > 0")
    if T_Ed < 0:
        raise ValueError("T_Ed deve essere >= 0")
    utilization = T_Ed / T_Rd
    return utilization <= 1.0, utilization

steel_torsion_resistance(W_t, f_yk, gamma_M0=1.0)

Resistenza a torsione della sezione [N*mm].

NTC18 §4.2.4.1.2.5 — Resistenza a torsione (formula standard EN): T_Rd = W_t * f_yk / (sqrt(3) * gamma_M0)

dove W_t e' il modulo resistente a torsione (W_t,el per torsione uniforme, W_t = 2A_mt per sezioni tubolari).

Parameters

W_t : float Modulo resistente a torsione della sezione [mm^3]. f_yk : float Tensione di snervamento caratteristica [N/mm^2]. gamma_M0 : float Coefficiente parziale gamma_M0 [-]. Default NTC18: 1.0.

Returns

float T_Rd: resistenza a torsione [N*mm].

Source code in src/pyntc/checks/steel.py

@ntc_ref(
    article="4.2.4.1.2.5",
    formula="4.2.28",
    latex=r"T_{Rd} = \frac{W_t \cdot f_{yk}}{\sqrt{3} \cdot \gamma_{M0}}",
)
def steel_torsion_resistance(
    W_t: float, f_yk: float, gamma_M0: float = 1.0
) -> float:
    """Resistenza a torsione della sezione [N*mm].

    NTC18 §4.2.4.1.2.5 — Resistenza a torsione (formula standard EN):
        T_Rd = W_t * f_yk / (sqrt(3) * gamma_M0)

    dove W_t e' il modulo resistente a torsione (W_t,el per torsione
    uniforme, W_t = 2*A_m*t per sezioni tubolari).

    Parameters
    ----------
    W_t : float
        Modulo resistente a torsione della sezione [mm^3].
    f_yk : float
        Tensione di snervamento caratteristica [N/mm^2].
    gamma_M0 : float
        Coefficiente parziale gamma_M0 [-]. Default NTC18: 1.0.

    Returns
    -------
    float
        T_Rd: resistenza a torsione [N*mm].
    """
    if W_t <= 0:
        raise ValueError("W_t deve essere > 0")
    if f_yk <= 0:
        raise ValueError("f_yk deve essere > 0")
    if gamma_M0 <= 0:
        raise ValueError("gamma_M0 deve essere > 0")
    return W_t * f_yk / (math.sqrt(3) * gamma_M0)

steel_vertical_deflection(delta1, delta2)

Freccia verticale totale SLE [4.260].

NTC18 §4.2.4.3, Formula [4.260]: delta_tot = delta1 + delta2

Parameters

delta1 : float Freccia da carichi permanenti [mm]. delta2 : float Freccia da carichi variabili [mm].

Returns

float delta_tot: freccia totale [mm].

Source code in src/pyntc/checks/steel.py

@ntc_ref(
    article="4.2.4.3",
    formula="4.260",
    latex=r"\delta_{tot} = \delta_1 + \delta_2",
)
def steel_vertical_deflection(delta1: float, delta2: float) -> float:
    """Freccia verticale totale SLE [4.260].

    NTC18 §4.2.4.3, Formula [4.260]:
        delta_tot = delta1 + delta2

    Parameters
    ----------
    delta1 : float
        Freccia da carichi permanenti [mm].
    delta2 : float
        Freccia da carichi variabili [mm].

    Returns
    -------
    float
        delta_tot: freccia totale [mm].
    """
    return delta1 + delta2

steel_von_mises_check(sigma_x, sigma_y, tau, f_yk, gamma_M0)

Verifica dello stato tensionale equivalente (Von Mises) [-].

NTC18 §4.2.4.1.2, Formula [4.2.4]: sqrt(σ_x² + σ_y² - σ_xσ_y + 3τ²) ≤ f_yk / γ_M0

Parameters

sigma_x : float Tensione normale nella direzione x [N/mm^2]. sigma_y : float Tensione normale nella direzione y [N/mm^2]. tau : float Tensione tangenziale [N/mm^2]. f_yk : float Tensione di snervamento caratteristica [N/mm^2]. gamma_M0 : float Coefficiente parziale gamma_M0 [-].

Returns

tuple[bool, float] (verificata, ratio): verificata = True se ratio <= 1.0; ratio = sigma_eq / (f_yk / gamma_M0).

Source code in src/pyntc/checks/steel.py

@ntc_ref(
    article="4.2.4.1.2",
    formula="4.2.4",
    latex=(
        r"\sqrt{\sigma_x^2 + \sigma_y^2 - \sigma_x\sigma_y + 3\tau^2}"
        r"\le f_{yk}/\gamma_{M0}"
    ),
)
def steel_von_mises_check(
    sigma_x: float,
    sigma_y: float,
    tau: float,
    f_yk: float,
    gamma_M0: float,
) -> tuple[bool, float]:
    """Verifica dello stato tensionale equivalente (Von Mises) [-].

    NTC18 §4.2.4.1.2, Formula [4.2.4]:
        sqrt(σ_x² + σ_y² - σ_x*σ_y + 3*τ²) ≤ f_yk / γ_M0

    Parameters
    ----------
    sigma_x : float
        Tensione normale nella direzione x [N/mm^2].
    sigma_y : float
        Tensione normale nella direzione y [N/mm^2].
    tau : float
        Tensione tangenziale [N/mm^2].
    f_yk : float
        Tensione di snervamento caratteristica [N/mm^2].
    gamma_M0 : float
        Coefficiente parziale gamma_M0 [-].

    Returns
    -------
    tuple[bool, float]
        (verificata, ratio): verificata = True se ratio <= 1.0;
        ratio = sigma_eq / (f_yk / gamma_M0).
    """
    if f_yk <= 0:
        raise ValueError("f_yk deve essere > 0")
    if gamma_M0 <= 0:
        raise ValueError("gamma_M0 deve essere > 0")
    sigma_eq = math.sqrt(sigma_x**2 + sigma_y**2 - sigma_x * sigma_y + 3.0 * tau**2)
    f_limit = f_yk / gamma_M0
    ratio = sigma_eq / f_limit
    return ratio <= 1.0, ratio

weld_combined_stress_check(sigma_perp, tau_perp, tau_par, f_u, beta_w, gamma_M2=1.25)

Verifica tensionale combinata di cordone d'angolo [-].

NTC18 §4.2.8.2.4, Formula [4.2.81]: sqrt(sigma_perp^2 + 3*(tau_perp^2 + tau_par^2)) <= f_u / (beta_w * gamma_M2)

dove

sigma_perp: tensione normale perpendicolare al piano della gola tau_perp: tensione tangenziale perp. all'asse del cordone tau_par: tensione tangenziale parallela all'asse del cordone

Fattore di correlazione beta_w (Tab. 4.2.XIII): S235 → 0.80, S275 → 0.85, S355 → 0.90, S420/S460 → 1.00

Parameters

sigma_perp : float Tensione normale perpendicolare al piano della gola [N/mm^2]. tau_perp : float Tensione tangenziale perpendicolare all'asse del cordone [N/mm^2]. tau_par : float Tensione tangenziale parallela all'asse del cordone [N/mm^2]. f_u : float Tensione di rottura dell'acciaio base [N/mm^2]. beta_w : float Fattore di correlazione [-] (da Tab. 4.2.XIII). gamma_M2 : float Coefficiente parziale gamma_M2 [-]. Default NTC18: 1.25.

Returns

tuple[bool, float] (verifica_superata, ratio): - verifica_superata: True se ratio <= 1.0 - ratio = sqrt(...) / (f_u / (beta_w * gamma_M2)) [-]

Source code in src/pyntc/checks/steel.py

@ntc_ref(
    article="4.2.8.2.4",
    formula="4.2.81",
    latex=(
        r"\sqrt{\sigma_{\perp}^2 + 3(\tau_{\perp}^2 + \tau_{\parallel}^2)}"
        r"\le \frac{f_u}{\beta_w \cdot \gamma_{M2}}"
    ),
)
def weld_combined_stress_check(
    sigma_perp: float,
    tau_perp: float,
    tau_par: float,
    f_u: float,
    beta_w: float,
    gamma_M2: float = 1.25,
) -> tuple[bool, float]:
    """Verifica tensionale combinata di cordone d'angolo [-].

    NTC18 §4.2.8.2.4, Formula [4.2.81]:
        sqrt(sigma_perp^2 + 3*(tau_perp^2 + tau_par^2)) <= f_u / (beta_w * gamma_M2)

    dove:
        sigma_perp: tensione normale perpendicolare al piano della gola
        tau_perp:   tensione tangenziale perp. all'asse del cordone
        tau_par:    tensione tangenziale parallela all'asse del cordone

    Fattore di correlazione beta_w (Tab. 4.2.XIII):
        S235 → 0.80, S275 → 0.85, S355 → 0.90, S420/S460 → 1.00

    Parameters
    ----------
    sigma_perp : float
        Tensione normale perpendicolare al piano della gola [N/mm^2].
    tau_perp : float
        Tensione tangenziale perpendicolare all'asse del cordone [N/mm^2].
    tau_par : float
        Tensione tangenziale parallela all'asse del cordone [N/mm^2].
    f_u : float
        Tensione di rottura dell'acciaio base [N/mm^2].
    beta_w : float
        Fattore di correlazione [-] (da Tab. 4.2.XIII).
    gamma_M2 : float
        Coefficiente parziale gamma_M2 [-]. Default NTC18: 1.25.

    Returns
    -------
    tuple[bool, float]
        (verifica_superata, ratio):
        - verifica_superata: True se ratio <= 1.0
        - ratio = sqrt(...) / (f_u / (beta_w * gamma_M2)) [-]
    """
    if f_u <= 0:
        raise ValueError("f_u deve essere > 0")
    if beta_w <= 0:
        raise ValueError("beta_w deve essere > 0")
    if gamma_M2 <= 0:
        raise ValueError("gamma_M2 deve essere > 0")

    sigma_eq = math.sqrt(sigma_perp**2 + 3.0 * (tau_perp**2 + tau_par**2))
    f_limit = f_u / (beta_w * gamma_M2)
    ratio = sigma_eq / f_limit
    return ratio <= 1.0, ratio

weld_fillet_directional_resistance(a, f_k, beta1, sigma_perp=0.0, tau_perp=0.0, tau_par=0.0, gamma_M2=1.25)

Verifica cordone d'angolo — metodo direzionale [4.283-4.284].

NTC18 §4.2.8.4, Formule [4.283] e [4.284]: F_w,Rd = a * f_k / (sqrt(3) * beta1 * gamma_M2) Verifica: sqrt(sigma_perp^2 + tau_perp^2 + tau_par^2) <= beta1 * f_k

Parameters

a : float Altezza del cordone [mm]. f_k : float Resistenza caratteristica del materiale base [N/mm^2]. beta1 : float Fattore di correlazione (Tab. 4.2.XIII) [-]. sigma_perp : float Tensione normale perpendicolare al piano di gola [N/mm^2]. tau_perp : float Tensione tangenziale perp. all'asse del cordone [N/mm^2]. tau_par : float Tensione tangenziale parallela all'asse del cordone [N/mm^2]. gamma_M2 : float Coefficiente parziale (default 1.25).

Returns

tuple[bool, float] (ok, ratio): True se verificata, rapporto tensione effettiva / limite.

Source code in src/pyntc/checks/steel.py

@ntc_ref(
    article="4.2.8.4",
    formula="4.283",
    latex=r"F_{w,Rd} = \frac{a \cdot f_k}{\sqrt{3} \cdot \beta_1 \cdot \gamma_{M2}}",
)
def weld_fillet_directional_resistance(
    a: float,
    f_k: float,
    beta1: float,
    sigma_perp: float = 0.0,
    tau_perp: float = 0.0,
    tau_par: float = 0.0,
    gamma_M2: float = 1.25,
) -> tuple[bool, float]:
    """Verifica cordone d'angolo — metodo direzionale [4.283-4.284].

    NTC18 §4.2.8.4, Formule [4.283] e [4.284]:
        F_w,Rd = a * f_k / (sqrt(3) * beta1 * gamma_M2)
        Verifica: sqrt(sigma_perp^2 + tau_perp^2 + tau_par^2) <= beta1 * f_k

    Parameters
    ----------
    a : float
        Altezza del cordone [mm].
    f_k : float
        Resistenza caratteristica del materiale base [N/mm^2].
    beta1 : float
        Fattore di correlazione (Tab. 4.2.XIII) [-].
    sigma_perp : float
        Tensione normale perpendicolare al piano di gola [N/mm^2].
    tau_perp : float
        Tensione tangenziale perp. all'asse del cordone [N/mm^2].
    tau_par : float
        Tensione tangenziale parallela all'asse del cordone [N/mm^2].
    gamma_M2 : float
        Coefficiente parziale (default 1.25).

    Returns
    -------
    tuple[bool, float]
        (ok, ratio): True se verificata, rapporto tensione effettiva / limite.
    """
    import math
    limit = beta1 * f_k
    sigma_eff = math.sqrt(sigma_perp**2 + tau_perp**2 + tau_par**2)
    ratio = sigma_eff / limit if limit > 0 else 0.0
    return (ratio <= 1.0, ratio)

weld_fillet_resistance(a, f_tk, beta_w, gamma_M2)

Resistenza per unita' di lunghezza di cordone d'angolo [N/mm].

NTC18 §4.2.8.2.4, Formula [4.2.83]: F_w,Rd = a * f_tk / (sqrt(3) * beta_w * gamma_M2)

Fattore di correlazione beta_w (Tab. 4.2.XIII): S235 → 0.80, S275 → 0.85, S355 → 0.90, S420/S460 → 1.00

Parameters

a : float Altezza di gola del cordone [mm]. f_tk : float Tensione di rottura dell'acciaio base [N/mm^2]. beta_w : float Fattore di correlazione [-] (da Tab. 4.2.XIII). gamma_M2 : float Coefficiente parziale gamma_M2 [-].

Returns

float F_w,Rd: resistenza per unita' di lunghezza [N/mm].

Source code in src/pyntc/checks/steel.py

@ntc_ref(article="4.2.8.2.4", formula="4.2.83", latex=r"F_{w,Rd} = \frac{a \cdot f_{tk}}{\sqrt{3} \cdot \beta_w \cdot \gamma_{M2}}")
def weld_fillet_resistance(
    a: float, f_tk: float, beta_w: float, gamma_M2: float
) -> float:
    """Resistenza per unita' di lunghezza di cordone d'angolo [N/mm].

    NTC18 §4.2.8.2.4, Formula [4.2.83]:
        F_w,Rd = a * f_tk / (sqrt(3) * beta_w * gamma_M2)

    Fattore di correlazione beta_w (Tab. 4.2.XIII):
        S235 → 0.80, S275 → 0.85, S355 → 0.90, S420/S460 → 1.00

    Parameters
    ----------
    a : float
        Altezza di gola del cordone [mm].
    f_tk : float
        Tensione di rottura dell'acciaio base [N/mm^2].
    beta_w : float
        Fattore di correlazione [-] (da Tab. 4.2.XIII).
    gamma_M2 : float
        Coefficiente parziale gamma_M2 [-].

    Returns
    -------
    float
        F_w,Rd: resistenza per unita' di lunghezza [N/mm].
    """
    if a <= 0:
        raise ValueError("a deve essere > 0")
    if f_tk <= 0:
        raise ValueError("f_tk deve essere > 0")
    if beta_w <= 0:
        raise ValueError("beta_w deve essere > 0")
    if gamma_M2 <= 0:
        raise ValueError("gamma_M2 deve essere > 0")
    return a * f_tk / (math.sqrt(3) * beta_w * gamma_M2)

weld_simplified_stress_check(n1, t1, f_k, beta2)

Verifica semplificata cordone d'angolo [4.285].

NTC18 §4.2.8.4, Formula [4.285]: |n1| + |t1| <= beta2 * f_k

Parameters

n1 : float Tensione normale nel cordone [N/mm^2]. t1 : float Tensione tangenziale nel cordone [N/mm^2]. f_k : float Resistenza caratteristica del materiale base [N/mm^2]. beta2 : float Fattore di riduzione semplificato [-].

Returns

tuple[bool, float] (ok, ratio): True se verificata, rapporto (|n1|+|t1|)/(beta2*f_k).

Source code in src/pyntc/checks/steel.py

@ntc_ref(
    article="4.2.8.4",
    formula="4.285",
    latex=r"|n_1| + |t_1| \leq \beta_2 \cdot f_k",
)
def weld_simplified_stress_check(
    n1: float, t1: float, f_k: float, beta2: float
) -> tuple[bool, float]:
    """Verifica semplificata cordone d'angolo [4.285].

    NTC18 §4.2.8.4, Formula [4.285]:
        |n1| + |t1| <= beta2 * f_k

    Parameters
    ----------
    n1 : float
        Tensione normale nel cordone [N/mm^2].
    t1 : float
        Tensione tangenziale nel cordone [N/mm^2].
    f_k : float
        Resistenza caratteristica del materiale base [N/mm^2].
    beta2 : float
        Fattore di riduzione semplificato [-].

    Returns
    -------
    tuple[bool, float]
        (ok, ratio): True se verificata, rapporto (|n1|+|t1|)/(beta2*f_k).
    """
    combined = abs(n1) + abs(t1)
    limit = beta2 * f_k
    ratio = combined / limit if limit > 0 else 0.0
    return (ratio <= 1.0, ratio)