EurocodePy

https://pcachim.github.io/eurocodepy/
Admin
EurocodePy is a Python library providing composable building blocks for structural design...
Tokens:208,839
Snippets:1,154
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install EurocodePy using uv

Source: https://pcachim.github.io/eurocodepy

Installs the EurocodePy library using the uv package manager.

```bash
# With uv
uv add eurocodepy
```

--------------------------------

### Install EurocodePy from PyPI

Source: https://pcachim.github.io/eurocodepy

Installs the EurocodePy library using pip from the Python Package Index.

```bash
# From PyPI
pip install eurocodepy
```

--------------------------------

### Install EurocodePy from GitHub

Source: https://pcachim.github.io/eurocodepy

Installs the latest development version of EurocodePy directly from its GitHub repository using pip.

```bash
# Latest development version from GitHub
pip install git+https://github.com/pcachim/eurocodepy.git
```

--------------------------------

### File Naming Conventions

Source: https://pcachim.github.io/eurocodepy/STYLE_GUIDE

Provides examples of snake_case for file names.

```text
main_script.py
user_profile.py

```

--------------------------------

### Get Soil Seismic Parameters

Source: https://pcachim.github.io/eurocodepy/modules/ec7

Retrieve seismic parameters for a given soil type using `get_soil_seismic_parameters`. This includes the soil amplification factor (S) and shear wave velocity (Vs30).

```python
from eurocodepy.ec7 import SoilSeismicParameters, get_soil_seismic_parameters

params = get_soil_seismic_parameters(soil_type='C')
params.S       # soil amplification factor
params.Vs30    # shear wave velocity [m/s]
```

--------------------------------

### Initialize Concrete, Steel, and Timber Materials

Source: https://pcachim.github.io/eurocodepy

Demonstrates initializing material objects for concrete, steel, and timber using their respective classes from the EurocodePy library. Shows how to access characteristic and design strength properties.

```python
import eurocodepy as ec

# --- Concrete material (EN 1992) ---
concrete = ec.Concrete('C30/37')
print(concrete.fck)   # characteristic compressive strength [MPa]
print(concrete.fcd)   # design compressive strength [MPa]

# --- Steel material (EN 1993) ---
steel = ec.Steel('S355')
print(steel.fy)   # yield strength [MPa]

# --- Timber material (EN 1995) ---
timber = ec.Timber('C24')
print(timber.fmk)  # characteristic bending strength [MPa]
```

--------------------------------

### Get Ground Acceleration (ag)

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec7/materials

Retrieve the ground acceleration (ag) in m/s² using this property.

```python
@property
def ag(self) -> float:
    """Return the ground acceleration (ag) in m/s². """
    return self._ag
```

--------------------------------

### Get iterator for welds

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec3/materials

Provides an iterator for the list of welds within the WeldConnection. This allows for easy iteration over the welds.

```python
def __iter__(self):  # noqa: ANN204
    """Return an iterator over the welds in the connection.

    Returns
        iterator: An iterator over the welds list.

    """
    return iter(self.welds)
```

--------------------------------

### Class Naming Conventions

Source: https://pcachim.github.io/eurocodepy/STYLE_GUIDE

Demonstrates PascalCase for class names.

```python
class User:
    # ...

```

--------------------------------

### Miscellaneous Style Tips

Source: https://pcachim.github.io/eurocodepy/STYLE_GUIDE

Covers string quoting, tuple packing/unpacking, None comparison, and default argument values.

```python
message = "Hello, world!"
print(message)
a, b, c = (1, 2, 3)
if x is None: # ...
def my_function(arg1, arg2=None): # ...
def my_other_function(arg1, arg2=[]): # This is bad.
def my_good_function(arg1, arg2=None): if arg2 is None: arg2 = [] # ... 
```

--------------------------------

### Get Soil Spectral Scale Factor (S)

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec7/materials

Retrieve the calculated soil spectral scale factor (S) using this property.

```python
@property
def s(self) -> float:
    """Return the soil spectral scale factor (S)."""
    return self._S
```

--------------------------------

### `from_fck(f_ck, name=None)`

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec2/materials

Creates a Concrete instance from its characteristic compressive strength (f_ck), calculating other relevant properties.

```APIDOC
## `from_fck(f_ck, name=None)` `classmethod`

### Description
Create a Concrete instance from characteristic compressive strength.

### Parameters
#### Path Parameters
- **f_ck** (int) - Required - Characteristic compressive strength of concrete (MPa)
- **name** (str) - Optional - Name for the concrete grade. Defaults to None.

### Returns
- **Concrete**: Concrete instance.
```

--------------------------------

### Get Vertical Seismic Coefficient (kv)

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec7/materials

Access the calculated vertical seismic coefficient (kv) using this property.

```python
@property
def kv(self) -> float:
    """Return the vertical seismic coefficient (kv)."""
    return self._kv
```

--------------------------------

### Get Horizontal Seismic Coefficient (kh)

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec7/materials

Access the calculated horizontal seismic coefficient (kh) using this property.

```python
@property
def kh(self) -> float:
    """Return the horizontal seismic coefficient (kh)."""
    return self._kh
```

