Comprobación de miembros sujetos a fatiga según FEM 2131/2132 (2)

Acero estructural

Ante todo, hay que definir el material de la estructura objeto de estudio. Se seguirán las nomenclaturas ISO y EN 1993. ISO por ser la usada en el código FEM y EN 1993 por corresponder a los Códigos Estructurales y ser de amplia difusión.

Steel (ISO)	Steel (EN 1993)	\(f_y\) [MPa]	\(f_u\) [MPa]
Fe 360	S 235	235	360
Fe 430	S 275	275	430
Fe 510	S 355	355	490

Siendo:

• Steel (ISO): grado de acero según ISO.
• Steel (EN 1993): grado de acero según EN 1993.
• \(f_y\) [MPa]: límite elástico según to EN 1993.
• \(f_u\) [MPa]: límite de rotura según EN 1993.

Defino el grado de acero y lo guardo en la variable steel_grade.

steel_grade = input('Steel grade (Fe 360, Fe 430, Fe 510, S 235, S 275, S 355): ')
if steel_grade not in ['Fe 360', 'Fe 430', 'Fe 510', 'S 235', 'S 275', 'S 355']:
    print('WARNING: wrong steel grade!')

Como estos valores son de uso frecuente los he incluido en una base de datos SQLite que me permite acceder a ellos a demanda. Dejo una copia de esta base de datos de materiales en GitHub.

Indico el directorio donde se encuentra la base de datos con los valores de los materiales y el nombre de la base de datos

cwd = 'midirectorio/SQLite/materiales'
db = 'structural_steel.db'

Conozoco el nombre de la tabla EN_1993-1-1, creo la conexión e importo los datos a un DataFrame de pandas.

import pandas as pd
import squlite3

table = 'EN_1993_1_1'
conn = sqlite3.connect(cwd + '/' + db)
df_steel = pd.read_sql('SELECT * FROM ' + table + ';', conn)

Tengo ya la información del acero en un DataFrame de pandas. La columna de Calidad tiene las referencias de la norma EN 1993. FEM usa las definiciones según ISO. Si he definido el acero según ISO debo hacer que el código sea capaz de encontrar el límite elástico y la tensión de rotura equivalentes. Esto lo consigo con la clase SteelValues.

class SteelValues:
    """Steel grade, elastic limit and ultimate tensile strength."""
    
    def __init__(self, df, steel_grade):
        """
        Asumes steel_grade is the steel grade of the material, get the elastic
        limit fy and the ultimate tensile strength fu of the material.

        Parameters
        ----------
        df          : pandas DataFrame ; characteristic values for the steel.
        steel_grade : str              ; steel grade of the material
        """
        
        self.df = df
        self.steel_grade = steel_grade
        
        self.d = {
            'Fe 360': 'S 235',
            'Fe 430': 'S 275',
            'Fe 510': 'S 355',
            'S 235': 'S 235',
            'S 275': 'S 275',
            'S 355': 'S 355'
            }  # Data with the values to search in the DataFrame.
        
        self.d1 = {
            'Fe 360': 'Fe360',
            'Fe 430': 'Fe430',
            'Fe 510': 'Fe510',
            'S 235': 'Fe360',
            'S 275': 'Fe430',
            'S 355': 'Fe510'
            }  # Data with the values to search in the database.

El método __init__ inicializa las variables self.df con los valores característicos del material y self.steel_grade con el grado de acero.

También inicializa los diccionarios self.d y self.d1. self.d lo emplearé para buscar valores equivalentes en el DataFrame con los valores caracteríticos del material y self.d1 para buscar los valores equivalentes en la base de datos de la tensión básica \(\sigma_W\).

Defino los getters del grado de acero y de la definición del acero para la base de datos de la tensión básica \(\sigma_W\).

    def get_steel_grade(self):
        """Getter of the steel grade of the material."""
        
        return self.steel_grade
    
    def get_steel_for_db(self):
        """Getter of the steel for de database of structural steel."""
        
        return self.d1[self.steel_grade]

El método elastic_limit() me devuelve el límite elástico del acero y el método ultimate_tensile_strength() me devuelve el límite de rotura del acero. Ambos valores son en MPa (o N/mm²).

    def elastic_limit(self):
        """Elastic limit fy."""
        
        sigma_E = self.df.loc[(
            self.df['Calidad'] == self.d[self.steel_grade]) & (
            self.df['tmax'] == 40.0)]['fy'].item()
        
        return sigma_E
    
    def ultimate_tensile_strength(self):
        """Ultimate tensile strength fu."""
        
        sigma_R = self.df.loc[(
            self.df['Calidad'] == self.d[self.steel_grade]) & (
            self.df['tmax'] == 40.0)]['fu'].item()
                
        return sigma_R

Se puede encontrar el script completo en el repositorio de GitHub.

Una vez definada la clase SteelValues puedo crear la instancia de la clase steel_values y acceder a sus atributos.

steel_values = SteelValues(df_steel, steel_grade)
sigma_E = steel_values.elastic_limit()
sigma_R = steel_values.ultimate_tensile_strength()
print(f'Steel grade               : {steel_grade}')
print(f'Elastic limit             : {sigma_E} MPa')
print(f'Ultimate tensile strength : {sigma_R} MPa')
Steel grade               : Fe 360
Elastic limit             : 235.0 MPa
Ultimate tensile strength : 360.0 MPa

Conocidos el número de ciclos (grupo de la componente), el detalle de la entalladura, el grado del acero y las tensiones máximas y mínimas, el siguiente paso será obtener los ratios \(\kappa\) entre las tensiones extremas.