### ===================================================================================================================
### NLKA tool - NLKA Graphs
### ===================================================================================================================
# Copyright ©VIIA 2025
### ===================================================================================================================
### 1. Import modules
### ===================================================================================================================
# General imports
from __future__ import annotations
from typing import TYPE_CHECKING, List, Dict, Optional, Union, Tuple
from pathlib import Path
import numpy as np
import json
# References for functions and classes in the rhdhv_fem package
from rhdhv_fem.fem_config import Config
# References for functions and classes in the viiaPackage
if TYPE_CHECKING:
from viiapackage.viiaStatus import ViiaProject
from viiapackage.tools.nlka_assessment.viia_nlka_element import NLKA_Element
# Import module matplotlib
import matplotlib
# Switch to a non-interactive backend to properly import matplotlib.pyplot
matplotlib.use(Config.MPL_NONINTERACTIVE(notify=False))
import matplotlib.pyplot as plt
from matplotlib import lines
### ===================================================================================================================
### 2. NLKAGraph class
### ===================================================================================================================
[docs]class NLKAGraph:
""" This is the class used for gathering and determining some key parameters in the NLKA assessment of wall
elements. The parameters are the seismic spectrum of the specific location and the inclination angle theta."""
# Define the class constant used for the assessment
angles = {
'one_way_spanning_wall': {
(5, 3): 0.025,
(5, 2): 0.025,
(5, 1): 0.025,
(4, 3): 0.025,
(4, 2): 0.025,
(4, 1): 0.015},
'cantilever_wall': {}}
spectrum_data = {
'return_period_of_475': {'agd': None, 't_b': None, 't_c': None, 't_d': None, 'p': None},
'return_period_of_975': {'agd': None, 't_b': None, 't_c': None, 't_d': None, 'p': None},
'return_period_of_2475': {'agd': None, 't_b': None, 't_c': None, 't_d': None, 'p': None}}
def __init__(self, e_top: int, e_bottom: int, return_period: int = 2475):
"""
Input:
- e_top (int): The number denotes the eccentricity at the top of the wall element, refer to Table H.2
in NPR9998:2020.
- e_bottom (int): The number denotes the eccentricity at the bottom of the wall element, refer to Table H.2
in NPR9998:2020.
- return_period (int): Decide which return period to use for the seismic parameters, in [years]. Default
value is 2475.
"""
self.project = None
self.pga = None
self.e_top = e_top
self.e_bottom = e_bottom
self.return_period = return_period
@property
def project(self):
return self.__project
@project.setter
def project(self, new_project: Optional[ViiaProject] = None):
self.__project = new_project
@property
def pga(self):
return self.__pga
@pga.setter
def pga(self, new_pga: Optional[float] = None):
if new_pga is not None:
if not isinstance(new_pga, (float, int)):
raise TypeError("ERROR: Input for pga of NLKA graph should be a float.")
if new_pga <= 0:
raise ValueError("ERROR: Input for pga of NLKA graph should have a positive value.")
self.__pga = new_pga
@property
def e_top(self):
return self.__e_top
@e_top.setter
def e_top(self, new_e_top: int):
if not isinstance(new_e_top, int):
raise TypeError(
"ERROR: Input for the type of eccentricity of the top of the wall (e-top) of NLKA graph should be an "
"integer.")
if new_e_top not in [1, 2, 3]:
raise ValueError(
f"ERROR: The provided type of eccentricity for the top of the wall '{new_e_top}' is not available "
f"for the NLKA graph. Please select from 1, 2 or 3.")
self.__e_top = new_e_top
@property
def e_bottom(self):
return self.__e_bottom
@e_bottom.setter
def e_bottom(self, new_e_bottom: int):
if not isinstance(new_e_bottom, int):
raise TypeError(
"ERROR: Input for the type of eccentricity of the bottom of the wall (e-bottom) of NLKA graph should "
"be an integer.")
if new_e_bottom not in [4, 5]:
raise ValueError(
f"ERROR: The provided type of eccentricity for the top of the wall '{new_e_bottom}' is not available "
f"for the NLKA graph. Please select from 4 or 5.")
self.__e_bottom = new_e_bottom
@property
def return_period(self):
return self.__return_period
@return_period.setter
def return_period(self, new_return_period: int = 2475):
if not isinstance(new_return_period, int):
raise TypeError("ERROR: Input for return-period of NLKA graph should be an integer.")
if new_return_period not in [475, 975, 2475]:
raise ValueError(
f"ERROR: The provided return-period ({new_return_period} years) is not available for the NLKA graph. "
f"Please select from 475, 975 or 2475 years.")
self.__return_period = new_return_period
[docs] def insert_spectrum_to_dictionary(self):
"""
Method of NLKAGraph to collect the spectrum data for the return periods of 475, 975, 2475 years from the model
to a dictionary.
"""
# Check the spectra from database
if len(self.project.collections.response_spectra) >= 4:
spectrum = self.project.collections.response_spectra
# Return period of 475
self.spectrum_data['return_period_of_475']['agd'] = spectrum[1].peak_ground_acceleration
self.spectrum_data['return_period_of_475']['t_b'] = spectrum[1].t_b
self.spectrum_data['return_period_of_475']['t_c'] = spectrum[1].t_c
self.spectrum_data['return_period_of_475']['t_d'] = spectrum[1].t_d
self.spectrum_data['return_period_of_475']['p'] = spectrum[1].plateau_factor
# Return period of 975
self.spectrum_data['return_period_of_975']['agd'] = spectrum[2].peak_ground_acceleration
self.spectrum_data['return_period_of_975']['t_b'] = spectrum[2].t_b
self.spectrum_data['return_period_of_975']['t_c'] = spectrum[2].t_c
self.spectrum_data['return_period_of_975']['t_d'] = spectrum[2].t_d
self.spectrum_data['return_period_of_975']['p'] = spectrum[2].plateau_factor
# Return period of 2475
self.spectrum_data['return_period_of_2475']['agd'] = spectrum[3].peak_ground_acceleration
self.spectrum_data['return_period_of_2475']['t_b'] = spectrum[3].t_b
self.spectrum_data['return_period_of_2475']['t_c'] = spectrum[3].t_c
self.spectrum_data['return_period_of_2475']['t_d'] = spectrum[3].t_d
self.spectrum_data['return_period_of_2475']['p'] = spectrum[3].plateau_factor
[docs] def decide_on_spectrum(self):
"""
Method of NLKAGraph to decide on the spectrum to use based upon the return period the user selected, if the pga
matches none of them, the return period of 2475 years will be selected.
"""
self.insert_spectrum_to_dictionary()
for key in self.spectrum_data.keys():
if str(self.return_period) == key.split('_')[-1]:
self.pga = self.spectrum_data[key]['agd']
break
if self.pga is None:
self.project.write_log(
'The input for the return period is not corresponding to the possible data input, a return period of '
'2475 years is chosen as default')
self.pga = self.spectrum_data['return_period_of_2475']['agd']
return self.pga, self.spectrum_data
[docs] def decide_on_theta(self):
"""
Method of NLKAGraph to decide on the inclination angle theta, the interstorey drift, to use in the assessment
based upon the boundary conditions of the wall. Refer to Figure H.2 in NPR9998:2020.
"""
try:
theta = self.angles['one_way_spanning_wall'][(self.e_bottom, self.e_top)]
except KeyError:
raise Exception('Boundary conditions are not correct for one way spanning wall')
return theta
[docs] def test_spectrum(self):
"""
Function used to test the functionality of the viia_nlka_graph function when no specific object is given and
therefore no location with corresponding seismic parameters exists. A random location is chosen for the test
(Loppersum)
"""
self.pga = 0.201
# Return period of 475
self.spectrum_data['return_period_of_475']['agd'] = 0.119
self.spectrum_data['return_period_of_475']['t_b'] = 0.238
self.spectrum_data['return_period_of_475']['t_c'] = 0.498
self.spectrum_data['return_period_of_475']['t_d'] = 0.669
self.spectrum_data['return_period_of_475']['p'] = 1.614
# Return period of 975
self.spectrum_data['return_period_of_975']['agd'] = 0.153
self.spectrum_data['return_period_of_975']['t_b'] = 0.247
self.spectrum_data['return_period_of_975']['t_c'] = 0.562
self.spectrum_data['return_period_of_975']['t_d'] = 0.711
self.spectrum_data['return_period_of_975']['p'] = 1.624
# Return period of 2475
self.spectrum_data['return_period_of_2475']['agd'] = 0.201
self.spectrum_data['return_period_of_2475']['t_b'] = 0.256
self.spectrum_data['return_period_of_2475']['t_c'] = 0.652
self.spectrum_data['return_period_of_2475']['t_d'] = 0.750
self.spectrum_data['return_period_of_2475']['p'] = 1.656
return self.pga, self.spectrum_data
### ===================================================================================================================
### 3. Helper functions
### ===================================================================================================================
[docs]def string_to_list(string: str) -> List[float]:
"""
Converts a string with an array of values into a list with those same values as floats
Input:
- string (str): Array of values in string format
Output:
- List of values that are equal to the values found in the array in string format
"""
string_list = string.split(' ')
return [float(item) for item in string_list]
[docs]def check_nlka_wall_material(material_name: str) -> bool:
"""
Check if the given material is according to standard materials for an NLKA assessment.
Input:
- material_name (str): The name of the material as defined by the user input
Output:
- Boolean that determines if the material_name is according to the expected options or if it's deviating
"""
wall_materials = ['MW-KLEI', 'MW-KZS', 'MW-AAC']
return any(wall in material_name for wall in wall_materials)
[docs]def additional_plot_styles(
label: List[str], colours: List[str], linestyles: List[str], z_over_height: Optional[List[float]] = None,
building_period: Optional[List[float]] = None) -> Tuple[str, str]:
"""
Determine which colours and line styles are assigned to the curves. The color will be based upon the label of the
z_over_height and the line style upon the building_period.
Input:
- label (list): List with the z over height ratio and the building period as strings.
- colours (list): List with the colours according to the VIIA style for plots.
- linestyles (list): List with different line styles possible for plots.
- z_over_height (list): List of ratios between the height of the center of gravity of the element to the top of
the foundation and the height of the building to the top of the roof. Default value: None.
- building_period (list): List of fundamental periods of the building in [s]. Default value: None
Output:
- The colour of the curve based upon the value of the z over height ratio and the line style of the curve based
upon the value of the building period.
"""
if z_over_height is not None and building_period is not None:
curve_colour = None
curve_style = None
if '-' in label[0]:
curve_colour = colours[0]
else:
for i, z_H in enumerate(z_over_height):
if z_H == float(label[0]):
curve_colour = colours[i + 1]
break
if '-' in label[1]:
curve_style = linestyles[0]
else:
for i, t_eff in enumerate(building_period):
if t_eff == float(label[1]):
curve_style = linestyles[i + 1]
break
return curve_colour, curve_style
else:
raise KeyError(
"ERROR: The input for the function is lacking information, make sure both the z_over_height and "
"building_period input lists are provided.")
[docs]def initial_data_dictionaries(
data: Dict, height: List[float], z_over_height: float,
building_period: float) -> Dict[str, Dict[float, List[float]]]:
"""
Function to structure the data in a dictionary such that the resulting maximum allowed heights that have overlap
are linked together by setting these heights as a string of numbers as key in the dictionary with a sub-dictionary
as value containing z_over_height as key and the building period as value.
An example for an initial dictionary entry is:
{
'1.3 1.9 2.3 2.7 3.0 3.2 3.4 3.7 3.9 4.0 4.2':
{0.1: [0.3, 0.5, 0.6], 0.3: [0.3, 0.5], 0.5: [0.3], 0.7: [0.3], 0.9: [0.3]}
}
Input:
- data (dict): Dictionary that is extended with all the results for the maximum heights and the respective z
over height ratios and building periods
- height (list): List with the maximum heights in [m]
- z_over_height (float): The ratio between the height of the center of gravity of the element to the top of
the foundation and the height of the building to the top of the roof
- building_period (float): The fundamental period of the building in [s]
Output:
- Dictionary with the maximum heights as keys to be able to capture overlap in graphs for different parameter
combinations of the labels z_over_height and building_period.
"""
# Check if dictionary key exists and if not initiate the key-value entry
if data.get(' '.join(str(elem) for elem in height)) is None:
data[' '.join(str(elem) for elem in height)] = {z_over_height: [building_period]}
# Check if sub-dictionary key exists and if not initiate the key-value entry
elif data[' '.join(str(elem) for elem in height)].get(z_over_height) is None:
data[' '.join(str(elem) for elem in height)][z_over_height] = [building_period]
# If the key of the dictionary and the key of the sub-dictionary both exist, the item is appended to the value list
else:
data[' '.join(str(elem) for elem in height)][z_over_height].append(building_period)
return data
[docs]def write_json_output_data(
data: Dict, overburden: List) -> List[Dict[str, Union[List[float], List[int], List[Dict[str, str]]]]]:
"""
Function to create the necessary data format for the json output file.
Input:
- data (dict): Dictionary containing all the maximum heights and legend labels in the original format that is
not yet fit for the required format in a json file.
- overburden (list): List with the values of the overburden loads used to get the maximum heights on.
Output:
- List containing dictionaries with all output entries needed to create the NLKA graphs.
"""
json_data = []
for key, values in data.items():
legend = []
height = string_to_list(key)
for i in range(len(values)):
legend.append({'ratio z/H': values[i][0], 'building period': values[i][1]})
json_data.append({'maximum heights': height, 'overburden loads': overburden, 'legend labels': legend})
return json_data
### ===================================================================================================================
### 4. NLKA graph function
### ===================================================================================================================
[docs]def viia_nlka_graph_data(
project: ViiaProject, e_top: int, e_bottom: int, thickness: float, material_name: str = 'MW-KLEI<1945',
max_overburden: int = 10, return_period: int = 2475, z_over_height: Optional[List[float]] = None,
building_period: Optional[List[float]] = None, height_cut_off: float = 8.0, data_output: bool = True,
graph_output: bool = True, nlka_folder: Path = None):
"""
Function to retrieve the maximum height of walls based upon NLKA assessment and store the data in a json file that
can be used to create a graph displaying the maximum height versus the overburden load
Input:
- project (obj): VIIA project object containing collections of fem objects and project variables.
- e_top (int): The number denotes the eccentricity at the top of the wall element, please refer to Table H.1 in
NPR9998:2018.
- e_bottom (int): The number denotes the eccentricity at the bottom of the wall element, please refer to Table
H.1 in NPR9998:2018.
- thickness (float): The thickness of the wall element in [m].
- material_name (str): The name of the material of the wall element. Some options are: MW-KLEI<1945,
MW-KLEI>1945, MW-KZS>1960, MW-KZS>1985 and MW-AAC (aerated concrete). Default value: MW-KLEI<1945.
- max_overburden (int): The maximum overburden load acting on the wall element in [kN/m]. This parameter will
determine the range of the overburden load for the graph data starting from 0. Default value: 10.
- return period (int): Decide which return period to use for the seismic parameters, in [years]. Selet from
475, 975 or 2475 years. Default value is 2475 years.
- z_over_height (list): List of ratios between the height of the center of gravity of the element to the top of
the foundation and the height of the building to the top of the roof. Default value is None, in which case the
default list is used: [0.1, 0.3, 0.5, 0.7, 0.9].
- building_period (list): List of fundamental periods of the building in [s]. Default value is None, in which
case the default list is used: [0.3, 0.5, 0.6].
- height_cut_off (float): The value of the height where the graphs will be 'cut-off' in [m]. This value is
chosen to remove curves from the graph that have relevance to the result. Default value: 8.0
- data_output (bool): This is True if you want to create a json-file containing the data to create the graphs.
Default value True.
- graph_output (bool): This is True if you want to create the graph through matplotlib and save it in your cwd.
Default value True.
- nlka_folder (Path): Location where to save the data and graphs that are created. Default value is None, the
default location will be used.
Output:
- JSON file containing the necessary data to create a graph with the maximum allowed wall heights.
- The NLKA maximum allowed wall heights graph created with matplotlib is returned as PNG file in a separate
folder.
"""
# Determine the NPR version to be used
if '2020' in project.project_information['npr_versie']:
npr_version = 'NPR9998:2018+C1+A1:2020'
else:
project.write_log(
"WARNING: The functionality to generate NLKA graphs is not applicable to walls assessed for NPR9998:2018. "
"Graphs are not generated.")
return None
# Initialize all empty parameters and check the input
# Overburden load
if max_overburden != 10:
project.write_log(
"WARNING: Manual input is given for the maximum overburden load, this produces a different range than "
"the advised range for the overburden loads in the graph.")
overburden_list = list(range(max_overburden + 1))
# Wall material
if not check_nlka_wall_material(material_name=material_name):
raise ValueError("ERROR: The given material does not apply for the NLKA assessment.")
material = project.viia_create_material(material_name=material_name)
# Ratio between center of gravity of wall and the height of the roof
if z_over_height is not None and type(z_over_height) != list:
raise TypeError(
"ERROR: The input for the z/H ratio should be a list, a list with a single input value is possible.")
elif z_over_height is None:
z_over_height = [0.1, 0.3, 0.5, 0.7, 0.9]
else:
project.write_log("WARNING: Manual input is given for the z/H ratios, it is advised to use default values.")
# Fundamental period of the building
if building_period is not None and type(building_period) != list:
raise TypeError(
"ERROR: The input for the building period should be a list, a list with a single input value is possible.")
elif building_period is None:
building_period = [0.3, 0.5, 0.6]
else:
project.write_log(
"WARNING: Manual input is given for the building periods, it is advised to use default values.")
if nlka_folder is None:
nlka_folder = project.workfolder_location / 'NLKA graphs'
project.write_log(
f"WARNING: No folder location is given, the default folder {nlka_folder.as_posix()} is chosen.")
# Initiate a height list to loop over to find the maximum allowed height
height_list = [round(item, 1) for item in np.linspace(0.1, 100, 1000)]
# Initiate dictionaries containing all graph data
rel_data = {}
non_rel_data = {}
# Collect location specific seismic parameters and the inclination angle (the interstorey drift) of the wall
spectrum = NLKAGraph(e_top=e_top, e_bottom=e_bottom, return_period=return_period)
spectrum.project = project
if 'test-' == project.name[:5]:
pga, spectrum_data = spectrum.test_spectrum() # Needed for testing purposes
else:
pga, spectrum_data = spectrum.decide_on_spectrum()
theta = spectrum.decide_on_theta()
# Loop over all parameter combinations to obtain the maximum allowed height per combination
for z_H in z_over_height:
for t_eff in building_period:
max_height = []
for overburden in overburden_list:
for i, height in enumerate(height_list):
# Set up an NLKA object
nlka_element = NLKA_Element(
project=project, name=f'wall_{overburden}_{t_eff}_{z_H}_{height}',
height=height, thickness=thickness, height_of_center_of_gravity=z_H,
height_of_building=1.0, overburden_load=overburden, pga=pga,
density=material.mass_density, frequency=1/t_eff, e_top=e_top,
e_bottom=e_bottom, angle=theta, spectrum_data=spectrum_data,
npr_version=npr_version)
# Obtain the unity check of the wall, if False (UC>1) the height of the previous step is recorded
unity_check = nlka_element.unity_check()
if not unity_check:
max_height.append(height_list[i - 1])
break
# Check if a maximum height was found for every overburden load
assert len(max_height) == len(overburden_list), \
'ERROR: The length of the maximum height list and the overburden load list are not the same.'
# Store all data in a dictionary such that overlapping maximum height lists can later be linked
if all(h >= height_cut_off for h in max_height):
non_rel_data = initial_data_dictionaries(non_rel_data, max_height, z_H, t_eff)
else:
rel_data = initial_data_dictionaries(rel_data, max_height, z_H, t_eff)
# Reformat the data for legend labels such that the combinations between z/H ratio and T_eff are stored together
if rel_data:
rel_data = reformat_data_dictionary(rel_data)
if non_rel_data:
non_rel_data = reformat_data_dictionary(non_rel_data)
# Create json-file with all collected data for the NLKA graphs
if data_output:
# Set the name for the used material to later use for the name of the save folder
if '<' in material.name:
material_name = material.name.split('<')[0]
elif '>' in material.name:
material_name = material.name.split('>')[0]
else:
if 'MW' in material.name:
material_name = material.name.split('-')[0] + '-' + material.name.split('-')[1]
else:
material_name = material.name
# Set the location where to save the graphs
save_folder = nlka_folder / 'Data' / f'{material_name} - t={thickness}'
save_folder.mkdir(parents=True, exist_ok=True)
# Create data structure of the input for the json
rel_output = write_json_output_data(rel_data, overburden_list)
non_rel_output = write_json_output_data(non_rel_data, overburden_list)
final_data = {'Output for curves on graph': rel_output, 'Output outside of graph area': non_rel_output}
# Create the json file
file = save_folder / f'NLKA_data BC={e_top}-{e_bottom}.json'
with open(file, 'w') as f:
json.dump(final_data, f, indent=2)
# Create the NLKA graphs
if graph_output:
# Set the location where to save the graphs
save_folder = nlka_folder / 'Graphs' / f'{material_name} - t={thickness}'
save_folder.mkdir(parents=True, exist_ok=True)
# Initiate plot
plt.close()
# Apply VIIA graph style
style_file = Path(project.viia_settings.project_specific_package_location) / 'viiaGraph.mplstyle'
plt.style.use(style_file.as_posix())
colours = plt.rcParams['axes.prop_cycle'].by_key()['color']
linestyles = [line for line in lines.lineStyles.keys()]
fig, ax = plt.subplots(figsize=(19.2, 9.8))
plt.rc('legend', fontsize=10)
# Set up the curves on the graph area
height_switch = False
for heights, labels in rel_data.items():
# Transform the string of the list with heights to a list of heights as floats
height_list = string_to_list(heights)
# Check if there are curves that partially exceed the height cut-off value
if len([True for height in height_list if height > height_cut_off]) >= 1:
height_switch = True
# Set up the initial colors, line styles and legend labels per curve
curve_layout = []
plot_label = 'Ratio and Building Period: '
for i in range(len(labels)):
colour, line_style = additional_plot_styles(
label=labels[i], colours=colours, linestyles=linestyles, z_over_height=z_over_height,
building_period=building_period)
if not curve_layout:
curve_layout = [[colour], [line_style]]
else:
curve_layout[0].append(colour)
curve_layout[1].append(line_style)
plot_label += rf'$z/H={labels[i][0]}$ & ' + r'$T_{eff}=$' + rf'${labels[i][1]}s$ | '
# In case of multiple label entries per curve choose which color and line style to use
if len(curve_layout[0]) > 1 and not all(color == curve_layout[0][0] for color in curve_layout[0]):
curve_layout[0] = [colours[0]]
if len(curve_layout[1]) > 1 and not all(style == curve_layout[1][0] for style in curve_layout[1]):
curve_layout[1] = [linestyles[0]]
plot_label = plot_label[:-3]
# Plot the curve on the axes
ax.plot(overburden_list, height_list, label=plot_label, color=curve_layout[0][0],
linestyle=curve_layout[1][0], linewidth=2)
# Check the data outside the graph area and make a textual note that will be printed below the graph
text_note = None
if non_rel_data:
if not rel_data:
text_note = \
r'NOTE: All possible combinations between the Ratio $z/H$ and the Building Period ' + \
r'$T_{eff}$ ' + f'have a maximum height above the cut-off value of {height_cut_off} m.'
else:
for heights, labels in non_rel_data.items():
text_note = 'NOTE: For all the maximum heights resulting from the combinations in '
for i in range(len(labels)):
text_note += \
rf'Ratio $z/H={labels[i][0]}$ & Building Period ' + r'$T_{eff}=$' + \
rf'${labels[i][1]}s$ or in '
text_note = \
text_note[:-6] + \
'\n the curves are not shown since all heights are above the cut-off' \
f' value of {height_cut_off} m'
else:
text_note = \
r'NOTE: All possible combinations between the Ratio $z/H$ and the Building Period ' + \
r'$T_{eff}$ ' + 'are represented in this graph.'
# Set up the layout of graph
ax.set_xlabel('Overburden Load [kN/m]')
ax.set_ylabel('Maximum Height [m]')
ax.set_xlim(left=0, right=max_overburden)
# If curves are exceeding the height cut-off, set upper limit y-axis
if height_switch:
ax.set_ylim(bottom=0, top=height_cut_off)
else:
ax.set_ylim(bottom=0)
# Only add the legend when there is curves inside the graph area
if rel_data:
ax.legend(markerscale=4, loc='lower right')
ax.set_title(rf'One-way spanning wall {material_name} according to {npr_version}: BC$=${e_top}$-${e_bottom}, '
rf't$=${thickness} m and $\rho=${material.mass_density} ' + 'kg/m\u00b3')
plt.figtext(x=0.5, y=0.01, s=text_note, ha='center', va='bottom', fontsize=12, bbox=dict(
edgecolor='#F0F0F0', fill=False, alpha=0.8))
# Save the graphs
fig.savefig(save_folder / f'one-way spanning wall - BC={e_top}-{e_bottom}.png', format='png')
# Remove the created material
material.remove_material()
### ===================================================================================================================
### 5. End of script
### ===================================================================================================================