--------------------------------

### Basic Code Formatting

Source: https://pcachim.github.io/eurocodepy/STYLE_GUIDE

Demonstrates indentation, inline comments, and code structure.

```python
if x > 0:
    print('x is positive')
else:
    print('x is non-positive')

# This is an inline comment.

def function_name(parameter):
    # Code inside function.

```

--------------------------------

### Get Weld Connection Length

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec3/materials

Calculates the total length of all welds in a connection. Ensure weld objects have a 'length' attribute.

```python
def total_length(self) -> float:
    """Calculate the total length of all welds in the connection.

    Returns:
        float: The sum of lengths of all welds in the connection (mm).

    """
    return sum(weld.length for weld in self.welds)
```

--------------------------------

### Bundle.__init__

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec2/materials

Initializes a Bundle object with a list of reinforcement bars.

```APIDOC
## __init__(bars)

### Description
Initialize a Bundle with a list of Bar objects.

### Parameters
#### Path Parameters
- **bars** (list[Bar]): Required - List of Bar objects to be included in the bundle.

### Raises
- ValueError: If the number of bars in the bundle is less than 2 or greater than 4.
```

--------------------------------

### Calculate Rectangular Section Properties

Source: https://pcachim.github.io/eurocodepy/modules/utils

Use `section_properties` to get geometric properties of a rectangular cross-section. Ensure dimensions are in millimeters.

```python
from eurocodepy.utils import crosssection, section_properties

# section_properties: properties of a rectangular section (uncracked)
props = section_properties(b=300, h=600)
# Returns a dict with keys:
# 'A'     — cross-sectional area [mm²]
# 'Iy'    — second moment of area about y-axis [mm⁴]
# 'Iz'    — second moment of area about z-axis [mm⁴]
# 'Wel_y' — elastic section modulus about y-axis [mm³]
# 'Wel_z' — elastic section modulus about y-axis [mm³]
# 'iy'    — radius of gyration about y-axis [mm]
# 'iz'    — radius of gyration about z-axis [mm]
```

--------------------------------

### SolidTimber Class Instantiation

Source: https://pcachim.github.io/eurocodepy/modules/ec5

Create SolidTimber objects for sawn structural timber using strength classes like C or D.

```python
from eurocodepy.ec5 import SolidTimber, Softwood, Hardwood

c24 = SolidTimber('C24')   # softwood C class
d30 = SolidTimber('D30')   # hardwood D class
```

--------------------------------

### Get kdef for Serviceability Limit State

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec5/materials

Returns the kdef value for the serviceability limit state based on the specified service class. Defaults to ServiceClass.SC1.

```python
def k_def(self, service_class: ServiceClass = ServiceClass.SC1) -> float:
        """Return the kdef value for serviceability limit state.

        Args:
            service_class (ServiceClass, optional): Service class (SC1, SC2, or SC3).
                Defaults to ServiceClass.SC1.

        Returns:
            float: kdef value for the specified service class.

        """
        return self.kdef[service_class.name]
```

--------------------------------

### Implement __post_init__ for NationalParams

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/national_parameters

The __post_init__ method for the NationalParams class loads national parameters based on the specified locale and municipality.

```python
def __post_init__(self):  # noqa: ANN204
    """Post-initialization to load data."""
    self.data = get_national_params(self.local, self.concelho)
```

--------------------------------

### Get Reinforcement Instance (Python)

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec2/materials

Retrieves a Reinforcement object from a string, Reinforcement object, or ReinforcementGrade enum. Raises a TypeError for invalid input types.

```python
def get_reinforcement(
    reinforcement: str | Reinforcement,
) -> Reinforcement:
    """Return a Reinforcement object from string, Reinforcement, or ReinforcementGrade.

    Parameters
    ----------
    reinforcement : str, Reinforcement, or ReinforcementGrade
        The reinforcement specification as a string (e.g., 'B500B'), a
        Reinforcement object, or a ReinforcementGrade enum.

    Returns
    -------
    Reinforcement
        A Reinforcement instance corresponding to the input.

    Raises
    ------
    TypeError
        If the input is not a str, Reinforcement, or ReinforcementGrade.

    """
    if isinstance(reinforcement, Reinforcement):
        return reinforcement

    if isinstance(reinforcement, str):
        return Reinforcement(reinforcement)

    msg = "Input must be a str, Reinforcement, or ReinforcementGrade"
    raise TypeError(msg)
```

--------------------------------

### __init__(bolt, outer_plate, inner_plate=None)

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec3/materials

Initializes the material properties for a connection, ensuring the bolt is of the correct type.

```APIDOC
## __init__(bolt, outer_plate, inner_plate=None)

### Description
Post-initialization to ensure the bolt is of type Bolt.

### Parameters
- **bolt** (Bolt) - The bolt object for the connection.
- **outer_plate** (SteelPlate) - The outer steel plate of the connection.
- **inner_plate** (SteelPlate | object) - Optional - The inner steel plate of the connection. Defaults to the outer plate if not provided.

### Source Code
```python
def __init__(self,
        bolt: Bolt,
        outer_plate: SteelPlate,
        inner_plate: SteelPlate | object = None) -> None:
    """Post-initialization to ensure the bolt is of type Bolt."""
    self._outer_plate = outer_plate
    self._inner_plate = inner_plate if (
        inner_plate is not None) else outer_plate
    self._bolt = bolt
    self._e1 = REC_E1 * self.bolt.d0
    self._p1 = REC_P2 * self.bolt.d0
    self._e2 = REC_E2 * self.bolt.d0
    self._p2 = REC_P2 * self.bolt.d0
    self._result = None
