Human induced vibrations module

This module contains functionality for analyses of human induced vibrations.

Step walking load analysis

In structural engineering, a step walking load analysis is used to understand and predict the impact of pedestrian traffic on structures like floors, bridges, and walkways. The procedure for the determination of an acceptable floor response to excitation induced by walking persons is based on the following:

1. The characteristics of the loading by identifying the appropriate features of the walking process by describing the load-time-history as a function of body weight, step frequency and their statistical demographic distribution,

2. The identification of the dynamic floor response from representative ‘Single degree of freedom’-models for different typologies of floors, to which actions in the form of parameterized time-histories of step forces are applied; these responses are given as time-histories or frequency distributions for further evaluations,

3. The comfort assessment of the floor responses taking into account human perception and condensation of data to a single representative response parameter (OS-RMS-value90) which defines a certain fractile of the distribution of responses to actions and is suitable for being compared with response requirements depending on the type of building and its use.

For more background information refer to [1] and [2].

Note

Current functionality provides tools for the first item, providing for the characteristics of the loading.

You can use the functionality by importing the human induced vibrations module:

from haskoning_atr_tools.human_induced_vibrations import *

References

References

[1]

Trillingen van vloeren door lopen Richtlijn voor het voorspellen, meten en beoordelen, SBR, d.d. September 2005

[2]

Background Document for Floor Vibrations RFS2-CT-2007-00033, Hivoss, d.d. 2007

Calculate the walking load

The walking load can be created with the calculate_walking_load() function:

walking_load = calculate_walking_load(step_frequency=2.0, body_mass=70, nr_steps=20, load_reduction=True)

step_frequency	float	The frequency of the steps, in [Hz]. The frequency should be between 1.64 and 3Hz.
body_mass	float	The mass of the body, in [kg]. The body mass should be between 40 and 125kg.
nr_steps	int	The number of steps to apply in the walking load.
load_reduction	bool	Toggle to apply a load reduction is applied to the first four and last four steps. Default value is False

Plot

The walking load can be visualised with the plot plot() method.

walking_load.plot()

Generated plot of the walking load over time.

Also a plot can be generated for the load of a single step.

walking_load.step_load.plot()

Generated plot of a single step over time.

Conversion to FEM

A method is available to convert the walking load to an instance of the Timeseries class in the haskoning_structural package. This object can be used in structural engineering software to analyse the walking load. To apply this functionality the user should install the haskoning_structural module separately as it does not come standard with the ATR tools module.

timeseries = walking_load.to_fem(project=fem_project)

Reference

haskoning_atr_tools.human_induced_vibrations.walking_load.calculate_walking_load(step_frequency: float, body_mass: float, nr_steps: int = 15, load_reduction: bool = False) → StepWalkingLoad

Calculate the walking load by superimposing the step load multiple times at intervals of 1/step_frequency. This calculation tool is based on the Dutch SBR richtlijn Trillingen van vloeren door lopen, Richtlijn voor het voorspellen, meten en beoordelen, d.d. September 2005. The procedure aligns to international research on the topic.

Input:

• step_frequency (float): The frequency of the steps, in [Hz]. The frequency should be between 1.64 and 3Hz.

• body_mass (float): The mass of the body, in [kg]. The body mass should be between 40 and 125kg.

• nr_steps (int): The number of steps to apply in the walking load. The total amount of steps should be at least 15. Default value is 15.

• load_reduction (bool): Toggle to apply a load reduction is applied to the first four and last four steps. Default value False, no load reduction is applied.

Output:

• Returns the instance of StepWalkingLoad that defines the calculated step walking load.

StepLoad class

The StepLoad class represents the load generated by a single walking step.

Reference

This is the documentation of the class and methods of StepLoad:

class haskoning_atr_tools.human_induced_vibrations.step_load.StepLoad(step_frequency: float, body_mass: float)

Bases: object

The StepLoad class represents the load generated by a single walking step.

__init__(step_frequency: float, body_mass: float)

Input:

• step_frequency (float): The frequency of the steps, in [Hz]. The frequency should be between 1.64 and 3Hz. According SBR art 4.1.1 when calculating or simulating floor vibrations due to walking, only walking frequencies between 1.64 Hz and 3.00 Hz are considered relevant for the dynamic response of the floor.

• body_mass (float): The mass of the body, in [kg]. The body mass should be between 40 and 125kg. SBR art 4.1.2 only provides for values for the mass of the walking person in range from 30 kg to 125 kg, in steps of 5 kg.

