### ===================================================================================================================
### Function to get the properties of the material-model
### ===================================================================================================================
# Copyright ©VIIA 2024
### ===================================================================================================================
### 1. Import modules
### ===================================================================================================================
# General imports
from __future__ import annotations
import math
from copy import deepcopy
from typing import TYPE_CHECKING, Optional
# References for functions and classes in the Eurocde module
from rhdhv_eurocode import EurocodeConcrete
from rhdhv_fem.fem_math import fem_greater, fem_smaller
# References for functions and classes in the viiaPackage
if TYPE_CHECKING:
from viiapackage.viiaStatus import ViiaProject
### ===================================================================================================================
### 2. Get material-properties
### ===================================================================================================================
[docs]def viia_get_material_model_properties(
project: ViiaProject, material_name: str, material_group: str, hbv_span: Optional[float] = None,
hbv_width: Optional[float] = None):
"""
This function creates the dictionary with the material properties of the material. The procedure depends on the name
of the materialgroup and creates a dictionary based on the dictionaries in the VIIA material database or based on
the name of the material.
Input:
- project (obj): VIIA project object containing collections of fem objects and project variables.
- material_name (str): Name of the material.
- material_group (str): The materialgroup determines the materialmodel that is used.
- hbv_span (float): Span of the floor for timber floors and roofs, in [m].
- hbv_width (float): Width of the floor, perpendicular to the span, for timber floors and roofs, in [m].
Output:
- A dictionary is returned with the default project material properties.
"""
if material_group in [
'Linear', 'LinearTimber', 'LinearSteel', 'LinearInterface', 'LinearOrthotropic', 'LinearOrthotropicSteel',
'LinearDirectStiffness', 'LinRebar', 'NonLinMasonry', 'NonLinConcrete', 'NonLinRebar',
'NonLinBondSlipRebar', 'NonLinSteel', 'NonLinInterfaceFriction', 'NonLinElasticInterface']:
adjusted_density = False
if '-DENSIT' in material_name:
adjusted_density = float(material_name.split('-DENSIT')[1])
material_name = material_name.split('-DENSIT')[0]
if 'MW' in material_name and 'x' not in material_name and adjusted_density:
mw_dict = project.viia_get_material(material_name, material_group)
mw_dict['mass density'] = adjusted_density
return mw_dict
if 'MW' in material_name and 'x' in material_name:
material_name_gen = '-'.join(material_name.split('-')[:-1])
mw_dict = project.viia_get_material(material_name_gen, material_group)
if '0.1x0.1' in material_name:
mw_dict['fracture energy in compression'] = deepcopy(mw_dict['gc01x01'])
elif '0.5x0.5' in material_name:
mw_dict['fracture energy in compression'] = deepcopy(mw_dict['gc05x05'])
elif '0.25x0.25' in material_name:
mw_dict['fracture energy in compression'] = deepcopy(mw_dict['gc025x025'])
if adjusted_density:
mw_dict['mass density'] = adjusted_density
return mw_dict
if 'KPV' in material_name:
return _viia_hollow_core_slabs(project=project, material_name=material_name)
elif 'BETON' in material_name and material_name not in ['BETON', 'LIN-BETON', 'LIN-SCHUIMBETON']:
# If specific concrete strength is specified this is calculated in seperate function
# Material name examples: 'LIN-BETON-C12/15' or 'BETON-C30/37'
return _viia_concrete_material_properties(project=project, material_name=material_name)
else:
return project.viia_get_material(material_name=material_name, material_group=material_group)
elif material_group == 'LinearTranslationalSpring':
if 'VEER' in material_name or 'SPRING' in material_name:
# Material name example: 'LIN-SPRING-1.50000E+06
stiffness = material_name.split('-')[2]
if len(material_name.split('-')) > 3:
# Material name example: 'LIN-SPRING-1.50000E+06-0.002'
damping = material_name.split('-')[3]
else:
damping = 0.0
return {'spring stiffness': stiffness,
'constant damping coefficient': damping}
else:
return _viia_cavity_wall_tie(project, material_name, material_group)
elif material_group == 'LinearRotationalSpring':
stiffness = float(material_name.split('-')[2])
if len(material_name.split('-')) > 3:
# Material name example: 'LIN-SPRING-1.50000E+06-0.002'
damping = material_name.split('-')[3]
else:
damping = 0.0
return {'spring stiffness': stiffness,
'constant damping coefficient': damping}
elif material_group == 'NonLinSpring':
return _viia_cavity_wall_tie(project, material_name, material_group)
elif material_group == 'TimberFrame':
npr_year = int(project.project_information['npr_versie'].split('NPR9998:')[-1][0:4])
if 'PLANKEN' in material_name:
project.write_log(
f"The timber frame properties for {material_name} are calculated based on "
f"{project.project_information['npr_versie']}. Do not adjust the geometry of the shapes where this "
f"material is applied on after creation, including updating the span direction.")
else:
project.write_log(
f"The timber frame properties for {material_name} are calculated based on "
f"{project.project_information['npr_versie']}.")
if npr_year >= 2020:
return viia_timber_frame_properties(
project=project, material_name=material_name, span=hbv_span, width=hbv_width)
else:
return _viia_timber_frame_properties_old_npr(
project=project, material_name=material_name)
elif material_group == 'EmbeddedPile':
# The embedded piles are not added via this function
raise NotImplementedError("ERROR: The material for embedded piles should be provided by separate routine.")
elif material_group == 'Soil':
# The soils are not added via this function
raise NotImplementedError("ERROR: The material for soil layers should be provided by seperate routine.")
elif material_group == 'PointMass':
if len(material_name.split('-')) == 5:
# Material name example: 'LIN-PUNTMASSA-200.0-100.0-150.0'
mass_x = float(material_name.split('-')[2])
mass_y = float(material_name.split('-')[3])
mass_z = float(material_name.split('-')[4])
return {'MASS': [mass_x, mass_y, mass_z],
'DAMP': 0}
else:
# Material name example: 'LIN-PUNTMASSA-200.0'
mass = float(material_name.split('-')[2])
return {'MASS': [mass],
'DAMP': 0}
elif material_group == 'LineMass':
# Material name example: 'LIN-LIJNMASSA-200.0-(1,1,1)'
mass = float(material_name.split('-')[2])
direction = material_name.split('-')[-1].split(',')
dir_x = float(direction[0].lstrip('('))
dir_y = float(direction[1])
dir_z = float(direction[2].rstrip(')'))
return {'distributed mass': [mass * dir_x, mass * dir_y, mass * dir_z]}
elif material_group == 'LineMass-Truss':
dictionary = project.viia_get_material('LIN-LIJNMASSA', 'Linear')
dictionary['mass density'] = \
float(material_name.split('-')[-1]) / project.project_specific['dummy_dimension_linemass'] ** 2
return dictionary
elif material_group == 'SurfaceMass':
# Material name example: 'LIN-VLAKMASSA-200.0'
mass = float(material_name.split('-')[2])
return {'mass': 'distributed mass', 'MASSSU': [mass, mass, mass]}
elif material_group == 'Dummy':
return {
'concentrated mass': project.viia_settings.DUMMY_MASS_VERTEX,
'damping coefficient': project.viia_settings.DUMMY_DAMP_VERTEX}
elif material_group == 'USRDEF':
return {'file location': project.project_specific['fos_data'][material_name]['file location'],
'interface type': '3d surface interface'}
[docs]def _viia_concrete_material_properties(project: ViiaProject, material_name: str):
"""
Function to get the material properties for any given concrete material, based on its concrete strengthclass
(NEN-EN 1992-1-1). Example material names are: 'LIN-BETON-C12/15' or 'BETON-C30/37'. The available
aggregates in the name can be: 'KWARTS', 'KALKSTEEN', 'ZANDSTEEN' or 'BASALT' (or none given).
Note that this function uses basic input parameters via the material database and adjusts them for the concrete
srengthclass. The materials in the database represent C20/25 concrete.
Input:
- project (obj): VIIA project object containing collections of fem objects and project variables.
- material_name (str): Name of the concrete material to be created (VIIA naming convention).
Output:
- Returns a dictionary with the general material properties defined in the materials database for VIIA and the
adjusted parameters that are related to the strength class of the concrete.
"""
# If 'GK' in name for 'goede kwaliteit' the material properties are increased following ABSC of CVW
# Example name for concrete in good condition and > 10 years old: 'LIN-BETON-GK' or 'BETON-C28/35-GK-ZANDSTEEN'
good_quality = False
if '-GK' in material_name:
material_name = material_name.replace('-GK', '')
good_quality = True
if material_name in ['LIN-BETON', 'LIN-SCHUIMBETON']:
concrete_dictionary = project.viia_get_material(material_name, 'Linear')
# Increase value youngs modulus if condition of concrete is good and age > 10 years
concrete_dictionary['youngs modulus'] = concrete_dictionary['youngs modulus'] * 1.05
return concrete_dictionary
elif material_name == 'BETON':
concrete_dictionary = project.viia_get_material(material_name, 'NonLinConcrete')
# Increase values if condition of concrete is good and age > 10 years
concrete_dictionary['youngs modulus'] = concrete_dictionary['youngs modulus'] * 1.05
concrete_dictionary['compressive strength'] = concrete_dictionary['compressive strength'] * 1.15
concrete_dictionary['tensile strength'] = concrete_dictionary['tensile strength'] * 1.1
return concrete_dictionary
# Remove the material group indicator from the name
concrete_name = material_name.split('BETON-')[-1]
# Check if an aggregate is specified, else the default values for quartz aggregate are used
concrete_aggregate = 'KWARTS'
if '-' in concrete_name:
concrete_aggregate = concrete_name.split('-')[-1]
concrete_name = concrete_name.split('-')[0]
# The concrete properties from NEN-EN 1992-1-1 are used
if 'LIN' in material_name:
# Get the default material properties project specific for VIIA (in LIN-BETON)
concrete_dictionary = project.viia_get_material('LIN-BETON', 'Linear')
# The youngs modulus for linear elastic material model is reduced with 50% to take into account the cracked
# stiffness in dynamic loading (UPR 5.0)
eurocode_concrete = EurocodeConcrete(concrete_name)
youngs_modulus = eurocode_concrete.E_cm * 1E9 * 0.5
# The youngs modulus can be adjusted for the aggregate (NEN-EN 1992-1-1, art 3.1.3)
if concrete_aggregate == 'KALKSTEEN':
youngs_modulus = youngs_modulus * 0.9
elif concrete_aggregate == 'ZANDSTEEN':
youngs_modulus = youngs_modulus * 0.7
elif concrete_aggregate == 'BASALT':
youngs_modulus = youngs_modulus * 1.2
# Replace the youngs modulus for the specific concrete requested
concrete_dictionary['youngs modulus'] = youngs_modulus
# Increase values if condition of concrete is good and age > 10 years
if good_quality:
concrete_dictionary['youngs modulus'] = concrete_dictionary['youngs modulus'] * 1.05
else:
# Get the default material properties project specific for VIIA (in BETON)
concrete_dictionary = project.viia_get_material('BETON', 'NonLinConcrete')
# The properties are calculated based on NEN-EN 1992-1-1 and 'richtlijn van Rijkswaterstaat voor het uitvoeren
# van niet-lineaire EEM-berekeningen aan beton¬constructies'
eurocode_concrete = EurocodeConcrete(concrete_name)
concrete_dictionary['youngs modulus'] = eurocode_concrete.E_cm * 1E9 * 0.85
concrete_dictionary['tensile strength'] = eurocode_concrete.f_ctm * 1E6 / 1.5
concrete_dictionary['mode-i tensile fracture energy'] = \
(eurocode_concrete.f_cm / 1E+1) ** 0.7 * 0.058 * 1000
concrete_dictionary['compressive strength'] = eurocode_concrete.f_cm * 1E6 / 1.5
concrete_dictionary['compressive fracture energy'] = 250 * concrete_dictionary['mode-i tensile fracture energy']
# The youngs modulus can be adjusted for the aggregate (NEN-EN 1992-1-1, art 3.1.3)
if concrete_aggregate == 'KALKSTEEN':
concrete_dictionary['youngs modulus'] = concrete_dictionary['youngs modulus'] * 0.9
elif concrete_aggregate == 'ZANDSTEEN':
concrete_dictionary['youngs modulus'] = concrete_dictionary['youngs modulus'] * 0.7
elif concrete_aggregate == 'BASALT':
concrete_dictionary['youngs modulus'] = concrete_dictionary['youngs modulus'] * 1.2
# Increase values if condition of concrete is good and age > 10 years
if good_quality:
concrete_dictionary['youngs modulus'] = concrete_dictionary['youngs modulus'] * 1.05
concrete_dictionary['compressive strength'] = concrete_dictionary['compressive strength'] * 1.15
concrete_dictionary['tensile strength'] = concrete_dictionary['tensile strength'] * 1.1
# The material properties are returned for linear concrete model
return concrete_dictionary
[docs]def _viia_timber_frame_properties_old_npr(project: ViiaProject, material_name: str):
"""
Function to create the material dictionary for timber frame surfaces. This can be 'HSB',
'HBV-PLANKEN' and 'HBV-PLATEN'.
Procedure can be found in:
Wooden floors.xls version 1.3 d.d. 1 february 2017
Reference: https://royalhaskoningdhv.box.com/s/sdt0sruw4m0fwga8xo57m0mqwt2z7rhr
.. note:: materialgroup should be 'TimberFrame', otherwise 'None' is returned.
Input:
- project (obj): VIIA project object containing collections of fem objects and project variables.
- material_name (str): Name of the timber frame material to be created (VIIA naming convention).
Output:
- Returns a dictionary with the general material properties defined in the materials database for VIIA and the
adjusted parameters that are related to the dimensions of the beams and planks/plates (information in material
name).
"""
# Get the general material properties for timber frame materials
if 'HSB' in material_name:
general_material_properties = project.viia_get_material('HSB', 'TimberFrame')
elif 'PLANKEN' in material_name:
general_material_properties = project.viia_get_material('PLANKEN', 'TimberFrame')
else:
general_material_properties = project.viia_get_material('PLATEN', 'TimberFrame')
# Input parameters in name (VIIA naming convention)
if 'HSB' in material_name:
# Material name example: 'LIN-HSB-0.018-0.05-0.15-0.6'
tf_thick = float(material_name.split('-')[2]) # thickness of planks [m]
tf_width = float(material_name.split('-')[3]) # width of beams supporting planks [m]
tf_height = float(material_name.split('-')[4]) # height of beam supporting planks [m]
tf_ctc = float(material_name.split('-')[5]) # centre to centre distance supporting beams [m]
else:
# Material name examples: 'LIN-HBV-PLANKEN-0.018-0.05-0.15-0.6', 'LIN-HBV-PLATEN-0.018-0.05-0.15-0.6'
tf_thick = float(material_name.split('-')[3]) # thickness of planks [m]
tf_width = float(material_name.split('-')[4]) # width of beams supporting planks [m]
tf_height = float(material_name.split('-')[5]) # height of beam supporting planks [m]
tf_ctc = float(material_name.split('-')[6]) # centre to centre distance supporting beams [m]
# Caculation of specific parameters
fem_model = general_material_properties['fem-model']
tf_youngs_modulus = general_material_properties['youngs modulus']
tf_poisson = general_material_properties['poissons ratio']
tf_rho_beam = general_material_properties['density_beam']
tf_rho_plate = general_material_properties['density_plate']
tf_shear_modulus = general_material_properties['shear modulus']
if project.analysis_type != 'SBS':
tf_rayleigh = general_material_properties['rayleigh damping parameters']
tf_nxy_cap = general_material_properties['capacity_nxy']
tf_ny_cap = general_material_properties['capacity_ny']
# Procedure
tf_total_thickness = tf_thick + tf_height
tf_z = (tf_ctc * tf_thick * (tf_height + tf_thick / 2) + (tf_width * tf_height**2) / 2) / \
(tf_ctc * tf_thick + tf_width * tf_height)
if 'PLANKEN' in material_name:
tf_asx = 5 * tf_width * tf_height / (6 * tf_ctc)
tf_moment_of_inertia = tf_width * tf_height**3 / 12
else:
tf_asx = 5 * tf_width * tf_total_thickness / (6 * tf_ctc)
tf_moment_of_inertia = \
1/12 * (tf_ctc * tf_thick**3 + tf_width * tf_height**3) + \
tf_ctc * tf_thick * (tf_total_thickness - tf_thick / 2 - tf_z)**2 + \
tf_width * tf_height * (tf_z - tf_height / 2)**2
if fem_greater(tf_width, tf_height):
tf_beta = (1 / 3 - 0.21 * tf_height / tf_width * (1 - math.pow(tf_height, 4) / (12 * math.pow(tf_width, 4))))
tf_ixy = tf_beta * tf_width * math.pow(tf_height, 3) / tf_ctc + math.pow(tf_thick, 3) / 6
else:
tf_beta = (1 / 3 - 0.21 * tf_width / tf_height * (1 - math.pow(tf_width, 4) / (12 * math.pow(tf_height, 4))))
tf_ixy = tf_beta * tf_height * math.pow(tf_width, 3) / tf_ctc + math.pow(tf_thick, 3) / 6
tf_iyx = 1 / 6 * math.pow(tf_thick, 3)
tf_iav = 1 / 2 * (tf_ixy + tf_iyx)
membrane_11 = \
tf_youngs_modulus * tf_thick / (1 - math.pow(tf_poisson, 2)) + tf_youngs_modulus * tf_width * tf_height / tf_ctc
membrane_12 = tf_poisson * tf_youngs_modulus * tf_thick / (1 - math.pow(tf_poisson, 2))
membrane_13 = 0
membrane_22 = tf_youngs_modulus * tf_thick / (1 - math.pow(tf_poisson, 2))
membrane_23 = 0
if 'PLANKEN' in material_name:
tf_equivalent_shear_modulus = general_material_properties['equivalent_shear_modulus'] / tf_ctc
membrane_33 = tf_equivalent_shear_modulus * tf_thick
else:
membrane_33 = tf_shear_modulus * tf_thick
bending_11 = tf_youngs_modulus * tf_moment_of_inertia / tf_ctc
bending_12 = tf_poisson * tf_youngs_modulus * math.pow(tf_thick, 3) / (12 * (1 - math.pow(tf_poisson, 2)))
bending_13 = 0
bending_22 = tf_youngs_modulus * math.pow(tf_thick, 3) / (12 * (1 - math.pow(tf_poisson, 2)))
bending_23 = 0
bending_33 = tf_shear_modulus * tf_iav
shear_11 = tf_shear_modulus * tf_asx
shear_12 = 0
shear_22 = 5 / 6 * tf_shear_modulus * tf_thick
tf_rho_equivalent = \
(tf_rho_plate * tf_ctc * tf_thick + tf_rho_beam * tf_width * tf_height) / \
(tf_ctc * tf_thick + tf_width * tf_height)
# Collect the therms of the matrix in a list for DIANA
membrane_stiffness_matrix = [membrane_11, membrane_12, membrane_13, membrane_22, membrane_23, membrane_33]
bending_stiffness_matrix = [bending_11, bending_12, bending_13, bending_22, bending_23, bending_33]
shear_stiffness_matrix = [shear_11, shear_12, shear_22]
# Parameters for SCIA (see `VIIA_QE_R464_N001`
shear_stiffness = 81.2/1000
tf_stiffness = (tf_moment_of_inertia * 12)**(1/3)
equivalent_thickness = (tf_thick + tf_width * tf_height / tf_ctc)
tf_nx_cap = round((tf_thick * tf_ctc + tf_width * tf_height) / tf_ctc * 10.1 * 1E3, 1)
material_data_dict = {
'fem-model': fem_model, # as string # orthotrope or isotrope material
'youngs modulus': tf_youngs_modulus, # as float # young's modulus [N/m2]
'poissons ratio': tf_poisson, # as float # poison's ratio [-]
'density_beam': tf_rho_beam, # as float # density beam [kg/m3]
'density_plate': tf_rho_plate, # as float # density plate [kg/m3]
'shear modulus': tf_shear_modulus, # as float # shear modulus [N/m2]
'mass density': tf_rho_equivalent, # as float # density of equivalent plate [kg/m3]
# DIANA parameters
'matrix a - membrane stiffness': membrane_stiffness_matrix,
# as list with 6 floats # membrane stiffness matrix [N/m2]
'matrix d - bending stiffness': bending_stiffness_matrix,
# as list with 6 floats # bending stiffness matrix [N/m2]
'matrix e - shear stiffness': shear_stiffness_matrix,
# as list with 3 floats # shear stiffness matrix [N/m2]
# SCIA parameters
'D11': tf_youngs_modulus * tf_stiffness**3 / 12 / 1E6, # [MNm]
'D22': tf_youngs_modulus*tf_thick**3 / 12 / 1E6,
'D12': 0,
'D33': 1/2*((tf_youngs_modulus * tf_stiffness**3 / 12 / 1E6) *
(tf_youngs_modulus*tf_thick**3 / 12 / 1E6)) ** (1 / 2), # [MN/m]
'D44': tf_shear_modulus * tf_width * tf_height / tf_ctc / 1.2 * 1E-6,
'D55': tf_shear_modulus * tf_thick / 1.2 * 1E-6,
'd11': tf_youngs_modulus * tf_thick * 1E-6,
'd22': tf_youngs_modulus * tf_thick * 1E-6,
'd12': 0,
'd33': shear_stiffness,
'equivalent thickness': equivalent_thickness, # equivalent thickness [m]
'capacity_nxy': tf_nxy_cap, # as float/string # shear capacity of the material
'capacity_nx': tf_nx_cap, # as float/string # shear capacity of the material
'capacity_ny': tf_ny_cap} # as float/string # shear capacity of the material
if project.analysis_type != 'SBS':
material_data_dict['rayleigh damping parameters'] = tf_rayleigh
# DIANA parameter as list with 2 floats, Rayleigh damping parameters a [rad/s]
return material_data_dict
[docs]def viia_timber_frame_properties(
project: ViiaProject, material_name: str, span: Optional[float] = None, width: Optional[float] = None,
plank_width: Optional[float] = None):
"""
Function to create the material dictionary for timber frame surfaces. This can be 'HSB',
'HBV-PLANKEN' and 'HBV-PLATEN'.
Procedure can be found in:
DISM_updated new UPR.xls version 2.5 d.d. 9 September 2021
Reference: `excel-sheet <https://royalhaskoningdhv.box.com/s/tdux0ei8y1ydayun6yu7jqdr9rt8elqs>`__
.. note:: materialgroup should be 'TimberFrame', otherwise 'None' is returned.
Input:
- project (obj): VIIA project object containing collections of fem objects and project variables.
- material_name (str): Name of the timber frame material to be created (VIIA naming convention).
- span (float): Span of the floor for timber floors and roofs, in [m].
- width (float): Width of the floor, perpendicular to the span, for timber floors and roofs, in [m].
- plank_width (float): Width of the planks, in [m]. Default value will be retrieved from the ViiaSettings class.
Output:
- Returns a dictionary with the general material properties defined in the materials database for VIIA and the
adjusted parameters that are related to the dimensions of the beams and planks/plates (information in material
name).
"""
# Get the general material properties for timber frame materials
if 'HSB' in material_name:
general_material_properties = project.viia_get_material('HSB', 'TimberFrame')
elif 'PLANKEN' in material_name:
general_material_properties = project.viia_get_material('PLANKEN', 'TimberFrame')
else:
general_material_properties = project.viia_get_material('PLATEN', 'TimberFrame')
if plank_width is None:
plank_width = project.viia_settings.DEFAULT_PLANK_WIDTH
# Input parameters in name (VIIA naming convention)
joist_length = None
plank_length = None
if 'HSB' in material_name:
# Material name example: 'LIN-HSB-0.018-0.05-0.15-0.6'
tf_thick = float(material_name.split('-')[2]) # thickness of OSB/multiplex panels [m]
tf_width = float(material_name.split('-')[3]) # width of beams supporting OSB/multiplex panels [m]
tf_height = float(material_name.split('-')[4]) # height of beam supporting OSB/multiplex panels [m]
tf_ctc = float(material_name.split('-')[5]) # centre to centre distance supporting beams [m]
elif 'PLANKEN' in material_name:
# Material name examples:
# 'LIN-HBV-PLANKEN-0.018-0.05-0.15-0.6-4-6.5' or 'LIN-HBV-PLANKEN-0.018-0.05-0.15-0.6-4-6.5-0.25' for floor
# material and 'LIN-HBV-PLANKEN-0.018-0.05-0.15-0.6' for roof material
tf_thick = float(material_name.split('-')[3]) # thickness of planks [m]
tf_width = float(material_name.split('-')[4]) # width of beams supporting planks [m]
tf_height = float(material_name.split('-')[5]) # height of beam supporting planks [m]
tf_ctc = float(material_name.split('-')[6]) # centre to centre distance supporting beams [m]
# Additional properties from the floor or roof shape
if span and width:
joist_length = span
plank_length = width
else:
# Material name examples: 'LIN-HBV-PLATEN-0.018-0.05-0.15-0.6'
if len(material_name.split('-')) not in [7]:
raise ValueError(f"Name of {material_name} is not according VIIA convention, it should look like "
f"'LIN-HBV-PLATEN-0.018-0.05-0.15-0.6'.")
tf_thick = float(material_name.split('-')[3]) # thickness of OSB/multiplex panels [m]
tf_width = float(material_name.split('-')[4]) # width of beams supporting OSB/multiplex panels [m]
tf_height = float(material_name.split('-')[5]) # height of beam supporting OSB/multiplex panels [m]
tf_ctc = float(material_name.split('-')[6]) # centre to centre distance supporting beams [m]
# Calculation of specific parameters
fem_model = general_material_properties['fem-model']
tf_youngs_modulus = general_material_properties['youngs modulus']
tf_poisson = general_material_properties['poissons ratio']
tf_rho_beam = general_material_properties['density_beam']
tf_rho_plate = general_material_properties['density_plate']
tf_shear_modulus = general_material_properties['shear modulus']
if project.analysis_type != 'SBS':
tf_rayleigh = general_material_properties['rayleigh damping parameters']
tf_nxy_cap = general_material_properties['capacity_nxy']
tf_ny_cap = general_material_properties['capacity_ny']
# Procedure
tf_asx = 5 * tf_width * tf_height / (6 * tf_ctc)
tf_moment_of_inertia = tf_width * tf_height**3 / 12
if fem_greater(tf_width, tf_height):
tf_beta = (1 / 3 - 0.21 * tf_height / tf_width * (1 - math.pow(tf_height, 4) / (12 * math.pow(tf_width, 4))))
tf_ixy = tf_beta * tf_width * math.pow(tf_height, 3) / tf_ctc + math.pow(tf_thick, 3) / 6
else:
tf_beta = (1 / 3 - 0.21 * tf_width / tf_height * (1 - math.pow(tf_width, 4) / (12 * math.pow(tf_height, 4))))
tf_ixy = tf_beta * tf_height * math.pow(tf_width, 3) / tf_ctc + math.pow(tf_thick, 3) / 6
tf_iyx = 1 / 6 * math.pow(tf_thick, 3)
tf_iav = 1 / 2 * (tf_ixy + tf_iyx)
membrane_11 = \
tf_youngs_modulus * tf_thick / (1 - math.pow(tf_poisson, 2)) + tf_youngs_modulus * tf_width * tf_height / tf_ctc
membrane_12 = tf_poisson * tf_youngs_modulus * tf_thick / (1 - math.pow(tf_poisson, 2))
membrane_13 = 0
membrane_22 = tf_youngs_modulus * tf_thick / (1 - math.pow(tf_poisson, 2))
membrane_23 = 0
# Timber floor or roof with joists and planks
if 'PLANKEN' in material_name:
if joist_length and plank_length:
# Timber floor with joists and planks
n_planken = joist_length / plank_width
plank_moment_of_inertia = tf_thick * plank_width ** 3 / 12 * n_planken
tf_equivalent_shear_stiffness_parallel = \
48 * tf_youngs_modulus / 1000 * plank_moment_of_inertia / 5 / joist_length / plank_length ** 2
tf_equivalent_shear_modulus_parallel = tf_equivalent_shear_stiffness_parallel / tf_thick
n_beams = (plank_length / tf_ctc) + 1
nail_factor = 1 + 0.000003 * 12 / tf_height / tf_width ** 3
joist_moment_of_inertia = tf_height * tf_width ** 3 * n_beams / 12
tf_equivalent_shear_stiffness_perpendicular = \
nail_factor * 48 * tf_youngs_modulus / 1000 * \
joist_moment_of_inertia / 5 / plank_length / joist_length ** 2
tf_equivalent_shear_modulus_perpendicular = tf_equivalent_shear_stiffness_perpendicular / tf_thick
tf_equivalent_shear_modulus = \
(tf_equivalent_shear_modulus_parallel + tf_equivalent_shear_modulus_perpendicular) / 2 * 1000
membrane_33 = tf_equivalent_shear_modulus * tf_thick
else:
# Timber roof
tf_equivalent_shear_modulus = (80 + 30) * 0.5 / tf_thick * 1000
membrane_33 = tf_equivalent_shear_modulus * tf_thick
# Timber floor with joists and OSB/multiplex panels
else:
# retrieve timber plate shear modulus (NPR example, plate thickness is 0.018 m)
tf_equivalent_shear_modulus = general_material_properties['equivalent_shear_modulus']
membrane_33 = tf_equivalent_shear_modulus * tf_thick
bending_11 = tf_youngs_modulus * tf_moment_of_inertia / tf_ctc
bending_12 = tf_poisson * tf_youngs_modulus * math.pow(tf_thick, 3) / (12 * (1 - math.pow(tf_poisson, 2)))
bending_13 = 0
bending_22 = tf_youngs_modulus * math.pow(tf_thick, 3) / (12 * (1 - math.pow(tf_poisson, 2)))
bending_23 = 0
bending_33 = tf_shear_modulus * tf_iav
shear_11 = tf_shear_modulus * tf_asx
shear_12 = 0
shear_22 = 5 / 6 * tf_shear_modulus * tf_thick
tf_rho_equivalent = \
(tf_rho_plate * tf_ctc * tf_thick + tf_rho_beam * tf_width * tf_height) / \
(tf_ctc * tf_thick + tf_width * tf_height)
# Collect the therms of the matrix in a list for DIANA
membrane_stiffness_matrix = [membrane_11, membrane_12, membrane_13, membrane_22, membrane_23, membrane_33]
bending_stiffness_matrix = [bending_11, bending_12, bending_13, bending_22, bending_23, bending_33]
shear_stiffness_matrix = [shear_11, shear_12, shear_22]
# Parameters for SCIA (see `VIIA_QE_R464_N001`
shear_stiffness = 81.2/1000
tf_stiffness = (tf_moment_of_inertia * 12)**(1/3)
equivalent_thickness = (tf_thick + tf_width * tf_height / tf_ctc)
tf_nx_cap = round((tf_thick * tf_ctc + tf_width * tf_height) / tf_ctc * 10.1 * 1E3, 1)
material_data_dict = {
'fem-model': fem_model, # as string # orthotrope or isotrope material
'youngs modulus': tf_youngs_modulus, # as float # young's modulus [N/m2]
'poissons ratio': tf_poisson, # as float # poison's ratio [-]
'density_beam': tf_rho_beam, # as float # density beam [kg/m3]
'density_plate': tf_rho_plate, # as float # density plate [kg/m3]
'shear modulus': tf_shear_modulus, # as float # shear modulus [N/m2]
'mass density': tf_rho_equivalent, # as float # density of equivalent plate [kg/m3]
# DIANA parameters
'matrix a - membrane stiffness': membrane_stiffness_matrix,
# as list with 6 floats # membrane stiffness matrix [N/m2]
'matrix d - bending stiffness': bending_stiffness_matrix,
# as list with 6 floats # bending stiffness matrix [N/m2]
'matrix e - shear stiffness': shear_stiffness_matrix,
# as list with 3 floats # shear stiffness matrix [N/m2]
# SCIA parameters
'D11': tf_youngs_modulus * tf_stiffness**3 / 12 / 1E6, # [MNm]
'D22': tf_youngs_modulus*tf_thick**3 / 12 / 1E6,
'D12': 0,
'D33': 1/2*((tf_youngs_modulus * tf_stiffness**3 / 12 / 1E6) *
(tf_youngs_modulus*tf_thick**3 / 12 / 1E6)) ** (1 / 2), # [MN/m]
'D44': tf_shear_modulus * tf_width * tf_height / tf_ctc / 1.2 * 1E-6,
'D55': tf_shear_modulus * tf_thick / 1.2 * 1E-6,
'd11': tf_youngs_modulus * tf_thick * 1E-6,
'd22': tf_youngs_modulus * tf_thick * 1E-6,
'd12': 0,
'd33': shear_stiffness,
'equivalent thickness': equivalent_thickness, # equivalent thickness [m]
'capacity_nxy': tf_nxy_cap, # as float/string # shear capacity of the material
'capacity_nx': tf_nx_cap, # as float/string # shear capacity of the material
'capacity_ny': tf_ny_cap} # as float/string # shear capacity of the material
if project.analysis_type != 'SBS':
material_data_dict['rayleigh damping parameters'] = tf_rayleigh
# DIANA parameter as list with 2 floats, Rayleigh damping parameters a [rad/s]
return material_data_dict
[docs]def _viia_cavity_wall_tie(project: ViiaProject, material_name: str, material_group: str):
"""
Method of Material class to create the material dictionary for cavity wall ties, refered to as 'SPOUWANKER' in
the shape name.
Procedure can be found in:
Cavity wall ties in compression refer to NPR 9096-1-1 2012 par 3.8.2
Input:
- project (obj): VIIA project object containing collections of fem objects and project variables.
- material_name (str): Name of the spring material to be created (VIIA naming convention).
- material_group (str): The name of the material group.
Output:
- Returns a dictionary of material properties.
"""
# Get general settings for the cavity wall ties
general_material_properties = project.viia_get_material('CAVITY-ANCHOR', 'LinearTranslationalSpring')
# Check materialgroup if linear spring is modelled
if material_group == 'LinearTranslationalSpring':
return {'spring stiffness': general_material_properties['spring stiffness']}
# Else non-linear spring is modelled
cavity = int(material_name.split('-')[-1])
# Get general settings for the cavity wall ties
general_material_properties = project.viia_get_material('CAVITY-ANCHOR', 'LinearTranslationalSpring')
# Procedure
cavity_wall_tie_area = math.pi * (general_material_properties['radius']/1000)**2
cavity_wall_tie_moment_of_inertia = math.pi * (general_material_properties['radius']/1000)**4 / 4
cavity_wall_tie_length = cavity/1000
cavity_wall_tie_section_modulus = math.pi * (2*general_material_properties['radius']/1000)**3 / 32
cavity_wall_tie_f_sp_b = \
math.pi**2 * general_material_properties['youngs modulus'] * cavity_wall_tie_moment_of_inertia /\
cavity_wall_tie_length**2
cavity_wall_tie_a = -1
cavity_wall_tie_b = \
cavity_wall_tie_f_sp_b + cavity_wall_tie_area * general_material_properties['yield strength'] + \
cavity_wall_tie_f_sp_b * cavity_wall_tie_area * general_material_properties['constant e'] / \
(cavity_wall_tie_section_modulus * 1000)
cavity_wall_tie_c = (-cavity_wall_tie_f_sp_b * general_material_properties['yield strength'] * cavity_wall_tie_area)
cavity_wall_tie_plus = \
(-cavity_wall_tie_b + math.sqrt(cavity_wall_tie_b**2 - 4 * cavity_wall_tie_a * cavity_wall_tie_c)) / \
(2 * cavity_wall_tie_a)
cavity_wall_tie_f_rd = cavity_wall_tie_plus
cavity_wall_tie_f1 = -math.ceil(cavity_wall_tie_f_rd)
cavity_wall_tie_f2 = -math.trunc(cavity_wall_tie_f_rd)
cavity_wall_tie_f3 = 0.00000E+00
cavity_wall_tie_f4 = 1.00000E+03
cavity_wall_tie_f5 = 1.00100E+03
cavity_wall_tie_d1 = -1.00000E+00
cavity_wall_tie_d2 = round(cavity_wall_tie_f2 / general_material_properties['spring stiffness'], 9)
cavity_wall_tie_d3 = 0.00000E+00
cavity_wall_tie_d4 = round(cavity_wall_tie_f4 / general_material_properties['spring stiffness'], 9)
cavity_wall_tie_d5 = 1.00000E+00
force_displacement_diagram = [
[cavity_wall_tie_d1, cavity_wall_tie_d2, cavity_wall_tie_d3, cavity_wall_tie_d4, cavity_wall_tie_d5],
[cavity_wall_tie_f1, cavity_wall_tie_f2, cavity_wall_tie_f3, cavity_wall_tie_f4, cavity_wall_tie_f5]]
return {
'spring stiffness': general_material_properties['spring stiffness'],
'constant damping coefficient': general_material_properties['spring damping coefficient'],
'elongation-force': force_displacement_diagram}
[docs]def _viia_hollow_core_slabs(project: ViiaProject, material_name: str):
"""
Function to calculate the material model parameters for hollow core slabs with or without compressive concrete
layer. The hollow core slab floors are modelled with linear elastic orthotropic material model. The parameters
are calculated based on the parameters of the floor itself and (if present) the compresive layer.
Refer to VIIA_QE_R376_N004 for the calculation procedure.
Input:
- project (obj): VIIA project object containing collections of fem objects and project variables.
- material_name (str): Name of the hollow core slab floor, VIIA naming convention. For example: 'LIN-KPV-260'
for hollow core slab A260 without compressive layer, or 'LIN-KPV-200-40' for hollow core slab with 40mm of
structural reinforced concrete (not the finishing!).
Output:
- A dictionary with input and parameters required for an orthotropic material model.
"""
# Select the hollow core slab from the library and find the compressive layer (if present)
# Example material name: 'LIN-KPV-150-60', or 'LIN-KPV-260'
hollow_core_slab = material_name.split('LIN-KPV-')[-1]
cl_thickness = 0
# Check if compressive layer is present
if '-' in hollow_core_slab:
cl_thickness = deepcopy(int(hollow_core_slab.split('-')[1]) / 1000)
hollow_core_slab = hollow_core_slab.split('-')[0]
hollow_core_slab = 'KPV-A' + hollow_core_slab.replace('A', '')
# Get general settings for the applied hollow core slab and compressive layer
hcs_data = project.viia_get_material(hollow_core_slab, 'LinearOrthotropic')
cl_data = project.viia_get_material('DRUKLAAG', 'LinearOrthotropic')
# Concrete properties of the hollow core slab
hcs_concrete = EurocodeConcrete(hcs_data['concrete strengthclass'])
cl_concrete = EurocodeConcrete(cl_data['concrete strengthclass'])
# Properties in the direction of the hollow core slab (strong direction)
hcs_area = hcs_data['cross-sectional area'] / hcs_data['width']
hcs_axial_stiffness_x = hcs_concrete.E_cm * 1E9 * hcs_area
cl_area = cl_thickness
cl_axial_stiffness_x = cl_concrete.E_cm * 1E9 * cl_data['cracked stiffness factor'] * cl_area
cl_centroid = hcs_data['thickness'] + cl_thickness / 2
equivalent_modulus_of_elasticity_x = (hcs_axial_stiffness_x + cl_axial_stiffness_x) / (hcs_area + cl_area)
axial_stiffness_x = hcs_axial_stiffness_x + cl_axial_stiffness_x
equivalent_centroid_x = \
(hcs_axial_stiffness_x * hcs_data['centroid'] + cl_axial_stiffness_x * cl_centroid) / axial_stiffness_x
bending_stiffness_x = \
hcs_concrete.E_cm * 1E9 * (hcs_data['second moment of area'] / hcs_data['width'] +
hcs_area * (equivalent_centroid_x - hcs_data['centroid']) ** 2) + \
cl_concrete.E_cm * 1E9 * cl_data['cracked stiffness factor'] * \
(cl_thickness ** 3 / 12 + cl_area * (equivalent_centroid_x - cl_centroid) ** 2)
# Properties in perpendicular direction in the plane of the hollow core slab (weak direction)
hcs_area_y = hcs_data['thickness flange top'] + hcs_data['thickness flange bottom']
hcs_axial_stiffness_y = hcs_concrete.E_cm * 1E9 * hcs_area_y
hcs_centroid_y = \
(hcs_data['thickness flange top'] * (hcs_data['thickness'] - hcs_data['thickness flange top'] / 2) +
hcs_data['thickness flange bottom'] ** 2 / 2) / hcs_area_y
equivalent_modulus_of_elasticity_y = (hcs_axial_stiffness_y + cl_axial_stiffness_x) / (hcs_area_y + cl_area)
axial_stiffness_y = hcs_axial_stiffness_y + cl_axial_stiffness_x
equivalent_centroid_y = \
(hcs_axial_stiffness_y * hcs_centroid_y + cl_axial_stiffness_x * cl_centroid) / axial_stiffness_y
hcs_second_moment_of_area_y = \
hcs_data['thickness flange top'] ** 3 / 12 + \
hcs_data['thickness flange bottom'] ** 3 / 12 + \
hcs_data['thickness flange top'] * \
(hcs_data['thickness'] - hcs_data['thickness flange top'] / 2 - hcs_centroid_y) ** 2 + \
hcs_data['thickness flange bottom'] * (hcs_data['thickness flange bottom'] / 2 - hcs_centroid_y) ** 2
bending_stiffness_y = \
hcs_concrete.E_cm * 1E9 * (hcs_second_moment_of_area_y +
hcs_area_y * (equivalent_centroid_y - hcs_centroid_y) ** 2) + \
cl_concrete.E_cm * 1E9 * cl_data['cracked stiffness factor'] * \
(cl_thickness ** 3 / 12 + cl_area * (equivalent_centroid_y - cl_centroid) ** 2)
composed_shear_modulus = \
(equivalent_modulus_of_elasticity_x + equivalent_modulus_of_elasticity_y) / \
(4 * (1 + hcs_data['poissons ratio']))
# Properties in perpendicular direction out of plane of the hollow core slab
hcs_second_moment_of_area_z = \
(hcs_data['thickness'] -
((hcs_data['thickness'] - hcs_data['thickness flange top'] - hcs_data['thickness flange bottom']) *
(1 - 2 * hcs_data['thickness web'])**3)) / 12
bending_stiffness_z = \
hcs_concrete.E_cm * 1E9 * \
(hcs_second_moment_of_area_z + hcs_data['cross-sectional area'] / hcs_data['width'] *
(hcs_data['centroid'] - equivalent_centroid_x) ** 2) + \
cl_concrete.E_cm * 1E9 * cl_data['cracked stiffness factor'] * (cl_thickness + cl_thickness**3) / 12
# Calculate the required input parameters for the material model
# For SBS analyses the nominal thickness is used, for other analyses the equivalent thickness is used
def get_input_parameters(equi_thickness):
if not fem_smaller(cl_thickness, 0):
shear_mod_xy = \
composed_shear_modulus * \
(cl_thickness + hcs_data['thickness flange top'] + hcs_data['thickness flange bottom']) / \
equi_thickness
else:
shear_mod_xy = hcs_data['shear constant factor VIIA'] / hcs_data['cross-sectional area']
equi_mass_density = (hcs_data['self weight'] + cl_area * cl_data['mass density']) / equi_thickness
return shear_mod_xy, equi_mass_density
# Calculate and return the linear isotropic data for SBS and the linear orthotropic data for other types of analyses
poissons_ratios = None
youngs_modulus = None
if project.analysis_type == 'SBS' and cl_thickness > 0:
equivalent_thickness = hcs_data['thickness'] + cl_thickness
shear_modulus_xy, equivalent_mass_density = get_input_parameters(equi_thickness=equivalent_thickness)
if isinstance(hcs_data['poissons ratio'], float):
poissons_ratios = hcs_data['poissons ratio']
elif isinstance(hcs_data['poissons ratio'], dict):
poissons_ratios = hcs_data['poissons ratio']['v_xy']
if poissons_ratios:
youngs_modulus = shear_modulus_xy * 2.0 * (1.0 + poissons_ratios)
return {
'mass density': equivalent_mass_density,
'youngs modulus': youngs_modulus,
'poissons ratio': poissons_ratios,
'equivalent thickness': equivalent_thickness}
else:
equivalent_thickness = round(math.sqrt(12 * bending_stiffness_x / axial_stiffness_x), 5)
shear_modulus_xy, equivalent_mass_density = get_input_parameters(equivalent_thickness)
shear_modulus = {
'G_xy': shear_modulus_xy,
'G_yz': (composed_shear_modulus *
(hcs_data['cross-sectional area'] / hcs_data['width'] + cl_area)) / equivalent_thickness,
'G_zx': (hcs_data['thickness'] *
hcs_data['thickness web'] / (hcs_data['thickness web'] + hcs_data['thickness hollow core']) +
cl_thickness) * composed_shear_modulus / equivalent_thickness}
if isinstance(hcs_data['poissons ratio'], float):
poissons_ratios = {
'v_xy': hcs_data['poissons ratio'],
'v_yz': hcs_data['poissons ratio'],
'v_xz': hcs_data['poissons ratio']}
elif isinstance(hcs_data['poissons ratio'], dict):
poissons_ratios = hcs_data['poissons ratio']
youngs_modulus = {
'E_x': axial_stiffness_x / equivalent_thickness,
'E_y': bending_stiffness_y / (equivalent_thickness ** 3 / 12),
'E_z': bending_stiffness_z / (equivalent_thickness / 12)}
material_data_dict = {
'hollow core slab': hollow_core_slab,
'compressive layer thickness': cl_thickness,
'compressive layer mass density': cl_data['mass density'],
'mass density': equivalent_mass_density,
'youngs modulus': youngs_modulus,
'shear modulus': shear_modulus,
'poissons ratio': poissons_ratios,
'equivalent thickness': equivalent_thickness}
if project.analysis_type != 'SBS':
material_data_dict['rayleigh damping parameters'] = hcs_data['rayleigh damping parameters']
return material_data_dict
### ===================================================================================================================
### 3. End of script
### ===================================================================================================================