```
```

--------------------------------

### Create Concrete from Characteristic Compressive Strength

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec2/materials

Use the `from_fck` class method to create a Concrete instance when only the characteristic compressive strength (f_ck) is known. An optional name can be provided.

```python
conc = Concrete.from_fck(30)
print(conc.fck)
```

--------------------------------

### Get Concrete Instance (Python)

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec2/materials

Retrieves a Concrete instance from a string, Concrete object, or ConcreteGrade enum. Raises a TypeError if the input type is invalid.

```python
def get_concrete(concrete: str | Concrete) -> Concrete:
    """Return a Concrete instance from a string, Concrete, or ConcreteGrade input.

    Parameters
    ----------
    concrete : str, Concrete, or ConcreteGrade
        The concrete specification as a string (e.g., 'C30/37'), a Concrete object,
        or a ConcreteGrade enum.

    Returns
    -------
    Concrete
        A Concrete instance corresponding to the input.

    Raises
    ------
    TypeError
        If the input is not a str, Concrete, or ConcreteGrade.

    """
    if isinstance(concrete, Concrete):
        return concrete
    if isinstance(concrete, str):
        return Concrete(concrete)

    msg = "Input must be a str, Concrete, or ConcreteGrade"
    raise TypeError(msg)
```

--------------------------------

### Initialize Solid Timber Material Properties

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec5/materials

Initializes properties for Solid Timber, supporting both softwood and hardwood grades. It sets material-specific parameters and calculates characteristic values based on the timber grade.

```python
class SolidTimber(Timber):
    """Class represents Eurocode 5 solid timber properties.

    It includes both softwood and hardwood types.
    Properties read from the database for the given type_label.

    Args:
        type_label (str, optional): Timber grade label (e.g., 'C24', 'D30').
        Defaults to 'C24'.

    Raises:
        ValueError: If the type_label is not found in the database.

    """

    def __init__(self, type_label: str = "C24") -> None:  # noqa: D107
        grades_list = [item for item in dbase.TimberGrades
                    if (item.startswith(("C", "D")))]
        if type_label not in grades_list:
            msg = (
                f"Softwood type '{type_label}' not found in database. "
                f"Softwood type must be one of {grades_list}"
            )
            raise ValueError(msg)

        super().__init__(type_label)

        if type_label.startswith("D"):
            self.Gk = 0.83 * self.Gmean
        else:
            self.Gk = 0.67 * self.Gmean
        self.fvrefk = dbase.TimberParams["fvrefk"][self.type]
        self.theta_twist = dbase.TimberParams["theta_twist"][self.type]
        self.kred = dbase.TimberParams["kred"][self.type]
        self.material = TimberType.TIMBER
        self.timber_product = TimberProduct.ST
```

--------------------------------

### Get Number of Welds in Connection

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec3/materials

Returns the count of weld objects stored within the connection. This method relies on the connection's internal 'welds' list.

```python
def __len__(self) -> float:
    """Return the number of welds in the connection.

    Returns:
        int: The number of welds in the connection.

    """
    return len(self.welds)
```

--------------------------------

### __init__(bolt, outer_plate, inner_plate=None, gap=0)

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec3/materials

Initializes the material properties for a bolt connection, ensuring the bolt is of the correct type and setting up initial parameters for plates and gaps.

```APIDOC
## __init__(bolt, outer_plate, inner_plate=None, gap=0)

### Description
Post-initialization to ensure the bolt is of type Bolt.

### Parameters
#### Path Parameters
- **bolt** (Bolt) - Required - The bolt object.
- **outer_plate** (SteelPlate) - Required - The outer steel plate.
- **inner_plate** (SteelPlate | object) - Optional - The inner steel plate. Defaults to None.
- **gap** (float) - Optional - The gap between plates in mm. Defaults to 0.
```

--------------------------------

### Get Safety Factor

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec5/uls/bending

Retrieves the safety factor (gamma_M) for a specified timber type. This factor is crucial for ULS (Ultimate Limit State) bending calculations.

```APIDOC
## get_safety_factor(timber_type)

### Description
Get the safety factor for a given timber type. This function is used in Ultimate Limit State (ULS) bending calculations.

### Parameters
#### Path Parameters
- **timber_type** (str) - Required - Type of timber ('timber', 'glulam', 'lvl').

### Returns
- **float** (float) - Safety factor gamma_M
```

--------------------------------

### Timber Class Initialization

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec5/materials

Initializes a Timber object with properties derived from the database based on the provided timber grade label. It handles potential errors if the label is not found.