calculate_step_load(step_size: float | None = None) → Tuple[List[float], List[float]]

Calculate the step load of a single step along the specified time duration according to SBR 4.1.

Input:

• step_size (float): Optional input for the step size within the defined time domain of the load, in [s]. Default value None, defines a step size equal to 1/1000 of the step load duration.

Output:

• Returns the step load as list of all the loads along the specified time duration as float, in [N].

calculate_step_load_at_time(defined_time: float = 0) → float

Calculate the step load at a specific time according to SBR section 4.4.

Input:

• defined_time (float): The specific time step at which to calculate the load, in [s]. Default value is 0.

Output:

• Returns the value of the step load at a specified time step, in [N].

property k_coefficients: List[float]

Returns the calculated k-coefficients based on the step frequency, as list of floats, in [-].

property method: str

Returns the method used for the calculation, currently only SBR is available, as string.

plot(show: bool = True, save_file: Path | str | None = None, step_size: float | None = None, normalised: bool = False)

Generate a plot of the step load over time.

Input:

• show (bool): Switch to indicate if the pop-up screen of the graph should appear. Default value is True.

• save_file (str or Path): The path of the image if the plot should be saved. If None the image will not be saved. Default is None.

• step_size (float): Optional input for the step size within the defined domain, in [s]. Default value None, defines a step size equal to 1/1000 of the step domain.

• normalised (bool): Select to create the plot for the normalised load over time. Default value is False.

Output:

• Returns the matplotlib figure when save_file is None.

• Returns the path to the created image if save_file has been provided.

property step_load_diagram: Tuple[List[float], List[float]]

Returns the step load diagram based on default step size. The tuple specifies list of the time-steps as float, in [s] and the loads as float, in [N].

property step_load_duration: float

Returns the step load duration based on the step frequency, as float, in [s].

StepWalkingLoad class

The StepWalkingLoad class represents the load generated by a series of walking steps.

Reference

This is the documentation of the class and methods of StepWalkingLoad:

class haskoning_atr_tools.human_induced_vibrations.step_walking_load.StepWalkingLoad(step_load: StepLoad, nr_steps: int = 15, load_reduction: bool = False, step_size: float | None = None)

Bases: object

The StepWalkingLoad class represents the load generated by a series of walking steps.

__init__(step_load: StepLoad, nr_steps: int = 15, load_reduction: bool = False, step_size: float | None = None)

Input:

• step_load (float): The definition for the single step in the walking load. Instance of StepLoad class.

• nr_steps (int): The number of steps to apply in the walking load. The total amount of steps should be at least 15. Default value is 15.

• load_reduction (bool): Toggle to apply a load reduction is applied to the first four and last four steps (load reduction 80%, 60%, 40% and 20% per step). Default value is False, no load reduction is applied.

• step_size (float): Optional input to directly set the time resolution, in [s], for evaluating the walking load. If None, a default value based on step frequency is used. Recommended to be small enough to capture step dynamics accurately. Maximum allowed value is 1/50 of the interval between steps (factor set in the config file).

property interval: float

Time between two consecutive steps, according SBR, in [s].

property method: str

Returns the method used for the calculation, currently only SBR is available, as string.

plot(show: bool = True, save_file: Path | str | None = None, normalised: bool = False)

Generate a plot of the step walking load over time.

Input:

• show (bool): Switch to indicate if the pop-up screen of the graph should appear. Default value is True.

• save_file (str or Path): The path of the image if the plot should be saved. If None the image will not be saved. Default is None.

• normalised (bool): Select to create the plot for the normalised load over time. Default value is False.

Output:

• Returns the matplotlib figure when save_file is None.

• Returns the path to the created image if save_file has been provided.

property step_walking_loads: List[float]

Returns list of values of the step walking load for a series of steps, in [N].

property time_domain: List[float]

Returns list of values of the time steps for the step walking load, in [s].

to_fem(project: None, name: str | None = None) → None

Method of StepWalkingLoad to convert the instance to a Timeseries object in the haskoning_structural library, and added to the provided FEM project.

Input:

• project (obj): Object reference of the project in the haskoning_structural module.

• name (str): Optional input for the name of the time-series function. If not provided it will be numbered based on the function ID in the FEM project.

Output:

• Returns the object created in the ‘Timeseries’ class of the haskoning_structural library.

• The timeseries is added as function to the FEM project collections.

property total_walking_time: float

Duration of the complete walking load, in [s].