```APIDOC
## Timber

### Description
Initialize Timber object. Properties are derived from the database for the given type_label.

### Parameters
#### Path Parameters
- **type_label** (str) - Optional - Timber grade label (e.g., 'C24'). Defaults to 'C24'.

### Raises
- **ValueError**: If the type_label is not found in the database.
```

--------------------------------

### Get Timber Safety Factor

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec5/uls/bending

Retrieves the safety factor (gamma_M) for timber based on its type. Ensure the timber type is one of 'timber', 'glulam', or 'lvl'.

```python
def get_safety_factor(timber_type: str) -> float:
    """Get the safety factor for a given timber type, load duration, and service class.

    Args:
        timber_type (str): Type of timber ('timber', 'glulam', 'lvl').

    Returns:
        float: Safety factor gamma_M

    """
    return ec.TimberParams["safety"][timber_type]
```

--------------------------------

### Helper Functions for Creep and Shrinkage (2004 Edition)

Source: https://pcachim.github.io/eurocodepy/modules/ec2

Import functions to calculate creep coefficient and shrinkage strain according to EN 1992-1-1:2004.

```python
# Creep and shrinkage (EN 1992-1-1:2004)
from eurocodepy.ec2 import calc_creep_coef, calc_shrink_strain

```

--------------------------------

### Glulam Class Instantiation

Source: https://pcachim.github.io/eurocodepy/modules/ec5

Instantiate Glulam objects for glued laminated timber using GL strength classes.

```python
from eurocodepy.ec5 import Glulam

gl28h = Glulam('GL28h')   # homogeneous
gl28c = Glulam('GL28c')   # combined
```

--------------------------------

### Get kdef Value for Serviceability Limit State

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec5/materials

Returns the kdef value, which is used for the serviceability limit state, based on the specified service class. The default service class is SC1.

```python
def k_def(self, service_class: ServiceClass = ServiceClass.SC1) -> float:
    """Return the kdef value for serviceability limit state.

    Args:
        service_class (ServiceClass, optional): Service class (SC1, SC2, or SC3).
            Defaults to ServiceClass.SC1.

    Returns:
        float: kdef value for the specified service class.

    """
    return self.kdef[service_class.name]


```

--------------------------------

### Get Full Set of Bending Design Parameters

Source: https://pcachim.github.io/eurocodepy/modules/ec2

Utilize `get_bend_params` to obtain a comprehensive set of bending design parameters, including neutral axis depth, lever arm, and strains.

```python
from eurocodepy.ec2.uls.beam import calc_mrd, calc_asl, get_bend_params

# Full set of bending design parameters (x, z, ε, …)
params = get_bend_params(b, d, As, concrete, reinforcement)

```

--------------------------------

### Helper Functions for Creep and Shrinkage (2025 Edition)

Source: https://pcachim.github.io/eurocodepy/modules/ec2

Import functions to calculate creep coefficient and shrinkage strain according to EN 1992-1-1:2025.

```python
# Creep and shrinkage (EN 1992-1-1:2025)
from eurocodepy.ec2 import creep_coef, shrink_strain

```

--------------------------------

### Steel Class Initialization

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec3/materials

Initializes a Steel instance with properties from a specified steel label. It validates the steel type against a database and sets characteristic and design strengths, as well as partial safety factors.

```APIDOC
## `__init__(type_label='S275')`

### Description
Initialize a Steel instance with properties from the specified steel label.

### Parameters
#### Arguments
- **type_label** (str): Steel type label (e.g., 'S235', 'S275', 'S355', 'S460'). Defaults to 'S275'.

### Raises
- **ValueError**: If the steel type is not found in the database.
```

--------------------------------

### CLT Material Properties

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec5/materials

Defines the Cross-Laminated Timber (CLT) material properties. It validates the type label to ensure it starts with 'CLT' and exists in the timber grades database. This class is not fully implemented.

```python
class CLT(Timber):
    """Eurocode 5 Cross-Laminated Timber (CLT) properties. Not implemented."""

    def __init__(self, type_label: str = "CLT30") -> None:  # noqa: D107
        grades_list = [item for item in dbase.TimberGrades if item.startswith("GL")]

        if not type_label.startswith("CLT"):
            msg = (
                f"CLT type '{type_label}' must start with 'CLT'. "
                f"CLT type must be one of {grades_list}"
            )
            raise ValueError(msg)
        if type_label not in grades_list:
            msg = (
                f"CLT type '{type_label}' not found in database. "
                f"CLT type must be one of {grades_list}"
            )
            raise ValueError(msg)

        super().__init__(type_label)
        self.material = TimberType.CLT
        self.timber_product = TimberProduct.CLT
```

--------------------------------

### Get kh for Serviceability Limit State

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec5/materials

Returns the kh value for the serviceability limit state, adjusted for timber size and force type (Bending, Shear, or Tension). Returns 1.0 for unsupported force types.

```python
def k_h(self, size: float,
            forcetype: TimberForcesType = TimberForcesType.Bending) -> float:
        """Return the kh value for serviceability limit state.

        Returns:
            float: kh value.

        """
        match forcetype:
            case TimberForcesType.Bending:
                aref = self.kh["aref"]
                sm = self.kh["sm"]
                kmin = self.kh["khmmin"]
                kmax = self.kh["khmmax"]
            case TimberForcesType.Shear:
                aref = self.kh["aref"]
                sm = self.kh["sv"]
                kmin = self.kh["khvmin"]
                kmax = self.kh["khvmax"]
            case TimberForcesType.Tension:
                aref = self.kh["aref"]
                sm = self.kh["sm"]
                kmin = self.kh["khmmin"]
                kmax = self.kh["khmmax"]
            case _:
                return 1.0

        kh = (aref / size)**sm
        return max(kmin, min(kh, kmax))
```

--------------------------------

### Draw Creep and Shrinkage Charts

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec2/sls/shrinkage

Draws charts visualizing creep and shrinkage of concrete over time. Requires a dictionary containing time values and corresponding strain values.

```python
def draw_charts(chart_data):
    """
    Draws charts related to creep and shrinkage of concrete.

    Args:
        chart_data: A dictionary containing the data for the charts.
    """

    t_values = chart_data["t_values"]
    epsilon_cs_values = chart_data["epsilon_cs_values"]

    # Chart 1: Creep and shrinkage over time
    plt.figure(figsize=(10, 6))
    plt.plot(t_values, epsilon_cs_values)
    plt.xlabel("Time (days)")
    plt.ylabel("Creep and Shrinkage (x10^-6)")
    plt.title("Creep and Shrinkage Over Time")
    plt.grid(True)

```

--------------------------------

### Initialize LVL Material Properties

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec5/materials

Initializes properties for Laminated Veneer Lumber (LVL) based on a type label. Raises ValueError if the type label is invalid or not found in the database.

```python
class LVL(Timber):
    """Eurocode 5 Laminated Veneer Lumber (LVL) properties. Not implemented."""

    def __init__(self, type_label: str = "LVL30P") -> None:  # noqa: D107
        grades_list = [item for item in dbase.TimberGrades if item.startswith("GL")]

        if not type_label.startswith("LVL"):
            msg = (
                f"LVL type '{type_label}' must start with 'LVL'. "
                f"LVL type must be one of {grades_list}"
            )
            raise ValueError(msg)
        if type_label not in grades_list:
            msg = (
                f"LVL type '{type_label}' not found in database. "
                f"LVL type must be one of {grades_list}"
            )
            raise ValueError(msg)

        super().__init__(type_label)
        self.material = TimberType.LVL
        self.timber_product = TimberProduct.LVL_P
```

--------------------------------

### Get Seismic Spectrum Parameters

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec8/spectrum

Use this function to retrieve seismic spectrum parameters. It requires the seismic code, importance coefficient, soil type, and zone as input. Ensure correct string formatting for all parameters.

```python
import pandas as pd

def get_spectrum_parameters(code: str, coef_imp: str, soil: str, zone: str) -> tuple:
    """Get the spectrum parameters.

    Args:
        code (str): code to be used (CEN-1, CEN-2, PT-1, PT-2, PT-A)
                CEN-1, CEN-2: standard Eurocode spectrums
                PT-1, PT-2, PT-A: Portuguese National Annex spectrums
                    (PT-1 and PT-2, for continent and Madeira, PT-A for Azores)
        coef_imp (str): importance coefficient (i, ii, iii, iv)
        soil (str): soil type (A, B, C, D, E)
        zone (str): zone (1_1, 1_2, 1_3, 1_4, 1_5, 1_6, 2.1, 2.2, 2.3, 2.4, 2.5, .1g,
        .2g, .3g, .4g, .5g, .6g, .7g, .8g, .9g, 1_0g)

    Returns:
        list: soil amplification factor, acceleration, T_B, T_C, T_D

    """
    # accelarations
    a_gr = {"1_1": 2.5, "1_2": 2.0, "1_3": 1_5, "1_4": 1_0, "1_5": 0.6, "1_6": 0.35,
            "2.1": 2.5, "2.2": 2.0, "2.3": 1.7, "2.4": 1.1, "2.5": 0.8,
            ".1g": 0.980665, ".2g": 1.96133, ".3g":  2.941995, ".4g": 3.92266,
            ".5g": 4.903325, ".6g": 5.88399, ".7g": 6.864655, ".8g": 7.84532,
            ".9g": 8.825985, "1_0g": 9.80665}

    index1 = ["i", "ii", "iii", "iv"]
    gama_f = {"CEN-1": [0.8, 1.0, 1.2, 1.4],
            "CEN-2": [0.8, 1.0, 1.2, 1.4],
            "PT-1": [0.65, 1.0, 1.45, 1.95],
            "PT-2": [0.75, 1.0, 1.25, 1.5],
            "PT-A": [0.85, 1.0, 1.15, 1.35]}
    coefs = pd.DataFrame(gama_f, index=index1)

    coef_imp = str.lower(coef_imp)
    a_g = a_gr[zone] * coefs.at[coef_imp, code]  # noqa: PD008

    soil = str.upper(soil)
    index = ["A", "B", "C", "D", "E"]
    code = str.upper(code)
    if code == "CEN-1":
        data = {"S_max": [1.0, 1.2, 1.15, 1.35, 1.4],
                "T_B": [0.15, 0.15, 0.2, 0.2, 0.15],
                "T_C": [0.4, 0.5, 0.6, 0.8, 0.5],
                "T_D": [2.0, 2.0, 2.0, 2.0, 2.0],
                }
    elif code == "CEN-2":
        data = {"S_max": [1.0, 1.35, 1.5, 1.8, 1.6],
                "T_B": [0.05, 0.05, 0.1, 0.1, 0.05],
                "T_C": [0.25, 0.25, 0.25, 0.3, 0.25],
                "T_D": [1.2, 1.2, 1.2, 1.2, 1.2],
                }
    elif code in {"PT-2", "PT-A"}:
        data = {"S_max": [1.0, 1.35, 1.60, 2.0, 1.8],
                "T_B": [0.1, 0.1, 0.1, 0.1, 0.1],
                "T_C": [0.25, 0.25, 0.25, 0.3, 0.25],
                "T_D": [2.0, 2.0, 2.0, 2.0, 2.0],
                }
    elif code == "PT-1":
        data = {"S_max": [1.0, 1.35, 1.60, 2.0, 1.8],
                "T_B": [0.1, 0.1, 0.1, 0.1, 0.1],
                "T_C": [0.6, 0.6, 0.6, 0.8, 0.6],
                "T_D": [2.0, 2.0, 2.0, 2.0, 2.0],
                }
    values = pd.DataFrame(data, index=index)

    s_max = values.at[soil, "S_max"]  # noqa: PD008

    if code in {"CEN-1", "CEN-2"} or a_g <= 1.0:
        s_val = s_max
    elif a_g >= 4.0:
        s_val = 1.0
    else:
        s_val = s_max - (s_max - 1.0) * (a_g - 1.0) / 3.0

    t_b = values.at[soil, "T_B"]  # noqa: PD008
    t_c = values.at[soil, "T_C"]  # noqa: PD008
    t_d = values.at[soil, "T_D"]  # noqa: PD008

    return s_val, a_g, t_b, t_c, t_d

```

--------------------------------

### Get Timber Design Values

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec5/materials

Retrieves design values for a specified timber class based on load combination types. Handles different load durations and combination types, returning an empty dictionary if combination indicators are missing.

```python
def GetTimberDesignValues(timber: Timber, combos: LoadCombinations) -> dict:
    """Get the design values for a timber class dependending on load combination type.

    Args:
        timber (Timber): the timber class (C18, GL24c, ...)
        combos (LoadCombinations): the collection of load combinations

    Returns:
        dict: the design strength values for each combination

    """
    design_values: dict = {}
    for combo in combos:
        try:
            service_class = combo.attributes["loadduration"]
            load_duration: "LoadDuration" = combo.attributes["loadduration"]  # noqa: UP037
            name: str = combo.name
            if combo.type in {
                CombinationType.SLS_K,
                CombinationType.SLS_FR,
                CombinationType.SLS_QP}:
                values = {
                    "design": False,
                }
            else:
                values = timber.design_values(service_class.name, load_duration)
                values["design"] = True
            design_values[name] = values
        except ValueError as e:
            print(f"Combination does not have timber indicators: {e}")  # noqa: T201
            return {}
    return design_values
```

--------------------------------

### Initialize SoilSeismicParameters

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec7/materials

Use this class to define seismic parameters for soil based on Eurocode 8. It requires spectrum name, ground acceleration, maximum spectral acceleration, importance coefficient, and vertical/horizontal acceleration ratio. The response reduction factor defaults to 1.0.

```python
class SoilSeismicParameters:
    """Seismic parameters for soil based on Eurocode 8.

    Args:
        spectrum (str): name of the seismic spectrum (e.g., "PT1", "PT2", "CEN1", ...)
        agR (float): ground acceleration in m/s²
        s_max (float): maximum spectral acceleration
        importance_coeff (float): importance coefficient for the structure
        avg_ahg (float): ratio vertical/horizontal acceleration
        r (float, optional): response reduction factor. Defaults to 1.0.

    Notes:
        r=2.0 - Free gravity walls that can accept a displacement dr = 300 a⋅S (mm)
        r=1.5 - Free gravity walls that can accept a displacement dr = 200 a⋅S (mm)
        r=1.0 - Flexural reinforced concrete walls, anchored or braced walls, reinforced
        concrete walls founded on vertical piles, restrained basement walls and bridge
        abutments

    Attributes:
        name (str): name of the seismic spectrum
        r (float): response reduction factor
        agr (float): ground acceleration in m/s²
        s_max (float): Maximum spectral acceleration. 
        alpha (float): normalized ground acceleration (ag / 9.80665)
        smax (float): maximum spectral acceleration
        importance_coeff (float): importance coefficient
        avg_ahg (float): ratio of vertical to horizontal acceleration
        kh (float): horizontal seismic coefficient
        kv (float): vertical seismic coefficient
        r (float, optional): Response reduction factor. Defaults to 1.0.

    """

    def __init__(self, name: str, agr: float, s_max: float,
                avg_ahg: float, r: float = 1.0) -> None:
        self.name = name
        self.r = r
        self._ag = agr
        self.smax = s_max
        self.avg_ahg = avg_ahg
        self.alpha = agr / 9.80665
        self._S = np.maximum(1, np.minimum(s_max, s_max - (s_max - 1) * (agr - 1) / 3))
        self._kh = self.alpha * self.smax / self.r
        self._kv = 0.5 * self.kh if self.avg_ahg > 0.6 else 0.33 * self._kh

    @property
    def kh(self) -> float:
        """Return the horizontal seismic coefficient (kh)."""
        return self._kh

    @property
    def kv(self) -> float:
        """Return the vertical seismic coefficient (kv)."""
        return self._kv

    @property
    def ag(self) -> float:
        """Return the ground acceleration (ag) in m/s². """
        return self._ag

    @property
    def s(self) -> float:
        """Return the soil spectral scale factor (S)."""
        return self._S
```

--------------------------------

### Get Seismic Spectrum Parameters

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/national_parameters

Retrieves seismic spectrum parameters from the SeismicLoads database. Handles case-insensitivity for soil type and importance class, and requires seismic type in uppercase. Supports various localization codes and seismic types.

```python
def seismic_get_params(code, seismic_type, soil_type, importance_class) -> dict:
    """Get the seismic spectrum parameters.

    This function retrieves the seismic spectrum parameters from the SeismicLoads
    database based on the provided parameters. It returns a dictionary containing
    the spectrum parameters, including the importance coefficient. The parameters
    are case-insensitive for soil type and importance class, but the seismic type
    should be provided in uppercase. The function is designed to work with different
    localization codes, such as "PT" for Portugal or "EU" for standard CEN. The
    seismic types can include "PT1", "PT2", "PTA" for Portugal, or "CEN-1", "CEN-2"
    for CEN standards. This function is useful for engineers and designers who need
    to apply seismic loads according to Eurocode standards.

    Args:
        code (str): Localization code (e.g., "PT" for Portugal, "EU" for standard
            CEN).
        seismic_type (str): type of seismic action (e.g., "PT1", "PT2", "PTA",
            "CEN-1", "CEN-2").
        soil_type (str): soil type (e.g., "A", "B", "C", "D", "E" for different
            soil conditions).
        importance_class (str): importance class (e.g., "i", "ii", "iii", "iv").

    Returns:
        dict: spectrum parameters for the specified code, seismic type, soil type,
            and importance class.

    Raises:
        ValueError: If the code, seismic type, soil type, or importance class is
            invalid.

    """
    code = str.upper(code)
    seismic_type = str.upper(seismic_type)
    soil_type = str.upper(soil_type)
    importance_class = str.lower(importance_class)
    if code not in SeismicLoads["Locale"]:
        msg = f"Invalid code: {code}. Available codes: {
            list(SeismicLoads['Locale'].keys())}"
        raise ValueError(msg)
    if seismic_type not in SeismicLoads["Locale"CHAPTER][code]["Spectrum"]:
        msg = f"Invalid seismic type: {seismic_type}. Available types: {
            list(SeismicLoads['Locale'][code]['Spectrum'].keys())}"
        raise ValueError(msg)
    if soil_type not in SeismicLoads["Locale"CHAPTER][code]["Spectrum"]:
        msg = f"Invalid soil type: {soil_type}. Available types: {
            list(SeismicLoads['Locale'][code]['Spectrum'][seismic_type].keys())}"
        raise ValueError(msg)
    if importance_class not in SeismicLoads["Locale"CHAPTER][code]["ImportanceClass"]:
        msg = f"Invalid importance class: {importance_class}. Available classes: {
            list(SeismicLoads['Locale'][code]['ImportanceCoef'].keys())}"
        raise ValueError(msg)

    # Retrieve the spectrum parameters
    spectrum = SeismicLoads["Locale"
            ][code]["Spectrum"][seismic_type][str.upper(soil_type)]
    spectrum["ImportanceCoef"] = SeismicLoads["Locale"
            ][code]["ImportanceCoef"][seismic_type][importance_class]
    return spectrum

```

--------------------------------

### Initialize Steel Material Properties

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec3/materials

Initializes a `Steel` instance with properties from a specified steel grade label. Raises `ValueError` if the label is not found in the database. Use this to define the mechanical properties of steel for structural calculations.

```python
def __init__(self, type_label: str = "S275") -> None:
    """Initialize a Steel instance with properties from the specified steel label.

    Args:
    type_label (str): Steel type label (e.g., 'S235', 'S275', 'S355', 'S460')

    Raises:
    ValueError: If the steel type is not found in the database.

    """
    if type_label not in dbase.SteelGrades:
        msg = (
            f"Steel type '{type_label}' not found in database. "
            f"Steel type must be one of {list(dbase.SteelGrades.keys())}"
        )
        raise ValueError(msg)

    reinf = dbase.SteelGrades[type_label]
    self.fyk = reinf["fyk"]  # Characteristic yield strength (MPa)
    self.fuk = reinf["fuk"]  # Characteristic ultimate strength (MPa)
    self.fyk40 = reinf["fyk40"]  # Characteristic yield strength for 40 mm bar (MPa)
    self.fuk40 = reinf["fuk40"]  # Charac. ultimate strength for 40 mm bar (MPa)
    self.Es = reinf["Es"]  # Modulus of elasticity (MPa)
    self.ClassType = type_label

    gamma_s = dbase.SteelParams["gamma_M0"]  # Partial safety factor
    self.gamma_M0 = dbase.SteelParams["gamma_M0"]  # Partial safety factor
    self.gamma_M1 = dbase.SteelParams["gamma_M1"]  # Partial safety factor
    self.gamma_M2 = dbase.SteelParams["gamma_M2"]  # Partial safety factor
    self.fyd = round(self.fyk / gamma_s, 1)  # Design yield strength (MPa)
    self.fyd40 = round(self.fyk40 / gamma_s, 1)  # Design yield strength (MPa)
```

--------------------------------

### Get Soil Seismic Parameters

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec7/materials

Retrieve seismic parameters for actions S1 and S2 using the get_soil_seismic_parameters function. This function requires country code, soil type, importance class, spectrum, and seismic zone. It returns a SoilSeismicParameters object.

```python
def get_soil_seismic_parameters(name: str, code: str, soil: str, imp_class: str,
            spectrum: str, zone: str) -> SoilSeismicParameters:
    """Set the parameters for the seismic action 1 and 2.

    Args:
        name (str): name of the seismic action (e.g., "S1", "S2")
        code (str): country (EU, PT)
        soil (str): type of soil (A, B, C, D, E)
        imp_class (str): importance class (i, ii, iii, iv)
        spectrum (str): spectrum name (for PT: PT1, PT2, PTA)
                                    (for EU: CEN1, CEN2)
        zone (str): seismic zone 1 (for PT: 1_1, 1_2, 1_3, 2_4, 2_5, 2_6, ...)
                                    (for EU: _1g, _2g ...)
        r (float, optional): response reduction factor. Defaults to 1.0.

    Returns:
        SoilSeismicParameters: object containing seismic parameters

    Notes:
        r=2.0 - Free gravity walls that can accept a displacement dr = 300 a⋅S (mm)
    return SoilSeismicParameters(
        name=name,
        agR=ag,
        s_max=smax,
        importance_coeff=impcoef,
        avg_ahg=agvagh
    )
        r=1.0 - Flexural reinforced concrete walls, anchored or braced walls, reinforced
        concrete walls founded on vertical piles, restrained basement walls and bridge
        abutments

    """
    ag = dbase.Loads["Seismic"]["Locale"][code]["a_gR"][spectrum][zone]
    smax = dbase.Loads["Seismic"]["Locale"][code]["Spectrum"][spectrum][soil]["S_max"]
    impcoef = dbase.Loads["Seismic"]["Locale"][code]["ImportanceCoef"][spectrum][imp_class]
    agvagh = dbase.Loads["Seismic"]["Locale"][code]["avg_ahg"][spectrum]

    return SoilSeismicParameters(name, ag, smax, impcoef, agvagh)

```

--------------------------------

### Initialize Steel Properties

Source: https://pcachim.github.io/eurocodepy/reference/eurocodepy/ec3/materials

Initializes a Steel instance with properties from a specified steel label. Raises ValueError if the steel type is not found in the database. Use 'S235', 'S275', 'S355', or 'S460' as type labels.

```python
class Steel:
    """Eurocode 3 steel reinforcement properties.

    :param type_label: Steel type label (e.g., 'S235', 'S275', 'S355', 'S460')
    :raises ValueError: If the steel type is not found in the database.
    """

    def __init__(self, type_label: str = "S275") -> None:
        """Initialize a Steel instance with properties from the specified steel label.

        Args:
        type_label (str): Steel type label (e.g., 'S235', 'S275', 'S355', 'S460')

        Raises:
        ValueError: If the steel type is not found in the database.

        """
        if type_label not in dbase.SteelGrades:
            msg = (
                f"Steel type '{type_label}' not found in database. "
                f"Steel type must be one of {list(dbase.SteelGrades.keys())}"
            )
            raise ValueError(msg)

        reinf = dbase.SteelGrades[type_label]
        self.fyk = reinf["fyk"]  # Characteristic yield strength (MPa)
        self.fuk = reinf["fuk"]  # Characteristic ultimate strength (MPa)
        self.fyk40 = reinf["fyk40"]  # Characteristic yield strength for 40 mm bar (MPa)
        self.fuk40 = reinf["fuk40"]  # Charac. ultimate strength for 40 mm bar (MPa)
        self.Es = reinf["Es"]  # Modulus of elasticity (MPa)
        self.ClassType = type_label

        gamma_s = dbase.SteelParams["gamma_M0"]  # Partial safety factor
        self.gamma_M0 = dbase.SteelParams["gamma_M0"]  # Partial safety factor
        self.gamma_M1 = dbase.SteelParams["gamma_M1"]  # Partial safety factor
        self.gamma_M2 = dbase.SteelParams["gamma_M2"]  # Partial safety factor
        self.fyd = round(self.fyk / gamma_s, 1)  # Design yield strength (MPa)
        self.fyd40 = round(self.fyk40 / gamma_s, 1)  # Design yield strength (MPa)

```
Tokens:
Raw